@ai-sdk/harness 0.0.0-6b196531-20260710185421

package/src/agent/harness-agent-tool-approval-continuation.ts

@@ -0,0 +1,94 @@
+import { HarnessError } from '../errors/harness-error';
+import type {
+  ModelMessage,
+  ToolApprovalRequest,
+  ToolApprovalResponse,
+} from '@ai-sdk/provider-utils';
+
+export type HarnessAgentToolApprovalContinuation = {
+  readonly approvalResponse: ToolApprovalResponse;
+  readonly toolCall: {
+    readonly type: 'tool-call';
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly input: unknown;
+    readonly providerExecuted?: boolean;
+  };
+};
+
+/**
+ * Extract approval decisions that should continue a suspended harness turn.
+ *
+ * AI SDK clients send approval decisions as a trailing `role: "tool"` message
+ * containing `tool-approval-response` parts. The response only carries the
+ * approval id, so the harness has to recover the matching approval request
+ * locally to find the original tool call before it can resume the paused turn.
+ * Responses that already have a tool result are ignored, because those
+ * approvals were already consumed by a prior continuation.
+ */
+export function collectHarnessAgentToolApprovalContinuations(input: {
+  messages: readonly ModelMessage[];
+}): readonly HarnessAgentToolApprovalContinuation[] {
+  const lastMessage = input.messages.at(-1);
+  if (lastMessage?.role !== 'tool') return [];
+
+  const toolCallsByToolCallId = new Map<
+    string,
+    HarnessAgentToolApprovalContinuation['toolCall']
+  >();
+  const approvalRequestsByApprovalId = new Map<string, ToolApprovalRequest>();
+  for (const message of input.messages) {
+    if (message.role !== 'assistant' || typeof message.content === 'string') {
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type === 'tool-call') {
+        toolCallsByToolCallId.set(part.toolCallId, {
+          type: 'tool-call',
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          input: part.input,
+          ...(part.providerExecuted !== undefined
+            ? { providerExecuted: part.providerExecuted }
+            : {}),
+        });
+      } else if (part.type === 'tool-approval-request') {
+        approvalRequestsByApprovalId.set(part.approvalId, part);
+      }
+    }
+  }
+
+  const toolResultIds = new Set<string>();
+  for (const part of lastMessage.content) {
+    if (part.type === 'tool-result') {
+      toolResultIds.add(part.toolCallId);
+    }
+  }
+
+  const continuations: HarnessAgentToolApprovalContinuation[] = [];
+  for (const part of lastMessage.content) {
+    if (part.type !== 'tool-approval-response') continue;
+
+    const approvalRequest = approvalRequestsByApprovalId.get(part.approvalId);
+    if (approvalRequest == null) {
+      throw new HarnessError({
+        message: `Tool approval response '${part.approvalId}' does not match a prior tool approval request.`,
+      });
+    }
+    if (toolResultIds.has(approvalRequest.toolCallId)) continue;
+
+    const toolCall = toolCallsByToolCallId.get(approvalRequest.toolCallId);
+    if (toolCall == null) {
+      throw new HarnessError({
+        message: `Tool approval request '${approvalRequest.approvalId}' references unknown tool call '${approvalRequest.toolCallId}'.`,
+      });
+    }
+
+    continuations.push({
+      approvalResponse: part,
+      toolCall,
+    });
+  }
+
+  return continuations;
+}

package/src/agent/harness-agent-tool-types.ts

@@ -0,0 +1,15 @@
+import type { HarnessAgentAdapter } from './harness-agent-types';
+import type { ToolSet } from '@ai-sdk/provider-utils';
+
+/** Extract the builtin tool set type from a harness adapter parameter. */
+export type HarnessBuiltinToolsOf<H> =
+  H extends HarnessAgentAdapter<infer T> ? T : never;
+
+/**
+ * Type-level merge of a harness's builtin tools with user-defined tools.
+ * User tools override builtins on key collision.
+ */
+export type HarnessAllTools<
+  THarness extends HarnessAgentAdapter<any>,
+  TUserTools extends ToolSet,
+> = Omit<HarnessBuiltinToolsOf<THarness>, keyof TUserTools> & TUserTools;

package/src/agent/harness-agent-types.ts

@@ -0,0 +1,50 @@
+import type { ToolSet } from '@ai-sdk/provider-utils';
+import type {
+  HARNESS_V1_BUILTIN_TOOLS,
+  HarnessV1,
+  HarnessV1BuiltinTool,
+  HarnessV1BuiltinToolName,
+  HarnessV1BuiltinToolUseKind,
+  HarnessV1ContinueTurnOptions,
+  HarnessV1ContinueTurnState,
+  HarnessV1LifecycleState,
+  HarnessV1PendingToolApproval,
+  HarnessV1PermissionMode,
+  HarnessV1Prompt,
+  HarnessV1PromptControl,
+  HarnessV1PromptTurnOptions,
+  HarnessV1ResumeSessionState,
+  HarnessV1Session,
+  HarnessV1Skill,
+  HarnessV1StartOptions,
+  HarnessV1StreamPart,
+  HarnessV1ToolSpec,
+} from '../v1';
+
+export type HarnessAgentAdapter<TBuiltinTools extends ToolSet = ToolSet> =
+  HarnessV1<TBuiltinTools>;
+
+export type HarnessAgentBuiltinTool<
+  INPUT = unknown,
+  OUTPUT = unknown,
+> = HarnessV1BuiltinTool<INPUT, OUTPUT>;
+export type HarnessAgentBuiltinToolName = HarnessV1BuiltinToolName;
+export type HarnessAgentBuiltinToolUseKind = HarnessV1BuiltinToolUseKind;
+export type HarnessAgentBuiltinTools = typeof HARNESS_V1_BUILTIN_TOOLS;
+
+export type HarnessAgentStartOptions = HarnessV1StartOptions;
+export type HarnessAgentAdapterSession = HarnessV1Session;
+export type HarnessAgentPrompt = HarnessV1Prompt;
+export type HarnessAgentPromptControl = HarnessV1PromptControl;
+export type HarnessAgentPromptTurnOptions = HarnessV1PromptTurnOptions;
+export type HarnessAgentContinueTurnOptions = HarnessV1ContinueTurnOptions;
+export type HarnessAgentStreamPart = HarnessV1StreamPart;
+export type HarnessAgentToolSpec = HarnessV1ToolSpec;
+
+export type HarnessAgentLifecycleState = HarnessV1LifecycleState;
+export type HarnessAgentResumeSessionState = HarnessV1ResumeSessionState;
+export type HarnessAgentContinueTurnState = HarnessV1ContinueTurnState;
+export type HarnessAgentPendingToolApproval = HarnessV1PendingToolApproval;
+
+export type HarnessAgentSkill = HarnessV1Skill;
+export type HarnessAgentPermissionMode = HarnessV1PermissionMode;