deepline 0.1.106 → 0.1.108

package/dist/repo/shared_libs/play-runtime/cell-staleness.ts

@@ -15,11 +15,15 @@ export type AuthoredStaleAfterSeconds<Value = unknown> =
 
 /** Freshness policy as written by play authors before runtime normalization. */
 export type AuthoredCellStalenessPolicy<Value = unknown> = {
+  recompute?: boolean;
+  recomputeOnError?: boolean;
   staleAfterSeconds?: AuthoredStaleAfterSeconds<Value>;
 };
 
 /** Runtime-normalized freshness policy stored in execution plans. */
 export type CellStalenessPolicy = {
+  recompute?: boolean;
+  recomputeOnError?: boolean;
   staleAfterSeconds?: number;
   dynamicStaleAfterSeconds?: boolean;
 };
@@ -53,7 +57,10 @@ export type PreviousCell<Value = unknown> = {
 };
 
 export type CellStalenessDecision =
-  | { action: 'recompute'; reason: 'missing' | 'failed' | 'stale' }
+  | {
+      action: 'recompute';
+      reason: 'missing' | 'failed' | 'forced' | 'stale';
+    }
   | { action: 'reuse'; reason: 'fresh' | 'no_policy' | 'no_expiry' };
 
 export type CellStalenessPolicyByField = Record<string, CellStalenessPolicy>;
