@ai-sdk/harness-acp 1.0.30 → 1.0.32

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @ai-sdk/harness-acp
 
+## 1.0.32
+
+### Patch Changes
+
+- 8961fde: feat(harness): allow changing `model` between turns via call options
+- Updated dependencies [8961fde]
+- Updated dependencies [eb59f2a]
+  - @ai-sdk/harness@1.0.94
+  - @ai-sdk/provider-utils@5.0.34
+
+## 1.0.31
+
+### Patch Changes
+
+- 7608210: feat(harness): add `model` parameter to `HarnessAgent` instead of having each harness adapter support it on their own constructor functions
+- f7bd978: chore(harness): update underlying adapter SDKs to their latest versions
+- 14d4fc0: feat(harness): allow changing harness settings between turns via `prepareCall()` support on `HarnessAgent`
+- Updated dependencies [cc9f6ce]
+- Updated dependencies [7608210]
+- Updated dependencies [6f8a2d7]
+- Updated dependencies [14d4fc0]
+- Updated dependencies [90192f1]
+  - @ai-sdk/harness@1.0.93
+  - @ai-sdk/provider-utils@5.0.33
+
 ## 1.0.30
 
 ### Patch Changes

package/README.md

@@ -34,6 +34,10 @@ const codexACP = createACP({
     packageVersion: '1.1.4',
   },
   executable: 'codex-acp',
+  modelMapping: {
+    type: 'session-config-option',
+    path: 'model',
+  },
   credentialEnv: ['CODEX_API_KEY', 'OPENAI_API_KEY'],
   credentialBrokering: ({ env, sandboxEnv }) => {
     const environmentVariableName = env.CODEX_API_KEY
@@ -96,6 +100,13 @@ ACP supports only `permissionMode: 'allow-all'` because its
 restrictive modes enable Codex's internal sandbox. A bridge-backed ACP harness
 requires a sandbox with at least one exposed port.
 
+`modelMapping` is required because ACP implementations expose different model
+selection operations. Use `session-config-option` with the ACP configuration
+option ID as `path`, or `session-model` with the JSON-RPC request property as
+`path` for implementations such as Grok Build that use the legacy
+`session/set_model` method. No model operation is sent when `HarnessAgent` has
+no model and the deprecated `modelId` fallback is also unset.
+
 Use `instructionMapping` when the ACP implementation exposes a native system
 or developer prompt. A `session-meta` mapping writes `HarnessAgent`
 instructions below the ACP session request's `_meta` field. A

package/dist/bridge/host-tool-mcp.mjs

@@ -12,7 +12,7 @@ import {
   ListToolsRequestSchema,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
-var VERSION = true ? "1.0.30" : "0.0.0-test";
+var VERSION = true ? "1.0.32" : "0.0.0-test";
 function createHostToolMCPServer({
   tools: tools2,
   revision = 1,

package/dist/bridge/index.mjs

@@ -157,6 +157,7 @@ var ENV_TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
 var WS_OPEN = 1;
 async function runBridge(options) {
   const { bridgeType: bridgeType2, bridgeStateDir: bridgeStateDir2, onStart, onStop, onDestroy } = options;
+  const teardownGraceMs = options.turnTeardownGraceMs ?? 1e4;
   const expectedToken = options.token ?? procEnv.BRIDGE_CHANNEL_TOKEN ?? "";
   const bridgeWsPort = options.port ?? parseInt(procEnv.BRIDGE_WS_PORT ?? "0", 10);
   const bridgeMetaPath = `${bridgeStateDir2}/bridge-meta.json`;
@@ -173,6 +174,7 @@ async function runBridge(options) {
   let isFirstTurn = true;
   let turnAbort;
   let currentUserMessages;
+  let activeTurn;
   let debugConfig;
   let consoleCaptureInstalled = false;
   const envDebugEnabled = ENV_TRUTHY.has(
@@ -363,10 +365,28 @@ async function runBridge(options) {
   const handleInbound = async (msg, ws) => {
     switch (msg.type) {
       case "start": {
+        for (; ; ) {
+          const pendingTurn = activeTurn;
+          if (pendingTurn == null) break;
+          turnAbort?.abort();
+          currentUserMessages?.close(
+            new Error("A new bridge turn replaced the active turn.")
+          );
+          let graceTimer;
+          const settled = await Promise.race([
+            pendingTurn.then(() => true),
+            new Promise((resolve) => {
+              graceTimer = setTimeout(() => resolve(false), teardownGraceMs);
+              graceTimer.unref?.();
+            })
+          ]);
+          clearTimeout(graceTimer);
+          if (!settled) break;
+        }
+        let turnFinished;
+        const thisTurn = new Promise((resolve) => turnFinished = resolve);
+        activeTurn = thisTurn;
         activeSocket = ws;
-        currentUserMessages?.close(
-          new Error("A new bridge turn replaced the active turn.")
-        );
         const firstTurn = isFirstTurn;
         isFirstTurn = false;
         eventLog = [];
@@ -423,8 +443,12 @@ async function runBridge(options) {
           if (currentUserMessages === userMessages) {
             currentUserMessages = void 0;
           }
-          currentTurnState = "waiting";
-          void writeBridgeMeta("waiting");
+          if (activeTurn === thisTurn) {
+            activeTurn = void 0;
+            currentTurnState = "waiting";
+            void writeBridgeMeta("waiting");
+          }
+          turnFinished();
         }
         return;
       }
@@ -607,7 +631,7 @@ function serialiseError(err) {
 }
 
 // src/v1/bridge/index.ts
-import * as acp4 from "@agentclientprotocol/sdk";
+import * as acp5 from "@agentclientprotocol/sdk";
 import { spawn } from "child_process";
 import { readFile, writeFile as writeFile2 } from "fs/promises";
 import { fileURLToPath } from "url";
@@ -659,7 +683,8 @@ var bridgeConfigurationSchema = z.object({
   authentication: authenticationSchema.optional(),
   providerAuthentication: providerAuthenticationSchema.optional(),
   providerEnvironment: z.record(z.string(), z.string()).optional(),
-  sessionMeta: serializableRecordSchema.optional()
+  sessionMeta: serializableRecordSchema.optional(),
+  clientCapabilities: serializableRecordSchema.optional()
 });
 async function readACPBridgeEnvironment({
   env
@@ -735,9 +760,13 @@ function createACPInitializeRequest({
   protocolVersion,
   clientApp,
   authentication,
+  clientCapabilities: configuredClientCapabilities,
   supportsBooleanSessionConfigOptions = false
 }) {
-  let clientCapabilities = authentication?.clientCapabilities ?? {};
+  let clientCapabilities = mergeRecords({
+    left: authentication?.clientCapabilities ?? {},
+    right: configuredClientCapabilities ?? {}
+  });
   if (supportsBooleanSessionConfigOptions) {
     clientCapabilities = mergeRecords({
       left: clientCapabilities,
@@ -2881,8 +2910,34 @@ function unsupported({
   return new HarnessBridgeCapabilityUnsupportedError({ harnessId, message });
 }
 
-// src/v1/bridge/recovered-session.ts
+// src/v1/bridge/model-mapping.ts
 import * as acp2 from "@agentclientprotocol/sdk";
+async function configureACPModel({
+  agent,
+  sessionId,
+  model,
+  mapping
+}) {
+  if (model == null) return;
+  if (mapping == null) {
+    throw new Error("ACP model mapping is required when a model is set.");
+  }
+  if (mapping.type === "session-model") {
+    await agent.request("session/set_model", {
+      sessionId,
+      [mapping.path]: model
+    });
+    return;
+  }
+  await agent.request(acp2.methods.agent.session.setConfigOption, {
+    sessionId,
+    configId: mapping.path,
+    value: model
+  });
+}
+
+// src/v1/bridge/recovered-session.ts
+import * as acp3 from "@agentclientprotocol/sdk";
 function assertACPResumeCapability({
   initialization,
   harnessId
@@ -2914,7 +2969,7 @@ function createACPRecoveredSession({
       }
       updates.clearErrors();
       const response = agent.request(
-        acp2.methods.agent.session.prompt,
+        acp3.methods.agent.session.prompt,
         { sessionId, prompt }
       );
       void response.then(
@@ -2935,7 +2990,7 @@ function createACPRecoveredSession({
       }
       updates.clearErrors();
       const response = agent.request(
-        acp2.methods.agent.session.prompt,
+        acp3.methods.agent.session.prompt,
         { sessionId, prompt, _meta: meta }
       );
       void response.then(
@@ -3008,7 +3063,7 @@ function createACPRecoveredSessionUpdates() {
 }
 
 // src/v1/bridge/session-lifecycle.ts
-import * as acp3 from "@agentclientprotocol/sdk";
+import * as acp4 from "@agentclientprotocol/sdk";
 function resolveACPSessionRestorationMethod({
   initialization,
   harnessId
@@ -3048,8 +3103,8 @@ async function restoreACPBridgeSession({
       mcpServers: [...mcpServers],
       ...meta == null ? {} : { _meta: meta }
     };
-    const response = method === "resume" ? await agent.request(acp3.methods.agent.session.resume, request) : await agent.request(
-      acp3.methods.agent.session.load,
+    const response = method === "resume" ? await agent.request(acp4.methods.agent.session.resume, request) : await agent.request(
+      acp4.methods.agent.session.load,
       request
     );
     discardCapturedHistory();
@@ -3201,6 +3256,12 @@ async function runTurn(start, turn) {
     });
     return;
   }
+  await configureACPModel({
+    agent: connection.agent,
+    sessionId: activeSession.sessionId,
+    model: start.model,
+    mapping: start.modelMapping
+  });
   let rejectCancellationFailure;
   const cancellationFailure = new Promise((_, reject) => {
     rejectCancellationFailure = reject;
@@ -3217,7 +3278,7 @@ async function runTurn(start, turn) {
       if (connection == null) {
         throw new Error("ACP connection closed before cancellation.");
       }
-      await connection.agent.notify(acp4.methods.agent.session.cancel, {
+      await connection.agent.notify(acp5.methods.agent.session.cancel, {
         sessionId: activeSession.sessionId
       });
     } catch (error) {
@@ -3388,11 +3449,13 @@ async function ensureSession({
     instructions: start.instructions,
     instructionMapping: start.instructionMapping,
     sessionMeta: bridgeConfiguration.sessionMeta,
-    environment: createChildEnvironment({
-      launchEnv,
-      implementationDir,
-      privateHome: implementation.privateHome
-    })
+    environment: {
+      ...createChildEnvironment({
+        launchEnv,
+        implementationDir,
+        privateHome: implementation.privateHome
+      })
+    }
   });
   child = spawn(
     `${implementationDir}/${implementation.executablePath}`,
@@ -3417,15 +3480,15 @@ async function ensureSession({
   const input = Writable.toWeb(child.stdin);
   const output = Readable.toWeb(child.stdout);
   const capturedStream = captureACPStream({
-    stream: acp4.ndJsonStream(input, output)
+    stream: acp5.ndJsonStream(input, output)
   });
   streamCapture = capturedStream.capture;
-  connection = acp4.client({ name: clientApp.name }).onRequest(
-    acp4.methods.client.session.requestPermission,
+  connection = acp5.client({ name: clientApp.name }).onRequest(
+    acp5.methods.client.session.requestPermission,
     ({ params }) => activePermissionController?.requestPermission(params) ?? {
       outcome: { outcome: "cancelled" }
     }
-  ).onNotification(acp4.methods.client.session.update, ({ params }) => {
+  ).onNotification(acp5.methods.client.session.update, ({ params }) => {
     if (params.sessionId !== recoveredSessionId) return;
     if (historicalUpdatesSuppressed) return;
     recoveredSessionUpdates?.enqueue({
@@ -3435,18 +3498,19 @@ async function ensureSession({
     });
   }).connect(capturedStream.stream);
   const initializeRequest = createACPInitializeRequest({
-    protocolVersion: acp4.PROTOCOL_VERSION,
+    protocolVersion: acp5.PROTOCOL_VERSION,
     clientApp,
     authentication,
+    clientCapabilities: bridgeConfiguration.clientCapabilities,
     supportsBooleanSessionConfigOptions: Object.values(
       start.permissionModeMapping ?? {}
     ).some(
       (target) => target?.type === "session-config-option" && typeof target.value === "boolean"
     )
   });
-  const initialization = await connection.agent.request(acp4.methods.agent.initialize, initializeRequest);
+  const initialization = await connection.agent.request(acp5.methods.agent.initialize, initializeRequest);
   validateACPProtocolVersion({
-    requested: acp4.PROTOCOL_VERSION,
+    requested: acp5.PROTOCOL_VERSION,
     initialization
   });
   if (authentication != null) {
@@ -3494,7 +3558,7 @@ async function ensureSession({
     assertACPResumeCapability({ initialization, harnessId: bridgeType });
     recoveredSessionId = start.recoveryMode.acpSessionId;
     recoveredSessionUpdates = createACPRecoveredSessionUpdates();
-    const resumeResponse = await connection.agent.request(acp4.methods.agent.session.resume, {
+    const resumeResponse = await connection.agent.request(acp5.methods.agent.session.resume, {
       sessionId: recoveredSessionId,
       cwd: workDir,
       mcpServers,
@@ -3616,7 +3680,7 @@ async function authenticate({
     initialization,
     methodId: authentication.methodId
   });
-  await agent.request(acp4.methods.agent.authenticate, {
+  await agent.request(acp5.methods.agent.authenticate, {
     methodId: authentication.methodId,
     ...authentication.meta == null ? {} : { _meta: authentication.meta }
   });
@@ -3718,7 +3782,7 @@ function promptActiveSession({
   }
   updates.clearErrors();
   const response = agent.request(
-    acp4.methods.agent.session.prompt,
+    acp5.methods.agent.session.prompt,
     {
       sessionId: session2.sessionId,
       prompt,