pi-background-tasks 2.3.0 → 2.4.2

package/src/core/delegate/types.ts

@@ -18,7 +18,7 @@ export const DELEGATE_RESULT_PACKAGE_SCHEMA_VERSION =
   'pi-background-tasks.delegate-result.v1' as const;
 export const DELEGATE_RECEIPT_SCHEMA_VERSION = 'pi-background-tasks.delegate-receipt.v1' as const;
 export const DELEGATE_BUDGET_PLAN_SCHEMA_VERSION =
-  'pi-background-tasks.delegate-budget-plan.v2' as const;
+  'pi-background-tasks.delegate-budget-plan.v3' as const;
 export const DELEGATE_MANIFEST_SCHEMA_VERSION = 'pi-background-tasks.delegate-manifest.v2' as const;
 
 /**
@@ -64,6 +64,7 @@ export interface DelegatePinnedRoute extends DelegateRoute {
 export interface DelegateBudgetRouteSource {
   family: TokenBudgetFamily;
   rate_source: TokenBudgetRateSource;
+  conservative_rate_source?: TokenBudgetRateSource | undefined;
 }
 
 export interface DelegateContextPolicyDescriptor {
@@ -192,6 +193,11 @@ export interface DelegateResultPackageV1 {
   spilled_artifacts: readonly DelegateSpillReceipt[];
 }
 
+export type DelegateSpillContentFormat =
+  | 'single_text_utf8'
+  | 'tool_result_content_json_v1'
+  | 'opaque_bytes';
+
 export interface DelegateSpillReceipt {
   schema_version: typeof DELEGATE_RECEIPT_SCHEMA_VERSION;
   artifact: string;
@@ -201,6 +207,11 @@ export interface DelegateSpillReceipt {
   source_call_index: number;
   byte_length: number;
   sha256: string;
+  /**
+   * Encoding of the hashed artifact bytes. Optional only for compatibility
+   * with v1 receipts written before content formats were recorded.
+   */
+  content_format?: DelegateSpillContentFormat | undefined;
 }
 
 export const DELEGATE_ERROR_CODES = [

package/src/core/fusion/child-protocol.ts

@@ -23,8 +23,8 @@ export const FUSION_TOOL_CALL_SEAL_SUFFIX = '.seal.json';
 export const FUSION_RUNTIME_GUARD_SCHEMA_VERSION =
   'pi-background-tasks.fusion-runtime-guard.v2' as const;
 export const FUSION_RUNTIME_GUARD_PREFIX = '\u001ePI_FUSION_RUNTIME_GUARD ';
-export const FUSION_CHILD_MAX_PROVIDER_REQUESTS = 128;
-export const FUSION_CHILD_MAX_TOOL_CALLS = 192;
+export const FUSION_CHILD_MAX_PROVIDER_REQUESTS = 550;
+export const FUSION_CHILD_MAX_TOOL_CALLS = 600;
 
 /**
  * Aggregate ceiling on tool-result bytes a single candidate child may accumulate.
@@ -32,7 +32,7 @@ export const FUSION_CHILD_MAX_TOOL_CALLS = 192;
  * The byte ceiling complements the tool/request count limits and pre-spawn stage
  * budgets. It remains an independent bound on total tool material across the child run.
  */
-export const FUSION_CHILD_MAX_TOTAL_TOOL_RESULT_BYTES = 8 * 1024 * 1024;
+export const FUSION_CHILD_MAX_TOTAL_TOOL_RESULT_BYTES = 32 * 1024 * 1024;
 
 export type FusionRuntimeGuardCode =
   | 'provider_request_limit'

package/src/core/fusion/pi-child.ts

@@ -76,8 +76,8 @@ import { resolveAnthropicAttributionExtensionPath } from '../anthropic-attributi
 
 // The response cap now applies to one final full answer, not cumulative Pi JSON events.
 export const FUSION_CHILD_STDOUT_LIMIT_BYTES = 32 * 1024 * 1024;
-export const FUSION_CHILD_STDERR_LIMIT_BYTES = 4 * 1024 * 1024;
-export const FUSION_CHILD_TIMEOUT_MS = 30 * 60 * 1000;
+export const FUSION_CHILD_STDERR_LIMIT_BYTES = 16 * 1024 * 1024;
+export const FUSION_CHILD_TIMEOUT_MS = 50 * 60 * 1000;
 /**
  * Stale-action watchdog threshold.
  *
@@ -86,10 +86,12 @@ export const FUSION_CHILD_TIMEOUT_MS = 30 * 60 * 1000;
  * the final assistant message, so a single slow model turn is genuinely silent on both
  * streams. The threshold must therefore exceed the longest plausible single turn, not the
  * longest plausible tool call: a value tuned to tool latency would kill healthy children
- * mid-reasoning. 1200s stays inside the 30-minute absolute cap while leaving a wide
- * margin over observed turn latency.
+ * mid-reasoning. Thirty-five minutes leaves a wide margin over observed turn latency
+ * while remaining materially below the 50-minute absolute cap, so the stale-action
+ * watchdog retains an independent purpose instead of becoming an unreachable duplicate
+ * timeout.
  */
-export const FUSION_CHILD_IDLE_TIMEOUT_MS = 20 * 60 * 1000;
+export const FUSION_CHILD_IDLE_TIMEOUT_MS = 35 * 60 * 1000;
 export const FUSION_CHILD_KILL_GRACE_MS = 3000;
 export const FUSION_CHILD_SIGKILL_WAIT_MS = 5000;
 const FUSION_PI_CHILD_O_NOFOLLOW =
@@ -1311,6 +1313,11 @@ async function assertFusionToolCallLogSeal(
     if (recordCount !== trace.summary.count) {
       throw new Error('fusion tool-call audit completion seal record count mismatch');
     }
+    if (recordCount > FUSION_CHILD_MAX_TOOL_CALLS) {
+      throw new Error(
+        `fusion tool-call audit exceeds tool-call limit ${String(FUSION_CHILD_MAX_TOOL_CALLS)}`,
+      );
+    }
     if (totalResultBytes !== trace.summary.total_result_bytes) {
       throw new Error('fusion tool-call audit completion seal result-byte total mismatch');
     }

package/src/core/fusion/web-fetch.ts

@@ -8,8 +8,8 @@ import { TextDecoder } from 'node:util';
 
 import type TurndownService from 'turndown';
 
-export const FUSION_WEB_FETCH_TIMEOUT_MS = 60_000;
-export const FUSION_WEB_FETCH_MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+export const FUSION_WEB_FETCH_TIMEOUT_MS = 90_000;
+export const FUSION_WEB_FETCH_MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
 export const FUSION_WEB_FETCH_MAX_OUTPUT_BYTES = 32 * 1024;
 export const FUSION_WEB_FETCH_MAX_REDIRECTS = 5;
 
@@ -57,6 +57,12 @@ export type FusionTransportRequest = (
   options: http.RequestOptions | https.RequestOptions,
 ) => http.ClientRequest;
 
+export type FusionContentExtractor = (
+  body: Buffer,
+  contentType: string,
+  requestedFormat: 'text' | 'markdown',
+) => Promise<{ content: string; format: 'text' | 'markdown' }>;
+
 export interface FusionWebFetchOptions {
   lookup?: FusionDnsLookup;
   request?: FusionTransportRequest;
@@ -68,6 +74,8 @@ export interface FusionWebFetchOptions {
   maxOutputBytes?: number;
   maxRedirects?: number;
   allowBlockedAddressesForTests?: boolean;
+  /** Test seam for proving extraction remains inside the full-operation deadline. */
+  extractContent?: FusionContentExtractor;
 }
 
 interface NormalizedRequestUrl {
@@ -106,6 +114,7 @@ interface EffectiveOptions {
   maxOutputBytes: number;
   maxRedirects: number;
   allowBlockedAddressesForTests: boolean;
+  extractContent: FusionContentExtractor;
 }
 
 interface ExtractionResult {
@@ -218,8 +227,21 @@ export async function fusionWebFetch(
       continue;
     }
 
-    const extracted = await extractContent(result.body, result.contentType, requestedFormat);
+    const extracted = await extractWithinDeadline(
+      result.body,
+      result.contentType,
+      requestedFormat,
+      effective,
+      deadlineMs,
+      currentUrl,
+    );
     const capped = capUtf8Bytes(extracted.content, effective.maxOutputBytes);
+    const contentSha256 = createHash('sha256').update(result.body).digest('hex');
+    assertFetchDeadline(effective, deadlineMs, currentUrl, 'content extraction');
+    const durationMs = Math.max(0, effective.now() - start);
+    if (durationMs > effective.timeoutMs) {
+      throw fetchTimeout(currentUrl, 'content extraction');
+    }
     return {
       url: requestedUrl.toString(),
       final_url: currentUrl.toString(),
@@ -229,8 +251,8 @@ export async function fusionWebFetch(
       truncated: capped.truncated,
       content: capped.content,
       response_bytes: result.body.byteLength,
-      content_sha256: createHash('sha256').update(result.body).digest('hex'),
-      duration_ms: Math.max(0, effective.now() - start),
+      content_sha256: contentSha256,
+      duration_ms: durationMs,
     };
   }
 }
@@ -247,9 +269,54 @@ function mergeOptions(options: FusionWebFetchOptions): EffectiveOptions {
     maxOutputBytes: options.maxOutputBytes ?? FUSION_WEB_FETCH_MAX_OUTPUT_BYTES,
     maxRedirects: options.maxRedirects ?? FUSION_WEB_FETCH_MAX_REDIRECTS,
     allowBlockedAddressesForTests: options.allowBlockedAddressesForTests ?? false,
+    extractContent: options.extractContent ?? extractContent,
   };
 }
 
+function fetchTimeout(url: URL, phase: string): FusionWebFetchError {
+  return new FusionWebFetchError(
+    'request_timeout',
+    `fusion_web_fetch request timeout elapsed during ${phase}`,
+    { url: url.toString() },
+  );
+}
+
+function assertFetchDeadline(
+  options: EffectiveOptions,
+  deadlineMs: number,
+  url: URL,
+  phase: string,
+): number {
+  const remainingMs = deadlineMs - options.now();
+  if (remainingMs <= 0) throw fetchTimeout(url, phase);
+  return remainingMs;
+}
+
+async function extractWithinDeadline(
+  body: Buffer,
+  contentType: string,
+  requestedFormat: 'text' | 'markdown',
+  options: EffectiveOptions,
+  deadlineMs: number,
+  url: URL,
+): Promise<ExtractionResult> {
+  const remainingMs = assertFetchDeadline(options, deadlineMs, url, 'content extraction');
+  let timer: NodeJS.Timeout | undefined;
+  try {
+    const timeout = new Promise<never>((_resolve, reject) => {
+      timer = setTimeout(() => reject(fetchTimeout(url, 'content extraction')), remainingMs);
+    });
+    const extraction = Promise.resolve().then(() =>
+      options.extractContent(body, contentType, requestedFormat),
+    );
+    const result = await Promise.race([extraction, timeout]);
+    assertFetchDeadline(options, deadlineMs, url, 'content extraction');
+    return result;
+  } finally {
+    if (timer !== undefined) clearTimeout(timer);
+  }
+}
+
 function normalizeRequestUrl(rawUrl: string): NormalizedRequestUrl {
   let parsed: URL;
   try {

package/src/core/update-check.ts

@@ -66,6 +66,11 @@ export function parsePackageInfo(payload: unknown): PackageInfo {
 
 const realFetch: FetchLike = (url, init) => fetch(url, init);
 
+/** Duck-type AbortError because Node versions differ on DOMException inheritance. */
+function isAbortError(error: unknown): boolean {
+  return typeof error === 'object' && error !== null && Reflect.get(error, 'name') === 'AbortError';
+}
+
 /** Time-boxed, never-throwing lookup of the latest published version of a package. */
 export async function fetchLatestVersion(
   options: FetchLatestVersionOptions,
@@ -74,7 +79,11 @@ export async function fetchLatestVersion(
   const timeoutMs = options.timeoutMs ?? DEFAULT_UPDATE_TIMEOUT_MS;
   const doFetch = options.fetchImpl ?? realFetch;
   const controller = new AbortController();
+  let timedOut = false;
   const timer = setTimeout(() => {
+    // Ownership matters: a fetch implementation may reject with AbortError for
+    // another reason. Only the abort initiated by this timer is an expected skip.
+    timedOut = true;
     controller.abort();
   }, timeoutMs);
   try {
@@ -84,7 +93,10 @@ export async function fetchLatestVersion(
     const payload = await response.json();
     return parseLatestVersionPayload(payload);
   } catch (error) {
-    if (options.onError) options.onError(error instanceof Error ? error : new Error(String(error)));
+    const expectedTimeoutAbort = timedOut && controller.signal.aborted && isAbortError(error);
+    if (options.onError && !expectedTimeoutAbort) {
+      options.onError(error instanceof Error ? error : new Error(String(error)));
+    }
     return undefined;
   } finally {
     clearTimeout(timer);