deepline 0.3.74 → 0.3.75

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

@@ -175,7 +175,7 @@ import {
   buildDurableToolCallCacheKey,
   buildLegacyRevisionedDurableToolCallCacheKey,
   buildDurableToolPayloadProviderIdempotencyKey,
-  buildDurableToolProviderIdempotencyKey,
+  buildProviderOperationIdempotencyKey,
   buildDurableToolReceiptPrefix,
   resolveDurableCallCachePolicy,
 } from './durable-call-cache';
@@ -219,11 +219,7 @@ import {
   type DurableReceiptExecutionStore,
 } from './durable-receipt-execution';
 import {
-  asyncOperationDurableStartInput,
   asyncOperationShouldWait,
-  classifyAsyncOperationResult,
-  executeAsyncOperationLifecycle,
-  resolveAsyncOperationPolling,
   type AsyncOperationContractWire,
 } from './async-operation';
 import {
@@ -1248,27 +1244,6 @@ function publicToolResponseEnvelope(value: unknown): {
   };
 }
 
-function materializedAsyncToolResponse(
-  response: ParsedToolExecuteResponse['toolResponse'] | undefined,
-  result: unknown,
-): ParsedToolExecuteResponse['toolResponse'] {
-  const hasRawV2 =
-    response !== undefined &&
-    Object.prototype.hasOwnProperty.call(response, 'rawV2');
-  const materializedRawV2 =
-    response?.view === 'data'
-      ? {
-          ...(recordOrNull(response.rawV2) ?? {}),
-          data: result,
-        }
-      : result;
-  return {
-    ...(response ?? {}),
-    raw: result,
-    ...(hasRawV2 ? { rawV2: materializedRawV2 } : {}),
-  };
-}
-
 /**
  * A batched provider request returns one envelope for several logical source
  * tool calls. Each source call persists only its own item-shaped canonical
@@ -1398,13 +1373,11 @@ type ToolExecutionApiOptions = {
   /** The receipt key is a completed-result cache for this read-only call. */
   completedResultCache?: boolean;
   executionAuthScopeDigest?: string | null;
-  /**
-   * Historical receipt identity used for the API's provider/billing
-   * idempotency receipt. This can differ from the worker-owned durable cache
-   * receipt while a response contract migrates.
-   */
-  providerIdempotencyReceiptKey?: string | null;
   providerIdempotencyKey?: string | null;
+  /** Exact forced-member identities that participate in a native batch key. */
+  providerOperationForceRefreshIdentities?: readonly string[];
+  /** Presentation-only cache identity paired with a separate execution fence. */
+  providerIdempotencyReceiptKey?: string | null;
   receiptLeaseExpiresAt?: string | null;
   beforeProviderCall?: () => Promise<void> | void;
   heartbeatReceipt?: () => Promise<void> | void;
@@ -1429,6 +1402,13 @@ type ToolExecutionApiOptions = {
   };
   /** Internal recursion guard for lifecycle poll/finish calls. */
   skipAsyncOperationResolution?: boolean;
