@coder/ai-sdk-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,930 @@
+// src/agent/coder-agent.ts
+import {
+  stepCountIs,
+  ToolLoopAgent
+} from "ai";
+
+// src/errors.ts
+var CoderAgentError = class extends Error {
+  name = "CoderAgentError";
+  constructor(message, options) {
+    super(message, options);
+  }
+};
+var CoderApiError = class extends CoderAgentError {
+  name = "CoderApiError";
+  status;
+  detail;
+  method;
+  path;
+  constructor(args) {
+    super(
+      `Coder API ${args.method} ${args.path} failed (${args.status}): ${args.message}` + (args.detail ? ` \u2014 ${args.detail}` : "")
+    );
+    this.status = args.status;
+    this.detail = args.detail;
+    this.method = args.method;
+    this.path = args.path;
+  }
+};
+var CoderChatError = class extends CoderAgentError {
+  name = "CoderChatError";
+  kind;
+  provider;
+  retryable;
+  statusCode;
+  constructor(payload) {
+    super(payload.detail ? `${payload.message}: ${payload.detail}` : payload.message);
+    this.kind = payload.kind;
+    this.provider = payload.provider;
+    this.retryable = payload.retryable ?? false;
+    this.statusCode = payload.status_code;
+  }
+};
+
+// src/coder/types.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "waiting",
+  "completed",
+  "error",
+  "requires_action"
+]);
+
+// src/coder/ws.ts
+import NodeWebSocket from "ws";
+var defaultFactory = (url, { headers }) => {
+  return new NodeWebSocket(url, { headers });
+};
+function httpToWs(baseUrl) {
+  if (baseUrl.startsWith("https://")) return `wss://${baseUrl.slice("https://".length)}`;
+  if (baseUrl.startsWith("http://")) return `ws://${baseUrl.slice("http://".length)}`;
+  return baseUrl;
+}
+async function* streamChatEvents(options) {
+  const { baseUrl, token, chatId, afterId, signal } = options;
+  const factory = options.webSocketFactory ?? defaultFactory;
+  const wsBase = httpToWs(baseUrl);
+  const query = afterId !== void 0 ? `?after_id=${afterId}` : "";
+  const url = `${wsBase}/api/experimental/chats/${chatId}/stream${query}`;
+  const queue = [];
+  let resolveNext;
+  let finished = false;
+  let failure;
+  const wake = () => {
+    resolveNext?.();
+    resolveNext = void 0;
+  };
+  const ws = factory(url, { headers: { "Coder-Session-Token": token } });
+  const onAbort = () => {
+    finished = true;
+    try {
+      ws.close(1e3);
+    } catch {
+    }
+    wake();
+  };
+  let abortListenerAdded = false;
+  if (signal) {
+    if (signal.aborted) onAbort();
+    else {
+      signal.addEventListener("abort", onAbort, { once: true });
+      abortListenerAdded = true;
+    }
+  }
+  const onMessage = (ev) => {
+    if (finished) return;
+    let batch;
+    try {
+      const data = typeof ev.data === "string" ? ev.data : String(ev.data);
+      batch = JSON.parse(data);
+    } catch (err) {
+      failure = new CoderAgentError("failed to parse chat stream frame", { cause: err });
+      finished = true;
+      wake();
+      return;
+    }
+    if (Array.isArray(batch)) {
+      for (const e of batch) queue.push(e);
+    } else if (batch && typeof batch === "object") {
+      queue.push(batch);
+    }
+    wake();
+  };
+  const onError = (ev) => {
+    if (finished) return;
+    const message = ev && typeof ev === "object" && "message" in ev ? String(ev.message) : "chat stream socket error";
+    failure = new CoderAgentError(message);
+    finished = true;
+    wake();
+  };
+  const onClose = () => {
+    finished = true;
+    wake();
+  };
+  ws.addEventListener("message", onMessage);
+  ws.addEventListener("error", onError);
+  ws.addEventListener("close", onClose);
+  try {
+    while (true) {
+      while (queue.length > 0) {
+        const next = queue.shift();
+        yield next;
+      }
+      if (failure) throw failure;
+      if (finished) return;
+      await new Promise((resolve) => {
+        resolveNext = resolve;
+      });
+    }
+  } finally {
+    finished = true;
+    if (signal && abortListenerAdded) signal.removeEventListener("abort", onAbort);
+    ws.removeEventListener("message", onMessage);
+    ws.removeEventListener("error", onError);
+    ws.removeEventListener("close", onClose);
+    try {
+      ws.close(1e3);
+    } catch {
+    }
+  }
+}
+
+// src/coder/client.ts
+var API_PREFIX = "/api/experimental/chats";
+var CoderChatClient = class {
+  baseUrl;
+  #token;
+  #fetch;
+  #webSocketFactory;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.#token = options.token;
+    this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.#webSocketFactory = options.webSocketFactory;
+  }
+  async #request(method, path, body, signal) {
+    const headers = { "Coder-Session-Token": this.#token };
+    if (body !== void 0) headers["Content-Type"] = "application/json";
+    const res = await this.#fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers,
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      signal
+    });
+    const text = await res.text();
+    let parsed;
+    try {
+      parsed = text.length > 0 ? JSON.parse(text) : void 0;
+    } catch {
+      parsed = void 0;
+    }
+    if (!res.ok) {
+      const errObj = parsed ?? {};
+      throw new CoderApiError({
+        status: res.status,
+        method,
+        path,
+        message: errObj.message ?? res.statusText ?? "request failed",
+        detail: errObj.detail
+      });
+    }
+    return parsed;
+  }
+  // --- REST -----------------------------------------------------------------
+  listModelConfigs(signal) {
+    return this.#request(
+      "GET",
+      `${API_PREFIX}/model-configs`,
+      void 0,
+      signal
+    );
+  }
+  createChat(req, signal) {
+    return this.#request("POST", API_PREFIX, req, signal);
+  }
+  getChat(chatId, signal) {
+    return this.#request("GET", `${API_PREFIX}/${chatId}`, void 0, signal);
+  }
+  createChatMessage(chatId, req, signal) {
+    return this.#request(
+      "POST",
+      `${API_PREFIX}/${chatId}/messages`,
+      req,
+      signal
+    );
+  }
+  getMessages(chatId, opts, signal) {
+    const params = new URLSearchParams();
+    if (opts?.before_id !== void 0) params.set("before_id", String(opts.before_id));
+    if (opts?.after_id !== void 0) params.set("after_id", String(opts.after_id));
+    if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+    const q = params.toString();
+    return this.#request(
+      "GET",
+      `${API_PREFIX}/${chatId}/messages${q ? `?${q}` : ""}`,
+      void 0,
+      signal
+    );
+  }
+  submitToolResults(chatId, req, signal) {
+    return this.#request("POST", `${API_PREFIX}/${chatId}/tool-results`, req, signal);
+  }
+  interruptChat(chatId, signal) {
+    return this.#request("POST", `${API_PREFIX}/${chatId}/interrupt`, void 0, signal);
+  }
+  updateChat(chatId, req, signal) {
+    return this.#request("PATCH", `${API_PREFIX}/${chatId}`, req, signal);
+  }
+  /** Convenience: archive a chat (soft-hide; safe for cleanup). */
+  archiveChat(chatId, signal) {
+    return this.updateChat(chatId, { archived: true }, signal);
+  }
+  // --- Streaming ------------------------------------------------------------
+  streamEvents(chatId, opts) {
+    return streamChatEvents({
+      baseUrl: this.baseUrl,
+      token: this.#token,
+      chatId,
+      afterId: opts?.afterId,
+      signal: opts?.signal,
+      webSocketFactory: this.#webSocketFactory
+    });
+  }
+  // --- Helpers --------------------------------------------------------------
+  /**
+   * Resolves a user-friendly model hint to a model-config UUID.
+   *
+   * Accepts: a config UUID (returned as-is), a `provider:model` id
+   * (e.g. `anthropic:claude-haiku-4-5-20251001`), a bare model id, or a
+   * display-name substring (case-insensitive). Returns `undefined` if no
+   * match is found, in which case the caller should let chatd pick the default.
+   */
+  async resolveModelConfigId(hint, signal) {
+    const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (UUID_RE.test(hint)) return hint;
+    const configs = await this.listModelConfigs(signal);
+    const lower = hint.toLowerCase();
+    const colon = hint.indexOf(":");
+    const provider = colon >= 0 ? hint.slice(0, colon).toLowerCase() : void 0;
+    const model = colon >= 0 ? hint.slice(colon + 1).toLowerCase() : lower;
+    const candidates = configs.filter((c) => c.enabled !== false);
+    const pool = candidates.length > 0 ? candidates : configs;
+    const exact = pool.find(
+      (c) => c.model.toLowerCase() === model && (provider === void 0 || c.provider.toLowerCase() === provider)
+    );
+    if (exact) return exact.id;
+    const byModel = pool.find((c) => c.model.toLowerCase() === model);
+    if (byModel) return byModel.id;
+    const byDisplay = pool.find((c) => c.display_name.toLowerCase().includes(lower));
+    if (byDisplay) return byDisplay.id;
+    const byModelSubstring = pool.find((c) => c.model.toLowerCase().includes(model));
+    return byModelSubstring?.id;
+  }
+};
+
+// src/model/prompt.ts
+function extractSystemPrompt(prompt) {
+  const parts = prompt.filter(
+    (m) => m.role === "system"
+  );
+  if (parts.length === 0) return void 0;
+  const joined = parts.map((m) => m.content).join("\n\n").trim();
+  return joined.length > 0 ? joined : void 0;
+}
+function userContentToInputParts(message) {
+  const out = [];
+  for (const part of message.content) {
+    if (part.type === "text" && part.text.length > 0) {
+      out.push({ type: "text", text: part.text });
+    }
+  }
+  return out;
+}
+function toolResultOutputToChatd(output) {
+  switch (output.type) {
+    case "text":
+      return { value: output.value, isError: false };
+    case "json":
+      return { value: output.value, isError: false };
+    case "error-text":
+      return { value: output.value, isError: true };
+    case "error-json":
+      return { value: output.value, isError: true };
+    case "execution-denied":
+      return { value: { execution_denied: true, reason: output.reason }, isError: true };
+    case "content":
+      return { value: output.value, isError: false };
+    default:
+      return { value: output, isError: false };
+  }
+}
+function classifyTurnAction(prompt) {
+  if (prompt.length === 0) return { kind: "noop" };
+  const last = prompt[prompt.length - 1];
+  if (!last) return { kind: "noop" };
+  if (last.role === "tool") {
+    const toolResults = [];
+    for (let i = prompt.length - 1; i >= 0; i--) {
+      const m = prompt[i];
+      if (!m || m.role !== "tool") break;
+      for (const part of m.content) {
+        if (part.type !== "tool-result") continue;
+        const { value, isError } = toolResultOutputToChatd(part.output);
+        toolResults.unshift({ tool_call_id: part.toolCallId, output: value, is_error: isError });
+      }
+    }
+    return { kind: "resume", toolResults };
+  }
+  if (last.role === "user") {
+    return { kind: "new-turn", content: userContentToInputParts(last) };
+  }
+  return { kind: "noop" };
+}
+function toolsToDynamicTools(tools) {
+  if (!tools) return [];
+  const out = [];
+  for (const tool of tools) {
+    if (tool.type !== "function") continue;
+    out.push({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.inputSchema
+    });
+  }
+  return out;
+}
+function dynamicToolNames(tools) {
+  const names = /* @__PURE__ */ new Set();
+  for (const tool of tools ?? []) {
+    if (tool.type === "function") names.add(tool.name);
+  }
+  return names;
+}
+
+// src/model/translate.ts
+function mapUsage(u) {
+  return {
+    inputTokens: {
+      total: u?.input_tokens,
+      noCache: void 0,
+      cacheRead: u?.cache_read_tokens,
+      cacheWrite: u?.cache_creation_tokens
+    },
+    outputTokens: {
+      total: u?.output_tokens,
+      text: void 0,
+      reasoning: u?.reasoning_tokens
+    }
+  };
+}
+function jsonResult(value) {
+  return value ?? {};
+}
+var TurnTranslator = class {
+  #dynamicToolNames;
+  #seq = 0;
+  #text = { id: void 0, len: 0, sawDelta: false };
+  #reasoning = { id: void 0, len: 0, sawDelta: false };
+  #currentAssistantId;
+  #serverToolCalls = /* @__PURE__ */ new Set();
+  #serverToolResults = /* @__PURE__ */ new Set();
+  #clientToolCalls = /* @__PURE__ */ new Set();
+  #clientToolCallSeen = false;
+  #usage;
+  #error;
+  #terminalStatus;
+  #maxMessageId = 0;
+  constructor(opts) {
+    this.#dynamicToolNames = opts.dynamicToolNames;
+  }
+  get terminalStatus() {
+    return this.#terminalStatus;
+  }
+  /** Whether a client (custom) tool call has been emitted this turn. */
+  get clientToolCallSeen() {
+    return this.#clientToolCallSeen;
+  }
+  get maxMessageId() {
+    return this.#maxMessageId;
+  }
+  get error() {
+    return this.#error;
+  }
+  // --- block helpers --------------------------------------------------------
+  #openText(out) {
+    if (this.#reasoning.id) this.#closeReasoning(out);
+    if (!this.#text.id) {
+      this.#text.id = `text-${++this.#seq}`;
+      this.#text.len = 0;
+      out.push({ type: "text-start", id: this.#text.id });
+    }
+  }
+  #closeText(out) {
+    if (this.#text.id) {
+      out.push({ type: "text-end", id: this.#text.id });
+      this.#text.id = void 0;
+      this.#text.len = 0;
+    }
+  }
+  #openReasoning(out) {
+    if (this.#text.id) this.#closeText(out);
+    if (!this.#reasoning.id) {
+      this.#reasoning.id = `reasoning-${++this.#seq}`;
+      this.#reasoning.len = 0;
+      out.push({ type: "reasoning-start", id: this.#reasoning.id });
+    }
+  }
+  #closeReasoning(out) {
+    if (this.#reasoning.id) {
+      out.push({ type: "reasoning-end", id: this.#reasoning.id });
+      this.#reasoning.id = void 0;
+      this.#reasoning.len = 0;
+    }
+  }
+  #emitTextUpTo(out, full) {
+    if (full.length <= this.#text.len && this.#text.id) return;
+    this.#openText(out);
+    if (full.length > this.#text.len) {
+      out.push({
+        type: "text-delta",
+        id: this.#text.id,
+        delta: full.slice(this.#text.len)
+      });
+      this.#text.len = full.length;
+    }
+  }
+  #emitReasoningUpTo(out, full) {
+    if (full.length <= this.#reasoning.len && this.#reasoning.id) return;
+    this.#openReasoning(out);
+    if (full.length > this.#reasoning.len) {
+      out.push({
+        type: "reasoning-delta",
+        id: this.#reasoning.id,
+        delta: full.slice(this.#reasoning.len)
+      });
+      this.#reasoning.len = full.length;
+    }
+  }
+  // --- tool helpers ---------------------------------------------------------
+  #isClientTool(name) {
+    return name !== void 0 && this.#dynamicToolNames.has(name);
+  }
+  #emitServerToolCall(out, part) {
+    const id = part.tool_call_id;
+    const name = part.tool_name;
+    if (!id || !name) return;
+    if (part.args === void 0) return;
+    if (this.#serverToolCalls.has(id)) return;
+    this.#serverToolCalls.add(id);
+    out.push({ type: "tool-input-start", id, toolName: name, providerExecuted: true });
+    out.push({ type: "tool-input-end", id });
+    out.push({
+      type: "tool-call",
+      toolCallId: id,
+      toolName: name,
+      input: typeof part.args === "string" ? part.args : JSON.stringify(part.args),
+      providerExecuted: true
+    });
+  }
+  #emitServerToolResult(out, part) {
+    const id = part.tool_call_id;
+    const name = part.tool_name;
+    if (!id || !name) return;
+    if (part.result === void 0) return;
+    if (this.#serverToolResults.has(id)) return;
+    this.#serverToolResults.add(id);
+    out.push({
+      type: "tool-result",
+      toolCallId: id,
+      toolName: name,
+      result: jsonResult(part.result),
+      isError: part.is_error ?? false
+    });
+  }
+  // --- ingest ---------------------------------------------------------------
+  ingest(ev) {
+    const out = [];
+    switch (ev.type) {
+      case "message_part":
+        this.#ingestMessagePart(out, ev);
+        break;
+      case "message":
+        if (ev.message) this.#ingestMessage(out, ev.message);
+        break;
+      case "action_required":
+        for (const tc of ev.action_required?.tool_calls ?? []) {
+          if (this.#clientToolCalls.has(tc.tool_call_id)) continue;
+          this.#closeText(out);
+          this.#closeReasoning(out);
+          this.#clientToolCalls.add(tc.tool_call_id);
+          this.#clientToolCallSeen = true;
+          out.push({ type: "tool-input-start", id: tc.tool_call_id, toolName: tc.tool_name });
+          out.push({ type: "tool-input-end", id: tc.tool_call_id });
+          out.push({
+            type: "tool-call",
+            toolCallId: tc.tool_call_id,
+            toolName: tc.tool_name,
+            input: tc.args
+          });
+        }
+        break;
+      case "error":
+        if (ev.error) {
+          this.#error = ev.error;
+          out.push({ type: "error", error: new CoderChatError(ev.error) });
+        }
+        break;
+      case "status":
+        if (ev.status && TERMINAL_STATUSES.has(ev.status.status)) {
+          this.#terminalStatus = ev.status.status;
+        }
+        break;
+      default:
+        break;
+    }
+    return out;
+  }
+  #ingestMessagePart(out, ev) {
+    const mp = ev.message_part;
+    if (!mp || mp.role !== "assistant" && mp.role !== "tool") return;
+    const part = mp.part;
+    switch (part.type) {
+      case "text":
+        this.#text.sawDelta = true;
+        this.#openText(out);
+        if (part.text) {
+          out.push({ type: "text-delta", id: this.#text.id, delta: part.text });
+          this.#text.len += part.text.length;
+        }
+        break;
+      case "reasoning":
+        this.#reasoning.sawDelta = true;
+        this.#openReasoning(out);
+        if (part.text) {
+          out.push({ type: "reasoning-delta", id: this.#reasoning.id, delta: part.text });
+          this.#reasoning.len += part.text.length;
+        }
+        break;
+      case "tool-call":
+        this.#closeText(out);
+        this.#closeReasoning(out);
+        if (!this.#isClientTool(part.tool_name)) this.#emitServerToolCall(out, part);
+        break;
+      case "tool-result":
+        if (!this.#isClientTool(part.tool_name)) this.#emitServerToolResult(out, part);
+        break;
+      default:
+        break;
+    }
+  }
+  #ingestMessage(out, message) {
+    if (message.id > this.#maxMessageId) this.#maxMessageId = message.id;
+    if (message.usage && (message.role === "assistant" || message.role === "tool")) {
+      this.#usage = message.usage;
+    }
+    const content = message.content ?? [];
+    if (message.role === "assistant") {
+      if (this.#currentAssistantId !== void 0 && this.#currentAssistantId !== message.id) {
+        this.#closeText(out);
+        this.#closeReasoning(out);
+        this.#text.sawDelta = false;
+        this.#reasoning.sawDelta = false;
+      }
+      this.#currentAssistantId = message.id;
+      if (!this.#text.sawDelta) {
+        const full = content.filter((p) => p.type === "text").map((p) => p.text ?? "").join("");
+        if (full.length > 0) this.#emitTextUpTo(out, full);
+      }
+      if (!this.#reasoning.sawDelta) {
+        const full = content.filter((p) => p.type === "reasoning").map((p) => p.text ?? "").join("");
+        if (full.length > 0) this.#emitReasoningUpTo(out, full);
+      }
+      for (const part of content) {
+        if (part.type === "tool-call" && !this.#isClientTool(part.tool_name))
+          this.#emitServerToolCall(out, part);
+        else if (part.type === "tool-result" && !this.#isClientTool(part.tool_name))
+          this.#emitServerToolResult(out, part);
+      }
+    } else if (message.role === "tool") {
+      for (const part of content) {
+        if (part.type === "tool-result" && !this.#isClientTool(part.tool_name))
+          this.#emitServerToolResult(out, part);
+      }
+    }
+  }
+  // --- finish ---------------------------------------------------------------
+  finish() {
+    const out = [];
+    this.#closeText(out);
+    this.#closeReasoning(out);
+    let unified;
+    if (this.#error || this.#terminalStatus === "error") unified = "error";
+    else if (this.#clientToolCallSeen || this.#terminalStatus === "requires_action")
+      unified = "tool-calls";
+    else unified = "stop";
+    out.push({
+      type: "finish",
+      usage: mapUsage(this.#usage),
+      finishReason: { unified, raw: this.#terminalStatus }
+    });
+    return out;
+  }
+};
+
+// src/model/language-model.ts
+var EMPTY_USAGE = {
+  inputTokens: {
+    total: void 0,
+    noCache: void 0,
+    cacheRead: void 0,
+    cacheWrite: void 0
+  },
+  outputTokens: { total: void 0, text: void 0, reasoning: void 0 }
+};
+var CoderLanguageModel = class {
+  specificationVersion = "v3";
+  provider = "coder.chatd";
+  modelId;
+  supportedUrls = {};
+  #config;
+  #chatId;
+  #lastSeenMessageId = 0;
+  #resolvedModelConfigId;
+  #modelResolved = false;
+  #submittedToolCallIds = /* @__PURE__ */ new Set();
+  #inFlight = false;
+  constructor(config) {
+    this.#config = config;
+    this.modelId = config.model ?? "chatd";
+    this.#chatId = config.chatId;
+  }
+  get chatId() {
+    return this.#chatId;
+  }
+  /** Drops the current session so the next turn creates a fresh chat. */
+  resetSession() {
+    this.#chatId = void 0;
+    this.#lastSeenMessageId = 0;
+    this.#submittedToolCallIds.clear();
+  }
+  async #resolveModelConfigId(signal) {
+    if (this.#modelResolved) return this.#resolvedModelConfigId;
+    if (this.#config.model) {
+      this.#resolvedModelConfigId = await this.#config.client.resolveModelConfigId(
+        this.#config.model,
+        signal
+      );
+    }
+    this.#modelResolved = true;
+    return this.#resolvedModelConfigId;
+  }
+  async *#runTurn(options) {
+    if (this.#inFlight) {
+      throw new CoderAgentError(
+        "A generation is already in flight on this CoderAgent (single-flight). Use a separate CoderAgent instance for concurrent sessions."
+      );
+    }
+    this.#inFlight = true;
+    try {
+      const { prompt, abortSignal: signal } = options;
+      yield { type: "stream-start", warnings: [] };
+      const action = classifyTurnAction(prompt);
+      if (action.kind === "noop") {
+        throw new CoderAgentError(
+          "CoderAgent received a prompt with no user message or tool results to act on."
+        );
+      }
+      const translator = new TurnTranslator({ dynamicToolNames: dynamicToolNames(options.tools) });
+      let afterId;
+      if (action.kind === "new-turn") {
+        const modelConfigId = await this.#resolveModelConfigId(signal);
+        if (!this.#chatId) {
+          const req = {
+            organization_id: this.#config.organizationId,
+            content: action.content,
+            client_type: "api"
+          };
+          const system = extractSystemPrompt(prompt);
+          if (system) req.system_prompt = system;
+          const tools = toolsToDynamicTools(options.tools);
+          if (tools.length > 0) req.unsafe_dynamic_tools = tools;
+          if (modelConfigId) req.model_config_id = modelConfigId;
+          if (this.#config.workspaceId) req.workspace_id = this.#config.workspaceId;
+          if (this.#config.mcpServerIds?.length) req.mcp_server_ids = this.#config.mcpServerIds;
+          if (this.#config.planMode) req.plan_mode = this.#config.planMode;
+          const chat = await this.#config.client.createChat(req, signal);
+          this.#chatId = chat.id;
+          afterId = this.#lastSeenMessageId > 0 ? this.#lastSeenMessageId : void 0;
+        } else {
+          const resp = await this.#config.client.createChatMessage(
+            this.#chatId,
+            {
+              content: action.content,
+              ...modelConfigId ? { model_config_id: modelConfigId } : {}
+            },
+            signal
+          );
+          afterId = resp.message?.id ?? this.#lastSeenMessageId;
+        }
+      } else {
+        if (!this.#chatId)
+          throw new CoderChatError({ message: "cannot submit tool results before a chat exists" });
+        const fresh = action.toolResults.filter(
+          (r) => !this.#submittedToolCallIds.has(r.tool_call_id)
+        );
+        if (fresh.length > 0) {
+          await this.#config.client.submitToolResults(this.#chatId, { results: fresh }, signal);
+          for (const r of fresh) this.#submittedToolCallIds.add(r.tool_call_id);
+        }
+        afterId = this.#lastSeenMessageId;
+      }
+      const chatId = this.#chatId;
+      let sinceRequiresAction = 0;
+      for await (const ev of this.#config.client.streamEvents(chatId, { afterId, signal })) {
+        for (const part of translator.ingest(ev)) yield part;
+        const status = translator.terminalStatus;
+        if (status) {
+          if (status !== "requires_action") break;
+          if (translator.clientToolCallSeen) break;
+          if (++sinceRequiresAction > 200) break;
+        }
+      }
+      if (signal?.aborted && !translator.terminalStatus) {
+        throw signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+      }
+      for (const part of translator.finish()) yield part;
+      if (translator.maxMessageId > this.#lastSeenMessageId)
+        this.#lastSeenMessageId = translator.maxMessageId;
+    } finally {
+      this.#inFlight = false;
+    }
+  }
+  async doStream(options) {
+    const gen = this.#runTurn(options);
+    const stream = new ReadableStream({
+      async pull(controller) {
+        try {
+          const { value, done } = await gen.next();
+          if (done) controller.close();
+          else controller.enqueue(value);
+        } catch (err) {
+          controller.error(err);
+        }
+      },
+      async cancel() {
+        await gen.return();
+      }
+    });
+    return { stream };
+  }
+  async doGenerate(options) {
+    const content = [];
+    const textBuf = /* @__PURE__ */ new Map();
+    const reasoningBuf = /* @__PURE__ */ new Map();
+    let usage = EMPTY_USAGE;
+    let finishReason = {
+      unified: "stop",
+      raw: void 0
+    };
+    const warnings = [];
+    for await (const part of this.#runTurn(options)) {
+      switch (part.type) {
+        case "stream-start":
+          warnings.push(...part.warnings);
+          break;
+        case "text-start":
+          textBuf.set(part.id, "");
+          break;
+        case "text-delta":
+          textBuf.set(part.id, (textBuf.get(part.id) ?? "") + part.delta);
+          break;
+        case "text-end": {
+          const t = textBuf.get(part.id) ?? "";
+          if (t.length > 0) content.push({ type: "text", text: t });
+          textBuf.delete(part.id);
+          break;
+        }
+        case "reasoning-start":
+          reasoningBuf.set(part.id, "");
+          break;
+        case "reasoning-delta":
+          reasoningBuf.set(part.id, (reasoningBuf.get(part.id) ?? "") + part.delta);
+          break;
+        case "reasoning-end": {
+          const t = reasoningBuf.get(part.id) ?? "";
+          if (t.length > 0) content.push({ type: "reasoning", text: t });
+          reasoningBuf.delete(part.id);
+          break;
+        }
+        case "tool-call":
+        case "tool-result":
+        case "source":
+        case "file":
+          content.push(part);
+          break;
+        case "finish":
+          usage = part.usage;
+          finishReason = part.finishReason;
+          break;
+        case "error":
+          throw part.error instanceof Error ? part.error : new CoderChatError({ message: String(part.error) });
+        default:
+          break;
+      }
+    }
+    return { content, finishReason, usage, warnings };
+  }
+};
+
+// src/agent/coder-agent.ts
+var DEFAULT_STOP = stepCountIs(64);
+var CoderAgent = class {
+  version = "agent-v1";
+  #client;
+  #model;
+  #inner;
+  constructor(settings) {
+    if (settings.client) {
+      this.#client = settings.client;
+    } else if (settings.baseUrl && settings.token) {
+      this.#client = new CoderChatClient({
+        baseUrl: settings.baseUrl,
+        token: settings.token,
+        fetch: settings.fetch,
+        webSocketFactory: settings.webSocketFactory
+      });
+    } else {
+      throw new CoderAgentError(
+        "CoderAgent requires either `client` or both `baseUrl` and `token`."
+      );
+    }
+    this.#model = new CoderLanguageModel({
+      client: this.#client,
+      organizationId: settings.organizationId,
+      model: settings.model,
+      workspaceId: settings.workspaceId,
+      mcpServerIds: settings.mcpServerIds,
+      planMode: settings.planMode,
+      chatId: settings.chatId
+    });
+    this.#inner = new ToolLoopAgent({
+      model: this.#model,
+      id: settings.id,
+      instructions: settings.instructions,
+      tools: settings.tools,
+      toolChoice: settings.toolChoice,
+      stopWhen: settings.stopWhen ?? DEFAULT_STOP,
+      maxRetries: settings.maxRetries ?? 0
+    });
+  }
+  get id() {
+    return this.#inner.id;
+  }
+  get tools() {
+    return this.#inner.tools;
+  }
+  /** The underlying chatd client. */
+  get client() {
+    return this.#client;
+  }
+  /** The current chatd chat id, once a turn has started. */
+  get chatId() {
+    return this.#model.chatId;
+  }
+  generate(options) {
+    return this.#inner.generate(options);
+  }
+  stream(options) {
+    return this.#inner.stream(options);
+  }
+  // --- session helpers ------------------------------------------------------
+  /** Start a fresh chatd chat on the next turn. */
+  resetSession() {
+    this.#model.resetSession();
+  }
+  /** Interrupt the in-flight generation, if any. */
+  async interrupt() {
+    const id = this.#model.chatId;
+    if (id) await this.#client.interruptChat(id);
+  }
+  /** Archive the underlying chat (safe cleanup; hides it from listings). */
+  async archive() {
+    const id = this.#model.chatId;
+    if (id) await this.#client.archiveChat(id);
+  }
+};
+export {
+  CoderAgent,
+  CoderAgentError,
+  CoderApiError,
+  CoderChatClient,
+  CoderChatError,
+  CoderLanguageModel,
+  TurnTranslator,
+  classifyTurnAction,
+  dynamicToolNames,
+  extractSystemPrompt,
+  streamChatEvents,
+  toolsToDynamicTools
+};
+//# sourceMappingURL=index.js.map