deepline 0.3.57 → 0.3.59

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

@@ -199,7 +199,7 @@ export const SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: '0.3.57',
+  version: '0.3.59',
   updateSummary:
     'Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.',
   packageCapabilities: {

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

@@ -30,6 +30,7 @@ import {
   compileRequestsWithStrategy,
   executeChunkedRequests,
 } from './batch-runtime';
+import type { CompiledRequestBatch } from './batch-runtime';
 import type { AnyBatchOperationStrategy } from './batching-types';
 import {
   PLAY_RUNTIME_WORK_RECEIPT_LEASE_TTL_MS,
@@ -169,10 +170,10 @@ import {
 import {
   buildDurableCtxCallCacheKey,
   buildDurableRunPlayInvocationScope,
-  buildDurableToolAggregateProviderIdempotencyKey,
   buildDurableToolAggregateReceiptKey,
   buildDurableToolCallAuthScopeDigest,
   buildDurableToolCallCacheKey,
+  buildDurableToolPayloadProviderIdempotencyKey,
   buildDurableToolProviderIdempotencyKey,
   buildDurableToolReceiptPrefix,
   resolveDurableCallCachePolicy,
@@ -11273,6 +11274,21 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       strategy,
       getPayload: (request: ToolCallRequest) => request.input,
     });
+    const compileOwnedPhysicalBatch = (
+      owned: ToolCallRequest[],
+    ): CompiledRequestBatch<ToolCallRequest> => {
+      const compiled = compileRequestsWithStrategy({
+        requests: owned,
+        strategy,
+        getPayload: (request: ToolCallRequest) => request.input,
+      });
+      if (compiled.length !== 1) {
+        throw new Error(
+          'Native batch owned members must compile into exactly one provider request.',
+        );
+      }
+      return compiled[0]!;
+    };
     const batchParallelismCeiling =
       this.governor.policy.pacing.workerToolBatchDefaultParallelism;
     const batchSize =
@@ -11282,6 +11298,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             batchParallelismCeiling,
           )
         : batchParallelismCeiling;
+    const batchProviderActionVersion =
+      (await this.#options.getToolActionCacheVersion?.(toolId))?.trim() ??
+      'unversioned';
     const successful: ToolCallRequest[] = [];
 
     const deliver = (request: ToolCallRequest, result: ToolExecuteResult) => {
@@ -11332,6 +11351,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           string,
           {
             members: ToolCallRequest[];
+            compiled: CompiledRequestBatch<ToolCallRequest>;
             providerOperationKey: string;
             receiptLeaseExpiresAt: string | null;
             timeoutMs: number | undefined;
@@ -11380,26 +11400,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                         detail.members[0]?.executionAuthScopeDigest ?? null,
                       providerIdempotencyReceiptKey:
                         detail.providerOperationKey,
-                      providerIdempotencyKey:
-                        buildDurableToolAggregateProviderIdempotencyKey({
-                          aggregateReceiptKey: detail.providerOperationKey,
-                          receiptKeys: detail.members.map(
-                            (member) =>
-                              member.providerIdempotencyKeyBase ??
-                              member.receiptKey!,
-                          ),
-                          providerIdempotencyKeys: detail.members.map(
-                            (member) =>
-                              this.providerIdempotencyKeyForToolCall({
-                                cacheKey:
-                                  member.providerIdempotencyKeyBase ??
-                                  member.receiptKey!,
-                                force: member.force === true,
-                                leaseId: member.receiptLeaseId,
-                                logicalCallId: member.logicalCallId,
-                              }),
-                          ),
-                        }),
+                      providerIdempotencyKey: detail.providerOperationKey,
                       receiptLeaseExpiresAt: detail.receiptLeaseExpiresAt,
                       timeoutMs: detail.timeoutMs,
                     },
@@ -11477,10 +11478,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               (member) => batchRequestByCallId.get(member.memberId)!,
             );
             const receiptKeys = owned.map((request) => request.receiptKey!);
-            const providerReceiptKeys = owned.map(
-              (request) =>
-                request.providerIdempotencyKeyBase ?? request.receiptKey!,
-            );
             const aggregateReceiptKey = buildDurableToolAggregateReceiptKey({
               receiptKeys,
               prefix: 'batch',
@@ -11489,16 +11486,36 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 toolId: batch.batchOperation,
               }),
             });