+  /**
+   * A status/result request belonging to a live async lifecycle. It must not
+   * create a result receipt or provider idempotency identity from a parent
+   * cache entry: the job handle is process-local, while the outer tool-call
+   * cache stores only its terminal materialized output.
+   */
+  uncachedAsyncLifecycleCall?: boolean;
 };
 const IN_MEMORY_STEP_RESULT_PREVIEW_LIMIT = 25;
 /**
@@ -2109,10 +2089,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     string,
     { resolve: (value: unknown) => void; reject: (reason: unknown) => void }
   >();
-  private readonly asyncOperationCapacity = new Map<
-    string,
-    { active: number; waiters: Array<() => void> }
-  >();
   #options: ContextOptions;
   private readonly rootRuntimeContract: PlayArtifactRuntimeContract;
   private readonly executionScope: RunExecutionScope;
@@ -2160,6 +2136,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     boundaryId: string;
     eventKey: string;
     timeoutMs: number;
+    messageRef?: { channel: string; ts: string };
   }> = [];
   private processedRowCount = 0;
   private sleepBoundaryIndex = 0;
@@ -9388,9 +9365,18 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       executionAuthScopeDigest,
       staleAfterSeconds: toolCachePolicy.staleAfterSeconds,
     });
-    // Only explicitly fenced operations use this key as a provider identity.
-    // Ordinary calls use it solely as their completed-result cache key.
-    let providerIdempotencyKeyBase = durableCacheKey;
+    const providerActionVersion =
+      (await this.#options.getToolActionCacheVersion?.(toolId))?.trim() ?? '';
+    // A provider operation is keyed by its requested semantic payload. The
+    // durable receipt below remains a completed-result cache only.
+    let providerIdempotencyKeyBase =
+      buildDurableToolPayloadProviderIdempotencyKey({
+        orgId: this.#options.orgId,
+        toolId,
+        executionAuthScopeDigest,
+        providerActionVersion,
+        payload: input,
+      });
     let directResultReceiptKey = durableCacheKey;
     // A raw-v2 artifact must never read an older receipt that cannot render
     // raw-v2. If both the primary and its revisioned recovery receipt are
@@ -9670,17 +9656,16 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   ...(toolRetryPolicy?.requiresExecutionFence === true
                     ? {
                         providerIdempotencyReceiptKey:
-                          cacheableToolResult && operationKey
-                            ? operationKey
+                          cacheableToolResult && resultReceiptKey
+                            ? resultReceiptKey
                             : physicalDirectKey,
                         providerIdempotencyKey:
                           this.providerIdempotencyKeyForToolCall({
-                            cacheKey:
+                            operationKey:
                               useDirectResultReceipts && operationKey
                                 ? providerIdempotencyKeyBase
                                 : physicalDirectKey,
                             force: cacheableToolResult && toolCachePolicy.force,
-                            leaseId: directReceiptLeaseId,
                             logicalCallId,
                           }),
                       }
@@ -9762,9 +9747,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 dispatcher,
               })
             : null;
-          const providerActionVersion =
-            (await this.#options.getToolActionCacheVersion?.(toolId))?.trim() ??
-            '';
           const call: Omit<ToolCallInput, 'compatibility'> = {
             scope: {
               organizationId: this.#options.orgId ?? 'unknown-org',
@@ -9993,7 +9975,14 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           executionAuthScopeDigest,
           staleAfterSeconds: toolCachePolicy.staleAfterSeconds,
         });
-        providerIdempotencyKeyBase = durableCacheKey;
+        providerIdempotencyKeyBase =
+          buildDurableToolPayloadProviderIdempotencyKey({
+            orgId: this.#options.orgId,
+            toolId,
+            executionAuthScopeDigest,
+            providerActionVersion,
+            payload: input,
+          });
         directResultReceiptKey = durableCacheKey;
         bypassDirectResultCache = false;
         checkpointCacheKeys.splice(
@@ -10048,6 +10037,21 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     const existing =
       this.checkpoint.resolvedBoundaries?.[preparedBoundary.boundaryId];
     if (existing?.kind === 'integration_event' && 'output' in existing) {
+      const output = recordOrNull(existing.output);
+      if (output?.timed_out === true) {
+        await handler.onTimeout?.({
+          payload: input,
+          context: eventContext,
+          boundary: {
+            boundaryId: preparedBoundary.boundaryId,
+            eventKey: preparedBoundary.eventKey,
+            timeoutMs: preparedBoundary.timeoutMs,
+            provider: existing.provider ?? handler.provider,
+            toolId: existing.toolId ?? handler.toolId,
+            ...(existing.messageRef ? { messageRef: existing.messageRef } : {}),
+          },
+        });
+      }
       this.runtimeLog(
         `Integration event ${preparedBoundary.boundaryId}: recovered response from checkpoint`,
       );
@@ -10103,6 +10107,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         boundaryId: boundary.boundaryId,
         eventKey: boundary.eventKey,
         timeoutMs: boundary.timeoutMs,
+        ...(boundary.messageRef ? { messageRef: boundary.messageRef } : {}),
       });
     }
 
@@ -10111,6 +10116,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       boundaryId: boundary.boundaryId,
       eventKey: boundary.eventKey,
       timeoutMs: boundary.timeoutMs,
+      ...(boundary.messageRef ? { messageRef: boundary.messageRef } : {}),
     });
   }
 
@@ -12589,7 +12595,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                       dispatchPayload: owner.input,
                       resultReceiptKey: receiptKey,
                       providerOperationKey:
-                        owner.providerIdempotencyKeyBase ?? owner.cacheKey,
+                        this.providerOperationKeyForQueuedToolCall(owner),
                       apiOptions: {
                         beforeProviderCall: () =>
                           this.assertRuntimeToolReceiptOwnership([owner]),
@@ -12597,18 +12603,14 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                         playNodeScope: playNodeScopeForToolCallRequest(owner),
                         executionAuthScopeDigest:
                           owner.executionAuthScopeDigest,
-                        providerIdempotencyReceiptKey:
-                          owner.providerIdempotencyKeyBase ?? owner.cacheKey,
                         receiptLeaseExpiresAt: owner.receiptLeaseExpiresAt,
                         heartbeatReceipt: () =>
                           this.renewRuntimeToolReceiptOwnership([owner]),
                         providerIdempotencyKey:
                           this.providerIdempotencyKeyForToolCall({
-                            cacheKey:
-                              owner.providerIdempotencyKeyBase ??
-                              owner.cacheKey,
+                            operationKey:
+                              this.providerOperationKeyForQueuedToolCall(owner),
                             force: owner.force === true,
-                            leaseId: owner.receiptLeaseId,
                             logicalCallId: owner.logicalCallId,
                           }),
                         timeoutMs: resolveRuntimeTimeoutMsForClaimedOwners([
@@ -12942,7 +12944,17 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                         toolId: batch.batchOperation,
                       }),
                     });
-                  const aggregateProviderIdempotencyReceiptKey =
+                  const aggregateForceRefreshIdentities = batch.memberRequests
+                    .filter((request) => request.force === true)
+                    .map((request) =>
+                      this.providerIdempotencyKeyForToolCall({
+                        operationKey:
+                          this.providerOperationKeyForQueuedToolCall(request),
+                        force: true,
+                        logicalCallId: request.logicalCallId,
+                      }),
+                    );
+                  const aggregateProviderOperationKey =
                     buildDurableToolPayloadProviderIdempotencyKey({
                       orgId: this.#options.orgId,
                       toolId: batch.batchOperation,
@@ -12956,18 +12968,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                           )
                         )?.trim() ?? 'unversioned',
                       payload: batch.batchPayload,
-                      forceRefreshIdentities: batch.memberRequests
-                        .filter((request) => request.force === true)
-                        .map((request) =>
-                          this.providerIdempotencyKeyForToolCall({
-                            cacheKey:
-                              request.providerIdempotencyKeyBase ??
-                              request.cacheKey,
-                            force: true,
-                            leaseId: request.receiptLeaseId,
-                            logicalCallId: request.logicalCallId,
-                          }),
-                        ),
+                      forceRefreshIdentities: aggregateForceRefreshIdentities,
                     });
                   let releaseToolSlot: () => void = () => undefined;
                   try {
@@ -12977,8 +12978,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                         dispatchToolId: batch.batchOperation,
                         dispatchPayload: batch.batchPayload,
                         resultReceiptKey: aggregateReceiptKey,
-                        providerOperationKey:
-                          aggregateProviderIdempotencyReceiptKey,
+                        providerOperationKey: aggregateProviderOperationKey,
                         apiOptions: {
                           durableCallReceiptKey: aggregateReceiptKey,
                           // A native batch is one physical provider request for
@@ -12991,10 +12991,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                           executionAuthScopeDigest:
                             batch.memberRequests[0]?.executionAuthScopeDigest ??
                             null,
-                          providerIdempotencyReceiptKey:
-                            aggregateProviderIdempotencyReceiptKey,
-                          providerIdempotencyKey:
-                            aggregateProviderIdempotencyReceiptKey,
+                          providerIdempotencyKey: aggregateProviderOperationKey,
+                          providerOperationForceRefreshIdentities:
+                            aggregateForceRefreshIdentities,
                           receiptLeaseExpiresAt: batch.memberRequests.reduce<
                             string | null
                           >((earliest, request) => {
@@ -13197,15 +13196,13 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                         request,
                         dispatchToolId: toolId,
                         dispatchPayload: request.input,
-                        // Always-fresh map calls intentionally have no durable
-                        // receipt or provider idempotency header. Their cache
-                        // key is only a local ToolCall contract identity.
+                        // Always-fresh map calls intentionally have no
+                        // result cache. Their provider-operation identity is
+                        // a unique forced semantic request, never a cache key.
                         resultReceiptKey:
                           request.receiptKey ?? request.cacheKey,
                         providerOperationKey:
-                          request.providerIdempotencyKeyBase ??
-                          request.receiptKey ??
-                          request.cacheKey,
+                          this.providerOperationKeyForQueuedToolCall(request),
                         apiOptions: {
                           beforeProviderCall: () =>
                             pendingReceiptHeartbeat
@@ -13221,16 +13218,13 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                                 completedResultCache: true,
                                 executionAuthScopeDigest:
                                   request.executionAuthScopeDigest,
-                                providerIdempotencyReceiptKey:
-                                  request.providerIdempotencyKeyBase ??
-                                  request.receiptKey,
                                 providerIdempotencyKey:
                                   this.providerIdempotencyKeyForToolCall({
-                                    cacheKey:
-                                      request.providerIdempotencyKeyBase ??
-                                      request.receiptKey,
+                                    operationKey:
+                                      this.providerOperationKeyForQueuedToolCall(
+                                        request,
+                                      ),
                                     force: request.force === true,
-                                    leaseId: request.receiptLeaseId,
                                     logicalCallId: request.logicalCallId,
                                   }),
                                 receiptLeaseExpiresAt:
@@ -13240,7 +13234,17 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                                     request,
                                   ]),
                               }
-                            : {}),
+                            : {
+                                providerIdempotencyKey:
+                                  this.providerIdempotencyKeyForToolCall({
+                                    operationKey:
+                                      this.providerOperationKeyForQueuedToolCall(
+                                        request,
+                                      ),
+                                    force: true,
+                                    logicalCallId: request.logicalCallId,
+                                  }),
+                              }),
                           timeoutMs: resolveRuntimeTimeoutMsForClaimedOwners([
                             request,
                           ]),
@@ -13383,173 +13387,36 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
   }
 
   private providerIdempotencyKeyForToolCall(input: {
-    cacheKey: string;
+    operationKey: string;
     force?: boolean;
-    leaseId?: string | null;
     logicalCallId?: string;
   }): string {
     let fallbackAttemptId: string | null = null;
-    if (input.force === true && !input.leaseId) {
+    if (input.force === true) {
       if (!input.logicalCallId) {
         throw new Error(
-          'Forced tool execution without a receipt lease requires a stable logical call identity.',
+          'Forced tool execution requires a stable logical call identity.',
         );
       }
       fallbackAttemptId = `${this.currentRunId}:${input.logicalCallId}`;
     }
-    return buildDurableToolProviderIdempotencyKey({
-      receiptKey: input.cacheKey,
+    return buildProviderOperationIdempotencyKey({
+      operationKey: input.operationKey,
       force: input.force,
-      receiptLeaseId: input.leaseId,
       fallbackAttemptId,
     });
   }
 
-  private async acquireAsyncOperationCapacity(input: {
-    toolId: string;
-    provider: string;
-    contract: AsyncOperationContractWire;
-    authScopeDigest: string | null;
-  }): Promise<() => void> {
-    const scopeSuffix =
-      input.contract.capacity.scope === 'organization_action'
-        ? input.toolId
-        : input.contract.capacity.scope === 'organization_connection'
-          ? (input.authScopeDigest ?? 'default-connection')
-          : input.provider;
-    const key = `${this.#options.orgId ?? 'unknown-org'}:${input.provider}:${input.contract.capacity.scope}:${scopeSuffix}`;
-    let limit = 1;
-    if (input.contract.capacity.limit.kind === 'fixed') {
-      limit = input.contract.capacity.limit.maxConcurrentJobs;
-    } else {
-      const hints =
-        (await this.#options.getToolQueueHints?.(input.toolId)) ?? [];
-      const declaredLimits = hints
-        .map((hint) => hint.maxConcurrency)
-        .filter(
-          (value): value is number =>
-            typeof value === 'number' && Number.isFinite(value) && value > 0,
-        );
-      limit = declaredLimits.length > 0 ? Math.min(...declaredLimits) : 1;
-    }
-    const state = this.asyncOperationCapacity.get(key) ?? {
-      active: 0,
-      waiters: [],
-    };
-    this.asyncOperationCapacity.set(key, state);
-    if (state.active >= limit) {
-      if (input.contract.capacity.onConflict === 'fail') {
-        throw new Error(
-          `Async provider capacity is full for ${input.provider}; the contract allows ${limit} active job(s).`,
-        );
-      }
-      await new Promise<void>((resolve) => state.waiters.push(resolve));
-    }
-    state.active += 1;
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      state.active = Math.max(0, state.active - 1);
-      state.waiters.shift()?.();
-      if (state.active === 0 && state.waiters.length === 0) {
-        this.asyncOperationCapacity.delete(key);
-      }
-    };
-  }
-
-  private asyncOperationActionReceiptKey(input: {
-    action: string;
-    parentReceiptKey: string | null;
-    jobId: string;
-    phase: string;
-  }): string | null {
-    if (!input.parentReceiptKey) return null;
-    return `${buildDurableToolReceiptPrefix({
-      orgId: this.#options.orgId,
-      toolId: input.action,
-    })}${stableDigest(
-      stableStringify({
-        parentReceiptKey: input.parentReceiptKey,
-        jobId: input.jobId,
-        phase: input.phase,
-      }),
-    )}`;
-  }
-
-  private async resolveAsyncOperation(input: {
-    toolId: string;
-    startInput: Record<string, unknown>;
-    startResponse: ParsedToolExecuteResponse;
-    contract: AsyncOperationContractWire;
-    receiptKey: string | null;
-  }): Promise<ParsedToolExecuteResponse> {
-    const responseValue = (response: ParsedToolExecuteResponse): unknown => {
-      if (response.toolResponse && 'raw' in response.toolResponse) {
-        return response.toolResponse.raw;
-      }
-      const result = recordOrNull(response.result);
-      return result && Object.prototype.hasOwnProperty.call(result, 'data')
-        ? result.data
-        : response.result;
-    };
-    const startResult = responseValue(input.startResponse);
-    const lifecycle = await executeAsyncOperationLifecycle({
-      contract: input.contract,
-      startInput: input.startInput,
-      startResult,
-      jobId: input.startResponse.jobId,
-      sleep: async (delayMs) =>
-        await this.sleepWithCheckpointHeartbeat(delayMs),
-      responseValue,
-      executeAction: async (request) => {
-        const receiptKey = this.asyncOperationActionReceiptKey({
-          action: request.action,
-          parentReceiptKey: input.receiptKey,
-          jobId: request.jobId,
-          phase: `${request.phase}:${request.pollAttempt}:${request.page ?? ''}`,
-        });
-        return await this.callToolExecutionAPI(request.action, request.input, {
-          skipAsyncOperationResolution: true,
-          durableCallReceiptKey: receiptKey,
-          providerIdempotencyReceiptKey: receiptKey,
-          providerIdempotencyKey: receiptKey,
-        });
-      },
-    });
-    if (lifecycle.kind === 'timed_out') {
-      const polling = resolveAsyncOperationPolling({
-        contract: input.contract,
-        startInput: input.startInput,
-      });
-      throw new Error(
-        `Async operation ${input.toolId} (${lifecycle.jobId}) did not reach a terminal state within ${polling.timeoutMs}ms.`,
-      );
-    }
-    if (
-      lifecycle.classification.outcome === 'failed' ||
-      lifecycle.classification.outcome === 'cancelled'
-    ) {
+  private providerOperationKeyForQueuedToolCall(
+    request: ToolCallRequest,
+  ): string {
+    const operationKey = request.providerIdempotencyKeyBase?.trim();
+    if (!operationKey) {
       throw new Error(
-        lifecycle.classification.message ??
-          `Async operation ${input.toolId} (${lifecycle.jobId}) ended ${lifecycle.classification.outcome}.`,
+        `Queued tool call ${request.callId} is missing its semantic provider operation identity.`,
       );
     }
-    const materialized = lifecycle.materialized!;
-    const selectedResponse = lifecycle.finishResponse ?? lifecycle.pollResponse;
-    return {
-      ...selectedResponse,
-      status:
-        lifecycle.classification.outcome === 'no_result' ||
-        materialized.outcome === 'no_result'
-          ? 'no_result'
-          : 'completed',
-      result: { data: materialized.result },
-      toolResponse: materializedAsyncToolResponse(
-        selectedResponse.toolResponse,
-        materialized.result,
-      ),
-    };
+    return operationKey;
   }
 
   private async callToolExecutionAPI(
@@ -13565,7 +13432,29 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     const requestsDurableInvocationFence =
       this.#options.requestDurableInvocationFence === true ||
       this.#options.durableInvocationFence === true;
-    const executeSuffix = requestsDurableInvocationFence
+    const asyncContract = options?.skipAsyncOperationResolution
+      ? null
+      : ((await this.#options.getToolAsyncOperation?.(toolId)) ?? null);
+    const shouldWaitForAsyncOperation = Boolean(
+      asyncContract && asyncOperationShouldWait(asyncContract, input),
+    );
+    const executionAuthScopeDigest = options?.executionAuthScopeDigest
+      ? options.executionAuthScopeDigest.trim() || null
+      : ((await this.resolveToolAuthScopeDigest(toolId))?.trim() ?? null);
+    const provider =
+      (await this.#options.getToolProvider?.(toolId))?.trim() ||
+      toolId.split(/[._]/)[0]?.trim() ||
+      'provider';
+    // A receipt is a terminal-output cache, never an async provider-job
+    // record. Launch/poll/finish transport must therefore remain receiptless:
+    // if this process stops, a later cache miss starts a new provider request
+    // rather than attaching itself to this one.
+    const uncachedAsyncLifecycleCall =
+      options?.uncachedAsyncLifecycleCall === true ||
+      shouldWaitForAsyncOperation;
+    const usesDurableInvocationFence =
+      requestsDurableInvocationFence && !uncachedAsyncLifecycleCall;
+    const executeSuffix = usesDurableInvocationFence
       ? 'execute-fenced-v1'
       : 'execute';
     // Keep receipts, runner heartbeats, terminals, sheets, and runtime control
@@ -13580,17 +13469,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       options?.timeoutMs,
       this.currentAuthoringContractEdition,
     );
-    const provider = toolId.split(/[._]/)[0]?.trim() || 'provider';
-    const asyncContract = options?.skipAsyncOperationResolution
-      ? null
-      : ((await this.#options.getToolAsyncOperation?.(toolId)) ?? null);
-    const shouldWaitForAsyncOperation = Boolean(
-      asyncContract && asyncOperationShouldWait(asyncContract, input),
-    );
-    const effectiveInput =
-      asyncContract && shouldWaitForAsyncOperation
-        ? asyncOperationDurableStartInput(asyncContract, input)
-        : input;
     const activityId = `provider:${toolId}`;
     let retryActivityEmitted = false;
     let toolCallSucceeded = false;
@@ -13599,16 +13477,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     // execution. Per-provider rate admission is intentionally deferred until
     // each physical fetch is ready to leave this process.
     const admissionStartedAt = Date.now();
-    const asyncCapacityRelease =
-      asyncContract && shouldWaitForAsyncOperation
-        ? await this.acquireAsyncOperationCapacity({
-            toolId,
-            provider,
-            contract: asyncContract,
-            authScopeDigest:
-              (await this.resolveToolAuthScopeDigest(toolId))?.trim() ?? null,
-          })
-        : null;
     let toolSlot: RuntimeResourceLease;
     try {
       toolSlot = await this.resourceGovernor.acquireTool({
@@ -13617,7 +13485,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         toolId,
       });
     } catch (error) {
-      asyncCapacityRelease?.();
       if (!(error instanceof ProviderExhaustedError)) throw error;
       const retryAtMs = Date.parse(error.retryAt);
       throw createToolHttpError(
@@ -13673,9 +13540,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           // Snapshot the caller-controlled payload exactly once. The replay
           // decision and every physical attempt must refer to the same bytes,
           // even if the original object has getters or is later mutated.
-          const toolInputSnapshot = JSON.parse(
-            JSON.stringify(effectiveInput),
-          ) as Record<string, unknown>;
+          const toolInputSnapshot = JSON.parse(JSON.stringify(input)) as Record<
+            string,
+            unknown
+          >;
           const retryPolicy = await this.#options
             .getToolRetryPolicy?.(toolId, toolInputSnapshot)
             .catch(() => null);
@@ -13695,19 +13563,17 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           const ambiguousTransportReplayAllowed =
             readOnlyQuery || retrySafeTransientHttp;
           const invocationOrgId = this.#options.orgId?.trim() ?? '';
-          const durableCallReceiptKey =
-            options?.durableCallReceiptKey?.trim() ||
-            (requestsDurableInvocationFence && invocationOrgId
-              ? `${buildDurableToolReceiptPrefix({
-                  orgId: invocationOrgId,
-                  toolId,
-                })}${stableDigest(
-                  `transport:${this.currentRunId}:${toolId}:${crypto.randomUUID()}`,
-                )}`
-              : null);
-          const executionAuthScopeDigest = options?.executionAuthScopeDigest
-            ? options.executionAuthScopeDigest.trim() || null
-            : ((await this.resolveToolAuthScopeDigest(toolId))?.trim() ?? null);
+          const durableCallReceiptKey = uncachedAsyncLifecycleCall
+            ? null
+            : options?.durableCallReceiptKey?.trim() ||
+              (usesDurableInvocationFence && invocationOrgId
+                ? `${buildDurableToolReceiptPrefix({
+                    orgId: invocationOrgId,
+                    toolId,
+                  })}${stableDigest(
+                    `transport:${this.currentRunId}:${toolId}:${crypto.randomUUID()}`,
+                  )}`
+                : null);
           const executionRequestNonce = crypto.randomUUID();
           // This identifies one logical tool call to billing. Physical retry
           // count remains in request metadata, so a transport retry cannot
@@ -13727,6 +13593,29 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               `Tool ${toolId} requires a provider execution fence but no provider operation identity was supplied.`,
             );
           }
+          const canonicalOperationActionVersion = providerExecutionFenceKey
+            ? (
+                await this.#options.getToolActionCacheVersion?.(toolId)
+              )?.trim() || null
+            : null;
+          const canonicalOperation =
+            providerExecutionFenceKey && canonicalOperationActionVersion
+              ? {
+                  version: 1,
+                  tool_id: toolId,
+                  action_version: canonicalOperationActionVersion,
+                  play_scope: this.currentGovernance.currentPlayId || 'play',
+                  output_intent: options?.completedResultCache
+                    ? 'dataset'
+                    : 'value',
+                  ...(options?.providerOperationForceRefreshIdentities?.length
+                    ? {
+                        force_refresh_identities:
+                          options.providerOperationForceRefreshIdentities,
+                      }
+                    : {}),
+                }
+              : null;
           // Every runtime provider call carries at least a tool-scoped
           // attribution. Callers that know the execution location (row-scoped
           // map cells, batched owners) supply the fuller scope.
@@ -13738,7 +13627,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               metadata: {
                 parent_run_id: this.#options.runId,
                 invocation_attempt: invocationAttempt,
-                ...(requestsDurableInvocationFence
+                ...(shouldWaitForAsyncOperation
+                  ? { async_operation_wait: true }
+                  : {}),
+                ...(usesDurableInvocationFence
                   ? { invocation_fence_version: 1 }
                   : {}),
                 ...(durableCallReceiptKey
@@ -13763,6 +13655,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                         : {}),
                     }
                   : {}),
+                ...(canonicalOperation
+                  ? { canonical_operation: canonicalOperation }
+                  : {}),
                 ...(options?.customerDbDataset
                   ? {
                       query_result_dataset: {
@@ -14391,29 +14286,8 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                     ? 'array'
                     : typeof parsed.result,
             });
-            const parsedValue =
-              parsed.toolResponse && 'raw' in parsed.toolResponse
-                ? parsed.toolResponse.raw
-                : (recordOrNull(parsed.result)?.data ?? parsed.result);
-            const asyncStartPending =
-              asyncContract && shouldWaitForAsyncOperation
-                ? classifyAsyncOperationResult(asyncContract, parsedValue)
-                    .outcome === 'running'
-                : false;
-            const resolved =
-              asyncContract &&
-              shouldWaitForAsyncOperation &&
-              (parsed.status === 'running' || asyncStartPending)
-                ? await this.resolveAsyncOperation({
-                    toolId,
-                    startInput: input,
-                    startResponse: parsed,
-                    contract: asyncContract,
-                    receiptKey: durableCallReceiptKey,
-                  })
-                : parsed;
             toolCallSucceeded = true;
-            return resolved;
+            return parsed;
           }
         },
       );
@@ -14440,7 +14314,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       if (!toolSlotTransferred) {
         toolSlot.release();
       }
-      asyncCapacityRelease?.();
     }
   }