deepline 0.1.199 → 0.1.200

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

@@ -0,0 +1,135 @@
+const encoder = typeof TextEncoder === 'undefined' ? null : new TextEncoder();
+
+export const TERMINAL_RUN_RESULT_MAX_BYTES = 2_500_000;
+export const CUSTOMER_OUTPUT_VALUE_MAX_BYTES = 1 * 1024 * 1024;
+export const CUSTOMER_OUTPUT_TOTAL_MAX_BYTES = 2 * 1024 * 1024;
+export const RUNTIME_RECEIPT_OUTPUT_MAX_BYTES = 2 * 1024 * 1024;
+export const RUNTIME_RECEIPT_COMPLETION_BUFFER_MAX_BYTES = 16 * 1024 * 1024;
+
+export class OutputTooLargeError extends Error {
+  readonly code = 'OUTPUT_TOO_LARGE';
+  readonly path: string;
+  readonly bytes: number;
+  readonly limitBytes: number;
+
+  constructor(input: {
+    path: string;
+    bytes: number;
+    limitBytes: number;
+    advice: string;
+  }) {
+    super(
+      `OutputTooLarge: ${input.path} is ${formatBytes(input.bytes)}, above the ${formatBytes(input.limitBytes)} limit. ` +
+        input.advice,
+    );
+    this.name = 'OutputTooLargeError';
+    this.path = input.path;
+    this.bytes = input.bytes;
+    this.limitBytes = input.limitBytes;
+  }
+}
+
+export function jsonByteLength(value: unknown): number {
+  const serialized = JSON.stringify(value);
+  if (serialized === undefined) return 0;
+  return encoder?.encode(serialized).byteLength ?? serialized.length;
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MiB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)} KiB`;
+  }
+  return `${bytes} B`;
+}
+
+function assertJsonSized(input: {
+  value: unknown;
+  path: string;
+  limitBytes: number;
+  advice: string;
+}): number {
+  let bytes: number;
+  try {
+    bytes = jsonByteLength(input.value);
+  } catch (error) {
+    throw new Error(
+      `${input.path} cannot be serialized as JSON: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+  if (bytes > input.limitBytes) {
+    throw new OutputTooLargeError({
+      path: input.path,
+      bytes,
+      limitBytes: input.limitBytes,
+      advice: input.advice,
+    });
+  }
+  return bytes;
+}
+
+export function valueWithinJsonByteLimit(value: unknown, limitBytes: number) {
+  if (value === undefined || value === null) {
+    return value;
+  }
+  return jsonByteLength(value) > limitBytes ? undefined : value;
+}
+
+/** Shared terminal-result contract for every scheduler backend. */
+export function persistableTerminalRunResult(value: unknown): unknown {
+  return valueWithinJsonByteLimit(value, TERMINAL_RUN_RESULT_MAX_BYTES);
+}
+
+export function assertCustomerOutputValueWithinLimit(input: {
+  value: unknown;
+  path: string;
+  limitBytes?: number;
+}): number {
+  return assertJsonSized({
+    value: input.value,
+    path: input.path,
+    limitBytes: input.limitBytes ?? CUSTOMER_OUTPUT_VALUE_MAX_BYTES,
+    advice:
+      'Deepline can process large provider/cache payloads, but customer-visible outputs must stay bounded. Extract the fields you need before returning or saving this value.',
+  });
+}
+
+export function assertCustomerOutputObjectWithinLimit(input: {
+  value: Record<string, unknown>;
+  path: string;
+  totalLimitBytes?: number;
+  valueLimitBytes?: number;
+}): number {
+  for (const [key, value] of Object.entries(input.value)) {
+    assertCustomerOutputValueWithinLimit({
+      value,
+      path: `${input.path}.${key}`,
+      limitBytes: input.valueLimitBytes,
+    });
+  }
+  return assertJsonSized({
+    value: input.value,
+    path: input.path,
+    limitBytes: input.totalLimitBytes ?? CUSTOMER_OUTPUT_TOTAL_MAX_BYTES,
+    advice:
+      'This looks like too much data for one customer-visible output object. Split the work into rows, or parse the provider response and save only the columns you actually need.',
+  });
+}
+
+export function assertRuntimeReceiptOutputWithinLimit(input: {
+  output: unknown;
+  path: string;
+  limitBytes?: number;
+}): number {
+  return assertJsonSized({
+    value: input.output,
+    path: input.path,
+    limitBytes: input.limitBytes ?? RUNTIME_RECEIPT_OUTPUT_MAX_BYTES,
+    advice:
+      'This receipt result is too large for durable call caching. This usually means raw search results, HTML, or a large list is being cached as one cell. Parse it before returning it from the tool boundary.',
+  });
+}

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

