@agentproto/driver-agent-cli 1.2.0 → 2.0.1

package/dist/{chunk-TJHKDKCU.mjs → chunk-H43KNN32.mjs}

@@ -6,7 +6,7 @@ import { existsSync, readFileSync, mkdirSync, writeFileSync, rmSync, rmdirSync,
 import { createInterface } from 'readline';
 import { join } from 'path';
 import { randomUUID } from 'crypto';
-import { tmpdir } from 'os';
+import { tmpdir, homedir } from 'os';
 import { createDoctype } from '@agentproto/define-doctype';
 
 /**
@@ -212,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(),
@@ -438,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({
@@ -495,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;
     },
@@ -608,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?.();
@@ -767,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) {
@@ -982,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;
@@ -993,7 +1074,7 @@ var RuntimeConfigError = class extends Error {
     this.name = "RuntimeConfigError";
   }
 };
-function composeSpawn(handle, config) {
+function composeSpawn(handle, config, opts) {
   if (!config)
     return {
       binArgs: [...handle.bin_args ?? []],
@@ -1007,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);
@@ -1058,7 +1140,7 @@ function composeSpawn(handle, config) {
       );
     }
   }
-  if (typeof requestedModel === "string" && handle.models?.apply === "arg" && handle.models.bin_args_template) {
+  if (typeof requestedModel === "string" && handle.models?.apply === "arg" && handle.models.bin_args_template && !opts?.skipModelArg) {
     append.push(
       ...handle.models.bin_args_template.map(
         (token) => token.replace("{model}", requestedModel)
@@ -1229,7 +1311,21 @@ function createAgentCliRuntime(definition) {
     definition,
     async start(opts) {
       const cwd = opts?.cwd ?? process.cwd();
-      const composed = composeSpawn(definition, opts?.config);
+      const cliEnv = {
+        ...filterStringEnv(process.env),
+        ...opts?.env ?? {}
+      };
+      const codexAuthMode = definition.id === "codex" ? detectCodexAuthMode(cliEnv, opts?.auth) : void 0;
+      const skipModelArg = definition.id === "codex" && codexAuthMode !== "api-key";
+      const composed = composeSpawn(definition, opts?.config, {
+        skipModelArg
+      });
+      const requestedModel = opts?.config?.options?.model;
+      if (skipModelArg && typeof requestedModel === "string") {
+        console.warn(
+          `[agent-cli] codex: skipped model override "${requestedModel}" for ChatGPT-account auth; using Codex's default model.`
+        );
+      }
       const env = {
         ...filterStringEnv(process.env),
         ...composed.env
@@ -1237,7 +1333,8 @@ 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];
@@ -1341,6 +1438,15 @@ function createAgentCliRuntime(definition) {
       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;
@@ -1379,6 +1485,58 @@ function createAgentCliRuntime(definition) {
             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");
@@ -1398,17 +1556,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);
@@ -1465,7 +1625,22 @@ function filterStringEnv(env) {
   }
   return out;
 }
+function detectCodexAuthMode(env, authSpec) {
+  if (authSpec?.credential && (authSpec.explicit === true || authSpec.enforce === "always")) {
+    return authSpec.mode === "api-key" ? "api-key" : "chatgpt";
+  }
+  if (env.OPENAI_API_KEY || env.CODEX_API_KEY) return "api-key";
+  const authPath = join(homedir(), ".codex", "auth.json");
+  try {
+    const parsed = JSON.parse(readFileSync(authPath, "utf8"));
+    if (parsed.auth_mode === "api-key" || parsed.auth_mode === "chatgpt") {
+      return parsed.auth_mode;
+    }
+  } catch {
+  }
+  return "chatgpt";
+}
 
-export { RuntimeConfigError, agentCliFrontmatterSchema, autoAllowPermissionHandler, composeSpawn, createAcpProtocolArm, createAgentCliRuntime, createMastraMapperState, createPrintSession, createProprietaryProtocolArm, defineAgentCli, mapMastraEvent, planModePermissionHandler, resolveContinuationStrategy, runtimeConfigSchema, toFileBasedMcpServers };
-//# sourceMappingURL=chunk-TJHKDKCU.mjs.map
-//# sourceMappingURL=chunk-TJHKDKCU.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-H43KNN32.mjs.map
+//# sourceMappingURL=chunk-H43KNN32.mjs.map