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

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

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

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

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

import { delegateTool } from "./coder-tools.js";

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

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

const loginScopeFlag = Flag.string("scope").pipe(

  Flag.atLeast(0),

  Flag.withDescription(

    "Request a scope for the new token; repeatable. Omit to take the server's default. Use chat:account to reach the chat API from `openagents coder`.",

    "Request a scope for the new token; repeatable. Omit to take the server's default, which already reaches the chat API from `openagents coder`.",

  ),

);

const loginResumeFlag = Flag.boolean("resume").pipe(

  Flag.withDescription("How many children may run at once. The rest queue"),

);

/**

 * The model delegated children run on.

 *

 * A child is a coding agent, and the model a session's own turns run on is

 * chosen for conversation, so children are pinned to Ox Alpha rather than

 * inheriting the parent's. It is a separate thread with its own budget, so a

 * fan-out cannot spend the authority the conversation is holding, and the

 * server issues it — no provider key reaches this process either way.

 */

const CHILD_THREAD_MODEL = "ox-alpha";

/** The children's thread, or the server's own words for why there is none. */

type ChildThread =

  | { readonly kind: "opened"; readonly thread: ThreadReplySource }

  | { readonly kind: "refused"; readonly reason: string };

/**

 * Open the thread children spend.

 *

 * A refusal is reported, never absorbed. Lending children the conversation's

 * own grant instead would run them on the conversation's model while the

 * interface said Ox Alpha, so a session that cannot open this thread delegates

 * to nothing and says which refusal stopped it.

 */

async function openChildThread(options: {

  readonly origin: string;

  readonly token: string;

  readonly objective: string;

}): Promise<ChildThread> {

  try {

    return {

      kind: "opened",

      thread: await openThread({

        origin: options.origin,

        token: options.token,

        objective: options.objective,

        model: process.env["OPENAGENTS_DELEGATE_THREAD_MODEL"] ?? CHILD_THREAD_MODEL,

      }),

    };

  } catch (cause) {

    const reason =

      cause instanceof ThreadUnavailable

        ? `${cause.message} (${cause.code})`

        : `The thread could not be opened: ${String(cause)}`;

    return { kind: "refused", reason };

  }

}

/** Delegation and whatever has to be torn down with it. */

interface DelegationSetup {

  readonly delegation: CoderDelegation;

        : undefined;

      const source = thread ?? new DummyReplySource();

      // Children get their own thread on their own model. The conversation

      // stays on the model it opened with, and a fan-out spends a budget the

      // reader's next question does not share.

      const childThread =

        thread !== undefined && Option.isSome(stored)

          ? yield* Effect.promise(() =>

              openChildThread({

                origin: endpoint.origin,

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

                objective: `delegated children of openagents coder in ${workspace.repository}`,

              }),

            )

          : undefined;

      const childGrant = childThread?.kind === "opened" ? childThread.thread.childGrant : undefined;

      const setup = yield* Effect.promise(() =>

        buildDelegation({

          model: Option.getOrUndefined(childModel),

          autoApprove: !childAsk,

          concurrency,

          cwd: process.cwd(),

          grant: thread?.childGrant,

          grant: childGrant,

        }),

      );

