@linxiraos/pi-agent-core 1.1.8 → 1.1.10

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [1.1.10] - 2026-09-07
+
+- OMP v18.1.11 sync baseline (`e3106be68f`); no package-specific user-visible changes.
+
+## [1.1.9] - 2026-09-05
+
+- v18.1.10 sync baseline (compaction and tool-arg stream updates).
+
 ## [1.1.8] - 2026-09-04
 
 - OMP sync v18.1.2–v18.1.5: Agent Hub activity stream groundwork, declarative provider auth registry, and tool-roster notice plumbing shared with the session layer.
@@ -20,12 +28,6 @@
 
 - 同步上游 OMP v18.0.5 / v18.0.6（内部运行时与构建改进）。
 
-## [1.1.1] - 2026-08-25
-
-### Fixed
-
-- Published tarballs now carry real dependency versions instead of Bun's `catalog:` protocol (1.1.0 installs failed with "Unsupported URL Type catalog:").
-
 ## [1.1.0] - 2026-08-25
 
 ### Changed

package/dist/types/compaction/compaction-v2-streaming.d.ts

@@ -7,6 +7,7 @@
  * compaction item as replacement history.
  */
 import type { CodexCompactionContext, FetchImpl, Model, ProviderSessionState } from "@linxiraos/pi-ai";
+import { type OpenAICodexCompactionBody } from "@linxiraos/pi-ai/providers/openai-codex-responses";
 /** Retained-message budget Codex uses after streamed V2 compaction. */
 export declare const V2_RETAINED_MESSAGE_TOKEN_BUDGET = 64000;
 /** Max retries for V2 streaming compaction on transient stream errors. */
@@ -21,18 +22,11 @@ export interface CompactionV2Usage {
     cachedInputTokens?: number;
     reasoningOutputTokens?: number;
 }
-/** Request body fields needed for Responses-stream V2 compaction. */
+/** Provider-ready Responses body and local state needed for V2 compaction. */
 export interface CompactionV2Request {
-    model: string;
+    body: OpenAICodexCompactionBody;
     input: unknown[];
-    instructions: string;
     retainedMessageBudget: number;
-    tools?: unknown[];
-    /** Responses reasoning param (effort + summary), matching a normal turn; omitted for non-reasoning models. */
-    reasoning?: {
-        effort: string;
-        summary: string;
-    };
     sessionId?: string;
     promptCacheKey?: string;
 }
@@ -61,6 +55,12 @@ export declare function buildCompactionV2Request(model: Model, input: unknown[],
     promptCacheKey?: string;
     retainedMessageBudget?: number;
 }): CompactionV2Request;
