deepline 0.1.153 → 0.1.155

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

@@ -169,6 +169,7 @@ type RuntimeApiRequest =
       runId: string;
       key: string;
       reclaimRunning?: boolean;
+      forceRefresh?: boolean;
     }
   | {
       action: 'complete_runtime_step_receipt';
@@ -190,6 +191,40 @@ type RuntimeApiRequest =
       runId: string;
       key: string;
       output?: unknown;
+    }
+  | {
+      action: 'get_runtime_step_receipts';
+      playName: string;
+      runId: string;
+      keys: string[];
+    }
+  | {
+      action: 'claim_runtime_step_receipts';
+      playName: string;
+      runId: string;
+      keys: string[];
+      reclaimRunning?: boolean;
+      forceRefresh?: boolean;
+    }
+  | {
+      action: 'complete_runtime_step_receipts';
+      playName: string;
+      runId: string;
+      receipts: Array<{
+        key: string;
+        runId: string;
+        output: unknown;
+      }>;
+    }
+  | {
+      action: 'fail_runtime_step_receipts';
+      playName: string;
+      runId: string;
+      receipts: Array<{
+        key: string;
+        runId: string;
+        error: string;
+      }>;
     };
 
 export type WorkerRuntimeApiContext = {
@@ -789,6 +824,19 @@ export async function getRuntimeStepReceiptViaAppRuntime(
   });
 }
 
+export async function getRuntimeStepReceiptsViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'get_runtime_step_receipts' }>,
+    'action'
+  >,
+): Promise<RuntimeStepReceipt[]> {
+  return await postAppRuntimeApi<RuntimeStepReceipt[]>(context, {
+    action: 'get_runtime_step_receipts',
+    ...input,
+  });
+}
+
 export async function claimRuntimeStepReceiptViaAppRuntime(
   context: WorkerRuntimeApiContext,
   input: Omit<
@@ -802,6 +850,19 @@ export async function claimRuntimeStepReceiptViaAppRuntime(
   });
 }
 
+export async function claimRuntimeStepReceiptsViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'claim_runtime_step_receipts' }>,
+    'action'
+  >,
+): Promise<RuntimeStepReceipt[]> {
+  return await postAppRuntimeApi<RuntimeStepReceipt[]>(context, {
+    action: 'claim_runtime_step_receipts',
+    ...input,
+  });
+}
+
 export async function completeRuntimeStepReceiptViaAppRuntime(
   context: WorkerRuntimeApiContext,
   input: Omit<
@@ -815,6 +876,19 @@ export async function completeRuntimeStepReceiptViaAppRuntime(
   });
 }
 
+export async function completeRuntimeStepReceiptsViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'complete_runtime_step_receipts' }>,
+    'action'
+  >,
+): Promise<RuntimeStepReceipt[]> {
+  return await postAppRuntimeApi<RuntimeStepReceipt[]>(context, {
+    action: 'complete_runtime_step_receipts',
+    ...input,
+  });
+}
+
 export async function failRuntimeStepReceiptViaAppRuntime(
   context: WorkerRuntimeApiContext,
   input: Omit<
@@ -828,6 +902,19 @@ export async function failRuntimeStepReceiptViaAppRuntime(
   });
 }
 
+export async function failRuntimeStepReceiptsViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'fail_runtime_step_receipts' }>,
+    'action'
+  >,
+): Promise<RuntimeStepReceipt[]> {
+  return await postAppRuntimeApi<RuntimeStepReceipt[]>(context, {
+    action: 'fail_runtime_step_receipts',
+    ...input,
+  });
+}
+
 export async function skipRuntimeStepReceiptViaAppRuntime(
   context: WorkerRuntimeApiContext,
   input: Omit<

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

@@ -148,62 +148,3 @@ export function compileRequestsWithStrategy<TRequest>(input: {
 
   return compiledBatches;
 }
-
-export async function executeWaterfallProviders<TRequest, TResult>(input: {
-  providers: string[];
-  getPendingRequests: () => TRequest[];
-  getCachedResults: (
-    provider: string,
-  ) => Array<ChunkExecutionResult<TRequest, TResult>> | null;
-  storeCachedResults: (
-    provider: string,
-    results: Array<ChunkExecutionResult<TRequest, TResult>>,
-  ) => void;
-  executeProviderRequests: (
-    provider: string,
-    requests: TRequest[],
-  ) => Promise<Array<ChunkExecutionResult<TRequest, TResult>>>;
-  onHit: (provider: string, request: TRequest, result: TResult) => void;
-  onMiss: (provider: string, request: TRequest) => void;
-  onProviderComplete?: (provider: string) => void;
-}): Promise<void> {
-  for (const provider of input.providers) {
-    const cached = input.getCachedResults(provider);
-    if (cached) {
-      for (const entry of cached) {
-        if (entry.result != null) {
-          input.onHit(provider, entry.request, entry.result);
-        }
-      }
-      input.onProviderComplete?.(provider);
-      continue;
-    }
-
-    const pending = input.getPendingRequests();
-    if (pending.length === 0) {
-      return;
-    }
-
-    const results = await input.executeProviderRequests(provider, pending);
-    input.storeCachedResults(provider, results);
-
-    for (const entry of results) {
-      if (entry.result != null) {
-        input.onHit(provider, entry.request, entry.result);
-      } else {
-        input.onMiss(provider, entry.request);
-      }
-    }
-
-    input.onProviderComplete?.(provider);
-  }
-}
-
-export function resolveWaterfallToolId(
-  provider: string,
-  toolName: string,
-): string {
-  return toolName.startsWith(`${provider}_`)
-    ? toolName
-    : `${provider}_${toolName}`;
-}

package/dist/bundling-sources/shared_libs/play-runtime/cell-staleness.ts

@@ -1,33 +1,3 @@
-/**
- * Resolve the next expiry window from a completed cell value.
- *
- * Return a positive whole number of seconds to set the next `staleAt`, or
- * `null` when this particular value should not expire.
- */
-export type StaleAfterSecondsResolver<Value = unknown> = (
-  value: Value,
-) => number | null;
-
-/** Authored freshness policy: fixed TTL seconds or a value-based resolver. */
-export type AuthoredStaleAfterSeconds<Value = unknown> =
-  | number
-  | StaleAfterSecondsResolver<Value>;
-
-/** 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;
-};
-
 /** Stored per-cell freshness and completion metadata. */
 export type CellStalenessMeta = {
   status?: string | null;
@@ -56,101 +26,8 @@ export type PreviousCell<Value = unknown> = {
   staleAfterSeconds?: number;
 };
 
-export type CellStalenessDecision =
-  | {
-      action: 'recompute';
-      reason: 'missing' | 'failed' | 'forced' | 'stale';
-    }
-  | { action: 'reuse'; reason: 'fresh' | 'no_policy' | 'no_expiry' };
-
-export type CellStalenessPolicyByField = Record<string, CellStalenessPolicy>;
-export type AuthoredCellStalenessPolicyByField = Record<
-  string,
-  AuthoredCellStalenessPolicy
->;
-
 export const DEEPLINE_CELL_META_FIELD = '__deeplineCellMeta';
 
-export function validateStaleAfterSeconds(
-  staleAfterSeconds: number | undefined,
-  label = 'staleAfterSeconds',
-): void {
-  if (staleAfterSeconds === undefined) {
-    return;
-  }
-  if (
-    !Number.isFinite(staleAfterSeconds) ||
-    !Number.isInteger(staleAfterSeconds) ||
-    staleAfterSeconds <= 0
-  ) {
-    throw new Error(`${label} must be a positive whole number of seconds.`);
-  }
-}
-
-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 flags;
-  }
-  if (typeof staleAfterSeconds === 'function') {
-    return {
-      ...flags,
-      dynamicStaleAfterSeconds: true,
-    };
-  }
-  validateStaleAfterSeconds(staleAfterSeconds);
-  return { ...flags, staleAfterSeconds };
-}
-
-export function resolveCompletedCellStalenessMeta<Value>(input: {
-  policy?: AuthoredCellStalenessPolicy<Value>;
-  value: Value;
-  completedAt: number;
-}): Pick<CellStalenessMeta, 'staleAfterSeconds' | 'staleAt'> {
-  const staleAfterSeconds = input.policy?.staleAfterSeconds;
-  if (staleAfterSeconds === undefined) {
-    return {};
-  }
-
-  const resolved =
-    typeof staleAfterSeconds === 'function'
-      ? staleAfterSeconds(input.value)
-      : staleAfterSeconds;
-  if (resolved === null) {
-    return { staleAt: null };
-  }
-  if (typeof resolved !== 'number') {
-    throw new Error(
-      'staleAfterSeconds(value) must return a positive whole number of seconds or null.',
-    );
-  }
-  validateStaleAfterSeconds(resolved, 'staleAfterSeconds(value)');
-  return {
-    staleAfterSeconds: resolved,
-    staleAt: input.completedAt + resolved * 1000,
-  };
-}
-
 export function previousCellFromValue<Value>(input: {
   hasValue: boolean;
   value: Value;
@@ -187,133 +64,3 @@ export function previousCellFromValue<Value>(input: {
   }
   return previous;
 }
-
-export function shouldRecomputeCell(input: {
-  hasValue: boolean;
-  value?: unknown;
-  meta?: CellStalenessMeta | null;
-  policy?: CellStalenessPolicy;
-  nowMs?: number;
-}): CellStalenessDecision {
-  if (!input.hasValue) {
-    return { action: 'recompute', reason: 'missing' };
-  }
-
-  const status = String(input.meta?.status ?? '').trim();
-  if (status === 'failed') {
-    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
-      : undefined;
-  if (staleAt === null) {
-    return { action: 'reuse', reason: 'no_expiry' };
-  }
-  if (typeof staleAt === 'number' && Number.isFinite(staleAt)) {
-    return (input.nowMs ?? Date.now()) > staleAt
-      ? { action: 'recompute', reason: 'stale' }
-      : { action: 'reuse', reason: 'fresh' };
-  }
-
-  if (input.policy?.dynamicStaleAfterSeconds) {
-    return { action: 'recompute', reason: 'stale' };
-  }
-
-  const staleAfterSeconds = input.policy?.staleAfterSeconds;
-  validateStaleAfterSeconds(staleAfterSeconds);
-  if (staleAfterSeconds === undefined) {
-    return { action: 'reuse', reason: 'no_policy' };
-  }
-
-  const completedAt =
-    typeof input.meta?.completedAt === 'number' &&
-    Number.isFinite(input.meta.completedAt)
-      ? input.meta.completedAt
-      : null;
-  if (completedAt === null) {
-    return { action: 'recompute', reason: 'missing' };
-  }
-
-  const ageMs = Math.max(0, (input.nowMs ?? Date.now()) - completedAt);
-  return ageMs > staleAfterSeconds * 1000
-    ? { action: 'recompute', reason: 'stale' }
-    : { action: 'reuse', reason: 'fresh' };
-}
-
-export function resolveReusableCellMetaForCurrentPolicy<Value>(input: {
-  hasValue: boolean;
-  value: Value;
-  meta?: CellStalenessMeta | null;
-  policy?: AuthoredCellStalenessPolicy<Value>;
-}): Pick<CellStalenessMeta, 'staleAfterSeconds' | 'staleAt'> {
-  if (
-    !input.hasValue ||
-    typeof input.policy?.staleAfterSeconds !== 'function'
-  ) {
-    return {};
-  }
-  const status = String(input.meta?.status ?? '').trim();
-  if (status === 'failed') {
-    return {};
-  }
-  const completedAt =
-    typeof input.meta?.completedAt === 'number' &&
-    Number.isFinite(input.meta.completedAt)
-      ? input.meta.completedAt
-      : null;
-  if (completedAt === null) {
-    return {};
-  }
-  return resolveCompletedCellStalenessMeta({
-    policy: input.policy,
-    value: input.value,
-    completedAt,
-  });
-}
-
-export function cellPolicyFields(
-  policies: CellStalenessPolicyByField | undefined,
-): string[] {
-  if (!policies) {
-    return [];
-  }
-  return Object.entries(policies)
-    .filter(
-      ([, policy]) =>
-        policy.staleAfterSeconds !== undefined ||
-        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'
-  );
-}