@ai-sdk/harness-acp 1.0.31 → 1.0.33

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @ai-sdk/harness-acp
 
+## 1.0.33
+
+### Patch Changes
+
+- 371e954: feat(harness): add `createBridgeToken()` and `withBridgeToken()` helpers for bridge backed harness adapters
+- 62f481f: fix(harness): fix bridge resolution to no longer look for an alternative path which could cause Turbopack errors
+- Updated dependencies [371e954]
+- Updated dependencies [87b4858]
+  - @ai-sdk/harness@1.0.95
+
+## 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

package/README.md

@@ -34,9 +34,10 @@ const codexACP = createACP({
     packageVersion: '1.1.4',
   },
   executable: 'codex-acp',
-  resolveModel: ({ model }) => ({
-    env: { CODEX_CONFIG: JSON.stringify({ model }) },
-  }),
+  modelMapping: {
+    type: 'session-config-option',
+    path: 'model',
+  },
   credentialEnv: ['CODEX_API_KEY', 'OPENAI_API_KEY'],
   credentialBrokering: ({ env, sandboxEnv }) => {
     const environmentVariableName = env.CODEX_API_KEY
@@ -99,12 +100,12 @@ 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.
 
-`resolveModel` is required because each ACP implementation accepts its model in
-a different place. It receives the `HarnessAgent` model when a session starts
-and can return launch `args`, `env`, or both. Returned arguments replace the
-static `args`; returned environment values overlay the static `env`. The
-resolver is not called when `HarnessAgent` has no model and the deprecated
-`modelId` fallback is also unset.
+`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`

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

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

package/dist/bridge/index.mjs

@@ -631,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";
@@ -684,8 +684,7 @@ var bridgeConfigurationSchema = z.object({
   providerAuthentication: providerAuthenticationSchema.optional(),
   providerEnvironment: z.record(z.string(), z.string()).optional(),
   sessionMeta: serializableRecordSchema.optional(),
-  implementationArgs: z.array(z.string()).optional(),
-  implementationEnv: z.record(z.string(), z.string()).optional()
+  clientCapabilities: serializableRecordSchema.optional()
 });
 async function readACPBridgeEnvironment({
   env
@@ -761,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,
@@ -2907,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
@@ -2940,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(
@@ -2961,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(
@@ -3034,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
@@ -3074,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();
@@ -3227,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;
@@ -3243,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) {
@@ -3419,13 +3454,12 @@ async function ensureSession({
         launchEnv,
         implementationDir,
         privateHome: implementation.privateHome
-      }),
-      ...bridgeConfiguration.implementationEnv
+      })
     }
   });
   child = spawn(
     `${implementationDir}/${implementation.executablePath}`,
-    [...bridgeConfiguration.implementationArgs ?? implementation.args],
+    [...implementation.args],
     {
       cwd: workDir,
       env: instructionConfiguration.environment,
@@ -3446,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({
@@ -3464,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) {
@@ -3523,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,
@@ -3645,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 }
   });
@@ -3747,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,