deepline 0.1.265 → 0.1.266

package/dist/bundling-sources/sdk/src/release.ts

@@ -125,7 +125,7 @@ export const 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.265',
+  version: '0.1.266',
   apiContract: '2026-07-admin-cli-local-cutover',
   supportPolicy: {
     minimumSupported: '0.1.53',

package/dist/bundling-sources/sdk/src/types.ts

@@ -677,6 +677,64 @@ export interface PlayStatus {
   };
   /** Exact ordinary `plays run` command that can rerun a failed execution. */
   rerunCommand?: string;
+  /**
+   * Projected settled-charge billing for the run. Returned by `runs.get`.
+   * `totalCredits`/`providerEvents` describe THIS run only; `rollup` (present
+   * with `--full`) carries the true subtree cost including ctx.runPlay children.
+   * Deepline credits only — provider spend is never exposed.
+   */
+  billing?: RunBillingSummary;
+  /**
+   * True subtree cost in Deepline credits (this run + every descendant run),
+   * mirrored to the top level for convenience. Present only with `--full`.
+   */
+  billingTotalCreditsRollup?: number;
+  /** Deepline credits attributable to descendant runs only. Present with `--full`. */
+  billingChildCredits?: number;
+  /** True when the child-run billing rollup could not be fully resolved. */
+  billingRollupIncomplete?: boolean;
+  /** Durable summaries of ctx.runPlay children, returned by `runs.get --full`. */
+  childRuns?: ChildRunSummary[];
+}
+
+/** One ctx.runPlay child run exposed on the parent's `--full` payload. */
+export interface ChildRunSummary {
+  runId: string;
+  playName?: string | null;
+  status: string;
+  parentRunId?: string | null;
+  rootRunId?: string | null;
+  createdAt?: number | null;
+  startedAt?: number | null;
+  finishedAt?: number | null;
+}
+
+/**
+ * Rolled-up billing for a run subtree, projected from settled Charge Lifecycle
+ * facts. Deepline credits only — never provider spend.
+ */
+export interface RunBillingSummary {
+  runId: string;
+  /** THIS run's own charges (parent-only; excludes descendant runs). */
+  totalCalls: number;
+  totalCredits: number;
+  providerEvents: number;
+  computeEvents: number;
+  /** Subtree rollup including descendant ctx.runPlay runs. Present with `--full`. */
+  rollup?: {
+    totalCreditsRollup: number;
+    childCredits: number;
+    ownCredits: number;
+    totalCallsRollup: number;
+    providerEventsRollup: number;
+    computeEventsRollup: number;
+    childProviderEvents: number;
+    childComputeEvents: number;
+    descendantRunCount: number;
+    rollupComplete: boolean;
+    rollupError?: string;
+  };
+  [key: string]: unknown;
 }
 
 export type LiveEventScope = 'play' | 'agent';

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

