@oh-my-pi/pi-agent-core 18.1.5 → 18.1.6

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [18.1.6] - 2026-09-03
+
+### Added
+
+- Added support for streaming tool argument updates, providing more responsive tool-call progress.
+
+### Changed
+
+- Improved steering behavior so queued steering commands preserve already-emitted non-interruptible tool calls while aborting or skipping only interruptible waits.
+
 ## [18.1.2] - 2026-09-01
 
 ### Fixed

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,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "18.1.5",
+	"version": "18.1.6",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -35,16 +35,16 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.1.5",
-		"@oh-my-pi/pi-catalog": "18.1.5",
-		"@oh-my-pi/pi-natives": "18.1.5",
-		"@oh-my-pi/pi-utils": "18.1.5",
-		"@oh-my-pi/pi-wire": "18.1.5",
-		"@oh-my-pi/snapcompact": "18.1.5",
+		"@oh-my-pi/pi-ai": "18.1.6",
+		"@oh-my-pi/pi-catalog": "18.1.6",
+		"@oh-my-pi/pi-natives": "18.1.6",
+		"@oh-my-pi/pi-utils": "18.1.6",
+		"@oh-my-pi/pi-wire": "18.1.6",
+		"@oh-my-pi/snapcompact": "18.1.6",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {
-		"@oh-my-pi/omptype": "18.1.5",
+		"@oh-my-pi/omptype": "18.1.6",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.9.0",
 		"@types/bun": "^1.3.14"

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

@@ -407,7 +407,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") {

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,6 +760,25 @@ 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,
@@ -766,6 +787,10 @@ export interface AgentTool<
 > 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. */
@@ -784,14 +809,15 @@ export interface AgentTool<
 	/** 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);
 	/**
@@ -885,4 +911,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 };