nuabase 2.3.4 → 2.3.5

package/dist/esm/local-agent.mjs

@@ -0,0 +1,884 @@
+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;
+  }
+  return failureClassification;
+}
+
+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
+      };
+      if (request.enforcement.kind === "in-prompt") {
+        return { kind: "answered", answer: { kind: "text", text: json.result ?? "" }, ...reported };
+      }
+      if (!json.structured_output) {
+        return {
+          kind: "failed",
+          failure: {
+            kind: "transient",
+            message: `claude returned no structured output. Reply: ${json.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: (0, failure_classification_1.stderrTail)(result) || result.stdout.trim() };
+      }
+    }
+  };
+  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 (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;
+    }
+    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;
+        }
+        result[defsKey] = defs;
+      }
+    }
+    return result;
+  }
+  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) {
+        return {
+          kind: "failed",
+          failure: (0, failure_classification_1.classifyAgentFailure)("codex", `exited with code ${result.exitCode} without a reply: ${(0, failure_classification_1.stderrTail)(result)}`)
+        };
+      }
+      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
+      };
+      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 {
+      }
+    }
+    return events;
+  }
+  return codex;
+}
+
+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();
+  adapters.AGENT_ADAPTERS = {
+    "claude-code": claude_code_1.claudeCodeAdapter,
+    codex: codex_1.codexAdapter
+  };
+  return adapters;
+}
+
+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"];
+    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);
+    }
+  })(agentId);
+  return agentId;
+}
+
+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 require$1 = createRequire(import.meta.url);
+function __require() { return require$1("node:path"); }
+
+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];
+      } };
+    }
+    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 });
+    }
+  }
+  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: {}
+        });
+      });
+      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"));
+    }
+    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;
+}
+
+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])));
+  }
+  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,
+        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,
+        binaryPath,
+        model: this.model ?? "default"
+      });
+      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);
+      }
+      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;
+    }
+    /**
+     * 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);
+    }
+    routeTo(model) {
+      return { kind: "routed", engine: new local_agent_engine_1.LocalAgentEngine(this.runner, model) };
+    }
+  }
+  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 = [];
+    }
+    async run(task) {
+      if (this.active >= this.limit) {
+        await new Promise((resolve) => this.waiting.push(resolve));
+      } else {
+        this.active++;
+      }
+      try {
+        return await task();
+      } finally {
+        const next = this.waiting.shift();
+        if (next) {
+          next();
+        } else {
+          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);
+  }
+  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})`);
+  }
+  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 {
+      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);
+  }
+  return createLocalAgent;
+}
+
+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;
+}
+
+var localAgentExports = requireLocalAgent();
+
+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 };