isOllamaModelFlag,

  OllamaReplySource,

  parseOllamaModelFlag,

  resolveOllamaModel,

} from "./coder-ollama.js";

import { openThread, ThreadUnavailable, type ThreadReplySource } from "./coder-thread.js";

import { delegateTool, openagentsTool, shellTool, skillTool } from "./coder-tools.js";

        named === undefined && !offline ? yield* Effect.promise(() => discoverOllamaModel()) : undefined;

      const wantsOllama = named === undefined ? localModel !== undefined : isOllamaModelFlag(named);

      const ollamaName =

        named === undefined ? localModel : isOllamaModelFlag(named) ? parseOllamaModelFlag(named) : undefined;

      const askedFor =

        named === undefined

          ? localModel

          : isOllamaModelFlag(named)

            ? parseOllamaModelFlag(named)

            : undefined;

      // A name is resolved against what is installed, so `ollama:qwen3.8`

      // reaches `qwen3.8:27b-mtp-q8_0`. An Ollama name carries its size and

      // quantisation after a colon, and a reader names the model they pulled;

      // sending that unresolved gets `model not found` from a server that has

      // it, which reads as the model being missing. The discovered default is

      // already a real name and needs no round trip.

      const resolved =

        wantsOllama && askedFor !== undefined && named !== undefined

          ? yield* Effect.promise(() => resolveOllamaModel(askedFor))

          : undefined;

      if (resolved !== undefined && resolved.model === undefined) {

        return yield* new InputError({

          message:

            resolved.installed.length === 0

              ? `No Ollama model matches ${askedFor}, and none are installed. Pull one with \`ollama pull\`.`

              : `No Ollama model matches ${askedFor}. Installed: ${resolved.installed.join(", ")}.`,

        });

      }

      const ollamaName = resolved?.model ?? askedFor;

      // Any other `--model` value still has to name a published backend. The

      // flag takes a string so an `ollama:` prefix can reach the local server,

}

/** Render Markdown source as styled rows no wider than `width`. */

export function renderMarkdown(text: string, width: number): ReadonlyArray<string> {

export function renderMarkdown(

  text: string,

  width: number,

  /**

   * A style every row sits in, restored after each reset the markup emits.

   *

   * Without this a caller cannot render Markdown inside a style of its own:

   * the first bold or code span ends with a reset, and everything after it on

   * that row loses the dim or the italic the caller asked for.

   */

  base = "",

): ReadonlyArray<string> {

  const rows: string[] = [];

  /** The fence marker that opened the current code block, if one is open. */

  let fence: string | undefined;

    rows.push(...blockRows(line, width));

  }

  return rows;

  if (base.length === 0) return rows;

  // Reapplied after every reset the markup wrote, and opened again on each row,

  // because a row is painted on its own and carries no style from the last.

  return rows.map((row) => `${base}${row.replaceAll(RESET, `${RESET}${base}`)}${RESET}`);

}

/** One non-fenced source line as one or more rendered rows. */

  host: string = DEFAULT_HOST,

  timeoutMs = 300,

): Promise<string | undefined> => {

  const deadline = AbortSignal.timeout(timeoutMs);

  return (await installedModels(host, timeoutMs))[0];

};

/**

 * The installed models, most recently modified first.

 *

 * Shared by discovery and by resolution, so the two cannot disagree about what

 * is on the machine.

 */

const installedModels = async (

  host: string,

  timeoutMs: number,

): Promise<ReadonlyArray<string>> => {

  try {

    const response = await fetch(new URL("/api/tags", host), { signal: deadline });

    if (!response.ok) return undefined;

    const response = await fetch(new URL("/api/tags", host), {

      signal: AbortSignal.timeout(timeoutMs),

    });

    if (!response.ok) return [];

    const body = (await response.json()) as {

      models?: ReadonlyArray<{ name?: unknown; modified_at?: unknown }>;

    };

    const models = (body.models ?? []).filter(

      (model): model is { name: string; modified_at?: string } => typeof model.name === "string",

    );

    if (models.length === 0) return undefined;

    // Sorting a fresh array, so nothing shared is mutated.

    // eslint-disable-next-line unicorn/no-array-sort -- the spread is the copy

    return [...models].sort((left, right) =>

      String(right.modified_at ?? "").localeCompare(String(left.modified_at ?? "")),

    )[0]?.name;

    return [...models]

      .sort((left, right) =>

        String(right.modified_at ?? "").localeCompare(String(left.modified_at ?? "")),

      )

      .map((model) => model.name);

  } catch {

    return undefined;

    return [];

  }

};

/**

 * The installed model a name means, or undefined when none does.

 *

 * An Ollama name carries its size and quantisation after a colon —

 * `qwen3.8:27b-mtp-q8_0` — and a reader naming the model they pulled says

 * `qwen3.8`. Sending that unresolved gets `model not found` from a server that

 * has the model, which reads as the model being missing.

 *

 * Exact first, so a full name is never reinterpreted. Then the family prefix,

 * which is what a short name means. The most recently modified wins where

 * several match, the same rule the default uses.

 */

