// so it takes neither a thread nor the stand-in.

      const source: ReplySource =

        wantsOllama && ollamaName !== undefined

          ? new OllamaReplySource({ model: ollamaName })

          ? new OllamaReplySource({

              model: ollamaName,

              ...(Option.isSome(reasoning) ? { reasoning: reasoning.value } : {}),

            })

          : (thread ?? new DummyReplySource());

      // Children get their own thread on their own model. The conversation

 */

const MAX_TOOL_STEPS = 100;

/**

 * What a reasoning level means to Ollama.

 *

 * `think` takes a boolean or, on a model that advertises thinking, one of these

 * names. `off` is the boolean, because a model asked to think at no level still

 * thinks; the way to stop it is to say not to.

 */

const THINK: Record<string, boolean | "low" | "medium" | "high"> = {

  off: false,

  low: "low",

  medium: "medium",

  high: "high",

};

/**

 * What `--reasoning` means here.

 *

 * The flag's ladder is the thread lane's — minimal through max — and Ollama has

 * four rungs, not five. `minimal` is off because a minimal amount of thinking

 * from a model that cannot be asked for a little is none, and `max` is `high`

 * because there is nothing above it. Named rather than silently clamped, so a

 * reader who asked for `max` and sees `high` can see why.

 */

const FROM_FLAG: Record<string, string> = {

  minimal: "off",

  off: "off",

  low: "low",

  medium: "medium",

  high: "high",

  max: "high",

};

/** The levels, in the order the interface cycles them. */

export const OLLAMA_REASONING_LEVELS = Object.keys(THINK);

export interface OllamaOptions {

  /** The Ollama model name, without the `ollama:` prefix. */

  readonly model: string;

  /** The Ollama server endpoint. Defaults to `http://127.0.0.1:11434`. */

  readonly host?: string | undefined;

  /** Where the reasoning level starts. Defaults to the model's own default. */

  readonly reasoning?: string | undefined;

}

