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

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

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

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

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

import {

  discoverOllamaModel,

  isOllamaModelFlag,

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

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

);

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

  Flag.withDescription(

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

  ),

);

const coderReasoningFlag = Flag.choice("reasoning", [

  "minimal",

  "low",

    prompt: coderPrompt,

    plain: coderPlainFlag,

    offline: coderOfflineFlag,

    local: coderLocalFlag,

    resume: coderResumeFlag,

    last: coderLastFlag,

    all: coderAllFlag,

    prompt,

    plain,

    offline,

    local,

    resume,

    last,

    all,

      }

      const named = Option.getOrUndefined(model);

      // Local is asked for, not fallen into. It used to be the default whenever

      // a machine happened to be running Ollama, which made the session's model

      // a property of what was running on the laptop rather than a choice, and

      // a reader who started the server for something else got a different

      // coder without asking for one.

      const localModel =

        named === undefined && !offline && !resume

        local && named === undefined && !offline && !resume

          ? yield* Effect.promise(() => discoverOllamaModel())

          : undefined;

      if (local && named === undefined && localModel === undefined && !offline && !resume) {

        return yield* new InputError({

          message:

            "--local answers from a model on this machine, and no Ollama server is running " +

            "with one. Start it, pull a model, or drop --local to use the coder backend.",

        });

      }

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

      const askedFor =

        named === undefined

                    // 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(),

                    reasoning: Option.getOrUndefined(reasoning),

                  }),

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

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

];

/**

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

 *

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

 */

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

export const defaultBackendId = (): string =>

  CODER_BACKENDS.some((backend) => backend.id === DEFAULT_CODER_BACKEND)

    ? DEFAULT_CODER_BACKEND

    : (CODER_BACKENDS[0]?.id ?? "");

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

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

          continue;

        }

        if (outcome === "unsupported") {

          this.threadClosed = true;

          this.queue.length = 0;

          this.trouble(

            "This server does not serve a thread transcript yet, so this session is not " +

              "recorded on it. The work is unaffected.",

          );

          break;

        }

        if (outcome === "thread_closed") {

          this.threadClosed = true;

          this.queue.length = 0;

  /** One POST, translated to what the pump can act on. Never throws. */

  private async send(

    event: QueuedEvent,

  ): Promise<"posted" | "retry" | "refused" | "thread_closed"> {

  ): Promise<"posted" | "retry" | "refused" | "thread_closed" | "unsupported"> {

    let response: Response;

    try {

      response = await this.post(

    // A server that is down answers 5xx; the event is still good.

    if (response.status >= 500) return "retry";

    // A server without the route is a server older than this client, not a

    // server calling the event invalid. Retrying cannot help and neither can

    // editing the payload, so the record stops for the session and says why

    // once — rather than reporting a refusal on every turn for a route that was

    // never reached.

    if (response.status === 404 || response.status === 405) return "unsupported";

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

    if (body["code"] === "thread_terminal") return "thread_closed";

    return "refused";

    expect(chunks.at(-1)).toMatchObject({ type: "usage" });

  });

});

describe("which lane a session opens on", () => {

  it("leads with Gemini 3.7 Flash when nobody names a backend", async () => {

    const { defaultBackendId, CODER_BACKENDS } = await import("../src/coder-backends.js");

    // Local used to be the default whenever a machine happened to be running

    // Ollama, which made the session's model a property of the laptop rather

    // than a choice.

    expect(defaultBackendId()).toBe("gemini-3.7-flash");

    // And the list still mirrors the server's enum in its own order: a

    // preference is named, not expressed by reordering an agreement.

    expect(CODER_BACKENDS.map((backend) => backend.id)).toEqual(["ox-alpha", "gemini-3.7-flash"]);

  });

});