@agentproto/driver-agent-cli 0.2.0 → 0.4.0

package/dist/{chunk-YQHVLX6O.mjs → chunk-L6BRNMVP.mjs}

@@ -2,8 +2,11 @@ import { z } from 'zod';
 import { Writable, Readable } from 'stream';
 import { createAcpClient } from '@agentproto/acp/client';
 import { spawn } from 'child_process';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, rmSync, rmdirSync, mkdtempSync } from 'fs';
 import { createInterface } from 'readline';
+import { join } from 'path';
 import { randomUUID } from 'crypto';
+import { tmpdir } from 'os';
 import { createDoctype } from '@agentproto/define-doctype';
 
 /**
@@ -150,12 +153,21 @@ var authSchema = z.object({
 var sessionSchema = z.object({
   mode: z.enum(["ephemeral", "persistent", "resumable"]).default("ephemeral"),
   idle_timeout_ms: z.number().int().min(1e3).default(6e5),
+  // No default: undefined disables the per-turn watchdog entirely. Only
+  // adapters known to sometimes drop the final `prompt` response (e.g.
+  // hermes) should declare this — applying it broadly would risk
+  // false-positiving on another adapter's legitimately long turns.
+  turn_idle_timeout_ms: z.number().int().min(1e3).optional(),
   max_turns: z.number().int().positive().optional(),
   context_carryover: z.boolean().default(true)
 }).strict();
 var modelsSchema = z.object({
   default: z.string().optional(),
   allowed: z.array(z.string()).optional(),
+  // Model-id patterns the adapter must never route to (case-insensitive,
+  // trailing `*` = prefix match). Enforced at compose time — see
+  // AgentCliModels.deny. Reserves premium providers for dedicated adapters.
+  deny: z.array(z.string()).optional(),
   env: z.record(z.string(), z.string()).optional(),
   // How a model is selected at session start: "config" (ACP
   // set_config_option, default) | "command" (a `/model <id>` control turn,
@@ -182,8 +194,21 @@ var capabilitiesSchema = z.object({
 var modeSchema = z.object({
   id: z.string().regex(MODE_ID_PATTERN),
   description: z.string().optional(),
+  bin_args_prepend: z.array(z.string()).optional(),
   bin_args_append: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional()
+  env: z.record(z.string(), z.string()).optional(),
+  // Env keys to DELETE from the spawn env (auth hygiene for gateway
+  // modes — see AgentCliMode.env_unset). Applied at the runtime merge
+  // point, not as a static set.
+  env_unset: z.array(z.string()).optional(),
+  // Honest support status surfaced to clients. Absent ⇒ "active".
+  status: z.enum(["active", "noop", "planned"]).optional(),
+  status_note: z.string().optional(),
+  // How the host activates this mode: "bin_args" (default, argv/env
+  // composed at spawn) | "config" (no CLI surface — forwarded to the ACP
+  // arm's connect({mode}) and applied via session/set_config_option
+  // configId:"mode", e.g. opencode).
+  apply: z.enum(["bin_args", "config"]).optional()
 }).strict();
 var optionSchema = z.object({
   id: z.string().regex(OPTION_ID_PATTERN),
@@ -193,9 +218,14 @@ var optionSchema = z.object({
   default: z.union([z.boolean(), z.number(), z.string()]).optional(),
   min: z.number().int().optional(),
   max: z.number().int().optional(),
+  bin_args_prepend: z.array(z.string()).optional(),
   bin_args_template: z.array(z.string()).optional(),
   bin_args_append_when_true: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional()
+  env: z.record(z.string(), z.string()).optional(),
+  // Env keys to DELETE from the spawn env when this option is active
+  // (auth hygiene for value-bearing gateway options — see
+  // AgentCliOption.env_unset). Symmetric with modeSchema.env_unset.
+  env_unset: z.array(z.string()).optional()
 }).strict().refine(
   // type === "enum" REQUIRES an `enum` array. The JSON Schema enforces
   // this via `if/then`; the zod side mirrors with a refine so both
@@ -203,6 +233,17 @@ var optionSchema = z.object({
   (o) => o.type !== "enum" || Array.isArray(o.enum) && o.enum.length > 0,
   { message: "option.type === 'enum' requires a non-empty `enum` array" }
 );
+var presetSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  description: z.string().optional(),
+  schemaFlavor: z.enum(["anthropic", "openai"]),
+  baseUrl: z.string().min(1),
+  keyEnv: z.string().min(1),
+  scrubEnv: z.array(z.string()).optional(),
+  defaultModel: z.string().optional(),
+  homepage: z.string().optional()
+}).strict();
 var continuationStrategyIdSchema = z.enum(CONTINUATION_STRATEGY_IDS);
 var continuationSchema = z.object({
   default: continuationStrategyIdSchema,
@@ -225,6 +266,16 @@ var mcpBlockSchema = z.object({
   transport: z.enum(["stdio", "http", "sse"]),
   url: z.string().url().optional()
 }).strict();
+var printConfigSchema = z.object({
+  prompt_flag: z.string().optional(),
+  output_format: z.array(z.string()).optional(),
+  pre_prompt: z.array(z.string()).optional(),
+  resume: z.object({
+    flag: z.string(),
+    kind: z.enum(["value", "boolean"])
+  }).strict().optional(),
+  event_schema: z.enum(["claude-stream-json", "mastra-jsonl"]).optional()
+}).strict().optional();
 var agentCliFrontmatterSchema = z.object({
   name: z.string().min(1).max(80),
   id: z.string().regex(ID_PATTERN),
@@ -242,11 +293,15 @@ var agentCliFrontmatterSchema = z.object({
   acp: z.string().optional(),
   mcp: mcpBlockSchema.optional(),
   adapter: z.string().regex(ADAPTER_PATTERN).optional(),
+  print: printConfigSchema,
   session: sessionSchema.optional(),
   models: modelsSchema.optional(),
   capabilities: capabilitiesSchema.optional(),
   modes: z.array(modeSchema).optional(),
   options: z.array(optionSchema).optional(),
+  // AIP-45 gateway presets this adapter can drive (merged into the
+  // provider-preset catalog; built-in wins on id collision).
+  presets: z.array(presetSchema).optional(),
   continuation: continuationSchema.optional(),
   requires: z.object({
     os: z.array(z.enum(["darwin", "linux", "windows"])).optional(),
@@ -325,6 +380,21 @@ var autoAllowPermissionHandler = ({
   const allow = options.find((o) => typeof o.kind === "string" && o.kind.startsWith("allow_")) ?? options[0];
   return { outcome: { outcome: "selected", optionId: allow.optionId } };
 };
+var PLAN_MODE_EXIT_TOOL_CALL_KIND = "switch_mode";
+var planModePermissionHandler = (params) => {
+  const { options, toolCall } = params;
+  if (!options || options.length === 0) {
+    return { outcome: { outcome: "cancelled" } };
+  }
+  if (toolCall?.kind === PLAN_MODE_EXIT_TOOL_CALL_KIND) {
+    const keepPlanning = options.find((o) => o.kind === "reject_once");
+    return keepPlanning ? { outcome: { outcome: "selected", optionId: keepPlanning.optionId } } : { outcome: { outcome: "cancelled" } };
+  }
+  return autoAllowPermissionHandler(params);
+};
+function defaultPermissionHandlerForMode(requestedMode) {
+  return requestedMode === "plan" ? planModePermissionHandler : autoAllowPermissionHandler;
+}
 function createAcpProtocolArm(options) {
   const { child, cwd } = options;
   if (!child.stdin || !child.stdout) {
@@ -342,7 +412,7 @@ function createAcpProtocolArm(options) {
       return session?.sessionId;
     },
     async connect(opts) {
-      const permissionHandler = options.onPermissionRequest ?? autoAllowPermissionHandler;
+      const permissionHandler = options.onPermissionRequest ?? defaultPermissionHandlerForMode(options.requestedMode);
       client = await createAcpClient({
         output,
         input,
@@ -350,6 +420,8 @@ function createAcpProtocolArm(options) {
         capabilities: {
           fs: { readTextFile: true, writeTextFile: true }
         },
+        onActivity: opts.onActivity,
+        turnIdleTimeoutMs: opts.turnIdleTimeoutMs,
         // Wire the permission handler so the agent's `session/request_permission`
         // callbacks get a real answer instead of bubbling up as
         // "AcpClient.requestPermission: no handler configured" → which
@@ -370,7 +442,8 @@ function createAcpProtocolArm(options) {
           cwd,
           mcpServers: opts.mcpServers,
           ...opts.model ? { model: opts.model } : {},
-          ...opts.effort ? { effort: opts.effort } : {}
+          ...opts.effort ? { effort: opts.effort } : {},
+          ...opts.mode ? { mode: opts.mode } : {}
         });
       }
     },
@@ -395,9 +468,29 @@ function createAcpProtocolArm(options) {
     }
   };
 }
+
+// src/mcp-servers.ts
+function toFileBasedMcpServers(servers) {
+  if (!servers || servers.length === 0) return void 0;
+  const out = {};
+  for (const s of servers) {
+    out[s.name] = s.transport === "stdio" ? { command: s.ref ?? "" } : { url: s.ref ?? "" };
+  }
+  return out;
+}
+var DEFAULT_OUTPUT = ["--output-format", "stream-json"];
+var DEFAULT_PRE_PROMPT = ["--no-interactive"];
+var DEFAULT_RESUME = { flag: "--resume", kind: "value" };
 function createPrintSession(opts) {
+  const config = opts.printConfig;
+  const outputFormat = config?.output_format ?? DEFAULT_OUTPUT;
+  const prePrompt = config?.pre_prompt ?? DEFAULT_PRE_PROMPT;
+  const promptFlag = config?.prompt_flag;
+  const resumeCfg = config?.resume ?? DEFAULT_RESUME;
+  const eventSchema = config?.event_schema ?? "claude-stream-json";
   let sessionId = opts.resumeSessionId ?? "";
   let activeChild = null;
+  const mcpRestore = setupMcpConfigFile(opts, eventSchema);
   return {
     get sessionId() {
       return sessionId;
@@ -406,13 +499,18 @@ function createPrintSession(opts) {
       const prompt = extractPromptText(message);
       const args = [
         ...opts.baseArgs,
-        "--print",
-        "--output-format",
-        "stream-json",
-        "--no-interactive",
-        ...sessionId ? ["--resume", sessionId] : [],
-        prompt
+        ...outputFormat,
+        ...prePrompt
       ];
+      if (sessionId) {
+        args.push(resumeCfg.flag);
+        if (resumeCfg.kind === "value") args.push(sessionId);
+      }
+      if (promptFlag) {
+        args.push(promptFlag, prompt);
+      } else {
+        args.push(prompt);
+      }
       const child = spawn(opts.bin, args, {
         cwd: opts.cwd,
         env: opts.env,
@@ -430,32 +528,38 @@ function createPrintSession(opts) {
         }
       });
       try {
-        if (!child.stdout) throw new Error("print-arm: child has no stdout pipe");
-        const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
+        if (!child.stdout)
+          throw new Error("print-arm: child has no stdout pipe");
         let capturedSessionId = "";
-        for await (const line of rl) {
-          if (!line.trim()) continue;
+        const mastraState = eventSchema === "mastra-jsonl" ? createMastraMapperState() : void 0;
+        const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
+        const queue = new EventQueue();
+        rl.on("line", (line) => {
+          if (!line.trim()) return;
           let evt;
           try {
             evt = JSON.parse(line);
           } catch {
-            continue;
-          }
-          if (evt.type === "result" && typeof evt.session_id === "string" && evt.session_id) {
-            capturedSessionId = evt.session_id;
+            return;
           }
+          const csid = captureSessionId(evt, eventSchema);
+          if (csid) capturedSessionId = csid;
           const sid = capturedSessionId || sessionId || "";
-          const mapped = mapEvent(evt, sid, stderrLines);
-          if (!mapped) continue;
+          const mapped = mapEvent(evt, sid, stderrLines, eventSchema, mastraState);
+          if (mapped) queue.push(mapped);
+        });
+        rl.once("close", () => queue.end());
+        for await (const mapped of queue) {
           yield mapped;
         }
         const exitCode = await waitForExit(child);
         if (capturedSessionId) sessionId = capturedSessionId;
         if (exitCode !== 0 && exitCode !== null) {
+          const binLabel = eventSchema === "mastra-jsonl" ? "mastracode" : "claude";
           const errEvt = {
             kind: "error",
             error: {
-              message: `claude exited with code ${exitCode}`,
+              message: `${binLabel} exited with code ${exitCode}`,
               ...stderrLines.length ? { data: { stderr: stderrLines.join("\n") } } : {}
             }
           };
@@ -470,6 +574,75 @@ function createPrintSession(opts) {
     },
     async close() {
       activeChild?.kill("SIGTERM");
+      mcpRestore?.();
+    }
+  };
+}
+function setupMcpConfigFile(opts, eventSchema) {
+  if (eventSchema !== "mastra-jsonl") return void 0;
+  if (!opts.mcpServers || opts.mcpServers.length === 0) return void 0;
+  const dir = join(opts.cwd, ".mastracode");
+  const file = join(dir, "mcp.json");
+  const injected = toFileBasedMcpServers(opts.mcpServers);
+  if (!injected) return void 0;
+  const fileExisted = existsSync(file);
+  let originalContent;
+  if (fileExisted) {
+    try {
+      originalContent = readFileSync(file, "utf8");
+    } catch {
+      originalContent = void 0;
+    }
+  }
+  const dirExisted = existsSync(dir);
+  if (!dirExisted) {
+    mkdirSync(dir, { recursive: true });
+  }
+  let existingServers = {};
+  if (originalContent !== void 0) {
+    try {
+      const parsed = JSON.parse(originalContent);
+      if (parsed && typeof parsed.mcpServers === "object" && parsed.mcpServers !== null) {
+        existingServers = parsed.mcpServers;
+      }
+    } catch {
+      existingServers = {};
+    }
+  }
+  const merged = { ...existingServers, ...injected };
+  const output = JSON.stringify({ mcpServers: merged }, null, 2);
+  writeFileSync(file, output, "utf8");
+  return () => {
+    try {
+      if (!fileExisted) {
+        rmSync(file, { force: true });
+        if (!dirExisted) {
+          try {
+            rmdirSync(dir);
+          } catch {
+          }
+        }
+      } else if (originalContent !== void 0) {
+        let current = {};
+        try {
+          const parsed = JSON.parse(readFileSync(file, "utf8"));
+          if (parsed && typeof parsed.mcpServers === "object" && parsed.mcpServers !== null) {
+            current = parsed.mcpServers;
+          }
+        } catch {
+          writeFileSync(file, originalContent, "utf8");
+          return;
+        }
+        for (const key of Object.keys(injected)) {
+          delete current[key];
+        }
+        if (Object.keys(current).length === 0) {
+          writeFileSync(file, originalContent, "utf8");
+        } else {
+          writeFileSync(file, JSON.stringify({ mcpServers: current }, null, 2), "utf8");
+        }
+      }
+    } catch {
     }
   };
 }
@@ -484,7 +657,33 @@ function extractPromptText(message) {
   }
   return JSON.stringify(message);
 }
-function mapEvent(evt, sessionId, stderrLines) {
+function captureSessionId(evt, schema) {
+  switch (schema) {
+    case "claude-stream-json":
+      if (evt.type === "result" && typeof evt.session_id === "string" && evt.session_id)
+        return evt.session_id;
+      return null;
+    case "mastra-jsonl":
+      if (evt.type === "result" && typeof evt.threadId === "string" && evt.threadId)
+        return evt.threadId;
+      return null;
+  }
+}
+function mapEvent(evt, sessionId, stderrLines, schema, mastraState) {
+  switch (schema) {
+    case "claude-stream-json":
+      return mapClaudeEvent(evt, sessionId, stderrLines);
+    case "mastra-jsonl": {
+      if (!mastraState) {
+        return mapClaudeEvent(evt, sessionId, stderrLines);
+      }
+      return mapMastraEvent(evt, sessionId, stderrLines, mastraState);
+    }
+    default:
+      return mapClaudeEvent(evt, sessionId, stderrLines);
+  }
+}
+function mapClaudeEvent(evt, sessionId, stderrLines) {
   switch (evt.type) {
     case "text":
       return typeof evt.text === "string" ? { kind: "text-delta", sessionId, text: evt.text } : null;
@@ -528,6 +727,197 @@ function mapEvent(evt, sessionId, stderrLines) {
       return null;
   }
 }
+function createMastraMapperState() {
+  return { lastTextLength: 0 };
+}
+function extractTextFromBlocks(content) {
+  if (!Array.isArray(content)) return "";
+  return content.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("");
+}
+function mapMastraEvent(evt, sessionId, stderrLines, state) {
+  switch (evt.type) {
+    // ── Text streaming ──────────────────────────────────────────
+    case "message_update": {
+      const content = evt.message?.content;
+      const fullText = extractTextFromBlocks(content);
+      if (fullText.length > state.lastTextLength) {
+        const delta = fullText.slice(state.lastTextLength);
+        state.lastTextLength = fullText.length;
+        return delta ? { kind: "text-delta", sessionId, text: delta } : null;
+      }
+      return null;
+    }
+    case "message_end": {
+      const msg = evt.message;
+      if (msg?.role !== "assistant") return null;
+      const fullText = extractTextFromBlocks(msg?.content);
+      if (fullText.length > state.lastTextLength) {
+        const delta = fullText.slice(state.lastTextLength);
+        state.lastTextLength = fullText.length;
+        return delta ? { kind: "text-delta", sessionId, text: delta } : null;
+      }
+      return null;
+    }
+    // ── Tool calls ──────────────────────────────────────────────
+    case "tool_start":
+      return {
+        kind: "tool-call",
+        sessionId,
+        toolCallId: typeof evt.toolCallId === "string" ? evt.toolCallId : "",
+        toolName: typeof evt.toolName === "string" ? evt.toolName : "?",
+        // Mastra's controller event carries the tool call payload under
+        // `args`, not `input` (that's the Claude Code stream-json field
+        // name used by the sibling mapClaudeEvent tool_use case below).
+        arguments: evt.args ?? {}
+      };
+    case "tool_end":
+      return {
+        kind: "tool-result",
+        sessionId,
+        toolCallId: typeof evt.toolCallId === "string" ? evt.toolCallId : "",
+        result: evt.result ?? null,
+        isError: evt.isError === true
+      };
+    // ── Turn end ────────────────────────────────────────────────
+    case "agent_end": {
+      const rawReason = typeof evt.reason === "string" ? evt.reason : "complete";
+      const reason = mapMastraFinishReason(rawReason);
+      return { kind: "turn-end", sessionId, reason };
+    }
+    // ── Final result line ────────────────────────────────────────
+    // Always written last, once, whether or not `agent_end` fired —
+    // pre-flight failures (bad model, unresolvable thread, missing API
+    // key) call straight into this without ever streaming an
+    // `agent_end` or `error` event. `turn-end` already came from
+    // `agent_end` on the success path, so this only needs to surface
+    // an error for the pre-flight-failure path.
+    case "result": {
+      const err = evt.error;
+      if (!err) return null;
+      return {
+        kind: "error",
+        sessionId,
+        error: {
+          message: typeof err.message === "string" ? err.message : "Unknown error",
+          ...stderrLines.length ? { data: { stderr: stderrLines.join("\n") } } : {}
+        }
+      };
+    }
+    // ── Errors ─────────────────────────────────────────────────
+    case "error": {
+      const err = evt.error;
+      return {
+        kind: "error",
+        sessionId,
+        error: {
+          message: typeof err?.message === "string" ? err.message : "Unknown error",
+          ...stderrLines.length ? { data: { stderr: stderrLines.join("\n") } } : {}
+        }
+      };
+    }
+    // ── Token usage ─────────────────────────────────────────────
+    // Mastra Code DOES expose usage: its `AgentController` emits a native
+    // `usage_update` event ({ type: "usage_update", usage: TokenUsage })
+    // on every model step-finish — verified against @mastra/core 1.48.0's
+    // AgentControllerEvent union and its emit site
+    // (`this.#session.emit({ type: "usage_update", usage: stepUsage })`).
+    // `TokenUsage` carries `{ promptTokens, completionTokens, totalTokens }`.
+    // Map it to this repo's `usage_update` StreamEvent (the SAME shape
+    // claude-code emits over ACP) so mastracode sessions — both the print
+    // arm and the in-process arm, which share this mapper — carry token
+    // telemetry in the transcript. mastracode reports these cumulatively
+    // (its own headless `runMC` result-usage is last-write-wins over these
+    // events), and last-write-wins on the descriptor matches that. It
+    // carries no context-window size/used or per-turn cost here, so those
+    // stay 0 / absent (projectEvent guards on >0, never clobbering a real
+    // size).
+    case "usage_update": {
+      const usage = evt.usage;
+      const promptTokens = typeof usage?.promptTokens === "number" ? usage.promptTokens : void 0;
+      const completionTokens = typeof usage?.completionTokens === "number" ? usage.completionTokens : void 0;
+      if (promptTokens === void 0 && completionTokens === void 0)
+        return null;
+      return {
+        kind: "usage_update",
+        sessionId,
+        size: 0,
+        used: 0,
+        ...promptTokens !== void 0 ? { tokensIn: promptTokens } : {},
+        ...completionTokens !== void 0 ? { tokensOut: completionTokens } : {}
+      };
+    }
+    // ── Shell output (tool-like) ────────────────────────────────
+    case "shell_output":
+      return typeof evt.output === "string" ? {
+        kind: "tool-result",
+        sessionId,
+        toolCallId: "",
+        result: evt.output,
+        isError: false
+      } : null;
+    // ── Skipped events ─────────────────────────────────────────
+    case "agent_start":
+    case "subagent_start":
+    case "subagent_end":
+    case "tool_approval_required":
+    case "tool_suspended":
+      return null;
+    default:
+      return null;
+  }
+}
+var QUEUE_HIGH_WATER_MARK = 1e4;
+var EventQueue = class {
+  buffer = [];
+  resolveNext = null;
+  ended = false;
+  highWaterWarned = false;
+  push(evt) {
+    this.buffer.push(evt);
+    if (this.buffer.length > QUEUE_HIGH_WATER_MARK && !this.highWaterWarned) {
+      this.highWaterWarned = true;
+      console.warn(
+        `print-arm: event backlog exceeded ${QUEUE_HIGH_WATER_MARK} buffered events \u2014 downstream consumer is not keeping up. The child's stdout is still being drained (no ENOBUFS), but memory will grow until the consumer catches up.`
+      );
+    }
+    const resolve = this.resolveNext;
+    this.resolveNext = null;
+    resolve?.();
+  }
+  /** Signal that no further events will be pushed. */
+  end() {
+    this.ended = true;
+    const resolve = this.resolveNext;
+    this.resolveNext = null;
+    resolve?.();
+  }
+  async *[Symbol.asyncIterator]() {
+    for (; ; ) {
+      const evt = this.buffer.shift();
+      if (evt !== void 0) {
+        yield evt;
+        continue;
+      }
+      if (this.ended) return;
+      await new Promise((resolve) => {
+        this.resolveNext = resolve;
+      });
+    }
+  }
+};
+function mapMastraFinishReason(raw) {
+  switch (raw) {
+    case "complete":
+      return "completed";
+    case "aborted":
+    case "suspended":
+      return "cancelled";
+    case "error":
+      return "error";
+    default:
+      return "completed";
+  }
+}
 function waitForExit(child) {
   return new Promise((resolve) => {
     child.once("exit", (code) => resolve(code));
@@ -535,6 +925,27 @@ function waitForExit(child) {
   });
 }
 
+// src/protocol/proprietary.ts
+async function createProprietaryProtocolArm(options) {
+  let mod;
+  try {
+    mod = await import(options.adapter);
+  } catch (err) {
+    const cause = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `createProprietaryProtocolArm: could not load adapter package '${options.adapter}'. Install it with: npm i ${options.adapter}
+  cause: ${cause}`
+    );
+  }
+  const candidate = "createAgentCliClient" in mod ? mod.createAgentCliClient : mod.default;
+  if (typeof candidate !== "function") {
+    throw new Error(
+      `createProprietaryProtocolArm: adapter package '${options.adapter}' does not export a 'createAgentCliClient' factory function (or a default export function). A protocol="proprietary" adapter must export createAgentCliClient(definition: AgentCliHandle): AgentCliClient | Promise<AgentCliClient>.`
+    );
+  }
+  return await candidate(options.definition);
+}
+
 // src/manifest/compose.ts
 var RuntimeConfigError = class extends Error {
   code;
@@ -547,9 +958,11 @@ var RuntimeConfigError = class extends Error {
   }
 };
 function composeSpawn(handle, config) {
-  const binArgs = [...handle.bin_args ?? []];
+  if (!config) return { binArgs: [...handle.bin_args ?? []], env: {}, envUnset: [] };
+  const prepend = [];
+  const append = [];
   const env = {};
-  if (!config) return { binArgs, env };
+  const envUnset = [];
   if (config.mode !== void 0) {
     const mode = (handle.modes ?? []).find((m) => m.id === config.mode);
     if (!mode) {
@@ -560,8 +973,12 @@ function composeSpawn(handle, config) {
         `Mode '${config.mode}' is not declared by manifest '${handle.id}'. Known modes: ${known}`
       );
     }
-    if (mode.bin_args_append) binArgs.push(...mode.bin_args_append);
-    if (mode.env) Object.assign(env, mode.env);
+    if ((mode.apply ?? "bin_args") === "bin_args") {
+      if (mode.bin_args_prepend) prepend.push(...mode.bin_args_prepend);
+      if (mode.bin_args_append) append.push(...mode.bin_args_append);
+      if (mode.env) Object.assign(env, mode.env);
+      if (mode.env_unset) envUnset.push(...mode.env_unset);
+    }
   }
   if (config.options && Object.keys(config.options).length > 0) {
     const declared = handle.options ?? [];
@@ -581,8 +998,23 @@ function composeSpawn(handle, config) {
       const value = config.options[option.id];
       validateOptionValue(option, value);
       const patch = renderOptionPatch(option, value);
-      binArgs.push(...patch.binArgs);
+      prepend.push(...patch.prepend);
+      append.push(...patch.append);
       Object.assign(env, patch.env);
+      if (patch.envUnset.length) envUnset.push(...patch.envUnset);
+    }
+  }
+  const requestedModel = config.options?.model;
+  if (typeof requestedModel === "string" && handle.models?.deny?.length) {
+    const denyHit = handle.models.deny.find(
+      (pattern) => matchesModelPattern(pattern, requestedModel)
+    );
+    if (denyHit) {
+      throw new RuntimeConfigError(
+        "model_denied",
+        "config.options.model",
+        `Model '${requestedModel}' is denied by manifest '${handle.id}' (matches deny pattern '${denyHit}'). This adapter deliberately does not route to that provider \u2014 use a permitted model or a different adapter.`
+      );
     }
   }
   if (config.continuation !== void 0 && handle.continuation) {
@@ -594,12 +1026,21 @@ function composeSpawn(handle, config) {
       );
     }
   }
