@agentproto/adapter-claude-sdk 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 agentproto contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+# @agentproto/adapter-claude-sdk
+
+First-party agentproto adapter that runs **Claude Code's agent harness as a
+library** — the Claude Agent SDK's headless `query()` async generator — behind
+an AIP-44 ACP server. The daemon spawns it like any other agent-CLI arm; a user
+can launch it standalone via `agentproto-claude-sdk acp`.
+
+I/O stays **100% Anthropic-native**: the SDK's message stream is relayed to ACP
+`session/update`s with no translation of the model I/O.
+
+## Why wrap the SDK directly?
+
+The `@agentproto/adapter-claude-code` adapter wraps the third-party
+`@agentclientprotocol/claude-agent-acp` bridge. Driving the SDK directly instead
+buys us:
+
+- **Clean model pinning** — `options.model`, no spawn-arg rejection (issue #186).
+- **Native usage telemetry** — a `usage_update` per turn (tokens + cost).
+- **Custom base URL** — `base_url` → `ANTHROPIC_BASE_URL`, so the same
+  Anthropic-native harness can front real Anthropic, Bedrock/Vertex/Azure, or an
+  Anthropic-compatible gateway (LiteLLM / claude-code-router). Gateway-side
+  translation is out of scope.
+
+## Usage
+
+```bash
+# Spawned by the daemon as the `claude-sdk` arm, or standalone:
+agentproto-claude-sdk acp [--model claude-opus-4-8] \
+  [--base-url https://gateway.example/v1] [--auth-token <token>] [--thinking]
+```
+
+Auth is read from the spawn env: `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN`,
+or `CLAUDE_CODE_USE_BEDROCK` / `CLAUDE_CODE_USE_VERTEX` / `CLAUDE_CODE_USE_FOUNDRY`.
+
+## Options (AIP-45 manifest)
+
+| id           | type    | applied as                                              |
+| ------------ | ------- | ------------------------------------------------------- |
+| `model`      | string  | `--model <id>` → SDK `options.model`                    |
+| `base_url`   | string  | `ANTHROPIC_BASE_URL` in the child env (see below)       |
+| `auth_token` | string  | `ANTHROPIC_AUTH_TOKEN` in the child env (`Bearer` auth) |
+| `thinking`   | boolean | `--thinking` → SDK `options.thinking = { type: enabled }` |
+
+Injected MCP servers (`session/new.mcpServers`) forward to SDK
+`options.mcpServers`, so the daemon can mount a scoped toolset like any other
+arm.
+
+### Anthropic-compatible gateways
+
+`base_url` + `auth_token` point one spawn at an Anthropic-compatible gateway
+with a per-spawn Bearer key (the ambient `ANTHROPIC_API_KEY` is for real
+Anthropic). `auth_token` becomes `ANTHROPIC_AUTH_TOKEN`, which the SDK sends as
+`Authorization: Bearer <token>` — accepted by Moonshot, OpenRouter, and DeepSeek.
+The token value is never logged.
+
+When `base_url` is set the adapter enters **gateway mode**: it pins every model
+tier the harness might internally request — `ANTHROPIC_MODEL`,
+`ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`,
+`ANTHROPIC_DEFAULT_HAIKU_MODEL`, `ANTHROPIC_SMALL_FAST_MODEL` — to the resolved
+`model`. Without this, a single-model gateway (e.g. Moonshot serving only
+`kimi-k2.7-code`) rejects the harness's background `claude-haiku-*` requests.
+Native Anthropic (no `base_url`) leaves tier routing untouched.
+
+Verified live: Moonshot `https://api.moonshot.ai/anthropic` +
+`model=kimi-k2.7-code`, and OpenRouter `https://openrouter.ai/api/v1`, both
+return valid Anthropic Messages format under `Authorization: Bearer`.
+
+### Gateway presets (modes)
+
+So you don't hand-type the base URL each spawn, three modes pre-wire the gateway
+endpoint (`base_url`/`auth_token`/`thinking` still work manually for anything
+else):
+
+| mode        | pre-wires                                                        | you supply                          |
+| ----------- | --------------------------------------------------------------- | ----------------------------------- |
+| `default`   | nothing — native Anthropic                                       | `ANTHROPIC_API_KEY`                 |
+| `moonshot`  | `ANTHROPIC_BASE_URL` + `model=kimi-k2.7-code` + `--thinking`     | `auth_token` (Moonshot key)         |
+| `openrouter`| `ANTHROPIC_BASE_URL`                                             | `model` (slug) + `auth_token` (key) |
+| `deepseek`  | `ANTHROPIC_BASE_URL` + `model=deepseek-v4-pro`                   | `auth_token` (DeepSeek key)         |
+
+`mode: moonshot` is a one-pick Kimi run; override `model` for another Moonshot
+model. `mode: openrouter` still needs a `model` (e.g. `z-ai/glm-5.2`,
+`deepseek/deepseek-v4-pro`, `moonshotai/kimi-k2`). `mode: deepseek` defaults to
+`deepseek-v4-pro`; override `model` for `deepseek-v4-flash`. The `auth_token`
+is the gateway key — the ambient `ANTHROPIC_API_KEY` stays for real Anthropic.
+DeepSeek isn't thinking-gated, so unlike `moonshot` no `--thinking` is forced.
+
+### Extended thinking
+
+Some gateway models are thinking-gated — `kimi-k2.7-code` rejects any request
+that omits `thinking` (`invalid thinking: only type=enabled is allowed for this
+model`). The SDK's `query()` exposes `Options.thinking?: ThinkingConfig`
+(`{ type: 'adaptive' } | { type: 'enabled', budgetTokens? } | { type:
+'disabled' }`); the `thinking` boolean option pass-through sets
+`options.thinking = { type: 'enabled' }`. Off by default so native Claude models
+keep their own (adaptive) thinking behaviour.
+
+See [`claude-sdk.ACP.md`](./claude-sdk.ACP.md) for the full wire profile.

package/claude-sdk.ACP.md

@@ -0,0 +1,87 @@
+# claude-sdk — ACP wire profile
+
+AIP-44 ACP profile for the first-party Claude Agent SDK adapter. The agent side
+is implemented in `src/acp-host.ts` against `@agentclientprotocol/sdk`'s
+`AgentSideConnection`, spawned over stdio (`agentproto-claude-sdk acp`). It
+drives the Claude Agent SDK's headless `query()` and relays the SDK's native
+message stream as ACP `session/update`s. I/O stays 100% Anthropic-native.
+
+## Lifecycle
+
+| Method            | Behaviour                                                        |
+| ----------------- | --------------------------------------------------------------- |
+| `initialize`      | Returns `PROTOCOL_VERSION` + `agentCapabilities.loadSession=false`. |
+| `authenticate`    | No-op (`{}`). Auth is read from the spawn env by the SDK.       |
+| `session/new`     | Allocates a UUID session id and records the injected `mcpServers`. The id is PINNED via the SDK's `options.sessionId` on the first turn, so the ACP and SDK session ids are the same value. |
+| `session/prompt`  | Extracts the user's text content blocks, drives `query({ prompt, options })`, and relays the SDK stream: `assistant` text → `agent_message_chunk`, `tool_use` → `tool_call`, `tool_result` → `tool_call_update`, `result` → `usage_update`. Resolves with `stopReason: end_turn` (or `cancelled` / `refusal`). |
+| `session/cancel`  | Aborts the in-flight turn (via the SDK `options.abortController`). |
+
+## Message mapping
+
+| SDK message (`SDKMessage`)        | ACP `session/update`     |
+| --------------------------------- | ------------------------ |
+| `assistant` → `text` block        | `agent_message_chunk`    |
+| `assistant` → `tool_use` block    | `tool_call` (in_progress)|
+| `user` → `tool_result` block      | `tool_call_update`       |
+| `result`                          | `usage_update` (tokens + cost) |
+| `system` / `init`                 | (captures `session_id`; not surfaced) |
+
+## Usage telemetry
+
+The `result` message's native Anthropic usage is mapped to the runtime's
+`usage_update` shape: `size` (context window from `modelUsage`), `used` (tokens
+in context), `cost` (from `total_cost_usd`, in USD), and the `tokensIn` /
+`tokensOut` extension.
+
+## Resume
+
+Turns resume via the SDK session store: the first turn pins the session UUID
+(`options.sessionId`), later turns continue it (`options.resume`). There is no
+ACP `session/load` replay surface, so `loadSession` is advertised as `false`.
+
+## Models
+
+`model` is a Claude model id (e.g. `claude-opus-4-8`, `claude-sonnet-5`,
+`claude-haiku-4-5-20251001`), applied per spawn via the `--model` arg (manifest
+`model` option's `bin_args_template`) → SDK `options.model`. Default:
+`claude-haiku-4-5-20251001`.
+
+## Base URL / providers
+
+`base_url` sets `ANTHROPIC_BASE_URL` in the child env (manifest `base_url`
+option's `env` template), keeping the harness Anthropic-native while pointing at
+real Anthropic, Bedrock/Vertex/Azure, or an Anthropic-compatible gateway.
+`CLAUDE_CODE_USE_BEDROCK` / `CLAUDE_CODE_USE_VERTEX` / `CLAUDE_CODE_USE_FOUNDRY`
+pass through from the spawn env.
+
+When `base_url` is set the adapter enters **gateway mode** and pins every
+internal model tier the harness may request to the resolved `model`:
+`ANTHROPIC_MODEL`, `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`,
+`ANTHROPIC_DEFAULT_HAIKU_MODEL`, `ANTHROPIC_SMALL_FAST_MODEL`. This stops a
+single-model gateway (e.g. Moonshot serving only `kimi-k2.7-code`) from
+receiving a background `claude-haiku-*` request it can't serve. Native Anthropic
+(no `base_url`) leaves tier routing untouched.
+
+## Auth / secrets
+
+`ANTHROPIC_API_KEY` or `ANTHROPIC_AUTH_TOKEN` on the spawn env (direct or via an
+Anthropic-compatible gateway), or the cloud-provider toggles above. No ACP-level
+auth handshake. The `auth_token` option sets `ANTHROPIC_AUTH_TOKEN` in the child
+env (manifest `auth_token` option's `env` template) — the SDK sends it as
+`Authorization: Bearer <token>`, letting one spawn target a gateway (Moonshot,
+OpenRouter, DeepSeek) with a per-spawn Bearer key. The token value is never logged.
+
+## Thinking
+
+`thinking` (boolean) appends `--thinking`, which sets SDK
+`options.thinking = { type: "enabled" }` (`Options.thinking?: ThinkingConfig`).
+Required by thinking-gated gateway models such as `kimi-k2.7-code`, which reject
+a request that omits `thinking`. Off by default so native Claude models keep
+their own adaptive thinking.
+
+## Permissions
+
+Tool-permission handling defaults to `bypassPermissions` (with the required
+danger flag) so the arm can act unattended inside the daemon's sandbox. Override
+via `CLAUDE_SDK_PERMISSION_MODE` (`default` | `acceptEdits` | `bypassPermissions`
+| `plan` | `dontAsk` | `auto`).

package/dist/chunk-DW2G2NIH.mjs

@@ -0,0 +1,430 @@
+import { PROTOCOL_VERSION, ndJsonStream, AgentSideConnection } from '@agentclientprotocol/sdk';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { Writable, Readable } from 'stream';
+
+/**
+ * @agentproto/adapter-claude-sdk v0.1.0-alpha
+ * First-party agentproto adapter: Claude Agent SDK headless query() -> ACP server.
+ */
+
+// src/options.ts
+var DEFAULT_MODEL = "claude-haiku-4-5-20251001";
+var CLOUD_PROVIDER_REDIRECT_TOGGLES = [
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "CLAUDE_CODE_USE_FOUNDRY",
+  "CLAUDE_CODE_USE_ANTHROPIC_AWS",
+  "CLAUDE_CODE_USE_MANTLE",
+  "CLAUDE_CODE_USE_GATEWAY"
+];
+var DEFAULT_IDLE_TIMEOUT_MS = 9e4;
+function mapAcpMcpServers(servers) {
+  const out = {};
+  for (const server of servers ?? []) {
+    if ("type" in server && server.type === "http") {
+      out[server.name] = {
+        type: "http",
+        url: server.url,
+        headers: flattenPairs(server.headers)
+      };
+    } else if ("type" in server && server.type === "sse") {
+      out[server.name] = {
+        type: "sse",
+        url: server.url,
+        headers: flattenPairs(server.headers)
+      };
+    } else {
+      out[server.name] = {
+        type: "stdio",
+        command: server.command,
+        args: server.args,
+        env: flattenPairs(server.env)
+      };
+    }
+  }
+  return out;
+}
+function flattenPairs(pairs) {
+  const out = {};
+  for (const pair of pairs ?? []) out[pair.name] = pair.value;
+  return out;
+}
+function buildQueryOptions(args) {
+  const { config, abortController, sessionId, resume, mcpServers } = args;
+  const model = config.model ?? DEFAULT_MODEL;
+  const baseEnv = args.env ?? process.env;
+  const env = { ...baseEnv };
+  if (config.baseUrl) {
+    env.ANTHROPIC_BASE_URL = config.baseUrl;
+    const gatewayKeyEnv = baseEnv.CLAUDE_SDK_GATEWAY_KEY_ENV;
+    const bearer = config.authToken ?? baseEnv.ANTHROPIC_AUTH_TOKEN ?? (gatewayKeyEnv ? baseEnv[gatewayKeyEnv] : void 0);
+    delete env.ANTHROPIC_API_KEY;
+    if (bearer) env.ANTHROPIC_AUTH_TOKEN = bearer;
+    else delete env.ANTHROPIC_AUTH_TOKEN;
+    for (const key of CLOUD_PROVIDER_REDIRECT_TOGGLES) delete env[key];
+    env.ANTHROPIC_MODEL = model;
+    env.ANTHROPIC_DEFAULT_OPUS_MODEL = model;
+    env.ANTHROPIC_DEFAULT_SONNET_MODEL = model;
+    env.ANTHROPIC_DEFAULT_HAIKU_MODEL = model;
+    env.ANTHROPIC_SMALL_FAST_MODEL = model;
+  } else if (config.authToken) {
+    env.ANTHROPIC_AUTH_TOKEN = config.authToken;
+  }
+  const options = {
+    model,
+    abortController,
+    permissionMode: config.permissionMode ?? "bypassPermissions",
+    // Required companion to bypassPermissions — this arm runs unattended.
+    allowDangerouslySkipPermissions: true,
+    // Hermetic embed: don't silently pull in filesystem settings / CLAUDE.md;
+    // the daemon owns the configuration surface.
+    settingSources: [],
+    // Stream partial (`stream_event`) messages so a long thinking / generation
+    // stretch is observable live instead of surfacing only at message
+    // boundaries. Two things depend on it: (1) the daemon's output ring — the
+    // mapped text/thinking deltas keep `lastOutputAt` advancing during a long
+    // busy turn instead of freezing until the next tool boundary; and (2) the
+    // turn watchdog (acp-host `#nextMessage`), which resets on every SDK
+    // message — without partials, a >90s thinking block (kimi-k2.7-code with
+    // `--thinking`) yields NO message and the idle watchdog wrongly aborts a
+    // healthy turn. See message-map's `streamEventUpdates`.
+    includePartialMessages: true,
+    env,
+    ...config.cwd ? { cwd: config.cwd } : {},
+    ...sessionId ? { sessionId } : {},
+    ...resume ? { resume } : {}
+  };
+  if (config.thinking) options.thinking = { type: "enabled" };
+  const mapped = mapAcpMcpServers(mcpServers);
+  if (Object.keys(mapped).length > 0) options.mcpServers = mapped;
+  return options;
+}
+
+// src/message-map.ts
+function toolKindForClaudeTool(name) {
+  switch (name) {
+    case "Read":
+    case "NotebookRead":
+      return "read";
+    case "Write":
+    case "Edit":
+    case "MultiEdit":
+    case "NotebookEdit":
+      return "edit";
+    case "Bash":
+    case "BashOutput":
+    case "KillBash":
+      return "execute";
+    case "Grep":
+    case "Glob":
+      return "search";
+    case "WebFetch":
+    case "WebSearch":
+      return "fetch";
+    case "Task":
+      return "think";
+    default:
+      return "other";
+  }
+}
+function stringField(input, key) {
+  if (input && typeof input === "object" && key in input) {
+    const value = Reflect.get(input, key);
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function toolCallTitle(name, input) {
+  const hint = stringField(input, "command") ?? stringField(input, "file_path") ?? stringField(input, "path") ?? stringField(input, "pattern") ?? stringField(input, "url");
+  return hint ? `${name}: ${hint}` : name;
+}
+function assistantMessageUpdates(msg, suppressText = false) {
+  const updates = [];
+  for (const block of msg.message.content) {
+    if (block.type === "text") {
+      if (suppressText || !block.text) continue;
+      updates.push({
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: block.text }
+      });
+    } else if (block.type === "tool_use") {
+      updates.push({
+        sessionUpdate: "tool_call",
+        toolCallId: block.id,
+        title: toolCallTitle(block.name, block.input),
+        kind: toolKindForClaudeTool(block.name),
+        status: "in_progress",
+        rawInput: block.input
+      });
+    }
+  }
+  return updates;
+}
+function streamEventUpdates(msg) {
+  const event = msg.event;
+  if (stringField(event, "type") !== "content_block_delta") return [];
+  const delta = event && typeof event === "object" ? Reflect.get(event, "delta") : void 0;
+  switch (stringField(delta, "type")) {
+    case "text_delta": {
+      const text = stringField(delta, "text");
+      return text ? [
+        {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text }
+        }
+      ] : [];
+    }
+    case "thinking_delta": {
+      const thinking = stringField(delta, "thinking");
+      return thinking ? [
+        {
+          sessionUpdate: "agent_thought_chunk",
+          content: { type: "text", text: thinking }
+        }
+      ] : [];
+    }
+    default:
+      return [];
+  }
+}
+function userMessageUpdates(msg) {
+  const content = msg.message.content;
+  if (typeof content === "string") return [];
+  const updates = [];
+  for (const block of content) {
+    if (block.type !== "tool_result") continue;
+    updates.push({
+      sessionUpdate: "tool_call_update",
+      toolCallId: block.tool_use_id,
+      status: block.is_error ? "failed" : "completed",
+      rawOutput: block.content
+    });
+  }
+  return updates;
+}
+function contextWindowOf(msg) {
+  let size = 0;
+  for (const usage of Object.values(msg.modelUsage)) {
+    if (usage.contextWindow > size) size = usage.contextWindow;
+  }
+  return size;
+}
+function resultUsageUpdate(msg) {
+  const u = msg.usage;
+  const cacheRead = u.cache_read_input_tokens ?? 0;
+  const cacheCreate = u.cache_creation_input_tokens ?? 0;
+  const tokensIn = u.input_tokens + cacheRead + cacheCreate;
+  const tokensOut = u.output_tokens;
+  return {
+    sessionUpdate: "usage_update",
+    size: contextWindowOf(msg),
+    used: tokensIn + tokensOut,
+    cost: { amount: msg.total_cost_usd, currency: "USD" },
+    tokensIn,
+    tokensOut
+  };
+}
+function sdkMessageToUpdates(msg, opts = {}) {
+  switch (msg.type) {
+    case "stream_event":
+      return streamEventUpdates(msg);
+    case "assistant":
+      return assistantMessageUpdates(msg, opts.suppressAssistantText ?? false);
+    case "user":
+      return userMessageUpdates(msg);
+    case "result":
+      return [resultUsageUpdate(msg)];
+    default:
+      return [];
+  }
+}
+function systemInitSessionId(msg) {
+  if (msg.type === "system" && isInit(msg)) return msg.session_id;
+  return null;
+}
+function isInit(msg) {
+  return msg.subtype === "init";
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var TurnStalledError = class extends Error {
+  constructor(idleMs) {
+    super(
+      `claude-sdk: query() produced no message for ${idleMs}ms \u2014 the model stream stalled and never delivered a terminal result. Aborting the turn to avoid a silent, zero-output hang. If this was a slow but healthy turn, raise CLAUDE_SDK_IDLE_TIMEOUT_MS.`
+    );
+    this.idleMs = idleMs;
+    this.name = "TurnStalledError";
+  }
+  idleMs;
+};
+function promptText(params) {
+  return params.prompt.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+}
+var ClaudeSdkAcpAgent = class {
+  #conn;
+  #config;
+  #query;
+  #sessions = /* @__PURE__ */ new Map();
+  constructor(conn, config = {}, query$1 = query) {
+    this.#conn = conn;
+    this.#config = config;
+    this.#query = query$1;
+  }
+  async initialize(_params) {
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      agentCapabilities: {
+        // Turns resume via the SDK's session store (options.resume), keyed by
+        // the pinned session id — but there is no ACP `session/load` replay
+        // surface, so we advertise loadSession: false.
+        loadSession: false
+      }
+    };
+  }
+  async authenticate(_params) {
+    return {};
+  }
+  async newSession(params) {
+    const id = crypto.randomUUID();
+    this.#sessions.set(id, {
+      id,
+      mcpServers: params.mcpServers ?? [],
+      started: false,
+      sdkSessionId: null,
+      prompt: null
+    });
+    return { sessionId: id };
+  }
+  async prompt(params) {
+    const session = this.#sessions.get(params.sessionId);
+    if (!session) throw new Error(`unknown session ${params.sessionId}`);
+    session.prompt?.abort();
+    const ac = new AbortController();
+    session.prompt = ac;
+    const text = promptText(params);
+    try {
+      const options = buildQueryOptions({
+        config: this.#config,
+        abortController: ac,
+        // First turn pins the id; later turns resume the SDK session.
+        ...session.started ? { resume: session.sdkSessionId ?? session.id } : { sessionId: session.id },
+        mcpServers: session.mcpServers
+      });
+      session.started = true;
+      await this.#drive(session, text, options, ac);
+    } catch (err) {
+      if (ac.signal.aborted && !(err instanceof TurnStalledError)) {
+        session.prompt = null;
+        return { stopReason: "cancelled" };
+      }
+      await this.#conn.sessionUpdate({
+        sessionId: session.id,
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: {
+            type: "text",
+            text: `
+[claude-sdk error] ${errorMessage(err)}
+`
+          }
+        }
+      });
+      session.prompt = null;
+      return { stopReason: "refusal" };
+    }
+    const cancelled = ac.signal.aborted;
+    session.prompt = null;
+    return { stopReason: cancelled ? "cancelled" : "end_turn" };
+  }
+  async cancel(params) {
+    this.#sessions.get(params.sessionId)?.prompt?.abort();
+  }
+  /**
+   * The daemon applies operator options (model, base_url) at spawn — via the
+   * manifest's `bin_args_template` / `env` — then also calls this ACP config
+   * hook (its default "config apply" path). Everything is already in effect,
+   * so this reports our (empty) runtime-configurable set. Without it the spawn
+   * fails with "Method not found: session/set_config_option".
+   */
+  async setSessionConfigOption(_params) {
+    return { configOptions: [] };
+  }
+  /** No agent-specific modes; accept and ignore so a host that sets one
+   *  doesn't error. */
+  async setSessionMode(_params) {
+    return {};
+  }
+  /** Drive one `query()` turn: adopt the SDK session id from `init`, then map
+   *  each SDK message to ACP updates and relay them.
+   *
+   *  Iteration is driven manually (rather than `for await`) so an idle watchdog
+   *  can bound the wait for each next message. If the SDK child wedges mid-turn
+   *  — stops yielding messages without delivering the terminal `result` and
+   *  without closing (e.g. a conflicting host env leaked into the subprocess) —
+   *  the watchdog aborts the turn with a {@link TurnStalledError} instead of
+   *  awaiting forever with zero output. A defensive safety net; a well-behaved
+   *  turn (Moonshot included, under a clean env) reaches `result` and this
+   *  never fires. */
+  async #drive(session, text, options, ac) {
+    const idleMs = this.#config.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+    const iterator = this.#query({ prompt: text, options })[Symbol.asyncIterator]();
+    let sawPartial = false;
+    try {
+      while (!ac.signal.aborted) {
+        const next = await this.#nextMessage(iterator, idleMs, ac);
+        if (next.done) break;
+        const msg = next.value;
+        const sdkId = systemInitSessionId(msg);
+        if (sdkId) session.sdkSessionId = sdkId;
+        if (msg.type === "stream_event") sawPartial = true;
+        for (const update of sdkMessageToUpdates(msg, {
+          suppressAssistantText: sawPartial
+        })) {
+          await this.#conn.sessionUpdate({ sessionId: session.id, update });
+        }
+      }
+    } finally {
+      void Promise.resolve(iterator.return?.(void 0)).catch(() => void 0);
+    }
+  }
+  /**
+   * Await the next SDK message, but no longer than `idleMs`. On timeout the
+   * turn is treated as stalled: abort the shared controller (tearing down the
+   * SDK subprocess) and reject with {@link TurnStalledError}. `idleMs <= 0`
+   * disables the watchdog and awaits indefinitely (legacy behaviour).
+   */
+  async #nextMessage(iterator, idleMs, ac) {
+    const next = iterator.next();
+    if (idleMs <= 0) return next;
+    void next.catch(() => void 0);
+    let timer;
+    const watchdog = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        ac.abort();
+        reject(new TurnStalledError(idleMs));
+      }, idleMs);
+      timer.unref();
+    });
+    try {
+      return await Promise.race([next, watchdog]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+};
+function runAcpOverStdio(config = {}) {
+  const toClient = Writable.toWeb(process.stdout);
+  const fromClient = Readable.toWeb(
+    process.stdin
+  );
+  const stream = ndJsonStream(toClient, fromClient);
+  return new AgentSideConnection(
+    (conn) => new ClaudeSdkAcpAgent(conn, config),
+    stream
+  );
+}
+
+export { ClaudeSdkAcpAgent, DEFAULT_MODEL, assistantMessageUpdates, buildQueryOptions, mapAcpMcpServers, promptText, resultUsageUpdate, runAcpOverStdio, sdkMessageToUpdates, systemInitSessionId, toolCallTitle, toolKindForClaudeTool, userMessageUpdates };
+//# sourceMappingURL=chunk-DW2G2NIH.mjs.map
+//# sourceMappingURL=chunk-DW2G2NIH.mjs.map