-            const providerOperationKey = buildDurableToolAggregateReceiptKey({
-              receiptKeys: providerReceiptKeys,
-              prefix: 'batch',
-              aggregateReceiptPrefix: buildDurableToolReceiptPrefix({
+            const compiled = compileOwnedPhysicalBatch(owned);
+            if (compiled.batchOperation !== batch.batchOperation) {
+              throw new Error(
+                'Native batch owned members changed provider operation during compilation.',
+              );
+            }
+            const providerOperationKey =
+              buildDurableToolPayloadProviderIdempotencyKey({
                 orgId: this.#options.orgId,
                 toolId: batch.batchOperation,
-              }),
-            });
+                executionAuthScopeDigest:
+                  owned[0]?.executionAuthScopeDigest ?? null,
+                providerActionVersion: batchProviderActionVersion,
+                payload: compiled.batchPayload,
+                forceRefreshIdentities: owned
+                  .filter((request) => request.force === true)
+                  .map((request) =>
+                    this.providerIdempotencyKeyForToolCall({
+                      cacheKey:
+                        request.providerIdempotencyKeyBase ??
+                        request.receiptKey!,
+                      force: true,
+                      leaseId: request.receiptLeaseId,
+                      logicalCallId: request.logicalCallId,
+                    }),
+                  ),
+              });
             dispatchDetails.set(aggregateReceiptKey, {
               members: owned,
+              compiled,
               providerOperationKey,
               receiptLeaseExpiresAt: owned.reduce<string | null>(
                 (earliest, request) => {
@@ -11523,7 +11540,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             return {
               ...members[0]!.call,
               tool: { id: batch.batchOperation, providerActionVersion: '' },
-              payload: batch.batchPayload,
+              payload: compiled.batchPayload,
               compatibility: {
                 resultReceiptKey: aggregateReceiptKey,
                 providerOperationKey,
@@ -11531,7 +11548,40 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             };
           },
           splitResult: async ({ result: aggregate, members }) => {
-            const split = batch.splitResults(
+            const receiptKeys = members.map((member) => {
+              const request = batchRequestByCallId.get(member.memberId);
+              if (!request?.receiptKey) {
+                throw new Error(
+                  `Native batch Tool Call lost receipt for ${member.memberId}.`,
+                );
+              }
+              return request.receiptKey;
+            });
+            const aggregateReceiptKey = buildDurableToolAggregateReceiptKey({
+              receiptKeys,
+              prefix: 'batch',
+              aggregateReceiptPrefix: buildDurableToolReceiptPrefix({
+                orgId: this.#options.orgId,
+                toolId: batch.batchOperation,
+              }),
+            });
+            const detail = dispatchDetails.get(aggregateReceiptKey);
+            if (!detail) {
+              throw new Error(
+                'Native batch Tool Call lost its split compilation details.',
+              );
+            }
+            if (
+              detail.members.length !== members.length ||
+              !detail.members.every(
+                (request, index) => request.callId === members[index]?.memberId,
+              )
+            ) {
+              throw new Error(
+                'Native batch Tool Call split members changed in transit.',
+              );
+            }
+            const split = detail.compiled.splitResults(
               legacyResultForBatchSplitter(aggregate),
             );
             return await Promise.all(
@@ -12573,11 +12623,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   const receiptKeys = batch.memberRequests.map(
                     (request) => request.cacheKey,
                   );
-                  const providerIdempotencyReceiptKeys =
-                    batch.memberRequests.map(
-                      (request) =>
-                        request.providerIdempotencyKeyBase ?? request.cacheKey,
-                    );
                   const aggregateReceiptKey =
                     buildDurableToolAggregateReceiptKey({
                       receiptKeys,
@@ -12588,13 +12633,31 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                       }),
                     });
                   const aggregateProviderIdempotencyReceiptKey =
-                    buildDurableToolAggregateReceiptKey({
-                      receiptKeys: providerIdempotencyReceiptKeys,
-                      prefix: 'batch',
-                      aggregateReceiptPrefix: buildDurableToolReceiptPrefix({
-                        orgId: this.#options.orgId,
-                        toolId: batch.batchOperation,
-                      }),
+                    buildDurableToolPayloadProviderIdempotencyKey({
+                      orgId: this.#options.orgId,
+                      toolId: batch.batchOperation,
+                      executionAuthScopeDigest:
+                        batch.memberRequests[0]?.executionAuthScopeDigest ??
+                        null,
+                      providerActionVersion:
+                        (
+                          await this.#options.getToolActionCacheVersion?.(
+                            batch.batchOperation,
+                          )
+                        )?.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,
+                          }),
+                        ),
                     });
                   let releaseToolSlot: () => void = () => undefined;
                   try {
@@ -12621,22 +12684,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                           providerIdempotencyReceiptKey:
                             aggregateProviderIdempotencyReceiptKey,
                           providerIdempotencyKey:
-                            buildDurableToolAggregateProviderIdempotencyKey({
-                              aggregateReceiptKey:
-                                aggregateProviderIdempotencyReceiptKey,
-                              receiptKeys: providerIdempotencyReceiptKeys,
-                              providerIdempotencyKeys: batch.memberRequests.map(
-                                (request) =>
-                                  this.providerIdempotencyKeyForToolCall({
-                                    cacheKey:
-                                      request.providerIdempotencyKeyBase ??
-                                      request.cacheKey,
-                                    force: request.force === true,
-                                    leaseId: request.receiptLeaseId,
-                                    logicalCallId: request.logicalCallId,
-                                  }),
-                              ),
-                            }),
+                            aggregateProviderIdempotencyReceiptKey,
                           receiptLeaseExpiresAt: batch.memberRequests.reduce<
                             string | null
                           >((earliest, request) => {

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

@@ -241,3 +241,42 @@ export function buildDurableToolAggregateProviderIdempotencyKey(input: {
     stableStringify({ receiptKeys, providerIdempotencyKeys }),
   )}`;
 }
+
+/**
+ * Provider-native batch caching is keyed by the exact compiled provider
+ * payload. Receipt identities coordinate ownership and terminal results; they
+ * cannot stand in for request identity because cache hits and foreign leases
+ * can remove members after the original batch was planned.
+ *
+ * An explicit force refresh is deliberately a separate namespace: it asks for
+ * a fresh provider operation even when the payload itself is unchanged.
+ */
+export function buildDurableToolPayloadProviderIdempotencyKey(input: {
+  orgId?: string | null;
+  toolId: string;
+  executionAuthScopeDigest?: string | null;
+  providerActionVersion?: string | null;
+  payload: Record<string, unknown>;
+  forceRefreshIdentities?: readonly string[];
+}): string {
+  const toolId = input.toolId.trim();
+  if (!toolId) {
+    throw new Error(
+      'Provider payload idempotency key needs a non-empty toolId.',
+    );
+  }
+  const forceRefreshIdentities = input.forceRefreshIdentities
+    ?.map((identity) => identity.trim())
+    .filter(Boolean);
+  return `${buildDurableToolReceiptPrefix({
+    orgId: input.orgId,
+    toolId,
+  })}payload-v1:${sha256Hex(
+    stableStringify({
+      executionAuthScopeDigest: input.executionAuthScopeDigest?.trim() || null,
+      providerActionVersion: input.providerActionVersion?.trim() || null,
+      payload: input.payload,
+      ...(forceRefreshIdentities?.length ? { forceRefreshIdentities } : {}),
+    }),
+  )}`;
+}

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-lifecycle.ts

@@ -311,11 +311,16 @@ async function createOneShotDaytonaSandbox(input: {
   });
 }
 
+type TimedOutDaytonaSandboxReconciliation =
+  | { kind: 'started'; sandbox: DaytonaSandbox }
+  | { kind: 'deleted' }
+  | { kind: 'not_found' };
+
 async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
   daytona: DaytonaClient;
   sandboxName: string;
-}): Promise<boolean> {
-  if (!input.daytona.get) return false;
+}): Promise<TimedOutDaytonaSandboxReconciliation> {
+  if (!input.daytona.get) return { kind: 'not_found' };
   let lastDeleteConflict: unknown = null;
   for (const delayMs of DAYTONA_TIMED_OUT_CREATE_RECONCILE_DELAYS_MS) {
     if (delayMs > 0) {
@@ -327,6 +332,14 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
     } catch {
       continue;
     }
+    // `create` waits only a bounded interval, but the named sandbox may finish
+    // the same create transition immediately afterwards. It is already the
+    // durable identity associated with this provider operation, so reusing it
+    // is safer and faster than attempting a conflicting delete or creating a
+    // second sandbox.
+    if (sandbox.state === 'started') {
+      return { kind: 'started', sandbox };
+    }
     try {
       await sandbox.delete(30);
     } catch (error) {
@@ -344,7 +357,7 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
         { cause: error },
       );
     }
-    return true;
+    return { kind: 'deleted' };
   }
   if (lastDeleteConflict) {
     throw new Error(
@@ -352,7 +365,7 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
       { cause: lastDeleteConflict },
     );
   }
-  return false;
+  return { kind: 'not_found' };
 }
 
 async function createRetriedOneShotDaytonaSandbox(input: {
@@ -402,16 +415,14 @@ async function createRetriedOneShotDaytonaSandbox(input: {
       // A normal rejected create has no durable provider resource. A timeout
       // can be ambiguous, so retain its lease until the crash TTL rather than
       // admitting another sandbox against an unknown provider outcome.
-      if (reservation && !isDaytonaSandboxStartTimeout(String(error))) {
-        await input.releaseSandboxCapacity?.(reservation.leaseId);
-      }
-      await input.observeCreateCall?.({
-        type: 'daytona_create_call_failed',
-        occurredAtMs: Date.now(),
-        providerAttempt: attempt,
-        errorClass: daytonaCreateErrorClass(error),
-      });
       const message = error instanceof Error ? error.message : String(error);
+      const recordCreateFailure = () =>
+        input.observeCreateCall?.({
+          type: 'daytona_create_call_failed',
+          occurredAtMs: Date.now(),
+          providerAttempt: attempt,
+          errorClass: daytonaCreateErrorClass(error),
+        });
       errors.push(message);
       input.emitStage('create:attempt_failed', {
         attempt,
@@ -427,18 +438,49 @@ async function createRetriedOneShotDaytonaSandbox(input: {
       });
       const immediateFallbackReason =
         resolveDaytonaSandboxAcquisitionUnavailableReason([message]);
-      if (immediateFallbackReason === 'daytona_total_cpu_limit_exceeded') {
-        throw new DaytonaSandboxAcquisitionUnavailableError(
-          immediateFallbackReason,
-          `Daytona sandbox create rejected by the organization CPU limit on provider attempt ${attempt}: ${message}`,
-        );
-      }
       if (isDaytonaSandboxStartTimeout(message)) {
-        const deleted = await reconcileAndDeleteTimedOutDaytonaSandbox({
-          daytona: input.daytona,
-          sandboxName,
-        });
-        if (deleted) {
+        let reconciliation: TimedOutDaytonaSandboxReconciliation;
+        try {
+          reconciliation = await reconcileAndDeleteTimedOutDaytonaSandbox({
+            daytona: input.daytona,
+            sandboxName,
+          });
+        } catch (reconciliationError) {
+          await recordCreateFailure();
+          throw reconciliationError;
+        }
+        if (reconciliation.kind === 'started') {
+          const acquiredAt = Date.now();
+          try {
+            await input.observeCreateCall?.({
+              type: 'daytona_create_call_succeeded',
+              occurredAtMs: acquiredAt,
+              providerAttempt: attempt,
+              sandboxId: reconciliation.sandbox.id,
+            });
+          } catch {
+            console.error(
+              '[play-runner.daytona.create_lifecycle_event_unrecorded]',
+              {
+                workflowId: input.context.workflowId ?? null,
+                runId: input.context.runId ?? null,
+                attempt,
+                sandboxId: reconciliation.sandbox.id,
+                eventType: 'daytona_create_call_succeeded',
+              },
+            );
+          }
+          return {
+            sandbox: reconciliation.sandbox,
+            attempt,
+            attemptElapsedMs: acquiredAt - attemptStartedAt,
+            ...(reservation
+              ? { sandboxCapacityLeaseId: reservation.leaseId }
+              : {}),
+          };
+        }
+        await recordCreateFailure();
+        if (reconciliation.kind === 'deleted') {
           // The provider-confirmed reconciliation means this reservation can
           // no longer represent a live sandbox. Release before returning the
           // acquisition-unavailable result so Modal fallback is not blocked
@@ -456,6 +498,16 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           { cause: error },
         );
       }
+      if (reservation) {
+        await input.releaseSandboxCapacity?.(reservation.leaseId);
+      }
+      await recordCreateFailure();
+      if (immediateFallbackReason === 'daytona_total_cpu_limit_exceeded') {
+        throw new DaytonaSandboxAcquisitionUnavailableError(
+          immediateFallbackReason,
+          `Daytona sandbox create rejected by the organization CPU limit on provider attempt ${attempt}: ${message}`,
+        );
+      }
       continue;
     }
     // The outcome must be attributed immediately after Daytona acknowledges

package/dist/cli/index.js

@@ -1075,7 +1075,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.57",
+  version: "0.3.59",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1

package/dist/cli/index.mjs

@@ -1060,7 +1060,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.57",
+  version: "0.3.59",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1

package/dist/index.js

@@ -826,7 +826,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.57",
+  version: "0.3.59",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1

package/dist/index.mjs

@@ -738,7 +738,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.57",
+  version: "0.3.59",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.3.57",
+  "version": "0.3.59",
   "description": "GTM data CLI and TypeScript SDK for coding agents",
   "license": "MIT",
   "homepage": "https://code.deepline.com",