@ai-sdk/harness-deepagents 1.0.100 → 1.0.102

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @ai-sdk/harness-deepagents
 
+## 1.0.102
+
+### Patch Changes
+
+- eeed977: feat(harness): allow passing arbitrary headers with inference requests via `headers` property in `HarnessAgentSettings`
+- a39c8bf: chore(harness): clarify `writeSkills` helper intent to require materializing skills in HOME directory
+- Updated dependencies [fe86f8f]
+- Updated dependencies [255cccf]
+- Updated dependencies [eeed977]
+- Updated dependencies [a39c8bf]
+  - @ai-sdk/harness@1.0.102
+
+## 1.0.101
+
+### Patch Changes
+
+- Updated dependencies [951c54d]
+  - @ai-sdk/harness@1.0.101
+
 ## 1.0.100
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -218,6 +218,7 @@ async function runBridge(options) {
     }
   }
   const pendingToolResults = /* @__PURE__ */ new Map();
+  const bufferedToolResults = [];
   const pendingToolApprovals = /* @__PURE__ */ new Map();
   const writeBridgeMeta = async (state) => {
     try {
@@ -397,9 +398,23 @@ async function runBridge(options) {
         const userMessages = createBridgeUserMessageQueue({ respond: emit });
         const turn = {
           emit,
-          requestToolResult: (toolCallId) => new Promise((resolve) => {
-            pendingToolResults.set(toolCallId, resolve);
-          }),
+          requestToolResult: (requestInput) => {
+            const request = typeof requestInput === "string" ? { toolCallId: requestInput } : requestInput;
+            const bufferedIndex = bufferedToolResults.findIndex(
+              (buffered) => buffered.toolCallId === request.toolCallId || request.matches?.(buffered.result) === true
+            );
+            if (bufferedIndex >= 0) {
+              return Promise.resolve(
+                bufferedToolResults.splice(bufferedIndex, 1)[0].result
+              );
+            }
+            return new Promise((resolve) => {
+              pendingToolResults.set(request.toolCallId, {
+                resolve,
+                matches: request.matches
+              });
+            });
+          },
           requestToolApproval: (approvalId) => new Promise((resolve) => {
             pendingToolApprovals.set(approvalId, resolve);
           }),
@@ -441,10 +456,25 @@ async function runBridge(options) {
         return;
       }
       case "tool-result": {
-        const resolver = pendingToolResults.get(msg.toolCallId);
-        if (resolver) {
-          pendingToolResults.delete(msg.toolCallId);
-          resolver({ output: msg.output, isError: msg.isError });
+        const result = {
+          output: msg.output,
+          isError: msg.isError,
+          toolResult: msg.toolResult
+        };
+        const exactPending = pendingToolResults.get(msg.toolCallId);
+        const matchingPending = exactPending == null ? Array.from(pendingToolResults.entries()).find(
+          ([, pending2]) => pending2.matches?.(result) === true
+        ) : void 0;
+        const pending = exactPending ?? matchingPending?.[1];
+        const pendingId = exactPending != null ? msg.toolCallId : matchingPending?.[0];
+        if (pending != null && pendingId != null) {
+          pendingToolResults.delete(pendingId);
+          pending.resolve(result);
+        } else {
+          bufferedToolResults.push({
+            toolCallId: msg.toolCallId,
+            result
+          });
         }
         return;
       }
@@ -2105,7 +2135,8 @@ function parseArgs(rawArgs) {
 function buildModel({
   rawModel,
   thinking,
-  effort
+  effort,
+  headers
 }) {
   if (!rawModel) return void 0;
   const baseUrl = procEnv2.ANTHROPIC_BASE_URL;
@@ -2116,11 +2147,14 @@ function buildModel({
     ...effort ? { outputConfig: { effort } } : {},
     ...procEnv2.ANTHROPIC_API_KEY ? { apiKey: procEnv2.ANTHROPIC_API_KEY } : {},
     ...baseUrl ? { anthropicApiUrl: baseUrl } : {},
-    ...procEnv2.AI_GATEWAY_API_KEY && HARNESS_CLIENT_APP ? {
+    ...headers != null || procEnv2.AI_GATEWAY_API_KEY ? {
       clientOptions: {
         defaultHeaders: {
-          "User-Agent": HARNESS_CLIENT_APP,
-          "x-client-app": HARNESS_CLIENT_APP
+          ...headers,
+          ...procEnv2.AI_GATEWAY_API_KEY && HARNESS_CLIENT_APP ? {
+            "User-Agent": HARNESS_CLIENT_APP,
+            "x-client-app": HARNESS_CLIENT_APP
+          } : {}
         }
       }
     } : {}
@@ -2130,14 +2164,15 @@ function createModelMiddleware() {
   return createMiddleware({
     name: "harnessModel",
     wrapModelCall: async (request, handler) => {
-      if (!activeModel && !activeThinking && !activeEffort) {
+      if (!activeModel && !activeThinking && !activeEffort && !activeHeaders) {
         return handler(request);
       }
       if (activeModel) {
         const configuredModel2 = buildModel({
           rawModel: activeModel,
           thinking: activeThinking,
-          effort: activeEffort
+          effort: activeEffort,
+          headers: activeHeaders
         });
         if (!configuredModel2) throw new Error("Deep Agents model is missing");
         return handler({ ...request, model: configuredModel2 });
@@ -2152,7 +2187,8 @@ function createModelMiddleware() {
       const configuredModel = buildModel({
         rawModel: model.model,
         thinking: activeThinking,
-        effort: activeEffort
+        effort: activeEffort,
+        headers: activeHeaders
       });
       if (!configuredModel) throw new Error("Deep Agents model is missing");
       return handler({ ...request, model: configuredModel });
@@ -2185,6 +2221,7 @@ var agentConfigurationSignature;
 var activeModel;
 var activeThinking;
 var activeEffort;
+var activeHeaders;
 var modelMiddleware = createModelMiddleware();
 var responseFormatMiddleware = createMiddleware({
   name: "HarnessResponseFormat",
@@ -2225,6 +2262,7 @@ async function runTurn(start, turn) {
   if (start.model) activeModel = start.model;
   activeThinking = start.thinking;
   activeEffort = start.effort;
+  activeHeaders = start.headers;
   currentResponseFormat = start.responseFormat?.type === "json" && start.responseFormat.schema != null ? toolStrategy(start.responseFormat.schema) : void 0;
   const emit = (event) => turn.emit(event);
   const interruptOn = buildInterruptOn(