@@ -51,6 +51,7 @@ import {
   isRetryableSecretResolutionStatus,
   secretResolutionRetryDecision,
   SECRET_RESOLUTION_MAX_ATTEMPTS,
+  SECRET_RESOLUTION_ATTEMPT_TIMEOUT_MS,
   type SecretResolutionRetryDecision,
 } from './secret-resolution-retry-policy';
 import {
@@ -307,6 +308,16 @@ const TOOL_BATCH_COALESCE_WINDOW_MS = 5;
 const TOOL_RETRY_AFTER_FALLBACK_MS = 1_000;
 const TOOL_RETRY_HEARTBEAT_INTERVAL_MS = 30_000;
 const DEEPLINEAGENT_TOOL_RUNTIME_TIMEOUT_MS = 15 * 60 * 1000;
+// Every runtime-API tool fetch needs a client-side deadline. Without one, a
+// stalled execute request (e.g. a credential-less call whose gateway connection
+// hangs before the fast 403 can return) leaves the row "1 in flight" for minutes
+// until the outer run deadline, violating loud-failure. The integrations execute
+// route caps server work at maxDuration=900s, so this ceiling sits just above it:
+// a healthy server (including the fast INTEGRATION_CREDENTIALS_MISSING 403) always
+// responds first, and only a genuinely stuck socket trips the abort — surfacing as
+// a bounded, repairable transport failure that row-isolation settles per row
+// instead of hanging the whole run.
+const DEFAULT_TOOL_RUNTIME_TIMEOUT_MS = 15 * 60 * 1000 + 30_000;
 const FETCH_TRANSPORT_MAX_ATTEMPTS = 3;
 const FETCH_TRANSPORT_RETRY_DELAY_MS = 100;
 // cloudflared returns this branded HTML when its connection to the local app
@@ -493,13 +504,17 @@ export function resolveToolRuntimeTimeoutMs(
     return Math.max(1, Math.ceil(requestedTimeoutMs));
   }
   const normalized = toolId.trim().toLowerCase();
+  // Long-inference tools keep their explicit 15-minute budget. Every other tool
+  // gets the default ceiling so no runtime-API fetch is ever unbounded — a
+  // missing-credential or otherwise stuck request fails loudly and fast within
+  // the deadline instead of hanging "1 in flight".
   return normalized === 'deeplineagent' ||
     normalized === 'deeplineagent_deeplineagent' ||
     normalized === 'ai_inference' ||
     normalized === 'deeplineagent_ai_inference' ||
     normalized === 'aiinference'
     ? DEEPLINEAGENT_TOOL_RUNTIME_TIMEOUT_MS
-    : undefined;
+    : DEFAULT_TOOL_RUNTIME_TIMEOUT_MS;
 }
 
 function isDeeplineDeveloperTunnelOrigin502(input: {
@@ -1586,6 +1601,10 @@ export class PlayContextImpl {
         try {
           response = await fetch(url, {
             method: 'POST',
+            // Bound the control-plane call so a stalled connection aborts and is
+            // caught below as a transport failure instead of hanging the tool
+            // call "1 in flight" forever.
+            signal: AbortSignal.timeout(SECRET_RESOLUTION_ATTEMPT_TIMEOUT_MS),
             headers: {
               Authorization: `Bearer ${this.#options.executorToken}`,
               'Content-Type': 'application/json',

package/dist/bundling-sources/shared_libs/play-runtime/csv-rename.ts

@@ -44,6 +44,29 @@ function sourceAliases(target: string, aliases: string | readonly string[]) {
   return [target, ...(Array.isArray(aliases) ? aliases : [aliases])];
 }
 
+/**
+ * `required` is a HEADER-presence guarantee, not a per-row non-null check.
+ *
+ * A required target is satisfied when at least one of its source aliases exists
+ * as a column in the CSV row (present in the header), regardless of whether this
+ * particular row's cell is blank. Blank cells in a present column are DATA, not a
+ * schema violation: they must flow through to the dataset so `onRowError` (or the
+ * play's own branching) governs them per row, never guillotine the whole run.
+ * Only a column that is entirely absent from the CSV is a `required` violation.
+ */
+function hasAliasColumnPresent(
+  lookup: Map<string, unknown>,
+  target: string,
+  sourceNames: string | readonly string[],
+): boolean {
+  for (const alias of sourceAliases(target, sourceNames)) {
+    if (lookup.has(alias) || lookup.has(normalizeCsvHeader(alias))) {
+      return true;
+    }
+  }
+  return false;
+}
+
 export function applyCsvRenameProjection<T extends Record<string, unknown>>(
   rows: readonly T[],
   options?: CsvRenameOptions,
@@ -52,11 +75,26 @@ export function applyCsvRenameProjection<T extends Record<string, unknown>>(
     ...(options?.rename ?? {}),
     ...(options?.columns ?? {}),
   };
+  const required = new Set(options?.required ?? []);
+
   if (Object.keys(aliases).length === 0) {
+    // No rename/alias projection requested. `required` is still a
+    // header-presence guarantee: assert each required column exists in the CSV
+    // (checked against the first row's shape), then pass rows through untouched.
+    // A present-but-blank cell is data, never a `required` violation.
+    if (required.size > 0 && rows.length > 0) {
+      const lookup = buildRowLookup(rows[0]!);
+      for (const target of required) {
+        if (!hasAliasColumnPresent(lookup, target, target)) {
+          throw new Error(
+            `ctx.csv(..., { required }) is missing required column "${target}". ` +
+              `Add a "${target}" column to the CSV header.`,
+          );
+        }
+      }
+    }
     return [...rows];
   }
-
-  const required = new Set(options?.required ?? []);
   return rows.map((row, index) => {
     const lookup = buildRowLookup(row);
     const projectedFields = new Set<string>();
@@ -88,9 +126,17 @@ export function applyCsvRenameProjection<T extends Record<string, unknown>>(
         } else {
           projected[target] = selected;
         }
-      } else if (required.has(target)) {
+      } else if (
+        required.has(target) &&
+        !hasAliasColumnPresent(lookup, target, sourceNames)
+      ) {
+        // The column is entirely absent from the CSV header — a schema/config
+        // error that is identical for every row. A present-but-blank cell is
+        // data and must NOT trip this: it flows through so onRowError can
+        // isolate that row instead of failing the whole run.
         throw new Error(
-          `ctx.csv(..., { rename }) row ${index + 1} is missing required column "${target}".`,
+          `ctx.csv(..., { required }) is missing required column "${target}". ` +
+            `Add a "${target}" column (or one of its aliases) to the CSV header.`,
         );
       }
     }

package/dist/bundling-sources/shared_libs/play-runtime/secret-resolution-retry-policy.ts

@@ -1,5 +1,11 @@
 export const SECRET_RESOLUTION_MAX_ATTEMPTS = 3;
 export const SECRET_RESOLUTION_MAX_RETRY_AFTER_MS = 2_000;
+// Per-attempt client deadline for the secret-resolution gateway call. This is an
+// internal control-plane fetch (resolve a named secret), not provider work, so it
+// must return quickly. Without a bound, a stalled connection hangs the tool call
+// "1 in flight" indefinitely; an abort here is caught as a transport failure and
+// retried/failed loudly via secretResolutionRetryDecision.
+export const SECRET_RESOLUTION_ATTEMPT_TIMEOUT_MS = 30_000;
 
 const SECRET_RESOLUTION_RETRY_JITTER_CAPS_MS = [100, 250] as const;
 

package/dist/cli/index.js

@@ -718,7 +718,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.265",
+  version: "0.1.266",
   apiContract: "2026-07-admin-cli-local-cutover",
   supportPolicy: {
     minimumSupported: "0.1.53",
@@ -14256,6 +14256,26 @@ function withOrdinaryRunAgainCommand(status, options, resolvedRevisionId) {
     rerunCommand: buildOrdinaryPlayRunCommand(options, resolvedRevisionId)
   } : status;
 }
+function buildBillingRollupTextLines(status) {
+  const billing = status.billing;
+  const rollup = billing?.rollup;
+  if (!rollup) return [];
+  const total = formatCreditAmount(rollup.totalCreditsRollup);
+  if (rollup.childCredits > 0 && rollup.descendantRunCount > 0) {
+    const own = formatCreditAmount(rollup.ownCredits);
+    const child = formatCreditAmount(rollup.childCredits);
+    const suffix = rollup.rollupComplete ? "" : " (incomplete: child billing could not be fully resolved)";
+    return [
+      `  cost: ${total} credits total \u2014 ${own} this run + ${child} across ${rollup.descendantRunCount} child run${rollup.descendantRunCount === 1 ? "" : "s"}${suffix}`
+    ];
+  }
+  if (!rollup.rollupComplete) {
+    return [
+      `  cost: ${total} credits (incomplete: child billing could not be fully resolved${rollup.rollupError ? ` \u2014 ${rollup.rollupError}` : ""})`
+    ];
+  }
+  return [`  cost: ${total} credits`];
+}
 function writePlayResult(status, jsonOutput, options) {
   const packaged = getPlayRunPackage(status);
   if (jsonOutput) {
@@ -14318,6 +14338,7 @@ function writePlayResult(status, jsonOutput, options) {
     lines.push(...renderedServerView.lines);
   }
   lines.push(...renderedServerView.actions);
+  lines.push(...buildBillingRollupTextLines(status));
   const compact = compactPlayStatus(status);
   const payload = options?.fullJson ? status : compact;
   printCommandEnvelope(

package/dist/cli/index.mjs

@@ -703,7 +703,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.265",
+  version: "0.1.266",
   apiContract: "2026-07-admin-cli-local-cutover",
   supportPolicy: {
     minimumSupported: "0.1.53",
@@ -14285,6 +14285,26 @@ function withOrdinaryRunAgainCommand(status, options, resolvedRevisionId) {
     rerunCommand: buildOrdinaryPlayRunCommand(options, resolvedRevisionId)
   } : status;
 }
+function buildBillingRollupTextLines(status) {
+  const billing = status.billing;
+  const rollup = billing?.rollup;
+  if (!rollup) return [];
+  const total = formatCreditAmount(rollup.totalCreditsRollup);
+  if (rollup.childCredits > 0 && rollup.descendantRunCount > 0) {
+    const own = formatCreditAmount(rollup.ownCredits);
+    const child = formatCreditAmount(rollup.childCredits);
+    const suffix = rollup.rollupComplete ? "" : " (incomplete: child billing could not be fully resolved)";
+    return [
+      `  cost: ${total} credits total \u2014 ${own} this run + ${child} across ${rollup.descendantRunCount} child run${rollup.descendantRunCount === 1 ? "" : "s"}${suffix}`
+    ];
+  }
+  if (!rollup.rollupComplete) {
+    return [
+      `  cost: ${total} credits (incomplete: child billing could not be fully resolved${rollup.rollupError ? ` \u2014 ${rollup.rollupError}` : ""})`
+    ];
+  }
+  return [`  cost: ${total} credits`];
+}
 function writePlayResult(status, jsonOutput, options) {
   const packaged = getPlayRunPackage(status);
   if (jsonOutput) {
@@ -14347,6 +14367,7 @@ function writePlayResult(status, jsonOutput, options) {
     lines.push(...renderedServerView.lines);
   }
   lines.push(...renderedServerView.actions);
+  lines.push(...buildBillingRollupTextLines(status));
   const compact = compactPlayStatus(status);
   const payload = options?.fullJson ? status : compact;
   printCommandEnvelope(

package/dist/index.d.mts

@@ -667,6 +667,62 @@ interface PlayStatus {
     };
     /** Exact ordinary `plays run` command that can rerun a failed execution. */
     rerunCommand?: string;
+    /**
+     * Projected settled-charge billing for the run. Returned by `runs.get`.
+     * `totalCredits`/`providerEvents` describe THIS run only; `rollup` (present
+     * with `--full`) carries the true subtree cost including ctx.runPlay children.
+     * Deepline credits only — provider spend is never exposed.
+     */
+    billing?: RunBillingSummary;
+    /**
+     * True subtree cost in Deepline credits (this run + every descendant run),
+     * mirrored to the top level for convenience. Present only with `--full`.
+     */
+    billingTotalCreditsRollup?: number;
+    /** Deepline credits attributable to descendant runs only. Present with `--full`. */
+    billingChildCredits?: number;
+    /** True when the child-run billing rollup could not be fully resolved. */
+    billingRollupIncomplete?: boolean;
+    /** Durable summaries of ctx.runPlay children, returned by `runs.get --full`. */
+    childRuns?: ChildRunSummary[];
+}
+/** One ctx.runPlay child run exposed on the parent's `--full` payload. */
+interface ChildRunSummary {
+    runId: string;
+    playName?: string | null;
+    status: string;
+    parentRunId?: string | null;
+    rootRunId?: string | null;
+    createdAt?: number | null;
+    startedAt?: number | null;
+    finishedAt?: number | null;
+}
+/**
+ * Rolled-up billing for a run subtree, projected from settled Charge Lifecycle
+ * facts. Deepline credits only — never provider spend.
+ */
+interface RunBillingSummary {
+    runId: string;
+    /** THIS run's own charges (parent-only; excludes descendant runs). */
+    totalCalls: number;
+    totalCredits: number;
+    providerEvents: number;
+    computeEvents: number;
+    /** Subtree rollup including descendant ctx.runPlay runs. Present with `--full`. */
+    rollup?: {
+        totalCreditsRollup: number;
+        childCredits: number;
+        ownCredits: number;
+        totalCallsRollup: number;
+        providerEventsRollup: number;
+        computeEventsRollup: number;
+        childProviderEvents: number;
+        childComputeEvents: number;
+        descendantRunCount: number;
+        rollupComplete: boolean;
+        rollupError?: string;
+    };
+    [key: string]: unknown;
 }
 type LiveEventScope = 'play' | 'agent';
 interface LiveEventEnvelope<TPayload = unknown> {

package/dist/index.d.ts

@@ -667,6 +667,62 @@ interface PlayStatus {
     };
     /** Exact ordinary `plays run` command that can rerun a failed execution. */
     rerunCommand?: string;
+    /**
+     * Projected settled-charge billing for the run. Returned by `runs.get`.
+     * `totalCredits`/`providerEvents` describe THIS run only; `rollup` (present
+     * with `--full`) carries the true subtree cost including ctx.runPlay children.
+     * Deepline credits only — provider spend is never exposed.
+     */
+    billing?: RunBillingSummary;
+    /**
+     * True subtree cost in Deepline credits (this run + every descendant run),
+     * mirrored to the top level for convenience. Present only with `--full`.
+     */
+    billingTotalCreditsRollup?: number;
+    /** Deepline credits attributable to descendant runs only. Present with `--full`. */
+    billingChildCredits?: number;
+    /** True when the child-run billing rollup could not be fully resolved. */
+    billingRollupIncomplete?: boolean;
+    /** Durable summaries of ctx.runPlay children, returned by `runs.get --full`. */
+    childRuns?: ChildRunSummary[];
+}
+/** One ctx.runPlay child run exposed on the parent's `--full` payload. */
+interface ChildRunSummary {
+    runId: string;
+    playName?: string | null;
+    status: string;
+    parentRunId?: string | null;
+    rootRunId?: string | null;
+    createdAt?: number | null;
+    startedAt?: number | null;
+    finishedAt?: number | null;
+}
+/**
+ * Rolled-up billing for a run subtree, projected from settled Charge Lifecycle
+ * facts. Deepline credits only — never provider spend.
+ */
+interface RunBillingSummary {
+    runId: string;
+    /** THIS run's own charges (parent-only; excludes descendant runs). */
+    totalCalls: number;
+    totalCredits: number;
+    providerEvents: number;
+    computeEvents: number;
+    /** Subtree rollup including descendant ctx.runPlay runs. Present with `--full`. */
+    rollup?: {
+        totalCreditsRollup: number;
+        childCredits: number;
+        ownCredits: number;
+        totalCallsRollup: number;
+        providerEventsRollup: number;
+        computeEventsRollup: number;
+        childProviderEvents: number;
+        childComputeEvents: number;
+        descendantRunCount: number;
+        rollupComplete: boolean;
+        rollupError?: string;
+    };
+    [key: string]: unknown;
 }
 type LiveEventScope = 'play' | 'agent';
 interface LiveEventEnvelope<TPayload = unknown> {

package/dist/index.js

@@ -437,7 +437,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.265",
+  version: "0.1.266",
   apiContract: "2026-07-admin-cli-local-cutover",
   supportPolicy: {
     minimumSupported: "0.1.53",

package/dist/index.mjs

@@ -367,7 +367,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.265",
+  version: "0.1.266",
   apiContract: "2026-07-admin-cli-local-cutover",
   supportPolicy: {
     minimumSupported: "0.1.53",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.265",
+  "version": "0.1.266",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {