@oh-my-pi/pi-agent-core 17.1.0 → 17.1.2

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [17.1.2] - 2026-07-24
+
+### Added
+
+- Added `resolveFallbackTool` option to allow routing unadvertised tool calls to host-side transports (e.g., device mounts)
+
+## [17.1.1] - 2026-07-24
+
+### Added
+
+- Added the provider-neutral native computer-call lifecycle, preserving observation outputs and input actions across pending and acknowledged tool results.
+
+### Changed
+
+- Queued steering no longer hard-aborts non-interruptible tools (e.g. `bash`): it aborts interruptible waits only and raises a cooperative steering signal (`ToolCallContext.steeringSignal`) that long-running tools may observe to finish early or background themselves. The mid-batch steering/IRC watch now runs for every tool batch instead of only batches containing an interruptible tool.
+
 ## [17.1.0] - 2026-07-24
 
 ### Added

package/dist/types/agent.d.ts

@@ -134,6 +134,12 @@ export interface AgentOptions {
      * Use for deobfuscating secrets or rewriting arguments.
      */
     transformToolCallArguments?: (args: Record<string, unknown>, toolName: string) => Record<string, unknown>;
+    /**
+     * Resolve a tool call whose name matched no advertised tool. Lets hosts
+     * route calls to tools exposed through side transports (e.g. `xd://`
+     * device mounts) instead of failing with "Tool not found".
+     */
+    resolveFallbackTool?: (name: string) => AgentTool<any> | undefined;
     /** Enable intent tracing schema injection/stripping in the harness. */
     intentTracing?: boolean;
     /**

package/dist/types/types.d.ts

@@ -1,4 +1,4 @@
-import type { ApiKey, AssistantMessage, AssistantMessageEvent, AssistantMessageEventStream, Context, Effort, ImageContent, Message, Model, ServiceTier, SimpleStreamOptions, Static, streamSimple, TextContent, Tool, ToolChoice, ToolResultMessage, TSchema } from "@oh-my-pi/pi-ai";
+import type { ApiKey, AssistantMessage, AssistantMessageEvent, AssistantMessageEventStream, Context, Effort, ImageContent, Message, Model, ServiceTier, SimpleStreamOptions, Static, streamSimple, TextContent, Tool, ToolCallProviderMetadata, ToolChoice, ToolResultMessage, ToolResultProviderMetadata, TSchema } from "@oh-my-pi/pi-ai";
 import type { Dialect } from "@oh-my-pi/pi-ai/dialect";
 import type { HarmonyAuditEvent } from "@oh-my-pi/pi-ai/utils/harmony-leak";
 import type { AppendOnlyContextManager } from "./append-only-context.js";
@@ -230,6 +230,13 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      * Use for deobfuscating secrets or rewriting arguments.
      */
     transformToolCallArguments?: (args: Record<string, unknown>, toolName: string) => Record<string, unknown>;
+    /**
+     * Resolve a tool call whose name matched no advertised tool (including
+     * `customWireName` aliases). Lets hosts route calls to tools they expose
+     * through side transports (e.g. `xd://` device mounts) instead of failing
+     * with "Tool not found". Returning `undefined` keeps the failure.
+     */
+    resolveFallbackTool?: (name: string) => AgentTool<any> | undefined;
     /**
      * Enable intent tracing for tool calls.
      * When enabled, the harness injects a `string` field into tool schemas sent to the model,
@@ -399,6 +406,8 @@ export interface ToolCallContext {
         id: string;
         name: string;
     }>;
+    /** Provider-native metadata for the current call, when present. */
+    providerMetadata?: ToolCallProviderMetadata;
     /**
      * Cooperative steering signal: aborted when a queued user/steering message
      * (or an interrupting peer IRC) is detected while this tool batch runs.
@@ -437,6 +446,8 @@ export interface AfterToolCallResult {
     content?: (TextContent | ImageContent)[];
     /** If provided, replaces the tool result details payload in full. */
     details?: unknown;
+    /** If provided, replaces the provider-native result metadata in full. */
+    providerMetadata?: ToolResultProviderMetadata;
     /** If provided, replaces the error flag carried with the tool result. */
     isError?: boolean;
     /** If provided, replaces the contextually-useless flag carried with the tool result. */
@@ -512,6 +523,8 @@ export interface AgentToolResult<T = any, _TInput = unknown> {
     content: (TextContent | ImageContent)[];
     details?: T;
     isError?: boolean;
+    /** Provider-native metadata that must survive into history replay unchanged. */
+    providerMetadata?: ToolResultProviderMetadata;
     /** Marks the result as contextually useless: safe for compaction to elide once consumed (e.g. zero matches, wait timeout). Ignored when isError is set. */
     useless?: boolean;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "17.1.0",
+	"version": "17.1.2",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -35,12 +35,12 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "17.1.0",
-		"@oh-my-pi/pi-catalog": "17.1.0",
-		"@oh-my-pi/pi-natives": "17.1.0",
-		"@oh-my-pi/pi-utils": "17.1.0",
-		"@oh-my-pi/pi-wire": "17.1.0",
-		"@oh-my-pi/snapcompact": "17.1.0",
+		"@oh-my-pi/pi-ai": "17.1.2",
+		"@oh-my-pi/pi-catalog": "17.1.2",
+		"@oh-my-pi/pi-natives": "17.1.2",
+		"@oh-my-pi/pi-utils": "17.1.2",
+		"@oh-my-pi/pi-wire": "17.1.2",
+		"@oh-my-pi/snapcompact": "17.1.2",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {

package/src/agent-loop.ts

@@ -5,6 +5,8 @@
 import {
 	type AssistantMessage,
 	type AssistantMessageEvent,
+	type ComputerAction,
+	type ComputerSafetyCheck,
 	type Context,
 	EventStream,
 	isApiKeyResolver,
@@ -12,8 +14,10 @@ import {
 	seedApiKeyResolver,
 	streamSimple,
 	stripSchemaDescriptions,
+	type ToolCallProviderMetadata,
 	type ToolChoice,
 	type ToolResultMessage,
+	type ToolResultProviderMetadata,
 	type TSchema,
 	toolWireSchema,
 	validateToolArguments,
@@ -106,6 +110,7 @@ const MAX_SOFT_TOOL_ESCALATIONS = 3;
 function hardToolChoiceBlocks(choice: ToolChoice | undefined, requiredTool: string): boolean {
 	if (choice === undefined) return false;
 	if (typeof choice === "string") return choice === "none";
+	if (choice.type === "computer") return requiredTool !== "computer";
 	const name = choice.type === "tool" ? choice.name : "function" in choice ? choice.function.name : choice.name;
 	return name !== requiredTool;
 }
@@ -180,6 +185,160 @@ export function resolveOwnedDialectFromEnv(value: string | undefined): Dialect |
 type AssistantContentBlock = AssistantMessage["content"][number];
 type AssistantToolCallBlock = Extract<AssistantContentBlock, { type: "toolCall" }>;
 
+function snapshotComputerSafetyChecks(value: unknown): ComputerSafetyCheck[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const checks: ComputerSafetyCheck[] = [];
+	for (const raw of value) {
+		if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined;
+		const check = raw as Record<string, unknown>;
+		if (typeof check.id !== "string" || check.id.length === 0) return undefined;
+		if (check.code !== undefined && check.code !== null && typeof check.code !== "string") return undefined;
+		if (check.message !== undefined && check.message !== null && typeof check.message !== "string") return undefined;
+		checks.push({
+			id: check.id,
+			...(check.code !== undefined ? { code: check.code as string | null } : {}),
+			...(check.message !== undefined ? { message: check.message as string | null } : {}),
+		});
+	}
+	return checks;
+}
+
+function isFiniteCoordinate(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value);
+}
+
+function hasValidComputerKeys(value: unknown, optional: boolean): boolean {
+	return (
+		(optional && value === undefined) ||
+		value === null ||
+		(Array.isArray(value) && value.every(key => typeof key === "string"))
+	);
+}
+
+function snapshotComputerAction(value: unknown): ComputerAction | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const action = value as Record<string, unknown>;
+	switch (action.type) {
+		case "click":
+			if (
+				!(["left", "right", "wheel", "back", "forward"] as unknown[]).includes(action.button) ||
+				!isFiniteCoordinate(action.x) ||
+				!isFiniteCoordinate(action.y) ||
+				!hasValidComputerKeys(action.keys, true)
+			)
+				return undefined;
+			break;
+		case "double_click":
+			if (
+				!isFiniteCoordinate(action.x) ||
+				!isFiniteCoordinate(action.y) ||
+				!hasValidComputerKeys(action.keys, false)
+			)
+				return undefined;
+			break;
+		case "drag":
+			if (
+				!Array.isArray(action.path) ||
+				!action.path.every(
+					point =>
+						point &&
+						typeof point === "object" &&
+						isFiniteCoordinate((point as Record<string, unknown>).x) &&
+						isFiniteCoordinate((point as Record<string, unknown>).y),
+				) ||
+				!hasValidComputerKeys(action.keys, true)
+			)
+				return undefined;
+			break;
+		case "keypress":
+			if (!Array.isArray(action.keys) || !action.keys.every(key => typeof key === "string")) return undefined;
+			break;
+		case "move":
+			if (!isFiniteCoordinate(action.x) || !isFiniteCoordinate(action.y) || !hasValidComputerKeys(action.keys, true))
+				return undefined;
+			break;
+		case "screenshot":
+		case "wait":
+			break;
+		case "scroll":
+			if (
+				!isFiniteCoordinate(action.x) ||
+				!isFiniteCoordinate(action.y) ||
+				!isFiniteCoordinate(action.scroll_x) ||
+				!isFiniteCoordinate(action.scroll_y) ||
+				!hasValidComputerKeys(action.keys, true)
+			)
+				return undefined;
+			break;
+		case "type":
+			if (typeof action.text !== "string") return undefined;
+			break;
+		default:
+			return undefined;
+	}
+	return structuredCloneJSON(action) as ComputerAction;
+}
+
+function snapshotToolCallProviderMetadata(value: unknown): ToolCallProviderMetadata | undefined {
+	if (value === undefined) return undefined;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const metadata = value as Record<string, unknown>;
+	if (
+		metadata.type !== "computer" ||
+		typeof metadata.providerItemId !== "string" ||
+		metadata.providerItemId.length === 0
+	)
+		return undefined;
+	if (!Array.isArray(metadata.actions) || metadata.actions.length === 0) return undefined;
+	const actions = metadata.actions.map(snapshotComputerAction);
+	if (actions.some(action => action === undefined)) return undefined;
+	const pendingSafetyChecks = snapshotComputerSafetyChecks(metadata.pendingSafetyChecks);
+	if (!pendingSafetyChecks) return undefined;
+	return {
+		type: "computer",
+		providerItemId: metadata.providerItemId,
+		actions: actions as ComputerAction[],
+		pendingSafetyChecks,
+	};
+}
+
+function snapshotToolResultProviderMetadata(value: unknown): {
+	metadata?: ToolResultProviderMetadata;
+	malformed: boolean;
+} {
+	if (value === undefined) return { malformed: false };
+	if (!value || typeof value !== "object" || Array.isArray(value)) return { malformed: true };
+	const metadata = value as Record<string, unknown>;
+	if (
+		metadata.type !== "computer" ||
+		!metadata.screenshot ||
+		typeof metadata.screenshot !== "object" ||
+		Array.isArray(metadata.screenshot)
+	) {
+		return { malformed: true };
+	}
+	const screenshot = metadata.screenshot as Record<string, unknown>;
+	const hasImageUrl = Object.hasOwn(screenshot, "image_url");
+	const hasFileId = Object.hasOwn(screenshot, "file_id");
+	if (screenshot.type !== "computer_screenshot" || hasImageUrl === hasFileId) return { malformed: true };
+	if (hasImageUrl && (typeof screenshot.image_url !== "string" || screenshot.image_url.length === 0))
+		return { malformed: true };
+	if (hasFileId && (typeof screenshot.file_id !== "string" || screenshot.file_id.length === 0))
+		return { malformed: true };
+	const acknowledgedSafetyChecks = snapshotComputerSafetyChecks(metadata.acknowledgedSafetyChecks);
+	if (!acknowledgedSafetyChecks) return { malformed: true };
+	return {
+		malformed: false,
+		metadata: {
+			type: "computer",
+			screenshot: hasImageUrl
+				? { type: "computer_screenshot", image_url: screenshot.image_url as string }
+				: { type: "computer_screenshot", file_id: screenshot.file_id as string },
+			acknowledgedSafetyChecks,
+		},
+	};
+}
+
 function snapshotAssistantContentBlock(block: AssistantContentBlock): AssistantContentBlock {
 	switch (block.type) {
 		case "text":
@@ -189,10 +348,16 @@ function snapshotAssistantContentBlock(block: AssistantContentBlock): AssistantC
 			return { ...block };
 		case "redactedThinking":
 			return { ...block };
+		case "anthropicServerTool":
+			return { ...block, block: structuredCloneJSON(block.block) };
 		case "fallback":
 			return { ...block, from: { ...block.from }, to: { ...block.to } };
 		case "toolCall":
-			return { ...block, arguments: structuredCloneJSON(block.arguments) };
+			return {
+				...block,
+				arguments: structuredCloneJSON(block.arguments),
+				providerMetadata: snapshotToolCallProviderMetadata(block.providerMetadata),
+			};
 	}
 }
 
@@ -268,6 +433,10 @@ function coerceToolResult(raw: unknown): { result: AgentToolResult<unknown>; mal
 	const rawObj = raw && typeof raw === "object" ? (raw as Record<string, unknown>) : null;
 	const rawContent = rawObj?.content;
 	const details = rawObj && "details" in rawObj ? rawObj.details : {};
+	const providerMetadataResult = snapshotToolResultProviderMetadata(
+		rawObj && "providerMetadata" in rawObj ? rawObj.providerMetadata : undefined,
+	);
+	const providerMetadata = providerMetadataResult.metadata;
 	// Tools may flag a non-throwing failure on the result itself (e.g. an
 	// aggregator that catches per-entry errors and synthesizes a combined
 	// result). Preserve the flag so agent-loop can surface it on the wire.
@@ -312,7 +481,13 @@ function coerceToolResult(raw: unknown): { result: AgentToolResult<unknown>; mal
 			text: `Tool returned an invalid result: ${invalidBlocks} content block${invalidBlocks === 1 ? "" : "s"} had an unsupported shape.`,
 		});
 	}
-	const isError = explicitError || invalidBlocks > 0;
+	if (providerMetadataResult.malformed) {
+		content.push({
+			type: "text",
+			text: "Tool returned an invalid result: computer providerMetadata had an unsupported shape.",
+		});
+	}
+	const isError = explicitError || invalidBlocks > 0 || providerMetadataResult.malformed;
 	// Anthropic rejects tool_result blocks with is_error: true and empty content.
 	if (isError && !hasSubstantiveToolResultContent(content)) {
 		content.length = 0;
@@ -322,10 +497,11 @@ function coerceToolResult(raw: unknown): { result: AgentToolResult<unknown>; mal
 		result: {
 			content,
 			details,
+			providerMetadata,
 			...(isError ? { isError: true } : {}),
 			...(useless && !isError ? { useless: true } : {}),
 		},
-		malformed: invalidBlocks > 0,
+		malformed: invalidBlocks > 0 || providerMetadataResult.malformed,
 	};
 }
 
@@ -1799,6 +1975,7 @@ async function executeToolCalls(
 		interruptMode = "immediate",
 		getToolContext,
 		transformToolCallArguments,
+		resolveFallbackTool,
 		intentTracing,
 		beforeToolCall,
 		afterToolCall,
@@ -1841,7 +2018,10 @@ async function executeToolCalls(
 		// determinism if both somehow collide.
 		const tool =
 			tools?.find(t => t.name === toolCall.name) ??
-			tools?.find(t => t.customWireName !== undefined && t.customWireName === toolCall.name);
+			tools?.find(t => t.customWireName !== undefined && t.customWireName === toolCall.name) ??
+			// Not in the advertised set: let the host route side-transport tools
+			// (e.g. xd:// device mounts) called by their top-level name.
+			resolveFallbackTool?.(toolCall.name);
 		const args = toolCall.arguments as Record<string, unknown>;
 		const interruptibleMode = tool?.interruptible;
 		let interruptible = false;
@@ -1947,6 +2127,7 @@ async function executeToolCalls(
 			toolName: toolCall.name,
 			content: result.content,
 			details: result.details,
+			providerMetadata: result.providerMetadata,
 			isError,
 			...(result.useless && !isError ? { useless: true } : {}),
 			timestamp: Date.now(),
@@ -2111,6 +2292,7 @@ async function executeToolCalls(
 							total: toolCalls.length,
 							toolCalls: toolCallInfos,
 							steeringSignal: steeringSoftController.signal,
+							providerMetadata: toolCall.providerMetadata,
 						})
 					: undefined;
 				const rawResult = await tool.execute(
@@ -2163,6 +2345,7 @@ async function executeToolCalls(
 							content: after.content ?? result.content,
 							details: after.details ?? result.details,
 							isError: after.isError ?? result.isError,
+							providerMetadata: after.providerMetadata ?? result.providerMetadata,
 							useless: after.useless ?? result.useless,
 						});
 						result = coerced.result;

package/src/agent.ts

@@ -72,6 +72,9 @@ function refreshToolChoiceForActiveTools(
 	if (!toolChoice || typeof toolChoice === "string") {
 		return toolChoice;
 	}
+	if (toolChoice.type === "computer") {
+		return tools.some(tool => tool.native?.type === "computer") ? toolChoice : undefined;
+	}
 
 	const toolName =
 		toolChoice.type === "tool"
@@ -238,6 +241,13 @@ export interface AgentOptions {
 	 */
 	transformToolCallArguments?: (args: Record<string, unknown>, toolName: string) => Record<string, unknown>;
 
+	/**
+	 * Resolve a tool call whose name matched no advertised tool. Lets hosts
+	 * route calls to tools exposed through side transports (e.g. `xd://`
+	 * device mounts) instead of failing with "Tool not found".
+	 */
+	resolveFallbackTool?: (name: string) => AgentTool<any> | undefined;
+
 	/** Enable intent tracing schema injection/stripping in the harness. */
 	intentTracing?: boolean;
 	/**
@@ -375,6 +385,7 @@ export class Agent {
 	#kimiApiFormat?: "openai" | "anthropic";
 	#preferWebsockets?: boolean;
 	#transformToolCallArguments?: (args: Record<string, unknown>, toolName: string) => Record<string, unknown>;
+	#resolveFallbackTool?: (name: string) => AgentTool<any> | undefined;
 	#intentTracing: boolean;
 	#pruneToolDescriptions: boolean;
 	#dialect?: Dialect;
@@ -455,6 +466,7 @@ export class Agent {
 		this.#kimiApiFormat = opts.kimiApiFormat;
 		this.#preferWebsockets = opts.preferWebsockets;
 		this.#transformToolCallArguments = opts.transformToolCallArguments;
+		this.#resolveFallbackTool = opts.resolveFallbackTool;
 		this.#intentTracing = opts.intentTracing === true;
 		this.#pruneToolDescriptions = opts.pruneToolDescriptions === true;
 		this.#dialect = opts.dialect;
@@ -1190,6 +1202,7 @@ export class Agent {
 			cwd: this.#cwd,
 			getCwd: this.#cwdResolver,
 			transformToolCallArguments: this.#transformToolCallArguments,
+			resolveFallbackTool: this.#resolveFallbackTool,
 			intentTracing: this.#intentTracing,
 			pruneToolDescriptions: this.#pruneToolDescriptions,
 			dialect: this.#dialect,

package/src/compaction/compaction.ts

@@ -427,6 +427,14 @@ function computeMessageTokens(message: AgentMessage, options?: { excludeEncrypte
 					// Encrypted reasoning blob the provider still bills for on replay;
 					// excluded from the compaction floor for the same reason as above.
 					if (!options?.excludeEncryptedReasoning) fragments.push(block.data);
+				} else if (block.type === "anthropicServerTool") {
+					// Native Anthropic server-tool call/result replayed verbatim on the
+					// wire (server_tool_use input, web_search_tool_result
+					// encrypted_content). Opaque provider-replay state the provider still
+					// bills for on same-provider replay; excluded from the compaction
+					// floor like other encrypted reasoning because its local byte size
+					// diverges from provider billing.
+					if (!options?.excludeEncryptedReasoning) fragments.push(stringifyJson(block.block) ?? "null");
 				}
 			}
 			break;

package/src/compaction/openai.ts

@@ -20,6 +20,7 @@ import { applyCodexResponsesLiteShape } from "@oh-my-pi/pi-ai/providers/openai-c
 import {
 	createOpenAICodexCompactionRequestContext,
 	createOpenAICodexCompatibilityMetadata,
+	getCodexAttestationHeader,
 } from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
 import { parseAzureDeploymentNameMap, parseTextSignature } from "@oh-my-pi/pi-ai/providers/openai-shared";
 import { transformMessages } from "@oh-my-pi/pi-ai/providers/transform-messages";
@@ -43,7 +44,7 @@ import {
 	OPENAI_HEADER_VALUES,
 	OPENAI_HEADERS,
 } from "@oh-my-pi/pi-catalog/wire/codex";
-import { $env, logger, stringifyJson } from "@oh-my-pi/pi-utils";
+import { $env, logger, stringifyJson, structuredCloneJSON } from "@oh-my-pi/pi-utils";
 
 export * from "./compaction-v2-streaming";
 
@@ -254,6 +255,7 @@ function addOpenAiCallIds(
 	items: Array<Record<string, unknown>>,
 	knownCallIds: Set<string>,
 	customCallIds: Set<string>,
+	computerCallIds: Set<string>,
 ): void {
 	for (const item of items) {
 		if (typeof item.call_id !== "string") continue;
@@ -262,10 +264,57 @@ function addOpenAiCallIds(
 		} else if (item.type === "custom_tool_call") {
 			knownCallIds.add(item.call_id);
 			customCallIds.add(item.call_id);
+		} else if (item.type === "computer_call") {
+			knownCallIds.add(item.call_id);
+			computerCallIds.add(item.call_id);
 		}
 	}
 }
 
+function computerHistoryNote(item: Record<string, unknown>): Record<string, unknown> {
+	const serialized = stringifyJson(item) ?? "";
+	return {
+		type: "message",
+		id: `msg_${Bun.hash(`computer-history:${serialized}`).toString(36)}`,
+		role: "assistant",
+		content: [
+			{
+				type: "output_text",
+				text: `[Previous computer history unavailable to this model]: ${serialized}`,
+				annotations: [],
+			},
+		],
+		status: "completed",
+	};
+}
+
+function adaptComputerHistoryForCompaction(
+	items: Array<Record<string, unknown>>,
+	supportsComputerUse: boolean,
+): Array<Record<string, unknown>> {
+	if (supportsComputerUse) return items;
+	return items.map(item =>
+		item.type === "computer_call" || item.type === "computer_call_output" ? computerHistoryNote(item) : item,
+	);
+}
+
+function computerFailureNote(call: Record<string, unknown>, output: string): Record<string, unknown> {
+	const serialized = stringifyJson(call) ?? "";
+	return {
+		type: "message",
+		id: `msg_${Bun.hash(`computer-failure:${serialized}:${output}`).toString(36)}`,
+		role: "assistant",
+		content: [
+			{
+				type: "output_text",
+				text: `[Computer call failed before a screenshot was recorded]: ${serialized}${output ? `\n${output}` : ""}`,
+				annotations: [],
+			},
+		],
+		status: "completed",
+	};
+}
+
 // ============================================================================
 // Native history construction (responses-API shape)
 // ============================================================================
@@ -287,20 +336,32 @@ export function buildOpenAiNativeHistory(
 	model: Model,
 	previousReplacementHistory?: Array<Record<string, unknown>>,
 ): Array<Record<string, unknown>> {
-	const input: Array<Record<string, unknown>> = previousReplacementHistory ? [...previousReplacementHistory] : [];
+	const input: Array<Record<string, unknown>> = previousReplacementHistory
+		? adaptComputerHistoryForCompaction([...previousReplacementHistory], model.supportsComputerUse === true)
+		: [];
 	const transformedMessages = transformMessages(messages, model, id => normalizeOpenAiCompactionToolCallId(id));
 
 	let msgIndex = 0;
 	const knownCallIds = new Set<string>();
 	const customCallIds = new Set<string>();
-	addOpenAiCallIds(input, knownCallIds, customCallIds);
+	const computerCallIds = new Set<string>();
+	const demotedComputerCallIds = new Set<string>();
+	addOpenAiCallIds(input, knownCallIds, customCallIds, computerCallIds);
 	for (const message of transformedMessages) {
 		if (message.role === "user" || message.role === "developer") {
 			const providerPayload = (message as { providerPayload?: AssistantMessage["providerPayload"] }).providerPayload;
-			const historyItems = getOpenAIResponsesHistoryItems(providerPayload, model.provider);
-			if (historyItems) {
+			const rawHistoryItems = getOpenAIResponsesHistoryItems(providerPayload, model.provider);
+			if (rawHistoryItems) {
+				if (model.supportsComputerUse !== true) {
+					for (const item of rawHistoryItems) {
+						if (item.type === "computer_call" && typeof item.call_id === "string") {
+							demotedComputerCallIds.add(item.call_id);
+						}
+					}
+				}
+				const historyItems = adaptComputerHistoryForCompaction(rawHistoryItems, model.supportsComputerUse === true);
 				input.push(...historyItems);
-				addOpenAiCallIds(historyItems, knownCallIds, customCallIds);
+				addOpenAiCallIds(historyItems, knownCallIds, customCallIds, computerCallIds);
 				msgIndex++;
 				continue;
 			}
@@ -341,14 +402,27 @@ export function buildOpenAiNativeHistory(
 				assistant.provider,
 			);
 			if (providerPayload) {
+				if (!providerPayload.dt) demotedComputerCallIds.clear();
+				if (model.supportsComputerUse !== true) {
+					for (const item of providerPayload.items) {
+						if (item.type === "computer_call" && typeof item.call_id === "string") {
+							demotedComputerCallIds.add(item.call_id);
+						}
+					}
+				}
+				const historyItems = adaptComputerHistoryForCompaction(
+					providerPayload.items,
+					model.supportsComputerUse === true,
+				);
 				if (providerPayload.dt) {
-					input.push(...providerPayload.items);
-					addOpenAiCallIds(providerPayload.items, knownCallIds, customCallIds);
+					input.push(...historyItems);
+					addOpenAiCallIds(historyItems, knownCallIds, customCallIds, computerCallIds);
 				} else {
-					input.splice(0, input.length, ...providerPayload.items);
+					input.splice(0, input.length, ...historyItems);
 					knownCallIds.clear();
 					customCallIds.clear();
-					addOpenAiCallIds(input, knownCallIds, customCallIds);
+					computerCallIds.clear();
+					addOpenAiCallIds(input, knownCallIds, customCallIds, computerCallIds);
 				}
 				msgIndex++;
 				continue;
@@ -394,6 +468,25 @@ export function buildOpenAiNativeHistory(
 
 				if (block.type === "toolCall") {
 					const normalized = normalizeResponsesToolCallId(block.id, block.customWireName ? "ctc" : "fc");
+					if (block.providerMetadata?.type === "computer") {
+						const computerCall = {
+							type: "computer_call",
+							id: block.providerMetadata.providerItemId,
+							call_id: normalized.callId,
+							actions: structuredCloneJSON(block.providerMetadata.actions),
+							pending_safety_checks: structuredCloneJSON(block.providerMetadata.pendingSafetyChecks),
+							status: "completed",
+						};
+						if (model.supportsComputerUse !== true) {
+							input.push(computerHistoryNote(computerCall));
+							demotedComputerCallIds.add(normalized.callId);
+							continue;
+						}
+						knownCallIds.add(normalized.callId);
+						computerCallIds.add(normalized.callId);
+						input.push(computerCall);
+						continue;
+					}
 					let itemId: string | undefined = normalized.itemId;
 					if (
 						isDifferentModel &&
@@ -430,17 +523,58 @@ export function buildOpenAiNativeHistory(
 
 		if (message.role === "toolResult") {
 			const normalized = normalizeResponsesToolCallId(message.toolCallId);
-			if (!knownCallIds.has(normalized.callId)) {
-				msgIndex++;
-				continue;
-			}
-
 			const textOutput = message.content
 				.filter(block => block.type === "text")
 				.map(block => block.text)
 				.join("\n");
 			const hasImages = message.content.some(block => block.type === "image");
 			const outputText = textOutput.length > 0 ? textOutput : hasImages ? "(see attached image)" : "";
+			if (demotedComputerCallIds.has(normalized.callId)) {
+				const resultItem =
+					message.providerMetadata?.type === "computer"
+						? {
+								type: "computer_call_output",
+								call_id: normalized.callId,
+								output: structuredCloneJSON(message.providerMetadata.screenshot),
+								acknowledged_safety_checks: structuredCloneJSON(
+									message.providerMetadata.acknowledgedSafetyChecks,
+								),
+							}
+						: { type: "computer_call_output", call_id: normalized.callId, error: outputText };
+				input.push(computerHistoryNote(resultItem));
+				demotedComputerCallIds.delete(normalized.callId);
+				msgIndex++;
+				continue;
+			}
+			if (!knownCallIds.has(normalized.callId)) {
+				msgIndex++;
+				continue;
+			}
+			if (computerCallIds.has(normalized.callId)) {
+				if (message.providerMetadata?.type === "computer") {
+					input.push({
+						type: "computer_call_output",
+						call_id: normalized.callId,
+						output: structuredCloneJSON(message.providerMetadata.screenshot),
+						acknowledged_safety_checks: structuredCloneJSON(message.providerMetadata.acknowledgedSafetyChecks),
+					});
+					msgIndex++;
+					continue;
+				}
+
+				const callIndex = input.findLastIndex(
+					item => item.type === "computer_call" && item.call_id === normalized.callId,
+				);
+				if (callIndex >= 0) {
+					const [call] = input.splice(callIndex, 1);
+					if (call) input.splice(callIndex, 0, computerFailureNote(call, outputText));
+				}
+				knownCallIds.delete(normalized.callId);
+				computerCallIds.delete(normalized.callId);
+				msgIndex++;
+				continue;
+			}
+
 			input.push({
 				type: customCallIds.has(normalized.callId) ? "custom_tool_call_output" : "function_call_output",
 				call_id: normalized.callId,
@@ -517,6 +651,10 @@ export async function requestOpenAiRemoteCompaction(
 		if (accountId) {
 			headers[OPENAI_HEADERS.ACCOUNT_ID] = accountId;
 		}
+		const attestation = await getCodexAttestationHeader(accountId);
+		if (attestation) {
+			headers[OPENAI_HEADERS.ATTESTATION] = attestation;
+		}
 		headers[OPENAI_HEADERS.BETA] = OPENAI_HEADER_VALUES.BETA_RESPONSES;
 		headers[OPENAI_HEADERS.ORIGINATOR] = OPENAI_HEADER_VALUES.ORIGINATOR_CODEX;
 		Object.assign(

package/src/types.ts

@@ -14,8 +14,10 @@ import type {
 	streamSimple,
 	TextContent,
 	Tool,
+	ToolCallProviderMetadata,
 	ToolChoice,
 	ToolResultMessage,
+	ToolResultProviderMetadata,
 	TSchema,
 } from "@oh-my-pi/pi-ai";
 import type { Dialect } from "@oh-my-pi/pi-ai/dialect";
@@ -274,6 +276,13 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 	 * Use for deobfuscating secrets or rewriting arguments.
 	 */
 	transformToolCallArguments?: (args: Record<string, unknown>, toolName: string) => Record<string, unknown>;
+	/**
+	 * Resolve a tool call whose name matched no advertised tool (including
+	 * `customWireName` aliases). Lets hosts route calls to tools they expose
+	 * through side transports (e.g. `xd://` device mounts) instead of failing
+	 * with "Tool not found". Returning `undefined` keeps the failure.
+	 */
+	resolveFallbackTool?: (name: string) => AgentTool<any> | undefined;
 
 	/**
 	 * Enable intent tracing for tool calls.
@@ -458,6 +467,8 @@ export interface ToolCallContext {
 	index: number;
 	total: number;
 	toolCalls: Array<{ id: string; name: string }>;
+	/** Provider-native metadata for the current call, when present. */
+	providerMetadata?: ToolCallProviderMetadata;
 	/**
 	 * Cooperative steering signal: aborted when a queued user/steering message
 	 * (or an interrupting peer IRC) is detected while this tool batch runs.
@@ -497,6 +508,8 @@ export interface AfterToolCallResult {
 	content?: (TextContent | ImageContent)[];
 	/** If provided, replaces the tool result details payload in full. */
 	details?: unknown;
+	/** If provided, replaces the provider-native result metadata in full. */
+	providerMetadata?: ToolResultProviderMetadata;
 	/** If provided, replaces the error flag carried with the tool result. */
 	isError?: boolean;
 	/** If provided, replaces the contextually-useless flag carried with the tool result. */
@@ -583,6 +596,8 @@ export interface AgentToolResult<T = any, _TInput = unknown> {
 	// Marks a non-throwing failure (e.g. an aggregator catching per-entry errors).
 	// agent-loop honors this and surfaces it as a tool error on the wire.
 	isError?: boolean;
+	/** Provider-native metadata that must survive into history replay unchanged. */
+	providerMetadata?: ToolResultProviderMetadata;
 	/** Marks the result as contextually useless: safe for compaction to elide once consumed (e.g. zero matches, wait timeout). Ignored when isError is set. */
 	useless?: boolean;
 }