deepline 0.1.227 → 0.1.229

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/ledger-event-batches.ts

@@ -0,0 +1,81 @@
+import {
+  MAX_LEDGER_LOG_LINE_LENGTH,
+  MAX_LEDGER_LOG_LINES_PER_EVENT,
+} from '../../../../shared_libs/play-runtime/ledger-safe-payload';
+import type { PlayRunLedgerEvent } from '../../../../shared_libs/play-runtime/run-ledger';
+
+/** Keep a Worker-to-runtime append comfortably below the API and Convex limits. */
+export const WORKER_LEDGER_EVENT_BATCH_MAX_BYTES = 128 * 1024;
+export const WORKER_LEDGER_EVENTS_PER_APPEND_MAX = 100;
+
+const encoder = new TextEncoder();
+
+function encodedJsonBytes(value: unknown): number {
+  return encoder.encode(JSON.stringify(value)).length;
+}
+
+function splitLogEvent(
+  event: Extract<PlayRunLedgerEvent, { type: 'log.appended' }>,
+): PlayRunLedgerEvent[] {
+  const events: PlayRunLedgerEvent[] = [];
+  const lines = event.lines.map((line) =>
+    line.slice(0, MAX_LEDGER_LOG_LINE_LENGTH),
+  );
+  let start = 0;
+  while (start < lines.length) {
+    let end = start;
+    let bytes = encodedJsonBytes({ ...event, lines: [] });
+    while (end < lines.length && end - start < MAX_LEDGER_LOG_LINES_PER_EVENT) {
+      const lineBytes = encodedJsonBytes(lines[end]!);
+      if (
+        end > start &&
+        bytes + lineBytes + 1 > WORKER_LEDGER_EVENT_BATCH_MAX_BYTES
+      ) {
+        break;
+      }
+      bytes += lineBytes + 1;
+      end += 1;
+    }
+    events.push({
+      ...event,
+      lines: lines.slice(start, end),
+      ...(typeof event.channelOffset === 'number'
+        ? { channelOffset: event.channelOffset + start }
+        : {}),
+    });
+    start = end;
+  }
+  return events;
+}
+
+/**
+ * Partition ledger delivery without dropping positional log lines. The worker
+ * retries only unacknowledged batches, so each batch must be independently
+ * valid for the app-runtime and Convex boundaries.
+ */
+export function partitionWorkerLedgerEvents(
+  events: readonly PlayRunLedgerEvent[],
+): PlayRunLedgerEvent[][] {
+  const batches: PlayRunLedgerEvent[][] = [];
+  let batch: PlayRunLedgerEvent[] = [];
+  let batchBytes = 2;
+
+  for (const event of events.flatMap((event) =>
+    event.type === 'log.appended' ? splitLogEvent(event) : [event],
+  )) {
+    const eventBytes = encodedJsonBytes(event);
+    if (
+      batch.length > 0 &&
+      (batch.length >= WORKER_LEDGER_EVENTS_PER_APPEND_MAX ||
+        batchBytes + eventBytes + 1 > WORKER_LEDGER_EVENT_BATCH_MAX_BYTES)
+    ) {
+      batches.push(batch);
+      batch = [];
+      batchBytes = 2;
+    }
+    batch.push(event);
+    batchBytes += eventBytes + 1;
+  }
+  if (batch.length > 0) batches.push(batch);
+  return batches;
+}

package/dist/bundling-sources/apps/play-runner-workers/src/workflow-retry-state.ts

@@ -1,13 +1,6 @@
 import type { ExecutionPlan } from '../../../shared_libs/play-runtime/execution-plan';
-import type {
-  PlayCallGovernanceSnapshot,
-  PlayRunInputPayload,
-} from '../../../shared_libs/play-runtime/scheduler-backend';
+import type { PlayRunInputPayload } from '../../../shared_libs/play-runtime/scheduler-backend';
 import type { PreloadedRuntimeDbSession } from '../../../shared_libs/play-runtime/db-session';
-import type {
-  PlayRuntimeManifest,
-  PlayRuntimeManifestMap,
-} from '../../../shared_libs/plays/compiler-manifest';
 
 import {
   PLAY_SUBMIT_INPUT_INLINE_MAX_BYTES,
@@ -57,8 +50,6 @@ export type WorkflowRetryPlayParams = {
   }> | null;
   contractSnapshot?: unknown;
   executionPlan?: ExecutionPlan | null;
-  childPlayManifests?: PlayRuntimeManifestMap | null;
-  playCallGovernance?: PlayCallGovernanceSnapshot | null;
   preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
   preloadedDbSessionRef?: {
     runId: string;
@@ -100,7 +91,6 @@ export function buildWorkflowRetryParams<
     ...params,
     dynamicWorkerCode: null,
     contractSnapshot: stripRetrySourceSnapshot(params.contractSnapshot),
-    childPlayManifests: stripRetryChildManifestCode(params.childPlayManifests),
     packagedFiles: stripRetryPackagedFiles(params.packagedFiles),
   } satisfies WorkflowRetryPlayParams as TParams;
   if (jsonByteLength(retryParams) <= WORKFLOW_RETRY_STATE_TARGET_BYTES) {
@@ -112,9 +102,6 @@ export function buildWorkflowRetryParams<
       retryParams.contractSnapshot,
       params,
     ),
-    childPlayManifests: stripRetryChildManifestToArtifact(
-      retryParams.childPlayManifests,
-    ),
   } satisfies WorkflowRetryPlayParams as TParams;
 }
 
