deepline 0.3.289 → 0.3.291

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

@@ -85,6 +85,8 @@ type RuntimeReceiptValueStorageInput = {
   inlineFields?: RuntimeReceiptValueInlineFields;
   inlineMaxBytes?: number;
   store?: RuntimeReceiptValueBlobStore;
+  /** Consult the durable writer fence only when this value needs a reference. */
+  referencesWritable?: () => Promise<boolean>;
 };
 
 export type PersistedRuntimeReceiptValue =
@@ -206,7 +208,10 @@ export async function persistRuntimeReceiptValue(
     input.inlineFields === undefined
       ? undefined
       : normalizeRuntimeReceiptValueInlineFields(input.inlineFields);
-  if (body.byteLength <= inlineMaxBytes) {
+  if (
+    body.byteLength <= inlineMaxBytes ||
+    (input.referencesWritable && !(await input.referencesWritable()))
+  ) {
     return { kind: 'inline', outputJson: input.serialized };
   }
 
@@ -242,6 +247,7 @@ export function createRuntimeReceiptValuePersister(
   input: {
     store?: RuntimeReceiptValueBlobStore;
     inlineMaxBytes?: number;
+    referencesWritable?: () => Promise<boolean>;
   } = {},
 ): RuntimeReceiptValuePersister {
   const inlineMaxBytes =
@@ -278,6 +284,9 @@ export function createRuntimeReceiptValuePersister(
                 ...value,
                 inlineMaxBytes,
                 ...(input.store ? { store: input.store } : {}),
+                ...(input.referencesWritable
+                  ? { referencesWritable: input.referencesWritable }
+                  : {}),
               }),
             };
           } catch (error) {

package/dist/bundling-sources/shared_libs/play-runtime/step-progress.ts

@@ -45,6 +45,8 @@ export type PlayVisualNodeProgress = {
   completedAt?: number | null;
   artifactTableNamespace?: string | null;
   nodeIo?: PlayDocflowNodeIoState;
+  /** Error reported by this step, distinct from a run stopping other work. */
+  error?: string;
   conditionCounts?: PlayConditionCounts;
 };
 
@@ -193,6 +195,9 @@ export function normalizePlayVisualNodeProgressMap(
       ...(startedAt !== undefined ? { startedAt } : {}),
       ...(completedAt !== undefined ? { completedAt } : {}),
       ...(message !== undefined ? { message } : {}),
+      ...(typeof rawProgress.error === 'string' && rawProgress.error.trim()
+        ? { error: rawProgress.error.trim() }
+        : {}),
       ...(artifactTableNamespace !== undefined
         ? { artifactTableNamespace }
         : {}),
@@ -305,7 +310,7 @@ export function applyVisualNodeProgress(input: {
     const completed = Number(progress.completed ?? 0);
     const total = Number(progress.total ?? 0);
     const progressStatus =
-      nodeState.status === 'failed'
+      nodeState.status === 'failed' || progress.error || progress.nodeIo?.error
         ? 'failed'
         : Number.isFinite(total) && total > 0
           ? Number.isFinite(completed) && completed >= total

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

@@ -0,0 +1,103 @@
+import {
+  defineBatchStrategyMap,
+  type BatchOperationStrategy,
+} from './batching-types';
+
+type Single = {
+  key: string;
+  simulated_delay_ms?: number;
+  overlap_group?: string;
+};
+type Result = {
+  key: string;
+  physical_id: string;
+  batch_size: number;
+  started_at_ms: number;
+  finished_at_ms: number;
+};
+type Bulk = {
+  items: Array<{ key: string }>;
+  simulated_delay_ms?: number;
+  overlap_group?: string;
+};
+const bucket = (input: Single) =>
+  JSON.stringify([input.simulated_delay_ms ?? 0, input.overlap_group ?? null]);
+
+const strategy: BatchOperationStrategy<
+  Single,
+  Single | Bulk,
+  Result | { items: Result[] },
+  Result
+> = {
+  sourceOperation: 'test_batching_single',
+  batchOperation: 'test_batching_bulk',
+  kind: 'identifier_batch',
+  maxBatchSize: 100,
+  bucketKeyPayloadFields: ['simulated_delay_ms', 'overlap_group'],
+  toBucketKey: bucket,
+  toItemKey: (input) => input.key,
+  canBatchWith: (left, right) => bucket(left) === bucket(right),
+  compile(inputs) {
+    const first = inputs[0];
+    if (
+      !first ||
+      inputs.length > 100 ||
+      inputs.some((input) => !input.key || bucket(input) !== bucket(first))
+    ) {
+      throw new Error('Synthetic batch needs 1–100 compatible keyed members.');
+    }
+    const keys = [...new Set(inputs.map((input) => input.key))];
+    return {
+      batchOperation:
+        keys.length === 1 ? 'test_batching_single' : 'test_batching_bulk',
+      batchPayload:
+        keys.length === 1
+          ? first
+          : {
+              items: keys.map((key) => ({ key })),
+              simulated_delay_ms: first.simulated_delay_ms,
+              ...(first.overlap_group
+                ? { overlap_group: first.overlap_group }
+                : {}),
+            },
+      items: inputs.map((payload) => ({ itemKey: payload.key, payload })),
+    };
+  },
+  splitResult(result, compiled) {
+    const rows =
+      compiled.batchOperation === 'test_batching_single'
+        ? [result as Result]
+        : (result as { items: Result[] }).items;
+    if (!Array.isArray(rows))
+      throw new Error('Synthetic batch omitted its result list.');
+    const byKey = new Map<string, Result>();
+    const expected = new Set(compiled.items.map((item) => item.itemKey));
+    for (const row of rows) {
+      if (
+        !row ||
+        !expected.has(row.key) ||
+        byKey.has(row.key) ||
+        typeof row.physical_id !== 'string' ||
+        row.physical_id.length === 0 ||
+        row.batch_size !== expected.size ||
+        !Number.isInteger(row.started_at_ms) ||
+        row.started_at_ms < 0 ||
+        !Number.isInteger(row.finished_at_ms) ||
+        row.finished_at_ms < row.started_at_ms
+      ) {
+        throw new Error(
+          'Synthetic batch returned a malformed or unexpected member.',
+        );
+      }
+      byKey.set(row.key, row);
+    }
+    return compiled.items.map((item) => {
+      const row = byKey.get(item.itemKey);
+      if (!row) throw new Error('Synthetic batch omitted a member.');
+      return { itemKey: item.itemKey, result: row, rawResult: row };
+    });
+  },
+};
+export const testAdmissionBatchStrategies = defineBatchStrategyMap({
+  test_batching_single: strategy,
+});

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/runtime-step-receipts-adapter.ts

@@ -349,10 +349,14 @@ export function createRuntimeStepToolResultReceipts(
         // exists to cap how many stored payloads expand at once; holding one
         // of its slots across this gateway round trip only queued unrelated
         // rows behind this row's write, so the mutation runs outside it.
+        const storedResult = stampResultReceipt(
+          candidate.result,
+          record.resultReceiptKey,
+        );
         const persisted = await input.store.complete(
           record.resultReceiptKey,
           ownerRunId,
-          serializeToolExecuteResult(candidate.result),
+          serializeToolExecuteResult(storedResult),
           COMPLETED_RECEIPT_CACHE_INSERT_LEASE_ID,
         );
         // Publication is immutable, but an independent miss keeps the
@@ -369,10 +373,10 @@ export function createRuntimeStepToolResultReceipts(
           }
         }
         await input.onStored?.({
-          result: candidate.result,
+          result: storedResult,
           resultReceiptKey: record.resultReceiptKey,
         });
-        return { kind: 'stored', result: candidate.result };
+        return { kind: 'stored', result: storedResult };
       } finally {
         await stopHeartbeat(record);
         await releaseExecutionLock(record);
@@ -394,6 +398,16 @@ export function createRuntimeStepToolResultReceipts(
   };
 }
 
+function stampResultReceipt(
+  result: ToolExecuteResult,
+  resultReceiptKey: string,
+): ToolExecuteResult {
+  return deserializeToolExecuteResult({
+    ...serializeToolExecuteResult(result),
+    execution: { ...result._metadata.execution, resultReceiptKey },
+  });
+}
+
 function completedResult(
   receipt: RuntimeStepReceipt | null,
   resultReceiptKey: string,
@@ -402,10 +416,13 @@ function completedResult(
     return null;
   }
   if (isSerializedToolExecuteResult(receipt.output)) {
-    return deserializeToolExecuteResult(receipt.output);
+    return stampResultReceipt(
+      deserializeToolExecuteResult(receipt.output),
+      resultReceiptKey,
+    );
   }
   if (isToolExecuteResult(receipt.output)) {
-    return receipt.output;
+    return stampResultReceipt(receipt.output, resultReceiptKey);
   }
   throw new Error(
     `Completed Tool Result Receipt ${resultReceiptKey} has no valid serialized ToolExecuteResult.`,

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

@@ -12,6 +12,41 @@ import {
 } from '../plays/tool-execution-error';
 
 const TOOL_HTTP_ERROR_BRAND = Symbol.for('deepline.tool-http-error.v1');
+const callEvidenceByError = new WeakMap<object, unknown>();
+
+/** Payload evidence stays out of the scalar portable error/status contract. */
+export function attachToolCallFailureEvidence(
+  error: object,
+  evidence: unknown,
+): void {
+  callEvidenceByError.set(error, evidence);
+}
+
+/** Read the already consumed error body without changing failure classification. */
+export function attachToolCallFailureEvidenceFromResponse(
+  error: object,
+  body: string,
+): void {
+  let response: unknown;
+  try {
+    response = JSON.parse(body);
+  } catch {
+    return;
+  }
+  if (!response || typeof response !== 'object') return;
+  const meta = (response as Record<string, unknown>).meta;
+  if (!meta || typeof meta !== 'object') return;
+  attachToolCallFailureEvidence(
+    error,
+    (meta as Record<string, unknown>).callEvidence,
+  );
+}
+
+export function readToolCallFailureEvidence(error: unknown): unknown {
+  return error && typeof error === 'object'
+    ? callEvidenceByError.get(error)
+    : undefined;
+}
 
 type ToolHttpErrorConstructorInput = {
   message: string;

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

@@ -1,3 +1,7 @@
+import {
+  jsonByteLengthUpTo,
+  RUNTIME_RECEIPT_OUTPUT_MAX_BYTES,
+} from './output-size-limits';
 export type {
   SerializedToolExecuteResult,
   ToolExecuteResult,
@@ -83,6 +87,11 @@ const relayPublishedResultReferences = new WeakMap<
   RuntimeReceiptValueReference
 >();
 
+// Call evidence belongs to the saved per-call payload. Keep it out of the
+// enumerable Play result so returning a tool result or storing it in a row
+// does not enlarge customer output with diagnostic request bodies.
+const savedToolCallEvidence = new WeakMap<object, unknown>();
+
 export function attachRelayPublishedToolResultReference(
   result: ToolExecuteResult,
   reference: RuntimeReceiptValueReference,
@@ -1271,6 +1280,7 @@ export function createToolExecuteResult<TResult = unknown>(input: {
     meta?: Record<string, unknown>;
   };
 }): ToolExecuteResult<TResult> {
+  const { callEvidence, ...publicMeta } = input.meta ?? {};
   const result = toResultEnvelope(input.result);
   const resultRoot = {
     toolResponse: {
@@ -1320,7 +1330,7 @@ export function createToolExecuteResult<TResult = unknown>(input: {
   const wrapper = {
     status: input.status,
     ...(input.jobId ? { job_id: input.jobId } : {}),
-    ...(input.meta ? { meta: input.meta } : {}),
+    ...(input.meta ? { meta: publicMeta } : {}),
     ...(input.billing ? { billing: input.billing } : {}),
     toolResponse,
     extractedValues,
@@ -1336,6 +1346,9 @@ export function createToolExecuteResult<TResult = unknown>(input: {
     value: metadata,
     enumerable: false,
   });
+  if (callEvidence !== undefined) {
+    savedToolCallEvidence.set(wrapper, callEvidence);
+  }
   return wrapper;
 }
 
@@ -1976,9 +1989,50 @@ function rawV2WithSerializedListRows(input: {
   });
 }
 
+/** Optional call evidence cannot turn a valid provider result into a retry. */
+function fitSavedCallEvidence(
+  value: SerializedToolExecuteResult,
+): SerializedToolExecuteResult {
+  if (
+    !value.meta?.callEvidence ||
+    !jsonByteLengthUpTo(value, RUNTIME_RECEIPT_OUTPUT_MAX_BYTES).exceeded
+  )
+    return value;
+  const { callEvidence: _evidence, ...meta } = value.meta;
+  const withoutEvidence = { ...value, meta };
+  // Preserve the original oversized-output failure if the result itself is
+  // invalid. Only newly added diagnostic evidence may be omitted.
+  if (
+    jsonByteLengthUpTo(withoutEvidence, RUNTIME_RECEIPT_OUTPUT_MAX_BYTES)
+      .exceeded
+  )
+    return value;
+  const reason =
+    'Call evidence exceeds the saved-result size limit; the complete tool output is retained.';
+  const unavailable = {
+    ...value,
+    meta: { ...meta, callEvidence: { unavailable: reason } },
+  };
+  if (
+    !jsonByteLengthUpTo(unavailable, RUNTIME_RECEIPT_OUTPUT_MAX_BYTES).exceeded
+  )
+    return unavailable;
+  // An output exactly at the historical limit has no room for the marker.
+  // Its original bytes remain legal; the runner retains the warning instead.
+  console.warn(reason);
+  return withoutEvidence;
+}
+
 export function serializeToolExecuteResult(
   value: ToolExecuteResult,
+  options?: { includeCallEvidence?: boolean },
 ): SerializedToolExecuteResult {
+  const callEvidence =
+    options?.includeCallEvidence === false
+      ? undefined
+      : savedToolCallEvidence.get(value);
+  const meta =
+    callEvidence !== undefined ? { ...value.meta, callEvidence } : value.meta;
   const metadata = metadataInputFromToolExecuteResult(value);
   const listDatasets = serializedListDatasetsFromResult(value);
   const listRows = serializedListRowsFromResult({
@@ -2007,11 +2061,11 @@ export function serializeToolExecuteResult(
       view,
       meta: value.toolResponse.meta,
     });
-    return {
+    return fitSavedCallEvidence({
       __kind: SERIALIZED_TOOL_EXECUTE_RESULT_V2_KIND,
       status: value.status,
       ...(typeof value.job_id === 'string' ? { job_id: value.job_id } : {}),
-      ...(isRecord(value.meta) ? { meta: value.meta } : {}),
+      ...(isRecord(meta) ? { meta } : {}),
       ...(isRecord(value.billing) ? { billing: value.billing } : {}),
       toolResponse: {
         // rawV2 is the canonical complete provider response. Only the legacy
@@ -2035,13 +2089,13 @@ export function serializeToolExecuteResult(
       ...(targetValues ? { targetValues } : {}),
       metadata,
       execution: value._metadata.execution,
-    };
+    });
   }
-  return {
+  return fitSavedCallEvidence({
     __kind: SERIALIZED_TOOL_EXECUTE_RESULT_V1_KIND,
     status: value.status,
     ...(typeof value.job_id === 'string' ? { job_id: value.job_id } : {}),
-    ...(isRecord(value.meta) ? { meta: value.meta } : {}),
+    ...(isRecord(meta) ? { meta } : {}),
     ...(isRecord(value.billing) ? { billing: value.billing } : {}),
     toolResponse: {
       raw: serializedRaw,
@@ -2052,7 +2106,7 @@ export function serializeToolExecuteResult(
     ...(targetValues ? { targetValues } : {}),
     metadata,
     execution: value._metadata.execution,
-  };
+  });
 }
 
 export function isSerializedToolExecuteResult(
@@ -2156,7 +2210,13 @@ export function cloneToolExecuteResultWithExecution<TResult>(
 ): ToolExecuteResult<TResult> {
   return deserializeToolExecuteResult({
     ...serializeToolExecuteResult(value),
-    execution,
+    execution: {
+      ...execution,
+      ...(!execution.resultReceiptKey &&
+      value._metadata.execution.resultReceiptKey
+        ? { resultReceiptKey: value._metadata.execution.resultReceiptKey }
+        : {}),
+    },
   }) as ToolExecuteResult<TResult>;
 }
 

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

@@ -34,6 +34,8 @@ export type PlayVisualNodeProgress = {
   completedAt?: number;
   artifactTableNamespace?: string | null;
   nodeIo?: PlayDocflowNodeIoState;
+  /** Error reported by this step, distinct from a run stopping other work. */
+  error?: string;
   conditionCounts?: PlayConditionCounts;
 };
 

package/dist/bundling-sources/shared_libs/play-runtime/zerobounce-batching.ts

@@ -8,11 +8,38 @@ type Bulk = {
   email_batch: Array<{ email_address: string; ip_address?: string }>;
 };
 type Verdict = Record<string, unknown> & { address: string; status: string };
-type Results = { email_batch?: unknown[]; errors?: unknown[]; data?: Results };
+type Results = {
+  email_batch?: unknown[];
+  errors?: unknown[];
+  data?: Results;
+  // The scalar validate endpoint returns one verdict at the top level.
+  address?: unknown;
+  status?: unknown;
+};
+
+const VERDICT_STATUSES = [
+  'valid',
+  'invalid',
+  'catch-all',
+  'unknown',
+  'spamtrap',
+  'abuse',
+  'do_not_mail',
+];
 
 function emailKey(email: string) {
   return email.trim().toLowerCase();
 }
+
+function isVerdict(value: unknown): value is Verdict {
+  const row = value as Verdict | null;
+  return Boolean(
+    row &&
+    typeof row.address === 'string' &&
+    typeof row.status === 'string' &&
+    VERDICT_STATUSES.includes(row.status),
+  );
+}
 function bucket(payload: Single) {
   // The response identifies emails, but does not echo the supplied IP.
   return JSON.stringify([
@@ -23,7 +50,7 @@ function bucket(payload: Single) {
 
 export const zerobounceValidateBatchStrategy: BatchOperationStrategy<
   Single,
-  Bulk,
+  Bulk | Single,
   Results,
   { data: Verdict }
 > = {
@@ -47,25 +74,58 @@ export const zerobounceValidateBatchStrategy: BatchOperationStrategy<
         'ZeroBounce batch requires 1–100 emails with matching IP options.',
       );
     }
+    const items = payloads.map((payload) => ({
+      itemKey: zerobounceValidateBatchStrategy.toItemKey(payload),
+      payload,
+    }));
+    const emails = [...new Set(payloads.map((p) => emailKey(p.email!)))];
+    if (emails.length === 1) {
+      // One distinct email (a per-row waterfall, duplicate rows, or receipt
+      // dedup leaving one owned member) must not ride the bulk endpoint:
+      // zerobounce_batch_validate is gated at 30/min provider_shared, while
+      // the scalar validate endpoint allows 80,000 validations per 10 s.
+      // Compiling here covers both the receipt-owned cohort
+      // (compileOwnedPhysicalBatch) and the legacy path.
+      return {
+        batchOperation: 'zerobounce_validate',
+        batchPayload: first,
+        items,
+      };
+    }
     return {
-      // Receipt deduplication may leave one owned email. Keep the bulk operation.
       batchOperation: 'zerobounce_batch_validate',
       batchPayload: {
-        email_batch: [...new Set(payloads.map((p) => emailKey(p.email!)))].map(
-          (email_address) => ({
-            email_address,
-            ...(first.ip_address ? { ip_address: first.ip_address } : {}),
-          }),
-        ),
+        email_batch: emails.map((email_address) => ({
+          email_address,
+          ...(first.ip_address ? { ip_address: first.ip_address } : {}),
+        })),
       },
-      items: payloads.map((payload) => ({
-        itemKey: zerobounceValidateBatchStrategy.toItemKey(payload),
-        payload,
-      })),
+      items,
     };
   },
   splitResult(fullResult, compiled) {
     const result = fullResult.data ?? fullResult;
+    if (compiled.batchOperation === 'zerobounce_validate') {
+      if (
+        !isVerdict(result) ||
+        compiled.items.some(
+          (item) => emailKey(result.address) !== emailKey(item.payload.email!),
+        )
+      ) {
+        throw new Error(
+          'ZeroBounce single verification returned a malformed or mismatched verdict.',
+        );
+      }
+      // Every item shares the one distinct email this call verified.
+      return compiled.items.map((item) => ({
+        itemKey: item.itemKey,
+        result: { data: result },
+        rawResult: result,
+      }));
+    }
+    if (!('email_batch' in compiled.batchPayload)) {
+      throw new Error('ZeroBounce bulk split received a scalar payload.');
+    }
     if (
       !Array.isArray(result.email_batch) ||
       (result.errors !== undefined &&
@@ -79,21 +139,8 @@ export const zerobounceValidateBatchStrategy: BatchOperationStrategy<
       compiled.batchPayload.email_batch.map((p) => emailKey(p.email_address)),
     );
     const byEmail = new Map<string, Verdict>();
-    for (const value of result.email_batch) {
-      const row = value as Verdict | null;
-      if (
-        !row ||
-        typeof row.address !== 'string' ||
-        ![
-          'valid',
-          'invalid',
-          'catch-all',
-          'unknown',
-          'spamtrap',
-          'abuse',
-          'do_not_mail',
-        ].includes(row.status)
-      ) {
+    for (const row of result.email_batch) {
+      if (!isVerdict(row)) {
         throw new Error(
           'ZeroBounce bulk verification returned a malformed verdict.',
         );

package/dist/bundling-sources/shared_libs/plays/tool-result-types.ts

@@ -37,6 +37,8 @@ export type ToolResultExecutionMetadata = {
   cacheKey?: string;
   receiptRole?: 'owner' | 'follower';
   receiptKey?: string;
+  /** Canonical saved result identity; receiptKey may name a transport alias. */
+  resultReceiptKey?: string;
   attachedToReceiptKey?: string;
 };