deepline 0.1.169 → 0.1.171

package/dist/bundling-sources/apps/play-runner-workers/src/dedup-do.ts

@@ -1153,7 +1153,6 @@ export class PlayDedup implements DurableObject {
     if (!state && timeoutMs > 0) {
       await new Promise<void>((resolve) => {
         let settled = false;
-        let timeout: ReturnType<typeof setTimeout>;
         const finish = () => {
           if (settled) return;
           settled = true;
@@ -1164,7 +1163,7 @@ export class PlayDedup implements DurableObject {
           clearTimeout(timeout);
           resolve();
         };
-        timeout = setTimeout(finish, timeoutMs);
+        const timeout = setTimeout(finish, timeoutMs);
         if (!this.childTerminalWaiters.has(eventKey)) {
           this.childTerminalWaiters.set(eventKey, new Set());
         }

package/dist/bundling-sources/apps/play-runner-workers/src/entry.ts

@@ -159,6 +159,8 @@ import {
   markWorkerToolReceiptResultCached,
   markWorkerToolReceiptResultExecution,
   planWorkerToolReceiptGroups,
+  resolveWorkerToolReceiptGroupWaitMaxAttempts,
+  resolveWorkerToolRuntimeTimeoutMs,
 } from './runtime/tool-receipts';
 // The harness stub forwards leaf calls (validation, runtime-api HTTP) into
 // the long-lived Play Harness Worker via env.HARNESS. We import the
@@ -563,11 +565,13 @@ function resolveRuntimeDeadlineRemainingMs(runtimeDeadlineMs?: number): number {
 
 function resolveToolRuntimeApiTimeout(input: {
   requestInput: Record<string, unknown>;
+  timeoutMs?: number;
   runtimeDeadlineMs?: number;
 }): { timeoutMs: number; timeoutErrorMessage?: string } {
-  const toolTimeoutMs = resolveRuntimeToolReceiptWaitTimeoutMs(
-    input.requestInput,
-  );
+  const toolTimeoutMs =
+    typeof input.timeoutMs === 'number' && Number.isFinite(input.timeoutMs)
+      ? Math.max(1, Math.ceil(input.timeoutMs))
+      : resolveRuntimeToolReceiptWaitTimeoutMs(input.requestInput);
   const remainingMs = resolveRuntimeDeadlineRemainingMs(
     input.runtimeDeadlineMs,
   );
@@ -1265,6 +1269,7 @@ async function executeTool(
   transientHttpRetrySafe = false,
   abortSignal?: AbortSignal,
   runtimeDeadlineMs?: number,
+  runtimeTimeoutMs?: number,
 ): Promise<ToolExecuteResult> {
   if (args.toolId === 'test_wait_for_event' && workflowStep) {
     const result = await waitForSyntheticIntegrationEvent(
@@ -1287,6 +1292,7 @@ async function executeTool(
     transientHttpRetrySafe,
     abortSignal,
     runtimeDeadlineMs,
+    runtimeTimeoutMs,
   );
 }
 
@@ -1300,6 +1306,7 @@ async function executeToolWithLifecycle(
   transientHttpRetrySafe = false,
   abortSignal?: AbortSignal,
   runtimeDeadlineMs?: number,
+  runtimeTimeoutMs?: number,
 ): Promise<ToolExecuteResult> {
   callbacks?.onToolCalled?.(args.toolId, nowMs());
   try {
@@ -1312,6 +1319,7 @@ async function executeToolWithLifecycle(
       transientHttpRetrySafe,
       abortSignal,
       runtimeDeadlineMs,
+      runtimeTimeoutMs,
     );
   } catch (error) {
     callbacks?.onToolFailed?.(args.toolId, nowMs());
@@ -1329,6 +1337,8 @@ function normalizeToolExecuteArgs(request: unknown): {
   input: Record<string, unknown>;
   force?: boolean;
   staleAfterSeconds?: number;
+  timeoutMs?: number;
+  receiptWaitMs?: number;
 } {
   if (!isToolExecuteRecord(request)) {
     throw new Error(
@@ -1354,6 +1364,14 @@ function normalizeToolExecuteArgs(request: unknown): {
     ...(typeof request.staleAfterSeconds === 'number'
       ? { staleAfterSeconds: request.staleAfterSeconds }
       : {}),
+    ...(typeof request.timeoutMs === 'number' &&
+    Number.isFinite(request.timeoutMs)
+      ? { timeoutMs: request.timeoutMs }
+      : {}),
+    ...(typeof request.receiptWaitMs === 'number' &&
+    Number.isFinite(request.receiptWaitMs)
+      ? { receiptWaitMs: request.receiptWaitMs }
+      : {}),
   };
 }
 
@@ -1450,6 +1468,7 @@ async function callToolDirect(
   transientHttpRetrySafe = false,
   abortSignal?: AbortSignal,
   runtimeDeadlineMs?: number,
+  runtimeTimeoutMs?: number,
 ): Promise<ToolExecuteResult> {
   const { id, toolId, input } = args;
   const path = `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`;
@@ -1464,6 +1483,7 @@ async function callToolDirect(
     try {
       const runtimeApiTimeout = resolveToolRuntimeApiTimeout({
         requestInput: input,
+        timeoutMs: runtimeTimeoutMs,
         runtimeDeadlineMs,
       });
       res = await fetchRuntimeApi(
@@ -1640,6 +1660,7 @@ type WorkerToolBatchRequest = {
   receiptKey: string | null;
   force: boolean;
   receiptWaitMaxAttempts: number;
+  runtimeTimeoutMs?: number;
   toolId: string;
   input: Record<string, unknown>;
   workflowStep?: WorkflowStep;
@@ -1658,6 +1679,20 @@ type PreparedWorkerToolBatchRequests = {
   deferredClaimedRequests: Promise<ClaimedWorkerToolBatchRequest[]>[];
 };
 
+function resolveClaimedWorkerToolRuntimeTimeoutMs(
+  claimedRequests: ClaimedWorkerToolBatchRequest[],
+  input: { runtimeDeadlineMs?: number },
+): number | undefined {
+  return resolveWorkerToolRuntimeTimeoutMs(claimedRequests, {
+    resolveOwnerTimeoutMs: (request) =>
+      resolveToolRuntimeApiTimeout({
+        requestInput: request.input,
+        timeoutMs: request.runtimeTimeoutMs,
+        runtimeDeadlineMs: input.runtimeDeadlineMs,
+      }).timeoutMs,
+  });
+}
+
 const WORKER_TOOL_BATCH_GRACE_MS = 250;
 const MAP_EXECUTION_HEARTBEAT_INTERVAL_MS = 5_000;
 const MAP_INCREMENTAL_PERSIST_CHUNK_ROWS = 100;
@@ -1802,6 +1837,7 @@ class WorkerToolBatchScheduler {
     input: Record<string, unknown>,
     workflowStep?: WorkflowStep,
     options?: { force?: boolean; staleAfterSeconds?: number | null },
+    runtimeOptions?: { timeoutMs?: number; receiptWaitMs?: number },
   ): Promise<unknown> {
     const providerActionVersion =
       await this.resolveToolActionCacheVersion(toolId);
@@ -1819,7 +1855,14 @@ class WorkerToolBatchScheduler {
         cacheKey: receiptKey,
         receiptKey,
         force: options?.force === true,
-        receiptWaitMaxAttempts: resolveRuntimeToolReceiptWaitMaxAttempts(input),
+        receiptWaitMaxAttempts: resolveRuntimeToolReceiptWaitMaxAttempts(
+          typeof runtimeOptions?.receiptWaitMs === 'number'
+            ? { max_wait_ms: runtimeOptions.receiptWaitMs }
+            : input,
+        ),
+        ...(typeof runtimeOptions?.timeoutMs === 'number'
+          ? { runtimeTimeoutMs: runtimeOptions.timeoutMs }
+          : {}),
         toolId,
         input,
         workflowStep,
@@ -2005,7 +2048,10 @@ class WorkerToolBatchScheduler {
     try {
       const receipt = await this.waitForDurableToolReceipt({
         receiptKey: input.receiptKey,
-        maxAttempts: request.receiptWaitMaxAttempts,
+        maxAttempts: resolveWorkerToolReceiptGroupWaitMaxAttempts(
+          input.group,
+          (groupRequest) => groupRequest.receiptWaitMaxAttempts,
+        ),
       });
       await this.resolveCompletedDurableToolReceiptGroup({
         group: input.group,
@@ -2114,7 +2160,10 @@ class WorkerToolBatchScheduler {
       try {
         const receipt = await this.waitForDurableToolReceipt({
           receiptKey: input.receiptKey,
-          maxAttempts: request.receiptWaitMaxAttempts,
+          maxAttempts: resolveWorkerToolReceiptGroupWaitMaxAttempts(
+            input.group,
+            (groupRequest) => groupRequest.receiptWaitMaxAttempts,
+          ),
         });
         await this.resolveCompletedDurableToolReceiptGroup({
           group: input.group,
@@ -2516,6 +2565,9 @@ class WorkerToolBatchScheduler {
                 toolContract?.retrySafeTransientHttp === true,
                 this.abortSignal,
                 this.runtimeDeadlineMs,
+                resolveClaimedWorkerToolRuntimeTimeoutMs([claimed], {
+                  runtimeDeadlineMs: this.runtimeDeadlineMs,
+                }),
               );
             } catch (error) {
               this.rejectRequests(
@@ -2686,6 +2738,9 @@ async function executeBatchedWorkerToolGroup(input: {
           toolContract?.retrySafeTransientHttp === true,
           input.abortSignal,
           input.runtimeDeadlineMs,
+          resolveClaimedWorkerToolRuntimeTimeoutMs(batch.memberRequests, {
+            runtimeDeadlineMs: input.runtimeDeadlineMs,
+          }),
         );
       } catch (error) {
         input.callbacks?.onToolFailed?.(batch.batchOperation, nowMs());
@@ -4474,9 +4529,12 @@ function createMinimalWorkerCtx(
   const executeWithRuntimeReceipt = async <T>(
     key: string,
     execute: () => Promise<T> | T,
-    repairRunningReceiptForSameRun = false,
-    reclaimRunning = false,
-    repairRunningReceiptForSameRunAfterWaitTimeout = false,
+    options: {
+      repairRunningReceiptForSameRun?: boolean;
+      reclaimRunning?: boolean;
+      repairRunningReceiptForSameRunAfterWaitTimeout?: boolean;
+      runningReceiptWaitMaxAttempts?: number;
+    } = {},
   ): Promise<T> => {
     const serialized = await runWorkerRuntimeReceiptBoundary<unknown>({
       orgId: req.orgId,
@@ -4485,9 +4543,12 @@ function createMinimalWorkerCtx(
       key,
       receiptStore,
       execute: async () => serializeDurableStepValue(await execute()),
-      repairRunningReceiptForSameRun,
-      reclaimRunning,
-      repairRunningReceiptForSameRunAfterWaitTimeout,
+      repairRunningReceiptForSameRun:
+        options.repairRunningReceiptForSameRun ?? false,
+      reclaimRunning: options.reclaimRunning ?? false,
+      repairRunningReceiptForSameRunAfterWaitTimeout:
+        options.repairRunningReceiptForSameRunAfterWaitTimeout ?? false,
+      runningReceiptWaitMaxAttempts: options.runningReceiptWaitMaxAttempts,
     });
     return deserializeDurableStepValue(serialized) as T;
   };
@@ -4509,7 +4570,6 @@ function createMinimalWorkerCtx(
         )(name, async () => serializeDurableStepValue(await execute()));
         return deserializeDurableStepValue(serialized) as T;
       },
-      false,
     );
   };
   const nextCtxStepReceiptKey = (
@@ -6280,6 +6340,10 @@ function createMinimalWorkerCtx(
             force: request.force === true,
             staleAfterSeconds: request.staleAfterSeconds,
           },
+          {
+            timeoutMs: request.timeoutMs,
+            receiptWaitMs: request.receiptWaitMs,
+          },
         );
       },
     },
@@ -6674,9 +6738,11 @@ function createMinimalWorkerCtx(
             childPlaySlot?.release();
           }
         },
-        false,
-        false,
-        true,
+        {
+          repairRunningReceiptForSameRunAfterWaitTimeout: true,
+          runningReceiptWaitMaxAttempts:
+            resolveRuntimeToolReceiptWaitMaxAttempts(input),
+        },
       );
     },
     async fetch(

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/map-chunk-plan.ts

@@ -17,7 +17,7 @@ export { TOOL_CALLING_MAP_CHUNK_SIZE };
 // Paid Cloudflare Workers support a much higher configured subrequest limit.
 // Keep a large buffer for coordinator/storage calls around row-level unbatched
 // tool RPCs, but avoid pathological one-row chunks for provider waterfalls.
-export const UNBATCHED_TOOL_SUBREQUESTS_PER_CHUNK_BUDGET = 500;
+export const UNBATCHED_TOOL_SUBREQUESTS_PER_CHUNK_BUDGET = 200;
 // Fresh unbatched tool calls use one RUNTIME_API integration execute RPC and
 // one HARNESS durable-receipt completion RPC. Batch-cap rows by both.
 export const SUBREQUESTS_PER_UNBATCHED_TOOL_CALL = 2;

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/receipts.ts

@@ -27,8 +27,11 @@ type RuntimeReceiptContext = {
   receiptStore: WorkerRuntimeReceiptStore;
 };
 
-const WORKER_RECEIPT_WAIT_MAX_ATTEMPTS = 240;
+const WORKER_RECEIPT_DEFAULT_WAIT_MS = 300_000;
 const WORKER_RECEIPT_WAIT_DELAY_MS = 250;
+const WORKER_RECEIPT_WAIT_MAX_ATTEMPTS = Math.ceil(
+  WORKER_RECEIPT_DEFAULT_WAIT_MS / WORKER_RECEIPT_WAIT_DELAY_MS,
+);
 
 class RuntimeReceiptWaitTimeoutError extends Error {
   constructor(key: string) {

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/tool-receipts.ts

@@ -95,6 +95,60 @@ export function planWorkerToolReceiptGroups<TRequest>(
   };
 }
 
+export function resolveWorkerToolReceiptGroupWaitMaxAttempts<TRequest>(
+  requests: TRequest[],
+  getWaitMaxAttempts: (request: TRequest) => number,
+): number {
+  return requests.reduce((maxAttempts, request) => {
+    const attempts = getWaitMaxAttempts(request);
+    return Number.isFinite(attempts) && attempts > maxAttempts
+      ? attempts
+      : maxAttempts;
+  }, 1);
+}
+
+export type WorkerToolRuntimeTimeoutRequest = {
+  input: Record<string, unknown>;
+  runtimeTimeoutMs?: number;
+};
+
+export type WorkerToolRuntimeTimeoutClaim = {
+  request: WorkerToolRuntimeTimeoutRequest;
+  followers: WorkerToolRuntimeTimeoutRequest[];
+};
+
+export function resolveWorkerToolRuntimeTimeoutMs(
+  claimedRequests: WorkerToolRuntimeTimeoutClaim[],
+  input: {
+    resolveOwnerTimeoutMs: (
+      request: WorkerToolRuntimeTimeoutRequest,
+    ) => number | undefined;
+  },
+): number | undefined {
+  let timeoutMs = 0;
+  for (const claimed of claimedRequests) {
+    const ownerTimeoutMs = input.resolveOwnerTimeoutMs(claimed.request);
+    if (
+      typeof ownerTimeoutMs === 'number' &&
+      Number.isFinite(ownerTimeoutMs) &&
+      ownerTimeoutMs > timeoutMs
+    ) {
+      timeoutMs = ownerTimeoutMs;
+    }
+    for (const follower of claimed.followers) {
+      const followerTimeoutMs = follower.runtimeTimeoutMs;
+      if (
+        typeof followerTimeoutMs === 'number' &&
+        Number.isFinite(followerTimeoutMs) &&
+        followerTimeoutMs > timeoutMs
+      ) {
+        timeoutMs = followerTimeoutMs;
+      }
+    }
+  }
+  return timeoutMs > 0 ? timeoutMs : undefined;
+}
+
 export function markWorkerToolReceiptResultCached(
   value: unknown,
   cacheKey: string,

package/dist/bundling-sources/sdk/src/play.ts

@@ -300,6 +300,10 @@ export type ToolExecutionRequest = {
   force?: boolean;
   /** Numeric TTL in seconds for this tool checkpoint. */
   staleAfterSeconds?: number;
+  /** Runtime transport timeout in milliseconds. This is not sent to the provider. */
+  timeoutMs?: number;
+  /** Follower wait budget in milliseconds before a running receipt is reclaimable. */
+  receiptWaitMs?: number;
 };
 
 export type StepResolver<Row, Value> = (

package/dist/bundling-sources/sdk/src/release.ts

@@ -104,10 +104,10 @@ export const SDK_RELEASE = {
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
-  version: '0.1.169',
+  version: '0.1.171',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.169',
+    latest: '0.1.171',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -72,6 +72,7 @@ import {
 import {
   RuntimeReceiptWaitTimeoutError,
   executeWithDurableRuntimeReceipt,
+  resolveRuntimeToolReceiptWaitMaxAttempts,
   runtimeReceiptOutput as durableRuntimeReceiptOutput,
   waitForCompletedRuntimeReceipt,
   type DurableReceiptExecutionStore,
@@ -709,6 +710,8 @@ export class PlayContextImpl {
       description?: string;
       force?: boolean;
       staleAfterSeconds?: number;
+      timeoutMs?: number;
+      receiptWaitMs?: number;
     }): Promise<TOutput> => {
       if (!request || typeof request !== 'object' || Array.isArray(request)) {
         throw new Error(
@@ -735,7 +738,9 @@ export class PlayContextImpl {
         request.input,
         request.description ||
           request.force === true ||
-          request.staleAfterSeconds !== undefined
+          request.staleAfterSeconds !== undefined ||
+          request.timeoutMs !== undefined ||
+          request.receiptWaitMs !== undefined
           ? {
               ...(request.description
                 ? { description: request.description }
@@ -744,6 +749,12 @@ export class PlayContextImpl {
               ...(request.staleAfterSeconds !== undefined
                 ? { staleAfterSeconds: request.staleAfterSeconds }
                 : {}),
+              ...(request.timeoutMs !== undefined
+                ? { timeoutMs: request.timeoutMs }
+                : {}),
+              ...(request.receiptWaitMs !== undefined
+                ? { receiptWaitMs: request.receiptWaitMs }
+                : {}),
             }
           : undefined,
       ) as Promise<TOutput>;
@@ -1283,10 +1294,12 @@ export class PlayContextImpl {
 
   private async waitForCompletedRuntimeToolReceipt(
     key: string,
+    maxAttempts?: number,
   ): Promise<RuntimeStepReceipt> {
     return await waitForCompletedRuntimeReceipt({
       receiptKey: key,
       store: this.durableReceiptExecutionStore(),
+      maxAttempts,
     });
   }
 
@@ -1301,6 +1314,8 @@ export class PlayContextImpl {
       staleAfterSeconds?: number | null;
       repairRunningReceiptForSameRun?: boolean;
       repairRunningReceiptForSameRunAfterWaitTimeout?: boolean;
+      runningReceiptWaitMaxAttempts?: number;
+      runningReceiptWaitDelayMs?: number;
       reclaimRunning?: boolean;
       markSkipped?: (output: T) => Promise<void> | void;
       onRecovered?: (
@@ -1332,6 +1347,8 @@ export class PlayContextImpl {
       repairRunningReceiptForSameRun: opts.repairRunningReceiptForSameRun,
       repairRunningReceiptForSameRunAfterWaitTimeout:
         opts.repairRunningReceiptForSameRunAfterWaitTimeout,
+      runningReceiptWaitMaxAttempts: opts.runningReceiptWaitMaxAttempts,
+      runningReceiptWaitDelayMs: opts.runningReceiptWaitDelayMs,
       reclaimRunning: opts.reclaimRunning,
       markSkipped: opts.markSkipped,
       onRecovered: opts.onRecovered,
@@ -3449,7 +3466,9 @@ export class PlayContextImpl {
           });
         }
         this.log(`Calling tool: ${toolId}`);
-        const execution = await this.callToolExecutionAPI(toolId, input);
+        const execution = await this.callToolExecutionAPI(toolId, input, {
+          timeoutMs: options?.timeoutMs,
+        });
         const wrapped = await this.wrapToolExecutionResult({
           toolId,
           status: execution.status,
@@ -3535,6 +3554,12 @@ export class PlayContextImpl {
           fieldName,
           toolId,
           input,
+          ...(typeof options?.timeoutMs === 'number'
+            ? { timeoutMs: options.timeoutMs }
+            : {}),
+          ...(typeof options?.receiptWaitMs === 'number'
+            ? { receiptWaitMs: options.receiptWaitMs }
+            : {}),
           tableNamespace: store.tableNamespace,
           rowKey: store.rowKey ?? null,
           description: normalizeStepDescription(options?.description),
@@ -3573,6 +3598,11 @@ export class PlayContextImpl {
               receiptKey: durableCacheKey,
             }),
           ),
+        runningReceiptWaitMaxAttempts: resolveRuntimeToolReceiptWaitMaxAttempts(
+          typeof options?.receiptWaitMs === 'number'
+            ? { max_wait_ms: options.receiptWaitMs }
+            : input,
+        ),
         execute: executeTool,
       },
     );
@@ -3853,6 +3883,8 @@ export class PlayContextImpl {
           );
         },
         repairRunningReceiptForSameRunAfterWaitTimeout: true,
+        runningReceiptWaitMaxAttempts:
+          resolveRuntimeToolReceiptWaitMaxAttempts(input),
         execute: executePlayCall,
       },
     );
@@ -4334,6 +4366,49 @@ export class PlayContextImpl {
             await this.rejectToolCall(toolId, request, error);
           }
         };
+        const requestsWithLiveFollowers = (
+          owner: ToolCallRequest,
+        ): ToolCallRequest[] => [
+          owner,
+          ...(liveFollowersByOwnerCallId.get(owner.callId) ?? []),
+        ];
+        const resolveRuntimeTimeoutMsForRequests = (
+          requests: ToolCallRequest[],
+        ): number | undefined => {
+          const timeoutMs = Math.max(
+            ...requests
+              .map((request) => request.timeoutMs)
+              .filter(
+                (candidate): candidate is number =>
+                  typeof candidate === 'number' &&
+                  Number.isFinite(candidate) &&
+                  candidate > 0,
+              ),
+            0,
+          );
+          return timeoutMs > 0 ? timeoutMs : undefined;
+        };
+        const resolveRuntimeTimeoutMsForClaimedOwners = (
+          owners: ToolCallRequest[],
+        ): number | undefined => {
+          let timeoutMs = 0;
+          for (const owner of owners) {
+            if (
+              typeof owner.timeoutMs !== 'number' ||
+              !Number.isFinite(owner.timeoutMs) ||
+              owner.timeoutMs <= 0
+            ) {
+              return undefined;
+            }
+            timeoutMs = Math.max(
+              timeoutMs,
+              resolveRuntimeTimeoutMsForRequests(
+                requestsWithLiveFollowers(owner),
+              ) ?? 0,
+            );
+          }
+          return timeoutMs > 0 ? timeoutMs : undefined;
+        };
 
         const durableExistingRunningHandlers: Promise<void>[] = [];
         if (
@@ -4452,10 +4527,25 @@ export class PlayContextImpl {
             receiptKey: string,
             requestsForKey: ToolCallRequest[],
           ): Promise<void> => {
+            const waitMaxAttempts =
+              requestsForKey.length > 0
+                ? Math.max(
+                    ...requestsForKey.map((request) =>
+                      resolveRuntimeToolReceiptWaitMaxAttempts(
+                        typeof request.receiptWaitMs === 'number'
+                          ? { max_wait_ms: request.receiptWaitMs }
+                          : request.input,
+                      ),
+                    ),
+                  )
+                : undefined;
             try {
               await resolveRequestsFromReceipt(
                 requestsForKey,
-                await this.waitForCompletedRuntimeToolReceipt(receiptKey),
+                await this.waitForCompletedRuntimeToolReceipt(
+                  receiptKey,
+                  waitMaxAttempts,
+                ),
                 'in_flight',
               );
               return;
@@ -4511,6 +4601,9 @@ export class PlayContextImpl {
                 const execution = await this.callToolExecutionAPI(
                   toolId,
                   owner.input,
+                  {
+                    timeoutMs: resolveRuntimeTimeoutMsForClaimedOwners([owner]),
+                  },
                 );
                 const result = await this.resolveToolCall(
                   toolId,
@@ -4619,6 +4712,11 @@ export class PlayContextImpl {
                 await this.callToolAPI(
                   batch.batchOperation,
                   batch.batchPayload,
+                  {
+                    timeoutMs: resolveRuntimeTimeoutMsForClaimedOwners(
+                      batch.memberRequests,
+                    ),
+                  },
                 ),
               onChunkComplete: async (chunkResults) => {
                 for (const entry of chunkResults) {
@@ -4674,6 +4772,11 @@ export class PlayContextImpl {
                     const execution = await this.callToolExecutionAPI(
                       toolId,
                       request.input,
+                      {
+                        timeoutMs: resolveRuntimeTimeoutMsForClaimedOwners([
+                          request,
+                        ]),
+                      },
                     );
                     const result = await this.resolveToolCall(
                       toolId,
@@ -4778,8 +4881,9 @@ export class PlayContextImpl {
   private async callToolAPI(
     toolId: string,
     input: Record<string, unknown>,
+    options?: { timeoutMs?: number },
   ): Promise<unknown> {
-    const execution = await this.callToolExecutionAPI(toolId, input);
+    const execution = await this.callToolExecutionAPI(toolId, input, options);
     if (execution.toolResponse && 'raw' in execution.toolResponse) {
       return execution.toolResponse.raw;
     }
@@ -4794,6 +4898,7 @@ export class PlayContextImpl {
   private async callToolExecutionAPI(
     toolId: string,
     input: Record<string, unknown>,
+    options?: { timeoutMs?: number },
   ): Promise<ParsedToolExecuteResponse> {
     if (!this.#options.executorToken || !this.#options.baseUrl) {
       throw new Error(
@@ -4801,6 +4906,11 @@ export class PlayContextImpl {
       );
     }
     const url = `${this.#options.baseUrl}/api/v2/integrations/${encodeURIComponent(toolId)}/execute`;
+    const timeoutMs =
+      typeof options?.timeoutMs === 'number' &&
+      Number.isFinite(options.timeoutMs)
+        ? Math.max(1, Math.ceil(options.timeoutMs))
+        : undefined;
 
     // The Governor's tool slot is the single seam for tool-call budget + the
     // global tool-concurrency backstop + per-(org, provider) pacing. It blocks
@@ -4831,9 +4941,20 @@ export class PlayContextImpl {
 
           while (true) {
             let response: Response;
+            const abortController = timeoutMs ? new AbortController() : null;
+            const timeoutHandle = timeoutMs
+              ? setTimeout(() => {
+                  abortController?.abort(
+                    new Error(
+                      `Tool ${toolId} runtime API call timed out after ${timeoutMs}ms.`,
+                    ),
+                  );
+                }, timeoutMs)
+              : null;
             try {
               response = await fetch(url, {
                 method: 'POST',
+                signal: abortController?.signal,
                 headers: {
                   'Content-Type': 'application/json',
                   Authorization: `Bearer ${this.#options.executorToken}`,
@@ -4856,6 +4977,13 @@ export class PlayContextImpl {
                 }),
               });
             } catch (error) {
+              if (abortController?.signal.aborted) {
+                throw abortController.signal.reason instanceof Error
+                  ? abortController.signal.reason
+                  : new Error(
+                      `Tool ${toolId} runtime API call timed out after ${timeoutMs}ms.`,
+                    );
+              }
               transportAttempt += 1;
               const message =
                 error instanceof Error ? error.message : String(error);
@@ -4876,6 +5004,10 @@ export class PlayContextImpl {
               throw new Error(
                 `Tool ${toolId} transport failed calling ${url} after ${transportAttempt}/${TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS} attempts: ${message}`,
               );
+            } finally {
+              if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+              }
             }
 
             span.setAttribute('plays.http_status_code', response.status);