@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.1

package/src/adapters/agy.js

@@ -0,0 +1,297 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { AGY_NATIVE_LIMITATION } from "../run-permissions.js";
+import { join } from "node:path";
+import { agyCredentialFailure, inspectAgyAuthLog } from "./agy-auth.js";
+import { classifyError, cliErrorLine, resetFromText } from "./errors.js";
+import { captureOutput, commandExists, describeFailure, processErrorKind, startJsonlProcess, stringify, truncate, unknownEvents } from "./process.js";
+import { STEP_TIMEOUT_MS } from "../config.js";
+import { childEnv } from "../env.js";
+import { agyIsolationProblem, agyManagedOptionsProblem, inspectAgyIsolationRuntime, prepareAgyIsolation, discoverIsolatedAgyModels, AGY_FILE_ONLY_LIMITATION, AGY_ISOLATION_VERSION } from "./agy-isolation.js";
+function sandboxGitEnv() {
+  return {
+    ...childEnv(),
+    GIT_CONFIG_GLOBAL: "/dev/null",
+    GIT_CONFIG_COUNT: "1",
+    GIT_CONFIG_KEY_0: "core.excludesFile",
+    GIT_CONFIG_VALUE_0: "/dev/null"
+  };
+}
+function skipPermissions() {
+  return process.env.CODEFLOW_AGY_SKIP_PERMISSIONS !== "0";
+}
+function createAgyAdapter(prepare = async (opts) => prepareAgyIsolation(opts.cwd, opts.mode, await inspectAgyIsolationRuntime())) {
+  return {
+    id: "agy",
+    displayName: "Antigravity CLI",
+    binary: "agy",
+    available: () => commandExists("agy"),
+    managedAvailability: agyIsolationProblem,
+    managedLimitations: [AGY_FILE_ONLY_LIMITATION],
+    async discoverModels(context) {
+      if (context?.agentContainer) throw new Error("Antigravity container discovery is unverified");
+      if (context?.isolatedAgy) return discoverIsolatedAgyModels();
+      const catalog = await discoverNativeAgyModels();
+      return { ...catalog, efforts: [], models: catalog.models.map((model) => ({ ...model, efforts: void 0 })), discovery: { source: "agy models", confidence: "reported", verifiedAt: Date.now() } };
+    },
+    async catalog() {
+      const out = await captureOutput("agy", ["models"], 45e3);
+      const models = out.split("\n").map((line) => line.split("	")).filter((cols) => cols.length >= 2 && cols[0].trim()).map(([id, label]) => ({ id: id.trim(), label: label.trim() }));
+      return { models, efforts: ["low", "medium", "high", "xhigh", "max"], allowCustom: true };
+    },
+    async run(opts, onEvent) {
+      const native = opts.permissions?.implementation === "agy-native-v1";
+      const managed = !!opts.permissions;
+      let nativeScratch;
+      let isolation;
+      if (opts.permissions) {
+        const problem = native ? agyNativeOptionsProblem(opts) : agyManagedOptionsProblem(opts);
+        if (problem) return { ok: false, finalText: "", errorKind: "cli_incompatible", error: problem };
+        if (opts.resumeSessionId) return { ok: false, finalText: "", errorKind: "session_not_found", error: "Managed Antigravity requires a fresh turn with portable context" };
+        try {
+          if (!native) isolation = await prepare(opts);
+        } catch {
+          return { ok: false, finalText: "", errorKind: "cli_incompatible", error: "Could not establish the verified Antigravity isolation boundary. macOS, CLI 1.4.4 and an existing Keychain login/security cache are required. No permissive fallback was used." };
+        }
+      }
+      try {
+        if (native) {
+          nativeScratch = await mkdtemp(join(tmpdir(), "codeflow-agy-native-"));
+          onEvent({ kind: "status", text: AGY_NATIVE_LIMITATION });
+        }
+        if (isolation) onEvent({ kind: "status", text: `${AGY_FILE_ONLY_LIMITATION} Executor: ${AGY_ISOLATION_VERSION}; CLI 1.4.4.` });
+        if (opts.agentContainer) onEvent({ kind: "status", text: `Antigravity runs in Docker image ${opts.agentContainer.image}. Team messages and memory are provided at turn boundaries.` });
+        if (opts.teamTools) onEvent({ kind: "status", text: "Live MCP collaboration is unavailable in this Antigravity adapter; team messages and memory are provided at turn boundaries." });
+        const timeoutMs = typeof opts.timeoutMs === "number" && Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0 ? opts.timeoutMs : STEP_TIMEOUT_MS;
+        const args = [
+          "--input-format",
+          "stream-json",
+          "--output-format",
+          "stream-json",
+          "--print-timeout",
+          `${Math.max(1, Math.ceil(timeoutMs / 6e4))}m`
+        ];
+        const sandboxed = !native && (!!isolation || !(opts.mode === "write" && opts.trust === "full"));
+        if (sandboxed) args.push("--sandbox");
+        if (opts.resumeSessionId) args.push("--conversation", opts.resumeSessionId);
+        if (opts.model) args.push("--model", opts.model);
+        if (opts.effort) args.push("--effort", opts.effort);
+        if (opts.jsonSchema) args.push("--json-schema", JSON.stringify(opts.jsonSchema));
+        const nativeLog = isolation || nativeScratch ? join(isolation?.paths.scratch ?? nativeScratch, "native-auth.log") : void 0;
+        if (isolation) args.push("--agent", "codeflow-isolated", "--disable-slash-commands", "--log-file", nativeLog);
+        else {
+          if (nativeLog) args.push("--log-file", nativeLog);
+          if (native || skipPermissions()) args.push("--dangerously-skip-permissions");
+        }
+        let sessionId;
+        let finalText = "";
+        let streamedText = "";
+        let resultError;
+        let statusKind;
+        let sawResult = false;
+        let policyDrift = false;
+        let managedDiagnostic = "";
+        let structured;
+        const openTools = /* @__PURE__ */ new Set();
+        const unknown = unknownEvents("agy");
+        const unknownSteps = /* @__PURE__ */ new Set();
+        const proc = startJsonlProcess({
+          agentContainer: opts.agentContainer ? { config: opts.agentContainer, mode: opts.mode } : void 0,
+          command: isolation?.command ?? "agy",
+          args: [...isolation?.args ?? [], ...args],
+          input: `${JSON.stringify({ event: "user", message: { content: opts.prompt } })}
+`,
+          cwd: isolation?.paths.workspace ?? opts.cwd,
+          // Without the sandbox the agent's commands use your git config, but never code-flow's own secrets.
+          env: isolation?.env ?? (sandboxed ? sandboxGitEnv() : childEnv()),
+          signal: opts.signal,
+          timeoutMs: timeoutMs + 3e4,
+          idleTimeoutMs: opts.idleTimeoutMs,
+          onText: (line) => {
+            if (managed) managedDiagnostic = (managedDiagnostic + "\n" + line).slice(-64e3);
+            else onEvent({ kind: "status", text: line });
+          },
+          onJson: (msg) => {
+            if (policyDrift) return;
+            switch (msg.event) {
+              case "init":
+                if (msg.conversation_id && !managed) {
+                  sessionId = msg.conversation_id;
+                  onEvent({ kind: "session", sessionId: msg.conversation_id });
+                }
+                break;
+              case "step_update": {
+                const step = msg.step_update ?? {};
+                if (isolation && step.step_type === "tool" && step.tool_name && !managedAgyToolAllowed(step.tool_name, opts.mode)) {
+                  policyDrift = true;
+                  proc.kill();
+                  return;
+                }
+                if (step.text_delta) {
+                  streamedText += step.text_delta;
+                  if (!managed) onEvent({ kind: "text", text: step.text_delta });
+                }
+                if (!step.text_delta && step.step_type !== "tool" && step.step_type !== "agent_response") {
+                  const id = `${step.conversation_id ?? ""}:${step.step_index ?? step.step_type}`;
+                  if (!unknownSteps.has(id)) {
+                    unknownSteps.add(id);
+                    unknown.add(`${step.step_type ?? "(no type)"} step`);
+                  }
+                }
+                if (step.step_type === "tool" && step.tool_name) {
+                  const callId = `${step.conversation_id ?? ""}:${step.step_index ?? step.tool_name}`;
+                  if (step.state === "ACTIVE" && !openTools.has(callId)) {
+                    openTools.add(callId);
+                    onEvent({
+                      kind: "tool_call",
+                      callId,
+                      name: step.tool_name,
+                      input: truncate(stringify(step.tool_info?.parameters ?? ""), 2e3)
+                    });
+                  } else if (step.state === "DONE" || step.state === "ERROR") {
+                    if (!openTools.has(callId)) {
+                      onEvent({
+                        kind: "tool_call",
+                        callId,
+                        name: step.tool_name,
+                        input: truncate(stringify(step.tool_info?.parameters ?? ""), 2e3)
+                      });
+                    }
+                    openTools.delete(callId);
+                    const error2 = step.tool_info?.error?.message;
+                    onEvent({
+                      kind: "tool_result",
+                      callId,
+                      output: truncate(error2 ?? stringify(step.tool_info?.output ?? step.tool_info?.result ?? "done")),
+                      isError: step.state === "ERROR"
+                    });
+                  }
+                }
+                break;
+              }
+              case "result": {
+                sawResult = true;
+                proc.resultSeen();
+                const result = msg.result ?? {};
+                finalText = result.response ?? streamedText;
+                if (result.conversation_id && !managed) sessionId = result.conversation_id;
+                if (result.structured_output !== void 0) structured = result.structured_output;
+                if (result.status && result.status !== "SUCCESS") {
+                  const detail = typeof result.error === "string" ? result.error : result.error?.message;
+                  resultError = detail ? `${detail} (agy status ${result.status})` : `agy finished with status ${result.status}`;
+                  statusKind = agyStatusKind(String(result.status), detail, !!opts.resumeSessionId);
+                } else if (!finalText.trim() && result.denied_actions?.length) {
+                  const denied = result.denied_actions.map((d) => d.display_name ?? d.action).join(", ");
+                  resultError = isolation ? "Isolated Antigravity denied a tool. Assign this task to a worker with the required tools." : `agy stopped after headless mode denied: ${denied}. Allow it in permissions.allow or enable CODEFLOW_AGY_SKIP_PERMISSIONS.`;
+                }
+                onEvent({
+                  kind: "usage",
+                  inputTokens: result.usage?.input_tokens,
+                  outputTokens: result.usage?.output_tokens,
+                  cacheReadTokens: result.usage?.cached_input_tokens ?? result.usage?.cache_read_input_tokens
+                });
+                break;
+              }
+              case "user":
+                break;
+              default:
+                unknown.add(msg.event ?? msg.type);
+            }
+          }
+        });
+        const outcome = await proc.outcome;
+        const authObservation = nativeLog ? await inspectAgyAuthLog(nativeLog) : void 0;
+        if (managed && (authObservation?.credentialFailure || authObservation?.interactiveAuthObserved || agyCredentialFailure(outcome.stderr + "\n" + managedDiagnostic))) {
+          resultError = "Native authentication could not be maintained in the recorded execution mode";
+          statusKind = "auth";
+        }
+        const drift = unknown.report();
+        if (drift && !managed) onEvent({ kind: "status", text: drift });
+        if (policyDrift) {
+          const error2 = "Antigravity reported a tool outside its verified file-only policy. The worker was stopped; runtime compatibility must be reverified.";
+          onEvent({ kind: "error", message: error2 });
+          return { ok: false, finalText: "", errorKind: "cli_incompatible", error: error2 };
+        }
+        if (sawResult && !resultError && !outcome.aborted) {
+          if (managed && finalText) onEvent({ kind: "text", text: finalText });
+          return { ok: true, finalText, sessionId, structured };
+        }
+        const stopped = processErrorKind(outcome);
+        if (!sawResult && outcome.exitCode === 0 && !stopped) {
+          resultError = "agy exited without a result event. Some agy versions print nothing when stdout is a pipe; update agy, and make sure you have logged in once with an interactive `agy` session.";
+        }
+        let error = resultError ?? describeFailure("agy", outcome);
+        const own = resultError ?? cliErrorLine(outcome.stderr + (managed ? "\n" + managedDiagnostic : ""));
+        const authKind = managed ? managedAgyAuthKind(sawResult ? resultError ?? "" : outcome.stderr + "\n" + managedDiagnostic) ?? (statusKind === "auth" ? "auth" : void 0) : void 0;
+        const errorKind = stopped === "cancelled" ? stopped : authKind ?? stopped ?? statusKind ?? classifyError(own);
+        if (managed) error = native ? `Unrestricted Antigravity failed (${errorKind}). Check the existing login in its normal session, then resume. Code Flow never starts sign-in or changes credentials; native diagnostics are withheld.` : managedAgyFailure(errorKind);
+        const resetsAt = errorKind === "usage_limit" ? resetFromText(own) : void 0;
+        onEvent({ kind: "error", message: error });
+        return {
+          ok: false,
+          finalText: managed ? "" : finalText || streamedText,
+          sessionId: errorKind === "session_not_found" ? void 0 : sessionId,
+          error,
+          errorKind,
+          ...resetsAt && { resetsAt }
+        };
+      } finally {
+        await isolation?.cleanup();
+        if (nativeScratch) await rm(nativeScratch, { recursive: true, force: true });
+      }
+    }
+  };
+}
+const agyAdapter = createAgyAdapter();
+function managedAgyToolAllowed(name, mode) {
+  return ["view_file", "list_dir", "manage_task", ...mode === "write" ? ["write_to_file", "replace_file_content"] : []].includes(name);
+}
+function managedAgyAuthKind(detail) {
+  return /authentication (?:failed|timed out)|please (?:sign|log) in|invalid_grant|(?:refresh|access)[ _-]?token.{0,80}(?:expired|revoked|invalid|failed)|(?:failed|unable) to (?:retrieve|refresh).{0,40}token|(?:keyring|keychain).{0,80}(?:locked|denied|unavailable)|interaction (?:is )?not allowed/i.test(detail) || agyCredentialFailure(detail) || classifyError(detail) === "auth" ? "auth" : void 0;
+}
+function managedAgyFailure(kind) {
+  if (kind === "auth") return "Antigravity could not use or refresh the existing native login. Check or unlock it in Antigravity's normal interactive session, then resume. Code Flow will start a fresh isolated turn; permissions were not widened.";
+  if (kind === "usage_limit" || kind === "rate_limit") return `Isolated Antigravity reached a ${kind === "usage_limit" ? "usage" : "rate"} limit.`;
+  return `Isolated Antigravity failed (${kind}). Native diagnostics were withheld because they can contain authentication data. Check the CLI in its normal interactive session before resuming; no permissive fallback was used.`;
+}
+function agyStatusKind(status, detail, resuming) {
+  if (/RESOURCE_EXHAUSTED|QUOTA/i.test(status)) {
+    const text = detail ?? "";
+    if (/\bper (?:minute|second|min\b)|\brate\b/i.test(text)) return "rate_limit";
+    return /daily|per day|\bplan\b|usage limit|quota (?:exceeded|reached|exhausted)|exceeded (?:your|the) [\w -]{0,30}quota/i.test(text) ? "usage_limit" : "rate_limit";
+  }
+  if (/RATE/i.test(status)) return "rate_limit";
+  if (/UNAUTHENTICATED|AUTH|LOGIN|SIGN_?IN/i.test(status)) return "auth";
+  if (resuming && /NOT_FOUND/i.test(status)) return "session_not_found";
+  if (/UNAVAILABLE|INTERNAL|OVERLOAD/i.test(status)) return "transient";
+  if (/DEADLINE|TIMEOUT/i.test(status)) return "timeout";
+  if (/CANCEL/i.test(status)) return "cancelled";
+  return void 0;
+}
+function agyNativeOptionsProblem(opts) {
+  const p = opts.permissions;
+  if (!p || p.provider !== "agy" || p.implementation !== "agy-native-v1" || p.isolation !== "none" || p.nativeDelegation !== true || p.commandNetwork !== "allowed" || p.externalTools !== "provider-configured" || p.trust !== "full" || opts.trust !== "full" || p.mode !== opts.mode || !["read", "write"].includes(p.mode) || !["managed", "none"].includes(p.delegation) || p.toolApprovals !== false || opts.interactiveApprovals || !Array.isArray(p.required) || p.required.length || !Number.isSafeInteger(p.policyRevision) || p.policyRevision < 1 || opts.agentContainer) return "Antigravity options do not match an explicit unrestricted permission receipt";
+}
+async function discoverNativeAgyModels() {
+  const scratch = await mkdtemp(join(tmpdir(), "codeflow-agy-models-"));
+  try {
+    const log = join(scratch, "native-auth.log");
+    const output = await captureOutput("agy", ["--log-file", log, "models"], 45e3);
+    const auth = await inspectAgyAuthLog(log);
+    if (auth.credentialFailure || auth.interactiveAuthObserved || agyCredentialFailure(output) || managedAgyAuthKind(output)) throw new Error("Native login unavailable");
+    const models = output.split("\n").map((line) => line.split("	")).filter((cols) => cols.length >= 2 && cols[0].trim()).map(([id, label]) => ({ id: id.trim(), label: label.trim() }));
+    if (!models.length) throw new Error("No models");
+    return { models, efforts: [], allowCustom: false };
+  } catch {
+    throw new Error("Antigravity model discovery could not verify the existing native login");
+  } finally {
+    await rm(scratch, { recursive: true, force: true });
+  }
+}
+export {
+  agyAdapter,
+  agyNativeOptionsProblem,
+  createAgyAdapter,
+  managedAgyAuthKind,
+  managedAgyToolAllowed
+};

