nuabase 2.3.7 → 3.0.0

package/dist/esm/local-agent.mjs

@@ -1,1041 +1,869 @@
-import { r as requireLogger } from './chunks/logger-DnkHzkX_.mjs';
-import { createRequire } from 'node:module';
-
-var localAgent$1 = {};
-
-var createLocalAgent = {};
-
-var adapters = {};
-
-var claudeCode = {};
-
-var failureClassification = {};
-
-var hasRequiredFailureClassification;
-function requireFailureClassification() {
-  if (hasRequiredFailureClassification) return failureClassification;
-  hasRequiredFailureClassification = 1;
-  Object.defineProperty(failureClassification, "__esModule", { value: true });
-  failureClassification.classifyAgentFailure = classifyAgentFailure;
-  failureClassification.stderrTail = stderrTail;
-  const FATAL_PATTERNS = [
-    /not logged in/i,
-    /logged out/i,
-    /(please|need to|must) (run .*)?log ?in/i,
-    /authenticat/i,
-    /unauthori[sz]ed/i,
-    /invalid api key/i,
-    /oauth/i,
-    /usage limit/i,
-    /rate.?limit/i,
-    /quota/i,
-    /credit balance/i,
-    /\b40[13]\b/,
-    /\b429\b/,
-    /not supported when using/i,
-    /model .* (does not exist|not found|not available)/i
-  ];
-  function classifyAgentFailure(agent, message) {
-    const full = `${agent}: ${message}`;
-    if (FATAL_PATTERNS.some((pattern) => pattern.test(message))) {
-      return { kind: "fatal", message: full };
-    }
-    return { kind: "transient", message: full };
-  }
-  function stderrTail(result, maxChars = 2e3) {
-    const stderr = result.stderr.trim();
-    return stderr.length > maxChars ? stderr.slice(-maxChars) : stderr;
+import { t as toStrictSchema, g as generateSpanId, b as logLlmCallError, C as ConsoleLogger } from './chunks/strict-json-schema-Du2LLrVP.mjs';
+import { spawn, execFile } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { promisify } from 'node:util';
+
+const FATAL_PATTERNS = [
+  /not logged in/i,
+  /logged out/i,
+  /(please|need to|must) (run .*)?log ?in/i,
+  /authenticat/i,
+  /unauthori[sz]ed/i,
+  /invalid api key/i,
+  /oauth/i,
+  /usage limit/i,
+  /rate.?limit/i,
+  /quota/i,
+  /credit balance/i,
+  /\b40[13]\b/,
+  /\b429\b/,
+  /not supported when using/i,
+  /model .* (does not exist|not found|not available)/i
+];
+function classifyAgentFailure(message) {
+  if (FATAL_PATTERNS.some((pattern) => pattern.test(message))) {
+    return { kind: "fatal", message };
   }
-  return failureClassification;
+  return { kind: "transient", message };
+}
+function stderrTail(result, maxChars = 2e3) {
+  const stderr = result.stderr.trim();
+  return stderr.length > maxChars ? stderr.slice(-maxChars) : stderr;
 }
 
-var hasRequiredClaudeCode;
-function requireClaudeCode() {
-  if (hasRequiredClaudeCode) return claudeCode;
-  hasRequiredClaudeCode = 1;
-  Object.defineProperty(claudeCode, "__esModule", { value: true });
-  claudeCode.claudeCodeAdapter = void 0;
-  const failure_classification_1 = requireFailureClassification();
-  const SYSTEM_PROMPT = [
-    "You are a data transformation function called by a program.",
-    "You have no tools. Follow the instructions in the user message exactly",
-    "and reply only with the requested JSON."
-  ].join(" ");
-  claudeCode.claudeCodeAdapter = {
-    id: "claude-code",
-    binaryName: "claude",
-    apiKeyEnvVars: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"],
-    modelAliases: { haiku: "haiku", sonnet: "sonnet", opus: "opus" },
-    // Claude Code accepts any JSON Schema with an object root.
-    nativeSchema(envelopeSchema) {
-      return envelopeSchema;
-    },
-    buildInvocation(request, model) {
-      const args = [
-        "-p",
-        "--output-format",
-        "json",
-        "--tools",
-        "",
-        "--setting-sources",
-        "",
-        "--strict-mcp-config",
-        "--no-session-persistence",
-        "--system-prompt",
-        SYSTEM_PROMPT
-      ];
-      if (model !== void 0) {
-        args.push("--model", model);
-      }
-      if (request.enforcement.kind === "native") {
-        args.push("--json-schema", JSON.stringify(request.enforcement.schema));
-      }
-      return { args, stdin: request.prompt };
-    },
-    readResult(result, request) {
-      let json;
-      try {
-        json = JSON.parse(result.stdout);
-      } catch {
-        return {
-          kind: "failed",
-          failure: (0, failure_classification_1.classifyAgentFailure)("claude", `exited with code ${result.exitCode} without a JSON result: ${(0, failure_classification_1.stderrTail)(result)}`)
-        };
-      }
-      if (json.is_error) {
-        const message = json.result || `error (${json.subtype ?? "unknown"})`;
-        if (json.api_error_status === 400 && /input_schema|json.?schema/i.test(message)) {
-          return {
-            kind: "failed",
-            failure: { kind: "schema-rejected", message: `claude rejected the output schema: ${message}` }
-          };
-        }
-        if (json.api_error_status === 401 || json.api_error_status === 403 || json.api_error_status === 429) {
-          return { kind: "failed", failure: { kind: "fatal", message: `claude: ${message}` } };
-        }
-        return { kind: "failed", failure: (0, failure_classification_1.classifyAgentFailure)("claude", message) };
-      }
-      if (json.subtype !== "success") {
-        return {
-          kind: "failed",
-          failure: {
-            kind: "transient",
-            message: `claude did not finish successfully (${json.subtype ?? "no subtype"})`
-          }
-        };
-      }
-      const usage = json.usage ?? {};
-      const promptTokens = (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
-      const completionTokens = usage.output_tokens ?? 0;
-      const reported = {
-        usage: { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens },
-        model: Object.keys(json.modelUsage ?? {})[0],
-        costUsdEstimate: json.total_cost_usd
+const SYSTEM_PROMPT$1 = [
+  "You are a data transformation function called by a program.",
+  "You have no tools. Follow the instructions in the user message exactly",
+  "and reply only with the requested JSON."
+].join(" ");
+const claudeCodeAdapter = {
+  id: "claude-code",
+  binaryName: "claude",
+  apiKeyEnvVars: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"],
+  modelAliases: { haiku: "haiku", sonnet: "sonnet", opus: "opus" },
+  // Claude Code accepts any JSON Schema with an object root.
+  nativeSchema(envelopeSchema) {
+    return envelopeSchema;
+  },
+  buildInvocation(request, { model, effort }) {
+    const args = [
+      "-p",
+      "--output-format",
+      "json",
+      "--tools",
+      "",
+      "--setting-sources",
+      "",
+      "--strict-mcp-config",
+      "--no-session-persistence",
+      "--system-prompt",
+      SYSTEM_PROMPT$1
+    ];
+    if (model !== void 0) {
+      args.push("--model", model);
+    }
+    if (effort !== void 0) {
+      args.push("--effort", effort);
+    }
+    if (request.enforcement.kind === "native") {
+      args.push("--json-schema", JSON.stringify(request.enforcement.schema));
+    }
+    return { args, stdin: request.prompt };
+  },
+  readResult(result, request) {
+    let json;
+    try {
+      json = JSON.parse(result.stdout);
+    } catch {
+      return {
+        kind: "failed",
+        failure: classifyAgentFailure(
+          `exited with code ${result.exitCode} without a JSON result: ${stderrTail(result)}`
+        )
       };
-      if (request.enforcement.kind === "in-prompt") {
-        return { kind: "answered", answer: { kind: "text", text: json.result ?? "" }, ...reported };
-      }
-      if (!json.structured_output) {
+    }
+    if (json.is_error) {
+      const message = json.result || `error (${json.subtype ?? "unknown"})`;
+      if (json.api_error_status === 400 && /input_schema|json.?schema/i.test(message)) {
         return {
           kind: "failed",
-          failure: {
-            kind: "transient",
-            message: `claude returned no structured output. Reply: ${json.result ?? ""}`
-          }
+          failure: { kind: "schema-rejected", message: `rejected the output schema: ${message}` }
         };
       }
-      return {
-        kind: "answered",
-        answer: { kind: "structured", envelope: json.structured_output },
-        ...reported
-      };
-    },
-    loginStatusArgs: ["auth", "status"],
-    readLoginStatus(result) {
-      try {
-        const status = JSON.parse(result.stdout);
-        return { loggedIn: status.loggedIn === true, detail: status.authMethod };
-      } catch {
-        return { loggedIn: false, detail: (0, failure_classification_1.stderrTail)(result) || result.stdout.trim() };
+      if (json.api_error_status === 401 || json.api_error_status === 403 || json.api_error_status === 429) {
+        return { kind: "failed", failure: { kind: "fatal", message } };
       }
+      return { kind: "failed", failure: classifyAgentFailure(message) };
     }
-  };
-  return claudeCode;
-}
-
-var codex = {};
-
-var strictJsonSchema = {};
-
-var hasRequiredStrictJsonSchema;
-function requireStrictJsonSchema() {
-  if (hasRequiredStrictJsonSchema) return strictJsonSchema;
-  hasRequiredStrictJsonSchema = 1;
-  Object.defineProperty(strictJsonSchema, "__esModule", { value: true });
-  strictJsonSchema.toStrictSchema = toStrictSchema;
-  const STRICT_UNSUPPORTED_KEYWORDS = /* @__PURE__ */ new Set([
-    "patternProperties",
-    "propertyNames",
-    "unevaluatedProperties",
-    "dependentRequired",
-    "dependentSchemas",
-    "if",
-    "then",
-    "else",
-    "not",
-    "allOf",
-    "oneOf"
-  ]);
-  function toStrictSchema(schema) {
-    return strictNode(schema);
-  }
-  function strictNode(node) {
-    if (typeof node !== "object" || node === null || Array.isArray(node)) {
-      return null;
-    }
-    const schema = node;
-    for (const key of Object.keys(schema)) {
-      if (STRICT_UNSUPPORTED_KEYWORDS.has(key))
-        return null;
-    }
-    const result = { ...schema };
-    delete result.$schema;
-    const isObject = schema.type === "object" || Array.isArray(schema.type) && schema.type.includes("object") || schema.properties !== void 0;
-    if (isObject) {
-      const properties = schema.properties ?? {};
-      if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) {
-        return null;
-      }
-      const required = new Set(schema.required ?? []);
-      const shapedProperties = {};
-      for (const [name, child] of Object.entries(properties)) {
-        if (!required.has(name))
-          return null;
-        const shaped = strictNode(child);
-        if (!shaped)
-          return null;
-        shapedProperties[name] = shaped;
-      }
-      result.properties = shapedProperties;
-      result.required = Object.keys(shapedProperties);
-      result.additionalProperties = false;
-    }
-    if (schema.items !== void 0) {
-      const shaped = strictNode(schema.items);
-      if (!shaped)
-        return null;
-      result.items = shaped;
+    if (json.subtype !== "success") {
+      return {
+        kind: "failed",
+        failure: {
+          kind: "transient",
+          message: `did not finish successfully (${json.subtype ?? "no subtype"})`
+        }
+      };
     }
-    if (schema.prefixItems !== void 0)
-      return null;
-    if (schema.anyOf !== void 0) {
-      const variants = schema.anyOf.map(strictNode);
-      if (variants.some((v) => v === null))
-        return null;
-      result.anyOf = variants;
+    const usage = json.usage ?? {};
+    const promptTokens = (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+    const completionTokens = usage.output_tokens ?? 0;
+    const reported = {
+      usage: {
+        promptTokens,
+        completionTokens,
+        totalTokens: promptTokens + completionTokens,
+        ...usage.cache_read_input_tokens !== void 0 && { promptCacheReadTokens: usage.cache_read_input_tokens },
+        ...usage.cache_creation_input_tokens !== void 0 && {
+          promptCacheWriteTokens: usage.cache_creation_input_tokens
+        }
+      },
+      model: Object.keys(json.modelUsage ?? {})[0],
+      costUsdEstimate: json.total_cost_usd
+    };
+    if (request.enforcement.kind === "in-prompt") {
+      return { kind: "answered", answer: { kind: "text", text: json.result ?? "" }, ...reported };
     }
-    for (const defsKey of ["$defs", "definitions"]) {
-      if (schema[defsKey] !== void 0) {
-        const defs = {};
-        for (const [name, child] of Object.entries(schema[defsKey])) {
-          const shaped = strictNode(child);
-          if (!shaped)
-            return null;
-          defs[name] = shaped;
+    if (!json.structured_output) {
+      return {
+        kind: "failed",
+        failure: {
+          kind: "transient",
+          message: `returned no structured output. Reply: ${json.result ?? ""}`
         }
-        result[defsKey] = defs;
-      }
+      };
     }
-    return result;
+    return {
+      kind: "answered",
+      answer: { kind: "structured", envelope: json.structured_output },
+      ...reported
+    };
+  },
+  loginStatusArgs: ["auth", "status"],
+  readLoginStatus(result) {
+    try {
+      const status = JSON.parse(result.stdout);
+      return { loggedIn: status.loggedIn === true, detail: status.authMethod };
+    } catch {
+      return { loggedIn: false, detail: stderrTail(result) || result.stdout.trim() };
+    }
+  },
+  sessionArgs(model, approval) {
+    return [
+      ...model === void 0 ? [] : ["--model", model],
+      ...approval === "auto" ? ["--permission-mode", "auto"] : []
+    ];
   }
-  return strictJsonSchema;
-}
-
-var hasRequiredCodex;
-function requireCodex() {
-  if (hasRequiredCodex) return codex;
-  hasRequiredCodex = 1;
-  Object.defineProperty(codex, "__esModule", { value: true });
-  codex.codexAdapter = void 0;
-  const strict_json_schema_1 = requireStrictJsonSchema();
-  const failure_classification_1 = requireFailureClassification();
-  const SCHEMA_FILE = "output-schema.json";
-  const LAST_MESSAGE_FILE = "last-message.txt";
-  codex.codexAdapter = {
-    id: "codex",
-    binaryName: "codex",
-    apiKeyEnvVars: ["OPENAI_API_KEY", "CODEX_API_KEY"],
-    // Codex's models have no equivalent among the aliases; set one with localAgent({ model }).
-    modelAliases: {},
-    // Codex accepts only OpenAI strict-mode schemas.
-    nativeSchema(envelopeSchema) {
-      return (0, strict_json_schema_1.toStrictSchema)(envelopeSchema);
-    },
-    buildInvocation(request, model) {
-      const args = [
-        "exec",
-        "-",
-        "--skip-git-repo-check",
-        "--ephemeral",
-        "--ignore-user-config",
-        "--ignore-rules",
-        "--sandbox",
-        "read-only",
-        "-c",
-        "model_reasoning_effort=low",
-        "--json",
-        "-o",
-        LAST_MESSAGE_FILE
-      ];
-      if (model !== void 0) {
-        args.push("-m", model);
-      }
-      const files = [];
-      if (request.enforcement.kind === "native") {
-        args.push("--output-schema", SCHEMA_FILE);
-        files.push({ name: SCHEMA_FILE, content: JSON.stringify(request.enforcement.schema) });
-      }
-      return { args, stdin: request.prompt, files, outputFiles: [LAST_MESSAGE_FILE] };
-    },
-    readResult(result, request) {
-      const events = parseEvents(result.stdout);
-      const failed = events.find((e) => e.type === "turn.failed" || e.type === "error");
-      if (failed) {
-        const message = failed.error?.message ?? failed.message ?? "unknown error";
-        if (/invalid_json_schema/.test(message)) {
-          return {
-            kind: "failed",
-            failure: { kind: "schema-rejected", message: `codex rejected the output schema: ${message}` }
-          };
-        }
-        return { kind: "failed", failure: (0, failure_classification_1.classifyAgentFailure)("codex", message) };
-      }
-      const agentMessages = events.filter((e) => e.item?.type === "agent_message");
-      const lastMessage = result.outputFiles[LAST_MESSAGE_FILE] ?? agentMessages[agentMessages.length - 1]?.item?.text;
-      if (result.exitCode !== 0 || lastMessage === void 0) {
+};
+
+const SCHEMA_FILE = "output-schema.json";
+const LAST_MESSAGE_FILE = "last-message.txt";
+const codexAdapter = {
+  id: "codex",
+  binaryName: "codex",
+  apiKeyEnvVars: ["OPENAI_API_KEY", "CODEX_API_KEY"],
+  // Codex's models have no equivalent among the aliases; set one with localAgent({ model }).
+  modelAliases: {},
+  // Codex accepts only OpenAI strict-mode schemas.
+  nativeSchema(envelopeSchema) {
+    return toStrictSchema(envelopeSchema);
+  },
+  buildInvocation(request, { model, effort }) {
+    const args = [
+      "exec",
+      "-",
+      "--skip-git-repo-check",
+      "--ephemeral",
+      "--ignore-user-config",
+      "--ignore-rules",
+      "--sandbox",
+      "read-only",
+      "--json",
+      "-o",
+      LAST_MESSAGE_FILE
+    ];
+    if (model !== void 0) {
+      args.push("-m", model);
+    }
+    if (effort !== void 0) {
+      args.push("-c", `model_reasoning_effort=${effort}`);
+    }
+    const files = [];
+    if (request.enforcement.kind === "native") {
+      args.push("--output-schema", SCHEMA_FILE);
+      files.push({ name: SCHEMA_FILE, content: JSON.stringify(request.enforcement.schema) });
+    }
+    return { args, stdin: request.prompt, files, outputFiles: [LAST_MESSAGE_FILE] };
+  },
+  readResult(result, request) {
+    const events = parseEvents$1(result.stdout);
+    const failed = events.find((e) => e.type === "turn.failed" || e.type === "error");
+    if (failed) {
+      const raw = failed.error?.message ?? failed.message ?? "unknown error";
+      const message = apiErrorMessage(raw);
+      if (/invalid_json_schema/.test(raw)) {
         return {
           kind: "failed",
-          failure: (0, failure_classification_1.classifyAgentFailure)("codex", `exited with code ${result.exitCode} without a reply: ${(0, failure_classification_1.stderrTail)(result)}`)
+          failure: { kind: "schema-rejected", message: `rejected the output schema: ${message}` }
         };
       }
-      const completed = events.filter((e) => e.type === "turn.completed");
-      const promptTokens = completed.reduce((sum, e) => sum + (e.usage?.input_tokens ?? 0), 0);
-      const completionTokens = completed.reduce((sum, e) => sum + (e.usage?.output_tokens ?? 0), 0);
-      const reported = {
-        usage: { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens },
-        // Codex does not report which model answered.
-        model: void 0,
-        costUsdEstimate: void 0
+      return { kind: "failed", failure: { ...classifyAgentFailure(raw), message } };
+    }
+    const agentMessages = events.filter((e) => e.item?.type === "agent_message");
+    const lastMessage = result.outputFiles[LAST_MESSAGE_FILE] ?? agentMessages[agentMessages.length - 1]?.item?.text;
+    if (result.exitCode !== 0 || lastMessage === void 0) {
+      return {
+        kind: "failed",
+        failure: classifyAgentFailure(
+          `exited with code ${result.exitCode} without a reply: ${stderrTail(result)}`
+        )
       };
-      if (request.enforcement.kind === "in-prompt") {
-        return { kind: "answered", answer: { kind: "text", text: lastMessage }, ...reported };
-      }
-      let envelope;
-      try {
-        envelope = JSON.parse(lastMessage);
-      } catch {
-        return {
-          kind: "failed",
-          failure: { kind: "transient", message: `codex reply is not JSON: ${lastMessage}` }
-        };
-      }
-      return { kind: "answered", answer: { kind: "structured", envelope }, ...reported };
-    },
-    loginStatusArgs: ["login", "status"],
-    readLoginStatus(result) {
-      const detail = `${result.stdout}
-${result.stderr}`.trim();
-      return { loggedIn: result.exitCode === 0, detail };
     }
-  };
-  function parseEvents(stdout) {
-    const events = [];
-    for (const line of stdout.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed.startsWith("{"))
-        continue;
-      try {
-        events.push(JSON.parse(trimmed));
-      } catch {
-      }
+    const completed = events.filter((e) => e.type === "turn.completed");
+    const promptTokens = completed.reduce((sum, e) => sum + (e.usage?.input_tokens ?? 0), 0);
+    const completionTokens = completed.reduce((sum, e) => sum + (e.usage?.output_tokens ?? 0), 0);
+    const cacheReadReported = completed.some((e) => e.usage?.cached_input_tokens !== void 0);
+    const cacheReadTokens = completed.reduce((sum, e) => sum + (e.usage?.cached_input_tokens ?? 0), 0);
+    const reported = {
+      usage: {
+        promptTokens,
+        completionTokens,
+        totalTokens: promptTokens + completionTokens,
+        ...cacheReadReported && { promptCacheReadTokens: cacheReadTokens }
+      },
+      // Codex does not report which model answered.
+      model: void 0,
+      costUsdEstimate: void 0
+    };
+    if (request.enforcement.kind === "in-prompt") {
+      return { kind: "answered", answer: { kind: "text", text: lastMessage }, ...reported };
     }
-    return events;
-  }
-  return codex;
-}
-
-var pi = {};
-
-var hasRequiredPi;
-function requirePi() {
-  if (hasRequiredPi) return pi;
-  hasRequiredPi = 1;
-  Object.defineProperty(pi, "__esModule", { value: true });
-  pi.piAdapter = void 0;
-  const failure_classification_1 = requireFailureClassification();
-  const SYSTEM_PROMPT = [
-    "You are a data transformation function called by a program.",
-    "You have no tools. Follow the instructions in the user message exactly",
-    "and reply only with the requested JSON."
-  ].join(" ");
-  pi.piAdapter = {
-    id: "pi",
-    binaryName: "pi",
-    // Every environment credential Pi's providers recognize. Under `auth:
-    // "subscription"` these are removed so Pi bills its own `auth.json` login.
-    apiKeyEnvVars: [
-      "AI_GATEWAY_API_KEY",
-      "ANT_LING_API_KEY",
-      "ANTHROPIC_API_KEY",
-      "ANTHROPIC_AUTH_TOKEN",
-      "ANTHROPIC_OAUTH_TOKEN",
-      "AWS_ACCESS_KEY_ID",
-      "AWS_SECRET_ACCESS_KEY",
-      "AWS_SESSION_TOKEN",
-      "AZURE_OPENAI_API_KEY",
-      "BASETEN_API_KEY",
-      "CEREBRAS_API_KEY",
-      "CLOUDFLARE_API_KEY",
-      "COPILOT_GITHUB_TOKEN",
-      "DEEPSEEK_API_KEY",
-      "FIREWORKS_API_KEY",
-      "GEMINI_API_KEY",
-      "GOOGLE_API_KEY",
-      "GOOGLE_CLOUD_API_KEY",
-      "GROQ_API_KEY",
-      "HF_TOKEN",
-      "KIMI_API_KEY",
-      "META_API_KEY",
-      "MINIMAX_API_KEY",
-      "MINIMAX_CN_API_KEY",
-      "MISTRAL_API_KEY",
-      "MOONSHOT_API_KEY",
-      "NVIDIA_API_KEY",
-      "OPENAI_API_KEY",
-      "OPENCODE_API_KEY",
-      "OPENROUTER_API_KEY",
-      "QWEN_TOKEN_PLAN_API_KEY",
-      "QWEN_TOKEN_PLAN_CN_API_KEY",
-      "RADIUS_API_KEY",
-      "TOGETHER_API_KEY",
-      "XAI_API_KEY",
-      "XIAOMI_API_KEY",
-      "XIAOMI_TOKEN_PLAN_AMS_API_KEY",
-      "XIAOMI_TOKEN_PLAN_CN_API_KEY",
-      "XIAOMI_TOKEN_PLAN_SGP_API_KEY",
-      "ZAI_API_KEY",
-      "ZAI_CODING_CN_API_KEY"
-    ],
-    // Pi uses its own `provider/id` model names; set one with localAgent({ model }).
-    modelAliases: {},
-    nativeSchema() {
-      return null;
-    },
-    buildInvocation(request, model) {
-      const args = [
-        "--mode",
-        "json",
-        "--no-session",
-        "--no-tools",
-        "--no-builtin-tools",
-        "--no-extensions",
-        "--no-skills",
-        "--no-prompt-templates",
-        "--no-themes",
-        "--no-context-files",
-        "--system-prompt",
-        SYSTEM_PROMPT,
-        "--offline"
-      ];
-      if (model !== void 0) {
-        args.push("--model", model);
-      }
-      return { args, stdin: request.prompt };
-    },
-    readResult(result, request) {
-      const events = parseEvents(result.stdout);
-      const assistant = events.filter((event) => event.type === "message_end" && event.message?.role === "assistant").map((event) => event.message).pop();
-      if (assistant && (assistant.stopReason === "error" || assistant.errorMessage)) {
-        return failed((0, failure_classification_1.classifyAgentFailure)("pi", assistant.errorMessage ?? "pi stopped with an error"));
-      }
-      const retryFailed = events.find((event) => event.type === "auto_retry_end" && event.success === false);
-      if (retryFailed) {
-        return failed((0, failure_classification_1.classifyAgentFailure)("pi", retryFailed.finalError ?? "auto retry failed"));
-      }
-      if (!assistant) {
-        return failed((0, failure_classification_1.classifyAgentFailure)("pi", `exited with code ${result.exitCode} without a reply: ${(0, failure_classification_1.stderrTail)(result)}`));
-      }
-      const text = (assistant.content ?? []).filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
-      const usage = assistant.usage ?? {};
-      const promptTokens = (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
-      const completionTokens = usage.output ?? 0;
-      const reported = {
-        usage: { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens },
-        model: assistant.model,
-        costUsdEstimate: usage.cost?.total
-      };
-      if (request.enforcement.kind === "in-prompt") {
-        return { kind: "answered", answer: { kind: "text", text }, ...reported };
-      }
-      let envelope;
-      try {
-        envelope = JSON.parse(text);
-      } catch {
-        return failed({ kind: "transient", message: `pi reply is not JSON: ${text}` });
-      }
-      return { kind: "answered", answer: { kind: "structured", envelope }, ...reported };
-    },
-    // Pi has no provider-agnostic login check: `pi auth check` requires --provider
-    // or --model, and the provider differs per user (it is not known until Pi's
-    // settings are read). Report installed Pi as logged in; the first real call
-    // surfaces any auth error, which classifyAgentFailure marks fatal.
-    loginStatusArgs: ["--version"],
-    readLoginStatus(result) {
+    let envelope;
+    try {
+      envelope = JSON.parse(lastMessage);
+    } catch {
       return {
-        loggedIn: result.exitCode === 0,
-        detail: "installed; auth is verified on the first call"
+        kind: "failed",
+        failure: { kind: "transient", message: `reply is not JSON: ${lastMessage}` }
       };
     }
-  };
-  function failed(failure) {
-    return { kind: "failed", failure };
+    return { kind: "answered", answer: { kind: "structured", envelope }, ...reported };
+  },
+  loginStatusArgs: ["login", "status"],
+  readLoginStatus(result) {
+    const detail = `${result.stdout}
+${result.stderr}`.trim();
+    return { loggedIn: result.exitCode === 0, detail };
+  },
+  sessionArgs(model, approval) {
+    return [
+      ...model === void 0 ? [] : ["--model", model],
+      ...approval === "auto" ? ["--approve-for-me"] : []
+    ];
   }
-  function parseEvents(stdout) {
-    const events = [];
-    for (const line of stdout.split("\n")) {
-      const trimmed = line.replace(/\r$/, "").trim();
-      if (!trimmed.startsWith("{"))
-        continue;
-      try {
-        const parsed = JSON.parse(trimmed);
-        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-          events.push(parsed);
-        }
-      } catch {
-      }
+};
+function parseEvents$1(stdout) {
+  const events = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      events.push(JSON.parse(trimmed));
+    } catch {
     }
-    return events;
   }
-  return pi;
+  return events;
 }
-
-var hasRequiredAdapters;
-function requireAdapters() {
-  if (hasRequiredAdapters) return adapters;
-  hasRequiredAdapters = 1;
-  Object.defineProperty(adapters, "__esModule", { value: true });
-  adapters.AGENT_ADAPTERS = void 0;
-  const claude_code_1 = requireClaudeCode();
-  const codex_1 = requireCodex();
-  const pi_1 = requirePi();
-  adapters.AGENT_ADAPTERS = {
-    "claude-code": claude_code_1.claudeCodeAdapter,
-    codex: codex_1.codexAdapter,
-    pi: pi_1.piAdapter
-  };
-  return adapters;
+function apiErrorMessage(message) {
+  try {
+    const inner = JSON.parse(message)?.error?.message;
+    if (typeof inner === "string") return inner;
+  } catch {
+  }
+  return message;
 }
 
-var agentId = {};
-
-var hasRequiredAgentId;
-function requireAgentId() {
-  if (hasRequiredAgentId) return agentId;
-  hasRequiredAgentId = 1;
-  (function(exports$1) {
-    Object.defineProperty(exports$1, "__esModule", { value: true });
-    exports$1.LOCAL_AGENT_IDS = void 0;
-    exports$1.isLocalAgentId = isLocalAgentId;
-    exports$1.LOCAL_AGENT_IDS = ["claude-code", "codex", "pi"];
-    const LOCAL_AGENT_ID_SET = new Set(exports$1.LOCAL_AGENT_IDS);
-    function isLocalAgentId(value) {
-      return typeof value === "string" && LOCAL_AGENT_ID_SET.has(value);
+const SYSTEM_PROMPT = [
+  "You are a data transformation function called by a program.",
+  "You have no tools. Follow the instructions in the user message exactly",
+  "and reply only with the requested JSON."
+].join(" ");
+const piAdapter = {
+  id: "pi",
+  binaryName: "pi",
+  // Every environment credential Pi's providers recognize. Under `auth:
+  // "subscription"` these are removed so Pi bills its own `auth.json` login.
+  apiKeyEnvVars: [
+    "AI_GATEWAY_API_KEY",
+    "ANT_LING_API_KEY",
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_OAUTH_TOKEN",
+    "AWS_ACCESS_KEY_ID",
+    "AWS_SECRET_ACCESS_KEY",
+    "AWS_SESSION_TOKEN",
+    "AZURE_OPENAI_API_KEY",
+    "BASETEN_API_KEY",
+    "CEREBRAS_API_KEY",
+    "CLOUDFLARE_API_KEY",
+    "COPILOT_GITHUB_TOKEN",
+    "DEEPSEEK_API_KEY",
+    "FIREWORKS_API_KEY",
+    "GEMINI_API_KEY",
+    "GOOGLE_API_KEY",
+    "GOOGLE_CLOUD_API_KEY",
+    "GROQ_API_KEY",
+    "HF_TOKEN",
+    "KIMI_API_KEY",
+    "META_API_KEY",
+    "MINIMAX_API_KEY",
+    "MINIMAX_CN_API_KEY",
+    "MISTRAL_API_KEY",
+    "MOONSHOT_API_KEY",
+    "NVIDIA_API_KEY",
+    "OPENAI_API_KEY",
+    "OPENCODE_API_KEY",
+    "OPENROUTER_API_KEY",
+    "QWEN_TOKEN_PLAN_API_KEY",
+    "QWEN_TOKEN_PLAN_CN_API_KEY",
+    "RADIUS_API_KEY",
+    "TOGETHER_API_KEY",
+    "XAI_API_KEY",
+    "XIAOMI_API_KEY",
+    "XIAOMI_TOKEN_PLAN_AMS_API_KEY",
+    "XIAOMI_TOKEN_PLAN_CN_API_KEY",
+    "XIAOMI_TOKEN_PLAN_SGP_API_KEY",
+    "ZAI_API_KEY",
+    "ZAI_CODING_CN_API_KEY"
+  ],
+  // Pi uses its own `provider/id` model names; set one with localAgent({ model }).
+  modelAliases: {},
+  nativeSchema() {
+    return null;
+  },
+  buildInvocation(request, { model, effort }) {
+    const args = [
+      "--mode",
+      "json",
+      "--no-session",
+      "--no-tools",
+      "--no-builtin-tools",
+      "--no-extensions",
+      "--no-skills",
+      "--no-prompt-templates",
+      "--no-themes",
+      "--no-context-files",
+      "--system-prompt",
+      SYSTEM_PROMPT,
+      "--offline"
+    ];
+    if (model !== void 0) {
+      args.push("--model", model);
+    }
+    if (effort !== void 0) {
+      args.push("--thinking", effort);
+    }
+    return { args, stdin: request.prompt };
+  },
+  readResult(result, request) {
+    const events = parseEvents(result.stdout);
+    const assistant = events.filter((event) => event.type === "message_end" && event.message?.role === "assistant").map((event) => event.message).pop();
+    if (assistant && (assistant.stopReason === "error" || assistant.errorMessage)) {
+      return failed(classifyAgentFailure(assistant.errorMessage ?? "stopped with an error"));
+    }
+    const retryFailed = events.find((event) => event.type === "auto_retry_end" && event.success === false);
+    if (retryFailed) {
+      return failed(classifyAgentFailure(retryFailed.finalError ?? "auto retry failed"));
+    }
+    if (!assistant) {
+      return failed(
+        classifyAgentFailure(
+          `exited with code ${result.exitCode} without a reply: ${stderrTail(result)}`
+        )
+      );
+    }
+    const text = (assistant.content ?? []).filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
+    const usage = assistant.usage ?? {};
+    const promptTokens = (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+    const completionTokens = usage.output ?? 0;
+    const reported = {
+      usage: {
+        promptTokens,
+        completionTokens,
+        totalTokens: promptTokens + completionTokens,
+        ...usage.cacheRead !== void 0 && { promptCacheReadTokens: usage.cacheRead },
+        ...usage.cacheWrite !== void 0 && { promptCacheWriteTokens: usage.cacheWrite }
+      },
+      model: assistant.model,
+      costUsdEstimate: usage.cost?.total
+    };
+    if (request.enforcement.kind === "in-prompt") {
+      return { kind: "answered", answer: { kind: "text", text }, ...reported };
     }
-  })(agentId);
-  return agentId;
+    let envelope;
+    try {
+      envelope = JSON.parse(text);
+    } catch {
+      return failed({ kind: "transient", message: `reply is not JSON: ${text}` });
+    }
+    return { kind: "answered", answer: { kind: "structured", envelope }, ...reported };
+  },
+  // Pi has no provider-agnostic login check: `pi auth check` requires --provider
+  // or --model, and the provider differs per user (it is not known until Pi's
+  // settings are read). Report installed Pi as logged in; the first real call
+  // surfaces any auth error, which classifyAgentFailure marks fatal.
+  loginStatusArgs: ["--version"],
+  readLoginStatus(result) {
+    return {
+      loggedIn: result.exitCode === 0,
+      detail: "installed; auth is verified on the first call"
+    };
+  },
+  sessionArgs(model, approval) {
+    return [
+      ...model === void 0 ? [] : ["--model", model],
+      ...approval === "auto" ? ["--approve"] : []
+    ];
+  }
+};
+function failed(failure) {
+  return { kind: "failed", failure };
+}
+function parseEvents(stdout) {
+  const events = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.replace(/\r$/, "").trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        events.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return events;
 }
 
-var detect = {};
-
-var processRunner = {};
-
-const require$4 = createRequire(import.meta.url);
-function __require$3() { return require$4("node:child_process"); }
-
-const require$3 = createRequire(import.meta.url);
-function __require$2() { return require$3("node:fs"); }
-
-const require$2 = createRequire(import.meta.url);
-function __require$1() { return require$2("node:os"); }
+const AGENT_ADAPTERS = {
+  "claude-code": claudeCodeAdapter,
+  codex: codexAdapter,
+  pi: piAdapter
+};
 
-const require$1 = createRequire(import.meta.url);
-function __require() { return require$1("node:path"); }
+const LOCAL_AGENT_IDS = ["claude-code", "codex", "pi"];
+const LOCAL_AGENT_ID_SET = new Set(LOCAL_AGENT_IDS);
+function isLocalAgentId(value) {
+  return typeof value === "string" && LOCAL_AGENT_ID_SET.has(value);
+}
 
-var hasRequiredProcessRunner;
-function requireProcessRunner() {
-  if (hasRequiredProcessRunner) return processRunner;
-  hasRequiredProcessRunner = 1;
-  var __createBinding = processRunner && processRunner.__createBinding || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === void 0) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() {
-        return m[k];
-      } };
+const KILL_GRACE_MS = 2e3;
+async function runInvocation(options) {
+  const workDir = fs.mkdtempSync(path.join(os.tmpdir(), "nua-local-agent-"));
+  try {
+    for (const file of options.invocation.files ?? []) {
+      fs.writeFileSync(path.join(workDir, file.name), file.content);
     }
-    Object.defineProperty(o, k2, desc);
-  }) : (function(o, m, k, k2) {
-    if (k2 === void 0) k2 = k;
-    o[k2] = m[k];
-  }));
-  var __setModuleDefault = processRunner && processRunner.__setModuleDefault || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  }) : function(o, v) {
-    o["default"] = v;
-  });
-  var __importStar = processRunner && processRunner.__importStar || /* @__PURE__ */ (function() {
-    var ownKeys = function(o) {
-      ownKeys = Object.getOwnPropertyNames || function(o2) {
-        var ar = [];
-        for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
-        return ar;
-      };
-      return ownKeys(o);
-    };
-    return function(mod) {
-      if (mod && mod.__esModule) return mod;
-      var result = {};
-      if (mod != null) {
-        for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-      }
-      __setModuleDefault(result, mod);
-      return result;
-    };
-  })();
-  Object.defineProperty(processRunner, "__esModule", { value: true });
-  processRunner.runInvocation = runInvocation;
-  processRunner.findOnPath = findOnPath;
-  const node_child_process_1 = __require$3();
-  const fs = __importStar(__require$2());
-  const os = __importStar(__require$1());
-  const path = __importStar(__require());
-  const KILL_GRACE_MS = 2e3;
-  async function runInvocation(options) {
-    const workDir = fs.mkdtempSync(path.join(os.tmpdir(), "nua-local-agent-"));
-    try {
-      for (const file of options.invocation.files ?? []) {
-        fs.writeFileSync(path.join(workDir, file.name), file.content);
-      }
-      const result = await spawnAndCollect(options, workDir);
-      for (const name of options.invocation.outputFiles ?? []) {
-        const filePath = path.join(workDir, name);
-        result.outputFiles[name] = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : void 0;
-      }
-      return result;
-    } finally {
-      fs.rmSync(workDir, { recursive: true, force: true });
+    const result = await spawnAndCollect(options, workDir);
+    for (const name of options.invocation.outputFiles ?? []) {
+      const filePath = path.join(workDir, name);
+      result.outputFiles[name] = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : void 0;
     }
+    return result;
+  } finally {
+    fs.rmSync(workDir, { recursive: true, force: true });
   }
-  function spawnAndCollect(options, cwd) {
-    const env = { ...process.env };
-    for (const name of options.unsetEnv ?? []) {
-      delete env[name];
-    }
-    return new Promise((resolve, reject) => {
-      const child = (0, node_child_process_1.spawn)(options.binaryPath, options.invocation.args, {
-        cwd,
-        env,
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true
-      });
-      const stdout = [];
-      const stderr = [];
-      let timedOut = false;
-      let killTimer;
-      const timeoutTimer = setTimeout(() => {
-        timedOut = true;
-        child.kill("SIGINT");
-        killTimer = setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS);
-      }, options.timeoutMs);
-      child.stdout.on("data", (chunk) => stdout.push(chunk));
-      child.stderr.on("data", (chunk) => stderr.push(chunk));
-      child.on("error", (error) => {
-        clearTimeout(timeoutTimer);
-        clearTimeout(killTimer);
-        const reason = error.code === "ENOENT" ? "not found" : error.message;
-        reject(new Error(`Could not start ${options.binaryPath}: ${reason}`));
-      });
-      child.on("close", (exitCode) => {
-        clearTimeout(timeoutTimer);
-        clearTimeout(killTimer);
-        resolve({
-          exitCode,
-          stdout: Buffer.concat(stdout).toString("utf8"),
-          stderr: Buffer.concat(stderr).toString("utf8"),
-          timedOut,
-          outputFiles: {}
-        });
+}
+function spawnAndCollect(options, cwd) {
+  const env = { ...process.env };
+  for (const name of options.unsetEnv ?? []) {
+    delete env[name];
+  }
+  return new Promise((resolve, reject) => {
+    const child = spawn(options.binaryPath, options.invocation.args, {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const stdout = [];
+    const stderr = [];
+    let timedOut = false;
+    let killTimer;
+    const timeoutTimer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGINT");
+      killTimer = setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS);
+    }, options.timeoutMs);
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.on("error", (error) => {
+      clearTimeout(timeoutTimer);
+      clearTimeout(killTimer);
+      const reason = error.code === "ENOENT" ? "not found" : error.message;
+      reject(new Error(`Could not start ${options.binaryPath}: ${reason}`));
+    });
+    child.on("close", (exitCode) => {
+      clearTimeout(timeoutTimer);
+      clearTimeout(killTimer);
+      resolve({
+        exitCode,
+        stdout: Buffer.concat(stdout).toString("utf8"),
+        stderr: Buffer.concat(stderr).toString("utf8"),
+        timedOut,
+        outputFiles: {}
       });
-      child.stdin.on("error", () => void 0);
-      child.stdin.end(options.invocation.stdin);
     });
+    child.stdin.on("error", () => void 0);
+    child.stdin.end(options.invocation.stdin);
+  });
+}
+function findOnPath(binaryName) {
+  const isWindows = process.platform === "win32";
+  const extensions = isWindows ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean) : [""];
+  if (isWindows) {
+    extensions.sort((a, b) => Number(b.toUpperCase() === ".EXE") - Number(a.toUpperCase() === ".EXE"));
   }
-  function findOnPath(binaryName) {
-    const isWindows = process.platform === "win32";
-    const extensions = isWindows ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean) : [""];
-    if (isWindows) {
-      extensions.sort((a, b) => Number(b.toUpperCase() === ".EXE") - Number(a.toUpperCase() === ".EXE"));
-    }
-    for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
-      if (!dir)
-        continue;
-      for (const ext of extensions) {
-        const candidate = path.join(dir, binaryName + ext);
-        try {
-          if (fs.statSync(candidate).isFile()) {
-            if (!isWindows)
-              fs.accessSync(candidate, fs.constants.X_OK);
-            return candidate;
-          }
-        } catch {
+  for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+    if (!dir) continue;
+    for (const ext of extensions) {
+      const candidate = path.join(dir, binaryName + ext);
+      try {
+        if (fs.statSync(candidate).isFile()) {
+          if (!isWindows) fs.accessSync(candidate, fs.constants.X_OK);
+          return candidate;
         }
+      } catch {
       }
     }
-    return null;
   }
-  return processRunner;
+  return null;
 }
 
-var hasRequiredDetect;
-function requireDetect() {
-  if (hasRequiredDetect) return detect;
-  hasRequiredDetect = 1;
-  Object.defineProperty(detect, "__esModule", { value: true });
-  detect.detectLocalAgents = detectLocalAgents;
-  const adapters_1 = requireAdapters();
-  const agent_id_1 = requireAgentId();
-  const process_runner_1 = requireProcessRunner();
-  const STATUS_TIMEOUT_MS = 2e4;
-  async function detectLocalAgents(binaryPaths = {}) {
-    return Promise.all(agent_id_1.LOCAL_AGENT_IDS.map((id) => detectAgent(adapters_1.AGENT_ADAPTERS[id], binaryPaths[id])));
+const STATUS_TIMEOUT_MS = 2e4;
+async function detectLocalAgents(binaryPaths = {}) {
+  return Promise.all(
+    LOCAL_AGENT_IDS.map((id) => detectAgent(AGENT_ADAPTERS[id], binaryPaths[id]))
+  );
+}
+async function detectAgent(adapter, binaryPathOverride) {
+  const binaryPath = binaryPathOverride ?? findOnPath(adapter.binaryName);
+  if (!binaryPath) {
+    return { agent: adapter.id, installed: false, loggedIn: false };
   }
-  async function detectAgent(adapter, binaryPathOverride) {
-    const binaryPath = binaryPathOverride ?? (0, process_runner_1.findOnPath)(adapter.binaryName);
-    if (!binaryPath) {
-      return { agent: adapter.id, installed: false, loggedIn: false };
-    }
-    try {
-      const [versionResult, statusResult] = await Promise.all([
-        (0, process_runner_1.runInvocation)({
-          binaryPath,
-          invocation: { args: ["--version"], stdin: "" },
-          timeoutMs: STATUS_TIMEOUT_MS
-        }),
-        (0, process_runner_1.runInvocation)({
-          binaryPath,
-          invocation: { args: adapter.loginStatusArgs, stdin: "" },
-          timeoutMs: STATUS_TIMEOUT_MS,
-          // Report the CLI's own login, not an API key that happens to be set.
-          unsetEnv: adapter.apiKeyEnvVars
-        })
-      ]);
-      if (versionResult.exitCode !== 0) {
-        return {
-          agent: adapter.id,
-          installed: false,
-          loggedIn: false,
-          detail: `${binaryPath} --version exited with code ${versionResult.exitCode}`
-        };
-      }
-      const login = adapter.readLoginStatus(statusResult);
-      return {
-        agent: adapter.id,
-        installed: true,
-        loggedIn: login.loggedIn,
+  try {
+    const [versionResult, statusResult] = await Promise.all([
+      runInvocation({
         binaryPath,
-        version: versionResult.stdout.trim() || void 0,
-        detail: login.detail
-      };
-    } catch (error) {
+        invocation: { args: ["--version"], stdin: "" },
+        timeoutMs: STATUS_TIMEOUT_MS
+      }),
+      runInvocation({
+        binaryPath,
+        invocation: { args: adapter.loginStatusArgs, stdin: "" },
+        timeoutMs: STATUS_TIMEOUT_MS,
+        // Report the CLI's own login, not an API key that happens to be set.
+        unsetEnv: adapter.apiKeyEnvVars
+      })
+    ]);
+    if (versionResult.exitCode !== 0) {
       return {
         agent: adapter.id,
         installed: false,
         loggedIn: false,
-        detail: error instanceof Error ? error.message : String(error)
+        detail: `${binaryPath} --version exited with code ${versionResult.exitCode}`
       };
     }
+    const login = adapter.readLoginStatus(statusResult);
+    return {
+      agent: adapter.id,
+      installed: true,
+      loggedIn: login.loggedIn,
+      binaryPath,
+      version: versionResult.stdout.trim() || void 0,
+      detail: login.detail
+    };
+  } catch (error) {
+    return {
+      agent: adapter.id,
+      installed: false,
+      loggedIn: false,
+      detail: error instanceof Error ? error.message : String(error)
+    };
   }
-  return detect;
 }
 
-var localAgent = {};
-
-var localAgentEngine = {};
-
-var hasRequiredLocalAgentEngine;
-function requireLocalAgentEngine() {
-  if (hasRequiredLocalAgentEngine) return localAgentEngine;
-  hasRequiredLocalAgentEngine = 1;
-  Object.defineProperty(localAgentEngine, "__esModule", { value: true });
-  localAgentEngine.LocalAgentEngine = void 0;
-  const logger_1 = requireLogger();
-  const process_runner_1 = requireProcessRunner();
-  class LocalAgentEngine {
-    constructor(runner, model) {
-      this.runner = runner;
-      this.model = model;
-    }
-    nativeSchema(envelopeSchema) {
-      return this.runner.adapter.nativeSchema(envelopeSchema);
-    }
-    attempt(request) {
-      return this.runner.limiter.run(() => this.runAgent(request));
-    }
-    async runAgent(request) {
-      const { adapter, binaryPath, logger, timeoutMs, unsetEnv } = this.runner;
-      const spanId = (0, logger_1.generateSpanId)();
-      const startTime = Date.now();
-      const method = request.enforcement.kind;
-      logger.info("LLM call started", {
-        type: "llm_call_start",
-        span_id: spanId,
-        service: adapter.id,
-        method,
+class LocalAgentEngine {
+  constructor(runner, call) {
+    this.runner = runner;
+    this.call = call;
+  }
+  nativeSchema(envelopeSchema) {
+    return this.runner.adapter.nativeSchema(envelopeSchema);
+  }
+  attempt(request) {
+    return this.runner.limiter.run(() => this.runAgent(request));
+  }
+  async runAgent(request) {
+    const { adapter, binaryPath, logger, unsetEnv } = this.runner;
+    const { model, effort, timeoutMs } = this.call;
+    const spanId = generateSpanId();
+    const startTime = Date.now();
+    const method = request.enforcement.kind;
+    logger.info("LLM call started", {
+      type: "llm_call_start",
+      span_id: spanId,
+      service: adapter.id,
+      method,
+      binaryPath,
+      model: model ?? "default"
+    });
+    const failed = (failure) => {
+      logLlmCallError(logger, spanId, adapter.id, method, failure.message, Date.now() - startTime);
+      return { kind: "failed", failure };
+    };
+    let result;
+    try {
+      result = await runInvocation({
         binaryPath,
-        model: this.model ?? "default"
+        invocation: adapter.buildInvocation(request, { model, effort }),
+        timeoutMs,
+        unsetEnv
       });
-      const failed = (failure) => {
-        (0, logger_1.logLlmCallError)(logger, spanId, adapter.id, method, failure.message, Date.now() - startTime);
-        return { kind: "failed", failure };
-      };
-      let result;
-      try {
-        result = await (0, process_runner_1.runInvocation)({
-          binaryPath,
-          invocation: adapter.buildInvocation(request, this.model),
-          timeoutMs,
-          unsetEnv
-        });
-      } catch (error) {
-        return failed({ kind: "fatal", message: error instanceof Error ? error.message : String(error) });
-      }
-      if (result.timedOut) {
-        return failed({ kind: "fatal", message: `${adapter.id} did not finish within ${timeoutMs}ms` });
-      }
-      const reply = adapter.readResult(result, request);
-      if (reply.kind === "failed") {
-        return failed(reply.failure);
+    } catch (error) {
+      return failed({ kind: "fatal", message: error instanceof Error ? error.message : String(error) });
+    }
+    if (result.timedOut) {
+      return failed({ kind: "fatal", message: `did not finish within ${timeoutMs}ms` });
+    }
+    const reply = adapter.readResult(result, request);
+    if (reply.kind === "failed") {
+      return failed(reply.failure);
+    }
+    logger.info("LLM call completed", {
+      type: "llm_call_complete",
+      span_id: spanId,
+      service: adapter.id,
+      method,
+      exitCode: result.exitCode,
+      usage: reply.usage,
+      duration_ms: Date.now() - startTime
+    });
+    return {
+      kind: "answered",
+      answer: reply.answer,
+      usage: reply.usage,
+      origin: {
+        engine: "local-agent",
+        agent: adapter.id,
+        model: reply.model ?? model,
+        costUsdEstimate: reply.costUsdEstimate
       }
-      logger.info("LLM call completed", {
-        type: "llm_call_complete",
-        span_id: spanId,
-        service: adapter.id,
-        method,
-        exitCode: result.exitCode,
-        usage: reply.usage,
-        duration_ms: Date.now() - startTime
-      });
-      return {
-        kind: "answered",
-        answer: reply.answer,
-        usage: reply.usage,
-        origin: {
-          engine: "local-agent",
-          agent: adapter.id,
-          model: reply.model ?? this.model,
-          costUsdEstimate: reply.costUsdEstimate
-        }
-      };
-    }
+    };
   }
-  localAgentEngine.LocalAgentEngine = LocalAgentEngine;
-  return localAgentEngine;
 }
 
-var hasRequiredLocalAgent$1;
-function requireLocalAgent$1() {
-  if (hasRequiredLocalAgent$1) return localAgent;
-  hasRequiredLocalAgent$1 = 1;
-  Object.defineProperty(localAgent, "__esModule", { value: true });
-  localAgent.LocalAgent = void 0;
-  const local_agent_engine_1 = requireLocalAgentEngine();
-  class LocalAgent {
-    constructor(runner, defaultModel) {
-      this.runner = runner;
-      this.defaultModel = defaultModel;
-      this.agent = runner.adapter.id;
-      this.logger = runner.logger;
+class LocalAgent {
+  constructor(runner, call) {
+    this.runner = runner;
+    this.call = call;
+    this.agent = runner.adapter.id;
+    this.logger = runner.logger;
+  }
+  /**
+   * The same agent with other call options, sharing this one's executable,
+   * environment, logger and limit on processes running at once. Options left
+   * out keep this agent's; a model or effort given as undefined is the CLI's
+   * default.
+   */
+  with(options) {
+    if (options.model !== void 0 && options.model.trim() === "") {
+      throw new TypeError("model must be a non-empty string; pass undefined to use the agent's default model");
     }
-    /**
-     * No model choice runs the default model. An alias runs the CLI's equivalent
-     * model, if it has one. Provider models cannot run on a local agent.
-     */
-    route(model) {
-      if (model === void 0) {
-        return this.routeTo(this.defaultModel);
-      }
-      if (!("alias" in model)) {
-        return {
-          kind: "unroutable",
-          message: `${this.agent} takes model aliases, not provider models. Set the agent's own model with localAgent({ model }).`
-        };
-      }
-      const agentModel = this.runner.adapter.modelAliases[model.alias];
-      if (agentModel === void 0) {
-        return { kind: "unroutable", message: `Model alias "${model.alias}" has no ${this.agent} equivalent` };
-      }
-      return this.routeTo(agentModel);
+    return new LocalAgent(this.runner, {
+      ...this.call,
+      ...options,
+      timeoutMs: options.timeoutMs ?? this.call.timeoutMs
+    });
+  }
+  /**
+   * No model choice runs the default model. An alias runs the CLI's equivalent
+   * model, if it has one. Provider models cannot run on a local agent.
+   */
+  route(model) {
+    if (model === void 0) {
+      return this.routeTo(this.call);
+    }
+    if (!("alias" in model)) {
+      return {
+        kind: "unroutable",
+        message: `${this.agent} takes model aliases, not provider models. Set the agent's own model with localAgent({ model }) or with().`
+      };
     }
-    routeTo(model) {
-      return { kind: "routed", engine: new local_agent_engine_1.LocalAgentEngine(this.runner, model) };
+    const agentModel = this.runner.adapter.modelAliases[model.alias];
+    if (agentModel === void 0) {
+      return { kind: "unroutable", message: `Model alias "${model.alias}" has no ${this.agent} equivalent` };
     }
+    return this.routeTo({ ...this.call, model: agentModel });
+  }
+  routeTo(call) {
+    return { kind: "routed", engine: new LocalAgentEngine(this.runner, call) };
   }
-  localAgent.LocalAgent = LocalAgent;
-  return localAgent;
 }
 
-var semaphore = {};
-
-var hasRequiredSemaphore;
-function requireSemaphore() {
-  if (hasRequiredSemaphore) return semaphore;
-  hasRequiredSemaphore = 1;
-  Object.defineProperty(semaphore, "__esModule", { value: true });
-  semaphore.Semaphore = void 0;
-  class Semaphore {
-    constructor(limit) {
-      this.limit = limit;
-      this.active = 0;
-      this.waiting = [];
+class Semaphore {
+  constructor(limit) {
+    this.limit = limit;
+    this.active = 0;
+    this.waiting = [];
+  }
+  async run(task) {
+    if (this.active >= this.limit) {
+      await new Promise((resolve) => this.waiting.push(resolve));
+    } else {
+      this.active++;
     }
-    async run(task) {
-      if (this.active >= this.limit) {
-        await new Promise((resolve) => this.waiting.push(resolve));
+    try {
+      return await task();
+    } finally {
+      const next = this.waiting.shift();
+      if (next) {
+        next();
       } else {
-        this.active++;
-      }
-      try {
-        return await task();
-      } finally {
-        const next = this.waiting.shift();
-        if (next) {
-          next();
-        } else {
-          this.active--;
-        }
+        this.active--;
       }
     }
   }
-  semaphore.Semaphore = Semaphore;
-  return semaphore;
 }
 
-var hasRequiredCreateLocalAgent;
-function requireCreateLocalAgent() {
-  if (hasRequiredCreateLocalAgent) return createLocalAgent;
-  hasRequiredCreateLocalAgent = 1;
-  Object.defineProperty(createLocalAgent, "__esModule", { value: true });
-  createLocalAgent.localAgent = localAgent;
-  createLocalAgent.findLocalAgent = findLocalAgent;
-  const logger_1 = requireLogger();
-  const adapters_1 = requireAdapters();
-  const agent_id_1 = requireAgentId();
-  const detect_1 = requireDetect();
-  const local_agent_1 = requireLocalAgent$1();
-  const process_runner_1 = requireProcessRunner();
-  const semaphore_1 = requireSemaphore();
-  const DEFAULT_TIMEOUT_MS = 18e4;
-  const DEFAULT_CONCURRENCY = 2;
-  function localAgent(config) {
-    if (!(0, agent_id_1.isLocalAgentId)(config.agent)) {
-      throw new TypeError(`Unknown local agent: ${String(config.agent)}`);
-    }
-    const settings = parseOptions(config);
-    const adapter = adapters_1.AGENT_ADAPTERS[config.agent];
-    const binaryPath = config.binaryPath ?? (0, process_runner_1.findOnPath)(adapter.binaryName);
-    if (!binaryPath) {
-      throw new Error(`${adapter.binaryName} was not found on PATH. Install ${config.agent} or set binaryPath.`);
-    }
-    return setUpLocalAgent(adapter, binaryPath, settings);
+const DEFAULT_TIMEOUT_MS = 18e4;
+const DEFAULT_CONCURRENCY = 2;
+function localAgent(config) {
+  if (!isLocalAgentId(config.agent)) {
+    throw new TypeError(`Unknown local agent: ${String(config.agent)}`);
   }
-  async function findLocalAgent(options = {}) {
-    const settings = parseOptions(options);
-    const statuses = await (0, detect_1.detectLocalAgents)();
-    for (const status of statuses) {
-      if (status.installed && status.loggedIn) {
-        return setUpLocalAgent(adapters_1.AGENT_ADAPTERS[status.agent], status.binaryPath, settings);
-      }
-    }
-    const summary = statuses.map((s) => `${s.agent}: ${s.installed ? "not logged in" : "not installed"}`).join(", ");
-    throw new Error(`No logged-in coding agent found (${summary})`);
+  const settings = parseOptions(config);
+  const adapter = AGENT_ADAPTERS[config.agent];
+  const binaryPath = config.binaryPath ?? findOnPath(adapter.binaryName);
+  if (!binaryPath) {
+    throw new Error(`${adapter.binaryName} was not found on PATH. Install ${config.agent} or set binaryPath.`);
   }
-  function parseOptions(options) {
-    const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
-    if (!Number.isInteger(concurrency) || concurrency < 1) {
-      throw new TypeError("concurrency must be a positive integer");
-    }
-    if (options.model !== void 0 && options.model.trim() === "") {
-      throw new TypeError("model must be a non-empty string; omit it to use the agent's default model");
+  return setUpLocalAgent(adapter, binaryPath, settings);
+}
+async function findLocalAgent(options = {}) {
+  const settings = parseOptions(options);
+  const statuses = await detectLocalAgents();
+  for (const status of statuses) {
+    if (status.installed && status.loggedIn) {
+      return setUpLocalAgent(AGENT_ADAPTERS[status.agent], status.binaryPath, settings);
     }
-    return {
-      model: options.model,
-      timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-      concurrency,
-      auth: options.auth ?? "subscription",
-      logger: options.logger ?? new logger_1.ConsoleLogger()
-    };
   }
-  function setUpLocalAgent(adapter, binaryPath, settings) {
-    if (/\.(cmd|bat)$/i.test(binaryPath)) {
-      throw new Error(`${binaryPath} is a .cmd shim, which local agents cannot run safely. Set binaryPath to the agent's native executable.`);
-    }
-    const runner = {
-      adapter,
-      binaryPath,
-      timeoutMs: settings.timeoutMs,
-      unsetEnv: settings.auth === "subscription" ? adapter.apiKeyEnvVars : [],
-      limiter: new semaphore_1.Semaphore(settings.concurrency),
-      logger: settings.logger
-    };
-    return new local_agent_1.LocalAgent(runner, settings.model);
+  const summary = statuses.map((s) => `${s.agent}: ${s.installed ? "not logged in" : "not installed"}`).join(", ");
+  throw new Error(`No logged-in coding agent found (${summary})`);
+}
+function parseOptions(options) {
+  const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new TypeError("concurrency must be a positive integer");
   }
-  return createLocalAgent;
+  if (options.model !== void 0 && options.model.trim() === "") {
+    throw new TypeError("model must be a non-empty string; omit it to use the agent's default model");
+  }
+  return {
+    model: options.model,
+    effort: options.effort,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    concurrency,
+    auth: options.auth ?? "subscription",
+    logger: options.logger ?? new ConsoleLogger()
+  };
 }
-
-var hasRequiredLocalAgent;
-function requireLocalAgent() {
-  if (hasRequiredLocalAgent) return localAgent$1;
-  hasRequiredLocalAgent = 1;
-  (function(exports$1) {
-    Object.defineProperty(exports$1, "__esModule", { value: true });
-    exports$1.isLocalAgentId = exports$1.LOCAL_AGENT_IDS = exports$1.detectLocalAgents = exports$1.localAgent = exports$1.findLocalAgent = void 0;
-    var create_local_agent_1 = requireCreateLocalAgent();
-    Object.defineProperty(exports$1, "findLocalAgent", { enumerable: true, get: function() {
-      return create_local_agent_1.findLocalAgent;
-    } });
-    Object.defineProperty(exports$1, "localAgent", { enumerable: true, get: function() {
-      return create_local_agent_1.localAgent;
-    } });
-    var detect_1 = requireDetect();
-    Object.defineProperty(exports$1, "detectLocalAgents", { enumerable: true, get: function() {
-      return detect_1.detectLocalAgents;
-    } });
-    var agent_id_1 = requireAgentId();
-    Object.defineProperty(exports$1, "LOCAL_AGENT_IDS", { enumerable: true, get: function() {
-      return agent_id_1.LOCAL_AGENT_IDS;
-    } });
-    Object.defineProperty(exports$1, "isLocalAgentId", { enumerable: true, get: function() {
-      return agent_id_1.isLocalAgentId;
-    } });
-  })(localAgent$1);
-  return localAgent$1;
+function setUpLocalAgent(adapter, binaryPath, settings) {
+  if (/\.(cmd|bat)$/i.test(binaryPath)) {
+    throw new Error(
+      `${binaryPath} is a .cmd shim, which local agents cannot run safely. Set binaryPath to the agent's native executable.`
+    );
+  }
+  const runner = {
+    adapter,
+    binaryPath,
+    unsetEnv: settings.auth === "subscription" ? adapter.apiKeyEnvVars : [],
+    limiter: new Semaphore(settings.concurrency),
+    logger: settings.logger
+  };
+  return new LocalAgent(runner, {
+    model: settings.model,
+    effort: settings.effort,
+    timeoutMs: settings.timeoutMs
+  });
 }
 
-var localAgentExports = requireLocalAgent();
+const LINUX_MAX_ARGUMENT_BYTES = 131072;
+function agentSessionMode(platform = process.platform) {
+  if (platform === "win32") return "none";
+  return platform === "darwin" ? "terminal" : "command";
+}
+async function startAgentSession(config) {
+  if (!isLocalAgentId(config.agent)) {
+    throw new TypeError(`Unknown local agent: ${String(config.agent)}`);
+  }
+  const platform = config.platform ?? process.platform;
+  const mode = agentSessionMode(platform);
+  if (mode === "none") {
+    return refused("unsupported_platform", `Agent sessions need a POSIX shell, which ${platform} lacks.`);
+  }
+  if (platform === "linux" && Buffer.byteLength(config.prompt) >= LINUX_MAX_ARGUMENT_BYTES) {
+    return refused("prompt_too_long", `The prompt is too long to pass to ${config.agent} on ${platform}.`);
+  }
+  const adapter = AGENT_ADAPTERS[config.agent];
+  const binaryPath = config.binaryPath ?? findOnPath(adapter.binaryName);
+  if (!binaryPath) {
+    return refused(
+      "agent_not_found",
+      `${adapter.binaryName} was not found on PATH. Install ${config.agent} or set binaryPath.`
+    );
+  }
+  const files = writeSessionFiles(config, binaryPath, adapter.sessionArgs(config.model, config.approval ?? "ask"));
+  if (mode === "command") return { kind: "command", files };
+  try {
+    await promisify(execFile)("open", [files.launcherPath]);
+  } catch (error) {
+    return { kind: "open_failed", files, error: error instanceof Error ? error.message : String(error) };
+  }
+  return { kind: "opened", files };
+}
+function refused(reason, message) {
+  return { kind: "refused", reason, message };
+}
+function writeSessionFiles(config, binaryPath, agentArgs) {
+  const name = config.name ?? defaultSessionName(config.agent);
+  fs.mkdirSync(config.dir, { recursive: true, mode: 448 });
+  const promptPath = path.join(config.dir, `${name}.md`);
+  const launcherPath = path.join(config.dir, `${name}.command`);
+  fs.writeFileSync(promptPath, config.prompt, { mode: 384, flag: "wx" });
+  fs.writeFileSync(launcherPath, sessionLauncher({ cwd: config.cwd, binaryPath, agentArgs, promptPath }), {
+    mode: 448,
+    flag: "wx"
+  });
+  return { promptPath, launcherPath, command: `sh ${shellQuote(launcherPath)}` };
+}
+function defaultSessionName(agent) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replaceAll(":", "-");
+  return `${stamp}-${agent}-${randomBytes(2).toString("hex")}`;
+}
+function sessionLauncher({ cwd, binaryPath, agentArgs, promptPath }) {
+  const command = [binaryPath, ...agentArgs].map(shellQuote).join(" ");
+  return [
+    "#!/bin/sh",
+    `cd ${shellQuote(cwd)} || exit 1`,
+    `exec ${command} -- "$(cat ${shellQuote(promptPath)})"`,
+    ""
+  ].join("\n");
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
 
-var LOCAL_AGENT_IDS = localAgentExports.LOCAL_AGENT_IDS;
-var detectLocalAgents = localAgentExports.detectLocalAgents;
-var findLocalAgent = localAgentExports.findLocalAgent;
-var isLocalAgentId = localAgentExports.isLocalAgentId;
-var localAgent$2 = localAgentExports.localAgent;
-export { LOCAL_AGENT_IDS, detectLocalAgents, findLocalAgent, isLocalAgentId, localAgent$2 as localAgent };
+export { LOCAL_AGENT_IDS, agentSessionMode, detectLocalAgents, findLocalAgent, isLocalAgentId, localAgent, sessionLauncher, startAgentSession };