deepline 0.3.34 → 0.3.36

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

@@ -199,7 +199,7 @@ export const SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: '0.3.34',
+  version: '0.3.36',
   updateSummary:
     'Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.',
   packageCapabilities: {

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

@@ -1,3 +1,8 @@
+import type {
+  ToolExecutionErrorCategory,
+  ToolExecutionErrorOrigin,
+} from '../tool-execution-error';
+
 /**
  * The durable terminal envelope carries the complete 5 MiB authored return
  * plus bounded scheduler-owned metadata (progress, warnings, and a log tail).
@@ -301,6 +306,14 @@ const LEDGER_STRIPPED_TERMINAL_RESULT_KEYS = [
   'suspension',
 ] as const;
 
+export type LedgerTerminalFailureSummary = {
+  code: string;
+  phase: string;
+  retryable: boolean | null;
+  origin?: ToolExecutionErrorOrigin;
+  category?: ToolExecutionErrorCategory;
+};
+
 /** A tiny reference descriptor left in place of a dropped over-limit result. */
 export type LedgerTerminalResultRef = {
   __kind: 'deepline.ledger_terminal_result_ref.v1';
@@ -323,6 +336,8 @@ export type LedgerTerminalResultRef = {
    * fetching the complete scheduler result.
    */
   preview?: BoundedRunListOutputPreview;
+  /** Failure ownership retained when the full failed result is out of line. */
+  failure?: LedgerTerminalFailureSummary;
 };
 
 export const LEDGER_TERMINAL_RESULT_STORED_WARNING =
@@ -682,6 +697,7 @@ function ledgerTerminalResultRef(
     content?: 'full';
     bytes?: number;
     preview?: BoundedRunListOutputPreview;
+    failure?: LedgerTerminalFailureSummary;
   } = {},
 ): LedgerTerminalResultRef {
   return {
@@ -693,12 +709,83 @@ function ledgerTerminalResultRef(
     projection: 'out_of_line',
     ...(options.content ? { content: options.content } : {}),
     ...(options.preview ? { preview: options.preview } : {}),
+    ...(options.failure ? { failure: options.failure } : {}),
     warning: options.content
       ? LEDGER_TERMINAL_RESULT_STORED_WARNING
       : LEDGER_TERMINAL_RESULT_OMITTED_WARNING,
   };
 }
 
+const TOOL_ERROR_ORIGINS = new Set<ToolExecutionErrorOrigin>([
+  'caller',
+  'provider',
+  'deepline',
+  'unknown',
+]);
+
+const TOOL_ERROR_CATEGORIES = new Set<ToolExecutionErrorCategory>([
+  'validation',
+  'authentication',
+  'authorization',
+  'rate_limit',
+  'network',
+  'upstream',
+  'billing',
+  'conflict',
+  'internal',
+  'unknown',
+]);
+
+const LEDGER_FAILURE_CODE_MAX_LENGTH = 160;
+const LEDGER_FAILURE_PHASE_MAX_LENGTH = 80;
+
+function terminalFailureSummary(
+  value: unknown,
+): LedgerTerminalFailureSummary | undefined {
+  if (!isPlainObject(value) || !Array.isArray(value.errors)) return undefined;
+  const first = value.errors.find(isPlainObject);
+  if (!first) return undefined;
+  const rawRetryable = first.retryable;
+  let retryable: boolean | null;
+  if (typeof rawRetryable === 'boolean') {
+    retryable = rawRetryable;
+  } else if (rawRetryable === null) {
+    retryable = null;
+  } else {
+    return undefined;
+  }
+  if (typeof first.code !== 'string' || typeof first.phase !== 'string') {
+    return undefined;
+  }
+  const code = first.code.trim();
+  const phase = first.phase.trim();
+  if (
+    !code ||
+    code.length > LEDGER_FAILURE_CODE_MAX_LENGTH ||
+    !phase ||
+    phase.length > LEDGER_FAILURE_PHASE_MAX_LENGTH
+  ) {
+    return undefined;
+  }
+  const origin = TOOL_ERROR_ORIGINS.has(
+    first.origin as ToolExecutionErrorOrigin,
+  )
+    ? (first.origin as ToolExecutionErrorOrigin)
+    : undefined;
+  const category = TOOL_ERROR_CATEGORIES.has(
+    first.category as ToolExecutionErrorCategory,
+  )
+    ? (first.category as ToolExecutionErrorCategory)
+    : undefined;
+  return {
+    code,
+    phase,
+    retryable,
+    ...(origin ? { origin } : {}),
+    ...(category ? { category } : {}),
+  };
+}
+
 export function ledgerTerminalResultRefForValue(
   value: unknown,
   reason: LedgerTerminalResultRefReason,
@@ -721,7 +808,12 @@ export function ledgerTerminalResultRefForValue(
       // persistence failure.
     }
   }
-  return ledgerTerminalResultRef(reason, { ...options, bytes, preview });
+  return ledgerTerminalResultRef(reason, {
+    ...options,
+    bytes,
+    preview,
+    failure: terminalFailureSummary(value),
+  });
 }
 
 /** Optional derived summaries must never block the terminal lifecycle event. */

package/dist/bundling-sources/shared_libs/play-runtime/run-failure.ts

@@ -1,4 +1,8 @@
-import { ToolExecutionError } from '../tool-execution-error';
+import {
+  ToolExecutionError,
+  type ToolExecutionErrorCategory,
+  type ToolExecutionErrorOrigin,
+} from '../tool-execution-error';
 
 const CLOUDFLARE_DURABLE_OBJECT_RESET_RE =
   /Durable Object.*(?:code (?:was|has been) updated|storage caused object)/;
@@ -186,6 +190,10 @@ export type PlayRunFailureDetails = {
   phase: string;
   message: string;
   retryable: boolean | null;
+  /** Original ownership boundary when the failure came from a typed tool call. */
+  origin?: ToolExecutionErrorOrigin;
+  /** Original reason family when the failure came from a typed tool call. */
+  category?: ToolExecutionErrorCategory;
   cause?: string;
   name?: string;
   stack?: string;
@@ -305,6 +313,8 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       phase: 'billing',
       message: cause,
       retryable: false,
+      origin: error.origin,
+      category: error.category,
       cause,
     };
   }