/**

   * the difference between steering a model and waiting one out.

   */

  private steered: string[] = [];

  private reasoningLevel: string;

  private callCount = 0;

  get model(): string {

  }

  constructor(options: OllamaOptions) {

    this.reasoningLevel =

      options.reasoning === undefined ? "medium" : (FROM_FLAG[options.reasoning] ?? "medium");

    this.host = options.host ?? DEFAULT_HOST;

    this.client = new Ollama({ host: this.host });

    this.modelName = options.model;

   * which model is the part a reader needs, and so is knowing the transcript

   * survives.

   */

  get reasoning(): { readonly level: string; readonly levels: ReadonlyArray<string> } {

    return { level: this.reasoningLevel, levels: OLLAMA_REASONING_LEVELS };

  }

  cycleReasoning(): string {

    const at = OLLAMA_REASONING_LEVELS.indexOf(this.reasoningLevel);

    this.reasoningLevel =

      OLLAMA_REASONING_LEVELS[(at + 1) % OLLAMA_REASONING_LEVELS.length] ?? "medium";

    return this.reasoningLevel;

  }

  /** Take a message for the next step of the running turn. */

  steer(text: string): boolean {

    this.steered.push(text);

        // request nobody can reason about.

        messages: [...this.transcript],

        stream: true,

        think: THINK[this.reasoningLevel] ?? "medium",

        ...(this.tools.length === 0 || finalRound

          ? {}

          : {

  readonly repository: string;

  readonly branch: string;

  readonly model: string;

  /** How hard the model is asked to think, when the source says. */

  readonly reasoning: string | undefined;

  /**

   * Turns this process has submitted, counted from the moment one starts.

   *

   * only where pressing it would do something.

   */

  cycleBackend?(): string;

  /**

   * How hard the model is asked to think, and what else it could be asked.

   *

   * A source that cannot vary it reports the level it is fixed at and offers no

   * others, which is how the interface knows to show the level without offering

   * a key that would do nothing.

   */

  readonly reasoning?: { readonly level: string; readonly levels: ReadonlyArray<string> };

  /** Move to the next reasoning level and return it. */

  cycleReasoning?(): string;

  /**

   * Declare the tools the model may call.

   *

      repository: this.repository,

      branch: this.branch,

      model: this.source.model,

      reasoning: this.source.reasoning?.level,

      turns: this.turnCount,

      budget: this.source.budget,

      tasks: this.delegation?.registry.list() ?? [],

   * — the status line would name a model that did not produce the text on

   * screen. The caller shows the refusal rather than switching silently.

   */

  /** Whether another reasoning level exists to move to. */

  get canCycleReasoning(): boolean {

    return (this.source.reasoning?.levels.length ?? 0) > 1;

  }

  /**

   * Move to the next reasoning level.

   *

   * Refused while a turn runs, for the reason switching a backend is: a turn

   * already accepted keeps the shape it was accepted with, and a level that

   * changed halfway through would describe neither half.

   */

  cycleReasoning(): { readonly changed: boolean; readonly level: string | undefined } {

    if (!this.canCycleReasoning || this.source.cycleReasoning === undefined) {

      return { changed: false, level: this.source.reasoning?.level };

    }

    if (this.running) {

      this.notice("A turn is running. The reasoning level changes on the next turn.");

      return { changed: false, level: this.source.reasoning?.level };

    }

    const level = this.source.cycleReasoning();

    this.notice(`Reasoning set to ${level}.`);

    return { changed: true, level };

  }

  cycleBackend(): { readonly switched: boolean; readonly label: string | undefined } {

    if (this.source.cycleBackend === undefined) return { switched: false, label: undefined };

    if (this.controller !== undefined) {

      // checkout they are in, they can ask git for the branch, and nothing on

      // screen but this says which model answers or what the thread has left.

      const facts = [snapshot.repository, snapshot.branch, snapshot.model];

      if (snapshot.reasoning !== undefined) facts.push(`thinking ${snapshot.reasoning}`);

      if (snapshot.budget !== undefined) facts.push(snapshot.budget);

      let where = "";

      for (let from = 0; from < facts.length; from += 1) {

      // Only when there is another model to switch to, and only while nothing

      // is running: a turn already accepted keeps the backend it named.

      if (session.canCycleBackend && !snapshot.running) keys.push({ text: "tab to switch model" });

      if (session.canCycleReasoning && !snapshot.running) {

        keys.push({ text: "shift+tab to change thinking" });

      }

      if (lines.length > transcriptRows) keys.push({ text: "pgup/pgdn to scroll" });

      if (focusedTool(snapshot) !== undefined) keys.push({ text: "ctrl+o to expand" });

            dirty = false;

            continue;

          }

          // Shift+tab, in both spellings: the classic back-tab and the one the

          // keyboard protocol reports. Tab moves the model, shift+tab moves how

          // hard it is asked to think.

          if (sequence === "\x1b[Z" || sequence === "\x1b[9;2u") {

            session.cycleReasoning();

            dirty = true;

            continue;

          }

          const page = Math.max(1, viewport - 1);

          if (sequence === "\x1b[5~") scrollBy(-page);

          else if (sequence === "\x1b[6~") scrollBy(page);

    await expect(resolveOllamaModel("qwen3.8")).resolves.toEqual({ installed: ["llama3:8b"] });

  });

});

describe("how hard the model is asked to think", () => {

  const seen: unknown[] = [];

  const sourceWithThink = () => {

    const source = new OllamaReplySource({ model: "m" });

    (source as unknown as { client: unknown }).client = {

      chat: async (request: Record<string, unknown>) => {

        seen.push(request["think"]);

        return Object.assign(

          (async function* () {

            yield { message: { content: "x" }, done: true };

          })(),

          { abort: () => {} },

        );

      },

    };

    return source;

  };

  it("sends the level on every request", async () => {

    seen.length = 0;

    const source = sourceWithThink();

    for await (const _ of source.reply("x", new AbortController().signal)) void _;

    expect(seen.at(-1)).toBe("medium");

  });

  it("cycles through the levels Ollama has, and off is not a level", async () => {

    seen.length = 0;

    const source = sourceWithThink();

    expect(source.reasoning.levels).toEqual(["off", "low", "medium", "high"]);

    const sent: unknown[] = [];

    for (let round = 0; round < 4; round += 1) {

      for await (const _ of source.reply("x", new AbortController().signal)) void _;

      sent.push(seen.at(-1));

      source.cycleReasoning();

    }

    // A model asked to think at no level still thinks; the way to stop it is to

    // say not to, which is the boolean.

    expect(sent).toEqual(["medium", "high", false, "low"]);

  });

  it("maps the flag's ladder onto the four rungs Ollama has", () => {

    // The flag is the thread lane's, and has five names.

    expect(new OllamaReplySource({ model: "m", reasoning: "minimal" }).reasoning.level).toBe("off");

    expect(new OllamaReplySource({ model: "m", reasoning: "max" }).reasoning.level).toBe("high");

    expect(new OllamaReplySource({ model: "m", reasoning: "low" }).reasoning.level).toBe("low");

  });

});

    await running;

  });

});

describe("changing how hard the model thinks", () => {

  const thinking = () => {

    let at = 0;

    const levels = ["off", "low", "medium", "high"] as const;

    return {

      model: "scripted",

      get reasoning() {

        return { level: levels[at] ?? "medium", levels };

      },

      cycleReasoning() {

        at = (at + 1) % levels.length;

        return levels[at] ?? "medium";

      },

      async *reply() {

        yield { type: "text", value: "ok" } as const;

      },

    };

  };

  it("shows the level in the status line", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const session = new CoderSession(thinking(), "repo", "main");

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    expect(screen(stdout.written).join("\n")).toContain("thinking off");

    stdin.emit("data", "\x04");

    await running;

  });

  it("cycles it on shift+tab, in both spellings", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const session = new CoderSession(thinking(), "repo", "main");

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    // The classic back-tab.

    stdin.emit("data", "\x1b[Z");

    expect(session.snapshot().reasoning).toBe("low");

    // And the one the keyboard protocol reports.

    stdin.emit("data", "\x1b[9;2u");

    expect(session.snapshot().reasoning).toBe("medium");

    stdin.emit("data", "\x04");

    await running;

  });

  it("offers no key when a source has one level and no other", async () => {

    const session = new CoderSession(source([]), "repo", "main");

    // Showing a key that does nothing is worse than showing none.

    expect(session.canCycleReasoning).toBe(false);

    expect(session.snapshot().reasoning).toBeUndefined();

  });

});