@ai-sdk/harness-pi 1.0.125 → 1.0.128

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @ai-sdk/harness-pi
 
+## 1.0.128
+
+### Patch Changes
+
+- af9597b: Compile packages for ES2022 runtime target
+- Updated dependencies [af9597b]
+- Updated dependencies [31742b9]
+- Updated dependencies [bc49f78]
+  - @ai-sdk/harness@1.0.126
+  - @ai-sdk/provider-utils@5.0.49
+
+## 1.0.127
+
+### Patch Changes
+
+- Updated dependencies [be877ff]
+  - @ai-sdk/provider-utils@5.0.48
+  - @ai-sdk/harness@1.0.125
+
+## 1.0.126
+
+### Patch Changes
+
+- e9c5e0f: fix(harness-pi): release suspended sessions when in-process reattachment is disabled
+- 85f3ff6: fix(harness-pi): bound model-facing tool results and support paged file reads
+- Updated dependencies [40231b6]
+  - @ai-sdk/harness@1.0.124
+
 ## 1.0.125
 
 ### Patch Changes

package/README.md

@@ -13,14 +13,13 @@ npm i @ai-sdk/harness-pi @ai-sdk/harness @ai-sdk/sandbox-vercel
 ```ts
 import { HarnessAgent } from '@ai-sdk/harness/agent';
 import { createPi } from '@ai-sdk/harness-pi';
-import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
+import { createVercelNetworkSandboxSession } from '@ai-sdk/sandbox-vercel';
 import { tool } from 'ai';
 import { z } from 'zod/v4';
 
 const agent = new HarnessAgent({
   harness: createPi({ thinkingLevel: 'medium' }),
   id: 'demo',
-  sandbox: createVercelSandbox({ runtime: 'node24' }),
   skills: [
     {
       name: 'careful-refactors',
@@ -37,7 +36,10 @@ const agent = new HarnessAgent({
   },
 });
 
-const session = await agent.createSession();
+const sandboxSession = await createVercelNetworkSandboxSession({
+  runtime: 'node24',
+});
+const session = await agent.createSession({ sandboxSession });
 try {
   const result = await agent.generate({
     session,
@@ -46,10 +48,12 @@ try {
   console.log(result.text);
 } finally {
   await session.destroy();
+  await sandboxSession.destroy();
 }
 ```
 
-The adapter requires a `HarnessV1SandboxProvider`. Pi has no in-sandbox bridge, so the sandbox doesn't need to expose any ports — `@ai-sdk/sandbox-vercel` or `@ai-sdk/sandbox-just-bash` both work.
+Pi has no in-sandbox bridge, so the supplied sandbox session does not need
+exposed ports. Vercel and just-bash sessions both work.
 
 ## Stateless session configuration
 

package/dist/index.d.ts

