deepline 0.1.306 → 0.1.308

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

@@ -1,3 +1,5 @@
+import { MAX_PLAY_SANDBOX_RUNTIME_LIMITS } from './sandbox-runtime-limits';
+
 /** Maximum active user-code runtime for a standard play, in seconds. */
 export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 30 * 60;
 export const STANDARD_PLAY_RUNTIME_LIMIT_LABEL = '30 minutes';
@@ -22,7 +24,9 @@ export const PLAY_RUNNER_STARTUP_GRACE_SECONDS = 4 * 60;
 export const PLAY_RUNNER_TIMEOUT_SECONDS = 40 * 60;
 
 /** TTL for workflow executor tokens, in seconds. */
-export const WORKFLOW_EXECUTOR_TOKEN_TTL_SECONDS = PLAY_RUNNER_TIMEOUT_SECONDS;
+export const WORKFLOW_EXECUTOR_TOKEN_TTL_SECONDS =
+  MAX_PLAY_SANDBOX_RUNTIME_LIMITS.timeoutSeconds +
+  (PLAY_RUNNER_TIMEOUT_SECONDS - STANDARD_PLAY_RUNTIME_LIMIT_SECONDS);
 
 /**
  * Absurd run-claim lease window, in seconds. The scheduler expires a claim whose

package/dist/bundling-sources/shared_libs/play-runtime/sandbox-compute-usage.ts

@@ -22,6 +22,7 @@ export function resolveDaytonaRuntimeComputeItems(input: {
       cpu: number | null;
       memoryGiB: number | null;
       diskGiB: number | null;
+      maxBillingDurationSeconds: number | null;
     }
   >();
   const items: ComputeBillingItem[] = [];
@@ -38,6 +39,9 @@ export function resolveDaytonaRuntimeComputeItems(input: {
     const billingStartedAt = finiteNonNegative(value.billingStartedAt);
     if (billingStartedAt === null) continue;
     const billingEndedAt = finiteNonNegative(value.billingEndedAt);
+    const maxBillingDurationSeconds = finiteNonNegative(
+      value.maxBillingDurationSeconds,
+    );
     const existing = resourcesBySandboxId.get(sandboxId);
     resourcesBySandboxId.set(sandboxId, {
       startedAt: Math.min(
@@ -46,16 +50,27 @@ export function resolveDaytonaRuntimeComputeItems(input: {
       ),
       endedAt:
         billingEndedAt === null
-          ? existing?.endedAt ?? null
+          ? (existing?.endedAt ?? null)
           : Math.max(existing?.endedAt ?? billingEndedAt, billingEndedAt),
       cpu: finiteNonNegative(value.cpu) ?? existing?.cpu ?? null,
       memoryGiB:
         finiteNonNegative(value.memoryGiB) ?? existing?.memoryGiB ?? null,
       diskGiB: finiteNonNegative(value.diskGiB) ?? existing?.diskGiB ?? null,
+      maxBillingDurationSeconds:
+        maxBillingDurationSeconds ??
+        existing?.maxBillingDurationSeconds ??
+        null,
     });
   }
   for (const [sandboxId, resource] of resourcesBySandboxId) {
-    const endedAt = resource.endedAt ?? input.endedAt;
+    const observedEndedAt = resource.endedAt ?? input.endedAt;
+    const endedAt =
+      resource.maxBillingDurationSeconds === null
+        ? observedEndedAt
+        : Math.min(
+            observedEndedAt,
+            resource.startedAt + resource.maxBillingDurationSeconds * 1_000,
+          );
     items.push(
       resolveDaytonaSandboxComputeItem({
         itemId: `daytona:${sandboxId}`,

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

@@ -0,0 +1,102 @@
+export type PlaySandboxRuntimeLimits = {
+  timeoutSeconds: number;
+  memoryGiB: number;
+  cpu: number;
+  diskGiB: number;
+};
+
+export const STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS: PlaySandboxRuntimeLimits = {
+  timeoutSeconds: 30 * 60,
+  memoryGiB: 1,
+  cpu: 1,
+  diskGiB: 3,
+};
+
+// Product-wide ceilings. Organisation entitlements may lower these, but a
+// customer-authored Play can never ask Daytona for an unbounded resource.
+export const MAX_PLAY_SANDBOX_RUNTIME_LIMITS: PlaySandboxRuntimeLimits = {
+  timeoutSeconds: 4 * 60 * 60,
+  memoryGiB: 16,
+  cpu: 4,
+  diskGiB: 50,
+};
+
+export type PlaySandboxRuntimeDeclaration = {
+  timeout?: string;
+  memory?: string;
+  cpu?: number;
+  disk?: string;
+};
+
+function parsePositiveInteger(value: string, unit: string): number | null {
+  const match = new RegExp(`^(\\d+)\\s*${unit}$`, 'i').exec(value.trim());
+  if (!match) return null;
+  const parsed = Number(match[1]);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+}
+
+function parseTimeout(value: string): number | null {
+  const match = /^(\d+)\s*([mh])$/i.exec(value.trim());
+  if (!match) return null;
+  const amount = Number(match[1]);
+  if (!Number.isSafeInteger(amount) || amount <= 0) return null;
+  return amount * (match[2].toLowerCase() === 'h' ? 3600 : 60);
+}
+
+export function resolvePlaySandboxRuntimeLimits(
+  declaration: PlaySandboxRuntimeDeclaration | null | undefined,
+): PlaySandboxRuntimeLimits {
+  const base = STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS;
+  if (!declaration) return { ...base };
+  const timeoutSeconds = declaration.timeout
+    ? parseTimeout(declaration.timeout)
+    : base.timeoutSeconds;
+  const memoryGiB = declaration.memory
+    ? parsePositiveInteger(declaration.memory, 'GiB')
+    : base.memoryGiB;
+  const diskGiB = declaration.disk
+    ? parsePositiveInteger(declaration.disk, 'GiB')
+    : base.diskGiB;
+  const cpu = declaration.cpu ?? base.cpu;
+  if (
+    timeoutSeconds === null ||
+    memoryGiB === null ||
+    diskGiB === null ||
+    !Number.isSafeInteger(cpu) ||
+    cpu <= 0
+  ) {
+    throw new Error(
+      'Invalid runtime sandbox declaration. Use timeout like "90m" or "2h", memory/disk like "4GiB", and a positive integer cpu.',
+    );
+  }
+  const resolved = { timeoutSeconds, memoryGiB, cpu, diskGiB };
+  for (const key of ['memoryGiB', 'cpu', 'diskGiB'] as const) {
+    if (resolved[key] < base[key]) {
+      throw new Error(
+        `Requested runtime ${key}=${resolved[key]} is below the supported minimum ${base[key]}.`,
+      );
+    }
+  }
+  for (const key of Object.keys(
+    resolved,
+  ) as (keyof PlaySandboxRuntimeLimits)[]) {
+    if (resolved[key] > MAX_PLAY_SANDBOX_RUNTIME_LIMITS[key]) {
+      throw new Error(
+        `Requested runtime ${key}=${resolved[key]} exceeds this organisation's maximum ${MAX_PLAY_SANDBOX_RUNTIME_LIMITS[key]}.`,
+      );
+    }
+  }
+  return resolved;
+}
+
+export function hasNonStandardPlaySandboxRuntimeLimits(
+  value: PlaySandboxRuntimeLimits,
+): boolean {
+  return Object.keys(value).some(
+    (key) =>
+      value[key as keyof PlaySandboxRuntimeLimits] !==
+      STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS[
+        key as keyof PlaySandboxRuntimeLimits
+      ],
+  );
+}

package/dist/bundling-sources/shared_libs/play-runtime/tool-http-errors.ts

@@ -229,6 +229,29 @@ function isHardBillingFailurePayload(
   );
 }
 
+/**
+ * A normalized provider 402 is fatal only when the integration boundary has
+ * declared it account-level capacity. A raw 402 never reaches this function as
+ * proof by itself: providers use that status inconsistently.
+ */
+function isProviderAccountCapacityFailurePayload(
+  payload: Record<string, unknown> | null,
+): payload is Record<string, unknown> {
+  if (!payload) return false;
+  const code = String(payload.code ?? payload.error_code ?? '').toUpperCase();
+  const category = String(
+    payload.error_category ?? payload.errorCategory ?? '',
+  ).toLowerCase();
+  const origin = String(
+    payload.failure_origin ?? payload.failureOrigin ?? '',
+  ).toLowerCase();
+  return (
+    code === 'PROVIDER_ACCOUNT_CAPACITY' &&
+    category === 'provider_account' &&
+    (origin === 'provider' || origin === 'provider_account')
+  );
+}
+
 function normalizeHardBillingPayload(
   payload: Record<string, unknown>,
 ): Record<string, unknown> {
@@ -268,11 +291,19 @@ function formatHardBillingFailureMessage(input: {
   maxAttempts: number;
 }): string {
   const code = getStringField(input.billing, 'code');
+  const providerCapacity = isProviderAccountCapacityFailurePayload(
+    input.billing,
+  );
   const message =
     getStringField(input.billing, 'message') ??
     getStringField(input.billing, 'error') ??
-    'Deepline billing cap exceeded.';
-  return `tool ${input.toolId} ${input.status} attempt ${input.attempt}/${input.maxAttempts}: Deepline billing cap exceeded. Run halted before marking remaining rows processed. ${code ? `code=${code}. ` : ''}${message}`;
+    (providerCapacity
+      ? 'Provider account capacity blocked execution.'
+      : 'Deepline billing cap exceeded.');
+  const headline = providerCapacity
+    ? 'Provider account capacity blocked execution.'
+    : 'Deepline billing cap exceeded.';
+  return `tool ${input.toolId} ${input.status} attempt ${input.attempt}/${input.maxAttempts}: ${headline} Run halted before marking remaining rows processed. ${code ? `code=${code}. ` : ''}${message}`;
 }
 
 function formatInsufficientCreditsMessage(input: {
@@ -434,8 +465,13 @@ export function normalizeToolHttpErrorMessage(input: {
     ? normalizeHardBillingPayload(billing)
     : isHardBillingFailurePayload(parsed)
       ? normalizeHardBillingPayload(parsed)
-      : null;
+      : isProviderAccountCapacityFailurePayload(parsed)
+        ? parsed
+        : null;
   if (hardBillingPayload) {
+    const providerCapacity = isProviderAccountCapacityFailurePayload(
+      hardBillingPayload,
+    );
     return createToolHttpError(
       schemaVersion,
       formatHardBillingFailureMessage({
@@ -450,8 +486,15 @@ export function normalizeToolHttpErrorMessage(input: {
       'terminal',
       {
         ...publicOptions,
-        origin: 'deepline',
-        category: 'billing',
+        origin: providerCapacity ? 'provider' : 'deepline',
+        // `provider_account` is the integration-boundary category. The
+        // portable ToolExecutionError taxonomy canonically represents it as
+        // provider-owned authentication; the code retains the precise
+        // account-capacity reason.
+        category: providerCapacity ? 'authentication' : 'billing',
+        code: providerCapacity
+          ? 'PROVIDER_ACCOUNT_CAPACITY'
+          : publicOptions.code,
         retryable: false,
       },
     );
@@ -481,15 +524,19 @@ export function isHardBillingToolHttpError(error: unknown): boolean {
   if (
     error instanceof ToolHttpError &&
     (isInsufficientCreditsBilling(error.billing) ||
-      isHardBillingFailurePayload(error.billing))
+      isHardBillingFailurePayload(error.billing) ||
+      isProviderAccountCapacityFailurePayload(error.billing))
   ) {
     return true;
   }
   return (
     error instanceof ToolExecutionError &&
-    error.origin === 'deepline' &&
-    error.category === 'billing' &&
-    error.code !== 'BILLING_UNAVAILABLE'
+    ((error.origin === 'deepline' &&
+      error.category === 'billing' &&
+      error.code !== 'BILLING_UNAVAILABLE') ||
+      (error.origin === 'provider' &&
+        error.category === 'authentication' &&
+        error.code === 'PROVIDER_ACCOUNT_CAPACITY'))
   );
 }
 

package/dist/bundling-sources/shared_libs/plays/bundling/index.ts

@@ -29,6 +29,7 @@ import type {
 } from '../artifact-types';
 import { buildPlayContractCompatibility } from '../contracts';
 import type { ToolExecutionErrorSchemaVersion } from '../../tool-execution-error';
+import type { PlaySandboxRuntimeDeclaration } from '../../play-runtime/sandbox-runtime-limits';
 import { validatePlaySourceFilesHaveNoInlineSecrets } from '../secret-guardrails';
 import { MAX_PLAY_BUNDLE_BYTES } from './limits';
 
@@ -126,6 +127,7 @@ export type BundledPlayFileSuccess = {
   filePath: string;
   playName: string | null;
   playDescription: string | null;
+  sandboxRuntimeDeclaration: PlaySandboxRuntimeDeclaration | null;
   compilerManifest?: PlayCompilerManifest;
   packagedFiles: PlayLocalFileReference[];
   unresolvedFileReferences: PlayLocalFileDiscoveryError[];
@@ -155,6 +157,7 @@ type SourceGraphAnalysis = {
   importPolicy: PlayImportPolicy;
   playName: string | null;
   playDescription: string | null;
+  sandboxRuntimeDeclaration: PlaySandboxRuntimeDeclaration | null;
   toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion | null;
   importedPlayDependencies: ImportedPlayDependency[];
 };
@@ -505,6 +508,7 @@ type PlayMetadataExtractionContext = {
 type ExtractedPlayMetadata = {
   name: string | null;
   description: string | null;
+  sandboxRuntimeDeclaration: PlaySandboxRuntimeDeclaration | null;
   toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion | null;
   toolErrorSchemaVersionUnknown: boolean;
 };
@@ -939,6 +943,48 @@ function toolErrorSchemaVersionFromOptions(
   return null;
 }
 
+function sandboxRuntimeDeclarationFromOptions(
+  node: AstNode | null | undefined,
+  context: PlayMetadataExtractionContext,
+): PlaySandboxRuntimeDeclaration | null {
+  const directRuntime = resolveStaticProperty(node, 'runtime', context);
+  const bindings = resolveStaticProperty(node, 'bindings', context);
+  const bindingRuntime =
+    bindings.kind === 'found'
+      ? resolveStaticProperty(bindings.value, 'runtime', context)
+      : ({ kind: 'absent' } satisfies StaticPropertyResolution);
+  const runtime =
+    directRuntime.kind === 'found' ? directRuntime : bindingRuntime;
+  if (runtime.kind !== 'found') return null;
+
+  const timeout = resolveStaticProperty(runtime.value, 'timeout', context);
+  const memory = resolveStaticProperty(runtime.value, 'memory', context);
+  const cpu = resolveStaticProperty(runtime.value, 'cpu', context);
+  const disk = resolveStaticProperty(runtime.value, 'disk', context);
+  const declaration: PlaySandboxRuntimeDeclaration = {};
+  if (timeout.kind === 'found') {
+    const value = staticStringFromExpression(timeout.value, context);
+    if (value === null) return null;
+    declaration.timeout = value;
+  }
+  if (memory.kind === 'found') {
+    const value = staticStringFromExpression(memory.value, context);
+    if (value === null) return null;
+    declaration.memory = value;
+  }
+  if (cpu.kind === 'found') {
+    const value = staticNumberFromExpression(cpu.value, context);
+    if (value === null) return null;
+    declaration.cpu = value;
+  }
+  if (disk.kind === 'found') {
+    const value = staticStringFromExpression(disk.value, context);
+    if (value === null) return null;
+    declaration.disk = value;
+  }
+  return declaration;
+}
+
 function stringPropertyFromObjectExpression(
   node: AstNode | null | undefined,
   propertyName: string,
@@ -1031,6 +1077,10 @@ function playMetadataFromDefinePlayCall(
   }
 
   const options = isObjectForm ? firstArg : (args[2] ?? null);
+  const sandboxRuntimeDeclaration = sandboxRuntimeDeclarationFromOptions(
+    options,
+    context,
+  );
   const toolErrorSchemaVersion = toolErrorSchemaVersionFromOptions(
     options,
     context,
@@ -1048,6 +1098,7 @@ function playMetadataFromDefinePlayCall(
   return {
     name,
     description,
+    sandboxRuntimeDeclaration,
     toolErrorSchemaVersion: toolErrorSchemaVersion ?? null,
     toolErrorSchemaVersionUnknown,
   };
@@ -1545,6 +1596,8 @@ async function analyzeSourceGraph(
   }
   const playName = metadata?.name ?? null;
   const playDescription = metadata?.description ?? null;
+  const sandboxRuntimeDeclaration =
+    metadata?.sandboxRuntimeDeclaration ?? null;
 
   return {
     sourceCode,
@@ -1564,6 +1617,7 @@ async function analyzeSourceGraph(
     },
     playName,
     playDescription,
+    sandboxRuntimeDeclaration,
     toolErrorSchemaVersion: metadata?.toolErrorSchemaVersion ?? null,
     importedPlayDependencies: [...importedPlayDependencies.values()].sort(
       (left, right) => left.filePath.localeCompare(right.filePath),
@@ -1824,6 +1878,7 @@ export async function bundlePlayFile(
         filePath: absolutePath,
         playName: analysis.playName,
         playDescription: analysis.playDescription,
+        sandboxRuntimeDeclaration: analysis.sandboxRuntimeDeclaration,
         packagedFiles: discoveredFiles.files,
         unresolvedFileReferences: discoveredFiles.unresolved,
         importedPlayDependencies: analysis.importedPlayDependencies,
@@ -1898,6 +1953,7 @@ export async function bundlePlayFile(
       filePath: absolutePath,
       playName: analysis.playName,
       playDescription: analysis.playDescription,
+      sandboxRuntimeDeclaration: analysis.sandboxRuntimeDeclaration,
       packagedFiles: discoveredFiles.files,
       unresolvedFileReferences: discoveredFiles.unresolved,
       importedPlayDependencies: analysis.importedPlayDependencies,

package/dist/bundling-sources/shared_libs/plays/contracts.ts

@@ -111,6 +111,12 @@ export type PlayRunContractSnapshot = {
   billingLimit?: {
     maxCreditsPerRun?: number | null;
   } | null;
+  runtimeLimit?: {
+    timeoutSeconds: number;
+    memoryGiB: number;
+    cpu: number;
+    diskGiB: number;
+  } | null;
   structuredDefinition?: unknown;
   artifactMetadata?: Record<string, unknown> | null;
   codeFormat?: 'function' | 'cjs_module' | 'esm_module' | null;