export const resolveOllamaModel = async (

  name: string,

  host: string = DEFAULT_HOST,

  timeoutMs = 2_000,

): Promise<{ readonly model?: string; readonly installed: ReadonlyArray<string> }> => {

  const installed = await installedModels(host, timeoutMs);

  if (installed.includes(name)) return { model: name, installed };

  // `qwen3.8` means `qwen3.8:…` and nothing else. A looser prefix would let it

  // mean `qwen3.85:…`, which is a different model: running one because it

  // shares a few characters with the one that was asked for is worse than

  // saying nothing matched and listing what is there.

  const family = installed.find((candidate) => candidate.startsWith(`${name}:`));

  return { ...(family === undefined ? {} : { model: family }), installed };

};

/** True when `--model` names an Ollama source. */

export const isOllamaModelFlag = (value: string): boolean => value.startsWith("ollama:");

        return toolRows(entry.tool, width, expanded.has(entry.tool.callId));

      }

      if (entry.text.length === 0 && !entry.settled) return ["…"];

      // Reasoning is dim italic rather than Markdown. The styling already says

      // what the text is, and emphasis nested inside italic reads worse than

      // the source it came from.

      if (entry.role === "reasoning") return wrapStyled(entry.text, width, `${DIM}${ITALIC}`);

      // Reasoning is Markdown too, rendered inside dim italic. It was plain

      // text on the theory that emphasis nested in italic reads worse than the

      // source — but the source is what a reader actually got: models write

      // `**#160**` and numbered lists in their reasoning, and unrendered

      // markup is harder to read than rendered markup in any style.

      if (entry.role === "reasoning") {

        return renderMarkdown(entry.text, width, `${DIM}${ITALIC}`);

      }

      if (entry.role === "assistant") return renderMarkdown(entry.text, width);

      return wrapStyled(entry.text, width, entry.role === "notice" ? DIM : "");

    };

      const prompt = composer;

      composer = "";

      anchor = undefined;

      runningSince = Date.now();

      // Only when a turn actually begins. Resetting on every submission made

      // `/export` mid-turn put the elapsed clock back to zero, which reads as

      // the turn having restarted when nothing happened to it at all.

      if (!session.running) runningSince = Date.now();

      render();

      // The elapsed time has to advance between chunks, not only when one

import type { CoderTool } from "../src/coder-tools.js";

import {

  discoverOllamaModel,

  resolveOllamaModel,

  isOllamaModelFlag,

  OllamaReplySource,

  parseOllamaModelFlag,

    await expect(discoverOllamaModel()).resolves.toBeUndefined();

  });

});

describe("naming a model by the part a reader remembers", () => {

  const serve = (names: ReadonlyArray<string>) =>

    vi.spyOn(globalThis, "fetch").mockResolvedValue(

      new Response(

        JSON.stringify({

          models: names.map((name, at) => ({

            name,

            modified_at: `2026-0${String(at + 1)}-01T00:00:00Z`,

          })),

        }),

        { status: 200, headers: { "content-type": "application/json" } },

      ),

    );

  afterEach(() => {

    vi.restoreAllMocks();

  });

  it("resolves a family name to the installed tag", async () => {

    serve(["qwen3.8:27b-mtp-q8_0"]);

    // An Ollama name carries its size and quantisation after a colon, and a

    // reader names the model they pulled.

    await expect(resolveOllamaModel("qwen3.8")).resolves.toMatchObject({

      model: "qwen3.8:27b-mtp-q8_0",

    });

  });

  it("takes a full name exactly, without reinterpreting it", async () => {

    serve(["qwen3.8:27b-mtp-q8_0", "qwen3.8:7b"]);

    await expect(resolveOllamaModel("qwen3.8:7b")).resolves.toMatchObject({ model: "qwen3.8:7b" });

  });

  it("does not let one family stand for another", async () => {

    serve(["qwen3.85:7b"]);

    // `qwen3.8` means `qwen3.8:…`, and must not mean `qwen3.85:…`.

    const found = await resolveOllamaModel("qwen3.8");

    expect(found.model).not.toBe("qwen3.85:7b");

  });

  it("reports what is installed when nothing matches", async () => {

    serve(["llama3:8b"]);

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

  });

});

    await running;

  });

});

describe("reasoning in the transcript", () => {

  it("renders the Markdown a model writes in it", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const session = new CoderSession(

      source([{ type: "reasoning", value: "1. **#160** is the bug" }]),

      "repo",

      "main",

    );

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    await session.submit("go");

    const rows = screen(stdout.written).join("\n");

    // Models write `**bold**` and numbered lists in their reasoning, and

    // unrendered markup is harder to read than rendered markup in any style.

    expect(rows).toContain("#160 is the bug");

    expect(rows).not.toContain("**#160**");

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

    await running;

  });

});