@ai-sdk/harness 1.0.99 → 1.0.101

package/src/bridge/index.ts

@@ -11,6 +11,7 @@ import { appendFile, mkdir, writeFile } from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { env as procEnv, pid, stdout } from 'node:process';
+import type { ToolResultPart } from '@ai-sdk/provider-utils';
 import { WebSocketServer, type WebSocket } from 'ws';
 
 export { HarnessBridgeCapabilityUnsupportedError } from './harness-bridge-capability-unsupported-error';
@@ -244,8 +245,21 @@ export interface BridgeTurn {
    * itself (via {@link emit}) using the same `toolCallId`.
    */
   requestToolResult(
-    toolCallId: string,
-  ): Promise<{ output: unknown; isError?: boolean }>;
+    input:
+      | string
+      | {
+          toolCallId: string;
+          matches?: (result: {
+            output: unknown;
+            isError?: boolean;
+            toolResult?: ToolResultPart;
+          }) => boolean;
+        },
+  ): Promise<{
+    output: unknown;
+    isError?: boolean;
+    toolResult?: ToolResultPart;
+  }>;
 
   /**
    * Register interest in a host approval decision and resolve when the matching
@@ -342,6 +356,7 @@ type InboundControl =
       toolCallId: string;
       output: unknown;
       isError?: boolean;
+      toolResult?: ToolResultPart;
     }
   | {
       type: 'tool-approval-response';
@@ -506,8 +521,27 @@ export async function runBridge<TStart extends { type: 'start' }>(
 
   const pendingToolResults = new Map<
     string,
-    (output: { output: unknown; isError?: boolean }) => void
+    {
+      resolve: (output: {
+        output: unknown;
+        isError?: boolean;
+        toolResult?: ToolResultPart;
+      }) => void;
+      matches?: (output: {
+        output: unknown;
+        isError?: boolean;
+        toolResult?: ToolResultPart;
+      }) => boolean;
+    }
   >();
+  const bufferedToolResults: Array<{
+    toolCallId: string;
+    result: {
+      output: unknown;
+      isError?: boolean;
+      toolResult?: ToolResultPart;
+    };
+  }> = [];
   const pendingToolApprovals = new Map<
     string,
     (response: { approved: boolean; reason?: string }) => void
@@ -749,10 +783,28 @@ export async function runBridge<TStart extends { type: 'start' }>(
         const userMessages = createBridgeUserMessageQueue({ respond: emit });
         const turn: BridgeTurn = {
           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);
@@ -800,10 +852,29 @@ export async function runBridge<TStart extends { type: 'start' }>(
         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(
+                ([, pending]) => pending.matches?.(result) === true,
+              )
+            : undefined;
+        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;
       }

package/src/utils/sandbox-credential-brokering.ts

@@ -11,7 +11,38 @@ export function isSandboxCredentialPlaceholder(value: string): boolean {
   return /^aisdkhc_[A-Za-z0-9_-]{43}$/.test(value);
 }
 
-export function warnCredentialBrokeringUnavailable(): void {
+/**
+ * Warns when credential brokering is unavailable, but only if real credentials
+ * remain among the credentials forwarded into the sandbox.
+ */
+export function warnCredentialBrokeringUnavailable(options: {
+  environment: Readonly<Record<string, string>>;
+  forwardedEnvironment: Readonly<Record<string, string>>;
+  credentialEnvironmentVariables: ReadonlyArray<string>;
+}): void {
+  const credentialEnvironmentVariables = [
+    ...new Set(options.credentialEnvironmentVariables),
+  ];
+  const credentials = credentialEnvironmentVariables
+    .map(name => options.environment[name])
+    .filter(
+      (credential): credential is string =>
+        credential != null && credential.length > 0,
+    );
+  const forwardedCredentials = credentialEnvironmentVariables
+    .map(name => options.forwardedEnvironment[name])
+    .filter((credential): credential is string => credential != null);
+
+  if (
+    !credentials.some(credential =>
+      forwardedCredentials.some(forwardedCredential =>
+        forwardedCredential.includes(credential),
+      ),
+    )
+  ) {
+    return;
+  }
+
   console.warn(
     'The sandbox implementation does not support configuring request transformations, so credential brokering does not work. Falling back to less secure credential forwarding.',
   );

package/src/v1/harness-v1-bridge-protocol.ts

@@ -295,6 +295,7 @@ export const harnessV1BridgeToolResultInboundSchema = z.object({
   toolCallId: z.string(),
   output: z.unknown(),
   isError: z.boolean().optional(),
+  toolResult: z.unknown().optional(),
 });
 
 export const harnessV1BridgeToolApprovalResponseInboundSchema = z.object({

package/src/v1/harness-v1-builtin-tool.ts

@@ -1,5 +1,6 @@
 import { tool, type FlexibleSchema, type Tool } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
+import { harnessV1QuestionsTool } from './harness-v1-questions-tool';
 
 /**
  * Cross-harness vocabulary of common built-in tool names with their baseline
@@ -50,6 +51,7 @@ export const HARNESS_V1_BUILTIN_TOOLS = {
     inputSchema: z.object({ query: z.string() }),
     outputSchema: z.unknown(),
   }),
+  askUserQuestions: harnessV1QuestionsTool,
 } as const;
 
 export type HarnessV1BuiltinToolName = keyof typeof HARNESS_V1_BUILTIN_TOOLS;

package/src/v1/harness-v1-lifecycle-state.ts

@@ -1,4 +1,5 @@
 import type { JSONValue } from '@ai-sdk/provider';
+import type { ProviderOptions } from '@ai-sdk/provider-utils';
 import type { HarnessV1Skill } from './harness-v1-skill';
 import type { HarnessV1ToolSpec } from './harness-v1-tool-spec';
 
@@ -16,6 +17,7 @@ export type HarnessV1PendingToolResult = {
   readonly toolCallId: string;
   readonly toolName: string;
   readonly input: string;
+  readonly providerOptions?: ProviderOptions;
 };
 
 /**

package/src/v1/harness-v1-prompt-control.ts

@@ -1,3 +1,5 @@
+import type { ToolResultPart } from '@ai-sdk/provider-utils';
+
 /**
  * Bidirectional control surface returned by `doPromptTurn`.
  *
@@ -16,6 +18,7 @@ export type HarnessV1PromptControl = {
     toolCallId: string;
     output: unknown;
     isError?: boolean;
+    toolResult?: ToolResultPart;
   }): PromiseLike<void>;
 
   /**

package/src/v1/harness-v1-questions-tool.ts

@@ -0,0 +1,72 @@
+import type { FunctionTool } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+const harnessV1QuestionSchema = z.object({
+  id: z.string().min(1),
+  question: z.string().min(1),
+  header: z.string().optional(),
+  options: z
+    .array(
+      z.object({
+        id: z.string().min(1),
+        label: z.string().min(1),
+        description: z.string().optional(),
+        preview: z.string().optional(),
+      }),
+    )
+    .optional(),
+  allowMultiple: z.boolean().optional(),
+  allowFreeForm: z
+    .union([
+      z.boolean(),
+      z.object({
+        secret: z.boolean(),
+      }),
+    ])
+    .optional(),
+});
+
+export const harnessV1QuestionsToolInputSchema = z.object({
+  allowPartialAnswers: z.boolean(),
+  questions: z.array(harnessV1QuestionSchema).min(1),
+});
+
+const harnessV1QuestionAnswerSchema = z.object({
+  optionIds: z.array(z.string()),
+  freeform: z.string().optional(),
+});
+
+export const harnessV1QuestionsToolOutputSchema = z.discriminatedUnion(
+  'action',
+  [
+    z.object({
+      action: z.literal('answered'),
+      answers: z.record(z.string(), harnessV1QuestionAnswerSchema),
+    }),
+    z.object({
+      action: z.literal('partially-answered'),
+      answers: z.record(z.string(), harnessV1QuestionAnswerSchema),
+    }),
+    z.object({ action: z.literal('declined') }),
+    z.object({ action: z.literal('cancelled') }),
+  ],
+);
+
+export type HarnessV1QuestionsToolInput = z.infer<
+  typeof harnessV1QuestionsToolInputSchema
+>;
+
+export type HarnessV1QuestionsToolOutput = z.infer<
+  typeof harnessV1QuestionsToolOutputSchema
+>;
+
+export const harnessV1QuestionsTool: FunctionTool<
+  HarnessV1QuestionsToolInput,
+  HarnessV1QuestionsToolOutput
+> = {
+  description: 'Ask the user one or more questions',
+  inputSchema: harnessV1QuestionsToolInputSchema,
+  outputSchema: harnessV1QuestionsToolOutputSchema,
+};
+
+export type HarnessV1QuestionsTool = typeof harnessV1QuestionsTool;

package/src/v1/index.ts

@@ -28,6 +28,15 @@ export {
   HARNESS_V1_BUILTIN_TOOLS,
   commonTool,
 } from './harness-v1-builtin-tool';
+export type {
+  HarnessV1QuestionsTool,
+  HarnessV1QuestionsToolInput,
+  HarnessV1QuestionsToolOutput,
+} from './harness-v1-questions-tool';
+export {
+  harnessV1QuestionsToolInputSchema,
+  harnessV1QuestionsToolOutputSchema,
+} from './harness-v1-questions-tool';
 export type { HarnessV1Metadata } from './harness-v1-metadata';
 export type { HarnessV1Prompt } from './harness-v1-prompt';
 export type {