deepline 0.3.72 → 0.3.73

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

@@ -69,6 +69,8 @@ export interface ToolCallRequest {
   providerIdempotencyKeyBase?: string | null;
   cacheable?: boolean;
   receiptKey?: string | null;
+  /** Pre-cutover result-cache keys to read before executing a canonical miss. */
+  legacyReceiptKeys?: string[];
   executionAuthScopeDigest?: string | null;
   receiptLeaseId?: string | null;
   receiptLeaseExpiresAt?: string | null;

package/dist/bundling-sources/shared_libs/play-runtime/durable-call-cache.ts

@@ -45,10 +45,39 @@ export function buildDurableToolCallCacheKey(input: {
   /** Run-stable clock used to choose the stale bucket. */
   cacheEpochMs?: number;
   playLocalScope?: string | null;
-  /**
-   * Explicit revision for a response transformation. Bump it only when the
-   * serialized tool output changes; omit it for historical artifacts.
-   */
+}): string {
+  return buildDurableToolCallCacheKeyWithPresentation(input);
+}
+
+/**
+ * Reads receipt keys written before response presentation stopped partitioning
+ * the exact-request cache. New writes must use `buildDurableToolCallCacheKey`.
+ */
+export function buildLegacyRevisionedDurableToolCallCacheKey(input: {
+  orgId?: string | null;
+  toolId: string;
+  requestInput: Record<string, unknown>;
+  authScopeDigest?: string | null;
+  providerActionVersion?: string | null;
+  cachePolicyVersion?: string | null;
+  staleAfterSeconds?: number | null;
+  cacheEpochMs?: number;
+  playLocalScope?: string | null;
+  toolResponseReceiptRevision: string;
+}): string {
+  return buildDurableToolCallCacheKeyWithPresentation(input);
+}
+
+function buildDurableToolCallCacheKeyWithPresentation(input: {
+  orgId?: string | null;
+  toolId: string;
+  requestInput: Record<string, unknown>;
+  authScopeDigest?: string | null;
+  providerActionVersion?: string | null;
+  cachePolicyVersion?: string | null;
+  staleAfterSeconds?: number | null;
+  cacheEpochMs?: number;
+  playLocalScope?: string | null;
   toolResponseReceiptRevision?: string | null;
 }): string {
   const orgId = input.orgId?.trim() || 'org';
@@ -63,11 +92,6 @@ export function buildDurableToolCallCacheKey(input: {
     );
   }
   const playLocalScope = input.playLocalScope?.trim() || 'play';
-  // Keep historical digests byte-for-byte stable when no explicit revision
-  // exists on the stored artifact.
-  const toolResponseReceiptRevision = normalizeToolResponseReceiptRevision(
-    input.toolResponseReceiptRevision,
-  );
   const digest = sha256Hex(
     stableStringify({
       kind: 'tool' satisfies DurableCallKind,
@@ -78,9 +102,15 @@ export function buildDurableToolCallCacheKey(input: {
       requestInput: input.requestInput,
       authScopeDigest: input.authScopeDigest ?? null,
       providerActionVersion,
+      ...(input.toolResponseReceiptRevision
+        ? {
+            toolResponseReceiptRevision: normalizeToolResponseReceiptRevision(
+              input.toolResponseReceiptRevision,
+            ),
+          }
+        : {}),
       cachePolicyVersion:
         input.cachePolicyVersion ?? DURABLE_CALL_CACHE_POLICY_VERSION,
-      ...(toolResponseReceiptRevision ? { toolResponseReceiptRevision } : {}),
       staleBucket: durableCacheStaleBucket({
         staleAfterSeconds: input.staleAfterSeconds,
         nowMs: input.cacheEpochMs,

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/index.ts

@@ -15,7 +15,6 @@ export {
 } from './runtime-step-receipts-adapter';
 export {
   createToolCallReceiptCohortJob,
-  ToolCallReceiptCohortWaitTimeoutError,
   type ToolCallReceiptCohort,
   type ToolCallReceiptCohortJob,
   type ToolCallReceiptCohortMember,
@@ -54,12 +53,8 @@ export { ToolCallReceiptLeaseLostError } from './contract';
  * Adapts a receipt lifecycle that is already owned by a higher-level runtime
  * job.  This is a composition seam, not a second receipt implementation.
  *
- * PlayContext's direct-call path currently owns a richer runtime receipt
- * protocol: completed-cache publication, non-idempotent execution locks,
- * auth-scope re-keying, and external-call-slot retention.  Once it has
- * claimed that protocol's receipt, ToolCall can still own the call boundary
- * (validation and dispatch) without trying to claim or terminally write the
- * same receipt a second time.  The outer job remains the sole durable owner.
+ * The outer runtime owns the physical batch operation. ToolCall keeps the
+ * result boundary uniform without performing a second cache write.
  *
  * Do not use this for a new caller. New runtimes should provide a real
  * ToolResultReceipts Adapter. This exists only while PlayContext's historical
@@ -117,21 +112,14 @@ export function createExternallyOwnedToolResultReceipts(input: {
     },
     async heartbeat(candidate) {
       assertKeyAndLease(candidate);
-      // The outer runtime owns durable heartbeating / execution locks. Returning
-      // active here deliberately avoids a duplicate heartbeat write.
       return 'active';
     },
     async complete(candidate) {
       assertKeyAndLease(candidate);
-      // The outer runtime atomically publishes the result, including its
-      // cache-only convergence behaviour. A second completion here would alter
-      // that race and can overwrite its execution metadata.
       return { kind: 'stored', result: candidate.result };
     },
     async fail(candidate) {
       assertKeyAndLease(candidate);
-      // Failure publication belongs to the outer state machine because it
-      // classifies auth-scope changes, suspensions, and lost ownership.
     },
   };
 }

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/native-batch.ts

@@ -1,6 +1,5 @@
 import type { ToolExecuteResult } from '../tool-result';
 import {
-  ToolCallReceiptLeaseLostError,
   type ToolCallInput,
   type ToolCallJob,
   type ToolCallReceiptLease,
@@ -24,8 +23,6 @@ export type NativeBatchToolCallMember = {
 
 export type NativeBatchOwnedToolCallMember = NativeBatchToolCallMember & {
   receipt: ToolCallReceiptLease;
-  /** Actual member lease expiry supplied by the receipt-cohort Adapter. */
-  leaseExpiresAt?: string | null;
 };
 
 export type NativeBatchToolCallInput = {
@@ -50,14 +47,6 @@ export type NativeBatchToolCallInput = {
   }):
     | Array<{ memberId: string; result: ToolExecuteResult }>
     | Promise<Array<{ memberId: string; result: ToolExecuteResult }>>;
-  /** Keep all owned member leases alive during a long provider batch. */
-  heartbeat?: {
-    /** May derive a real interval from the claimed member leases. */
-    intervalMs:
-      | number
-      | ((input: { members: NativeBatchOwnedToolCallMember[] }) => number);
-    onTransientFailure?(error: unknown): void;
-  };
 };
 
 /** A native batch returns each local member result, including cache followers. */
@@ -70,12 +59,8 @@ export type NativeBatchToolCallJob = {
 /**
  * Owns one provider-native map batch.
  *
- * The Module composes two deep jobs rather than copying either protocol:
- * `ToolCallReceiptCohort` owns per-member receipt leases, recovery and terminal
- * fanout; `ToolCall` owns the physical provider-operation invocation. This
- * Module supplies the missing semantic rule between them: exactly one
- * aggregate operation may be dispatched, and it must be split completely
- * before every owned member receipt is completed.
+ * It reads each member's completed-result cache before assembling one physical
+ * provider batch for the misses, then atomically stores each successful split.
  */
 export function createNativeBatchToolCallJob(dependencies: {
   receiptCohort: ToolCallReceiptCohortJob;
@@ -98,68 +83,26 @@ export function createNativeBatchToolCallJob(dependencies: {
           forceFailedRefresh: member.forceFailedRefresh,
           waitMaxAttempts: member.waitMaxAttempts,
         })),
-        // Do not make locally owned rows wait behind a foreign receipt's
-        // bounded recovery. The first aggregate can run now; any receipt
-        // reclaimed after the wait forms its own later aggregate operation.
-        eager: true,
       });
       const executeOwned = async (): Promise<void> => {
         const owned = ownedMembers(cohort, input.members);
         if (owned.length === 0) return;
         const physical = input.buildPhysicalCall({ members: owned });
         validatePhysicalCall(physical, input.owner);
-        let leaseLost: ToolCallReceiptLeaseLostError | null = null;
-        const heartbeatIntervalMs = input.heartbeat
-          ? typeof input.heartbeat.intervalMs === 'function'
-            ? input.heartbeat.intervalMs({ members: owned })
-            : input.heartbeat.intervalMs
-          : null;
-        const heartbeat =
-          input.heartbeat && heartbeatIntervalMs !== null
-            ? cohort.startHeartbeat({
-                intervalMs: positiveHeartbeatInterval(heartbeatIntervalMs),
-                onLeaseLost(error) {
-                  leaseLost ??= error;
-                },
-                onTransientFailure: input.heartbeat.onTransientFailure,
-              })
-            : null;
         try {
-          await assertCohortOwned(cohort, heartbeat, leaseLost);
           const aggregate = await dependencies.physicalToolCall.call(physical);
-          await assertCohortOwned(cohort, heartbeat, leaseLost);
-          let split: Array<{ memberId: string; result: ToolExecuteResult }>;
-          try {
-            split = await input.splitResult({
-              result: aggregate,
-              members: owned,
-            });
-            validateSplit(owned, split);
-          } catch (error) {
-            throw error;
-          }
+          const split = await input.splitResult({
+            result: aggregate,
+            members: owned,
+          });
+          validateSplit(owned, split);
           await cohort.complete(split);
         } catch (error) {
-          // Once the aggregate call begins, a provider/transport failure is a
-          // terminal fact for every owned member. Lease loss is the exception:
-          // a stale owner must not overwrite the new holder's receipt state.
-          if (!(error instanceof ToolCallReceiptLeaseLostError)) {
-            await failOwned(cohort, owned, error);
-          }
+          await failOwned(cohort, owned, error);
           throw error;
-        } finally {
-          heartbeat?.stop();
         }
       };
 
-      // Start the known-owned aggregate before foreign receipt hydration. The
-      // settlement is still awaited before collection, and any newly reclaimed
-      // member gets a distinct physical operation rather than being silently
-      // omitted from this batch.
-      const initialExecution = executeOwned();
-      const settlement = cohort.settle();
-      await initialExecution;
-      await settlement;
       await executeOwned();
 
       return await collectMemberResults(cohort, input.members);
@@ -178,21 +121,11 @@ function ownedMembers(
     owned.push({
       ...member,
       receipt: state.lease,
-      ...(state.leaseExpiresAt ? { leaseExpiresAt: state.leaseExpiresAt } : {}),
     });
   }
   return owned;
 }
 
-function positiveHeartbeatInterval(value: number): number {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(
-      'Native Batch Tool Call heartbeat interval must be positive.',
-    );
-  }
-  return Math.max(1, Math.floor(value));
-}
-
 async function collectMemberResults(
   cohort: ToolCallReceiptCohort,
   members: NativeBatchToolCallMember[],
@@ -204,11 +137,10 @@ async function collectMemberResults(
       results.set(member.memberId, state.result);
       continue;
     }
-    if (state.kind === 'following' || state.kind === 'recovering') {
+    if (state.kind === 'following') {
       results.set(member.memberId, await state.result);
       continue;
     }
-    if (state.kind === 'failed') throw state.error;
     throw new Error(
       `Native Batch Tool Call left owned member ${member.memberId} without a terminal result.`,
     );
@@ -216,21 +148,6 @@ async function collectMemberResults(
   return results;
 }
 
-async function assertCohortOwned(
-  cohort: ToolCallReceiptCohort,
-  heartbeat: { assertOwned(): void } | null,
-  leaseLost: ToolCallReceiptLeaseLostError | null,
-): Promise<void> {
-  heartbeat?.assertOwned();
-  if (leaseLost) throw leaseLost;
-  const status = await cohort.heartbeat();
-  if (status === 'terminal') {
-    throw new ToolCallReceiptLeaseLostError('native-batch-cohort');
-  }
-  heartbeat?.assertOwned();
-  if (leaseLost) throw leaseLost;
-}
-
 async function failOwned(
   cohort: ToolCallReceiptCohort,
   owned: NativeBatchOwnedToolCallMember[],