@@ -65,6 +65,8 @@ type PiHarnessSettings = {
 declare const PI_BUILTIN_TOOLS: {
     readonly read: HarnessV1BuiltinTool<{
         file_path: string;
+        offset?: number | undefined;
+        limit?: number | undefined;
     }, unknown>;
     readonly write: HarnessV1BuiltinTool<{
         file_path: string;
@@ -106,6 +108,8 @@ declare const VERSION: string;
 declare const pi: _ai_sdk_harness.HarnessV1<{
     readonly read: _ai_sdk_harness.HarnessV1BuiltinTool<{
         file_path: string;
+        offset?: number | undefined;
+        limit?: number | undefined;
     }, unknown>;
     readonly write: _ai_sdk_harness.HarnessV1BuiltinTool<{
         file_path: string;

package/dist/index.js

@@ -136,7 +136,7 @@ import {
 import { access } from "fs/promises";
 
 // src/version.ts
-var VERSION = true ? "1.0.125" : "0.0.0-test";
+var VERSION = true ? "1.0.128" : "0.0.0-test";
 
 // src/pi-auth.ts
 var DEFAULT_GATEWAY_BASE_URL = "https://ai-gateway.vercel.sh";
@@ -1154,6 +1154,104 @@ ${stderr}`;
   };
 }
 
+// src/pi-tool-result.ts
+import {
+  DEFAULT_MAX_BYTES,
+  formatSize,
+  truncateHead,
+  truncateTail
+} from "@earendil-works/pi-coding-agent";
+function joinContentAndNotice(content, notice) {
+  return content.length > 0 ? `${content}
+
+[${notice}]` : `[${notice}]`;
+}
+function truncateUtf8Start(text, maxBytes) {
+  const buffer = Buffer.from(text, "utf8");
+  if (buffer.length <= maxBytes) return text;
+  let end = maxBytes;
+  while (end > 0 && (buffer[end] & 192) === 128) {
+    end--;
+  }
+  return buffer.subarray(0, end).toString("utf8");
+}
+function formatHeadNotice(truncation, continuation) {
+  const limit = truncation.truncatedBy === "bytes" ? ` (${formatSize(truncation.maxBytes)} limit)` : "";
+  return `Output truncated: showing the first ${truncation.outputLines} of ${truncation.totalLines} lines${limit}. ${continuation}`;
+}
+function formatTailNotice(truncation, continuation) {
+  const limit = truncation.truncatedBy === "bytes" ? ` (${formatSize(truncation.maxBytes)} limit)` : "";
+  return `Output truncated: showing the last ${truncation.outputLines} of ${truncation.totalLines} lines${limit}. ${continuation}`;
+}
+function truncatePiToolOutputHead(text, continuation) {
+  const truncation = truncateHead(text);
+  if (!truncation.truncated) return text;
+  if (truncation.firstLineExceedsLimit) {
+    const content = truncateUtf8Start(text, DEFAULT_MAX_BYTES);
+    return joinContentAndNotice(
+      content,
+      `Output truncated: showing the first ${formatSize(
+        Buffer.byteLength(content, "utf8")
+      )} of a ${formatSize(truncation.totalBytes)} line. ${continuation}`
+    );
+  }
+  return joinContentAndNotice(
+    truncation.content,
+    formatHeadNotice(truncation, continuation)
+  );
+}
+function truncatePiToolOutputTail(text, continuation) {
+  const truncation = truncateTail(text);
+  if (!truncation.truncated) return text;
+  return joinContentAndNotice(
+    truncation.content,
+    formatTailNotice(truncation, continuation)
+  );
+}
+function formatPiReadToolOutput({
+  text,
+  filePath,
+  offset,
+  limit
+}) {
+  const allLines = text.split("\n");
+  const startLine = offset == null ? 0 : Math.max(0, Math.floor(offset) - 1);
+  const startLineDisplay = startLine + 1;
+  if (startLine >= allLines.length) {
+    throw new Error(
+      `Offset ${offset} is beyond end of file (${allLines.length} lines total)`
+    );
+  }
+  const normalizedLimit = limit == null ? void 0 : Math.max(1, Math.floor(limit));
+  const endLine = normalizedLimit == null ? allLines.length : Math.min(startLine + normalizedLimit, allLines.length);
+  const selectedContent = allLines.slice(startLine, endLine).join("\n");
+  const truncation = truncateHead(selectedContent);
+  if (truncation.firstLineExceedsLimit) {
+    const lineSize = formatSize(
+      Buffer.byteLength(allLines[startLine] ?? "", "utf8")
+    );
+    return `[Line ${startLineDisplay} is ${lineSize}, exceeds ${formatSize(
+      DEFAULT_MAX_BYTES
+    )} limit. Use bash: sed -n '${startLineDisplay}p' ${filePath} | head -c ${DEFAULT_MAX_BYTES}]`;
+  }
+  if (truncation.truncated) {
+    const endLineDisplay = startLineDisplay + Math.max(0, truncation.outputLines - 1);
+    const nextOffset = endLineDisplay + 1;
+    const limitNotice = truncation.truncatedBy === "bytes" ? ` (${formatSize(DEFAULT_MAX_BYTES)} limit)` : "";
+    return joinContentAndNotice(
+      truncation.content,
+      `Showing lines ${startLineDisplay}-${endLineDisplay} of ${allLines.length}${limitNotice}. Use offset=${nextOffset} to continue.`
+    );
+  }
+  if (endLine < allLines.length) {
+    return joinContentAndNotice(
+      truncation.content,
+      `${allLines.length - endLine} more lines in file. Use offset=${endLine + 1} to continue.`
+    );
+  }
+  return truncation.content;
+}
+
 // src/pi-translate.ts
 import { randomBytes } from "crypto";
 import { secureJsonParse } from "@ai-sdk/provider-utils";
@@ -2559,7 +2657,13 @@ async function createPiSession(input) {
         toolCallId,
         toolName: delivered.toolName,
         content: [
-          { type: "text", text: serializeToolOutput(delivered.output) }
+          {
+            type: "text",
+            text: truncatePiToolOutputHead(
+              serializeToolOutput(delivered.output),
+              "Call the tool again with narrower parameters to inspect the omitted output."
+            )
+          }
         ],
         isError: delivered.isError,
         timestamp: Date.now()
@@ -3089,7 +3193,7 @@ async function createPiSession(input) {
     },
     doStop,
     doDetach: async () => {
-      if (activeTurn != null || pendingToolResults.size > 0) {
+      if (input.settings.reattachInProcess !== false && (activeTurn != null || pendingToolResults.size > 0)) {
         parkedPiSessions.set(input.sessionId, {
           session: sessionImpl,
           input,
@@ -3114,7 +3218,7 @@ async function createPiSession(input) {
       if (stopped) {
         throw new Error("Pi session has been stopped.");
       }
-      if (activeTurn != null && (pendingToolResults.size > 0 || pendingToolApprovals.size > 0)) {
+      if (input.settings.reattachInProcess !== false && activeTurn != null && (pendingToolResults.size > 0 || pendingToolApprovals.size > 0)) {
         parkedPiSessions.set(input.sessionId, {
           session: sessionImpl,
           input,
@@ -3135,8 +3239,11 @@ async function createPiSession(input) {
       }
       suspending = true;
       const turnToSuspend = activeTurn;
-      await turnToSuspend?.abort();
+      const abortingTurn = turnToSuspend?.abort();
       deferredRerun?.cancel();
+      settlePendingToolResults("Pi session suspended");
+      settlePendingToolApprovals("Pi session suspended");
+      await abortingTurn;
       await turnToSuspend?.done.catch(() => {
       });
       try {
@@ -3151,8 +3258,6 @@ async function createPiSession(input) {
       }
       stopped = true;
       parkedPiSessions.delete(input.sessionId);
-      settlePendingToolResults("Pi session suspended");
-      settlePendingToolApprovals("Pi session suspended");
       await disposePiSession();
       workspaceVfs.unmount();
       await rm2(hostRoot, { recursive: true, force: true });
@@ -3217,8 +3322,22 @@ function buildBuiltinToolDefinition(input) {
       return defineTool({
         name: "read",
         label: "read",
-        description: "Read file contents.",
-        parameters: Type2.Object({ file_path: Type2.String() }),
+        description: "Read file contents. Output is limited to 2,000 lines or 50KB. Use offset and limit to read large files in pages.",
+        parameters: Type2.Object({
+          file_path: Type2.String(),
+          offset: Type2.Optional(
+            Type2.Integer({
+              minimum: 1,
+              description: "Line number to start reading from (1-indexed)."
+            })
+          ),
+          limit: Type2.Optional(
+            Type2.Integer({
+              minimum: 1,
+              description: "Maximum number of lines to read."
+            })
+          )
+        }),
         async execute(toolCallId, params) {
           const denied = await maybeDenyPiBuiltinTool({
             toolCallId,
@@ -3227,7 +3346,14 @@ function buildBuiltinToolDefinition(input) {
           });
           if (denied) return denied;
           const buf = await input.remoteOps.readBuffer(params.file_path);
-          return asPiToolResult(buf.toString("utf8"));
+          return asPiToolResult(
+            formatPiReadToolOutput({
+              text: buf.toString("utf8"),
+              filePath: params.file_path,
+              offset: params.offset,
+              limit: params.limit
+            })
+          );
         }
       });
     case "write":
@@ -3305,7 +3431,12 @@ function buildBuiltinToolDefinition(input) {
           const text = `${out}${result.exitCode != null ? `
 
 (exit ${result.exitCode})` : ""}`.trim();
-          return asPiToolResult(text);
+          return asPiToolResult(
+            truncatePiToolOutputTail(
+              text,
+              "Re-run the command with narrower output, or redirect it to a file and use read with offset and limit."
+            )
+          );
         }
       });
     case "grep":
@@ -3330,7 +3461,12 @@ function buildBuiltinToolDefinition(input) {
           });
           if (denied) return denied;
           const out = await input.remoteOps.grepFiles(params.pattern, params);
-          return asPiToolResult(out);
+          return asPiToolResult(
+            truncatePiToolOutputHead(
+              out,
+              "Narrow the pattern or path, or read the matching file with offset and limit."
+            )
+          );
         }
       });
     case "find":
@@ -3355,7 +3491,12 @@ function buildBuiltinToolDefinition(input) {
             params.path ?? ".",
             params.limit ?? 1e3
           );
-          return asPiToolResult(matches.join("\n"));
+          return asPiToolResult(
+            truncatePiToolOutputHead(
+              matches.join("\n"),
+              "Narrow the pattern or search path to inspect the omitted matches."
+            )
+          );
         }
       });
     case "ls":
@@ -3378,7 +3519,12 @@ function buildBuiltinToolDefinition(input) {
             params.path ?? ".",
             params.limit ?? 500
           );
-          return asPiToolResult(entries.join("\n"));
+          return asPiToolResult(
+            truncatePiToolOutputHead(
+              entries.join("\n"),
+              "List a narrower directory path to inspect the omitted entries."
+            )
+          );
         }
       });
   }
@@ -3397,7 +3543,14 @@ function buildUserToolDefinition(spec, pending) {
     async execute(toolCallId) {
       return new Promise((resolve2) => {
         pending.set(toolCallId, { resolve: resolve2 });
-      }).then((output) => asPiToolResult(serializeToolOutput(output)));
+      }).then(
+        (output) => asPiToolResult(
+          truncatePiToolOutputHead(
+            serializeToolOutput(output),
+            "Call the tool again with narrower parameters to inspect the omitted output."
+          )
+        )
+      );
     }
   });
 }
@@ -3408,9 +3561,11 @@ var PI_BUILTIN_TOOLS = {
   read: commonTool("read", {
     nativeName: "read",
     toolUseKind: "readonly",
-    description: "Read file contents.",
+    description: "Read file contents. Output is limited to 2,000 lines or 50KB. Use offset and limit to read large files in pages.",
     inputSchema: z3.object({
-      file_path: z3.string()
+      file_path: z3.string(),
+      offset: z3.number().int().positive().optional(),
+      limit: z3.number().int().positive().optional()
     })
   }),
   write: commonTool("write", {