deepline 0.1.307 → 0.1.308

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;

package/dist/cli/index.js

@@ -1037,7 +1037,7 @@ var SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: "0.1.307",
+  version: "0.1.308",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -12142,6 +12142,134 @@ function resolveEnabledExecutionProfile(override) {
   }
 }
 
+// ../shared_libs/play-runtime/sandbox-runtime-limits.ts
+var STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS = {
+  timeoutSeconds: 30 * 60,
+  memoryGiB: 1,
+  cpu: 1,
+  diskGiB: 3
+};
+var MAX_PLAY_SANDBOX_RUNTIME_LIMITS = {
+  timeoutSeconds: 4 * 60 * 60,
+  memoryGiB: 16,
+  cpu: 4,
+  diskGiB: 50
+};
+function parsePositiveInteger3(value, unit) {
+  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) {
+  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);
+}
+function resolvePlaySandboxRuntimeLimits(declaration) {
+  const base = STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS;
+  if (!declaration) return { ...base };
+  const timeoutSeconds = declaration.timeout ? parseTimeout(declaration.timeout) : base.timeoutSeconds;
+  const memoryGiB = declaration.memory ? parsePositiveInteger3(declaration.memory, "GiB") : base.memoryGiB;
+  const diskGiB = declaration.disk ? parsePositiveInteger3(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"]) {
+    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
+  )) {
+    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;
+}
+function hasNonStandardPlaySandboxRuntimeLimits(value) {
+  return Object.keys(value).some(
+    (key) => value[key] !== STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS[key]
+  );
+}
+
+// ../shared_libs/play-runtime/worker-api-types.ts
+var DAYTONA_COMPUTE_PRICING_USD = {
+  vcpuSecond: 14e-6,
+  memoryGiBSecond: 45e-7,
+  storageGiBSecond: 3e-8,
+  includedStorageGiB: 5
+};
+function roundUsd(amount) {
+  return Number(Math.max(0, amount).toFixed(12));
+}
+function resolveDaytonaSandboxComputeItem(input2) {
+  const billableSeconds = Math.max(1, Math.ceil(input2.wallTimeSeconds));
+  const cpu = Math.max(0, input2.cpu);
+  const memoryGiB = Math.max(0, input2.memoryGiB);
+  const billableDiskGiB = Math.max(
+    0,
+    input2.diskGiB - DAYTONA_COMPUTE_PRICING_USD.includedStorageGiB
+  );
+  const providerCostUsd = roundUsd(
+    billableSeconds * (cpu * DAYTONA_COMPUTE_PRICING_USD.vcpuSecond + memoryGiB * DAYTONA_COMPUTE_PRICING_USD.memoryGiBSecond + billableDiskGiB * DAYTONA_COMPUTE_PRICING_USD.storageGiBSecond)
+  );
+  return {
+    itemId: input2.itemId,
+    source: input2.source ?? "daytona",
+    unit: "sandbox_second",
+    units: billableSeconds,
+    providerCostUsd,
+    metadata: {
+      sandboxId: input2.sandboxId ?? null,
+      cpu,
+      memoryGiB,
+      diskGiB: Math.max(0, input2.diskGiB),
+      billableDiskGiB,
+      startedAt: input2.startedAt,
+      endedAt: input2.endedAt
+    }
+  };
+}
+
+// ../shared_libs/billing/compute-pricing.ts
+var COMPUTE_BILLING_MARKUP_MULTIPLIER = 5;
+var DEFAULT_USD_PER_CUSTOMER_CREDIT = 0.1;
+var DEFAULT_PROVIDER_MARKUP_MULTIPLIER = 1.4;
+function roundUpCredits(value) {
+  if (!Number.isFinite(value) || value <= 0) return 0;
+  return Math.ceil(value * 100) / 100;
+}
+function estimateDaytonaMaximumComputeCredits(limits) {
+  const item = resolveDaytonaSandboxComputeItem({
+    itemId: "estimate",
+    wallTimeSeconds: limits.timeoutSeconds,
+    cpu: limits.cpu,
+    memoryGiB: limits.memoryGiB,
+    diskGiB: limits.diskGiB
+  });
+  return roundUpCredits(
+    item.providerCostUsd * COMPUTE_BILLING_MARKUP_MULTIPLIER * DEFAULT_PROVIDER_MARKUP_MULTIPLIER / DEFAULT_USD_PER_CUSTOMER_CREDIT
+  );
+}
+function formatNonStandardSandboxRuntimeWarning(limits) {
+  if (!hasNonStandardPlaySandboxRuntimeLimits(limits)) return null;
+  const maximumComputeCredits = estimateDaytonaMaximumComputeCredits(limits);
+  return `This Play requests a non-standard sandbox (${limits.timeoutSeconds}s, ${limits.memoryGiB}GiB memory, ${limits.cpu} CPU, ${limits.diskGiB}GiB disk). Maximum compute estimate: ${maximumComputeCredits.toFixed(2)} Deepline credits. It may queue longer.`;
+}
+
 // ../shared_libs/play-runtime/internal-step-ids.ts
 var INTERNAL_GLUE_NODE_ID_PREFIX = "run_javascript:";
 function isInternalGlueStepId(stepId) {
@@ -12701,7 +12829,7 @@ function looksLikeFilePath(target) {
   }
   return target.includes("\\") || /\.(ts|js|mjs|play\.ts)$/.test(target);
 }
