@agentproto/driver-agent-cli 1.1.0 → 2.0.0

package/dist/{chunk-2E3ATB4P.mjs → chunk-LP542BMX.mjs}

@@ -184,8 +184,13 @@ var modelsSchema = z.object({
   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()
+  // for agents like hermes that ignore the ACP session model config) |
+  // "arg" (a CLI argument composed into bin_args at spawn, for agents
+  // like codex-acp that take their model as `-c model="<id>"`).
+  apply: z.enum(["config", "command", "arg"]).optional(),
+  // Argv template for apply:"arg" — {model} interpolates the requested
+  // model id. See AgentCliModels.bin_args_template.
+  bin_args_template: z.array(z.string()).optional()
 }).strict();
 var capabilitiesSchema = z.object({
   streaming: z.boolean().optional(),
@@ -207,6 +212,14 @@ var capabilitiesSchema = z.object({
 var modeSchema = z.object({
   id: z.string().regex(MODE_ID_PATTERN),
   description: z.string().optional(),
+  // Which orthogonal session-config axis this mode expresses (SPEC-tracked in
+  // @agentproto/runtime's session-config.ts). Narrowed to only "context" (SPEC
+  // §3.4a): route is derived from the model catalog (@route), not a manifest
+  // mode, and posture comes from the harness's own ACP mode registry
+  // (SessionModeState.availableModes) — neither is a `modes[]` entry anymore.
+  // The legacy "posture"/"route" classification still exists, but only inside
+  // the daemon's back-compat `decomposeMode` shim, not this manifest surface.
+  kind: z.enum(["context"]).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(),
@@ -433,6 +446,15 @@ function createAcpProtocolArm(options) {
     get sessionId() {
       return session?.sessionId;
     },
+    get availableConfigOptions() {
+      return session?.availableConfigOptions ?? [];
+    },
+    get availableModes() {
+      return session?.availableModes ?? [];
+    },
+    get currentModeId() {
+      return session?.currentModeId;
+    },
     async connect(opts) {
       const permissionHandler = options.onPermissionRequest ?? defaultPermissionHandlerForMode(options.requestedMode);
       client = await createAcpClient({
@@ -490,6 +512,14 @@ function createAcpProtocolArm(options) {
       if (!session) return;
       await session.cancel();
     },
+    async setConfigOption(configId, value) {
+      if (!session) return { applied: false, reason: "not-connected" };
+      return session.setConfigOption(configId, value);
+    },
+    async setSessionMode(modeId) {
+      if (!session) return { applied: false, reason: "not-connected" };
+      return session.setSessionMode(modeId);
+    },
     respondPermission(requestId, resolution) {
       return client?.respondPermission(requestId, resolution) ?? false;
     },
@@ -603,6 +633,33 @@ function createPrintSession(opts) {
     async cancel() {
       activeChild?.kill("SIGTERM");
     },
+    // The print arm spawns a fresh subprocess PER TURN from `baseArgs`,
+    // which already has the model baked in (composed once, before this
+    // session object was even constructed — see `bin_args_template`
+    // handling in define-agent-cli.ts/compose.ts). There is no live
+    // connection to apply a mid-session config change to, and rebuilding
+    // `baseArgs` would mean a fresh session, not a live switch — so this
+    // is honestly `requires-restart`, same as the `arg` model-apply
+    // strategy for ACP arms.
+    async setModel() {
+      return { applied: false, reason: "requires-restart" };
+    },
+    // No ACP session — no wrapper-advertised capability read-surface and
+    // no `session/set_mode` RPC to switch live. Mirrors the "arm has no
+    // mid-session config surface" case `define-agent-cli.ts` reports for
+    // `setModel` on other arms.
+    availableConfigOptions: [],
+    availableModes: [],
+    currentModeId: void 0,
+    async setSessionMode() {
+      return { applied: false, reason: "not-supported" };
+    },
+    // Same as `setSessionMode`: a print arm has no live ACP session to apply
+    // `set_config_option(configId:"effort")` against — effort is baked into
+    // the spawn argv/env, so a live change is honestly `not-supported`.
+    async setEffort() {
+      return { applied: false, reason: "not-supported" };
+    },
     async close() {
       activeChild?.kill("SIGTERM");
       mcpRestore?.();
@@ -762,8 +819,12 @@ 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("");
+  let blocks = content;
+  if (blocks !== null && typeof blocks === "object" && !Array.isArray(blocks) && Array.isArray(blocks.parts)) {
+    blocks = blocks.parts;
+  }
+  if (!Array.isArray(blocks)) return "";
+  return blocks.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("");
 }
 function mapMastraEvent(evt, sessionId, stderrLines, state) {
   switch (evt.type) {
@@ -977,6 +1038,31 @@ async function createProprietaryProtocolArm(options) {
   return await candidate(options.definition);
 }
 
+// src/legacy-modes.ts
+var LEGACY_GATEWAY_MODE_IDS = /* @__PURE__ */ new Set([
+  "moonshot",
+  "openrouter",
+  "requesty",
+  "deepseek"
+]);
+var LEGACY_POSTURE_MODE_IDS = /* @__PURE__ */ new Set([
+  "default",
+  "plan",
+  "accept-edits",
+  "bypass-permissions",
+  "read-only",
+  "full-access",
+  "build"
+]);
+function inferLegacyModeKind(modeId) {
+  if (LEGACY_GATEWAY_MODE_IDS.has(modeId)) return "route";
+  if (LEGACY_POSTURE_MODE_IDS.has(modeId)) return "posture";
+  return "context";
+}
+function isLegacyExtractedModeId(modeId) {
+  return LEGACY_GATEWAY_MODE_IDS.has(modeId) || LEGACY_POSTURE_MODE_IDS.has(modeId);
+}
+
 // src/manifest/compose.ts
 var RuntimeConfigError = class extends Error {
   code;
@@ -1002,14 +1088,15 @@ function composeSpawn(handle, config) {
   if (config.mode !== void 0) {
     const mode = (handle.modes ?? []).find((m) => m.id === config.mode);
     if (!mode) {
-      const known = (handle.modes ?? []).map((m) => m.id).join(", ") || "(none)";
-      throw new RuntimeConfigError(
-        "unknown_mode",
-        "config.mode",
-        `Mode '${config.mode}' is not declared by manifest '${handle.id}'. Known modes: ${known}`
-      );
-    }
-    if ((mode.apply ?? "bin_args") === "bin_args") {
+      if (!isLegacyExtractedModeId(config.mode)) {
+        const known = (handle.modes ?? []).map((m) => m.id).join(", ") || "(none)";
+        throw new RuntimeConfigError(
+          "unknown_mode",
+          "config.mode",
+          `Mode '${config.mode}' is not declared by manifest '${handle.id}'. Known modes: ${known}`
+        );
+      }
+    } else 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);
@@ -1053,6 +1140,13 @@ function composeSpawn(handle, config) {
       );
     }
   }
+  if (typeof requestedModel === "string" && handle.models?.apply === "arg" && handle.models.bin_args_template) {
+    append.push(
+      ...handle.models.bin_args_template.map(
+        (token) => token.replace("{model}", requestedModel)
+      )
+    );
+  }
   if (config.continuation !== void 0 && handle.continuation) {
     if (!handle.continuation.supported.includes(config.continuation)) {
       throw new RuntimeConfigError(
@@ -1201,6 +1295,11 @@ var defineAgentCli = createDoctype(
           "defineAgentCli (AIP-45): session.mode=resumable requires capabilities.resumable: true"
         );
       }
+      if (data.models?.apply === "arg" && !data.models.bin_args_template?.length) {
+        throw new Error(
+          'defineAgentCli (AIP-45): models.apply="arg" requires models.bin_args_template'
+        );
+      }
     },
     build(def) {
       return { ...def };
@@ -1220,17 +1319,20 @@ function createAgentCliRuntime(definition) {
       for (const k of composed.envUnset) delete env[k];
       const authSpec = opts?.auth;
       const hasGatewayAuthToken = "ANTHROPIC_AUTH_TOKEN" in composed.env;
-      const engageAuth = !!authSpec && !hasGatewayAuthToken && (authSpec.enforce === "always" || authSpec.explicit === true);
+      const hasGatewayBaseUrl = "ANTHROPIC_BASE_URL" in composed.env;
+      const engageAuth = !!authSpec && !hasGatewayAuthToken && !hasGatewayBaseUrl && (authSpec.enforce === "always" || authSpec.explicit === true);
       if (authSpec && engageAuth) {
         for (const key of authSpec.unsetEnv) {
           if (!(key in composed.env)) delete env[key];
         }
         if (!authSpec.credential) {
-          throw new RuntimeConfigError(
-            "missing_auth_credential",
-            "opts.auth.credential",
-            `agent-cli '${definition.id}': auth mode "${authSpec.mode}" requires an explicit credential (resolved from a named config/store ref), but none was provided.` + (authSpec.mode === "subscription" ? ` Mint one via \`claude setup-token\` (bills the Max/Pro subscription, not API credits) and configure it \u2014 never inherited from the shell.` : ` Configure an API key (\`agentproto auth provider set \u2026\` or per-spawn) \u2014 never inherited from the shell.`)
-          );
+          const slug = definition.id;
+          const providerLabel = definition.provider ?? "<provider>";
+          const configBlock = `{"defaults":{"adapters":{"${slug}":{"auth":{"mode":"api-key"}}}}} in ~/.agentproto/config.json`;
+          const storeHint = authSpec.ignoredApiKeyInStore ? ` (providers.json already has a stored key for ${providerLabel} \u2014 ignored until that block exists)` : "";
+          const supportsSub = !!definition.authSubscription;
+          const message = authSpec.neitherConfigured && supportsSub ? `agent-cli '${slug}': no billing auth. Subscription \u2192 \`claude setup-token\`. Api-key \u2192 \`agentproto auth provider set ${providerLabel} sk-\u2026\`${storeHint}. Add ${configBlock}. Never inherited from the shell.` : authSpec.mode === "subscription" ? `agent-cli '${slug}': run \`claude setup-token\` and configure the result \u2014 bills the Max/Pro subscription, not API credits. Never inherited from the shell.` : `agent-cli '${slug}': run \`agentproto auth provider set ${providerLabel} sk-\u2026\`${storeHint}, then add ${configBlock}. Never inherited from the shell.`;
+          throw new RuntimeConfigError("missing_auth_credential", "opts.auth.credential", message);
         }
         env[authSpec.setEnv] = authSpec.credential;
       }
@@ -1318,21 +1420,109 @@ function createAgentCliRuntime(definition) {
         await applyModelCommand(arm, String(optModel));
       }
       const sessionId = arm.sessionId ?? randomUUID();
+      let currentTurnId;
       return {
         sessionId,
         pid: child?.pid,
+        // Capability read-surface (SPEC §3.9/§3.4a) — snapshotted once
+        // `arm.connect()` above has resolved, so an ACP arm's captured
+        // `newSession`/`loadSession` response is already populated. Arms
+        // that don't model this (print, proprietary) leave the getters
+        // undefined, defaulted here to the same empty/absent shape their
+        // `setModel`-style counterparts use for "not supported".
+        availableConfigOptions: arm.availableConfigOptions ?? [],
+        availableModes: arm.availableModes ?? [],
+        currentModeId: arm.currentModeId,
         send(message) {
           const turnId = randomUUID();
+          currentTurnId = turnId;
           return promptTurn(arm, turnId, message);
         },
+        /**
+         * Cancel the in-flight turn — the wire equivalent of Ctrl-C at the
+         * agent's own TUI, and the primitive the host's interrupt path
+         * (`SessionsRegistry.interruptSession`, `{interrupt: true}`) is built
+         * on.
+         *
+         * This used to be `abortController.abort()` alone, which cancelled
+         * NOTHING: that controller is the CONNECTION-level signal, handed to
+         * `arm.connect({abortSignal})` at spawn, and no arm reads it. So the
+         * abort fired into the void while the agent kept working — a turn
+         * "cancelled" this way ran happily to completion, and the host's 60s
+         * settle-wait then timed out on a turn that was never asked to stop.
+         * It only ever LOOKED like it worked for turns that happened to end
+         * naturally inside that wait.
+         *
+         * Both arms have always implemented the real thing — the ACP arm
+         * sends `session/cancel`, the print arm SIGTERMs the child — it was
+         * simply never called. Call it.
+         *
+         * Connection-level abort deliberately stays out of this: aborting the
+         * connection would end the SESSION, and cancelling a turn must leave
+         * it alive and idle for the next prompt. That distinction is the whole
+         * point of interrupt-vs-kill.
+         */
         async cancel() {
-          abortController.abort();
+          if (currentTurnId === void 0) return;
+          await arm.cancel(currentTurnId);
         },
         ...arm.respondPermission ? {
           respondPermission(requestId, resolution) {
             return arm.respondPermission(requestId, resolution);
           }
         } : {},
+        /**
+         * Mid-session model switch — the runtime counterpart to the
+         * spawn-time `modelApply` handling above. Dispatches on the same
+         * `definition.models.apply` strategy so a live switch behaves
+         * exactly like the spawn-time apply would have, just against an
+         * already-running session. See {@link SetModelResult} for the
+         * reason vocabulary; this never throws and never tears down the
+         * session on a rejected switch.
+         */
+        async setModel(modelId) {
+          if (modelApply === "arg") {
+            return { applied: false, reason: "requires-restart" };
+          }
+          if (modelApply === "command") {
+            return applyModelCommand(arm, modelId);
+          }
+          if (!arm.setConfigOption) {
+            return { applied: false, reason: "not-supported" };
+          }
+          const result = await arm.setConfigOption("model", modelId);
+          return result.applied ? { applied: true, model: modelId } : { applied: false, ...result.reason ? { reason: result.reason } : {} };
+        },
+        /**
+         * Mid-session posture switch — the native-mode counterpart to
+         * `setModel`, wired directly to the arm's `setSessionMode` (only
+         * the ACP arm implements it). See {@link SetSessionModeResult} for
+         * the reason vocabulary; this never throws and never tears down
+         * the session on a rejected switch.
+         */
+        async setSessionMode(modeId) {
+          if (!arm.setSessionMode) {
+            return { applied: false, reason: "not-supported" };
+          }
+          const result = await arm.setSessionMode(modeId);
+          return result.applied ? { applied: true, modeId } : { applied: false, ...result.reason ? { reason: result.reason } : {} };
+        },
+        /**
+         * Mid-session effort switch — the effort-axis counterpart to
+         * `setModel`'s `"config"` strategy, wired to the same
+         * `arm.setConfigOption` surface with `configId:"effort"` (only the
+         * ACP arm implements it). Best-effort and non-fatal: an effort label
+         * the current model rejects resolves `{applied:false, reason}` (SPEC
+         * risk R7), never thrown and never tearing down the session. See
+         * {@link SetEffortResult} for the reason vocabulary.
+         */
+        async setEffort(effort) {
+          if (!arm.setConfigOption) {
+            return { applied: false, reason: "not-supported" };
+          }
+          const result = await arm.setConfigOption("effort", effort);
+          return result.applied ? { applied: true, effort } : { applied: false, ...result.reason ? { reason: result.reason } : {} };
+        },
         async close() {
           await arm.close();
           if (child && !child.killed) child.kill("SIGTERM");
@@ -1352,17 +1542,19 @@ async function applyModelCommand(arm, modelId) {
       if (/switch|model\s+set|now using/i.test(JSON.stringify(evt))) acked = true;
     }
   } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
     console.warn(
       `[agent-cli] /model ${modelId} control turn failed (continuing on default):`,
       err instanceof Error ? err.message : err
     );
-    return;
+    return { applied: false, reason };
   }
   if (!acked) {
-    console.warn(
-      `[agent-cli] /model ${modelId}: no switch acknowledgement \u2014 agent may be on its default model`
-    );
+    const reason = "no switch acknowledgement \u2014 agent may be on its default model";
+    console.warn(`[agent-cli] /model ${modelId}: ${reason}`);
+    return { applied: false, reason };
   }
+  return { applied: true, model: modelId };
 }
 async function* promptTurn(arm, turnId, message) {
   await arm.send(turnId, message);
@@ -1420,6 +1612,6 @@ function filterStringEnv(env) {
   return out;
 }
 
-export { RuntimeConfigError, agentCliFrontmatterSchema, autoAllowPermissionHandler, composeSpawn, createAcpProtocolArm, createAgentCliRuntime, createMastraMapperState, createPrintSession, createProprietaryProtocolArm, defineAgentCli, mapMastraEvent, planModePermissionHandler, resolveContinuationStrategy, runtimeConfigSchema, toFileBasedMcpServers };
-//# sourceMappingURL=chunk-2E3ATB4P.mjs.map
-//# sourceMappingURL=chunk-2E3ATB4P.mjs.map
+export { LEGACY_GATEWAY_MODE_IDS, LEGACY_POSTURE_MODE_IDS, RuntimeConfigError, agentCliFrontmatterSchema, autoAllowPermissionHandler, composeSpawn, createAcpProtocolArm, createAgentCliRuntime, createMastraMapperState, createPrintSession, createProprietaryProtocolArm, defineAgentCli, inferLegacyModeKind, isLegacyExtractedModeId, mapMastraEvent, planModePermissionHandler, resolveContinuationStrategy, runtimeConfigSchema, toFileBasedMcpServers };
+//# sourceMappingURL=chunk-LP542BMX.mjs.map
+//# sourceMappingURL=chunk-LP542BMX.mjs.map