deepline 0.1.168 → 0.1.170

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,7 @@ export class PlayContextImpl {
       staleAfterSeconds?: number | null;
       repairRunningReceiptForSameRun?: boolean;
       repairRunningReceiptForSameRunAfterWaitTimeout?: boolean;
+      runningReceiptWaitMaxAttempts?: number;
       reclaimRunning?: boolean;
       markSkipped?: (output: T) => Promise<void> | void;
       onRecovered?: (
@@ -1332,6 +1346,7 @@ export class PlayContextImpl {
       repairRunningReceiptForSameRun: opts.repairRunningReceiptForSameRun,
       repairRunningReceiptForSameRunAfterWaitTimeout:
         opts.repairRunningReceiptForSameRunAfterWaitTimeout,
+      runningReceiptWaitMaxAttempts: opts.runningReceiptWaitMaxAttempts,
       reclaimRunning: opts.reclaimRunning,
       markSkipped: opts.markSkipped,
       onRecovered: opts.onRecovered,
@@ -3449,7 +3464,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 +3552,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 +3596,11 @@ export class PlayContextImpl {
               receiptKey: durableCacheKey,
             }),
           ),
+        runningReceiptWaitMaxAttempts: resolveRuntimeToolReceiptWaitMaxAttempts(
+          typeof options?.receiptWaitMs === 'number'
+            ? { max_wait_ms: options.receiptWaitMs }
+            : input,
+        ),
         execute: executeTool,
       },
     );
@@ -4334,6 +4362,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 +4523,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 +4597,9 @@ export class PlayContextImpl {
                 const execution = await this.callToolExecutionAPI(
                   toolId,
                   owner.input,
+                  {
+                    timeoutMs: resolveRuntimeTimeoutMsForClaimedOwners([owner]),
+                  },
                 );
                 const result = await this.resolveToolCall(
                   toolId,
@@ -4619,6 +4708,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 +4768,11 @@ export class PlayContextImpl {
                     const execution = await this.callToolExecutionAPI(
                       toolId,
                       request.input,
+                      {
+                        timeoutMs: resolveRuntimeTimeoutMsForClaimedOwners([
+                          request,
+                        ]),
+                      },
                     );
                     const result = await this.resolveToolCall(
                       toolId,
@@ -4778,8 +4877,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 +4894,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 +4902,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 +4937,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}`,
@@ -4850,9 +4967,19 @@ export class PlayContextImpl {
                 body: JSON.stringify({
                   payload: input,
                   metadata: { parent_run_id: this.#options.runId },
+                  ...(this.#options.integrationMode
+                    ? { integration_mode: this.#options.integrationMode }
+                    : {}),
                 }),
               });
             } 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);
@@ -4873,6 +5000,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);

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -28,6 +28,8 @@ export interface ToolCallRequest {
   fieldName?: string;
   toolId: string;
   input: Record<string, unknown>;
+  timeoutMs?: number;
+  receiptWaitMs?: number;
   tableNamespace?: string;
   rowKey?: string | null;
   description?: string;
@@ -169,6 +171,8 @@ export interface ToolCallOptions {
   description?: string;
   force?: boolean;
   staleAfterSeconds?: number;
+  timeoutMs?: number;
+  receiptWaitMs?: number;
 }
 
 export interface ToolExecutionRequest {
@@ -178,6 +182,8 @@ export interface ToolExecutionRequest {
   description?: string;
   force?: boolean;
   staleAfterSeconds?: number;
+  timeoutMs?: number;
+  receiptWaitMs?: number;
 }
 
 export type SqlQuery = {
@@ -388,6 +394,8 @@ export interface ContextOptions {
   executorToken?: string;
   baseUrl?: string;
   vercelProtectionBypassToken?: string | null;
+  /** Optional per-run integration execution mode for provider calls. */
+  integrationMode?: 'live' | 'eval_stub' | 'fixture';
   orgId?: string;
   userEmail?: string;
   playName?: string;
@@ -451,9 +459,7 @@ export interface ContextOptions {
   getToolRetryPolicy?: (toolId: string) => Promise<{
     retrySafeTransientHttp?: boolean;
   } | null>;
-  getToolActionCacheVersion?: (
-    toolId: string,
-  ) => Promise<string> | string;
+  getToolActionCacheVersion?: (toolId: string) => Promise<string> | string;
   getToolTargetGetters?: (
     toolId: string,
     output: string,

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

@@ -14,6 +14,7 @@ export interface PlayRunnerContextConfig {
   executorToken?: string;
   baseUrl?: string;
   vercelProtectionBypassToken?: string | null;
+  integrationMode?: 'live' | 'eval_stub' | 'fixture';
   orgId?: string;
   workflowId?: string;
   playId?: string;

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

@@ -83,6 +83,7 @@ type RuntimeApiContext = {
   playName?: string | null;
   runId?: string | null;
   userEmail?: string | null;
+  integrationMode?: 'live' | 'eval_stub' | 'fixture' | null;
   dbSessionStrategy?: 'preloaded' | 'sandbox_public_key' | null;
   preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
   vercelProtectionBypassToken?: string | null;
@@ -1512,6 +1513,7 @@ function mapRuntimeWorkReceiptRow(raw: Record<string, unknown>): WorkReceipt {
     output: raw.output == null ? null : raw.output,
     error: raw.error == null ? null : String(raw.error),
     runId: raw.run_id == null ? null : String(raw.run_id),
+    updatedAt: raw.updated_at == null ? null : String(raw.updated_at),
   };
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backend.ts

@@ -124,6 +124,8 @@ export type PlaySchedulerSubmitInput = {
   dynamicWorkerCode?: string | null;
   executorToken: string;
   baseUrl: string;
+  /** Optional per-run provider execution mode. Defaults to server policy when omitted. */
+  integrationMode?: 'live' | 'eval_stub' | 'fixture';
   orgId: string;
   userEmail: string;
   userId?: string | null;

package/dist/bundling-sources/shared_libs/play-runtime/work-receipts.ts

@@ -11,6 +11,7 @@ export type WorkReceipt = {
   output?: unknown;
   error?: string | null;
   runId?: string | null;
+  updatedAt?: string | null;
 };
 
 export type WorkReceiptCommand = {