import { runCoderPlain } from "./coder-plain.js";

import { CoderSession, DummyReplySource } from "./coder-session.js";

import { runCoderUi } from "./coder-ui.js";

import { OxAlphaReplySource } from "./coder-ox.js";

import { backendIds, findBackend } from "./coder-backends.js";

import { ChatApiReplySource } from "./coder-chat-api.js";

import { describeWorkspace } from "./coder-workspace.js";

import { ComputerClient } from "./computer-client.js";

import { ComputerUp } from "./computer-up.js";

  "high",

  "max",

]).pipe(Flag.optional, Flag.withDescription("Reasoning effort the server passes to the provider"));

// The accepted values come from the same list the status line and Tab read, so

// a backend cannot be offered by one and refused by another.

const coderModelFlag = Flag.choice("model", backendIds() as string[]).pipe(

  Flag.optional,

  Flag.withDescription("The backend that answers the turn"),

);

const coderCommand = Command.make(

  "coder",

    plain: coderPlainFlag,

    offline: coderOfflineFlag,

    reasoning: coderReasoningFlag,

    model: coderModelFlag,

  },

  ({ prompt, plain, offline, reasoning }) =>

  ({ prompt, plain, offline, reasoning, model }) =>

    Effect.gen(function* () {

      const flags = yield* rootCommand;

      const terminal = yield* TerminalSession;

      const workspace = describeWorkspace();

      const endpoint = yield* resolveApiEndpoint(endpointOverrides(flags));

      // Replies come from the account chat API, which runs Ox Alpha through

      // OpenRouter on the server, so the CLI never holds a provider key and a

      // session costs exactly what the server metered. Without a credential it

      // falls back to the stand-in and says so rather than failing.

      // Replies come from the account chat API, so the CLI never holds a

      // provider key and a thread costs exactly what the server metered.

      // Without a credential it falls back to the stand-in and says so rather

      // than failing.

      const stored = offline

        ? Option.none()

        : yield* findToken(endpoint.origin).pipe(

            ),

          );

      const chosen = Option.getOrUndefined(model);

      const source = Option.isSome(stored)

        ? new OxAlphaReplySource({

        ? new ChatApiReplySource({

            origin: endpoint.origin,

            token: Redacted.value(stored.value.token),

            reasoning: Option.getOrUndefined(reasoning),

            backend: chosen === undefined ? undefined : findBackend(chosen),

          })

        : new DummyReplySource();

      if (Option.isNone(stored) && !offline) {

        session.notice(

          "No stored credential, so replies come from the built-in stand-in. " +

            "Run `openagents auth login --scope chat:account` to reach Ox Alpha.",

            "Run `openagents auth login --scope chat:account` to reach a real model.",

        );

      }

/**

 * The backends `openagents coder` can send a turn to.

 *

 * The server owns the real list and publishes it at `GET /api/v3` under

 * `extensions["chat.openagents"].parameters.model`. This is the client's copy,

 * kept as data for the same reason the server keeps one: a backend the status

 * line offers, the `--model` flag accepts, and Tab cycles through has to be one

 * list, or the three drift and the CLI offers something the server refuses.

 *

 * Adding a backend is one entry here and one entry on the server. Nothing else

 * in this package names a backend.

 *

 * The `id` is what `POST /api/v3/chat/turns` takes as `model`, so it must match

 * the server's published enum exactly. The `label` is what a person reads in

 * the status bar, where the whole line is competing for a narrow terminal.

 */

export interface CoderBackend {

  /** The value the chat API takes as `model`. Matches the server's enum. */

  readonly id: string;

  /** The short name the status line shows. */

  readonly label: string;

}

export const CODER_BACKENDS: readonly CoderBackend[] = [

  { id: "ox-alpha", label: "Ox Alpha" },

  { id: "gemini-3.7-flash", label: "Gemini 3.7 Flash" },

];

/** The backend a turn uses when nothing named one. */

export const defaultBackend = (): CoderBackend => CODER_BACKENDS[0] as CoderBackend;

/** The backend with this id, or `undefined` when nothing matches. */

export const findBackend = (id: string): CoderBackend | undefined =>

  CODER_BACKENDS.find((backend) => backend.id === id);

/**

 * The next backend after this one, wrapping at the end.

 *

 * Cycling rather than toggling is what makes a third backend data: Tab keeps

 * working without a second key or a menu.

 */

export const nextBackend = (current: CoderBackend): CoderBackend => {

  const index = CODER_BACKENDS.findIndex((backend) => backend.id === current.id);

  return CODER_BACKENDS[(index + 1) % CODER_BACKENDS.length] as CoderBackend;

};

/** Every id, for a flag's error message and its accepted values. */

export const backendIds = (): readonly string[] => CODER_BACKENDS.map((backend) => backend.id);

/**

 * A reply source backed by the account chat API, which runs Ox Alpha through

 * OpenRouter on the server.

 * A reply source backed by the account chat API.

 *

 * The CLI never holds a provider key and never talks to OpenRouter. It submits

 * a turn and reads the durable event log the server writes, so a coder session

 * costs exactly what the server metered and leaves the same receipts the web

 * surface leaves.

 * The CLI never holds a provider key and never talks to a model vendor. It

 * submits a turn and reads the durable event log the server writes, so a coder

 * thread costs exactly what the server metered and leaves the same receipts the

 * web surface leaves.

 *

 * Which model answers is the server's `model` parameter, and every backend

 * answers with the same events, so this file has no branch per backend: the

 * backend is a value it sends and a label it reports.

 *

 * Two properties of the shipped contract shape this file:

 *

 *   appears in pieces rather than at once.

 */

import { type CoderBackend, defaultBackend, nextBackend } from "./coder-backends.js";

import type { ReplyChunk } from "./coder-session.js";

const SUBMIT_PATH = "/api/v3/chat/turns";

/** Give up rather than poll forever when a turn never reaches a terminal event. */

const TURN_TIMEOUT_MS = 300_000;

export interface OxAlphaOptions {

export interface ChatApiOptions {

  readonly origin: string;

  readonly token: string;

  /** Reasoning effort the server passes to the provider. */

  readonly reasoning?: string | undefined;

  readonly model?: string | undefined;

  /** The backend that answers. Defaults to the first in the published list. */

  readonly backend?: CoderBackend | undefined;

}

interface ChatEvent {

  readonly status?: string;

}

export class OxAlphaUnavailable extends Error {

export class ChatApiUnavailable extends Error {

  constructor(

    readonly code: string,

    message: string,

  ) {

    super(message);

    this.name = "OxAlphaUnavailable";

    this.name = "ChatApiUnavailable";

  }

}

 * which made a tool call invisible and joined the sentence before it to the

 * sentence after it.

 */

export class OxAlphaReplySource {

  readonly model: string;

export class ChatApiReplySource {

  private backend: CoderBackend;

  /**

   * The server records one conversation per account, so a turn submitted here

    "This conversation is the account's one conversation, shared with /chat " +

    "and with earlier coder runs, so the model remembers turns from all of them.";

  constructor(private readonly options: OxAlphaOptions) {

    this.model = options.model ?? "stealth/ox-alpha";

  constructor(private readonly options: ChatApiOptions) {

    this.backend = options.backend ?? defaultBackend();

  }

  /** The label the status line shows, which is the current backend's. */

  get model(): string {

    return this.backend.label;

  }

  /** The id the next turn sends as `model`. */

  get backendId(): string {

    return this.backend.id;

  }

  /**

   * Move to the next backend and return its label.

   *

   * This changes only what the next turn asks for. A turn already running was

   * submitted with the backend it named and keeps it, because the server has

   * already accepted that turn and cannot be told to change its mind.

   */

  cycleBackend(): string {

    this.backend = nextBackend(this.backend);

    return this.backend.label;

  }

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

    while (!signal.aborted) {

      if (Date.now() - startedAt > TURN_TIMEOUT_MS) {

        throw new OxAlphaUnavailable(

        throw new ChatApiUnavailable(

          "turn_timed_out",

          "The turn produced no terminal event within five minutes.",

        );

          // `code` beside it.

          const reason = event.payload?.["reason"];

          const code = event.payload?.["code"];

          throw new OxAlphaUnavailable(

          throw new ChatApiUnavailable(

            typeof code === "string" ? code : "turn_failed",

            typeof reason === "string" ? reason : "The turn failed on the server.",

          );

      },

      body: JSON.stringify({

        message: prompt,

        model: this.backend.id,

        ...(this.options.reasoning === undefined ? {} : { reasoning: this.options.reasoning }),

      }),

    });

    const body = (await response.json().catch(() => ({}))) as Record<string, unknown>;

    if (response.status === 401 || response.status === 403) {

      throw new OxAlphaUnavailable(

      throw new ChatApiUnavailable(

        "scope_missing",

        "This token cannot reach the chat API. Sign in again with the chat:account scope.",

      );

    }

    if (response.status === 409) {

      throw new OxAlphaUnavailable(

      throw new ChatApiUnavailable(

        "turn_in_progress",

        "The account already has a turn running. One turn runs at a time.",

      );

    }

    if (response.status === 429) {

      throw new OxAlphaUnavailable("rate_limited", "The chat API is rate limiting this account.");

      throw new ChatApiUnavailable("rate_limited", "The chat API is rate limiting this account.");

    }

    if (response.status < 200 || response.status >= 300) {

      const code = typeof body["error"] === "string" ? body["error"] : `http_${response.status}`;

      throw new OxAlphaUnavailable(code, `The chat API refused the turn (${code}).`);

      throw new ChatApiUnavailable(code, `The chat API refused the turn (${code}).`);

    }

    const turn = body["turn"];

    });

    if (response.status === 401 || response.status === 403) {

      throw new OxAlphaUnavailable(

      throw new ChatApiUnavailable(

        "scope_missing",

        "This token cannot read chat events. Sign in again with the chat:account scope.",

      );

   * another surface has to say so, because nothing else on screen would.

   */

  readonly scopeNotice?: string;

  /**

   * Move to the next backend and return its new label.

   *

   * A source that has only one backend leaves this undefined, and the interface

   * then offers no key for it. That is deliberate: the bottom bar names a key

   * only where pressing it would do something.

   */

  cycleBackend?(): string;

  /**

   * Yield the reply to `prompt` in chunks. Rendering appends each chunk as it

   * arrives, so a slow source shows partial text rather than nothing.

    };

  }

  /**

   * Whether this thread can change backend at all.

   *

   * False for a source with nothing to switch to, which is what the interface

   * reads before offering the key.

   */

  get canCycleBackend(): boolean {

    return typeof this.source.cycleBackend === "function";

  }

  /**

   * Move the next turn to the next backend.

   *

   * Refused while a turn is running. The running turn was submitted with the

   * backend it named and the server has already accepted it, so switching now

   * would change the label without changing the answer being streamed under it

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

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

   */

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

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

    if (this.controller !== undefined) {

      this.notice("A turn is running. The model switches on the next turn.");

      return { switched: false, label: this.source.model };

    }

    const label = this.source.cycleBackend();

    this.notice(`Model switched to ${label}.`);

    return { switched: true, label };

  }

  onChange(listener: () => void): () => void {

    this.listeners.add(listener);

    return () => this.listeners.delete(listener);

        if (composer.length > 0) keys.push("esc to clear");

        else keys.push("ctrl+d to quit");

      }

      // 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("tab to switch model");

      if (lines.length > transcriptHeight) keys.push("pgup/pgdn to scroll");

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

          continue;

        }

        // Tab is a printable character to the run scanner below, so it has to

        // be claimed here or it lands in the composer as literal whitespace.

        if (char === "\t" && session.canCycleBackend) {

          session.cycleBackend();

          dirty = false;

          index += 1;

          continue;

        }

        if (char === "\x7f" || char === "\b") {

          composer = composer.slice(0, -1);

          dirty = true;

import { describe, expect, it } from "vitest";

import {

  backendIds,

  CODER_BACKENDS,

  defaultBackend,

  findBackend,

  nextBackend,

} from "../src/coder-backends.js";

/**

 * The list three surfaces read.

 *

 * `--model` takes its accepted values from it, the status line takes its label

 * from it, and Tab walks it. These pin the properties those three depend on, so

 * adding a backend stays one entry rather than one entry plus three fixes.

 */

describe("coder backends", () => {

  it("names each backend once", () => {

    expect(backendIds()).toEqual([...new Set(backendIds())]);

    expect(CODER_BACKENDS.length).toBeGreaterThan(1);

  });

  it("gives every backend a label a status line can show", () => {

    for (const backend of CODER_BACKENDS) {

      expect(backend.label).not.toBe("");

      expect(backend.id).not.toBe("");

    }

  });

  it("defaults to the first entry, and finds a backend by the id the server takes", () => {

    expect(defaultBackend()).toBe(CODER_BACKENDS[0]);

    expect(findBackend("gemini-3.7-flash")?.label).toBe("Gemini 3.7 Flash");

    expect(findBackend("gpt-4")).toBeUndefined();

  });

  it("reaches every backend by cycling, and returns to the start", () => {

    const seen: string[] = [];

    let current = defaultBackend();

    for (let step = 0; step < CODER_BACKENDS.length; step += 1) {

      current = nextBackend(current);

      seen.push(current.id);

    }

    expect(new Set(seen)).toEqual(new Set(backendIds()));

    expect(current).toBe(defaultBackend());

  });

  it("publishes ids the chat API's own enum lists", () => {

    // These are the values `POST /api/v3/chat/turns` accepts as `model`, so a

    // change here without the matching server change is a refusal at runtime.

    expect(backendIds()).toEqual(["ox-alpha", "gemini-3.7-flash"]);

  });

});

import { afterEach, describe, expect, it, vi } from "vitest";

import { OxAlphaReplySource, OxAlphaUnavailable } from "../src/coder-ox.js";

import { CODER_BACKENDS, defaultBackend, findBackend } from "../src/coder-backends.js";

import { ChatApiReplySource, ChatApiUnavailable } from "../src/coder-chat-api.js";

import type { ReplyChunk } from "../src/coder-session.js";

const json = (status: number, body: unknown) =>

  new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });

const chunks = async (source: OxAlphaReplySource, prompt = "hello") => {

const chunks = async (source: ChatApiReplySource, prompt = "hello") => {

  const out: ReplyChunk[] = [];

  for await (const chunk of source.reply(prompt, new AbortController().signal)) out.push(chunk);

  return out;

};

/** The assistant text a turn produced, which most of these tests assert on. */

const collect = async (source: OxAlphaReplySource, prompt = "hello") =>

const collect = async (source: ChatApiReplySource, prompt = "hello") =>

  (await chunks(source, prompt))

    .map((chunk) => (chunk.type === "text" ? chunk.value : ""))

    .join("");

const source = () =>

  new OxAlphaReplySource({ origin: "https://openagents.test", token: "test-token" });

  new ChatApiReplySource({ origin: "https://openagents.test", token: "test-token" });

afterEach(() => {

  vi.unstubAllGlobals();

  return calls;

};

describe("OxAlphaReplySource", () => {

describe("ChatApiReplySource", () => {

  it("yields text deltas for the submitted run and stops at completed", async () => {

    stubFetch(

      [

  it("reports a missing scope rather than an empty reply", async () => {

    stubFetch([[]], json(401, { error: "invalid_api_token" }));

    await expect(collect(source())).rejects.toThrow(OxAlphaUnavailable);

    await expect(collect(source())).rejects.toThrow(ChatApiUnavailable);

    await expect(collect(source())).rejects.toThrow(/chat:account/);

  });

      }),

    );

    const configured = new OxAlphaReplySource({

    const configured = new ChatApiReplySource({

      origin: "https://openagents.test",

      token: "test-token",

      reasoning: "high",

    });

    await collect(configured, "do the thing");

    expect(seen[0]).toEqual({ message: "do the thing", reasoning: "high" });

    expect(seen[0]).toEqual({

      message: "do the thing",

      model: defaultBackend().id,

      reasoning: "high",

    });

  });

  it("reports the label of the backend it is set to", () => {

    expect(source().model).toBe(defaultBackend().label);

    expect(source().backendId).toBe(defaultBackend().id);

  });

  it("sends the backend it was constructed with", async () => {

    const seen: Array<Record<string, unknown>> = [];

    let page = 0;

    vi.stubGlobal(

      "fetch",

      vi.fn((url: URL, init?: RequestInit) => {

        if (url.pathname.endsWith("/chat/turns")) {

          seen.push(JSON.parse(String(init?.body)) as Record<string, unknown>);

          return Promise.resolve(json(202, { turn: { id: "run-1" } }));

        }

        // The source snapshots the log before it submits, so the first read

        // has to predate the turn or it counts the reply as already seen.

        const events =

          page++ === 0

            ? []

            : [

                { run_id: "run-1", sequence: 1, type: "text_delta", payload: { value: "hi" } },

                { run_id: "run-1", sequence: 2, type: "response_completed", payload: {} },

              ];

        return Promise.resolve(json(200, { events }));

      }),

    );

    const gemini = new ChatApiReplySource({

      origin: "https://openagents.test",

      token: "test-token",

      backend: findBackend("gemini-3.7-flash"),

    });

    expect(gemini.model).toBe("Gemini 3.7 Flash");

    expect(await collect(gemini, "hello")).toBe("hi");

    expect(seen[0]?.["model"]).toBe("gemini-3.7-flash");

  });

  it("reports the model it runs on", () => {

    expect(source().model).toBe("stealth/ox-alpha");

  it("cycles through every backend and wraps back to the first", () => {

    const cycling = source();

    const labels = CODER_BACKENDS.map(() => cycling.cycleBackend());

    // Every backend is reachable, and the last cycle returns to the start, so

    // a third entry needs no second key.

    expect(new Set(labels).size).toBe(CODER_BACKENDS.length);

    expect(cycling.model).toBe(defaultBackend().label);

  });

  it("says that its turns land in the account's one shared conversation", () => {

    const roles = new Set(session.snapshot().entries.map((entry) => entry.role));

    expect(roles).toEqual(new Set(["you", "reasoning", "tool", "assistant"]));

  });

  describe("switching backend", () => {

    const noop = () => {};

    /** A source that can switch, and records how often it was asked to. */

    const switchable = (hold: Promise<void>): ReplySource & { switches: number } => {

      const state = {

        switches: 0,

        model: "First",

        cycleBackend() {

          state.switches += 1;

          state.model = `Model ${state.switches}`;

          return state.model;

        },

        async *reply() {

          await hold;

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

        },

      };

      return state;

    };

    it("a source with one backend offers no switch", () => {

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

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

      expect(session.cycleBackend()).toEqual({ switched: false, label: undefined });

    });

    it("switches while idle and names the new model", () => {

      const session = new CoderSession(switchable(Promise.resolve()), "repo", "main");

      expect(session.canCycleBackend).toBe(true);

      expect(session.cycleBackend()).toEqual({ switched: true, label: "Model 1" });

      expect(session.snapshot().model).toBe("Model 1");

      expect(session.snapshot().entries.at(-1)?.text).toBe("Model switched to Model 1.");

    });

    it("refuses while a turn is running, and says why", async () => {

      let release: () => void = noop;

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

        release = resolve;

      });

      const source = switchable(hold);

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

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

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

      const result = session.cycleBackend();

      // The turn on screen was submitted against the model the status line

      // names, so the label must not move out from under it.

      expect(result.switched).toBe(false);

      expect(source.switches).toBe(0);

      expect(session.snapshot().model).toBe("First");

      expect(session.snapshot().entries.at(-1)?.text).toContain("on the next turn");

      release();

      await running;

      // And it works again the moment the turn is over.

      expect(session.cycleBackend().switched).toBe(true);

    });

  });

});

import { EventEmitter } from "node:events";

import { describe, expect, it } from "vitest";

import { CODER_BACKENDS, defaultBackend } from "../src/coder-backends.js";

import { CoderSession, type ReplyChunk, type ReplySource } from "../src/coder-session.js";

import { runCoderUi } from "../src/coder-ui.js";

  },

});

/** A source with backends to cycle, which is what makes Tab mean anything. */

const switchable = (chunks: ReadonlyArray<ReplyChunk>): ReplySource => {

  let index = 0;

  return {

    get model() {

      return CODER_BACKENDS[index]?.label ?? "none";

    },

    cycleBackend() {

      index = (index + 1) % CODER_BACKENDS.length;

      return CODER_BACKENDS[index]?.label ?? "none";

    },

    async *reply() {

      for (const chunk of chunks) yield chunk;

    },

  };

};

/**

 * Replay the painted rows.

 *

    expect(bar).toContain("ctrl+d to quit");

    // There is nothing to interrupt while the session is idle.

    expect(bar).not.toContain("interrupt");

    // And nothing to switch to, because this source has one backend.

    expect(bar).not.toContain("tab to switch");

  });

  describe("switching backend with tab", () => {

    const driveSwitchable = async (keys: ReadonlyArray<string>) => {

      const stdin = new FakeIn();

      const stdout = new FakeOut();

      const session = new CoderSession(

        switchable([{ type: "text", value: "hello" }]),

        "repo",

        "main",

      );

      const running = runCoderUi(session, {

        stdin: stdin as unknown as NodeJS.ReadStream,

        stdout: stdout as unknown as NodeJS.WriteStream,

      });

      await session.submit("go");

      for (const key of keys) stdin.emit("data", key);

      const painted = stdout.written;

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

      await running;

      return { painted, rows: screen(painted), session };

    };

    it("names the key only where there is another backend to reach", async () => {

      const { rows } = await driveSwitchable([]);

      expect(rows.at(-1) ?? "").toContain("tab to switch model");

    });

    it("moves to the next backend and says so", async () => {

      const { session, rows } = await driveSwitchable(["\t"]);

      const expected = CODER_BACKENDS[1]?.label ?? "";

      expect(session.snapshot().model).toBe(expected);

      expect(rows.join("\n")).toContain(`Model switched to ${expected}.`);

    });

    it("wraps around, so every backend is reachable from one key", async () => {

      const { session } = await driveSwitchable(CODER_BACKENDS.map(() => "\t"));

      expect(session.snapshot().model).toBe(defaultBackend().label);

    });

    it("does not leave a tab in the composer", async () => {

      const { rows } = await driveSwitchable(["\t"]);

      const composer = rows.find((row) => row.includes(">")) ?? "";

      expect(composer).not.toContain("\t");

    });

  });

});