-  return { binArgs, env };
+  return {
+    binArgs: [...prepend, ...handle.bin_args ?? [], ...append],
+    env,
+    envUnset
+  };
 }
 function resolveContinuationStrategy(handle, config) {
   if (config?.continuation) return config.continuation;
   return handle.continuation?.default ?? "none";
 }
+function matchesModelPattern(pattern, modelId) {
+  const p = pattern.toLowerCase();
+  const m = modelId.toLowerCase();
+  return p.endsWith("*") ? m.startsWith(p.slice(0, -1)) : m === p;
+}
 function validateOptionValue(option, value) {
   const path = `config.options.${option.id}`;
   switch (option.type) {
@@ -665,17 +1106,23 @@ function validateOptionValue(option, value) {
 function renderOptionPatch(option, value) {
   const stringValue = String(value);
   if (option.type === "boolean") {
-    if (value !== true) return { binArgs: [], env: {} };
+    if (value !== true) return { prepend: [], append: [], env: {}, envUnset: [] };
     return {
-      binArgs: option.bin_args_append_when_true ? [...option.bin_args_append_when_true] : [],
-      env: option.env ? interpolateEnv(option.env, stringValue) : {}
+      prepend: [],
+      append: option.bin_args_append_when_true ? [...option.bin_args_append_when_true] : [],
+      env: option.env ? interpolateEnv(option.env, stringValue) : {},
+      envUnset: option.env_unset ? [...option.env_unset] : []
     };
   }
   return {
-    binArgs: option.bin_args_template ? option.bin_args_template.map(
+    prepend: option.bin_args_prepend ? option.bin_args_prepend.map(
       (token) => token.replace(/\{value\}/g, stringValue)
     ) : [],
-    env: option.env ? interpolateEnv(option.env, stringValue) : {}
+    append: option.bin_args_template ? option.bin_args_template.map(
+      (token) => token.replace(/\{value\}/g, stringValue)
+    ) : [],
+    env: option.env ? interpolateEnv(option.env, stringValue) : {},
+    envUnset: option.env_unset ? [...option.env_unset] : []
   };
 }
 function interpolateEnv(env, value) {
@@ -732,35 +1179,55 @@ function createAgentCliRuntime(definition) {
       const composed = composeSpawn(definition, opts?.config);
       const env = {
         ...filterStringEnv(process.env),
-        ...composed.env,
-        ...opts?.env ?? {}
+        ...composed.env
       };
+      for (const k of composed.envUnset) delete env[k];
+      Object.assign(env, opts?.env ?? {});
+      const permissionMode = resolveClaudeCodePermissionMode(
+        definition,
+        opts?.config?.mode
+      );
+      if (permissionMode) {
+        const configDir = mkdtempSync(
+          join(tmpdir(), "agentproto-claude-config-")
+        );
+        writeFileSync(
+          join(configDir, "settings.json"),
+          JSON.stringify({ permissions: { defaultMode: permissionMode } })
+        );
+        env.CLAUDE_CONFIG_DIR = configDir;
+      }
       if (definition.protocol === "print") {
         return createPrintSession({
           bin: definition.bin,
           baseArgs: composed.binArgs,
           cwd,
           env,
-          ...opts?.resumeSessionId ? { resumeSessionId: opts.resumeSessionId } : {}
+          ...opts?.resumeSessionId ? { resumeSessionId: opts.resumeSessionId } : {},
+          ...opts?.mcpServers ? { mcpServers: opts.mcpServers } : {},
+          printConfig: definition.print
         });
       }
-      const child = spawn(definition.bin, composed.binArgs, {
-        cwd,
-        env,
-        stdio: ["pipe", "pipe", "pipe"],
-        signal: opts?.signal
-      });
+      let child;
       const stderrBuf = [];
-      const STDERR_KEEP_LINES = 80;
-      child.stderr?.setEncoding("utf8");
-      child.stderr?.on("data", (chunk) => {
-        for (const line of chunk.split(/\r?\n/)) {
-          if (!line) continue;
-          stderrBuf.push(line);
-          if (stderrBuf.length > STDERR_KEEP_LINES) stderrBuf.shift();
-        }
-      });
-      const arm = buildProtocolArm(definition, child, cwd);
+      if (definition.protocol !== "proprietary") {
+        child = spawn(definition.bin, composed.binArgs, {
+          cwd,
+          env,
+          stdio: ["pipe", "pipe", "pipe"],
+          signal: opts?.signal
+        });
+        const STDERR_KEEP_LINES = 80;
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+          for (const line of chunk.split(/\r?\n/)) {
+            if (!line) continue;
+            stderrBuf.push(line);
+            if (stderrBuf.length > STDERR_KEEP_LINES) stderrBuf.shift();
+          }
+        });
+      }
+      const arm = await buildProtocolArm(definition, child, cwd, opts?.config?.mode);
       arm._stderrTail = () => stderrBuf.join("\n");
       const abortController = new AbortController();
       if (opts?.signal) {
@@ -772,6 +1239,10 @@ function createAgentCliRuntime(definition) {
       const optEffort = opts?.config?.options?.effort;
       const modelApply = definition.models?.apply ?? "config";
       const configModel = optModel && modelApply === "config" ? String(optModel) : void 0;
+      const requestedModeId = opts?.config?.mode;
+      const requestedModeDecl = requestedModeId ? (definition.modes ?? []).find((m) => m.id === requestedModeId) : void 0;
+      const configMode = requestedModeDecl?.apply === "config" ? requestedModeId : void 0;
+      const turnIdleTimeoutMs = opts?.turnIdleTimeoutMs ?? definition.session?.turn_idle_timeout_ms;
       await arm.connect({
         cwd,
         env,
@@ -779,7 +1250,10 @@ function createAgentCliRuntime(definition) {
         ...opts?.resumeSessionId ? { resumeSessionId: opts.resumeSessionId } : {},
         ...opts?.mcpServers ? { mcpServers: opts.mcpServers } : {},
         ...configModel ? { model: configModel } : {},
-        ...optEffort ? { effort: String(optEffort) } : {}
+        ...optEffort ? { effort: String(optEffort) } : {},
+        ...configMode ? { mode: configMode } : {},
+        ...opts?.onActivity ? { onActivity: opts.onActivity } : {},
+        ...turnIdleTimeoutMs !== void 0 ? { turnIdleTimeoutMs } : {}
       });
       if (optModel && modelApply === "command") {
         await applyModelCommand(arm, String(optModel));
@@ -787,6 +1261,7 @@ function createAgentCliRuntime(definition) {
       const sessionId = arm.sessionId ?? randomUUID();
       return {
         sessionId,
+        pid: child?.pid,
         send(message) {
           const turnId = randomUUID();
           return promptTurn(arm, turnId, message);
@@ -796,7 +1271,7 @@ function createAgentCliRuntime(definition) {
         },
         async close() {
           await arm.close();
-          if (!child.killed) child.kill("SIGTERM");
+          if (child && !child.killed) child.kill("SIGTERM");
         }
       };
     }
@@ -839,24 +1314,39 @@ async function* promptTurn(arm, turnId, message) {
     yield evt;
   }
 }
-function buildProtocolArm(def, child, cwd) {
+async function buildProtocolArm(def, child, cwd, requestedMode) {
   switch (def.protocol) {
     case "acp":
+      if (!child) {
+        throw new Error("createAgentCliRuntime: acp protocol requires a spawned subprocess");
+      }
       return createAcpProtocolArm({
         child,
         cwd,
-        clientInfo: { name: def.id, version: def.version }
+        clientInfo: { name: def.id, version: def.version },
+        requestedMode
       });
     case "mcp":
       throw new Error("createAgentCliRuntime: mcp protocol arm not yet implemented");
     case "proprietary":
-      throw new Error(
-        "createAgentCliRuntime: proprietary protocol arm not yet implemented"
-      );
+      if (!def.adapter) {
+        throw new Error(
+          "createAgentCliRuntime: proprietary protocol requires manifest.adapter"
+        );
+      }
+      return createProprietaryProtocolArm({ adapter: def.adapter, definition: def });
     case "print":
       throw new Error("createAgentCliRuntime: print arm bypasses buildProtocolArm");
   }
 }
+function resolveClaudeCodePermissionMode(definition, configMode) {
+  if (definition.id !== "claude-code" || !configMode) return void 0;
+  const mode = (definition.modes ?? []).find((m) => m.id === configMode);
+  const args = mode?.bin_args_append ?? [];
+  const flagIndex = args.indexOf("--permission-mode");
+  if (flagIndex === -1 || flagIndex + 1 >= args.length) return void 0;
+  return args[flagIndex + 1];
+}
 function filterStringEnv(env) {
   const out = {};
   for (const [k, v] of Object.entries(env)) {
@@ -865,6 +1355,6 @@ function filterStringEnv(env) {
   return out;
 }
 
-export { RuntimeConfigError, agentCliFrontmatterSchema, autoAllowPermissionHandler, composeSpawn, createAcpProtocolArm, createAgentCliRuntime, createPrintSession, defineAgentCli, resolveContinuationStrategy, runtimeConfigSchema };
-//# sourceMappingURL=chunk-YQHVLX6O.mjs.map
-//# sourceMappingURL=chunk-YQHVLX6O.mjs.map
+export { RuntimeConfigError, agentCliFrontmatterSchema, autoAllowPermissionHandler, composeSpawn, createAcpProtocolArm, createAgentCliRuntime, createMastraMapperState, createPrintSession, createProprietaryProtocolArm, defineAgentCli, mapMastraEvent, planModePermissionHandler, resolveContinuationStrategy, runtimeConfigSchema, toFileBasedMcpServers };
+//# sourceMappingURL=chunk-L6BRNMVP.mjs.map
+//# sourceMappingURL=chunk-L6BRNMVP.mjs.map