deepline 0.3.128 → 0.3.130

package/dist/bundling-sources/shared_libs/play-runtime/runtime-sandbox-placement-policy.ts

@@ -21,6 +21,10 @@ export const RUNTIME_SANDBOX_PLACEMENT_POLICIES = {
   modalOnlyV1: 'modal_only@1',
 } as const;
 
+/** Deployment-scoped policy selection for an isolated runtime lane. */
+export const RUNTIME_SANDBOX_PLACEMENT_POLICY_ENV =
+  'DEEPLINE_RUNTIME_SANDBOX_PLACEMENT_POLICY';
+
 export type RuntimeSandboxPlacementPolicyId =
   (typeof RUNTIME_SANDBOX_PLACEMENT_POLICIES)[keyof typeof RUNTIME_SANDBOX_PLACEMENT_POLICIES];
 

package/dist/bundling-sources/shared_libs/play-runtime/runtime-sheet-row-writer.ts

@@ -273,6 +273,20 @@ export class RuntimeSheetRowWriter<Row, Update> {
     return this.#finishPromise;
   }
 
+  /**
+   * Latch a failure that originated outside this writer's own batch flight —
+   * the map's persistence latch tripping on a receipt failure, or the sheet
+   * superseding this run. Every pending admission and commit rejects with
+   * `error` now, every later `settle`/`checkpoint`/`finish` rejects with it,
+   * and an in-progress retry backoff is cut short so no further attempt is
+   * made for a batch the sheet can no longer accept. The adapter call that is
+   * already in flight is not awaited: its outcome cannot change what the
+   * caller is told, and waiting on it is how a superseded run sat for hours.
+   */
+  fail(error: unknown): void {
+    this.#latchFailure(error);
+  }
+
   diagnostics(): RuntimeSheetRowWriterDiagnostics {
     return {
       activeKind: this.#active?.[0]?.kind ?? null,
@@ -513,12 +527,16 @@ export class RuntimeSheetRowWriter<Row, Update> {
           signal: this.#controller.signal,
         });
       } catch (error) {
+        // A writer that was failed from outside while this batch was in
+        // flight must not retry: the sheet has already rejected this run.
+        if (this.#failure !== null) throw this.#failure;
         const retry = this.#classifyRetryableError(error);
         if (!retry) throw error;
         await this.#sleep(
           Math.max(0, Math.ceil(retry.retryAfterMs)),
           this.#controller.signal,
         );
+        if (this.#failure !== null) throw this.#failure;
       }
     }
   }
