deepline 0.2.9 → 0.2.11

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -530,6 +530,8 @@ export interface ContextOptions {
   vercelProtectionBypassToken?: string | null;
   /** Optional per-run integration execution mode for provider calls. */
   integrationMode?: 'live' | 'eval_stub' | 'fixture';
+  /** Preview/dev test seam that applies provider pacing to fixture responses. */
+  enforceFixtureProviderPacing?: boolean;
   orgId?: string;
   userEmail?: string;
   playName?: string;

package/dist/bundling-sources/shared_libs/play-runtime/db-session.ts

@@ -2,6 +2,7 @@ import type {
   EncryptedPostgresUrl,
   PostgresUrlEncryptionRequest,
 } from './db-session-crypto';
+import { WORKFLOW_EXECUTOR_TOKEN_TTL_SECONDS } from './runtime-constants';
 
 // Workflow DB sessions must not expire before the workflow run/retry state they
 // pair with. Run/retry state lives 60 min (WORKFLOW_RUN_STATE_TTL_MS in the
@@ -11,6 +12,13 @@ import type {
 export const DB_SESSION_DEFAULT_TTL_SECONDS = 60 * 60;
 export const DB_SESSION_MAX_TTL_SECONDS = 60 * 60;
 
+// A sandbox cannot mint new database authority after launch. Its preloaded
+// sessions therefore have to remain valid for the same bounded activity as
+// the executor token that unwraps them. Keep the shorter default/max above for
+// renewable control-plane sessions; they do not govern launch-time preloads.
+export const PRELOADED_RUNTIME_DB_SESSION_TTL_SECONDS =
+  WORKFLOW_EXECUTOR_TOKEN_TTL_SECONDS;
+
 export const DB_SESSION_OPERATIONS = [
   'rows.read',
   'rows.append',

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

@@ -122,6 +122,8 @@ export interface PlayRunnerContextConfig {
   runtimeTestFaultHeader?: string | null;
   vercelProtectionBypassToken?: string | null;
   integrationMode?: 'live' | 'eval_stub' | 'fixture';
+  /** Preview/dev test seam that applies provider pacing to fixture responses. */
+  enforceFixtureProviderPacing?: boolean;
   /** Immutable tool-error payload schema copied from the run contract. */
   toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
   orgId?: string;

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

@@ -4396,10 +4396,26 @@ export async function claimRuntimeWorkReceipts(
     leaseTtlMs?: number | null;
   },
 ): Promise<WorkReceiptClaim[]> {
-  const keys = [
-    ...new Set(input.keys.map((key) => key.trim()).filter(Boolean)),
-  ];
-  if (keys.length === 0) return [];
+  if (
+    input.leaseIds !== undefined &&
+    input.leaseIds.length !== input.keys.length
+  ) {
+    throw new Error(
+      `Runtime receipt bulk claim requires one lease ID per key. Received ${input.leaseIds.length} lease IDs for ${input.keys.length} keys.`,
+    );
+  }
+  const positionalEntries = input.keys
+    .map((key, originalIndex) => ({ key: key.trim(), originalIndex }))
+    .filter((entry) => Boolean(entry.key));
+  const positionalKeys = positionalEntries.map((entry) => entry.key);
+  if (positionalKeys.length === 0) return [];
+  const firstPositionByKey = new Map<string, number>();
+  positionalEntries.forEach(({ key, originalIndex }) => {
+    if (!firstPositionByKey.has(key)) {
+      firstPositionByKey.set(key, originalIndex);
+    }
+  });
+  const keys = [...firstPositionByKey.keys()];
   const session = await getRuntimeWorkReceiptSessionForKeys(context, {
     playName: input.playName,
     keys,
@@ -4409,16 +4425,9 @@ export async function claimRuntimeWorkReceipts(
     session,
     async (client) => {
       const keyHexes = keys.map(workReceiptKeyHex);
-      if (
-        input.leaseIds !== undefined &&
-        input.leaseIds.length !== keys.length
-      ) {
-        throw new Error(
-          `Runtime receipt bulk claim requires one lease ID per key. Received ${input.leaseIds.length} lease IDs for ${keys.length} keys.`,
-        );
-      }
-      const leaseIds = keys.map((_, index) => {
-        const providedLeaseId = input.leaseIds?.[index]?.trim();
+      const leaseIds = keys.map((key) => {
+        const position = firstPositionByKey.get(key)!;
+        const providedLeaseId = input.leaseIds?.[position]?.trim();
         return (
           providedLeaseId ||
           (input.leaseAware === true ? newRuntimeWorkReceiptLeaseId() : null)
@@ -4604,19 +4613,40 @@ export async function claimRuntimeWorkReceipts(
           input.reclaimRunning === true,
         ],
       );
-      return rows.map((row) => {
+      const claimsByKey = new Map<string, WorkReceiptClaim>();
+      for (const row of rows) {
         const receipt = mapRuntimeWorkReceiptRow(row);
         if (row.claimed === true) {
-          return { disposition: 'claimed', receipt } satisfies WorkReceiptClaim;
+          claimsByKey.set(receipt.key, {
+            disposition: 'claimed',
+            receipt,
+          });
+          continue;
         }
         if (input.forceRefresh !== true && isReusableWorkReceipt(receipt)) {
-          return { disposition: 'reused', receipt } satisfies WorkReceiptClaim;
+          claimsByKey.set(receipt.key, {
+            disposition: 'reused',
+            receipt,
+          });
+          continue;
         }
-        return runtimeWorkReceiptClaimDispositionForBlockedReceipt({
-          receipt,
-          claimantRunId: input.runId,
-          claimantRunAttempt: runAttempt,
-        });
+        claimsByKey.set(
+          receipt.key,
+          runtimeWorkReceiptClaimDispositionForBlockedReceipt({
+            receipt,
+            claimantRunId: input.runId,
+            claimantRunAttempt: runAttempt,
+          }),
+        );
+      }
+      return positionalKeys.map((key) => {
+        const claim = claimsByKey.get(key);
+        if (!claim) {
+          throw new Error(
+            `Runtime receipt ${key} bulk claim did not return a positional result.`,
+          );
+        }
+        return claim;
       });
     },
   );

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

@@ -69,6 +69,21 @@ export class RuntimeReceiptWriterClosedError extends Error {
   }
 }
 
+export class RuntimeReceiptWriterRetryDeadlineError extends Error {
+  constructor(
+    readonly attempts: number,
+    readonly elapsedMs: number,
+    readonly maxRetryElapsedMs: number,
+    options?: { cause?: unknown },
+  ) {
+    super(
+      `Runtime receipt persistence did not recover within ${maxRetryElapsedMs}ms after ${attempts} attempts.`,
+      options,
+    );
+    this.name = 'RuntimeReceiptWriterRetryDeadlineError';
+  }
+}
+
 /**
  * Private batching implementation used by a Play Durability Store Adapter.
  *
@@ -90,6 +105,7 @@ export class RuntimeReceiptWriter<Input, Output> {
   readonly #maxBatchBytes: number;
   readonly #maxBufferedBytes: number;
   readonly #maxFlushMs: number;
+  readonly #maxRetryElapsedMs: number;
   readonly #onRetryEvent:
     | ((event: RuntimeReceiptWriterRetryEvent<Input>) => void)
     | null;
@@ -121,6 +137,7 @@ export class RuntimeReceiptWriter<Input, Output> {
     maxBatchBytes?: number;
     maxBufferedBytes?: number;
     maxFlushMs?: number;
+    maxRetryElapsedMs?: number;
     onRetryEvent?: (event: RuntimeReceiptWriterRetryEvent<Input>) => void;
   }) {
     this.#batchKey = options.batchKey;
@@ -138,6 +155,10 @@ export class RuntimeReceiptWriter<Input, Output> {
       this.#maxBufferedBytes,
     );
     this.#maxFlushMs = Math.max(0, Math.floor(options.maxFlushMs ?? 5));
+    this.#maxRetryElapsedMs = normalizePositiveInteger(
+      options.maxRetryElapsedMs,
+      2 * 60_000,
+    );
     this.#onRetryEvent = options.onRetryEvent ?? null;
   }
 
@@ -357,7 +378,24 @@ export class RuntimeReceiptWriter<Input, Output> {
       } catch (error) {
         const retry = this.#classifyRetryableError(error);
         if (!retry) throw error;
+        const elapsedMs = Date.now() - startedAt;
+        if (elapsedMs >= this.#maxRetryElapsedMs) {
+          throw new RuntimeReceiptWriterRetryDeadlineError(
+            attempt,
+            elapsedMs,
+            this.#maxRetryElapsedMs,
+            { cause: error },
+          );
+        }
         const retryAfterMs = jitteredRetryDelayMs(retry.retryAfterMs);
+        if (elapsedMs + retryAfterMs > this.#maxRetryElapsedMs) {
+          throw new RuntimeReceiptWriterRetryDeadlineError(
+            attempt,
+            elapsedMs,
+            this.#maxRetryElapsedMs,
+            { cause: error },
+          );
+        }
         this.#emitRetryEvent({
           phase: 'retry',
           attempt,

package/dist/bundling-sources/shared_libs/play-runtime/test-runtime-seams.ts

@@ -26,7 +26,7 @@ type ParsedRuntimeTestFaults =
 
 type RuntimeTestSeamContext = {
   internalTokenHeader?: string | null;
-  syntheticRunHeader?: string | null;
+  verifiedSyntheticExecutor?: boolean;
 };
 
 type ParsedRuntimeTestFaultCounts =
@@ -44,6 +44,8 @@ type ValidatedRuntimeTestFaultHeader =
 export type RuntimeTestPolicyOverrides = {
   /** Opt-in bounded runner map latency profile for local/preview diagnosis. */
   mapLatencyProfile?: boolean;
+  /** Exercise provider pacing during fixture runs without dispatching provider traffic. */
+  enforceFixtureProviderPacing?: boolean;
   receiptLeaseTtlMs?: number;
   sheetAttemptLeaseMs?: number;
   heartbeatIntervalMs?: number;
@@ -117,10 +119,7 @@ function runtimeTestSeamsAuthorized(
   return (
     testRuntimeSeamsEnabled() ||
     internalTokenAllowsRuntimeSeams(context) ||
-    Boolean(
-      context?.syntheticRunHeader?.trim() &&
-      context.syntheticRunHeader.trim() !== '0',
-    )
+    context?.verifiedSyntheticExecutor === true
   );
 }
 
@@ -183,7 +182,8 @@ function parseRuntimeTestPolicyOverrides(
     (key) =>
       !RUNTIME_TEST_POLICY_MS_FIELDS.has(key) &&
       key !== 'workBudgetYieldLimits' &&
-      key !== 'mapLatencyProfile',
+      key !== 'mapLatencyProfile' &&
+      key !== 'enforceFixtureProviderPacing',
   );
   if (unknownKeys.length > 0) {
     return {
@@ -200,6 +200,16 @@ function parseRuntimeTestPolicyOverrides(
     }
     overrides.mapLatencyProfile = record.mapLatencyProfile;
   }
+  if ('enforceFixtureProviderPacing' in record) {
+    if (typeof record.enforceFixtureProviderPacing !== 'boolean') {
+      return {
+        error:
+          'testPolicyOverrides.enforceFixtureProviderPacing must be a boolean.',
+      };
+    }
+    overrides.enforceFixtureProviderPacing =
+      record.enforceFixtureProviderPacing;
+  }
   for (const field of RUNTIME_TEST_POLICY_MS_FIELDS) {
     if (!(field in record)) continue;
     const parsed = readPositiveIntegerField({
@@ -279,6 +289,7 @@ export function readRuntimeTestFaultRegistry(input: {
   headerValue: string | null;
   internalTokenHeader?: string | null;
   syntheticRunHeader?: string | null;
+  verifiedSyntheticExecutor?: boolean;
 }): ParsedRuntimeTestFaults {
   const headerValue = input.headerValue?.trim();
   if (!headerValue) {
@@ -320,6 +331,7 @@ export function validateRuntimeTestFaultHeader(input: {
   headerValue: string | null;
   internalTokenHeader?: string | null;
   syntheticRunHeader?: string | null;
+  verifiedSyntheticExecutor?: boolean;
 }): ValidatedRuntimeTestFaultHeader {
   const parsed = parseRuntimeTestFaultCounts(input);
   if (parsed.ok === false) {
@@ -332,6 +344,7 @@ export function parseRuntimeTestFaultCounts(input: {
   headerValue: string | null;
   internalTokenHeader?: string | null;
   syntheticRunHeader?: string | null;
+  verifiedSyntheticExecutor?: boolean;
 }): ParsedRuntimeTestFaultCounts {
   const headerValue = input.headerValue?.trim();
   if (!headerValue) {

package/dist/cli/index.js

@@ -1040,7 +1040,7 @@ var SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: "0.2.9",
+  version: "0.2.11",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -2177,6 +2177,13 @@ function projectPlayRunActivity(input2) {
     (dataset) => dataset.phase === "registered" || dataset.complete !== true && dataset.phase !== "failed"
   ).sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
   if (pendingDataset) {
+    const activeDatasetStep = input2.nodeStates?.find(
+      (candidate) => candidate.nodeId === input2.activeNodeId && candidate.status === "running" && candidate.artifactTableNamespace === pendingDataset.tableNamespace
+    );
+    const datasetStep = activeDatasetStep ?? input2.nodeStates?.find(
+      (candidate) => candidate.artifactTableNamespace === pendingDataset.tableNamespace
+    );
+    const datasetProgress = datasetStep?.progress ?? null;
     return projection(
       {
         schemaVersion: 1,
@@ -2189,12 +2196,12 @@ function projectPlayRunActivity(input2) {
         state: {
           kind: "active",
           progress: {
-            completed: pendingDataset.persistedRows,
-            total: typeof pendingDataset.succeededRows === "number" || typeof pendingDataset.failedRows === "number" ? (pendingDataset.succeededRows ?? 0) + (pendingDataset.failedRows ?? 0) : void 0,
-            failed: pendingDataset.failedRows
+            completed: datasetProgress?.completed ?? pendingDataset.persistedRows,
+            total: datasetProgress?.total ?? (typeof pendingDataset.succeededRows === "number" || typeof pendingDataset.failedRows === "number" ? (pendingDataset.succeededRows ?? 0) + (pendingDataset.failedRows ?? 0) : void 0),
+            failed: datasetProgress?.failed ?? pendingDataset.failedRows
           }
         },
-        observedAt: pendingDataset.updatedAt ?? observedAt
+        observedAt: datasetStep?.updatedAt ?? pendingDataset.updatedAt ?? observedAt
       },
       now
     );
@@ -3499,6 +3506,17 @@ function resolveToolExecuteTimeoutMs(toolId, input2) {
 }
 var RUNS_FAILED_LOG_LIMIT = 20;
 var RUN_LOGS_PAGE_LIMIT = 1e3;
+function requireTargetBillingIdempotencyKey(value) {
+  const normalized = value.trim();
+  if (normalized.length === 0 || normalized.length > 200 || normalized !== value) {
+    throw new DeeplineError(
+      "Billing idempotencyKey must contain 1\u2013200 characters with no leading or trailing whitespace.",
+      void 0,
+      "INVALID_BILLING_IDEMPOTENCY_KEY"
+    );
+  }
+  return normalized;
+}
 function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -3769,7 +3787,12 @@ var DeeplineClient = class {
       },
       invoices: {
         list: (options2) => this.listBillingInvoices(options2)
-      }
+      },
+      targetPlans: () => this.getTargetBillingPlans(),
+      targetStatus: () => this.getTargetBillingStatus(),
+      purchaseCredits: (options2) => this.purchaseTargetBillingCredits(options2),
+      transitionPlan: (options2) => this.transitionTargetBillingPlan(options2),
+      portalSession: () => this.createTargetBillingPortalSession()
     };
     this.monitors = {
       status: () => this.getMonitorsAccess(),
@@ -5683,6 +5706,52 @@ var DeeplineClient = class {
       `/api/v2/billing/invoices${suffix}`
     );
   }
+  /** List the reviewed target plans and whether new acquisition is enabled. */
+  async getTargetBillingPlans() {
+    return this.http.get("/api/v2/billing/plans");
+  }
+  /** Read the workspace's normalized target plan, payment, and balance state. */
+  async getTargetBillingStatus() {
+    return this.http.get("/api/v2/billing/status");
+  }
+  /**
+   * Purchase target-billing credits through the durable commercial operation
+   * flow. The caller supplies an idempotency key for safe retries.
+   */
+  async purchaseTargetBillingCredits(options) {
+    const idempotencyKey = requireTargetBillingIdempotencyKey(
+      options.idempotencyKey
+    );
+    return this.http.post(
+      "/api/v2/billing/credit-purchases",
+      { credits: options.credits },
+      { "Idempotency-Key": idempotencyKey },
+      { maxRetries: 0, exactUrlOnly: true }
+    );
+  }
+  /**
+   * Start, change, cancel, or restore a target plan through one idempotent
+   * commercial operation.
+   */
+  async transitionTargetBillingPlan(options) {
+    const idempotencyKey = requireTargetBillingIdempotencyKey(
+      options.idempotencyKey
+    );
+    return this.http.post(
+      "/api/v2/billing/plan-transitions",
+      {
+        action: options.action,
+        ...options.targetPlanSku ? { target_plan_sku: options.targetPlanSku } : {}
+      },
+      { "Idempotency-Key": idempotencyKey },
+      { maxRetries: 0, exactUrlOnly: true }
+    );
+  }
+  /** Create a Stripe-hosted portal session for payment recovery and invoices. */
+  async createTargetBillingPortalSession() {
+    const response = await this.http.post("/api/v2/billing/portal-sessions", {});
+    return response.data;
+  }
   // ——————————————————————————————————————————————————————————
   // Monitors
   // ——————————————————————————————————————————————————————————
@@ -7493,6 +7562,9 @@ function topUpIdempotencyKey(raw) {
   }
   return `cli_topup:${Date.now()}:${(0, import_node_crypto2.randomUUID)()}`;
 }
+function targetBillingIdempotencyKey(raw) {
+  return typeof raw === "string" ? raw : `cli_target_billing:${Date.now()}:${(0, import_node_crypto2.randomUUID)()}`;
+}
 function checkoutCommandForCredits(credits) {
   return `deepline billing checkout --credits ${credits} --no-open --json`;
 }
@@ -8298,6 +8370,92 @@ async function handleTopUp(creditsRaw, options) {
     json: options.json
   });
 }
+async function handleTargetStatus(options) {
+  const client2 = new DeeplineClient();
+  const payload = await client2.billing.targetStatus();
+  printCommandEnvelope(
+    {
+      ok: true,
+      ...payload,
+      render: {
+        sections: [
+          {
+            title: "billing status",
+            lines: [
+              `Plan: ${payload.plan.name} (${payload.plan.sku})`,
+              `State: ${payload.state}`,
+              `Payment: ${payload.payment_state}`,
+              `Automatic recharge: ${payload.recharge_state}`
+            ]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+async function handleBuyCredits(creditsRaw, options) {
+  const credits = parseTopUpCredits(creditsRaw);
+  if (credits === null) {
+    reportBillingFailure(
+      {
+        exitCode: 2,
+        code: "INVALID_CREDITS",
+        message: "<credits> must be a positive integer."
+      },
+      options
+    );
+    return;
+  }
+  const idempotencyKey = targetBillingIdempotencyKey(options.idempotencyKey);
+  const payload = await new DeeplineClient().billing.purchaseCredits({
+    credits,
+    idempotencyKey
+  });
+  printCommandEnvelope(
+    { ok: true, idempotency_key: idempotencyKey, ...payload },
+    { json: options.json }
+  );
+}
+async function handleTargetPlan(planSku, options) {
+  if (planSku !== "payg-v1" && planSku !== "builder-v1" && planSku !== "team-v1") {
+    reportBillingFailure(
+      {
+        exitCode: 2,
+        code: "INVALID_PLAN",
+        message: "Plan must be payg-v1, builder-v1, or team-v1."
+      },
+      options
+    );
+    return;
+  }
+  const idempotencyKey = targetBillingIdempotencyKey(options.idempotencyKey);
+  const payload = await new DeeplineClient().billing.transitionPlan({
+    action: "start_or_change",
+    targetPlanSku: planSku,
+    idempotencyKey
+  });
+  printCommandEnvelope(
+    { ok: true, idempotency_key: idempotencyKey, ...payload },
+    { json: options.json }
+  );
+}
+async function handleTargetPlanCancellation(options) {
+  const idempotencyKey = targetBillingIdempotencyKey(options.idempotencyKey);
+  const payload = await new DeeplineClient().billing.transitionPlan({
+    action: options.undo ? "undo_cancel" : "cancel",
+    idempotencyKey
+  });
+  printCommandEnvelope(
+    { ok: true, idempotency_key: idempotencyKey, ...payload },
+    { json: options.json }
+  );
+}
+async function handleTargetPortal(options) {
+  const payload = await new DeeplineClient().billing.portalSession();
+  if (!options.json && !options.noOpen) openInBrowser(payload.url);
+  printCommandEnvelope({ ok: true, ...payload }, { json: options.json });
+}
 async function handleRedeemCode(code, options) {
   const { http } = getAuthedHttpClient();
   const payload = await http.post(
@@ -8493,6 +8651,11 @@ Examples:
     "--idempotency-key <key>",
     "Stable retry key for the same intended top-up"
   ).option("--dry-run", "Print the planned top-up without charging").option("--compact", "Keep only high-signal fields in JSON output").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleTopUp);
+  billing.command("buy").description("Buy credits through the target billing contract.").argument("<credits>", "Positive integer Deepline credit amount").option("--idempotency-key <key>", "Stable retry key").option("--json", "Emit JSON output").action(handleBuyCredits);
+  billing.command("status").description("Show normalized target billing state.").option("--json", "Emit JSON output").action(handleTargetStatus);
+  billing.command("change-plan").description("Start or change the target billing plan.").argument("<plan_sku>", "payg-v1, builder-v1, or team-v1").option("--idempotency-key <key>", "Stable retry key").option("--json", "Emit JSON output").action(handleTargetPlan);
+  billing.command("cancel-plan").description("Cancel a target subscription at period end, or undo it.").option("--undo", "Undo a pending period-end cancellation").option("--idempotency-key <key>", "Stable retry key").option("--json", "Emit JSON output").action(handleTargetPlanCancellation);
+  billing.command("portal").description("Open the Stripe-hosted billing recovery portal.").option("--no-open", "Print the URL without opening a browser").option("--json", "Emit JSON output").action(handleTargetPortal);
   billing.command("plans").description("Show published plans and the plan you are on.").addHelpText(
     "after",
     `