@poncho-ai/harness 0.28.1 → 0.28.3

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @poncho-ai/harness@0.28.1 build /home/runner/work/poncho-ai/poncho-ai/packages/harness
+> @poncho-ai/harness@0.28.3 build /home/runner/work/poncho-ai/poncho-ai/packages/harness
 > node scripts/embed-docs.js && tsup src/index.ts --format esm --dts
 
 [embed-docs] Generated poncho-docs.ts with 4 topics
@@ -8,8 +8,8 @@
 CLI tsup v8.5.1
 CLI Target: es2022
 ESM Build start
-ESM dist/index.js 288.74 KB
-ESM ⚡️ Build success in 135ms
+ESM dist/index.js 291.95 KB
+ESM ⚡️ Build success in 123ms
 DTS Build start
-DTS ⚡️ Build success in 6964ms
+DTS ⚡️ Build success in 6599ms
 DTS dist/index.d.ts 29.62 KB

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @poncho-ai/harness
 
+## 0.28.3
+
+### Patch Changes
+
+- [`87f844b`](https://github.com/cesr/poncho-ai/commit/87f844b0a76ece87e4bba78eaf73392f857cdef2) Thanks [@cesr](https://github.com/cesr)! - Fix tool execution blowing past serverless timeout and cross-skill script paths
+  - Race tool batch execution against remaining soft deadline so parallel tools can't push past the hard platform timeout
+  - Add post-tool-execution soft deadline checkpoint for tools that finish just past the deadline
+  - Allow skill scripts to reference sibling directories (e.g. ../scripts/current-date.ts)
+  - Catch script path normalization errors in approval check instead of crashing the run
+
+## 0.28.2
+
+### Patch Changes
+
+- [`98df42f`](https://github.com/cesr/poncho-ai/commit/98df42f79e0a376d0a864598557758bfa644039d) Thanks [@cesr](https://github.com/cesr)! - Fix serverless subagent and continuation reliability
+  - Use stable internal secret across serverless instances for callback auth
+  - Wrap continuation self-fetches in waitUntil to survive function shutdown
+  - Set runStatus during callback re-runs so clients detect active processing
+  - Add post-streaming soft deadline check to catch long model responses
+  - Client auto-recovers from abrupt stream termination and orphaned continuations
+  - Fix callback continuation losing \_continuationMessages when no pending results
+
 ## 0.28.1
 
 ### Patch Changes

package/dist/index.js

@@ -1604,6 +1604,8 @@ Remote storage keys are namespaced and versioned, for example \`poncho:v1:<agent
 | \`ANTHROPIC_API_KEY\` | Yes* | Claude API key |
 | \`OPENAI_API_KEY\` | No | OpenAI API key (if using OpenAI) |
 | \`PONCHO_AUTH_TOKEN\` | No | Unified auth token (Web UI passphrase + API Bearer token) |
+| \`PONCHO_INTERNAL_SECRET\` | No | Shared secret used by internal serverless callbacks (recommended for Vercel/Lambda) |
+| \`PONCHO_SELF_BASE_URL\` | No | Explicit base URL for internal self-callbacks when auto-detection is unavailable |
 | \`OTEL_EXPORTER_OTLP_ENDPOINT\` | No | Telemetry destination |
 | \`LATITUDE_API_KEY\` | No | Latitude dashboard integration |
 | \`LATITUDE_PROJECT_ID\` | No | Latitude project identifier for capture traces |
@@ -4085,7 +4087,8 @@ var createSkillTools = (skills, options) => {
                 error: `Unknown skill: "${name}". Available skills: ${knownNames}`
               };
             }
-            const resolved2 = resolveScriptPath(skill.skillDir, script);
+            const projectRoot = options?.workingDir ?? process.cwd();
+            const resolved2 = resolveScriptPath(skill.skillDir, script, projectRoot);
             if (options?.isScriptAllowed && !options.isScriptAllowed(name, resolved2.relativePath)) {
               return {
                 error: `Script "${resolved2.relativePath}" for skill "${name}" is not allowed by policy.`
@@ -4173,7 +4176,7 @@ var collectScriptFiles = async (directory) => {
 var normalizeScriptPolicyPath = (relativePath) => {
   const trimmed = relativePath.trim();
   const normalized = normalize2(trimmed).split(sep2).join("/");
-  if (normalized.startsWith("..") || normalized.startsWith("/")) {
+  if (normalized.startsWith("/")) {
     throw new Error("Script path must be relative and within the allowed directory");
   }
   const withoutDotPrefix = normalized.startsWith("./") ? normalized.slice(2) : normalized;
@@ -4182,10 +4185,11 @@ var normalizeScriptPolicyPath = (relativePath) => {
   }
   return withoutDotPrefix;
 };
-var resolveScriptPath = (baseDir, relativePath) => {
+var resolveScriptPath = (baseDir, relativePath, containmentDir) => {
   const normalized = normalizeScriptPolicyPath(relativePath);
   const fullPath = resolve9(baseDir, normalized);
-  if (!fullPath.startsWith(`${resolve9(baseDir)}${sep2}`) && fullPath !== resolve9(baseDir)) {
+  const boundary = resolve9(containmentDir ?? baseDir);
+  if (!fullPath.startsWith(`${boundary}${sep2}`) && fullPath !== boundary) {
     throw new Error("Script path must stay inside the allowed directory");
   }
   const extension = extname(fullPath).toLowerCase();
@@ -5323,10 +5327,15 @@ var AgentHarness = class _AgentHarness {
       if (!rawScript) {
         return false;
       }
-      const canonicalPath = normalizeRelativeScriptPattern(
-        `./${normalizeScriptPolicyPath(rawScript)}`,
-        "run_skill_script input.script"
-      );
+      let canonicalPath;
+      try {
+        canonicalPath = normalizeRelativeScriptPattern(
+          `./${normalizeScriptPolicyPath(rawScript)}`,
+          "run_skill_script input.script"
+        );
+      } catch {
+        return true;
+      }
       const scriptPatterns = this.getRequestedScriptApprovalPatterns();
       return scriptPatterns.some(
         (pattern) => matchesRelativeScriptPattern(canonicalPath, pattern)
@@ -6347,6 +6356,22 @@ ${textContent}` };
           yield emitCancellation();
           return;
         }
+        if (softDeadlineMs > 0 && now() - start > softDeadlineMs) {
+          const result_ = {
+            status: "completed",
+            response: responseText + fullText,
+            steps: step,
+            tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
+            duration: now() - start,
+            continuation: true,
+            continuationMessages: [...messages],
+            maxSteps,
+            contextTokens: latestContextTokens + toolOutputEstimateSinceModel,
+            contextWindow
+          };
+          yield pushEvent({ type: "run:completed", runId, result: result_ });
+          return;
+        }
         const finishReason = await result.finishReason;
         if (finishReason === "error") {
           yield pushEvent({
@@ -6531,7 +6556,44 @@ ${textContent}` };
             );
           }
         }
-        const batchResults = approvedCalls.length > 0 ? await this.dispatcher.executeBatch(approvedCalls, toolContext) : [];
+        const TOOL_DEADLINE_SENTINEL = /* @__PURE__ */ Symbol("tool_deadline");
+        const toolDeadlineRemainingMs = softDeadlineMs > 0 ? softDeadlineMs - (now() - start) : Infinity;
+        let batchResults;
+        if (approvedCalls.length === 0) {
+          batchResults = [];
+        } else if (toolDeadlineRemainingMs <= 0) {
+          batchResults = TOOL_DEADLINE_SENTINEL;
+        } else if (toolDeadlineRemainingMs < Infinity) {
+          const raced = await Promise.race([
+            this.dispatcher.executeBatch(approvedCalls, toolContext),
+            new Promise(
+              (resolve12) => setTimeout(() => resolve12(TOOL_DEADLINE_SENTINEL), toolDeadlineRemainingMs)
+            )
+          ]);
+          if (raced === TOOL_DEADLINE_SENTINEL) {
+            batchResults = TOOL_DEADLINE_SENTINEL;
+          } else {
+            batchResults = raced;
+          }
+        } else {
+          batchResults = await this.dispatcher.executeBatch(approvedCalls, toolContext);
+        }
+        if (batchResults === TOOL_DEADLINE_SENTINEL) {
+          const result_ = {
+            status: "completed",
+            response: responseText + fullText,
+            steps: step,
+            tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
+            duration: now() - start,
+            continuation: true,
+            continuationMessages: [...messages],
+            maxSteps,
+            contextTokens: latestContextTokens + toolOutputEstimateSinceModel,
+            contextWindow
+          };
+          yield pushEvent({ type: "run:completed", runId, result: result_ });
+          return;
+        }
         if (isCancelled()) {
           yield emitCancellation();
           return;
@@ -6619,6 +6681,22 @@ ${textContent}` };
           content: JSON.stringify(toolResultsForModel),
           metadata: toolMsgMeta
         });