@@ -534,7 +544,10 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
     code: 'RUN_FAILED',
     phase: 'runtime',
     message: cause,
-    retryable: null,
+    retryable: error instanceof ToolExecutionError ? error.retryable : null,
+    ...(error instanceof ToolExecutionError
+      ? { origin: error.origin, category: error.category }
+      : {}),
     ...(diagnostics
       ? {
           name: diagnostics.name,

package/dist/bundling-sources/shared_libs/plays/resolve-static-pipeline.ts

@@ -16,6 +16,12 @@ export type ResolveStaticPipelineInput = {
     playId: string,
   ) => Promise<ResolvablePlayStaticShape | null>;
   maxDepth?: number;
+  /**
+   * Keep an embedded local-import contract when one is present, while still
+   * resolving compact calls nested inside it. Named live calls omit the
+   * embedded pipeline and continue through the registry resolver.
+   */
+  preferEmbeddedPlayCalls?: boolean;
 };
 
 function clonePipeline(pipeline: PlayStaticPipeline): PlayStaticPipeline {
@@ -69,8 +75,17 @@ async function resolvePipelineSubsteps(input: {
   ) => Promise<ResolvablePlayStaticShape | null>;
   stack: string[];
   maxDepth: number;
+  preferEmbeddedPlayCalls: boolean;
+  resolvedPipelineCache: Map<string, Promise<PlayStaticPipeline | null>>;
 }): Promise<PlayStaticSubstep[]> {
-  const { steps, resolveReferencedPlay, stack, maxDepth } = input;
+  const {
+    steps,
+    resolveReferencedPlay,
+    stack,
+    maxDepth,
+    preferEmbeddedPlayCalls,
+    resolvedPipelineCache,
+  } = input;
   const callDepth = Math.max(0, stack.length - 1);
 
   return await Promise.all(
@@ -81,20 +96,44 @@ async function resolvePipelineSubsteps(input: {
       });
 
       if (
-        (annotated.type === 'dataset' ||
-          annotated.type === 'step_suite' ||
-          annotated.type === 'control_flow') &&
-        annotated.steps?.length
+        annotated.type === 'dataset' ||
+        annotated.type === 'step_suite' ||
+        annotated.type === 'control_flow'
       ) {
-        return {
+        const nested = {
           ...annotated,
-          steps: await resolvePipelineSubsteps({
-            steps: annotated.steps,
-            resolveReferencedPlay,
-            stack,
-            maxDepth,
-          }),
-        } satisfies PlayStaticSubstep;
+          ...(annotated.steps?.length
+            ? {
+                steps: await resolvePipelineSubsteps({
+                  steps: annotated.steps,
+                  resolveReferencedPlay,
+                  stack,
+                  maxDepth,
+                  preferEmbeddedPlayCalls,
+                  resolvedPipelineCache,
+                }),
+              }
+            : {}),
+        };
+        if (nested.type === 'control_flow' && nested.branches?.length) {
+          return {
+            ...nested,
+            branches: await Promise.all(
+              nested.branches.map(async (branch) => ({
+                ...branch,
+                steps: await resolvePipelineSubsteps({
+                  steps: branch.steps,
+                  resolveReferencedPlay,
+                  stack,
+                  maxDepth,
+                  preferEmbeddedPlayCalls,
+                  resolvedPipelineCache,
+                }),
+              })),
+            ),
+          } satisfies PlayStaticSubstep;
+        }
+        return nested satisfies PlayStaticSubstep;
       }
 
       if (annotated.type !== 'play_call') {
@@ -118,9 +157,51 @@ async function resolvePipelineSubsteps(input: {
         } satisfies PlayStaticSubstep;
       }
 
-      const childShape = await resolveReferencedPlay(annotated.playId);
-      const childPipeline = materializePipeline(childShape);
-      if (!childPipeline) {
+      const cacheKey = JSON.stringify([...stack, annotated.playId]);
+      let resolvedChildPipelinePromise = resolvedPipelineCache.get(cacheKey);
+      if (!resolvedChildPipelinePromise) {
+        resolvedChildPipelinePromise = (async () => {
+          const childShape =
+            preferEmbeddedPlayCalls && annotated.pipeline
+              ? { staticPipeline: annotated.pipeline }
+              : await resolveReferencedPlay(annotated.playId);
+          const childPipeline = materializePipeline(childShape);
+          if (!childPipeline) {
+            return null;
+          }
+
+          const resolvedChildPipeline = {
+            ...childPipeline,
+            stages: await resolvePipelineSubsteps({
+              steps: childPipeline.stages ?? [],
+              resolveReferencedPlay,
+              stack: [...stack, annotated.playId],
+              maxDepth,
+              preferEmbeddedPlayCalls,
+              resolvedPipelineCache,
+            }),
+            substeps: await resolvePipelineSubsteps({
+              steps: childPipeline.substeps,
+              resolveReferencedPlay,
+              stack: [...stack, annotated.playId],
+              maxDepth,
+              preferEmbeddedPlayCalls,
+              resolvedPipelineCache,
+            }),
+          };
+          const childContract = compileSheetContract(resolvedChildPipeline);
+
+          return {
+            ...resolvedChildPipeline,
+            sheetContract: childContract.contract,
+            sheetContractErrors: childContract.errors,
+          };
+        })();
+        resolvedPipelineCache.set(cacheKey, resolvedChildPipelinePromise);
+      }
+
+      const resolvedChildPipeline = await resolvedChildPipelinePromise;
+      if (!resolvedChildPipeline) {
         return {
           ...annotated,
           resolutionError: `Unable to statically resolve play "${annotated.playId}"`,
@@ -128,30 +209,9 @@ async function resolvePipelineSubsteps(input: {
         } satisfies PlayStaticSubstep;
       }
 
-      const resolvedChildPipeline = {
-        ...childPipeline,
-        stages: await resolvePipelineSubsteps({
-          steps: childPipeline.stages ?? [],
-          resolveReferencedPlay,
-          stack: [...stack, annotated.playId],
-          maxDepth,
-        }),
-        substeps: await resolvePipelineSubsteps({
-          steps: childPipeline.substeps,
-          resolveReferencedPlay,
-          stack: [...stack, annotated.playId],
-          maxDepth,
-        }),
-      };
-      const childContract = compileSheetContract(resolvedChildPipeline);
-
       return {
         ...annotated,
-        pipeline: {
-          ...resolvedChildPipeline,
-          sheetContract: childContract.contract,
-          sheetContractErrors: childContract.errors,
-        },
+        pipeline: resolvedChildPipeline,
       } satisfies PlayStaticSubstep;
     }),
   );
@@ -161,10 +221,15 @@ export async function resolveStaticPipelineTree(
   input: ResolveStaticPipelineInput,
 ): Promise<PlayStaticPipeline | null> {
   const maxDepth = input.maxDepth ?? 6;
+  const preferEmbeddedPlayCalls = input.preferEmbeddedPlayCalls ?? false;
   const rootPipeline = materializePipeline(input.root);
   if (!rootPipeline) {
     return null;
   }
+  const resolvedPipelineCache = new Map<
+    string,
+    Promise<PlayStaticPipeline | null>
+  >();
 
   const resolvedPipeline = {
     ...rootPipeline,
@@ -173,12 +238,16 @@ export async function resolveStaticPipelineTree(
       resolveReferencedPlay: input.resolveReferencedPlay,
       stack: [input.rootPlayId],
       maxDepth,
+      preferEmbeddedPlayCalls,
+      resolvedPipelineCache,
     }),
     substeps: await resolvePipelineSubsteps({
       steps: rootPipeline.substeps,
       resolveReferencedPlay: input.resolveReferencedPlay,
       stack: [input.rootPlayId],
       maxDepth,
+      preferEmbeddedPlayCalls,
+      resolvedPipelineCache,
     }),
   };
   const contract = compileSheetContract(resolvedPipeline);

package/dist/bundling-sources/shared_libs/plays/static-pipeline.ts

@@ -609,6 +609,13 @@ export function truncateStaticPipelineForRuntimeContract(
  */
 export function createStaticPipelineReferenceProjection(
   pipeline: PlayStaticPipeline | null | undefined,
+  options?: {
+    /**
+     * Local imported Plays do not have an independently published registry
+     * contract. Keep those embedded while compacting live named Play calls.
+     */
+    preserveEmbeddedPlayIds?: ReadonlySet<string>;
+  },
 ): PlayStaticPipeline | null | undefined {
   const stored = truncateStaticPipelineForStorage(pipeline, {
     maxEmbeddedPlayCallPipelineDepth: Number.POSITIVE_INFINITY,
@@ -629,6 +636,13 @@ export function createStaticPipelineReferenceProjection(
         }>;
       };
       if (projected.type === 'play_call') {
+        if (
+          projected.pipeline &&
+          options?.preserveEmbeddedPlayIds?.has(projected.playId)
+        ) {
+          projected.pipeline = projectPipeline(projected.pipeline);
+          return projected;
+        }
         delete projected.pipeline;
         if (
           projected.resolutionError?.startsWith(
@@ -656,11 +670,15 @@ export function createStaticPipelineReferenceProjection(
       return projected;
     });
 
-  return {
-    ...stored,
-    stages: projectSteps(stored.stages),
-    substeps: projectSteps(stored.substeps),
-  };
+  const projectPipeline = (
+    candidate: PlayStaticPipeline,
+  ): PlayStaticPipeline => ({
+    ...candidate,
+    stages: projectSteps(candidate.stages),
+    substeps: projectSteps(candidate.substeps),
+  });
+
+  return projectPipeline(stored);
 }
 
 function asStaticRecord(value: unknown): Record<string, unknown> | null {

package/dist/cli/index.js

@@ -1043,7 +1043,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.34",
+  version: "0.3.36",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1

package/dist/cli/index.mjs

@@ -1029,7 +1029,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.34",
+  version: "0.3.36",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1

package/dist/index.js

@@ -779,7 +779,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.34",
+  version: "0.3.36",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1

package/dist/index.mjs

@@ -702,7 +702,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.34",
+  version: "0.3.36",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.3.34",
+  "version": "0.3.36",
   "description": "GTM data CLI and TypeScript SDK for coding agents",
   "license": "MIT",
   "homepage": "https://code.deepline.com",