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

import { CoderTaskRegistry } from "./coder-tasks.js";

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

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

import {

  backendIds,

  chooseBackend,

  defaultBackendId,

  fetchServedCatalog,

  refuseBackend,

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

import {

  discoverOllamaModel,

  isOllamaModelFlag,

  Flag.withDescription("Complete the pending device authorization for the selected API"),

);

/**

 * The login that reaches this session's server. Credentials are stored per

 * endpoint, so a session pointed anywhere other than production is not served

 * by a bare `openagents auth login` — the same profile has to be named again,

 * and a hint that omits it sends the reader around a loop that never signs

 * them in.

 */

const loginCommandFor = (endpoint: {

  readonly origin: string;

  readonly profile: string;

}): string =>

  endpoint.profile === "production"

    ? "openagents auth login"

    : endpoint.profile === "custom"

      ? `openagents --api-url ${endpoint.origin} auth login`

      : `openagents --profile ${endpoint.profile} auth login`;

const resumeCommandFor = (endpoint: {

  readonly origin: string;

  readonly profile: string;

const coderOfflineFlag = Flag.boolean("offline").pipe(

  Flag.withDescription("Answer from the built-in stand-in instead of the chat API"),

);

const coderDevFlag = Flag.boolean("dev").pipe(

  Flag.withDescription(

    "Talk to a development server on this machine instead of the production API",

  ),

);

const coderLocalFlag = Flag.boolean("local").pipe(

  Flag.withDescription(

    "Answer from a model running on this machine through Ollama, instead of the coder backend",

    plain: coderPlainFlag,

    offline: coderOfflineFlag,

    local: coderLocalFlag,

    dev: coderDevFlag,

    resume: coderResumeFlag,

    last: coderLastFlag,

    all: coderAllFlag,

    plain,

    offline,

    local,

    dev,

    resume,

    last,

    all,

      const flags = yield* rootCommand;

      const terminal = yield* TerminalSession;

      const workspace = describeWorkspace();

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

      // `--dev` is the `local` profile by another name, so one flag points a

      // session at a server on this machine. A deploy can take half an hour,

      // and iterating against a server nobody has deployed to yet is the

      // difference between a change being testable now and after lunch.

      const endpoint = yield* resolveApiEndpoint(

        dev

          ? { profile: Option.some("local" as Profile), apiUrl: Option.none() }

          : endpointOverrides(flags),

      );

      if (dev) {

        const reachable = yield* Effect.promise(async () => {

          try {

            const answer = await fetch(new URL("/healthz", endpoint.origin), {

              signal: AbortSignal.timeout(1_500),

            });

            return answer.ok;

          } catch {

            return false;

          }

        });

        if (!reachable) {

          return yield* new InputError({

            message:

              `No development server is answering at ${endpoint.origin}. ` +

              "Start it with `mix phx.server` in the openagents.com checkout, or drop --dev.",

          });

        }

      }

      // A `--model` value that starts with `ollama:` goes to the local Ollama

      // server and needs no account credential.

      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,

      // which costs the enum `Flag.choice` used to enforce, so the check moves

      // here rather than disappearing.

      if (named !== undefined && !wantsOllama && !backendIds().includes(named)) {

        return yield* new InputError({

          message: `Unknown model ${named}. Use ollama:<model> for a local Ollama server, or one of: ${backendIds().join(", ")}.`,

        });

      }

      // The session opens a thread of its own and spends that thread's grant,

      // so the CLI still holds no provider key and nothing typed here reaches

      // the account's conversation. Without a credential it falls back to the

              if (Option.isNone(stored)) {

                throw new ThreadUnavailable(

                  "scope_missing",

                  "Resuming reads the account's threads. Run `openagents auth login` first.",

                  `Resuming reads the account's threads. Run \`${loginCommandFor(endpoint)}\` first.`,

                );

              }

              const api = { origin: endpoint.origin, token: Redacted.value(stored.value.token) };

      if (resume && resumed === undefined) return;

      // What this deployment actually serves. Asked once, before a thread is

      // opened, because the model a session leads with is a preference and the

      // catalog is the only thing that knows whether it can be honoured here.

      // A dev server and production do not serve the same list, and a client

      // that assumes one of them is wrong against the other.

      const served =

        Option.isSome(stored) && !wantsOllama && !offline && resumed === undefined

          ? yield* Effect.promise(() =>

              fetchServedCatalog({

                origin: endpoint.origin,

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

              }),

            )

          : undefined;

      // A named model the server cannot serve is refused here, where the reason

      // can name the model and list the alternatives, rather than at the thread

      // route, where it is a bare `Validation Failed`.

      //

      // Where the catalog could not be read, the static list stands in. It is

      // the weaker check — it cannot know what a given deployment has a

      // credential for — so it runs only when there is nothing better, and it

      // never overrules a server that has spoken. The flag takes a string

      // rather than an enum so an `ollama:` prefix can reach the local server,

      // which is why this is a check and not `Flag.choice`.

      if (named !== undefined && !wantsOllama) {

        const refusal =

          served !== undefined

            ? refuseBackend(served, named)

            : backendIds().includes(named)

              ? undefined

              : `Unknown model ${named}. Use ollama:<model> for a local Ollama server, ` +

                `or one of: ${backendIds().join(", ")}.`;

        if (refusal !== undefined) return yield* new InputError({ message: refusal });

      }

      const chosen = served === undefined ? undefined : chooseBackend(served, named);

      if (served !== undefined && chosen === undefined) {

        return yield* new InputError({

          message:

            `No model on ${endpoint.origin} has a configured provider credential, ` +

            "so a session opened there could not answer.",

        });

      }

      const thread =

        resumed !== undefined

          ? resumed.source

                    // records it on the thread, and `--resume` filters on it

                    // rather than parsing the objective back.

                    repository: workspace.repository,

                    // The named backend, or the one this build leads with.

                    model: named ?? defaultBackendId(),

                    // What the server said it serves, having been asked. The

                    // static fallback is for a server too old to publish a

                    // catalog, which is the only case where `chosen` is absent.

                    model: chosen?.id ?? named ?? defaultBackendId(),

                    reasoning: Option.getOrUndefined(reasoning),

                  }),

                // The server's own code and sentence, which is what turns a ninth

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

        session.notice(

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

            "Run `openagents auth login` to reach a real model.",

            `Run \`${loginCommandFor(endpoint)}\` to reach a real model.`,

        );

      }

      if (setup === undefined) {

        return yield* new InputError({

          message:

            "Nothing to run children on. Sign in with `openagents auth login` so " +

            `Nothing to run children on. Sign in with \`${loginCommandFor(endpoint)}\` so ` +

            "children can spend a thread, or pass --child-model provider/model to run " +

            "them on a provider of your own.",

        });

/**

 * 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 shows and the `--model` flag accepts has to be one list, or the two

 * drift and the CLI offers something the server refuses.

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

 * session that can reach the server reads it from there — see

 * `fetchServedCatalog` below. The list in this file is the fallback for a

 * session that cannot: `--offline`, or no stored credential.

 *

 * A hardcoded copy is a copy that drifts. This one did: it named

 * `gemini-3.7-flash`, no deployment had ever served a model by that id, and a

 * session that took the name from here opened its thread against a catalog that

 * refused it. The published catalog also says which models are *available* —

 * served here, credential configured — which a static list cannot say at all,

 * and which is the difference between a thread that answers and a 422.

 *

 * Choosing between them is not the client's call today. A coder session runs on

 * a thread, and the inference proxy takes the model from that thread's grant,

 * so this list is what the flag validates against and what the status line

 * names, nothing more.

 *

 * 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.

 * The `id` is what `POST /api/v3/threads` takes as `model`. The `label` is what

 * a person reads in the status bar, where the whole line is competing for a

 * narrow terminal; a model the server serves and this file has never heard of

 * is labelled with its own id.

 */

export interface CoderBackend {

];

/**

 * What a coder session opens on when nobody names a backend.

 *

 * Deliberately not the server's own default, which is the catalog's first entry

 * and serves every caller of the chat API. A coder turn is a long one with tools

 * in it, and this build leads with the fast model for that; a reader who wants

 * the other says so with `--model`.

 * The backend a coder session leads with when nobody names one.

 *

 * Named rather than taken from the list's order, because the order here mirrors

 * the server's published enum and a test holds the two together. Expressing a

 * preference by reordering would have broken that agreement to say something the

 * list was never saying.

 * A *preference*, not an answer. A coder turn is a long one with tools in it,

 * and this build leads with the fast model for that — but only where the server

 * actually serves it. Where it does not, `chooseBackend` falls to the server's

 * own default rather than opening a thread on a name the catalog will refuse.

 */

export const DEFAULT_CODER_BACKEND = "gemini-3.7-flash";

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

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

/** One model as the server publishes it at `GET /api/v3/models`. */

export interface ServedModel {

  readonly id: string;

  /** Served here *and* its provider credential configured. */

  readonly available: boolean;

  /** The model the server itself falls back to. */

  readonly isDefault: boolean;

}

/**

 * What this deployment serves, read from the server rather than assumed.

 *

 * `undefined` means the question could not be asked — an older server without

 * the route, an unreachable one, a token that cannot read it. That is not the

 * same as "serves nothing", so the caller falls back to the static list rather

 * than refusing to start.

 */

export const fetchServedCatalog = async (

  api: { readonly origin: string; readonly token: string },

  signal?: AbortSignal,

): Promise<readonly ServedModel[] | undefined> => {

  try {

    const response = await fetch(new URL("/api/v3/models", api.origin), {

      headers: { authorization: `Bearer ${api.token}`, accept: "application/json" },

      signal: signal ?? AbortSignal.timeout(5_000),

    });

    if (!response.ok) return undefined;

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

      readonly models?: readonly {

        readonly id?: unknown;

        readonly availability?: unknown;

        readonly default?: unknown;

      }[];

    };

    if (!Array.isArray(body.models)) return undefined;

    const served = body.models.flatMap((model) =>

      typeof model.id === "string" && model.id.length > 0

        ? [

            {

              id: model.id,

              // Anything other than the word `available` is treated as not

              // available: a vocabulary this client has not seen is a reason to

              // pick a different model, not to assume the new word is benign.

              available: model.availability === "available",

              isDefault: model.default === true,

            },

          ]

        : [],

    );

    return served.length === 0 ? undefined : served;

  } catch {

    return undefined;

  }

};

/**

 * The backend to open a thread on, given what the server actually serves.

 *

 * The preference wins where it is served and available. Otherwise the server's

 * own default, then whatever else is available — because a session that can run

 * on something should run, and a reader who wanted the other model says so with

 * `--model` and gets told plainly when it cannot be had.

 *

 * `undefined` means the catalog is real and nothing in it can answer. That is a

 * server with no provider credential configured, and it is worth saying rather

 * than opening a thread that will fail at its first turn.

 */

export const chooseBackend = (

  served: readonly ServedModel[],

  preferred: string = DEFAULT_CODER_BACKEND,

): ServedModel | undefined =>

  served.find((model) => model.id === preferred && model.available) ??

  served.find((model) => model.isDefault && model.available) ??

  served.find((model) => model.available);

/**

 * Why this named model cannot be opened, or `undefined` if it can.

 *

 * Refusing here turns the server's `422 Validation Failed` — which names no

 * model and suggests no alternative — into a sentence that says which model,

 * why, and what this deployment does serve.

 */

export const refuseBackend = (

  served: readonly ServedModel[],

  named: string,

): string | undefined => {

  const match = served.find((model) => model.id === named);

  const usable = served.filter((model) => model.available).map((model) => model.id);

  const alternatives =

    usable.length === 0

      ? "This server has no model with a configured credential."

      : `This server serves ${usable.join(", ")}.`;

  if (match === undefined) return `No model called '${named}' is served here. ${alternatives}`;

  if (!match.available) {

    return `'${named}' is served here but its provider credential is not configured. ${alternatives}`;

  }

  return undefined;

};

/** The status-line name for a model id, which may be one the static list lacks. */

export const backendLabel = (id: string): string =>

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

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

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

import {

  backendIds,

  chooseBackend,

  CODER_BACKENDS,

  fetchServedCatalog,

  refuseBackend,

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

/**

 * The list two surfaces read.

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

  });

});

describe("choosing a backend from what the server serves", () => {

  const model = (id: string, available: boolean, isDefault = false) => ({

    id,

    available,

    isDefault,

  });

  it("leads with the preferred backend where the server serves it", () => {

    const chosen = chooseBackend([

      model("gpt-5.6-luna", true, true),

      model("gemini-3.7-flash", true),

    ]);

    expect(chosen?.id).toBe("gemini-3.7-flash");

  });

  it("falls to the server's own default when the preference is not served", () => {

    // The case that sent every session into a 422: no deployment served a model

    // by that id, and the client named it anyway.

    const chosen = chooseBackend([model("gpt-5.6-luna", true, true), model("ox-alpha", false)]);

    expect(chosen?.id).toBe("gpt-5.6-luna");

  });

  it("falls past an unavailable default to something that can answer", () => {

    const chosen = chooseBackend([model("gpt-5.6-luna", false, true), model("ox-alpha", true)]);

    expect(chosen?.id).toBe("ox-alpha");

  });

  it("honours an explicitly named model over the preference", () => {

    const chosen = chooseBackend(

      [model("gpt-5.6-luna", true, true), model("gemini-3.7-flash", true)],

      "gpt-5.6-luna",

    );

    expect(chosen?.id).toBe("gpt-5.6-luna");

  });

  it("chooses nothing when no model has a configured credential", () => {

    expect(chooseBackend([model("gpt-5.6-luna", false, true), model("ox-alpha", false)])).toBe(

      undefined,

    );

  });

});

describe("refusing a named backend", () => {

  const served = [

    { id: "gpt-5.6-luna", available: true, isDefault: true },

    { id: "ox-alpha", available: false, isDefault: false },

  ];

  it("says a model is not served here and names what is", () => {

    const refusal = refuseBackend(served, "gemini-3.7-flash");

    expect(refusal).toContain("gemini-3.7-flash");

    expect(refusal).toContain("gpt-5.6-luna");

  });

  it("separates a missing credential from a missing model", () => {

    const refusal = refuseBackend(served, "ox-alpha");

    expect(refusal).toContain("credential is not configured");

  });

  it("does not refuse a model the server serves and can run", () => {

    expect(refuseBackend(served, "gpt-5.6-luna")).toBe(undefined);

  });

  it("says so plainly when the deployment can run nothing", () => {

    const refusal = refuseBackend([{ id: "ox-alpha", available: false, isDefault: true }], "ox-alpha");

    expect(refusal).toContain("no model with a configured credential");

  });

});

describe("reading the published catalog", () => {

  const withFetch = async (

    handler: (url: string) => Response | Promise<Response>,

    run: () => Promise<unknown>,

  ) => {

    const original = globalThis.fetch;

    globalThis.fetch = ((input: URL | RequestInfo) =>

      Promise.resolve(handler(String(input)))) as typeof fetch;

    try {

      return await run();

    } finally {

      globalThis.fetch = original;

    }

  };

  const api = { origin: "http://localhost:4000", token: "t" };

  it("reads ids and availability from the server's own shape", async () => {

    const served = await withFetch(

      (url) => {

        expect(url).toBe("http://localhost:4000/api/v3/models");

        return new Response(

          JSON.stringify({

            default: "gpt-5.6-luna",

            models: [

              { id: "gpt-5.6-luna", availability: "available", default: true },

              { id: "ox-alpha", availability: "unavailable", default: false },

            ],

          }),

          { status: 200 },

        );

      },

      () => fetchServedCatalog(api),

    );

    expect(served).toEqual([

      { id: "gpt-5.6-luna", available: true, isDefault: true },

      { id: "ox-alpha", available: false, isDefault: false },

    ]);

  });

  it("treats an availability word it has never seen as not available", async () => {

    const served = (await withFetch(

      () =>

        new Response(JSON.stringify({ models: [{ id: "new", availability: "degraded" }] }), {

          status: 200,

        }),

      () => fetchServedCatalog(api),

    )) as readonly { available: boolean }[];

    expect(served[0]?.available).toBe(false);

  });

  it("cannot answer for a server that refuses the route, rather than reporting an empty catalog", async () => {

    // `undefined` is "could not ask", which falls back to the static list. An

    // empty list would mean "serves nothing" and would stop the session.

    for (const status of [401, 404, 500]) {

      const served = await withFetch(

        () => new Response("", { status }),

        () => fetchServedCatalog(api),

      );

      expect(served).toBe(undefined);

    }

  });

  it("cannot answer for an unreachable server", async () => {

    const served = await withFetch(

      () => {

        throw new Error("ECONNREFUSED");

      },

      () => fetchServedCatalog(api),

    );

    expect(served).toBe(undefined);

  });

});