@ai-sdk/harness-codex 1.0.152 → 1.0.153

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @ai-sdk/harness-codex
 
+## 1.0.153
+
+### Patch Changes
+
+- 6c65131: feat(harness): consistently support parallel and sequential tool approvals
+- 1bebfcf: feat(harness): add support for tools with `toModelOutput()` transformation
+- Updated dependencies [6c65131]
+- Updated dependencies [1bebfcf]
+  - @ai-sdk/harness@1.0.151
+
 ## 1.0.152
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -8,6 +8,71 @@ import { spawn } from "node:child_process";
 import { isDeepStrictEqual } from "node:util";
 import path from "node:path";
 //#region ../harness/dist/bridge/index.js
+const name = "AI_HarnessBridgeCapabilityUnsupportedError";
+/**
+* Signals an unsupported capability discovered inside a sandbox bridge.
+* `isInstance` also recognizes the serialized error shape received by the
+* host, where it can be translated to `HarnessCapabilityUnsupportedError`.
+*/
+var HarnessBridgeCapabilityUnsupportedError = class extends Error {
+	constructor({ message, harnessId, cause }) {
+		super(message);
+		Object.defineProperty(this, "name", { value: name });
+		this.harnessId = harnessId;
+		this.cause = cause;
+	}
+	static isInstance(error) {
+		return error != null && typeof error === "object" && "name" in error && error.name === name && "message" in error && typeof error.message === "string";
+	}
+};
+function getNormalizedInlineImage(part) {
+	if (part.type === "file" && part.mediaType.startsWith("image/") && part.mediaType !== "image/*" && part.data.type === "data" && typeof part.data.data === "string") return {
+		data: part.data.data,
+		mediaType: part.mediaType
+	};
+}
+function convertHarnessToolModelOutput({ output }) {
+	switch (output.type) {
+		case "text":
+		case "error-text": return {
+			content: [{
+				type: "text",
+				text: output.value
+			}],
+			isError: output.type === "error-text"
+		};
+		case "json":
+		case "error-json": return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(output.value)
+			}],
+			isError: output.type === "error-json"
+		};
+		case "execution-denied": return {
+			content: [{
+				type: "text",
+				text: output.reason ?? "Tool execution denied."
+			}],
+			isError: true
+		};
+		case "content": return {
+			content: output.value.map((part) => {
+				if (part.type === "text") return {
+					type: "text",
+					text: part.text
+				};
+				const image = getNormalizedInlineImage(part);
+				if (image != null) return {
+					type: "image",
+					...image
+				};
+				throw new HarnessBridgeCapabilityUnsupportedError({ message: `Harnesses support only text and inline images in tool model output; unsupported content '${part.type}'.` });
+			}),
+			isError: false
+		};
+	}
+}
 const DEBUG_LEVEL_WEIGHT = {
 	error: 0,
 	warn: 1,
@@ -1352,7 +1417,8 @@ function createCodexAppServerRuntime() {
 						request,
 						dynamicTools: active.dynamicTools,
 						emit: active.options.emit,
-						requestToolResult: active.options.turn.requestToolResult
+						requestToolResult: active.options.turn.requestToolResult,
+						stepTracker: active.options.stepTracker
 					}).catch((error) => {
 						active.fail(error);
 						throw error;
@@ -1607,7 +1673,7 @@ function createDynamicTools(tools) {
 function isValidDynamicToolName(name) {
 	return name.length > 0 && name.length <= 128 && /^[a-zA-Z0-9_-]+$/.test(name) && name !== "mcp" && !name.startsWith("mcp__");
 }
-async function handleAppServerRequest({ request, dynamicTools, emit, requestToolResult }) {
+async function handleAppServerRequest({ request, dynamicTools, emit, requestToolResult, stepTracker }) {
 	if (request.method !== "item/tool/call") throw new Error(`Codex app-server requested unsupported method '${request.method}'.`);
 	const params = asRecord(request.params);
 	if (params == null || typeof params.callId !== "string" || typeof params.tool !== "string") throw new Error("Codex app-server sent an invalid dynamic tool request.");
@@ -1620,7 +1686,9 @@ async function handleAppServerRequest({ request, dynamicTools, emit, requestTool
 		input: JSON.stringify(params.arguments ?? {}),
 		providerExecuted: false
 	});
-	const result = await requestToolResult(params.callId);
+	const callId = params.callId;
+	stepTracker.awaitHostInput({ itemId: callId });
+	const result = await requestToolResult(callId).finally(() => stepTracker.resolveHostInput({ itemId: callId }));
 	emit({
 		type: "tool-result",
 		toolCallId: params.callId,
@@ -1628,6 +1696,19 @@ async function handleAppServerRequest({ request, dynamicTools, emit, requestTool
 		result: result.output ?? null,
 		isError: result.isError === true
 	});
+	if (result.toolResult != null) {
+		const converted = convertHarnessToolModelOutput({ output: result.toolResult.output });
+		return {
+			contentItems: converted.content.map((part) => part.type === "text" ? {
+				type: "inputText",
+				text: part.text
+			} : {
+				type: "inputImage",
+				imageUrl: `data:${part.mediaType};base64,${part.data}`
+			}),
+			success: result.isError !== true && !converted.isError
+		};
+	}
 	return {
 		contentItems: [{
 			type: "inputText",
@@ -1663,6 +1744,8 @@ function asRecord(value) {
 function createCodexStepTracker(input) {
 	let stepOpen = false;
 	const pendingToolItemIds = /* @__PURE__ */ new Set();
+	const hostInputWaitingItemIds = /* @__PURE__ */ new Set();
+	const earlyFinishStepItemIds = /* @__PURE__ */ new Set();
 	const finishStep = () => {
 		if (!stepOpen || pendingToolItemIds.size > 0) return;
 		input.send({
@@ -1675,6 +1758,23 @@ function createCodexStepTracker(input) {
 			harnessMetadata: { codex: { inferredStep: true } }
 		});
 		stepOpen = false;
+		earlyFinishStepItemIds.clear();
+	};
+	const emitEarlyFinishStepIfReady = () => {
+		if (!stepOpen || pendingToolItemIds.size === 0) return;
+		for (const itemId of pendingToolItemIds) if (!hostInputWaitingItemIds.has(itemId)) return;
+		const uncovered = [...pendingToolItemIds].filter((itemId) => !earlyFinishStepItemIds.has(itemId));
+		if (uncovered.length === 0) return;
+		for (const itemId of uncovered) earlyFinishStepItemIds.add(itemId);
+		input.send({
+			type: "finish-step",
+			finishReason: {
+				unified: "tool-calls",
+				raw: "host-input"
+			},
+			usage: defaultUsage(),
+			harnessMetadata: { codex: { inferredStep: true } }
+		});
 	};
 	return {
 		observeEvent({ event, itemId }) {
@@ -1682,8 +1782,10 @@ function createCodexStepTracker(input) {
 			if (!item || !isStepItem(item)) return;
 			stepOpen = true;
 			if (isToolStepItem(item)) {
-				if (event.type === "item.started" && itemId) pendingToolItemIds.add(itemId);
-				else if (event.type === "item.completed") {
+				if (event.type === "item.started" && itemId) {
+					pendingToolItemIds.add(itemId);
+					emitEarlyFinishStepIfReady();
+				} else if (event.type === "item.completed") {
 					if (itemId) pendingToolItemIds.delete(itemId);
 					finishStep();
 				}
@@ -1691,7 +1793,17 @@ function createCodexStepTracker(input) {
 		},
 		finishTurn() {
 			pendingToolItemIds.clear();
+			hostInputWaitingItemIds.clear();
 			finishStep();
+		},
+		awaitHostInput({ itemId }) {
+			stepOpen = true;
+			pendingToolItemIds.add(itemId);
+			hostInputWaitingItemIds.add(itemId);
+			emitEarlyFinishStepIfReady();
+		},
+		resolveHostInput({ itemId }) {
+			hostInputWaitingItemIds.delete(itemId);
 		}
 	};
 }