export class OllamaReplySource implements ReplySource {

  private readonly client: Ollama;

  private readonly host: string;

  private readonly modelName: string;

  private readonly transcript: WireMessage[] = [];

  private tools: ReadonlyArray<CoderTool> = [];

  }

  constructor(options: OllamaOptions) {

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

    this.host = options.host ?? DEFAULT_HOST;

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

    this.modelName = options.model;

  }

    }));

  }

  /**

   * The turn, with the endpoint named if the server stops answering.

   *

   * A local server that has stopped, or dropped the connection part way through

   * a long turn, reports as `fetch failed` and nothing else. Which server and

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

   * survives.

   */

  async *reply(prompt: string, signal: AbortSignal): AsyncIterable<ReplyChunk> {

    try {

      yield* this.turn(prompt, signal);

    } catch (cause) {

      // Neutral about the reason, because the reason follows: a refused

      // connection and a model that does not exist are both reported here, and

      // claiming the server is down when it answered would send a reader to

      // check the wrong thing.

      throw new Error(

        `Ollama at ${this.host} could not answer for ${this.modelName}. ` +

          "This conversation is kept, so say `continue` once it can",

        { cause },

      );

    }

  }

  private async *turn(prompt: string, signal: AbortSignal): AsyncIterable<ReplyChunk> {

    // Built on the first turn rather than in the constructor: the tools are

    // declared after construction, and the prompt is derived from them.

    if (this.transcript.length === 0) {

  status: "running" | "succeeded" | "failed";

}

/**

 * A failure, with the reason underneath it.

 *

 * Node reports a failed request as `fetch failed` and puts what actually

 * happened — the refused connection, the reset socket — in `cause`. Reporting

 * only the top of that chain tells a reader nothing they can act on, which is

 * how a session came to show `fetch failed` and nothing else.

 */

const describeFailure = (cause: unknown): string => {

  const seen = new Set<unknown>();

  const parts: string[] = [];

  let current = cause;

  while (current !== undefined && current !== null && !seen.has(current)) {

    seen.add(current);

    const text = current instanceof Error ? current.message : String(current);

    if (text.length > 0 && !parts.includes(text)) parts.push(text);

    current = current instanceof Error ? (current as { cause?: unknown }).cause : undefined;

  }

  return parts.length === 0 ? "The turn failed." : parts.join(": ");

};

/** What a turn cost, on the entry that closed it. */

export interface CoderMetrics {

  readonly promptTokens?: number | undefined;

  private readonly entries: CoderEntry[] = [];

  private readonly listeners = new Set<() => void>();

  private controller: AbortController | undefined;

  /**

   * Prompts typed while a turn was running, in the order they were typed.

   *

   * Their entries are already on the transcript, so a reader sees what they

   * said the moment they said it; only the sending waits.

   */

  private readonly pending: string[] = [];

  private turnCount = 0;

  private unsubscribeTasks: (() => void) | undefined;

      return;

    }

    if (this.controller !== undefined) return;

    // A turn is running, so this one waits its place rather than being dropped.

    // Typing while the model works is how a reader steers, and an interface

    // that silently ignores the key is one that cannot be steered at all.

    if (this.controller !== undefined) {

      this.entries.push({ role: "you", text: prompt, settled: true, at: Date.now() });

      this.pending.push(prompt);

      this.notice(

        this.pending.length === 1

          ? "Queued. It goes to the model when this turn ends; press escape to interrupt and send it now."

          : `Queued, ${String(this.pending.length)} waiting.`,

      );

      this.emit();

      return;

    }

    this.entries.push({ role: "you", text: prompt, settled: true, at: Date.now() });

    await this.run(prompt);

  }

  /**

   * Send one prompt and stream its reply.

   *

   * Split from `submit` so a queued prompt, whose entry is already on the

   * transcript, is sent without adding a second one.

   */

  private async run(prompt: string): Promise<void> {

    // An empty assistant entry from the start, so the interface shows a caret

    // rather than nothing while the first chunk is in flight. It is withdrawn

    // if the turn opens with reasoning or a tool call instead of text.

      // A failed turn ends the turn, not the session. The reason belongs on the

      // transcript where the prompt that caused it is still visible, and any

      // text the source produced before failing is kept.

      const message = cause instanceof Error ? cause.message : String(cause);

      const message = describeFailure(cause);

      if (text !== undefined && text.text.length === 0) {

        this.entries.splice(this.entries.indexOf(text), 1);

        text = undefined;

      this.controller = undefined;

      this.emit();

    }

    // Whatever was typed during the turn goes now, in order. Its entry is

    // already on the transcript, so this sends without adding another.

    const next = this.pending.shift();

    if (next !== undefined) await this.run(next);

  }

  /** Interrupt the running reply. No effect when nothing is running. */

        render();

        return;

      }

      if (!session.interrupt()) composer = "";

      // Say that it happened. An interrupt that only stops the stream leaves a

      // reader looking at a settled reply with no way to tell whether the key

      // did anything, which reads as the key not working.

      if (session.interrupt()) session.notice("Interrupted.");

      else composer = "";

      render();

    };

          index += 1;

          // Swallow a CRLF pair so a paste does not submit twice.

          if (char === "\r" && text[index] === "\n") index += 1;

          if (!session.running) {

            submit();

            dirty = false;

          }

          // Always. A turn already running is not a reason to drop what was

          // typed: an interface command runs at once, and anything else is

          // queued by the session and sent when the turn ends. Ignoring the key

          // is what made `/export` impossible mid-turn and steering impossible

          // at all.

          submit();

          dirty = false;

          continue;

        }

    expect(session.snapshot().running).toBe(false);

  });

  it("refuses a second prompt while one is running rather than queueing it", async () => {

    const session = new CoderSession(scripted(["a", "b"], 15), "repo", "main");

  it("queues a prompt typed during a turn, and sends it when the turn ends", async () => {

    const sent: string[] = [];

    const recording: ReplySource = {

      model: "scripted",

      async *reply(prompt) {

        sent.push(prompt);

        await new Promise((resolve) => setTimeout(resolve, 15));

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

      },

    };

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

    const first = session.submit("first");

    await session.submit("second");

    await first;

    // The queued turn starts as the first one ends.

    await new Promise((resolve) => setTimeout(resolve, 40));

    // Typing while the model works is how a reader steers. Dropping the key

    // was what made steering impossible.

    expect(sent).toEqual(["first", "second"]);

    const prompts = session

      .snapshot()

      .entries.filter((entry) => entry.role === "you")

      .map((entry) => entry.text);

    expect(prompts).toEqual(["first"]);

    // Shown the moment it was typed, not when it was sent, and shown once.

    expect(prompts).toEqual(["first", "second"]);

  });

  it("says a prompt was queued rather than accepting it silently", async () => {

    const session = new CoderSession(scripted(["a"], 15), "repo", "main");

    const first = session.submit("first");

    await session.submit("second");

    await first;

    const notices = session

      .snapshot()

      .entries.filter((entry) => entry.role === "notice")

      .map((entry) => entry.text);

    expect(notices.some((text) => text.startsWith("Queued."))).toBe(true);

  });

  it("ignores an empty prompt", async () => {

    expect(session.snapshot().turns).toBe(1);

  });

  it("does not count a prompt it refused", async () => {

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

  it("counts a queued prompt only when its turn starts", async () => {

    const session = new CoderSession(scripted(["a"], 15), "repo", "main");

    await session.submit("   ");

    expect(session.snapshot().turns).toBe(0);

    const first = session.submit("first");

    await session.submit("second while the first runs");

    await first;

    // Waiting to be sent is not a turn in flight.

    expect(session.snapshot().turns).toBe(1);

    await first;

    await new Promise((resolve) => setTimeout(resolve, 40));

    expect(session.snapshot().turns).toBe(2);

  });

  it("carries workspace and model into the snapshot for the status line", () => {

    expect(session.snapshot().turns).toBe(0);

  });

});

describe("typing while a turn is running", () => {

  const held = (): { source: ReplySource; release: () => void; sent: string[] } => {

    const sent: string[] = [];

    let release = () => {};

    const gate = new Promise<void>((resolve) => {

      release = resolve;

    });

    return {

      sent,

      release: () => release(),

      source: {

        model: "scripted",

        async *reply(prompt: string) {

          sent.push(prompt);

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

          await gate;

        },

      },

    };

  };

  it("runs an interface command at once rather than dropping the key", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const { source: paused, release } = held();

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

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    const turn = session.submit("go");

    await new Promise((resolve) => setTimeout(resolve, 0));

    expect(session.snapshot().running).toBe(true);

    // `/export` was impossible mid-turn: enter was ignored while running.

    stdin.emit("data", "/system");

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

    const notices = session

      .snapshot()

      .entries.filter((entry) => entry.role === "notice")

      .map((entry) => entry.text);

    expect(notices.some((text) => text.includes("standing context") || text.length > 0)).toBe(true);

    release();

    await turn;

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

    await running;

  });

  it("queues ordinary text and sends it when the turn ends", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const { source: paused, release, sent } = held();

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

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    const turn = session.submit("go");

    await new Promise((resolve) => setTimeout(resolve, 0));

    stdin.emit("data", "steer me");

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

    // Shown at once, sent later: a reader sees what they said when they said it.

    expect(

      session

        .snapshot()

        .entries.filter((entry) => entry.role === "you")

        .map((entry) => entry.text),

    ).toEqual(["go", "steer me"]);

    expect(sent).toEqual(["go"]);

    release();

    await turn;

    await new Promise((resolve) => setTimeout(resolve, 20));

    expect(sent).toEqual(["go", "steer me"]);

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

    await running;

  });

});