@@ -0,0 +1,17 @@
+export type PlayRunInputPayload = Record<string, unknown> | unknown[];
+
+export function normalizePlayRunInputPayload(
+  input: unknown,
+): PlayRunInputPayload {
+  if (Array.isArray(input)) return input;
+  if (input && typeof input === 'object') {
+    return input as Record<string, unknown>;
+  }
+  return {};
+}
+
+export function playRunInputObjectView(
+  input: PlayRunInputPayload,
+): Record<string, unknown> {
+  return Array.isArray(input) ? {} : input;
+}

package/dist/bundling-sources/shared_libs/play-runtime/play-latency-trace.ts

@@ -1,5 +1,3 @@
-import { HATCHET_COLD_EXECUTION_PHASE_DEFINITIONS } from './hatchet-cold-execution-target';
-
 export type PlayLatencyPhaseDefinition = {
   header: string;
   phase: string;
@@ -294,7 +292,6 @@ export const PLAY_LATENCY_SUMMARY_COLUMNS: PlayLatencyPhaseDefinition[] = [
     description:
       'Runner wall time not explained by inner coordinator.runner_run.',
   },
-  ...HATCHET_COLD_EXECUTION_PHASE_DEFINITIONS,
 ];
 
 const PHASE_DEFINITION_BY_KEY = new Map(

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

@@ -11,6 +11,7 @@ import type { PlayLiveEventSource } from './live-events';
 import type { PreloadedRuntimeDbSession } from './db-session';
 import type { PacingRule } from './governor/rate-state-backend';
 import type { GovernanceSnapshot } from './governor/governor';
+import type { PlayRunInputPayload } from './play-input';
 
 export type PlayRunnerRateStateBackendConfig =
   | {
@@ -49,6 +50,7 @@ export type PlayRunnerRateStatePenalizeInput = {
 export interface PlayRunnerContextConfig {
   executorToken?: string;
   baseUrl?: string;
+  receiptGatewayBaseUrl?: string | null;
   vercelProtectionBypassToken?: string | null;
   integrationMode?: 'live' | 'eval_stub' | 'fixture';
   orgId?: string;
@@ -78,6 +80,13 @@ export interface PlayRunnerContextConfig {
   preloadedDbSessions?: PreloadedRuntimeDbSession[];
   rateStateBackend?: PlayRunnerRateStateBackendConfig;
   runtimeSchedulerSchema?: string | null;
+  /**
+   * Execution profile a scheduler-backed `ctx.runPlay` child must be launched
+   * under. The runner posts it as the `profile` on the child `/api/v2/plays/run`
+   * submission so a child inherits the parent's scheduler (e.g. `absurd`) instead
+   * of defaulting away from the parent scheduler. Absent means `absurd`.
+   */
+  childRunProfile?: string | null;
   governance?: GovernanceSnapshot | null;
 }
 
@@ -87,7 +96,7 @@ export interface PlayRunnerExecutionConfig {
     bundledCodePath?: string | null;
     bundledCodeEncoding?: 'utf8' | 'gzip';
   } | null;
-  input: Record<string, unknown>;
+  input: PlayRunInputPayload;
   checkpoint?: PlayCheckpoint | null;
   csvSourcePath?: string | null;
   csvSourceUrl?: string | null;

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

@@ -12,8 +12,7 @@ import {
 
 export const PLAY_RUNTIME_PROVIDER_IDS = {
   workersEdge: 'workers_edge',
-  hatchet: 'hatchet',
-  local: 'local',
+  absurd: 'absurd',
 } as const;
 
 export type PlayRuntimeProviderId =
@@ -40,22 +39,17 @@ export const PLAY_RUNTIME_PROVIDERS: Record<
     artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
     label: 'Cloudflare Dynamic Workflows + Dynamic Workers + DO dedup',
   },
-  hatchet: {
-    id: PLAY_RUNTIME_PROVIDER_IDS.hatchet,
-    scheduler: PLAY_SCHEDULER_BACKENDS.hatchet,
+  absurd: {
+    id: PLAY_RUNTIME_PROVIDER_IDS.absurd,
+    scheduler: PLAY_SCHEDULER_BACKENDS.absurd,
+    // Server runs execute on Daytona; the local-dev/test shape swaps the runner
+    // axis to local_process (same as the local profile) via an explicit
+    // runtimeBackend override at submit while tests drive local_process.
     runner: PLAY_RUNTIME_BACKENDS.daytona,
     dedup: PLAY_DEDUP_BACKENDS.inMemory,
     artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
     label:
-      'Hatchet scheduler + one-shot Daytona runner + receipt-backed in-process dedup',
-  },
-  local: {
-    id: PLAY_RUNTIME_PROVIDER_IDS.local,
-    scheduler: PLAY_SCHEDULER_BACKENDS.temporal,
-    runner: PLAY_RUNTIME_BACKENDS.localProcess,
-    dedup: PLAY_DEDUP_BACKENDS.inMemory,
-    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    label: 'Local Temporal scheduler + local subprocess runner (tests)',
+      'Absurd (Postgres-native durable) scheduler + one-shot Daytona runner + receipt-backed in-process dedup',
   },
 };
 
@@ -72,7 +66,7 @@ export function resolvePlayRuntimeProvider(
       return PLAY_RUNTIME_PROVIDERS[id as PlayRuntimeProviderId];
     }
     throw new Error(
-      `Unknown play runtime provider "${id}". Expected one of: ${Object.keys(
+      `Unsupported play runtime provider "${id}". Expected one of: ${Object.keys(
         PLAY_RUNTIME_PROVIDERS,
       ).join(', ')}.`,
     );

package/dist/bundling-sources/shared_libs/play-runtime/receipt-completion-sink.ts

@@ -0,0 +1,262 @@
+import {
+  RUNTIME_RECEIPT_COMPLETION_BUFFER_MAX_BYTES,
+  RUNTIME_RECEIPT_OUTPUT_MAX_BYTES,
+} from './output-size-limits';
+
+export const DEFAULT_RECEIPT_COMPLETION_SINK_MAX_BATCH_SIZE = 200;
+export const DEFAULT_RECEIPT_COMPLETION_SINK_MAX_FLUSH_MS = 10;
+export const DEFAULT_RECEIPT_COMPLETION_SINK_MAX_BUFFERED_BYTES =
+  RUNTIME_RECEIPT_COMPLETION_BUFFER_MAX_BYTES;
+export const DEFAULT_RECEIPT_COMPLETION_SINK_MAX_INPUT_BYTES =
+  RUNTIME_RECEIPT_OUTPUT_MAX_BYTES;
+
+type ReceiptCompletionSinkTimer = ReturnType<typeof setTimeout>;
+
+export interface ReceiptCompletionSinkFlushEvent {
+  count: number;
+  bytes: number;
+  elapsedMs?: number;
+}
+
+export interface RuntimeReceiptCompletionSinkOptions<TInput, TOutput> {
+  maxBatchSize?: number;
+  maxFlushMs?: number;
+  maxBufferedBytes?: number;
+  maxInputBytes?: number;
+  estimateBytes?: (input: TInput) => number;
+  completeMany: (inputs: TInput[]) => Promise<TOutput[]>;
+  onFlushStart?: (event: ReceiptCompletionSinkFlushEvent) => void;
+  onFlushDone?: (event: ReceiptCompletionSinkFlushEvent) => void;
+  onFlushError?: (
+    event: ReceiptCompletionSinkFlushEvent & { error: unknown },
+  ) => void;
+  now?: () => number;
+}
+
+interface PendingReceiptCompletion<TInput, TOutput> {
+  input: TInput;
+  bytes: number;
+  resolve: (output: TOutput) => void;
+  reject: (error: unknown) => void;
+}
+
+function normalizePositiveInteger(
+  value: number | undefined,
+  fallback: number,
+): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return fallback;
+  return Math.max(1, Math.floor(value));
+}
+
+function defaultReceiptCompletionByteEstimate(input: unknown): number {
+  try {
+    return new TextEncoder().encode(JSON.stringify(input)).byteLength;
+  } catch {
+    return 1024;
+  }
+}
+
+export class ReceiptCompletionBufferLimitError extends Error {
+  readonly code = 'RECEIPT_COMPLETION_BUFFER_LIMIT_EXCEEDED';
+
+  constructor(message: string) {
+    super(message);
+    this.name = 'ReceiptCompletionBufferLimitError';
+  }
+}
+
+export class ReceiptCompletionResultCountError extends Error {
+  readonly code = 'RECEIPT_COMPLETION_RESULT_COUNT_MISMATCH';
+
+  constructor(message: string) {
+    super(message);
+    this.name = 'ReceiptCompletionResultCountError';
+  }
+}
+
+export class RuntimeReceiptCompletionSink<TInput, TOutput> {
+  readonly maxBatchSize: number;
+  readonly maxFlushMs: number;
+  readonly maxBufferedBytes: number;
+  readonly maxInputBytes: number;
+
+  #pending: Array<PendingReceiptCompletion<TInput, TOutput>> = [];
+  #pendingBytes = 0;
+  #flushTimer: ReceiptCompletionSinkTimer | null = null;
+  #flushPromise: Promise<void> | null = null;
+  #closed = false;
+  #completeMany: (inputs: TInput[]) => Promise<TOutput[]>;
+  #estimateBytes: (input: TInput) => number;
+  #onFlushStart?: (event: ReceiptCompletionSinkFlushEvent) => void;
+  #onFlushDone?: (event: ReceiptCompletionSinkFlushEvent) => void;
+  #onFlushError?: (
+    event: ReceiptCompletionSinkFlushEvent & { error: unknown },
+  ) => void;
+  #now: () => number;
+
+  constructor(options: RuntimeReceiptCompletionSinkOptions<TInput, TOutput>) {
+    this.maxBatchSize = normalizePositiveInteger(
+      options.maxBatchSize,
+      DEFAULT_RECEIPT_COMPLETION_SINK_MAX_BATCH_SIZE,
+    );
+    this.maxFlushMs = normalizePositiveInteger(
+      options.maxFlushMs,
+      DEFAULT_RECEIPT_COMPLETION_SINK_MAX_FLUSH_MS,
+    );
+    this.maxBufferedBytes = normalizePositiveInteger(
+      options.maxBufferedBytes,
+      DEFAULT_RECEIPT_COMPLETION_SINK_MAX_BUFFERED_BYTES,
+    );
+    this.maxInputBytes = normalizePositiveInteger(
+      options.maxInputBytes,
+      DEFAULT_RECEIPT_COMPLETION_SINK_MAX_INPUT_BYTES,
+    );
+    this.#completeMany = options.completeMany;
+    this.#estimateBytes =
+      options.estimateBytes ?? defaultReceiptCompletionByteEstimate;
+    this.#onFlushStart = options.onFlushStart;
+    this.#onFlushDone = options.onFlushDone;
+    this.#onFlushError = options.onFlushError;
+    this.#now = options.now ?? Date.now;
+  }
+
+  addComplete(input: TInput): Promise<TOutput> {
+    return this.addMany([input]).then((outputs) => outputs[0]!);
+  }
+
+  addMany(inputs: readonly TInput[]): Promise<TOutput[]> {
+    if (inputs.length === 0) return Promise.resolve([]);
+    if (this.#closed) {
+      return Promise.reject(
+        new Error('Runtime receipt completion sink is already closed.'),
+      );
+    }
+
+    const outputPromises = inputs.map((input) => this.#enqueue(input));
+    this.#scheduleFlush();
+    return Promise.all(outputPromises);
+  }
+
+  async flush(): Promise<void> {
+    this.#clearFlushTimer();
+    this.#flushPromise ??= this.#runFlushLoop().finally(() => {
+      this.#flushPromise = null;
+    });
+    return await this.#flushPromise;
+  }
+
+  async close(): Promise<void> {
+    this.#closed = true;
+    await this.flush();
+  }
+
+  getStats(): { pending: number; pendingBytes: number; flushing: boolean } {
+    return {
+      pending: this.#pending.length,
+      pendingBytes: this.#pendingBytes,
+      flushing: Boolean(this.#flushPromise),
+    };
+  }
+
+  #enqueue(input: TInput): Promise<TOutput> {
+    const bytes = Math.max(1, Math.ceil(this.#estimateBytes(input)));
+    if (bytes > this.maxInputBytes) {
+      return Promise.reject(
+        new ReceiptCompletionBufferLimitError(
+          `Runtime receipt completion payload is ${bytes} bytes, above the ${this.maxInputBytes} byte per-receipt limit. Parse large provider/search responses before returning them from the tool boundary.`,
+        ),
+      );
+    }
+
+    if (
+      this.#pending.length >= this.maxBatchSize ||
+      this.#pendingBytes + bytes > this.maxBufferedBytes
+    ) {
+      void this.flush().catch(() => undefined);
+    }
+
+    return new Promise<TOutput>((resolve, reject) => {
+      this.#pending.push({ input, bytes, resolve, reject });
+      this.#pendingBytes += bytes;
+      if (this.#pending.length >= this.maxBatchSize) {
+        void this.flush().catch(() => undefined);
+      }
+    });
+  }
+
+  #scheduleFlush(): void {
+    if (this.#flushTimer || this.#flushPromise || this.#pending.length === 0) {
+      return;
+    }
+    this.#flushTimer = setTimeout(() => {
+      this.#flushTimer = null;
+      void this.flush().catch(() => undefined);
+    }, this.maxFlushMs);
+  }
+
+  #clearFlushTimer(): void {
+    if (!this.#flushTimer) return;
+    clearTimeout(this.#flushTimer);
+    this.#flushTimer = null;
+  }
+
+  async #runFlushLoop(): Promise<void> {
+    while (this.#pending.length > 0) {
+      const batch = this.#takeBatch();
+      await this.#flushBatch(batch);
+    }
+  }
+
+  #takeBatch(): Array<PendingReceiptCompletion<TInput, TOutput>> {
+    const batch: Array<PendingReceiptCompletion<TInput, TOutput>> = [];
+    let batchBytes = 0;
+    while (this.#pending.length > 0 && batch.length < this.maxBatchSize) {
+      const next = this.#pending[0]!;
+      if (
+        batch.length > 0 &&
+        batchBytes + next.bytes > this.maxBufferedBytes
+      ) {
+        break;
+      }
+      this.#pending.shift();
+      this.#pendingBytes -= next.bytes;
+      batch.push(next);
+      batchBytes += next.bytes;
+    }
+    return batch;
+  }
+
+  async #flushBatch(
+    batch: Array<PendingReceiptCompletion<TInput, TOutput>>,
+  ): Promise<void> {
+    const inputs = batch.map((item) => item.input);
+    const bytes = batch.reduce((sum, item) => sum + item.bytes, 0);
+    const startedAt = this.#now();
+    this.#onFlushStart?.({ count: inputs.length, bytes });
+    try {
+      const outputs = await this.#completeMany(inputs);
+      if (outputs.length !== batch.length) {
+        throw new ReceiptCompletionResultCountError(
+          `Runtime receipt completion sink expected ${batch.length} result(s), received ${outputs.length}.`,
+        );
+      }
+      outputs.forEach((output, index) => batch[index]!.resolve(output));
+      this.#onFlushDone?.({
+        count: inputs.length,
+        bytes,
+        elapsedMs: this.#now() - startedAt,
+      });
+    } catch (error) {
+      for (const item of batch) {
+        item.reject(error);
+      }
+      this.#onFlushError?.({
+        count: inputs.length,
+        bytes,
+        elapsedMs: this.#now() - startedAt,
+        error,
+      });
+      throw error;
+    }
+  }
+}

package/dist/bundling-sources/shared_libs/play-runtime/receipt-heartbeat-supervisor.ts

@@ -0,0 +1,64 @@
+export type RuntimeReceiptHeartbeatOutcome = 'active' | 'terminal';
+
+export type RuntimeReceiptHeartbeatSupervisor = {
+  start(): void;
+  stop(): void;
+};
+
+export function createRuntimeReceiptHeartbeatSupervisor(input: {
+  intervalMs: number;
+  heartbeat: () => Promise<RuntimeReceiptHeartbeatOutcome>;
+  isLeaseLost: (error: unknown) => boolean;
+  onLeaseLost: (error: unknown) => void;
+  onTransientFailure?: (error: unknown) => void;
+  onTerminal?: () => void;
+}): RuntimeReceiptHeartbeatSupervisor {
+  if (!Number.isFinite(input.intervalMs) || input.intervalMs <= 0) {
+    throw new Error('Runtime receipt heartbeat interval must be positive.');
+  }
+
+  let stopped = false;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  const stop = () => {
+    stopped = true;
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+
+  const schedule = () => {
+    if (stopped || timer !== null) return;
+    timer = setTimeout(() => {
+      timer = null;
+      void input
+        .heartbeat()
+        .then((outcome) => {
+          if (outcome === 'terminal') {
+            stop();
+            input.onTerminal?.();
+            return;
+          }
+          schedule();
+        })
+        .catch((error) => {
+          if (input.isLeaseLost(error)) {
+            stop();
+            input.onLeaseLost(error);
+            return;
+          }
+          input.onTransientFailure?.(error);
+          schedule();
+        });
+    }, input.intervalMs);
+  };
+
+  return {
+    start() {
+      if (stopped) return;
+      schedule();
+    },
+    stop,
+  };
+}