deepline 0.2.20 → 0.2.22

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

@@ -607,6 +607,22 @@ export type PlaySecretMetadata = {
 export type RunsNamespace = {
   /** Get current run status by public run id. */
   get: (runId: string, options?: RunsGetOptions) => Promise<PlayStatus>;
+  /** Explicitly read the retained original input (may include customer data). */
+  input: (runId: string) => Promise<{
+    runId: string;
+    input: Record<string, unknown> | unknown[];
+    bytes: number;
+    sha256: string | null;
+    replayedFromRunId: string | null;
+  }>;
+  /** Start a fresh run from a prior run's retained input and pinned revision. */
+  rerun: (runId: string) => Promise<{
+    runId: string;
+    replayedFromRunId: string;
+    revisionId: string | null;
+    status: string;
+    next: { inspect: string; input: string };
+  }>;
   /** List runs for one play, optionally filtered by status. */
   list: (options: RunsListOptions) => Promise<PlayRunListItem[]>;
   /** Stream run events and return the latest/terminal run status. */
@@ -1569,6 +1585,8 @@ export class DeeplineClient {
       list: (options) => this.listRuns(options),
       tail: (runId, options) => this.tailRun(runId, options),
       logs: (runId, options) => this.getRunLogs(runId, options),
+      input: (runId) => this.getRunInput(runId),
+      rerun: (runId) => this.rerun(runId),
       exportDatasetRows: (input) => this.getPlaySheetRows(input),
       stop: (runId, options) => this.stopRun(runId, options),
       stopAll: (options) => this.stopAllRuns(options),
@@ -3452,6 +3470,31 @@ export class DeeplineClient {
     }
   }
 
+  /** Get the exact original input retained for a run. This is intentionally separate from status. */
+  async getRunInput(runId: string): Promise<{
+    runId: string;
+    input: Record<string, unknown> | unknown[];
+    bytes: number;
+    sha256: string | null;
+    replayedFromRunId: string | null;
+  }> {
+    return this.http.get(`/api/v2/runs/${encodeURIComponent(runId)}/input`);
+  }
+
+  /** Start a fresh run from a prior run's retained input and pinned revision. */
+  async rerun(runId: string): Promise<{
+    runId: string;
+    replayedFromRunId: string;
+    revisionId: string | null;
+    status: string;
+    next: { inspect: string; input: string };
+  }> {
+    return this.http.post(
+      `/api/v2/runs/${encodeURIComponent(runId)}/rerun`,
+      {},
+    );
+  }
+
   /**
    * Fetch persisted logs for a run using the public runs resource model.
    *

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

@@ -160,7 +160,7 @@ export const SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: '0.2.20',
+  version: '0.2.22',
   contracts: {
     api: {
       name: 'sdk-http-api',

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

@@ -149,6 +149,10 @@ type RuntimeApiRequest =
       maxCreditsPerRun?: number | null;
       staticPipeline?: unknown;
       source?: 'published' | 'ad_hoc' | 'draft';
+      inputFileId?: string;
+      inputBytes?: number;
+      inputSha256?: string;
+      replayedFromRunId?: string | null;
     }
   | ({
       action: 'save_results';
@@ -1598,6 +1602,10 @@ export async function startRunViaAppRuntime(
     maxCreditsPerRun?: number | null;
     staticPipeline?: unknown;
     source?: 'published' | 'ad_hoc' | 'draft';
+    inputFileId?: string;
+    inputBytes?: number;
+    inputSha256?: string;
+    replayedFromRunId?: string | null;
     idempotencyKey?: string;
   },
 ): Promise<void> {

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backend.ts

@@ -49,6 +49,11 @@ export type PlaySchedulerSubmitInput = {
   artifactHash: string;
   graphHash: string;
   input: PlayRunInputPayload;
+  /** Convex metadata for the exact input saved before scheduler submission. */
+  inputFileId?: string;
+  inputBytes?: number;
+  inputSha256?: string;
+  replayedFromRunId?: string | null;
   /** Start a fresh run graph and recompute runtime-sheet rows. */
   force?: boolean;
   /** Explicit cache bypass for completed ctx.tools.execute receipts. */

package/dist/bundling-sources/shared_libs/security/safe-outbound-fetch.ts

@@ -14,6 +14,7 @@ import {
 type NodeSafeFetchOptions = {
   maxRedirects?: number;
   maxResponseBytes?: number;
+  truncateResponseBody?: boolean;
   sensitiveHeaders?: Iterable<string>;
   validateUrl?: (url: URL) => void;
 };
@@ -187,6 +188,7 @@ function createRequest(
   init: RequestInit,
   prepared: PreparedBody,
   maxResponseBytes: number | undefined,
+  truncateResponseBody: boolean,
 ): Promise<Response> {
   return new Promise((resolve, reject) => {
     const transport = url.protocol === 'https:' ? https : http;
@@ -208,7 +210,8 @@ function createRequest(
           !noBodyResponse &&
           maxResponseBytes !== undefined &&
           Number.isFinite(contentLength) &&
-          contentLength > maxResponseBytes
+          contentLength > maxResponseBytes &&
+          !truncateResponseBody
         ) {
           response.resume();
           reject(
@@ -219,12 +222,27 @@ function createRequest(
 
         const chunks: Buffer[] = [];
         let receivedBytes = 0;
+        let settled = false;
+        const resolveResponse = () => {
+          if (settled) return;
+          settled = true;
+          resolve(
+            new Response(noBodyResponse ? null : Buffer.concat(chunks), {
+              status,
+              statusText: response.statusMessage,
+              headers: response.headers as HeadersInit,
+            }),
+          );
+        };
         response.on('data', (chunk) => {
+          if (settled) return;
           const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          const previousReceivedBytes = receivedBytes;
           receivedBytes += buffer.byteLength;
           if (
             maxResponseBytes !== undefined &&
-            receivedBytes > maxResponseBytes
+            receivedBytes > maxResponseBytes &&
+            !truncateResponseBody
           ) {
             response.destroy(
               new Error(
@@ -234,19 +252,29 @@ function createRequest(
             return;
           }
           if (!noBodyResponse) {
-            chunks.push(buffer);
+            if (maxResponseBytes !== undefined && truncateResponseBody) {
+              const remainingBytes = Math.max(
+                0,
+                maxResponseBytes - previousReceivedBytes,
+              );
+              if (remainingBytes > 0) {
+                chunks.push(buffer.subarray(0, remainingBytes));
+              }
+              if (receivedBytes >= maxResponseBytes) {
+                resolveResponse();
+                response.destroy();
+              }
+            } else {
+              chunks.push(buffer);
+            }
           }
         });
-        response.on('error', reject);
-        response.on('end', () => {
-          resolve(
-            new Response(noBodyResponse ? null : Buffer.concat(chunks), {
-              status,
-              statusText: response.statusMessage,
-              headers: response.headers as HeadersInit,
-            }),
-          );
+        response.on('error', (error) => {
+          if (settled) return;
+          settled = true;
+          reject(error);
         });
+        response.on('end', resolveResponse);
       },
     );
 
@@ -299,6 +327,7 @@ export async function safeOutboundFetch(
   const redirectMode = init.redirect ?? 'follow';
   const maxRedirects = options.maxRedirects ?? 10;
   const maxResponseBytes = options.maxResponseBytes;
+  const truncateResponseBody = options.truncateResponseBody === true;
   const validateUrl = options.validateUrl;
   let currentUrl = assertPublicHttpUrl(input);
   let currentInit: RequestInit = { ...init, redirect: 'manual' };
@@ -321,6 +350,7 @@ export async function safeOutboundFetch(
       currentInit,
       await prepareBody(currentInit),
       maxResponseBytes,
+      truncateResponseBody,
     );
 
     Object.defineProperty(response, 'url', {