+        if (softDeadlineMs > 0 && now() - start > softDeadlineMs) {
+          const result_ = {
+            status: "completed",
+            response: responseText + fullText,
+            steps: step,
+            tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
+            duration: now() - start,
+            continuation: true,
+            continuationMessages: [...messages],
+            maxSteps,
+            contextTokens: latestContextTokens + toolOutputEstimateSinceModel,
+            contextWindow
+          };
+          yield pushEvent({ type: "run:completed", runId, result: result_ });
+          return;
+        }
         if (this.environment === "development") {
           const agentChanged = await this.refreshAgentIfChanged();
           const skillsChanged = await this.refreshSkillsIfChanged(true);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/harness",
-  "version": "0.28.1",
+  "version": "0.28.3",
   "description": "Agent execution runtime - conversation loop, tool dispatch, streaming",
   "repository": {
     "type": "git",

package/src/harness.ts

@@ -812,10 +812,15 @@ export class AgentHarness {
       if (!rawScript) {
         return false;
       }
-      const canonicalPath = normalizeRelativeScriptPattern(
-        `./${normalizeScriptPolicyPath(rawScript)}`,
-        "run_skill_script input.script",
-      );
+      let canonicalPath: string;
+      try {
+        canonicalPath = normalizeRelativeScriptPattern(
+          `./${normalizeScriptPolicyPath(rawScript)}`,
+          "run_skill_script input.script",
+        );
+      } catch {
+        return true;
+      }
       const scriptPatterns = this.getRequestedScriptApprovalPatterns();
       return scriptPatterns.some((pattern) =>
         matchesRelativeScriptPattern(canonicalPath, pattern),
@@ -2030,6 +2035,25 @@ ${boundedMainMemory.trim()}`
           return;
         }
 
+      // Post-streaming soft deadline: if the model stream took long enough to
+      // push past the soft deadline, checkpoint now before tool execution.
+      if (softDeadlineMs > 0 && now() - start > softDeadlineMs) {
+        const result_: RunResult = {
+          status: "completed",
+          response: responseText + fullText,
+          steps: step,
+          tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
+          duration: now() - start,
+          continuation: true,
+          continuationMessages: [...messages],
+          maxSteps,
+          contextTokens: latestContextTokens + toolOutputEstimateSinceModel,
+          contextWindow,
+        };
+        yield pushEvent({ type: "run:completed", runId, result: result_ });
+        return;
+      }
+
       // Check finish reason for error / abnormal completions.
       const finishReason = await result.finishReason;
 
@@ -2266,10 +2290,53 @@ ${boundedMainMemory.trim()}`
         }
       }
 
-      const batchResults =
-        approvedCalls.length > 0
-          ? await this.dispatcher.executeBatch(approvedCalls, toolContext)
-          : [];
+      // Race tool execution against the soft deadline so long-running tool
+      // batches (e.g. 4 parallel web_search calls) can't push us past the
+      // hard platform timeout.  If the deadline fires first, we checkpoint
+      // with the pre-tool messages and the step will be re-done on
+      // continuation (assistant + tool results are not yet in `messages`).
+      const TOOL_DEADLINE_SENTINEL = Symbol("tool_deadline");
+      const toolDeadlineRemainingMs = softDeadlineMs > 0
+        ? softDeadlineMs - (now() - start)
+        : Infinity;
+
+      let batchResults: Awaited<ReturnType<typeof this.dispatcher.executeBatch>>;
+      if (approvedCalls.length === 0) {
+        batchResults = [];
+      } else if (toolDeadlineRemainingMs <= 0) {
+        batchResults = TOOL_DEADLINE_SENTINEL as never;
+      } else if (toolDeadlineRemainingMs < Infinity) {
+        const raced = await Promise.race([
+          this.dispatcher.executeBatch(approvedCalls, toolContext),
+          new Promise<typeof TOOL_DEADLINE_SENTINEL>((resolve) =>
+            setTimeout(() => resolve(TOOL_DEADLINE_SENTINEL), toolDeadlineRemainingMs),
+          ),
+        ]);
+        if (raced === TOOL_DEADLINE_SENTINEL) {
+          batchResults = TOOL_DEADLINE_SENTINEL as never;
+        } else {
+          batchResults = raced;
+        }
+      } else {
+        batchResults = await this.dispatcher.executeBatch(approvedCalls, toolContext);
+      }
+
+      if ((batchResults as unknown) === TOOL_DEADLINE_SENTINEL) {
+        const result_: RunResult = {
+          status: "completed",
+          response: responseText + fullText,
+          steps: step,
+          tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
+          duration: now() - start,
+          continuation: true,
+          continuationMessages: [...messages],
+          maxSteps,
+          contextTokens: latestContextTokens + toolOutputEstimateSinceModel,
+          contextWindow,
+        };
+        yield pushEvent({ type: "run:completed", runId, result: result_ });
+        return;
+      }
 
       if (isCancelled()) {
         yield emitCancellation();
@@ -2367,6 +2434,26 @@ ${boundedMainMemory.trim()}`
         metadata: toolMsgMeta as Message["metadata"],
       });
 
+      // Post-tool-execution soft deadline: long-running tool batches (e.g.
+      // multiple web_search calls) can push past the deadline. Checkpoint
+      // now so the platform doesn't hard-kill us before we can continue.
+      if (softDeadlineMs > 0 && now() - start > softDeadlineMs) {
+        const result_: RunResult = {
+          status: "completed",
+          response: responseText + fullText,
+          steps: step,
+          tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
+          duration: now() - start,
+          continuation: true,
+          continuationMessages: [...messages],
+          maxSteps,
+          contextTokens: latestContextTokens + toolOutputEstimateSinceModel,
+          contextWindow,
+        };
+        yield pushEvent({ type: "run:completed", runId, result: result_ });
+        return;
+      }
+
         // In development, re-read AGENT.md and re-scan skills after tool
         // execution so changes are available on the next step without
         // requiring a server restart.

package/src/skill-tools.ts

@@ -244,7 +244,8 @@ export const createSkillTools = (
                 error: `Unknown skill: "${name}". Available skills: ${knownNames}`,
               };
             }
-            const resolved = resolveScriptPath(skill.skillDir, script);
+            const projectRoot = options?.workingDir ?? process.cwd();
+            const resolved = resolveScriptPath(skill.skillDir, script, projectRoot);
             if (
               options?.isScriptAllowed &&
               !options.isScriptAllowed(name, resolved.relativePath)
@@ -357,7 +358,7 @@ const collectScriptFiles = async (directory: string): Promise<string[]> => {
 export const normalizeScriptPolicyPath = (relativePath: string): string => {
   const trimmed = relativePath.trim();
   const normalized = normalize(trimmed).split(sep).join("/");
-  if (normalized.startsWith("..") || normalized.startsWith("/")) {
+  if (normalized.startsWith("/")) {
     throw new Error("Script path must be relative and within the allowed directory");
   }
   const withoutDotPrefix = normalized.startsWith("./") ? normalized.slice(2) : normalized;
@@ -370,10 +371,12 @@ export const normalizeScriptPolicyPath = (relativePath: string): string => {
 const resolveScriptPath = (
   baseDir: string,
   relativePath: string,
+  containmentDir?: string,
 ): { fullPath: string; relativePath: string } => {
   const normalized = normalizeScriptPolicyPath(relativePath);
   const fullPath = resolve(baseDir, normalized);
-  if (!fullPath.startsWith(`${resolve(baseDir)}${sep}`) && fullPath !== resolve(baseDir)) {
+  const boundary = resolve(containmentDir ?? baseDir);
+  if (!fullPath.startsWith(`${boundary}${sep}`) && fullPath !== boundary) {
     throw new Error("Script path must stay inside the allowed directory");
   }
   const extension = extname(fullPath).toLowerCase();