deepline 0.3.247 → 0.3.249

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/runtime-queue-health.ts

@@ -1035,26 +1035,23 @@ export async function readRuntimeQueueHealthFromClient(
       }),
     );
   }
-  const [outbox, computeBilling, cleanup] = await Promise.all([
-    client.query<CountRow>(
-      outboxProjectionQuery(schema, input.includeRetirementCandidates === true),
-      [now, sampleLimit + 1, sampleLimit],
-    ),
-    client.query<CountRow>(
-      computeBillingProjectionQuery(
-        schema,
-        input.includeRetirementCandidates === true,
-      ),
-      [now, sampleLimit + 1, sampleLimit],
-    ),
-    client.query<CountRow>(
-      cleanupProjectionQuery(
-        schema,
-        input.includeRetirementCandidates === true,
-      ),
-      [now, sampleLimit + 1, sampleLimit],
+  // One checkout owns this read. pg serializes its wire protocol, so await
+  // each query instead of concurrently submitting work to the same client.
+  const outbox = await client.query<CountRow>(
+    outboxProjectionQuery(schema, input.includeRetirementCandidates === true),
+    [now, sampleLimit + 1, sampleLimit],
+  );
+  const computeBilling = await client.query<CountRow>(
+    computeBillingProjectionQuery(
+      schema,
+      input.includeRetirementCandidates === true,
     ),
-  ]);
+    [now, sampleLimit + 1, sampleLimit],
+  );
+  const cleanup = await client.query<CountRow>(
+    cleanupProjectionQuery(schema, input.includeRetirementCandidates === true),
+    [now, sampleLimit + 1, sampleLimit],
+  );
   projections.push(
     projectionFromRow({
       id: 'runtime:run-ledger-outbox',

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/runtime-receipt-value-storage.ts

@@ -22,6 +22,9 @@ export type RuntimeValueBlobStore = {
   remove(key: string): Promise<void>;
 };
 
+/** A receipt read only needs immutable GET access to the object store. */
+export type RuntimeValueBlobReader = Pick<RuntimeValueBlobStore, 'get'>;
+
 /** Backward-compatible receipt-specific name for the shared object store. */
 export type RuntimeReceiptValueBlobStore = RuntimeValueBlobStore;
 
@@ -64,9 +67,9 @@ function transientStoreError(
  * injects its object-store adapter. This keeps R2 credentials and transport
  * mechanics at the gateway edge, without a reverse package dependency.
  */
-export function requireRuntimeValueBlobStore(
-  store: RuntimeValueBlobStore | undefined,
-): RuntimeValueBlobStore {
+export function requireRuntimeValueBlobStore<
+  T extends Pick<RuntimeValueBlobStore, 'get'>,
+>(store: T | undefined): T {
   if (!store) {
     throw new Error(
       'Runtime value storage requires an explicit object-store adapter.',
@@ -304,7 +307,7 @@ export function createRuntimeReceiptValuePersister(
  * while allowing independent immutable objects to use the connection pool.
  */
 export function createRuntimeReceiptValueReader(
-  input: { store?: RuntimeReceiptValueBlobStore } = {},
+  input: { store?: RuntimeValueBlobReader } = {},
 ): RuntimeReceiptValueReader {
   type Read = {
     orgId: string;
@@ -384,10 +387,15 @@ export async function readRuntimeReceiptValue(input: {
   orgId: string;
   receiptKey: string;
   reference: RuntimeReceiptValueReference;
-  store?: RuntimeReceiptValueBlobStore;
+  store?: RuntimeValueBlobReader;
 }): Promise<unknown> {
   assertRuntimeReceiptValueReferenceScope(input);
-  const store = requireRuntimeValueBlobStore(input.store);
+  const store = input.store;
+  if (!store) {
+    throw new Error(
+      'Runtime receipt value read requires an object-store reader.',
+    );
+  }
   let body: Buffer;
   try {
     body = await store.get(input.reference.key);

package/dist/bundling-sources/shared_libs/play-runtime/tool-execute-retry-policy.ts

@@ -1,6 +1,7 @@
 import {
   isHardBillingToolHttpError,
   normalizeToolHttpErrorMessage,
+  readExplicitToolHttpRetryability,
   type ToolHttpError,
 } from './tool-http-errors';
 import {
@@ -302,6 +303,7 @@ function decideToolExecuteHttpRetry(input: {
   hardBillingFailure?: boolean;
   hasRetryAfterHeader?: boolean;
   transientHttpRetrySafe?: boolean;
+  explicitRetryable?: boolean;
 }): ToolExecuteHttpRetryDecision {
   if (input.hardBillingFailure) {
     return {
@@ -371,6 +373,13 @@ function decideToolExecuteHttpRetry(input: {
     };
   }
   if (input.status >= 500 && input.status < 600) {
+    if (input.explicitRetryable === false) {
+      return {
+        retryable: false,
+        attemptCap: 1,
+        reason: 'non_retryable_status',
+      };
+    }
     if (!input.transientHttpRetrySafe) {
       return {
         retryable: false,
@@ -440,6 +449,10 @@ export function createToolExecuteHttpFailureAttemptTracker(): ToolExecuteHttpFai
         }),
         hasRetryAfterHeader: true,
         transientHttpRetrySafe: input.transientHttpRetrySafe === true,
+        explicitRetryable: readExplicitToolHttpRetryability({
+          toolId: input.toolId,
+          bodyText: input.bodyText ?? '',
+        }),
       });
       attemptsByReason[decision.reason] += 1;
       return attemptsByReason[decision.reason];
@@ -495,6 +508,7 @@ export function classifyToolExecuteHttpFailure(input: {
   const concurrencyBackpressure = isConcurrencyBackpressureResponse(input);
   const runtimeSchedulerCapacity = isRuntimeSchedulerCapacityResponse(input);
   const providerPacingWait = isProviderPacingWaitResponse(input);
+  const explicitRetryable = readExplicitToolHttpRetryability(input);
   const initialRetryDecision = decideToolExecuteHttpRetry({
     status: input.status,
     idempotencyInProgress,
@@ -505,6 +519,7 @@ export function classifyToolExecuteHttpFailure(input: {
     providerPacingWait,
     hasRetryAfterHeader,
     transientHttpRetrySafe,
+    explicitRetryable,
   });
   const providerPacingWaitBody = providerPacingWait
     ? parseJsonObject(input.bodyText)
@@ -568,6 +583,7 @@ export function classifyToolExecuteHttpFailure(input: {
     hardBillingFailure,
     hasRetryAfterHeader,
     transientHttpRetrySafe,
+    explicitRetryable,
   });
   const shouldRetry =
     providerOwnedRateLimit ||

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

@@ -359,6 +359,46 @@ function formatPublicToolErrorPayload(input: {
   ).slice(0, 1_500);
 }
 
+/** Undefined means the response made no authoritative retryability claim. */
+export function readExplicitToolHttpRetryability(input: {
+  toolId: string;
+  bodyText: string;
+  schemaVersion?: ToolExecutionErrorSchemaVersion;
+}): boolean | undefined {
+  let parsed: Record<string, unknown> | null;
+  try {
+    const value = JSON.parse(input.bodyText);
+    parsed = isRecord(value) ? value : null;
+  } catch {
+    return undefined;
+  }
+  const serialized = getObjectField(parsed, 'tool_error');
+  const hydrated = deserializeToolExecutionFailure(
+    '',
+    serialized,
+    input.schemaVersion ?? TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+  );
+  if (hydrated) {
+    // Deserialization defaults missing/unknown retryability to false. Only
+    // the original attributed boolean is a decision supplied by the sender.
+    return hydrated.origin !== 'unknown'
+      ? (getBooleanField(serialized, 'retryable') ?? undefined)
+      : undefined;
+  }
+  const origin = normalizeToolExecutionOrigin(
+    getStringField(parsed, 'failure_origin'),
+    {
+      provider: getStringField(parsed, 'provider'),
+      operation: getStringField(parsed, 'operation') ?? input.toolId,
+    },
+  );
+  // Older readers do not recognize every category (notably model_output),
+  // but that must not erase an attributed sender's explicit retry refusal.
+  return origin !== 'unknown'
+    ? (getBooleanField(parsed, 'retryable') ?? undefined)
+    : undefined;
+}
+
 export function normalizeToolHttpErrorMessage(input: {
   toolId: string;
   status: number;

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -1612,7 +1612,10 @@ export interface PlayAuthoringRuntimeContext {
    */
   log(
     message: string,
-    options?: { level?: 'debug' | 'info' | 'warn' | 'error' },
+    options?: {
+      level?: 'debug' | 'info' | 'warn' | 'error';
+      context?: Readonly<Record<string, string | number | boolean>>;
+    },
   ): void;
   sleep(ms: number): Promise<void>;
 }
@@ -3259,7 +3262,7 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   `  runPlay<TOutput = unknown>(key: string, playRef: ${cloudReferenceType('ctx.runPlay.playRef')}, input: ${cloudReferenceType('ctx.runPlay.input')}, options: PlayCallOptions): Promise<TOutput>;`,
   '  runPlayAsync<TInput extends Record<string, unknown>>(key: string, playRef: PlayReferenceLike<TInput>, input: NoInfer<TInput>, options: PlayAsyncCallOptions): Promise<AsyncPlayRunRef>;',
   '  runPlayAsync(key: string, playRef: string, input: Record<string, unknown>, options: PlayAsyncCallOptions): Promise<AsyncPlayRunRef>;',
-  "  log(message: string, options?: { level?: 'debug' | 'info' | 'warn' | 'error' }): void;",
+  "  log(message: string, options?: { level?: 'debug' | 'info' | 'warn' | 'error'; context?: Readonly<Record<string, string | number | boolean>> }): void;",
   `  sleep(ms: ${cloudReferenceType('ctx.sleep.ms')}): Promise<void>;`,
   '}',
   "export type DefinePlayConfig<TInput, TOutput extends PlayReturnObject> = { id: string; description?: string; input: PlayInputContract<TInput>; run: (ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>; bindings?: PlayBindings<TInput>; billing?: PlayBindings<TInput>['billing']; runtime?: PlayBindings<TInput>['runtime']; compatibility?: PlayBindings<TInput>['compatibility'] };",

package/dist/bundling-sources/shared_libs/plays/dataset-summary.ts

@@ -1,11 +1,15 @@
+export const DATASET_EXECUTION_BUCKETS = [
+  'queued',
+  'running',
+  'completed:executed',
+  'completed:reused',
+  'skipped:condition',
+  'skipped:missed',
+  'failed',
+] as const;
+
 export type DatasetColumnExecutionBucket =
-  | 'queued'
-  | 'running'
-  | 'completed:executed'
-  | 'completed:reused'
-  | 'skipped:condition'
-  | 'skipped:missed'
-  | 'failed';
+  (typeof DATASET_EXECUTION_BUCKETS)[number];
 
 export type DatasetColumnExecutionStats = Record<
   DatasetColumnExecutionBucket,

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

@@ -3,7 +3,6 @@ import {
   createStoredStaticPipelineV2,
   hydrateStoredStaticPipelineV2,
   readStoredStaticPipeline,
-  createStaticPipelineV1CompatibilityProjection,
   type PlayStaticPipeline,
 } from './static-pipeline';
 import {
@@ -46,7 +45,11 @@ function executionStorageFields(
     retainedPipelineGraph: RetainedPipelineGraph;
   };
   return {
-    staticPipeline: createStaticPipelineV1CompatibilityProjection(pipeline),
+    // Shared-graph readers own the complete presentation and execution view.
+    // Retaining a recursive V1 mirror would expand the same child once per
+    // call again, even when the authoritative graph is compact. Keep only the
+    // historical field's fixed empty shape; never use it as an execution root.
+    staticPipeline: pipeline === null ? null : { fields: [], substeps: [] },
     retainedPipelineGraph: compact.retainedPipelineGraph,
   };
 }

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

@@ -1,5 +1,8 @@
 import { normalizeTableNamespace } from './row-identity';
-import { sqlSafePlayColumnName } from '../play-data-plane/column-names';
+import {
+  sqlSafePlayColumnName,
+  sqlSafePlayStepColumnName,
+} from '../play-data-plane/column-names';
 import type {
   PlaySheetColumnSource,
   PlaySheetColumnContract,
@@ -1879,7 +1882,13 @@ export function compileSheetContract(pipeline: PlayStaticPipeline): {
     }
     columns.push({
       ...column,
-      sqlName: sqlSafePlayColumnName(column.id),
+      sqlName:
+        column.source === 'waterfallStep' && column.stepId
+          ? sqlSafePlayStepColumnName(
+              column.field ?? column.waterfallId ?? column.id,
+              column.stepId,
+            )
+          : sqlSafePlayColumnName(column.id),
     });
   };