deepline 0.3.23 → 0.3.24

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

@@ -1,6 +1,7 @@
 import type { PlayRunnerBackend } from './types';
 import { daytonaPlayRunnerBackend } from './backends/daytona';
 import {
+  daytonaModalCanaryPlayRunnerBackend,
   daytonaModalFallbackPlayRunnerBackend,
   daytonaOnlyPlayRunnerBackend,
   modalOnlyPlayRunnerBackend,
@@ -14,6 +15,8 @@ import {
   type PlayRuntimeBackendId,
 } from '@shared_libs/play-runtime/backend';
 import {
+  isRuntimeSandboxCanaryProduction,
+  RUNTIME_SANDBOX_PLACEMENT_POLICIES,
   runtimeSandboxPlacementPolicyForBackend,
   type RuntimeSandboxPlacementPolicyId,
 } from '@shared_libs/play-runtime/runtime-sandbox-placement-policy';
@@ -32,6 +35,13 @@ export function resolvePlayRunnerBackend(
   );
   const placementPolicy = runtimeSandboxPlacementPolicyForBackend(backend);
   if (placementPolicy) {
+    if (
+      placementPolicy.id ===
+        RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaModalCanaryV1 &&
+      !isRuntimeSandboxCanaryProduction({ nodeEnv: process.env.NODE_ENV })
+    ) {
+      return daytonaModalFallbackPlayRunnerBackend;
+    }
     return resolveRuntimeSandboxPlacementBackend(placementPolicy.id);
   }
   if (backend === PLAY_RUNTIME_BACKENDS.localProcess) {
@@ -42,6 +52,7 @@ export function resolvePlayRunnerBackend(
 
 export {
   daytonaPlayRunnerBackend,
+  daytonaModalCanaryPlayRunnerBackend,
   daytonaModalFallbackPlayRunnerBackend,
   daytonaOnlyPlayRunnerBackend,
   localProcessPlayRunnerBackend,

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

@@ -1,4 +1,6 @@
 import { PLAY_RUNTIME_BACKENDS, type PlayRuntimeBackendId } from './backend';
+import { createHash } from 'node:crypto';
+import { isIsolatedRuntimeSchedulerSchema } from './runtime-scheduler-topology';
 
 export const RUNTIME_SANDBOX_PROVIDERS = {
   daytona: 'daytona',
@@ -15,6 +17,7 @@ export type RuntimeSandboxProvider =
 export const RUNTIME_SANDBOX_PLACEMENT_POLICIES = {
   daytonaOnlyV1: 'daytona_only@1',
   daytonaThenModalV1: 'daytona_then_modal@1',
+  daytonaModalCanaryV1: 'daytona_modal_canary@1',
   modalOnlyV1: 'modal_only@1',
 } as const;
 
@@ -41,8 +44,59 @@ export type RuntimeSandboxPlacementPolicy = Readonly<{
   transitions: readonly RuntimeSandboxPlacementTransition[];
   requiredCredentialEnv: readonly string[];
   cleanupProviders: readonly RuntimeSandboxProvider[];
+  canary?: Readonly<{
+    provider: RuntimeSandboxProvider;
+    basisPoints: number;
+    selector: 'sha256_run_id_basis_points@1';
+    environment: 'production';
+  }>;
 }>;
 
+const CANARY_BUCKET_COUNT = 10_000;
+
+export type RuntimeSandboxCanarySelection = Readonly<{
+  canary: RuntimeSandboxProvider | null;
+  bucket: number | null;
+  basisPoints: number;
+}>;
+
+export function isRuntimeSandboxCanaryProduction(input: {
+  nodeEnv?: string | null;
+  runtimeSchedulerSchema?: string | null;
+}): boolean {
+  return (
+    input.nodeEnv === 'production' &&
+    !isIsolatedRuntimeSchedulerSchema(input.runtimeSchedulerSchema)
+  );
+}
+
+/** Stable across scheduler attempts and worker processes for a durable run id. */
+export function selectRuntimeSandboxCanary(input: {
+  policy: RuntimeSandboxPlacementPolicy;
+  runId?: string | null;
+  production: boolean;
+}): RuntimeSandboxCanarySelection {
+  const canary = input.policy.canary;
+  const runId = input.runId?.trim();
+  if (!canary || !runId || !input.production) {
+    return {
+      canary: null,
+      bucket: null,
+      basisPoints: canary?.basisPoints ?? 0,
+    };
+  }
+  const bucket =
+    createHash('sha256')
+      .update(`runtime-sandbox-placement@1:${runId}`)
+      .digest()
+      .readUInt32BE(0) % CANARY_BUCKET_COUNT;
+  return {
+    canary: bucket < canary.basisPoints ? canary.provider : null,
+    bucket,
+    basisPoints: canary.basisPoints,
+  };
+}
+
 const DAYTONA_THEN_MODAL_V1: RuntimeSandboxPlacementPolicy = {
   id: RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaThenModalV1,
   compatibilityRuntimeBackend: PLAY_RUNTIME_BACKENDS.daytona,
@@ -72,6 +126,23 @@ const DAYTONA_THEN_MODAL_V1: RuntimeSandboxPlacementPolicy = {
   ],
 };
 
+/**
+ * Staged Daytona-compatible policy. Workers learn this policy before launch
+ * writers start persisting it, so an app-first deploy cannot strand runs on an
+ * unsupported policy id. One percent of production runs enter the same Modal
+ * Adapter used by DAYTONA_THEN_MODAL_V1 after a capacity failure.
+ */
+const DAYTONA_MODAL_CANARY_V1: RuntimeSandboxPlacementPolicy = {
+  ...DAYTONA_THEN_MODAL_V1,
+  id: RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaModalCanaryV1,
+  canary: {
+    provider: RUNTIME_SANDBOX_PROVIDERS.modal,
+    basisPoints: 100,
+    selector: 'sha256_run_id_basis_points@1',
+    environment: 'production',
+  },
+};
+
 /**
  * Frozen compatibility policy for launches written before placement policy ids
  * existed. It is retained until every pre-policy release lane has drained.
@@ -100,6 +171,8 @@ export const RUNTIME_SANDBOX_PLACEMENT_POLICY_CATALOG: Readonly<
   [RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaOnlyV1]: DAYTONA_ONLY_V1,
   [RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaThenModalV1]:
     DAYTONA_THEN_MODAL_V1,
+  [RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaModalCanaryV1]:
+    DAYTONA_MODAL_CANARY_V1,
   [RUNTIME_SANDBOX_PLACEMENT_POLICIES.modalOnlyV1]: MODAL_ONLY_V1,
 };
 
@@ -129,7 +202,7 @@ export function runtimeSandboxPlacementPolicyForBackend(
   backend: PlayRuntimeBackendId,
 ): RuntimeSandboxPlacementPolicy | null {
   if (backend === PLAY_RUNTIME_BACKENDS.daytona) {
-    return DAYTONA_THEN_MODAL_V1;
+    return DAYTONA_MODAL_CANARY_V1;
   }
   if (backend === PLAY_RUNTIME_BACKENDS.modal) {
     return MODAL_ONLY_V1;

package/dist/bundling-sources/shared_libs/plays/tool-category-descriptions.ts

@@ -42,6 +42,11 @@ export const TOOL_CATEGORY_DESCRIPTIONS: Readonly<Record<string, string>> = {
   free: 'Free tools that do not spend Deepline credits.',
 };
 
+/** Stable UI/CLI enumeration of the well-known canonical category slugs. */
+export const WELL_KNOWN_TOOL_CATEGORIES = Object.freeze(
+  Object.keys(TOOL_CATEGORY_DESCRIPTIONS),
+);
+
 /**
  * One-line definition for a tool category slug, or null when none is declared.
  * Never fabricates a definition for unknown slugs.