deepline 0.1.19 → 0.1.21

package/dist/repo/sdk/src/client.ts

@@ -163,6 +163,15 @@ function mapLegacyTemporalStatus(status: string): PlayStatus['status'] {
   }
 }
 
+function decodeBase64Bytes(value: string): Uint8Array {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
 /**
  * Low-level client for the Deepline REST API.
  *
@@ -849,9 +858,34 @@ export class DeeplineClient {
       bytes: number;
     }>,
   ): Promise<PlayStagedFileRef[]> {
-    const response = await this.http.post<{ files: PlayStagedFileRef[] }>(
+    const formData = new FormData();
+    formData.set(
+      'metadata',
+      JSON.stringify({
+        files: files.map((file, index) => ({
+          index,
+          logicalPath: file.logicalPath,
+          contentHash: file.contentHash,
+          contentType: file.contentType,
+          bytes: file.bytes,
+        })),
+      }),
+    );
+    for (const [index, file] of files.entries()) {
+      const bytes = decodeBase64Bytes(file.contentBase64);
+      const body = bytes.buffer.slice(
+        bytes.byteOffset,
+        bytes.byteOffset + bytes.byteLength,
+      ) as ArrayBuffer;
+      formData.set(
+        `file:${index}`,
+        new Blob([body], { type: file.contentType }),
+        file.logicalPath,
+      );
+    }
+    const response = await this.http.postFormData<{ files: PlayStagedFileRef[] }>(
       '/api/v2/plays/files/stage',
-      { files },
+      formData,
     );
     return response.files;
   }
@@ -896,9 +930,17 @@ export class DeeplineClient {
    * console.log(`Logs: ${status.progress?.logs.length ?? 0} lines`);
    * ```
    */
-  async getPlayStatus(workflowId: string): Promise<PlayStatus> {
+  async getPlayStatus(
+    workflowId: string,
+    options?: { billing?: boolean },
+  ): Promise<PlayStatus> {
+    const params = new URLSearchParams();
+    if (options?.billing === false) {
+      params.set('billing', 'false');
+    }
+    const query = params.size > 0 ? `?${params.toString()}` : '';
     const response = await this.http.get<Record<string, unknown>>(
-      `/api/v2/plays/run/${encodeURIComponent(workflowId)}`,
+      `/api/v2/plays/run/${encodeURIComponent(workflowId)}${query}`,
     );
     return normalizePlayStatus(response);
   }

package/dist/repo/sdk/src/http.ts

@@ -31,6 +31,7 @@ import {
 interface RequestOptions {
   method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
   body?: unknown;
+  formData?: FormData;
   headers?: Record<string, string>;
   /** Per-request timeout override in milliseconds. */
   timeout?: number;
@@ -150,7 +151,12 @@ export class HttpClient {
           const response = await fetch(candidateUrl, {
             method,
             headers,
-            body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+            body:
+              options?.formData !== undefined
+                ? options.formData
+                : options?.body !== undefined
+                  ? JSON.stringify(options.body)
+                  : undefined,
             signal: controller.signal,
           });
 
@@ -179,10 +185,26 @@ export class HttpClient {
           }
 
           if (!response.ok) {
-            const msg =
+            const errorValue =
               typeof parsed === 'object' && parsed && 'error' in parsed
-                ? String((parsed as Record<string, unknown>).error)
-                : `HTTP ${response.status}`;
+                ? (parsed as Record<string, unknown>).error
+                : undefined;
+            const msg =
+              typeof errorValue === 'string'
+                ? errorValue
+                : errorValue &&
+                    typeof errorValue === 'object' &&
+                    'message' in errorValue &&
+                    typeof (errorValue as Record<string, unknown>).message ===
+                      'string'
+                  ? (errorValue as Record<string, string>).message
+                  : typeof parsed === 'object' &&
+                      parsed &&
+                      'message' in parsed &&
+                      typeof (parsed as Record<string, unknown>).message ===
+                        'string'
+                    ? (parsed as Record<string, string>).message
+                    : `HTTP ${response.status}`;
             throw new DeeplineError(msg, response.status, 'API_ERROR', {
               response: parsed,
             });
@@ -301,6 +323,18 @@ export class HttpClient {
     });
   }
 
+  async postFormData<T = unknown>(
+    path: string,
+    formData: FormData,
+    headers?: Record<string, string>,
+  ): Promise<T> {
+    return this.request<T>(path, {
+      method: 'POST',
+      formData,
+      headers,
+    });
+  }
+
   /**
    * Send a DELETE request.
    *

package/dist/repo/sdk/src/plays/harness-stub.ts

@@ -33,6 +33,7 @@
 
 import type {
   PlayHarnessRpc,
+  PreloadedRuntimeDbSessionInput,
   RuntimeApiCallInput,
   RuntimeApiCallResult,
   RuntimePayloadSchemaId,
@@ -121,6 +122,17 @@ export async function harnessRuntimeApiCall(
   return requireBinding().runtimeApiCall(input);
 }
 
+/**
+ * Warm Postgres sessions in the long-lived harness Worker. This preserves the
+ * map fast path without bundling the Neon client into every dynamic play.
+ */
+export async function harnessPrewarmPostgresSessions(input: {
+  executorToken: string;
+  sessions: PreloadedRuntimeDbSessionInput[];
+}): Promise<{ ok: true; sessions: number }> {
+  return requireBinding().prewarmPostgresSessions(input);
+}
+
 /**
  * Start or continue a map dataset write inside the harness, so this call
  * skips per-play callback overhead for heavy Postgres writes.

package/dist/repo/sdk/src/version.ts

@@ -1,2 +1,2 @@
-export const SDK_VERSION = "0.1.19";
+export const SDK_VERSION = "0.1.21";
 export const SDK_API_CONTRACT = "2026-05-runs-v2";

package/dist/repo/shared_libs/play-runtime/scheduler-backend.ts

@@ -17,6 +17,7 @@ import type {
 } from './ctx-types';
 import type { ExecutionPlan } from './execution-plan';
 import type { PlayRuntimeManifestMap } from '../plays/compiler-manifest';
+import type { PreloadedRuntimeDbSession } from './db-session';
 
 export const PLAY_SCHEDULER_BACKENDS = {
   temporal: 'temporal',
@@ -79,6 +80,7 @@ export type PlaySchedulerSubmitInput = {
   executionPlan?: ExecutionPlan | null;
   childPlayManifests?: PlayRuntimeManifestMap | null;
   playCallGovernance?: PlayCallGovernanceSnapshot | null;
+  preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
   /** Optional immutable Worker module source for local Dynamic Worker loading. */
   dynamicWorkerCode?: string | null;
   executorToken: string;
@@ -109,12 +111,6 @@ export type PlaySchedulerProgressEvent =
 
 export type PlaySchedulerRunHandle = {
   runId: string;
-  /**
-   * Optional snapshot of the run's state captured during submit() so callers
-   * can skip an immediate follow-up status read. Populated by backends that
-   * piggyback the read on the create round-trip (currently cf-workflows).
-   */
-  initialState?: Record<string, unknown> | null;
   /**
    * Stream live progress events. Implementations may use SSE, polling, etc.
    * The contract: yields events in order until terminal status.
@@ -156,6 +152,7 @@ export interface PlaySchedulerBackend {
     options?: {
       coordinatorUrl?: string | null;
       coordinatorInternalToken?: string | null;
+      initialState?: Record<string, unknown> | null;
     },
   ): Promise<PlaySchedulerRunHandle>;
 }

package/dist/repo/shared_libs/plays/row-identity.ts

@@ -276,13 +276,64 @@ export function resolvePlayRunTableNamespace(
 export function derivePlayRowIdentity(
   row: Record<string, unknown>,
   tableNamespace: string,
+  logicFingerprint?: string | null,
 ): string {
-  const normalizedNamespace = normalizeTableNamespace(tableNamespace);
-  const canonicalRow = stableStringify(row);
-  const digest = sha256Hex(`${normalizedNamespace}\n${canonicalRow}`);
+  return deriveDerivedOutputIdentity({
+    inputItem: row,
+    operationNamespace: tableNamespace,
+    logicFingerprint,
+  });
+}
+
+export function deriveDerivedOutputIdentity(input: {
+  inputItem: Record<string, unknown>;
+  operationNamespace: string;
+  logicFingerprint?: string | null;
+}): string {
+  const normalizedNamespace = normalizeTableNamespace(
+    input.operationNamespace,
+  );
+  const canonicalRow = stableStringify(input.inputItem);
+  const fingerprint = input.logicFingerprint?.trim()
+    ? `\nlogic:${input.logicFingerprint.trim()}`
+    : '';
+  const digest = sha256Hex(
+    `${normalizedNamespace}${fingerprint}\n${canonicalRow}`,
+  );
   return `${normalizedNamespace}:${digest}`;
 }
 
+export function deriveToolRequestIdentity(input: {
+  toolId: string;
+  requestInput: Record<string, unknown>;
+  effectiveAccountContext?: string | null;
+  toolContractRevision?: string | number | null;
+  reuseSafetyPolicy?: string | null;
+}): string {
+  const toolId = input.toolId.trim();
+  if (!toolId) {
+    throw new Error('Tool request identity requires a non-empty tool id.');
+  }
+  const accountContext =
+    input.effectiveAccountContext?.trim() || 'default_account_context';
+  const contractRevision =
+    input.toolContractRevision == null
+      ? 'default_tool_contract'
+      : String(input.toolContractRevision).trim() || 'default_tool_contract';
+  const reuseSafetyPolicy =
+    input.reuseSafetyPolicy?.trim() || 'default_reuse_policy';
+  const digest = sha256Hex(
+    stableStringify({
+      accountContext,
+      requestInput: input.requestInput,
+      reuseSafetyPolicy,
+      toolContractRevision: contractRevision,
+      toolId,
+    }),
+  );
+  return `tool:${normalizeTableNamespace(toolId)}:${digest}`;
+}
+
 /**
  * Build a stable row identity from an explicit user-provided key string.
  *
@@ -293,9 +344,13 @@ export function derivePlayRowIdentity(
 export function derivePlayRowIdentityFromKey(
   key: string,
   tableNamespace: string,
+  logicFingerprint?: string | null,
 ): string {
   const normalizedNamespace = normalizeTableNamespace(tableNamespace);
-  const digest = sha256Hex(`${normalizedNamespace}\nkey:${key}`);
+  const fingerprint = logicFingerprint?.trim()
+    ? `\nlogic:${logicFingerprint.trim()}`
+    : '';
+  const digest = sha256Hex(`${normalizedNamespace}${fingerprint}\nkey:${key}`);
   return `${normalizedNamespace}:${digest}`;
 }
 

package/package.json

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