+/** Wrap a body built by the normal Codex serializer for V2 compaction transport. */
+export declare function buildCompactionV2RequestFromBody(model: Model, body: OpenAICodexCompactionBody, options?: {
+    sessionId?: string;
+    promptCacheKey?: string;
+    retainedMessageBudget?: number;
+}): CompactionV2Request;
 /** Request V2 compaction over the normal OpenAI Responses streaming endpoint. */
 export declare function requestCompactionV2Streaming(model: Model, apiKey: string, request: CompactionV2Request, signal?: AbortSignal, options?: {
     fetch?: FetchImpl;

package/dist/types/compaction/compaction.d.ts

@@ -160,7 +160,8 @@ export interface SummaryOptions {
     promptOverride?: string;
     extraContext?: string[];
     remoteEndpoint?: string;
-    remoteInstructions?: string;
+    /** Stable system-prompt segments from the live turn, preserved for provider cache reuse. */
+    remoteSystemPrompt?: string[];
     initiatorOverride?: MessageAttribution;
     metadata?: Record<string, unknown>;
     convertToLlm?: ConvertToLlm;

package/dist/types/telemetry.d.ts

@@ -456,7 +456,7 @@ export declare function recordManualChatTelemetry(telemetry: AgentTelemetry | un
 /**
  * Options accepted by {@link instrumentedCompleteSimple}. Mirrors the
  * `streamAssistantResponse` chat-span lifecycle for oneshot LLM calls
- * (compaction summaries, handoff document, branch summary, inspect_image).
+ * (compaction summaries, handoff document, branch summary, image_question).
  */
 export interface InstrumentedChatSpanOptions {
     readonly telemetry: AgentTelemetry | undefined;
@@ -467,7 +467,7 @@ export interface InstrumentedChatSpanOptions {
     /**
      * Tag stamped onto `pi.gen_ai.oneshot.kind`. Values used by the agent:
      * `compaction_summary`, `compaction_short_summary`, `compaction_turn_prefix`,
-     * `handoff`, `branch_summary`, `inspect_image`. Free-form to allow callers
+     * `handoff`, `branch_summary`, `image_question`. Free-form to allow callers
      * outside this package to add new kinds without bumping the helper.
      */
     readonly oneshotKind?: string;

package/dist/types/types.d.ts

@@ -195,8 +195,10 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
     /**
      * Peeks whether steering messages are queued, without consuming them.
      *
-     * Called after each tool execution (unless interruptMode is "wait") to decide
-     * whether to skip the remaining tool calls in the batch. The queue keeps
+     * Polled while a tool batch runs (unless interruptMode is "wait") to decide
+     * whether to abort in-flight and skip not-yet-started *interruptible* waits;
+     * every other already-emitted call still executes and the message injects
+     * at the batch boundary. The queue keeps
      * owning its messages until the loop reaches the next injection boundary and
      * dequeues via {@link getSteeringMessages} — so callers can still cancel or
      * restore queued messages while in-flight tools settle, and an external
@@ -653,8 +655,29 @@ export type ToolApproval = ToolApprovalDecision | ((args: unknown) => ToolApprov
 export interface AgentToolContext {
 }
 export type AgentToolExecFn<TParameters extends TSchema = TSchema, TDetails = any, TTheme = unknown> = (this: AgentTool<TParameters, TDetails, TTheme>, toolCallId: string, params: Static<TParameters>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails, TParameters>, context?: AgentToolContext) => Promise<AgentToolResult<TDetails, TParameters>>;
+/** Live receiver for a tool call's streamed arguments (see AgentTool.openArgStream). */
+export interface AgentToolArgStream {
+    /** Raw wire fragment of the arguments (JSON text, or verbatim payload for custom-format tools). */
+    push(delta: string): void;
+    /** Arguments are complete; `args` is the final parsed object the loop will pass to `execute`. */
+    end(args: unknown): void;
+    /** The call will never execute (stream error, abort, blocked). Release resources. */
+    cancel(): void;
+}
+export interface AgentToolArgStreamInit {
+    toolCallId: string;
+    toolName: string;
+    /** Wire-level name for custom-format tools; undefined for JSON function tools. */
+    customWireName?: string;
+    /** Push a serializable projection of the in-flight call (e.g. diff previews); surfaces as `tool_stream_update`. */
+    emit(update: unknown): void;
+}
 export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any, TTheme = unknown> extends Tool<TParameters> {
     label: string;
+    /**
+     * Called at `toolcall_start`, before any argument delta. Return `undefined` to opt out.
+     */
+    openArgStream?: (init: AgentToolArgStreamInit) => AgentToolArgStream | undefined;
     /** If true, tool is excluded unless explicitly listed in --tools or agent's tools field */
     hidden?: boolean;
     /** If true, tool can stage a pending action that requires explicit resolution via the resolve tool. */
@@ -673,14 +696,15 @@ export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any
     /** If true, argument validation errors are non-fatal: raw args are passed to execute() instead of returning an error to the LLM. */
     lenientArgValidation?: boolean;
     /**
-     * Whether the agent loop may abort this tool mid-execution to deliver a
-     * queued steering message. A function resolves this per call from the raw,
-     * pre-validation arguments.
+     * Whether the agent loop may abort this tool mid-execution — or skip it
+     * before it starts — to deliver a queued steering message. A function
+     * resolves this per call from the raw, pre-validation arguments.
      *
      * Enable only for calls that purely *wait* and observe their abort signal
      * cleanly (e.g. `job` poll), so the abort surfaces the tool's current
-     * snapshot rather than corrupting a side effect. Honored only when
-     * `interruptMode` is "immediate".
+     * snapshot rather than corrupting a side effect. Every other call runs to
+     * completion even when steering is queued; the message lands at the next
+     * batch boundary. Honored only when `interruptMode` is "immediate".
      */
     interruptible?: boolean | ((args: Partial<Static<TParameters>>) => boolean);
     /**
@@ -777,6 +801,11 @@ export type AgentEvent = {
     toolName: string;
     args: any;
     partialResult: any;
+} | {
+    type: "tool_stream_update";
+    toolCallId: string;
+    toolName: string;
+    update: unknown;
 } | {
     type: "tool_execution_end";
     toolCallId: string;

package/package.json

@@ -1,22 +1,55 @@
 {
-	"type": "module",
-	"name": "@linxiraos/pi-agent-core",
-	"version": "1.1.8",
-	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
-	"homepage": "https://linxira-os.github.io/zeta/",
-	"author": "Can Boluk",
-	"contributors": [
-		"Mario Zechner"
+	"exports": {
+		"./*": {
+			"import": "./src/*.ts",
+			"types": "./dist/types/*.d.ts"
+		},
+		"./compaction/*": {
+			"import": "./src/compaction/*.ts",
+			"types": "./dist/types/compaction/*.d.ts"
+		},
+		"./compaction": {
+			"import": "./src/compaction.ts",
+			"types": "./dist/types/compaction.d.ts"
+		},
+		".": {
+			"import": "./src/index.ts",
+			"types": "./dist/types/index.d.ts"
+		}
+	},
+	"files": [
+		"src",
+		"README.md",
+		"CHANGELOG.md",
+		"LICENSE",
+		"THIRD-PARTY-NOTICES.txt",
+		"dist/types"
 	],
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/Linxira-OS/linxira-zeta.git",
-		"directory": "packages/agent"
+	"engines": {
+		"bun": ">=1.3.14"
 	},
-	"bugs": {
-		"url": "https://github.com/Linxira-OS/linxira-zeta/issues"
+	"devDependencies": {
+		"@linxiraos/pi-omptype": "1.1.10",
+		"@types/bun": "^1.3.14",
+		"@opentelemetry/sdk-trace-base": "^2.9.0",
+		"@opentelemetry/context-async-hooks": "^2.9.0"
+	},
+	"dependencies": {
+		"@linxiraos/pi-snapcompact": "1.1.10",
+		"@linxiraos/pi-wire": "1.1.10",
+		"@linxiraos/pi-utils": "1.1.10",
+		"@linxiraos/pi-natives": "1.1.10",
+		"@linxiraos/pi-catalog": "1.1.10",
+		"@linxiraos/pi-ai": "1.1.10",
+		"@opentelemetry/api": "^1.9.1"
+	},
+	"scripts": {
+		"test": "bun test --parallel",
+		"check:types": "tsgo -p tsconfig.json --noEmit",
+		"check": "tsgo -p tsconfig.json --noEmit"
 	},
+	"types": "./dist/types/index.d.ts",
+	"main": "./src/index.ts",
 	"keywords": [
 		"ai",
 		"agent",
@@ -24,58 +57,22 @@
 		"transport",
 		"state-management"
 	],
-	"main": "./src/index.ts",
-	"types": "./dist/types/index.d.ts",
-	"scripts": {
-		"check": "biome check . && bun run check:types",
-		"check:types": "tsgo -p tsconfig.json --noEmit",
-		"lint": "biome lint .",
-		"test": "bun test --parallel",
-		"fix": "biome check --write --unsafe .",
-		"fmt": "biome format --write ."
-	},
-	"dependencies": {
-		"@linxiraos/pi-ai": "1.1.8",
-		"@linxiraos/pi-catalog": "1.1.8",
-		"@linxiraos/pi-natives": "1.1.8",
-		"@linxiraos/pi-utils": "1.1.8",
-		"@linxiraos/pi-wire": "1.1.8",
-		"@linxiraos/pi-snapcompact": "1.1.8",
-		"@opentelemetry/api": "^1.9.1"
-	},
-	"devDependencies": {
-		"@linxiraos/pi-omptype": "1.1.8",
-		"@opentelemetry/context-async-hooks": "^2.9.0",
-		"@opentelemetry/sdk-trace-base": "^2.9.0",
-		"@types/bun": "^1.3.14"
+	"bugs": {
+		"url": "https://github.com/Linxira-OS/linxira-zeta/issues"
 	},
-	"engines": {
-		"bun": ">=1.3.14"
+	"repository": {
+		"directory": "packages/agent",
+		"url": "git+https://github.com/Linxira-OS/linxira-zeta.git",
+		"type": "git"
 	},
-	"files": [
-		"src",
-		"README.md",
-		"CHANGELOG.md",
-		"LICENSE",
-		"THIRD-PARTY-NOTICES.txt",
-		"dist/types"
+	"license": "MIT",
+	"contributors": [
+		"Mario Zechner"
 	],
-	"exports": {
-		".": {
-			"types": "./dist/types/index.d.ts",
-			"import": "./src/index.ts"
-		},
-		"./compaction": {
-			"types": "./dist/types/compaction.d.ts",
-			"import": "./src/compaction.ts"
-		},
-		"./compaction/*": {
-			"types": "./dist/types/compaction/*.d.ts",
-			"import": "./src/compaction/*.ts"
-		},
-		"./*": {
-			"types": "./dist/types/*.d.ts",
-			"import": "./src/*.ts"
-		}
-	}
+	"author": "Can Boluk",
+	"homepage": "https://linxira-os.github.io/zeta/",
+	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
+	"version": "1.1.10",
+	"name": "@linxiraos/pi-agent-core",
+	"type": "module"
 }

package/src/agent-loop.ts

@@ -73,6 +73,7 @@ import type {
 	AgentMessage,
 	AgentPreModelCallResult,
 	AgentTool,
+	AgentToolArgStream,
 	AgentToolCall,
 	AgentToolResult,
 	AgentTurnEndContext,
@@ -924,7 +925,10 @@ function extractIntent(args: Record<string, unknown>): { intent?: string; stripp
 	if (typeof intent !== "string") {
 		return { strippedArgs };
 	}
-	const trimmed = intent.trim();
+	const trimmed = intent
+		.trim()
+		.replace(/\s*\.+$/, "")
+		.trim();
 	return { intent: trimmed.length > 0 ? trimmed : undefined, strippedArgs };
 }
 
@@ -1775,6 +1779,17 @@ async function streamAssistantResponse(
 			let partialMessage: AssistantMessage | null = null;
 			let addedPartial = false;
 			const completedToolCallIds = new Set<string>();
+			const argStreams = new Map<number, { id: string; stream: AgentToolArgStream }>();
+			const cancelArgStreams = (): void => {
+				for (const { id, stream: argStream } of argStreams.values()) {
+					try {
+						argStream.cancel();
+					} catch (error) {
+						logger.debug("Tool argument stream cancel failed", { toolCallId: id, error });
+					}
+				}
+				argStreams.clear();
+			};
 
 			const responseIterator = response[Symbol.asyncIterator]();
 			const finishAbortedStream = async (): Promise<AssistantMessage> => {
@@ -1888,6 +1903,52 @@ async function streamAssistantResponse(
 					// when the LLM is streaming chunks faster than the loop can rest.
 					await yieldIfDue();
 
+					if (event.type === "toolcall_start") {
+						const block = event.partial.content[event.contentIndex];
+						if (block?.type === "toolCall") {
+							const tool = resolveToolForCall(context.tools, block, config.resolveFallbackTool);
+							if (tool?.openArgStream) {
+								try {
+									const argStream = tool.openArgStream({
+										toolCallId: block.id,
+										toolName: block.name,
+										customWireName: block.customWireName,
+										emit: update =>
+											stream.push({
+												type: "tool_stream_update",
+												toolCallId: block.id,
+												toolName: block.name,
+												update,
+											}),
+									});
+									if (argStream) argStreams.set(event.contentIndex, { id: block.id, stream: argStream });
+								} catch (error) {
+									logger.debug("Tool argument stream open failed", { toolCallId: block.id, error });
+								}
+							}
+						}
+					} else if (event.type === "toolcall_delta") {
+						const entry = argStreams.get(event.contentIndex);
+						if (entry) {
+							try {
+								entry.stream.push(event.delta);
+							} catch (error) {
+								logger.debug("Tool argument stream push failed", { toolCallId: entry.id, error });
+							}
+						}
+					} else if (event.type === "toolcall_end") {
+						const entry = argStreams.get(event.contentIndex);
+						if (entry) {
+							try {
+								entry.stream.end(event.toolCall.arguments);
+							} catch (error) {
+								logger.debug("Tool argument stream end failed", { toolCallId: entry.id, error });
+							} finally {
+								argStreams.delete(event.contentIndex);
+							}
+						}
+					}
+
 					switch (event.type) {
 						case "start":
 							partialMessage = event.partial;
@@ -1944,6 +2005,7 @@ async function streamAssistantResponse(
 				}
 			} finally {
 				detachAbortListener?.();
+				cancelArgStreams();
 			}
 
 			let trailing = await response.result();
@@ -2440,8 +2502,9 @@ async function executeToolCalls(
 			// Queued steering hard-aborts only interruptible waits and raises the
 			// cooperative soft signal for everything else: the boundary dequeue
 			// below injects the message as soon as running tools finish (or
-			// background themselves), and not-yet-started tools are skipped.
-			// Idempotent — a second steer poll after the abort is a no-op.
+			// background themselves), and not-yet-started interruptible waits
+			// are skipped. Idempotent — a second steer poll after the abort is
+			// a no-op.
 			if (!steeringAbortController.signal.aborted) {
 				interruptState.triggered = true;
 				interruptState.source = steeringSource ?? "unknown";
@@ -2495,16 +2558,18 @@ async function executeToolCalls(
 	};
 
 	const runTool = async (record: (typeof records)[number], index: number): Promise<void> => {
-		// A pending interrupt preempts not-yet-started tools so the message
-		// injects promptly. A peer-IRC interrupt is the exception: it aborts
-		// interruptible waits only and leaves non-interruptible foreground work
-		// untouched (see the emit branch below and the `does not abort a
-		// non-interruptible foreground tool` case). That guarantee must hold for
-		// work still queued behind the aborted wait too — otherwise a batched
-		// `todo`/`write` gets dropped as "Skipped due to pending peer interrupt"
-		// purely for being ordered after the wait (#7493). User/system steering
-		// still preempts everything queued.
-		if (interruptState.triggered && (record.interruptible || interruptState.source !== "irc")) {
+		// A pending interrupt preempts not-yet-started *interruptible* waits so
+		// the message injects promptly instead of sitting out a `hub wait`.
+		// Non-interruptible work is never skipped, whatever the source: the
+		// expensive part — generating the call — is already paid, the tool
+		// itself is cheap, and a skip only makes the model re-emit the same
+		// call after the steer lands (#10439). The same guarantee is what keeps
+		// a batched `todo`/`write` queued behind an aborted wait alive (#7493)
+		// and lets a subagent's already-emitted terminal `yield` commit when
+		// the parent steers mid-stream (#10645). The steer still injects at the
+		// batch boundary; the cooperative soft signal lets long-running tools
+		// step aside on their own.
+		if (interruptState.triggered && record.interruptible) {
 			// Skip both span emission and the collector orphan record here. The
 			// tail sweep below (after `Promise.allSettled`) is the single path
 			// that handles "no result message was produced" — it calls
@@ -2719,8 +2784,8 @@ async function executeToolCalls(
 
 	// While tool calls are in flight, queued steering or interrupting IRC would
 	// otherwise wait out the tools' own window. Poll only non-consuming queues:
-	// detection hard-aborts interruptible waits, soft-signals cooperative tools
-	// (auto-background bash), and skips not-yet-started tools, so the boundary
+	// detection hard-aborts interruptible waits (running or not yet started)
+	// and soft-signals cooperative tools (auto-background bash), so the boundary
 	// dequeue below injects the message promptly. Gated on immediate-interrupt
 	// mode; checkSteering is idempotent (no-op once triggered).
 	const watchSteeringWhileRunning =

package/src/compaction/compaction-v2-streaming.ts

@@ -27,6 +27,7 @@ import { captureOpenAIHttpError } from "@linxiraos/pi-ai/utils/openai-http";
 import {
 	applyCodexResidencyHeader,
 	CODEX_BASE_URL,
+	codexRoutingHint,
 	getCodexAccountId,
 	OPENAI_HEADER_VALUES,
 	OPENAI_HEADERS,
@@ -70,15 +71,11 @@ export interface CompactionV2Usage {
 	reasoningOutputTokens?: number;
 }
 
-/** Request body fields needed for Responses-stream V2 compaction. */
+/** Provider-ready Responses body and local state needed for V2 compaction. */
 export interface CompactionV2Request {
-	model: string;
+	body: OpenAICodexCompactionBody;
 	input: unknown[];
-	instructions: string;
 	retainedMessageBudget: number;
-	tools?: unknown[];
-	/** Responses reasoning param (effort + summary), matching a normal turn; omitted for non-reasoning models. */
-	reasoning?: { effort: string; summary: string };
 	sessionId?: string;
 	promptCacheKey?: string;
 }
@@ -204,13 +201,44 @@ export function buildCompactionV2Request(
 		retainedMessageBudget?: number;
 	},
 ): CompactionV2Request {
-	return {
+	const cacheOptions = { sessionId: options?.sessionId, promptCacheKey: options?.promptCacheKey };
+	const promptCacheKey = getOpenAIPromptCacheKey(cacheOptions);
+	const body: OpenAICodexCompactionBody = {
 		model: resolveCompactionV2Model(model),
 		input,
 		instructions,
+		stream: true,
+		store: false,
+		...(options?.reasoning || model.useResponsesLite
+			? {
+					reasoning: model.useResponsesLite ? { ...options?.reasoning, context: "all_turns" } : options?.reasoning,
+					include: ["reasoning.encrypted_content"],
+				}
+			: {}),
+		...(promptCacheKey ? { prompt_cache_key: promptCacheKey } : {}),
+		...(options?.tools && options.tools.length > 0 ? { tools: options.tools, tool_choice: "auto" } : {}),
+	};
+	if (model.useResponsesLite) {
+		applyCodexResponsesLiteShape(body);
+	}
+	return buildCompactionV2RequestFromBody(model, body, options);
+}
+
+/** Wrap a body built by the normal Codex serializer for V2 compaction transport. */
+export function buildCompactionV2RequestFromBody(
+	model: Model,
+	body: OpenAICodexCompactionBody,
+	options?: {
+		sessionId?: string;
+		promptCacheKey?: string;
+		retainedMessageBudget?: number;
+	},
+): CompactionV2Request {
+	const input = Array.isArray(body.input) ? body.input : [];
+	return {
+		body: { ...body, model: resolveCompactionV2Model(model), input },
+		input,
 		retainedMessageBudget: resolveCompactionV2RetainedMessageBudget(options?.retainedMessageBudget),
-		reasoning: options?.reasoning,
-		tools: options?.tools,
 		sessionId: options?.sessionId,
 		promptCacheKey: options?.promptCacheKey,
 	};
@@ -311,35 +339,17 @@ async function attemptCompactionV2Streaming(
 	},
 ): Promise<CompactionV2Response> {
 	// Faithful to Codex: append the compaction trigger as the final input item
-	// of an otherwise-normal Responses request, then stream the result. `store`
-	// stays false — compaction must never persist a server-side response object.
-	const cacheOptions = { sessionId: request.sessionId, promptCacheKey: request.promptCacheKey };
-	const promptCacheKey = getOpenAIPromptCacheKey(cacheOptions);
+	// of an otherwise-normal Responses request. `store` remains false —
+	// compaction must never persist a server-side response object.
 	const body: OpenAICodexCompactionBody = {
-		model: request.model,
+		...request.body,
 		input: [...request.input, COMPACTION_TRIGGER_ITEM],
-		instructions: request.instructions,
-		stream: true,
 		store: false,
-		...(request.reasoning || model.useResponsesLite
-			? {
-					// Lite implies gpt-5.4+, where codex-rs sends `all_turns` replay.
-					reasoning: model.useResponsesLite ? { ...request.reasoning, context: "all_turns" } : request.reasoning,
-					include: ["reasoning.encrypted_content"],
-				}
-			: {}),
-		...(promptCacheKey ? { prompt_cache_key: promptCacheKey } : {}),
-		...(request.tools && request.tools.length > 0 ? { tools: request.tools, tool_choice: "auto" } : {}),
+		stream: true,
 	};
 	if (options.codexMetadata) {
 		body.client_metadata = options.codexMetadata.clientMetadata;
 	}
-	// Responses Lite models take the same rewrite on the compaction stream:
-	// instructions/tools ride as input items (codex-rs `compact_remote_v2`
-	// builds through `build_responses_request`).
-	if (model.useResponsesLite) {
-		applyCodexResponsesLiteShape(body);
-	}
 
 	if (shouldUseCodexProviderTransport(model)) {
 		const eventStream = await openCodexCompactionEventStream(model, body, {
@@ -407,7 +417,7 @@ function buildCompactionV2Headers(
 					"content-type": "application/json",
 					...resolveOpenAIRequestSetup(
 						{ provider: model.provider, id: model.id, baseUrl: model.baseUrl, headers: model.headers },
-						{ apiKey, messages: [], openAISessionId: routingSessionId, promptCacheSessionId },
+						{ apiKey, messages: [], sessionId: request.sessionId ?? routingSessionId, promptCacheSessionId },
 					).headers,
 				};
 	if (api === "openai-codex-responses" || model.provider === "openai-codex") {
@@ -424,6 +434,7 @@ function buildCompactionV2Headers(
 		headers[OPENAI_HEADERS.BETA] = OPENAI_HEADER_VALUES.BETA_RESPONSES;
 		headers[OPENAI_HEADERS.ORIGINATOR] = OPENAI_HEADER_VALUES.ORIGINATOR_CODEX;
 		headers[OPENAI_HEADERS.CODEX_BETA_FEATURES] = OPENAI_HEADER_VALUES.REMOTE_COMPACTION_V2;
+		headers[OPENAI_HEADERS.ROUTING_HINT] = codexRoutingHint(request.body.model, undefined);
 		if (model.useResponsesLite) {
 			headers[OPENAI_HEADERS.RESPONSES_LITE] = "true";
 		}

package/src/compaction/compaction.ts

@@ -25,7 +25,12 @@ import {
 } from "@linxiraos/pi-ai";
 import type { Dialect } from "@linxiraos/pi-ai/dialect";
 import * as AIError from "@linxiraos/pi-ai/error";
-import { createOpenAICodexCompactionRequestContext } from "@linxiraos/pi-ai/providers/openai-codex-responses";
+import type { InputItem as CodexInputItem } from "@linxiraos/pi-ai/providers/openai-codex/request-transformer";
+import {
+	buildTransformedCodexRequestBody,
+	createOpenAICodexCompactionRequestContext,
+	type OpenAICodexCompactionBody,
+} from "@linxiraos/pi-ai/providers/openai-codex-responses";
 import { convertTools } from "@linxiraos/pi-ai/providers/openai-responses";
 import { buildResponsesInput, resolveOpenAICompatPolicy } from "@linxiraos/pi-ai/providers/openai-shared";
 import { stripOpenAIResponsesOutputOnlyStatusesForReplay } from "@linxiraos/pi-ai/utils";
@@ -39,6 +44,7 @@ import { Tokenizer } from "../tokenizer";
 import type { AgentMessage } from "../types";
 import {
 	buildCompactionV2Request,
+	buildCompactionV2RequestFromBody,
 	getCompactionV2PreserveData,
 	requestCompactionV2Streaming,
 	shouldUseCompactionV2Streaming,
@@ -660,7 +666,8 @@ export interface SummaryOptions {
 	promptOverride?: string;
 	extraContext?: string[];
 	remoteEndpoint?: string;
-	remoteInstructions?: string;
+	/** Stable system-prompt segments from the live turn, preserved for provider cache reuse. */
+	remoteSystemPrompt?: string[];
 	initiatorOverride?: MessageAttribution;
 	metadata?: Record<string, unknown>;
 	convertToLlm?: ConvertToLlm;
@@ -1433,6 +1440,19 @@ export function prepareCompaction(
 // ============================================================================
 
 const TURN_PREFIX_SUMMARIZATION_PROMPT = prompt.render(compactionTurnPrefixPrompt);
+function isCodexResponsesModel(model: Model): model is Model<"openai-codex-responses"> {
+	return model.api === "openai-codex-responses";
+}
+
+function isCodexInputItem(item: Record<string, unknown>): item is CodexInputItem & Record<string, unknown> {
+	return (
+		(item.id === undefined || item.id === null || typeof item.id === "string") &&
+		(item.type === undefined || item.type === null || typeof item.type === "string") &&
+		(item.role === undefined || typeof item.role === "string") &&
+		(item.call_id === undefined || item.call_id === null || typeof item.call_id === "string") &&
+		(item.name === undefined || typeof item.name === "string")
+	);
+}
 
 function openAiCompatSupportsImageDetailOriginal(model: Model): boolean {
 	const compat = model.compat;
@@ -1546,7 +1566,7 @@ export async function compact(
 		promptOverride: options?.promptOverride,
 		extraContext: options?.extraContext,
 		remoteEndpoint: settings.remoteEnabled === false ? undefined : settings.remoteEndpoint,
-		remoteInstructions: options?.remoteInstructions,
+		remoteSystemPrompt: options?.remoteSystemPrompt,
 		initiatorOverride: options?.initiatorOverride,
 		metadata: options?.metadata,
 		convertToLlm: options?.convertToLlm,
@@ -1598,17 +1618,63 @@ export async function compact(
 			previousRemoteCompaction?.provider === model.provider
 				? previousRemoteCompaction.replacementHistory
 				: undefined;
-		const remoteHistory = buildOpenAiResponsesCompactionInput(
-			(summaryOptions.convertToLlm ?? defaultConvertToLlm)(remoteMessages),
-			model,
-			previousReplacementHistory,
-		);
+		const messages = (summaryOptions.convertToLlm ?? defaultConvertToLlm)(remoteMessages);
+		const remoteSystemPrompt = summaryOptions.remoteSystemPrompt ?? [SUMMARIZATION_SYSTEM_PROMPT];
+		let codexBody: OpenAICodexCompactionBody | undefined;
+		let remoteHistory: Array<Record<string, unknown>>;
+		if (isCodexResponsesModel(model)) {
+			const previousCodexInput: CodexInputItem[] = [];
+			for (const item of previousReplacementHistory ?? []) {
+				if (!isCodexInputItem(item)) {
+					throw new Error("Stored Codex V2 compaction history contains an invalid input item");
+				}
+				previousCodexInput.push(item);
+			}
+			codexBody = await buildTransformedCodexRequestBody(
+				model,
+				{ systemPrompt: remoteSystemPrompt, messages, tools: summaryOptions.tools },
+				{
+					reasoning: resolveCompactionEffort(model, summaryOptions.thinkingLevel),
+					forceReasoningOff: summaryOptions.thinkingLevel === ThinkingLevel.Off,
+					responsesLite: model.useResponsesLite,
+					sessionId: summaryOptions.sessionId,
+					promptCacheKey: summaryOptions.promptCacheKey,
+					providerSessionState: summaryOptions.providerSessionState,
+					codexCompaction: createOpenAICodexCompactionRequestContext({
+						context: summaryOptions.codexCompaction,
+						implementation: "responses_compaction_v2",
+					}),
+				},
+				undefined,
+				previousCodexInput,
+			);
+			const input = Array.isArray(codexBody.input) ? codexBody.input : [];
+			const nativeInput: Array<Record<string, unknown>> = [];
+			for (const item of input) {
+				if (!isRecord(item)) {
+					throw new Error("Codex V2 compaction input contains a non-object item");
+				}
+				nativeInput.push(item);
+			}
+			remoteHistory = stripOpenAIResponsesOutputOnlyStatusesForReplay(nativeInput);
+			codexBody.input = remoteHistory;
+		} else {
+			remoteHistory = buildOpenAiResponsesCompactionInput(messages, model, previousReplacementHistory);
+		}
 		if (remoteHistory.length > 0) {
 			try {
-				const instructions = summaryOptions.remoteInstructions ?? SUMMARIZATION_SYSTEM_PROMPT;
-				const tools = summaryOptions.tools
-					? convertTools(summaryOptions.tools, model.compat.supportsStrictMode, model)
-					: undefined;
+				const instructions = codexBody
+					? typeof codexBody.instructions === "string"
+						? codexBody.instructions
+						: ""
+					: remoteSystemPrompt.join("\n\n");
+				const tools = codexBody
+					? Array.isArray(codexBody.tools)
+						? codexBody.tools
+						: undefined
+					: summaryOptions.tools
+						? convertTools(summaryOptions.tools, model.compat.supportsStrictMode, model)
+						: undefined;
 				const trimmed = trimRemoteCompactionInputToContextWindow(
 					remoteHistory,
 					new Tokenizer(model),
@@ -1626,13 +1692,18 @@ export async function compact(
 						contextWindow: model.contextWindow,
 					});
 				}
-				const request = buildCompactionV2Request(model, trimmed.input, instructions, {
-					tools,
-					reasoning: buildCompactionV2Reasoning(model, summaryOptions.thinkingLevel),
+				const requestOptions = {
 					sessionId: summaryOptions.sessionId,
 					promptCacheKey: summaryOptions.promptCacheKey,
 					retainedMessageBudget: settings.v2RetainedMessageBudget,
-				});
+				};
+				const request = codexBody
+					? buildCompactionV2RequestFromBody(model, { ...codexBody, input: trimmed.input }, requestOptions)
+					: buildCompactionV2Request(model, trimmed.input, instructions, {
+							...requestOptions,
+							tools,
+							reasoning: buildCompactionV2Reasoning(model, summaryOptions.thinkingLevel),
+						});
 				const remote = await withAuth(
 					apiKey,
 					key =>
@@ -1685,7 +1756,7 @@ export async function compact(
 							model,
 							key,
 							remoteHistory,
-							summaryOptions.remoteInstructions ?? SUMMARIZATION_SYSTEM_PROMPT,
+							summaryOptions.remoteSystemPrompt?.join("\n\n") ?? SUMMARIZATION_SYSTEM_PROMPT,
 							signal,
 							{
 								fetch: summaryOptions.fetch,

package/src/compaction/openai.ts

@@ -48,6 +48,7 @@ import { captureOpenAIHttpError } from "@linxiraos/pi-ai/utils/openai-http";
 import {
 	applyCodexResidencyHeader,
 	CODEX_BASE_URL,
+	codexRoutingHint,
 	getCodexAccountId,
 	OPENAI_HEADER_VALUES,
 	OPENAI_HEADERS,
@@ -824,6 +825,8 @@ export async function requestOpenAiRemoteCompaction(
 		}
 		headers[OPENAI_HEADERS.BETA] = OPENAI_HEADER_VALUES.BETA_RESPONSES;
 		headers[OPENAI_HEADERS.ORIGINATOR] = OPENAI_HEADER_VALUES.ORIGINATOR_CODEX;
+		// This compaction request sends no `service_tier`, so the hint is model-only.
+		headers[OPENAI_HEADERS.ROUTING_HINT] = codexRoutingHint(request.model, undefined);
 		Object.assign(
 			headers,
 			createOpenAICodexCompatibilityMetadata({

package/src/telemetry.ts

@@ -1638,7 +1638,7 @@ export async function recordManualChatTelemetry(
 /**
  * Options accepted by {@link instrumentedCompleteSimple}. Mirrors the
  * `streamAssistantResponse` chat-span lifecycle for oneshot LLM calls
- * (compaction summaries, handoff document, branch summary, inspect_image).
+ * (compaction summaries, handoff document, branch summary, image_question).
  */
 export interface InstrumentedChatSpanOptions {
 	readonly telemetry: AgentTelemetry | undefined;
@@ -1649,7 +1649,7 @@ export interface InstrumentedChatSpanOptions {
 	/**
 	 * Tag stamped onto `pi.gen_ai.oneshot.kind`. Values used by the agent:
 	 * `compaction_summary`, `compaction_short_summary`, `compaction_turn_prefix`,
-	 * `handoff`, `branch_summary`, `inspect_image`. Free-form to allow callers
+	 * `handoff`, `branch_summary`, `image_question`. Free-form to allow callers
 	 * outside this package to add new kinds without bumping the helper.
 	 */
 	readonly oneshotKind?: string;

package/src/types.ts

@@ -245,8 +245,10 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 	/**
 	 * Peeks whether steering messages are queued, without consuming them.
 	 *
-	 * Called after each tool execution (unless interruptMode is "wait") to decide
-	 * whether to skip the remaining tool calls in the batch. The queue keeps
+	 * Polled while a tool batch runs (unless interruptMode is "wait") to decide
+	 * whether to abort in-flight and skip not-yet-started *interruptible* waits;
+	 * every other already-emitted call still executes and the message injects
+	 * at the batch boundary. The queue keeps
 	 * owning its messages until the loop reaches the next injection boundary and
 	 * dequeues via {@link getSteeringMessages} — so callers can still cancel or
 	 * restore queued messages while in-flight tools settle, and an external
@@ -758,11 +760,34 @@ export type AgentToolExecFn<TParameters extends TSchema = TSchema, TDetails = an
 	context?: AgentToolContext,
 ) => Promise<AgentToolResult<TDetails, TParameters>>;
 
+/** Live receiver for a tool call's streamed arguments (see AgentTool.openArgStream). */
+export interface AgentToolArgStream {
+	/** Raw wire fragment of the arguments (JSON text, or verbatim payload for custom-format tools). */
+	push(delta: string): void;
+	/** Arguments are complete; `args` is the final parsed object the loop will pass to `execute`. */
+	end(args: unknown): void;
+	/** The call will never execute (stream error, abort, blocked). Release resources. */
+	cancel(): void;
+}
+
+export interface AgentToolArgStreamInit {
+	toolCallId: string;
+	toolName: string;
+	/** Wire-level name for custom-format tools; undefined for JSON function tools. */
+	customWireName?: string;
+	/** Push a serializable projection of the in-flight call (e.g. diff previews); surfaces as `tool_stream_update`. */
+	emit(update: unknown): void;
+}
+
 // AgentTool extends Tool but adds the execute function
 export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any, TTheme = unknown>
 	extends Tool<TParameters> {
 	// A human-readable label for the tool to be displayed in UI
 	label: string;
+	/**
+	 * Called at `toolcall_start`, before any argument delta. Return `undefined` to opt out.
+	 */
+	openArgStream?: (init: AgentToolArgStreamInit) => AgentToolArgStream | undefined;
 	/** If true, tool is excluded unless explicitly listed in --tools or agent's tools field */
 	hidden?: boolean;
 	/** If true, tool can stage a pending action that requires explicit resolution via the resolve tool. */
@@ -781,14 +806,15 @@ export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any
 	/** If true, argument validation errors are non-fatal: raw args are passed to execute() instead of returning an error to the LLM. */
 	lenientArgValidation?: boolean;
 	/**
-	 * Whether the agent loop may abort this tool mid-execution to deliver a
-	 * queued steering message. A function resolves this per call from the raw,
-	 * pre-validation arguments.
+	 * Whether the agent loop may abort this tool mid-execution — or skip it
+	 * before it starts — to deliver a queued steering message. A function
+	 * resolves this per call from the raw, pre-validation arguments.
 	 *
 	 * Enable only for calls that purely *wait* and observe their abort signal
 	 * cleanly (e.g. `job` poll), so the abort surfaces the tool's current
-	 * snapshot rather than corrupting a side effect. Honored only when
-	 * `interruptMode` is "immediate".
+	 * snapshot rather than corrupting a side effect. Every other call runs to
+	 * completion even when steering is queued; the message lands at the next
+	 * batch boundary. Honored only when `interruptMode` is "immediate".
 	 */
 	interruptible?: boolean | ((args: Partial<Static<TParameters>>) => boolean);
 	/**
@@ -882,4 +908,5 @@ export type AgentEvent =
 	// Tool execution lifecycle
 	| { type: "tool_execution_start"; toolCallId: string; toolName: string; args: any; intent?: string }
 	| { type: "tool_execution_update"; toolCallId: string; toolName: string; args: any; partialResult: any }
+	| { type: "tool_stream_update"; toolCallId: string; toolName: string; update: unknown }
 	| { type: "tool_execution_end"; toolCallId: string; toolName: string; result: any; isError?: boolean };