@@ -83,15 +90,36 @@ export function validateStaleAfterSeconds(
 export function normalizeCellStalenessPolicy(
   policy: AuthoredCellStalenessPolicy | undefined,
 ): CellStalenessPolicy {
+  if (
+    policy?.recompute !== undefined &&
+    typeof policy.recompute !== 'boolean'
+  ) {
+    throw new Error('recompute must be a boolean.');
+  }
+  if (
+    policy?.recomputeOnError !== undefined &&
+    typeof policy.recomputeOnError !== 'boolean'
+  ) {
+    throw new Error('recomputeOnError must be a boolean.');
+  }
+  const recompute = policy?.recompute === true;
+  const recomputeOnError = policy?.recomputeOnError === true;
+  const flags = {
+    ...(recompute ? { recompute: true } : {}),
+    ...(recomputeOnError ? { recomputeOnError: true } : {}),
+  };
   const staleAfterSeconds = policy?.staleAfterSeconds;
   if (staleAfterSeconds === undefined) {
-    return {};
+    return flags;
   }
   if (typeof staleAfterSeconds === 'function') {
-    return { dynamicStaleAfterSeconds: true };
+    return {
+      ...flags,
+      dynamicStaleAfterSeconds: true,
+    };
   }
   validateStaleAfterSeconds(staleAfterSeconds);
-  return { staleAfterSeconds };
+  return { ...flags, staleAfterSeconds };
 }
 
 export function resolveCompletedCellStalenessMeta<Value>(input: {
@@ -162,6 +190,7 @@ export function previousCellFromValue<Value>(input: {
 
 export function shouldRecomputeCell(input: {
   hasValue: boolean;
+  value?: unknown;
   meta?: CellStalenessMeta | null;
   policy?: CellStalenessPolicy;
   nowMs?: number;
@@ -175,6 +204,17 @@ export function shouldRecomputeCell(input: {
     return { action: 'recompute', reason: 'failed' };
   }
 
+  if (input.policy?.recompute === true) {
+    return { action: 'recompute', reason: 'forced' };
+  }
+
+  if (
+    input.policy?.recomputeOnError === true &&
+    isErrorLikeCellValue(input.value)
+  ) {
+    return { action: 'recompute', reason: 'failed' };
+  }
+
   const staleAt =
     input.meta && Object.prototype.hasOwnProperty.call(input.meta, 'staleAt')
       ? input.meta.staleAt
@@ -254,7 +294,26 @@ export function cellPolicyFields(
     .filter(
       ([, policy]) =>
         policy.staleAfterSeconds !== undefined ||
-        policy.dynamicStaleAfterSeconds === true,
+        policy.dynamicStaleAfterSeconds === true ||
+        policy.recompute === true ||
+        policy.recomputeOnError === true,
     )
     .map(([field]) => field);
 }
+
+function isErrorLikeCellValue(value: unknown): boolean {
+  if (typeof value === 'string') {
+    return /(^|: )error(:|$)/i.test(value.trim());
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+  const record = value as Record<string, unknown>;
+  const raw = (record.toolResponse as { raw?: unknown } | undefined)?.raw;
+  return (
+    (raw !== undefined && isErrorLikeCellValue(raw)) ||
+    (typeof record.error === 'string' && record.error.trim().length > 0) ||
+    record.status === 'failed' ||
+    record.status === 'error'
+  );
+}

package/dist/repo/shared_libs/play-runtime/run-ledger.ts

@@ -438,6 +438,12 @@ function normalizeStepProgress(
           ),
         }
       : {}),
+    ...(finiteNumber(value.startedAt) !== null
+      ? { startedAt: finiteNumber(value.startedAt) }
+      : {}),
+    ...(finiteNumber(value.completedAt) !== null
+      ? { completedAt: finiteNumber(value.completedAt) }
+      : {}),
     ...(finiteNumber(value.updatedAt) !== null
       ? { updatedAt: finiteNumber(value.updatedAt) }
       : {}),

package/dist/repo/shared_libs/play-runtime/step-program-dataset-builder.ts

@@ -5,6 +5,8 @@ export type StepProgramDatasetOptions = {
     row: Record<string, unknown>,
     index: number,
   ) => boolean | Promise<boolean>;
+  recompute?: boolean;
+  recomputeOnError?: boolean;
   staleAfterSeconds?: AuthoredStaleAfterSeconds;
 };
 
@@ -48,6 +50,8 @@ function isPreviousCell(value: unknown): value is PreviousCell {
 
 export type StepProgramDatasetStep<TResolver> = {
   name: string;
+  recompute?: boolean;
+  recomputeOnError?: boolean;
   resolver: TResolver;
   staleAfterSeconds?: AuthoredStaleAfterSeconds;
 };
@@ -133,6 +137,10 @@ export class StepProgramDatasetBuilder<
         ...(normalized.options?.staleAfterSeconds !== undefined
           ? { staleAfterSeconds: normalized.options.staleAfterSeconds }
           : {}),
+        ...(normalized.options?.recompute === true ? { recompute: true } : {}),
+        ...(normalized.options?.recomputeOnError === true
+          ? { recomputeOnError: true }
+          : {}),
       } as TStep,
     ];
     return this;

package/dist/repo/shared_libs/plays/static-pipeline.ts

@@ -32,6 +32,61 @@ export interface PlayStaticPipeline {
   sheetContractErrors?: string[];
 }
 
+function dedupeStaticFieldNames(
+  fields: Array<string | null | undefined>,
+): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const field of fields) {
+    const trimmed = typeof field === 'string' ? field.trim() : '';
+    if (!trimmed || seen.has(trimmed)) {
+      continue;
+    }
+    seen.add(trimmed);
+    out.push(trimmed);
+  }
+  return out;
+}
+
+export function inputFieldFromStaticCsvArg(csvArg: unknown): string | null {
+  if (typeof csvArg !== 'string') return null;
+  const match = /^input\.([A-Za-z_$][\w$]*)$/.exec(csvArg.trim());
+  return match?.[1] ?? null;
+}
+
+export function deriveStaticPipelineFileInputFields(
+  pipeline: PlayStaticPipeline | null | undefined,
+): string[] {
+  if (!pipeline) {
+    return [];
+  }
+  const explicitCsvFields = getCompiledPipelineSubsteps(pipeline)
+    .filter((substep) => substep.type === 'csv')
+    .map((substep) =>
+      substep.type === 'csv'
+        ? (inputFieldFromStaticCsvArg(substep.path) ?? substep.field)
+        : null,
+    );
+  const inferredCsvField =
+    explicitCsvFields.length > 0
+      ? null
+      : (inputFieldFromStaticCsvArg(pipeline.csvArg) ??
+        (pipeline.csvArg ? 'csv' : null));
+  return dedupeStaticFieldNames([...explicitCsvFields, inferredCsvField]);
+}
+
+export function deriveStaticPipelineEntryInputFields(
+  pipeline: PlayStaticPipeline | null | undefined,
+): string[] {
+  if (!pipeline) {
+    return [];
+  }
+  const fileInputs = deriveStaticPipelineFileInputFields(pipeline);
+  return fileInputs.length > 0
+    ? fileInputs
+    : dedupeStaticFieldNames(pipeline.inputFields ?? []);
+}
+
 export type PlaySheetColumnSource =
   | 'input'
   | 'datasetColumn'
@@ -73,6 +128,8 @@ export interface PlayStaticColumnProducer {
   toolId?: string;
   playId?: string;
   dependsOnFields?: string[];
+  recompute?: boolean;
+  recomputeOnError?: boolean;
   staleAfterSeconds?: number;
   conditional?: boolean;
   sourceRange?: PlayStaticSourceRange;
@@ -84,6 +141,8 @@ export interface PlayStaticDatasetColumn {
   id: string;
   source: PlaySheetColumnSource;
   sqlName?: string;
+  recompute?: boolean;
+  recomputeOnError?: boolean;
   staleAfterSeconds?: number;
   producers: PlayStaticColumnProducer[];
 }
@@ -275,6 +334,8 @@ export interface PlayStaticSourceRange {
 type PlayStaticSubstepMetadata = {
   conditional?: boolean;
   dependsOnFields?: string[];
+  recompute?: boolean;
+  recomputeOnError?: boolean;
   staleAfterSeconds?: number;
 };
 
@@ -600,13 +661,18 @@ function compileDatasetColumns(
     );
     if (!column) continue;
     const pipelineSubstep =
-      substep.staleAfterSeconds === undefined
+      substep.staleAfterSeconds === undefined &&
+      substep.recompute !== true &&
+      substep.recomputeOnError !== true
         ? pipelineSubsteps.find(
             (candidate) => fieldForColumnProducer(candidate) === field,
           )
         : undefined;
     const producer = columnProducerFromSubstep(
-      pipelineSubstep && pipelineSubstep.staleAfterSeconds !== undefined
+      pipelineSubstep &&
+        (pipelineSubstep.staleAfterSeconds !== undefined ||
+          pipelineSubstep.recompute === true ||
+          pipelineSubstep.recomputeOnError === true)
         ? pipelineSubstep
         : substep,
       field,
@@ -618,6 +684,15 @@ function compileDatasetColumns(
     ) {
       column.staleAfterSeconds = producer.staleAfterSeconds;
     }
+    if (column.recompute !== true && producer.recompute === true) {
+      column.recompute = true;
+    }
+    if (
+      column.recomputeOnError !== true &&
+      producer.recomputeOnError === true
+    ) {
+      column.recomputeOnError = true;
+    }
   }
 
   return [...columnsById.values()];
@@ -667,6 +742,8 @@ function columnProducerFromSubstep(
     ...(substep.dependsOnFields?.length
       ? { dependsOnFields: [...substep.dependsOnFields] }
       : {}),
+    ...(substep.recompute === true ? { recompute: true } : {}),
+    ...(substep.recomputeOnError === true ? { recomputeOnError: true } : {}),
     ...(substep.staleAfterSeconds !== undefined
       ? { staleAfterSeconds: substep.staleAfterSeconds }
       : {}),
@@ -828,7 +905,14 @@ export function compileSheetContract(pipeline: PlayStaticPipeline): {
       errors.push('Sheet contract produced an empty column id.');
       return;
     }
-    if (columns.some((existing) => existing.id === column.id)) return;
+    const existing = columns.find((candidate) => candidate.id === column.id);
+    if (existing) {
+      if (existing.source === 'input' && column.source === 'datasetColumn') {
+        existing.source = 'datasetColumn';
+        existing.field = column.field;
+      }
+      return;
+    }
     columns.push({
       ...column,
       sqlName: sqlSafePlayColumnName(column.id),

package/package.json

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