@ai-sdk/harness-pi 1.0.97 → 1.0.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-pi",
-  "version": "1.0.97",
+  "version": "1.0.99",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/harness": "1.0.95",
+    "@ai-sdk/harness": "1.0.97",
     "@ai-sdk/provider-utils": "5.0.34",
     "@earendil-works/pi-ai": "0.74.2",
     "@earendil-works/pi-coding-agent": "^0.84.3",
@@ -37,7 +37,7 @@
     "zod": "^3.25.76 || ^4.1.8"
   },
   "devDependencies": {
-    "@ai-sdk/sandbox-just-bash": "1.0.95",
+    "@ai-sdk/sandbox-just-bash": "1.0.97",
     "@types/node": "22.19.19",
     "@vercel/ai-tsconfig": "0.0.0",
     "tsup": "^8.5.1",

package/src/pi-events.ts

@@ -12,6 +12,14 @@ export const piSessionEventSchema = z.looseObject({
     .looseObject({
       type: z.string().optional(),
       delta: z.string().optional(),
+      // `toolcall_start` / `toolcall_delta` / `toolcall_end` address a content
+      // block by index rather than by tool call id. The id and name live in the
+      // partial assistant message at that index, which Pi fills in before the
+      // first delta arrives.
+      contentIndex: z.number().optional(),
+      partial: z
+        .looseObject({ content: z.array(z.unknown()).optional() })
+        .optional(),
     })
     .optional(),
   toolCallId: z.string().optional(),

package/src/pi-translate.ts

@@ -28,6 +28,13 @@ export interface PiTranslatorState {
   reasoningStarted: boolean;
   /** Tool-call id → tool name (used to fill in `toolName` on results). */
   observedToolNames: Map<string, string>;
+  /**
+   * Content-block index → tool-call id for tool inputs that are still
+   * streaming. Pi addresses `toolcall_*` events by `contentIndex`, while the
+   * harness stream parts are keyed by the tool call id, so the id is resolved
+   * once at `toolcall_start` and reused for the deltas that follow.
+   */
+  streamingToolInputIds: Map<number, string>;
   /** Tool ids requested by the current assistant message but not yet completed. */
   pendingStepToolCallIds: Set<string>;
   /** Total tool calls requested by the current assistant message. */
@@ -85,6 +92,7 @@ export function createPiTranslatorState(
     currentReasoningId: undefined,
     reasoningStarted: false,
     observedToolNames: new Map(),
+    streamingToolInputIds: new Map(),
     pendingStepToolCallIds: new Set(),
     stepToolCallCount: undefined,
     stepOpen: false,
@@ -154,6 +162,48 @@ function resolveToolName(
   return { wire: common ?? nativeName, native: nativeName };
 }
 
+/**
+ * How a tool call is dispatched, from the native tool name. Pi runs its
+ * builtin tools and MCP tools itself; everything else is handed back to the
+ * harness host. `tool-input-start` reports the same flags as the `tool-call`
+ * that follows it so a consumer does not have to wait for the call to know
+ * who will execute it.
+ */
+function resolveToolDispatch(
+  state: PiTranslatorState,
+  nativeName: string,
+): { isMcpTool: boolean; providerExecuted: boolean } {
+  const isMcpTool =
+    !state.hostToolNames.has(nativeName) &&
+    (nativeName === 'mcp' || nativeName.startsWith('mcp__'));
+  return {
+    isMcpTool,
+    providerExecuted: state.builtinToolNames.has(nativeName) || isMcpTool,
+  };
+}
+
+/**
+ * The `{ id, name }` of the tool call a `toolcall_*` event refers to, read out
+ * of the partial assistant message it carries. Returns undefined when the
+ * block is missing or not a tool call yet, in which case the input is left
+ * unstreamed — the complete `tool-call` still arrives at `tool_execution_start`.
+ */
+function readStreamingToolCall(
+  event: PiSessionEvent,
+): { contentIndex: number; id: string; name: string } | undefined {
+  const update = event.assistantMessageEvent;
+  const contentIndex = update?.contentIndex;
+  if (typeof contentIndex !== 'number') return undefined;
+  const block = update?.partial?.content?.[contentIndex];
+  if (!block || typeof block !== 'object') return undefined;
+  const record = block as Record<string, unknown>;
+  if (record.type !== 'toolCall') return undefined;
+  const { id, name } = record;
+  if (typeof id !== 'string' || id.length === 0) return undefined;
+  if (typeof name !== 'string' || name.length === 0) return undefined;
+  return { contentIndex, id, name };
+}
+
 function finishStep(state: PiTranslatorState): HarnessV1StreamPart[] {
   if (!state.stepOpen || state.pendingStepToolCallIds.size > 0) return [];
   state.stepOpen = false;
@@ -225,6 +275,8 @@ export function translatePiEvent(
       state.currentTextId = undefined;
       state.currentReasoningId = undefined;
       state.reasoningStarted = false;
+      // Content-block indices restart with every assistant message.
+      state.streamingToolInputIds.clear();
       return [];
     }
 
@@ -282,6 +334,43 @@ export function translatePiEvent(
         });
         return parts;
       }
+      // Tool inputs stream as raw JSON text, the same way text and reasoning
+      // stream. Surfacing them lets a consumer show what the model is writing
+      // before the call is complete, instead of waiting for the whole input to
+      // land at `tool_execution_start`.
+      if (update.type === 'toolcall_start') {
+        const call = readStreamingToolCall(event);
+        if (!call) return [];
+        const { wire, native } = resolveToolName(state, call.name);
+        const { isMcpTool, providerExecuted } = resolveToolDispatch(
+          state,
+          native,
+        );
+        state.streamingToolInputIds.set(call.contentIndex, call.id);
+        return [
+          {
+            type: 'tool-input-start',
+            id: call.id,
+            toolName: wire,
+            ...(providerExecuted ? { providerExecuted: true } : {}),
+            ...(isMcpTool ? { dynamic: true } : {}),
+          },
+        ];
+      }
+      if (update.type === 'toolcall_delta' || update.type === 'toolcall_end') {
+        const contentIndex = update.contentIndex;
+        if (typeof contentIndex !== 'number') return [];
+        const id = state.streamingToolInputIds.get(contentIndex);
+        // Without a start there is no id to attach the input to. Dropping it
+        // is safe: the complete input still arrives with the `tool-call`.
+        if (id === undefined) return [];
+        if (update.type === 'toolcall_end') {
+          state.streamingToolInputIds.delete(contentIndex);
+          return [{ type: 'tool-input-end', id }];
+        }
+        if (typeof update.delta !== 'string') return [];
+        return [{ type: 'tool-input-delta', id, delta: update.delta }];
+      }
       return [];
     }
 
@@ -331,10 +420,10 @@ export function translatePiEvent(
       if (!event.toolCallId || !event.toolName) return [];
       const { wire, native } = resolveToolName(state, event.toolName);
       state.observedToolNames.set(event.toolCallId, wire);
-      const isMcpTool =
-        !state.hostToolNames.has(native) &&
-        (native === 'mcp' || native.startsWith('mcp__'));
-      const providerExecuted = state.builtinToolNames.has(native) || isMcpTool;
+      const { isMcpTool, providerExecuted } = resolveToolDispatch(
+        state,
+        native,
+      );
       if (isMcpTool) state.dynamicToolCallIds.add(event.toolCallId);
       const input = serializeToolOutput(event.args ?? event.input ?? {});
       return [