-function parsePositiveInteger3(value, flagName) {
+function parsePositiveInteger4(value, flagName) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     throw new Error(`${flagName} must be a positive integer.`);
@@ -16221,7 +16349,7 @@ function parsePlayRunOptions(args) {
       );
     }
     if ((arg === "--tail-timeout-ms" || arg === "--timeout-ms") && args[index + 1]) {
-      waitTimeoutMs = parsePositiveInteger3(args[++index], arg);
+      waitTimeoutMs = parsePositiveInteger4(args[++index], arg);
       continue;
     }
     if (PLAY_RUN_RESERVED_BOOLEAN_FLAGS.has(arg)) {
@@ -16544,23 +16672,49 @@ function formatPlayCheckIssueLines(issue) {
   }
   return lines;
 }
-function printPlayCheckIssues(issues, writer) {
-  if (!issues?.length) return;
-  const errorIssues = issues.filter((issue) => issue.severity === "error");
-  const warningIssues = issues.filter((issue) => issue.severity === "warning");
+function printPlayCheckIssues(issues, writer, warnings = void 0) {
+  const errorIssues = (issues ?? []).filter(
+    (issue) => issue.severity === "error"
+  );
+  const warningIssues = (issues ?? []).filter(
+    (issue) => issue.severity === "warning"
+  );
+  const structuredWarningMessages = warningIssues.map(
+    (issue) => issue.message.trim()
+  );
+  const stringWarnings = [...new Set(warnings ?? [])].filter((warning) => {
+    const trimmed = warning.trim();
+    return trimmed.length > 0 && !structuredWarningMessages.some(
+      (message) => trimmed === message || trimmed.startsWith(message)
+    );
+  });
   if (errorIssues.length) {
     writer("  issues:");
     for (const issue of errorIssues) {
       for (const line of formatPlayCheckIssueLines(issue)) writer(line);
     }
   }
-  if (warningIssues.length) {
+  if (warningIssues.length || stringWarnings.length) {
     writer("  warnings:");
     for (const issue of warningIssues) {
       for (const line of formatPlayCheckIssueLines(issue)) writer(line);
     }
+    for (const warning of stringWarnings) writer(`  - ${warning.trim()}`);
   }
 }
+function formatPlaySandboxRuntimeWarning(declaration) {
+  if (!declaration) return null;
+  const warning = formatNonStandardSandboxRuntimeWarning(
+    resolvePlaySandboxRuntimeLimits(declaration)
+  );
+  return warning ? `Warning: ${warning}` : null;
+}
+function printBundledRuntimeWarning(bundle) {
+  const warning = formatPlaySandboxRuntimeWarning(
+    bundle.sandboxRuntimeDeclaration
+  );
+  if (warning) console.warn(warning);
+}
 function partitionMirroredErrors(errors, issues) {
   const errorMessages = (issues ?? []).filter((issue) => issue.severity === "error").map((issue) => issue.message.trim()).filter((message) => message.length > 0);
   if (errorMessages.length === 0) {
@@ -16738,7 +16892,11 @@ async function handlePlayCheck(args) {
     }
     printPlayTriggers(enrichedResult.triggers);
     printRecognizedSummary(enrichedResult.recognized);
-    printPlayCheckIssues(enrichedResult.issues, (line) => console.log(line));
+    printPlayCheckIssues(
+      enrichedResult.issues,
+      (line) => console.log(line),
+      enrichedResult.warnings
+    );
     printToolGetterHints(enrichedResult.toolGetterHints);
   } else {
     console.error(`\u2717 ${playName} failed cloud play check`);
@@ -16749,7 +16907,11 @@ async function handlePlayCheck(args) {
     for (const error of unstructuredErrors) {
       console.error(`  ${error}`);
     }
-    printPlayCheckIssues(enrichedResult.issues, (line) => console.error(line));
+    printPlayCheckIssues(
+      enrichedResult.issues,
+      (line) => console.error(line),
+      enrichedResult.warnings
+    );
     printToolGetterHints(enrichedResult.toolGetterHints);
   }
   return enrichedResult.valid ? 0 : 1;
@@ -16810,6 +16972,7 @@ async function handleFileBackedRun(options, hooks) {
   }
   const bundleResult = graph.root;
   const playName = bundleResult.playName ?? extractPlayName(sourceCode, absolutePlayPath);
+  printBundledRuntimeWarning(bundleResult);
   try {
     progress.phase("publishing imported plays");
     await traceCliSpan(
@@ -17347,7 +17510,7 @@ async function handleRunLogs(args) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--limit" && args[index + 1]) {
-      limit = parsePositiveInteger3(args[++index], "--limit");
+      limit = parsePositiveInteger4(args[++index], "--limit");
       continue;
     }
     if (arg === "--out" && args[index + 1]) {