@@ -566,6 +584,9 @@ export class RuntimeSheetRowWriter<Row, Update> {
     if (this.#failure !== null) return;
     this.#failure = error;
     this.#clearTimer();
+    // Ends a retry backoff sleep and tells an adapter that honours the signal
+    // to stop; a failed writer never sends the same batch again.
+    this.#controller.abort(error);
     for (const entry of this.#active ?? []) {
       if (entry.kind === 'terminal') {
         entry.committed.forEach((waiter) => waiter.reject(error));

package/dist/bundling-sources/shared_libs/play-runtime/sandbox-runs/contract.ts

@@ -6,7 +6,16 @@
  * before the runner command can be accepted.
  */
 
-export type SandboxProvider = 'daytona' | 'modal' | 'local';
+/**
+ * A provider name identifies a durable physical-resource owner.  The shared
+ * flow uses this identity for fencing, capacity, and receipts; provider
+ * adapters own the actual SDK calls and cleanup implementation.
+ */
+export type SandboxProvider =
+  | 'daytona'
+  | 'modal'
+  | 'agentcore_runtime'
+  | 'local';
 
 /** A portable, credential-free description of one execution resource. */
 export type SandboxRunResource = {
@@ -184,7 +193,11 @@ export type SandboxExecutionInput<Launch, Checkpoint, Suspension> =
  * deliberately excludes provider handles, commands, credentials, and payloads.
  */
 export type SandboxExecutionResource = SandboxRunResource & {
-  kind: 'daytona_sandbox' | 'modal_sandbox' | 'local_process';
+  kind:
+    | 'daytona_sandbox'
+    | 'modal_sandbox'
+    | 'agentcore_runtime_session'
+    | 'local_process';
   runtimeEnvironment?: 'preview' | 'production';
   billingEndedAtMs?: number | null;
   cpu?: number | null;

package/dist/bundling-sources/shared_libs/play-runtime/sandbox-runs/runner-backend-adapter.ts

@@ -129,7 +129,7 @@ function createRunnerCallbacks(input: {
     return converted;
   };
   const requireResource = (
-    provider: 'daytona' | 'modal',
+    provider: 'daytona' | 'modal' | 'agentcore_runtime',
     sandboxId: string,
   ) => {
     const resource = input.resources.get(`${provider}:${sandboxId}`);
@@ -221,14 +221,12 @@ function createRunnerCallbacks(input: {
 function toSandboxResource(
   resource: PlayRunnerRuntimeResource,
 ): SandboxExecutionResource {
-  const isModal = resource.kind === 'modal_sandbox';
+  const provider = sandboxProviderForRuntimeResourceKind(resource.kind);
   return {
     kind: resource.kind,
-    provider: isModal ? 'modal' : 'daytona',
+    provider,
     resourceId: resource.sandboxId,
-    routingDomain: isModal
-      ? (resource.modalAppId ?? null)
-      : (resource.daytonaOrganizationId ?? null),
+    routingDomain: runtimeResourceRoutingDomain(resource, provider),
     billingStartedAtMs: resource.billingStartedAt,
     billingEndedAtMs: resource.billingEndedAt ?? null,
     lateAcquired: resource.lateAcquired,
@@ -258,22 +256,18 @@ function toSandboxResource(
 export function playRunnerRuntimeResourceFromSandboxExecutionResource(
   resource: SandboxExecutionResource,
 ): PlayRunnerRuntimeResource {
-  const isModal = resource.provider === 'modal';
   if (resource.kind === 'local_process' || resource.provider === 'local') {
     throw new Error(
       'The PlayRunnerBackend Sandbox Runs Adapter cannot persist a local process as a physical runtime resource.',
     );
   }
+  const provider: Exclude<SandboxExecutionResource['provider'], 'local'> =
+    resource.provider;
   return {
-    kind: isModal ? 'modal_sandbox' : 'daytona_sandbox',
+    kind: runtimeResourceKindForSandboxProvider(provider),
     sandboxId: resource.resourceId,
     runtimeEnvironment: resource.runtimeEnvironment,
-    ...(isModal
-      ? { modalAppId: resource.routingDomain ?? undefined }
-      : {
-          daytonaEnvironment: resource.runtimeEnvironment,
-          daytonaOrganizationId: resource.routingDomain ?? undefined,
-        }),
+    ...runtimeResourceRoutingFields(resource, provider),
     billingStartedAt: resource.billingStartedAtMs,
     billingEndedAt: resource.billingEndedAtMs ?? null,
     lateAcquired: resource.lateAcquired,
@@ -287,6 +281,69 @@ export function playRunnerRuntimeResourceFromSandboxExecutionResource(
   };
 }
 
+function sandboxProviderForRuntimeResourceKind(
+  kind: PlayRunnerRuntimeResource['kind'],
+): 'daytona' | 'modal' | 'agentcore_runtime' {
+  switch (kind) {
+    case 'daytona_sandbox':
+      return 'daytona';
+    case 'modal_sandbox':
+      return 'modal';
+    case 'agentcore_runtime_session':
+      return 'agentcore_runtime';
+  }
+}
+
+function runtimeResourceRoutingDomain(
+  resource: PlayRunnerRuntimeResource,
+  provider: 'daytona' | 'modal' | 'agentcore_runtime',
+): string | null {
+  switch (provider) {
+    case 'daytona':
+      return resource.daytonaOrganizationId ?? null;
+    case 'modal':
+      return resource.modalAppId ?? null;
+    case 'agentcore_runtime':
+      return resource.agentcoreRuntimeArn ?? null;
+  }
+}
+
+function runtimeResourceKindForSandboxProvider(
+  provider: Exclude<SandboxExecutionResource['provider'], 'local'>,
+): PlayRunnerRuntimeResource['kind'] {
+  switch (provider) {
+    case 'daytona':
+      return 'daytona_sandbox';
+    case 'modal':
+      return 'modal_sandbox';
+    case 'agentcore_runtime':
+      return 'agentcore_runtime_session';
+  }
+}
+
+function runtimeResourceRoutingFields(
+  resource: SandboxExecutionResource,
+  provider: Exclude<SandboxExecutionResource['provider'], 'local'>,
+): Pick<
+  PlayRunnerRuntimeResource,
+  | 'daytonaEnvironment'
+  | 'daytonaOrganizationId'
+  | 'modalAppId'
+  | 'agentcoreRuntimeArn'
+> {
+  switch (provider) {
+    case 'daytona':
+      return {
+        daytonaEnvironment: resource.runtimeEnvironment,
+        daytonaOrganizationId: resource.routingDomain ?? undefined,
+      };
+    case 'modal':
+      return { modalAppId: resource.routingDomain ?? undefined };
+    case 'agentcore_runtime':
+      return { agentcoreRuntimeArn: resource.routingDomain ?? undefined };
+  }
+}
+
 function resourceKey(resource: SandboxExecutionResource): string {
   return `${resource.provider}:${resource.resourceId}`;
 }

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-play-deploy-task.ts

@@ -4,7 +4,7 @@ import {
   resolveAbsurdPoolOptions,
   resolveAbsurdQueueSuffix,
 } from './absurd-shared';
-import { ensureAbsurdSchema } from './postgres';
+import { assertAbsurdSchemaReady } from './postgres';
 import {
   acquirePgNotifyHub,
   withRuntimeSchedulerClient,
@@ -171,7 +171,7 @@ export function ensurePlayDeployQueueReady(input?: {
   if (existing) return existing;
   const promise = (async () => {
     await withRuntimeSchedulerClient(poolOptions, (client) =>
-      ensureAbsurdSchema(client),
+      assertAbsurdSchemaReady(client),
     );
     const absurd = createAbsurdRuntimeClient(poolOptions, queueName);
     const existingQueues = new Set(await absurd.listQueues());