package/src/adapters/claude.js

@@ -0,0 +1,220 @@
+import { discoverModels } from "./model-discovery.js";
+import { managedPermissionProblem } from "./managed-permissions.js";
+import { classifyError, cliErrorLine, resetFromText } from "./errors.js";
+import { commandExists, describeFailure, processErrorKind, startJsonlProcess, stderrTail, stringify, truncate, unknownEvents } from "./process.js";
+import { adapterTeamCapabilities, prepareTeamTools, TEAM_NESTED_DENYLIST, TEAM_TOOL_ALLOWLIST } from "./team-tools.js";
+const READ_TOOLS = [
+  "Read",
+  "Grep",
+  "Glob",
+  "Bash(git diff *)",
+  "Bash(git log *)",
+  "Bash(git show *)",
+  "Bash(git status *)",
+  "Bash(ls *)"
+];
+const GIT_READ_DENY = ["Bash(git *--out*)", "Bash(git *--no-index*)"];
+const IGNORED_TYPES = /* @__PURE__ */ new Set(["stream_event", "tool_progress", "tool_use_summary", "auth_status", "keep_alive", "control_request", "control_response", "control_cancel_request"]);
+const IGNORED_BLOCKS = /* @__PURE__ */ new Set(["redacted_thinking"]);
+const DEFAULT_WRITE_TOOLS = [
+  ...READ_TOOLS,
+  "Bash(git add *)",
+  "Bash(npm *)",
+  "Bash(npx *)",
+  "Bash(node *)",
+  "Bash(pnpm *)",
+  "Bash(yarn *)",
+  "Bash(python3 *)",
+  "Bash(pytest *)",
+  "Bash(uv *)",
+  "Bash(poetry *)",
+  "Bash(cargo *)",
+  "Bash(go *)",
+  "Bash(make *)",
+  "Bash(mkdir *)"
+];
+function writeTools(trust = "standard") {
+  if (trust === "safe") return READ_TOOLS;
+  if (trust === "trusted") return [...READ_TOOLS, "Bash"];
+  const env = process.env.CODEFLOW_CLAUDE_WRITE_TOOLS;
+  return env ? env.split(",").map((t) => t.trim()).filter(Boolean) : DEFAULT_WRITE_TOOLS;
+}
+const claudeAdapter = {
+  id: "claude",
+  discoverModels: (context) => discoverModels("claude", context),
+  displayName: "Claude Code",
+  binary: "claude",
+  available: () => commandExists("claude"),
+  // The CLI has no model-listing command; it accepts these aliases (always the latest
+  // model of each family) or any full model name.
+  async catalog() {
+    return {
+      models: [
+        { id: "fable", label: "Fable (latest)" },
+        { id: "opus", label: "Opus (latest)" },
+        { id: "sonnet", label: "Sonnet (latest)" },
+        { id: "haiku", label: "Haiku (latest)" }
+      ],
+      efforts: ["low", "medium", "high", "xhigh", "max"],
+      allowCustom: true
+    };
+  },
+  async run(opts, onEvent) {
+    const permissionProblem = await managedPermissionProblem("claude", opts);
+    if (permissionProblem) return permissionProblem;
+    const supportsTools = !opts.agentContainer && opts.teamTools && (await adapterTeamCapabilities("claude")).scopedTools === "tested";
+    const teamTools = supportsTools ? await prepareTeamTools(opts.teamTools) : void 0;
+    if (opts.agentContainer) onEvent({ kind: "status", text: `Claude runs in Docker image ${opts.agentContainer.image}. Live team tools are unavailable in containers; use structured outcomes and next-turn replies.` });
+    else if (opts.teamTools && !teamTools) onEvent({ kind: "status", text: "This Claude CLI has no verified per-turn team tools; use structured outcomes and next-turn replies." });
+    try {
+      const args = ["-p", "--output-format", "stream-json", "--verbose"];
+      if (opts.permissions) args.push("--settings", '{"ultracode":false,"disableWorkflows":true,"disableAllHooks":true}');
+      if (opts.resumeSessionId) args.push("--resume", opts.resumeSessionId);
+      if (opts.model) args.push("--model", opts.model);
+      if (opts.effort) args.push("--effort", opts.effort);
+      if (opts.jsonSchema) args.push("--json-schema", JSON.stringify(opts.jsonSchema));
+      if (teamTools) args.push("--mcp-config", teamTools.claudeConfig, "--strict-mcp-config");
+      else if (opts.permissions?.externalTools === "disabled") args.push("--mcp-config", '{"mcpServers":{}}', "--strict-mcp-config");
+      if (opts.permissions?.externalTools === "disabled") args.push("--no-chrome");
+      const collaborationTools = teamTools ? TEAM_TOOL_ALLOWLIST : [];
+      const full = opts.mode === "write" && opts.trust === "full";
+      const allowedTools = full ? [] : [...opts.mode === "write" ? writeTools(opts.trust) : READ_TOOLS, ...collaborationTools];
+      const limitedShell = !full && !allowedTools.includes("Bash");
+      const deniedTools = [...opts.mode === "read" ? ["Edit", "Write", "NotebookEdit"] : [], ...opts.questionProtocol === "structured" || opts.permissions?.nativeDelegation === false ? TEAM_NESTED_DENYLIST : [], ...opts.permissions?.externalTools === "disabled" ? ["WebSearch", "WebFetch"] : []];
+      const denied = [deniedTools.join(","), limitedShell ? GIT_READ_DENY.join(",") : ""].filter(Boolean);
+      if (denied.length) args.push("--disallowedTools", ...denied);
+      if (full) args.push("--permission-mode", "bypassPermissions");
+      else args.push("--permission-mode", opts.mode === "write" ? "acceptEdits" : "default", "--allowedTools", allowedTools.join(","));
+      let sessionId;
+      let finalText = "";
+      let lastAssistantText = "";
+      let resultError;
+      let sawResult = false;
+      let structured;
+      let rejected;
+      const unknown = unknownEvents("claude");
+      const proc = startJsonlProcess({
+        agentContainer: opts.agentContainer ? { config: opts.agentContainer, mode: opts.mode } : void 0,
+        command: "claude",
+        args,
+        input: opts.prompt,
+        cwd: opts.cwd,
+        signal: opts.signal,
+        timeoutMs: opts.timeoutMs,
+        idleTimeoutMs: opts.idleTimeoutMs,
+        onText: (line) => onEvent({ kind: "status", text: line }),
+        onJson: (msg) => {
+          switch (msg.type) {
+            case "system":
+              if (msg.subtype === "init" && msg.session_id) {
+                sessionId = msg.session_id;
+                onEvent({ kind: "session", sessionId: msg.session_id });
+              }
+              break;
+            case "assistant":
+              for (const block of msg.message?.content ?? []) {
+                if (block.type === "text" && block.text) {
+                  lastAssistantText = block.text;
+                  onEvent({ kind: "text", text: block.text });
+                } else if (block.type === "thinking" && block.thinking) {
+                  onEvent({ kind: "thinking", text: block.thinking });
+                } else if (block.type === "tool_use") {
+                  onEvent({
+                    kind: "tool_call",
+                    callId: block.id,
+                    name: block.name,
+                    input: truncate(stringify(block.input), 2e3)
+                  });
+                } else if (!["text", "thinking"].includes(block.type) && !IGNORED_BLOCKS.has(block.type)) {
+                  unknown.add(`${block.type} block`);
+                }
+              }
+              break;
+            case "user":
+              for (const block of msg.message?.content ?? []) {
+                if (block.type !== "tool_result") continue;
+                const output = Array.isArray(block.content) ? block.content.map((c) => c.type === "text" ? c.text : `[${c.type}]`).join("\n") : stringify(block.content ?? "");
+                onEvent({
+                  kind: "tool_result",
+                  callId: block.tool_use_id,
+                  output: truncate(output),
+                  isError: Boolean(block.is_error)
+                });
+              }
+              break;
+            case "rate_limit_event": {
+              const info = msg.rate_limit_info ?? {};
+              const windows = {};
+              for (const [name, w] of Object.entries(info.unifiedWindows ?? {})) {
+                windows[name] = { utilization: w?.utilization, resetsAt: w?.resetsAt ? w.resetsAt * 1e3 : void 0 };
+              }
+              if (!Object.keys(windows).length && (info.utilization !== void 0 || info.resetsAt)) {
+                windows[info.rateLimitType ?? "limit"] = { utilization: info.utilization, resetsAt: info.resetsAt ? info.resetsAt * 1e3 : void 0 };
+              }
+              onEvent({ kind: "quota", status: info.status ?? "unknown", windows });
+              if (info.status && info.status !== "allowed") onEvent({ kind: "status", text: `Claude rate limit: ${info.status}` });
+              if (info.status === "rejected") {
+                const full2 = Object.values(windows).filter((w) => (w.utilization ?? 0) >= 1 && w.resetsAt).map((w) => w.resetsAt);
+                rejected = { resetsAt: info.resetsAt ? info.resetsAt * 1e3 : full2.length ? Math.max(...full2) : void 0 };
+              }
+              break;
+            }
+            case "result":
+              sawResult = true;
+              proc.resultSeen();
+              finalText = typeof msg.result === "string" ? msg.result : lastAssistantText;
+              if (msg.session_id) sessionId = msg.session_id;
+              if (msg.structured_output !== void 0) structured = msg.structured_output;
+              if (msg.is_error || /^error/.test(msg.subtype ?? "")) resultError = resultErrorText(msg);
+              onEvent({
+                kind: "usage",
+                // Writing to the prompt cache is billed as input; reading from it is counted apart.
+                inputTokens: (msg.usage?.input_tokens ?? 0) + (msg.usage?.cache_creation_input_tokens ?? 0),
+                outputTokens: msg.usage?.output_tokens,
+                cacheReadTokens: msg.usage?.cache_read_input_tokens,
+                costUsd: msg.total_cost_usd
+              });
+              if (Array.isArray(msg.permission_denials) && msg.permission_denials.length) {
+                const names = msg.permission_denials.map((d) => d.tool_name).join(", ");
+                onEvent({ kind: "status", text: `Denied in headless mode: ${names}` });
+              }
+              break;
+            default:
+              if (!IGNORED_TYPES.has(msg.type)) unknown.add(msg.type);
+          }
+        }
+      });
+      const outcome = await proc.outcome;
+      const drift = unknown.report();
+      if (drift) onEvent({ kind: "status", text: drift });
+      if (sawResult && !resultError && !outcome.aborted) return { ok: true, finalText, sessionId, structured };
+      const tail = stderrTail(outcome);
+      const error = resultError ? `${resultError}${tail && !resultError.includes(tail) ? `
+${tail}` : ""}` : !sawResult && outcome.exitCode === 0 ? `claude exited without a result${tail ? `: ${tail}` : ""}` : describeFailure("claude", outcome);
+      const own = resultError ?? cliErrorLine(outcome.stderr);
+      let errorKind = processErrorKind(outcome) ?? classifyError(own);
+      if (rejected && (errorKind === "other" || errorKind === "rate_limit")) errorKind = "usage_limit";
+      const resetsAt = errorKind === "usage_limit" ? rejected?.resetsAt ?? resetFromText(own) : void 0;
+      onEvent({ kind: "error", message: error });
+      return {
+        ok: false,
+        finalText: finalText || lastAssistantText,
+        sessionId: errorKind === "session_not_found" ? void 0 : sessionId,
+        error,
+        errorKind,
+        ...resetsAt && { resetsAt }
+      };
+    } finally {
+      await teamTools?.cleanup();
+    }
+  }
+};
+function resultErrorText(msg) {
+  if (msg.is_error && typeof msg.result === "string" && msg.result.trim()) return msg.result.trim();
+  const errors = Array.isArray(msg.errors) ? msg.errors.filter((e) => typeof e === "string" && e).join("; ") : "";
+  const what = msg.subtype === "error_max_turns" ? "Claude stopped at its turn limit" : msg.subtype === "error_max_budget_usd" ? "Claude stopped at its budget limit" : msg.subtype === "error_during_execution" ? "Claude stopped with an error during execution" : `Claude reported an error${msg.subtype && msg.subtype !== "success" ? ` (${msg.subtype})` : ""}`;
+  return errors ? `${what}: ${errors}` : what;
+}
+export {
+  claudeAdapter
+};