@agentproto/driver-agent-cli 0.1.1 → 0.3.0

package/dist/{chunk-VIYTAHJJ.mjs → chunk-KHHRPQ2Q.mjs}

@@ -2,7 +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';
 
 /**
@@ -149,13 +153,22 @@ 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(),
-  env: z.record(z.string(), 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,
+  // for agents like hermes that ignore the ACP session model config).
+  apply: z.enum(["config", "command"]).optional()
 }).strict();
 var capabilitiesSchema = z.object({
   streaming: z.boolean().optional(),
@@ -220,6 +233,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),
@@ -233,10 +256,11 @@ var agentCliFrontmatterSchema = z.object({
   auth: authSchema.optional(),
   sandbox: z.union([z.string(), z.record(z.string(), z.unknown())]),
   runner: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
-  protocol: z.enum(["acp", "mcp", "proprietary"]),
+  protocol: z.enum(["acp", "mcp", "proprietary", "print"]),
   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(),
@@ -320,6 +344,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) {
@@ -337,7 +376,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,
@@ -345,6 +384,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
@@ -357,10 +398,16 @@ function createAcpProtocolArm(options) {
       if (opts.resumeSessionId) {
         session = await client.loadSession({
           sessionId: opts.resumeSessionId,
-          cwd
+          cwd,
+          mcpServers: opts.mcpServers
         });
       } else {
-        session = await client.newSession({ cwd });
+        session = await client.newSession({
+          cwd,
+          mcpServers: opts.mcpServers,
+          ...opts.model ? { model: opts.model } : {},
+          ...opts.effort ? { effort: opts.effort } : {}
+        });
       }
     },
     async send(turnId, message) {
@@ -385,6 +432,409 @@ 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;
+    },
+    async *send(message) {
+      const prompt = extractPromptText(message);
+      const args = [
+        ...opts.baseArgs,
+        ...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,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      activeChild = child;
+      const stderrLines = [];
+      const STDERR_KEEP = 80;
+      child.stderr?.setEncoding("utf8");
+      child.stderr?.on("data", (chunk) => {
+        for (const line of chunk.split(/\r?\n/)) {
+          if (!line) continue;
+          stderrLines.push(line);
+          if (stderrLines.length > STDERR_KEEP) stderrLines.shift();
+        }
+      });
+      try {
+        if (!child.stdout)
+          throw new Error("print-arm: child has no stdout pipe");
+        const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
+        let capturedSessionId = "";
+        const mastraState = eventSchema === "mastra-jsonl" ? createMastraMapperState() : void 0;
+        for await (const line of rl) {
+          if (!line.trim()) continue;
+          let evt;
+          try {
+            evt = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          const csid = captureSessionId(evt, eventSchema);
+          if (csid) capturedSessionId = csid;
+          const sid = capturedSessionId || sessionId || "";
+          const mapped = mapEvent(evt, sid, stderrLines, eventSchema, mastraState);
+          if (!mapped) continue;
+          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: `${binLabel} exited with code ${exitCode}`,
+              ...stderrLines.length ? { data: { stderr: stderrLines.join("\n") } } : {}
+            }
+          };
+          yield errEvt;
+        }
+      } finally {
+        activeChild = null;
+      }
+    },
+    async cancel() {
+      activeChild?.kill("SIGTERM");
+    },
+    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 {
+    }
+  };
+}
+function extractPromptText(message) {
+  if (typeof message === "string") return message;
+  if (message !== null && typeof message === "object") {
+    const m = message;
+    if (typeof m.text === "string") return m.text;
+    if (Array.isArray(message)) {
+      return message.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n");
+    }
+  }
+  return JSON.stringify(message);
+}
+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;
+    case "thinking":
+      return typeof evt.thinking === "string" ? { kind: "thought", sessionId, text: evt.thinking } : null;
+    case "tool_use":
+      return {
+        kind: "tool-call",
+        sessionId,
+        toolCallId: typeof evt.id === "string" ? evt.id : "",
+        toolName: typeof evt.name === "string" ? evt.name : "?",
+        arguments: evt.input ?? {}
+      };
+    case "tool_result":
+      return {
+        kind: "tool-result",
+        sessionId,
+        toolCallId: typeof evt.tool_use_id === "string" ? evt.tool_use_id : "",
+        result: evt.content ?? null,
+        isError: evt.is_error === true
+      };
+    case "result":
+      if (evt.subtype === "error_during_execution" || evt.is_error === true) {
+        return {
+          kind: "error",
+          sessionId,
+          error: {
+            message: typeof evt.error === "string" ? evt.error : "Unknown error",
+            ...stderrLines.length ? { data: { stderr: stderrLines.join("\n") } } : {}
+          }
+        };
+      }
+      if (evt.subtype === "success") {
+        return { kind: "turn-end", sessionId, reason: "completed" };
+      }
+      return null;
+    case "system":
+    case "assistant":
+      return null;
+    default:
+      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") } } : {}
+        }
+      };
+    }
+    // ── 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;
+  }
+}
+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));
+    child.once("error", () => resolve(null));
+  });
+}
+
+// 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;
@@ -585,23 +1035,51 @@ function createAgentCliRuntime(definition) {
         ...composed.env,
         ...opts?.env ?? {}
       };
-      const child = spawn(definition.bin, composed.binArgs, {
-        cwd,
-        env,
-        stdio: ["pipe", "pipe", "pipe"],
-        signal: opts?.signal
-      });
+      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?.mcpServers ? { mcpServers: opts.mcpServers } : {},
+          printConfig: definition.print
+        });
+      }
+      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) {
@@ -609,15 +1087,29 @@ function createAgentCliRuntime(definition) {
           once: true
         });
       }
+      const optModel = opts?.config?.options?.model;
+      const optEffort = opts?.config?.options?.effort;
+      const modelApply = definition.models?.apply ?? "config";
+      const configModel = optModel && modelApply === "config" ? String(optModel) : void 0;
+      const turnIdleTimeoutMs = opts?.turnIdleTimeoutMs ?? definition.session?.turn_idle_timeout_ms;
       await arm.connect({
         cwd,
         env,
         abortSignal: abortController.signal,
-        ...opts?.resumeSessionId ? { resumeSessionId: opts.resumeSessionId } : {}
+        ...opts?.resumeSessionId ? { resumeSessionId: opts.resumeSessionId } : {},
+        ...opts?.mcpServers ? { mcpServers: opts.mcpServers } : {},
+        ...configModel ? { model: configModel } : {},
+        ...optEffort ? { effort: String(optEffort) } : {},
+        ...opts?.onActivity ? { onActivity: opts.onActivity } : {},
+        ...turnIdleTimeoutMs !== void 0 ? { turnIdleTimeoutMs } : {}
       });
+      if (optModel && modelApply === "command") {
+        await applyModelCommand(arm, String(optModel));
+      }
       const sessionId = arm.sessionId ?? randomUUID();
       return {
         sessionId,
+        pid: child?.pid,
         send(message) {
           const turnId = randomUUID();
           return promptTurn(arm, turnId, message);
@@ -627,12 +1119,35 @@ function createAgentCliRuntime(definition) {
         },
         async close() {
           await arm.close();
-          if (!child.killed) child.kill("SIGTERM");
+          if (child && !child.killed) child.kill("SIGTERM");
         }
       };
     }
   };
 }
+async function applyModelCommand(arm, modelId) {
+  const turnId = randomUUID();
+  let acked = false;
+  try {
+    for await (const evt of promptTurn(arm, turnId, {
+      type: "text",
+      text: `/model ${modelId}`
+    })) {
+      if (/switch|model\s+set|now using/i.test(JSON.stringify(evt))) acked = true;
+    }
+  } catch (err) {
+    console.warn(
+      `[agent-cli] /model ${modelId} control turn failed (continuing on default):`,
+      err instanceof Error ? err.message : err
+    );
+    return;
+  }
+  if (!acked) {
+    console.warn(
+      `[agent-cli] /model ${modelId}: no switch acknowledgement \u2014 agent may be on its default model`
+    );
+  }
+}
 async function* promptTurn(arm, turnId, message) {
   await arm.send(turnId, message);
   const stderrTail = arm._stderrTail;
@@ -647,22 +1162,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)) {
@@ -671,6 +1203,6 @@ function filterStringEnv(env) {
   return out;
 }
 
-export { RuntimeConfigError, agentCliFrontmatterSchema, autoAllowPermissionHandler, composeSpawn, createAcpProtocolArm, createAgentCliRuntime, defineAgentCli, resolveContinuationStrategy, runtimeConfigSchema };
-//# sourceMappingURL=chunk-VIYTAHJJ.mjs.map
-//# sourceMappingURL=chunk-VIYTAHJJ.mjs.map
+export { RuntimeConfigError, agentCliFrontmatterSchema, autoAllowPermissionHandler, composeSpawn, createAcpProtocolArm, createAgentCliRuntime, createMastraMapperState, createPrintSession, createProprietaryProtocolArm, defineAgentCli, mapMastraEvent, planModePermissionHandler, resolveContinuationStrategy, runtimeConfigSchema, toFileBasedMcpServers };
+//# sourceMappingURL=chunk-KHHRPQ2Q.mjs.map
+//# sourceMappingURL=chunk-KHHRPQ2Q.mjs.map