@@ -175,42 +162,6 @@ function stripRetryContractSnapshotToArtifact(
   };
 }
 
-function stripRetryChildManifestCode(
-  manifests: PlayRuntimeManifestMap | null | undefined,
-): PlayRuntimeManifestMap | null {
-  if (!manifests) return null;
-  const stripped: PlayRuntimeManifestMap = {};
-  for (const [key, manifest] of Object.entries(manifests)) {
-    const rest = { ...manifest };
-    delete rest.bundledCode;
-    delete rest.sourceCode;
-    delete (rest as Record<string, unknown>).sourceMap;
-    stripped[key] = rest;
-  }
-  return stripped;
-}
-
-function stripRetryChildManifestToArtifact(
-  manifests: PlayRuntimeManifestMap | null | undefined,
-): PlayRuntimeManifestMap | null {
-  if (!manifests) return null;
-  const stripped: PlayRuntimeManifestMap = {};
-  for (const [key, manifest] of Object.entries(manifests)) {
-    stripped[key] = {
-      playName: manifest.playName,
-      graphHash: manifest.graphHash,
-      artifactStorageKey: manifest.artifactStorageKey,
-      artifactHash: manifest.artifactHash,
-      staticPipelineHash: manifest.staticPipelineHash,
-      staticPipeline: manifest.staticPipeline,
-      compiledAt: manifest.compiledAt,
-      compilerVersion: manifest.compilerVersion,
-      maxCreditsPerRun: manifest.maxCreditsPerRun,
-    };
-  }
-  return stripped;
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/bundling-sources/sdk/src/client.ts

@@ -243,8 +243,30 @@ type ExecuteToolRawOptions = {
   maxRetries?: number;
 };
 
-function resolveToolExecuteTimeoutMs(toolId: string): number | undefined {
+/**
+ * The server launches the Apify run, polls it for `payload.timeoutMs`, then
+ * reads its dataset before replying. Keep the client request alive through
+ * that final hand-off so a pollable run id is never lost to the SDK default
+ * timeout.
+ */
+const APIFY_SYNC_DEFAULT_TIMEOUT_MS = 300_000;
+const APIFY_SYNC_RESPONSE_GRACE_MS = 90_000;
+
+function resolveToolExecuteTimeoutMs(
+  toolId: string,
+  input: Record<string, unknown>,
+): number | undefined {
   const normalized = toolId.trim().toLowerCase();
+  if (normalized === 'apify_run_actor_sync') {
+    const requestedTimeoutMs = input.timeoutMs ?? APIFY_SYNC_DEFAULT_TIMEOUT_MS;
+    if (
+      typeof requestedTimeoutMs === 'number' &&
+      Number.isFinite(requestedTimeoutMs) &&
+      requestedTimeoutMs > 0
+    ) {
+      return Math.floor(requestedTimeoutMs) + APIFY_SYNC_RESPONSE_GRACE_MS;
+    }
+  }
   return normalized === 'deeplineagent' ||
     normalized === 'deeplineagent_deeplineagent' ||
     normalized === 'ai_inference' ||
@@ -1417,7 +1439,7 @@ export class DeeplineClient {
       headers,
       {
         forbiddenAsApiError: true,
-        timeout: options?.timeout ?? resolveToolExecuteTimeoutMs(toolId),
+        timeout: options?.timeout ?? resolveToolExecuteTimeoutMs(toolId, input),
         maxRetries: options?.maxRetries ?? 0,
         exactUrlOnly: true,
       },

package/dist/bundling-sources/sdk/src/play.ts

@@ -161,7 +161,7 @@ export interface PlayCallOptions {
  *   sqlListeners: [
  *     {
  *       id: 'jobs',
- *       tool: 'tamradar.company_radar',
+ *       tool: 'deepline_native.company_radar',
  *       stream: 'company_job_openings',
  *       operations: ['INSERT'],
  *     },
@@ -237,7 +237,7 @@ export type SqlListenerWhere = {
 export type SqlListenerDeclaration = {
   /** Short id unique inside this play. Deepline stores it as playName.id. */
   id: string;
-  /** Modeled monitor tool id, for example "tamradar.company_radar". */
+  /** Modeled monitor tool id, for example "deepline_native.company_radar". */
   tool: string;
   /** Stream key exposed by the modeled monitor tool, for example "company_job_openings". */
   stream: string;

package/dist/bundling-sources/sdk/src/release.ts

@@ -108,10 +108,10 @@ export const SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: '0.1.227',
+  version: '0.1.229',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.227',
+    latest: '0.1.229',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.219',
     commandMinimumSupported: [