        thread.useTools([delegateTool(setup.delegation)]);

      }

      // Delegation is off rather than quietly running children on the

      // conversation's model, so the refusal that turned it off is what the

      // reader sees.

      if (childThread?.kind === "refused") {

        session.notice(`This session cannot delegate: ${childThread.reason}`);

      }

      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 a real model.",

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

        );

      }

          // session nobody is in. A process killed outright still leaves it to

          // the server's expiry reap.

          if (thread !== undefined) await thread.revoke();

          if (childThread?.kind === "opened") await childThread.thread.revoke();

          if (setup !== undefined) await setup.close();

        }

      });

    }),

).pipe(

  Command.withDescription(

    "Open a terminal coding session on a thread of its own. Replies come from the thread's grant through the inference proxy, so nothing typed here reaches /chat; --offline answers from a built-in stand-in instead. The session can delegate: ask it to split work and it runs child coding agents on the same grant, or launch a fan-out yourself with `/delegate [<n>x] <prompt>`, and the interface shows the fleet",

    "Open a terminal coding session on a thread of its own. Replies come from the thread's grant through the inference proxy, so nothing typed here reaches /chat; --offline answers from a built-in stand-in instead. The session can delegate: ask it to split work and it runs child coding agents on a thread of their own pinned to Ox Alpha, or launch a fan-out yourself with `/delegate [<n>x] <prompt>`, and the interface shows the fleet",

  ),

);

            )

          : Option.none();

      // Every turn on this thread is a child's, so it is opened on the child

      // model directly rather than opening one thread to hold and another to

      // spend.

      const thread = Option.isSome(stored)

        ? yield* Effect.tryPromise({

            try: () =>

                origin: endpoint.origin,

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

                objective: `openagents delegate: ${describePrompt(prompt)}`,

                model: process.env["OPENAGENTS_DELEGATE_THREAD_MODEL"] ?? CHILD_THREAD_MODEL,

              }),

            catch: (cause) => coderRefusal(endpoint.origin, cause),

          })

      if (setup === undefined) {

        return yield* new InputError({

          message:

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

            "chat:account` so children can spend a thread, or pass --child-model " +

            "provider/model to run them on a provider of your own.",

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

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

            "them on a provider of your own.",

        });

      }

      const delegation = setup.delegation;

    if (delegation === undefined) {

      this.notice(

        "This session cannot delegate: children spend the session's thread, and this " +

          "session has none. Sign in with `openagents auth login --scope chat:account`, " +

          "session has none. Sign in with `openagents auth login`, " +

          "or start the session with `--child-model provider/model` to run children on a " +

          "provider of your own.",

      );

  readonly objective: string;

  /** Recorded on the thread as its admitted execution shape. */

  readonly reasoning?: string | undefined;

  /**

   * The model the thread's grant pins, and therefore the model every call

   * through the proxy reaches. Omitted, the server pins its default.

   *

   * This is the only place a model is chosen: the proxy refuses a model named

   * in a request body. So a session that wants its children on another model

   * opens a second thread naming it, with its own budget, rather than lending

   * them the authority its own turns spend.

   */

  readonly model?: string | undefined;

}

export class ThreadUnavailable extends Error {

    body: JSON.stringify({

      objective: options.objective,

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

      ...(options.model === undefined ? {} : { model: options.model }),

    }),

  }).catch((cause: unknown) => {

    throw new ThreadUnavailable(

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

    throw new ThreadUnavailable(

      "scope_missing",

      "This token cannot open a thread. Sign in again with the chat:account scope.",

      "This token cannot open a thread. Run `openagents auth login` to sign in again.",

      response.status,

    );

  }

    expect(calls[0]?.body).toEqual({ objective: "coder in repo on main", reasoning: "high" });

  });

  it("names the model the thread's grant should pin, so children can run on another", async () => {

    const calls = stub({});

    await openThread({

      origin: ORIGIN,

      token: ACCOUNT_TOKEN,

      objective: "delegated children",

      model: "ox-alpha",

    });

    expect(calls[0]?.body).toEqual({ objective: "delegated children", model: "ox-alpha" });

  });

  it("lends children the model their own thread pinned, not the conversation's", async () => {

    stub({

      create: json(201, {

        ...CREATED,

        grant: { ...CREATED.grant, model: "ox-alpha" },

      }),

    });

    const source = await openThread({

      origin: ORIGIN,

      token: ACCOUNT_TOKEN,

      objective: "delegated children",

      model: "ox-alpha",

    });

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

  });

  it("starts with the ceilings the grant was minted with", async () => {

    stub({});

    expect((await open()).budget).toBe("256 calls · 1.0M tok · $2.00");