deepline 0.1.210 → 0.1.212

package/dist/index.mjs

@@ -352,10 +352,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.210",
+  version: "0.1.212",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.210",
+    latest: "0.1.212",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -1088,9 +1088,91 @@ function normalizePlayRunLedgerTerminalSource(value) {
   ) ? value : null;
 }
 
+// ../shared_libs/play-runtime/secret-redaction.ts
+var SECRET_REDACTION_PLACEHOLDER = "[REDACTED_SECRET]";
+var BEARER_TOKEN_RE = /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/g;
+var JWT_RE = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g;
+var PRIVATE_KEY_RE = /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g;
+var COMMON_SECRET_RE = /\b(?:sk|pk|rk|pat|ghp|github_pat|xox[baprs]|key|token|secret|api[_-]?key)[A-Za-z0-9_./+=:-]{12,}\b/gi;
+var URL_SECRET_VALUE_RE = /\b(?:sk|pk|rk|pat|ghp|github_pat|xox)[A-Za-z0-9_./+=:-]{12,}\b/i;
+var HIGH_ENTROPY_ASSIGNMENT_RE = /\b(?:api[_-]?key|token|secret|password|authorization|access[_-]?token|refresh[_-]?token)\b\s*[:=]\s*["']?[^"',\s]{16,}["']?/gi;
+var SENSITIVE_URL_PARAM_RE = /[?#&](?:\w*(?:key|token)|secret|password|authorization|credential|signature|sig)(?:=|$)/i;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function redactSecretLikeString(value) {
+  const trimmed = value.trim();
+  if (/^https?:\/\/\S+$/i.test(trimmed)) {
+    if (/^https?:\/\/[^/?#@]+@/i.test(trimmed) || SENSITIVE_URL_PARAM_RE.test(trimmed)) {
+      return SECRET_REDACTION_PLACEHOLDER;
+    }
+    if (!URL_SECRET_VALUE_RE.test(value)) return value;
+  }
+  return value.replace(PRIVATE_KEY_RE, SECRET_REDACTION_PLACEHOLDER).replace(BEARER_TOKEN_RE, `Bearer ${SECRET_REDACTION_PLACEHOLDER}`).replace(JWT_RE, SECRET_REDACTION_PLACEHOLDER).replace(COMMON_SECRET_RE, SECRET_REDACTION_PLACEHOLDER).replace(HIGH_ENTROPY_ASSIGNMENT_RE, (match) => {
+    const separator = match.includes("=") ? "=" : ":";
+    const [key] = match.split(separator, 1);
+    return `${key.trim()}${separator}${SECRET_REDACTION_PLACEHOLDER}`;
+  });
+}
+function createSecretRedactionContext(initialValues = []) {
+  const exactSecrets = /* @__PURE__ */ new Set();
+  function register(value) {
+    if (value.length >= 4) exactSecrets.add(value);
+  }
+  for (const value of initialValues) register(value);
+  function redactString(value) {
+    let output = value;
+    for (const secret of exactSecrets) {
+      output = output.replace(
+        new RegExp(escapeRegExp(secret), "g"),
+        SECRET_REDACTION_PLACEHOLDER
+      );
+      try {
+        const encoded = encodeURIComponent(secret);
+        if (encoded !== secret) {
+          output = output.replace(
+            new RegExp(escapeRegExp(encoded), "g"),
+            SECRET_REDACTION_PLACEHOLDER
+          );
+        }
+      } catch {
+      }
+    }
+    return redactSecretLikeString(output);
+  }
+  function redact(value) {
+    if (typeof value === "string") return redactString(value);
+    if (Array.isArray(value)) return value.map((entry) => redact(entry));
+    if (isRecord(value)) {
+      return Object.fromEntries(
+        Object.entries(value).map(([key, entry]) => [key, redact(entry)])
+      );
+    }
+    return value;
+  }
+  return {
+    register,
+    redactString,
+    redact
+  };
+}
+
+// ../shared_libs/play-runtime/output-size-limits.ts
+var encoder = typeof TextEncoder === "undefined" ? null : new TextEncoder();
+var CUSTOMER_OUTPUT_VALUE_MAX_BYTES = 1 * 1024 * 1024;
+var CUSTOMER_OUTPUT_TOTAL_MAX_BYTES = 2 * 1024 * 1024;
+var RUNTIME_RECEIPT_OUTPUT_MAX_BYTES = 10 * 1024 * 1024;
+var RUNTIME_RECEIPT_COMPLETION_BUFFER_MAX_BYTES = 32 * 1024 * 1024;
+
+// ../shared_libs/play-runtime/ledger-safe-payload.ts
+var ledgerIngressRedactor = createSecretRedactionContext();
+
 // ../shared_libs/play-runtime/run-ledger.ts
 var LOG_TAIL_LIMIT = 100;
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function finiteNumber(value) {
@@ -1172,6 +1254,8 @@ function createEmptyPlayRunLedgerSnapshot(input) {
     durationMs: startedAt !== null && finishedAt !== null ? Math.max(0, finishedAt - startedAt) : null,
     orderedStepIds: [],
     stepsById: {},
+    orderedDatasetIds: [],
+    datasetsById: {},
     logTail: [],
     totalLogCount: 0,
     logsTruncated: false,
@@ -1181,21 +1265,21 @@ function createEmptyPlayRunLedgerSnapshot(input) {
   };
 }
 function normalizePlayRunLedgerSnapshot(value, fallback) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return createEmptyPlayRunLedgerSnapshot(fallback);
   }
   const orderedStepIds = Array.isArray(value.orderedStepIds) ? value.orderedStepIds.filter(
     (entry) => typeof entry === "string" && Boolean(entry.trim())
   ) : [];
-  const rawSteps = isRecord(value.stepsById) ? value.stepsById : {};
+  const rawSteps = isRecord2(value.stepsById) ? value.stepsById : {};
   const stepsById = {};
   for (const [stepId, rawStep] of Object.entries(rawSteps)) {
-    if (!stepId.trim() || !isRecord(rawStep)) continue;
+    if (!stepId.trim() || !isRecord2(rawStep)) continue;
     const rawStatus = normalizeStepStatus(rawStep.status);
     if (!rawStatus) continue;
     const completedAt = finiteNumber(rawStep.completedAt);
     const status = rawStatus === "running" && completedAt !== null ? "completed" : rawStatus;
-    const rawProgress = isRecord(rawStep.progress) ? rawStep.progress : null;
+    const rawProgress = isRecord2(rawStep.progress) ? rawStep.progress : null;
     stepsById[stepId] = {
       stepId,
       label: optionalString(rawStep.label),
@@ -1210,6 +1294,23 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       progress: rawProgress ? normalizeStepProgress(rawProgress) : null
     };
   }
+  const rawDatasets = isRecord2(value.datasetsById) ? value.datasetsById : {};
+  const datasetsById = {};
+  for (const [datasetId, rawDataset] of Object.entries(rawDatasets)) {
+    if (!datasetId.trim() || !isRecord2(rawDataset)) continue;
+    const phase = rawDataset.phase === "available" || rawDataset.phase === "failed" ? rawDataset.phase : "registered";
+    datasetsById[datasetId] = {
+      datasetId,
+      path: optionalString(rawDataset.path) ?? `datasets.${datasetId}`,
+      tableNamespace: optionalString(rawDataset.tableNamespace) ?? datasetId,
+      phase,
+      persistedRows: Math.max(0, finiteNumber(rawDataset.persistedRows) ?? 0),
+      succeededRows: Math.max(0, finiteNumber(rawDataset.succeededRows) ?? 0),
+      failedRows: Math.max(0, finiteNumber(rawDataset.failedRows) ?? 0),
+      complete: rawDataset.complete === true,
+      updatedAt: finiteNumber(rawDataset.updatedAt) ?? 0
+    };
+  }
   const createdAt = finiteNumber(value.createdAt) ?? fallback.createdAt ?? null;
   const startedAt = finiteNumber(value.startedAt) ?? fallback.startedAt ?? null;
   const finishedAt = finiteNumber(value.finishedAt) ?? fallback.finishedAt ?? null;
@@ -1229,6 +1330,10 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
     durationMs: startedAt !== null && finishedAt !== null ? Math.max(0, finishedAt - startedAt) : finiteNumber(value.durationMs),
     orderedStepIds: orderedStepIds.filter((stepId) => stepsById[stepId]),
     stepsById,
+    orderedDatasetIds: (Array.isArray(value.orderedDatasetIds) ? value.orderedDatasetIds : Object.keys(datasetsById)).filter(
+      (datasetId) => typeof datasetId === "string" && Boolean(datasetsById[datasetId])
+    ),
+    datasetsById,
     logTail: logTail.slice(-LOG_TAIL_LIMIT),
     // Snapshots persisted before totalLogCount existed only know the retained
     // tail, so the best lower bound for the cumulative count is the tail size.
@@ -1323,18 +1428,18 @@ function normalizePlayRunLiveStatus(value) {
 function isTerminalPlayRunLiveStatus(status) {
   return isTerminalPlayRunLifecycleStatus(status);
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function finiteNumber2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function extractTerminalRunLogTail(result) {
-  if (!isRecord2(result) || !isRecord2(result._metadata)) {
+  if (!isRecord3(result) || !isRecord3(result._metadata)) {
     return null;
   }
   const runLogTail = result._metadata.runLogTail;
-  if (!isRecord2(runLogTail) || !Array.isArray(runLogTail.tail)) {
+  if (!isRecord3(runLogTail) || !Array.isArray(runLogTail.tail)) {
     return null;
   }
   const logTail = runLogTail.tail.filter(
@@ -1390,6 +1495,9 @@ function buildSnapshotFromLedger(snapshot) {
     ...snapshot.logsTruncated ? { logsTruncated: true } : {},
     activeArtifactTableNamespace: snapshot.activeArtifactTableNamespace ?? null,
     resultTableNamespace: snapshot.resultTableNamespace ?? null,
+    datasets: snapshot.orderedDatasetIds.map((datasetId) => snapshot.datasetsById[datasetId]).filter(
+      (dataset) => Boolean(dataset)
+    ),
     nodeStates,
     activeNodeId: snapshot.activeStepId ?? null,
     ...rowOutcomes ? { rowOutcomes } : {}
@@ -2066,8 +2174,9 @@ function resolveToolExecuteTimeoutMs(toolId) {
   const normalized = toolId.trim().toLowerCase();
   return normalized === "deeplineagent" || normalized === "deeplineagent_deeplineagent" || normalized === "ai_inference" || normalized === "deeplineagent_ai_inference" || normalized === "aiinference" ? DEEPLINEAGENT_EXECUTE_TIMEOUT_MS : void 0;
 }
+var RUNS_FAILED_LOG_LIMIT = 20;
 var RUN_LOGS_PAGE_LIMIT = 1e3;
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPrebuiltPlayDescription(play) {
@@ -2224,7 +2333,7 @@ function updatePlayLiveStatusState(state, event) {
   }
   const runId = typeof payload.runId === "string" && payload.runId ? payload.runId : isPlayRunPackage(payload) ? payload.run.id : state.runId;
   const status = normalizeLiveStatus(payload.status) ?? (isPlayRunPackage(payload) ? normalizeLiveStatus(payload.run.status) : null) ?? state.status;
-  const progressPayload = isRecord3(payload.progress) ? payload.progress : {};
+  const progressPayload = isRecord4(payload.progress) ? payload.progress : {};
   if (event.type === "play.run.final_status" && state.logs.length === 0 && state.lastLogSeq === 0) {
     const payloadLogs = readStringArray(payload.logs);
     const progressLogs = readStringArray(progressPayload.logs);
@@ -2339,9 +2448,9 @@ var DeeplineClient = class {
     return fields.length > 0 ? { fields } : schema;
   }
   schemaMetadata(schema, key) {
-    if (!isRecord3(schema)) return null;
+    if (!isRecord4(schema)) return null;
     const value = schema[key];
-    return isRecord3(value) ? value : null;
+    return isRecord4(value) ? value : null;
   }
   playRunCommand(play, options) {
     const target = play.reference || play.name;
@@ -2390,7 +2499,7 @@ var DeeplineClient = class {
       aliases,
       inputSchema: options?.compact ? this.compactSchema(play.inputSchema) : play.inputSchema ?? null,
       outputSchema: options?.compact ? this.compactSchema(play.outputSchema) : play.outputSchema ?? null,
-      staticPipeline: isRecord3(play.staticPipeline) ? play.staticPipeline : isRecord3(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord3(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
+      staticPipeline: isRecord4(play.staticPipeline) ? play.staticPipeline : isRecord4(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord4(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
       ...csvInput ? { csvInput } : {},
       ...rowOutputSchema ? { rowOutputSchema } : {},
       runCommand,
@@ -3324,7 +3433,46 @@ var DeeplineClient = class {
     const response = await this.http.get(
       `/api/v2/runs/${encodeURIComponent(runId)}${query}`
     );
-    return normalizePlayStatus(response);
+    const status = normalizePlayStatus(response);
+    if (options?.failedLogs !== true || status.status !== "failed") {
+      return status;
+    }
+    const requestedFailedLogLimit = typeof options.failedLogLimit === "number" && Number.isFinite(options.failedLogLimit) ? Math.max(1, Math.floor(options.failedLogLimit)) : RUNS_FAILED_LOG_LIMIT;
+    let failedLogs;
+    let failedLogsLoaded = true;
+    try {
+      failedLogs = await this.getRunLogs(runId, {
+        failed: true,
+        limit: Math.min(RUNS_FAILED_LOG_LIMIT, requestedFailedLogLimit)
+      });
+    } catch (error) {
+      failedLogsLoaded = false;
+      const retryCommand = `deepline runs get ${runId} --log-failed --json`;
+      const reason = error instanceof Error && error.message.trim() ? ` (${error.message.trim().slice(0, 500)})` : "";
+      failedLogs = {
+        runId,
+        totalCount: 0,
+        returnedCount: 0,
+        firstSequence: null,
+        lastSequence: null,
+        truncated: false,
+        hasMore: false,
+        entries: [],
+        view: "failed",
+        warning: `Failed logs could not be loaded${reason}. The run status and persisted datasets are still available.`,
+        next: { logs: retryCommand }
+      };
+    }
+    return {
+      ...status,
+      failedLogs: {
+        ...failedLogs,
+        view: "failed",
+        ...failedLogsLoaded ? {
+          association: failedLogs.association ?? "terminal_failure_window"
+        } : {}
+      }
+    };
   }
   /**
    * List play runs using the public runs resource model.
@@ -3475,6 +3623,7 @@ var DeeplineClient = class {
       onNotice: options?.onNotice,
       fallback: "none"
     })) {
+      options?.onEvent?.(event);
       const status = updatePlayLiveStatusState(state, event);
       if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
         continue;
@@ -3538,6 +3687,7 @@ var DeeplineClient = class {
           mode: "cli",
           signal: options?.signal
         })) {
+          options?.onEvent?.(event);
           sawEvent = true;
           const status = updatePlayLiveStatusState(state, event);
           if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
@@ -3587,6 +3737,37 @@ var DeeplineClient = class {
    * ```
    */
   async getRunLogs(runId, options) {
+    if (options?.all === true && options.failed === true) {
+      throw new DeeplineError(
+        "runs.logs cannot combine all and failed views.",
+        void 0,
+        "INVALID_RUN_LOG_VIEW"
+      );
+    }
+    if (options?.failed === true) {
+      const requestedLimit = typeof options.limit === "number" && Number.isFinite(options.limit) && options.limit > 0 ? Math.trunc(options.limit) : RUNS_FAILED_LOG_LIMIT;
+      const failedLimit = Math.min(RUNS_FAILED_LOG_LIMIT, requestedLimit);
+      const page = await this.http.get(
+        `/api/v2/runs/${encodeURIComponent(runId)}/logs?view=failed&limit=${failedLimit}`
+      );
+      return {
+        runId: page.runId,
+        totalCount: page.totalLogCount,
+        returnedCount: page.entries.length,
+        firstSequence: page.firstSeq,
+        lastSequence: page.lastSeq,
+        // The failed view is a complete designed window, not a pageable slice.
+        // `truncated` means retention loss here; association/warning explain it.
+        truncated: page.logsTruncated === true,
+        hasMore: false,
+        entries: page.entries.map((entry) => entry.line),
+        view: page.view ?? "failed",
+        association: page.association ?? "terminal_failure_window",
+        ...page.warning ? { warning: page.warning } : {},
+        ...page.next ? { next: page.next } : {},
+        ...page.logsTruncated ? { logsTruncated: true } : {}
+      };
+    }
     const limit = options?.all ? Number.MAX_SAFE_INTEGER : typeof options?.limit === "number" && Number.isFinite(options.limit) && options.limit > 0 ? Math.trunc(options.limit) : 200;
     const fetchPage = (afterSeq2, pageLimit) => this.http.get(
       `/api/v2/runs/${encodeURIComponent(runId)}/logs?afterSeq=${afterSeq2}&limit=${pageLimit}`
@@ -3620,6 +3801,7 @@ var DeeplineClient = class {
       truncated: entries.length < probe.totalLogCount,
       hasMore: lastSequence !== null && lastSequence < lastStoredSeq,
       entries: entries.map((entry) => entry.line),
+      view: options?.all ? "all" : "tail",
       ...probe.logsTruncated ? { logsTruncated: true } : {}
     };
   }
@@ -4415,16 +4597,33 @@ var DeferredPlayDataset = class {
   take(limit, options) {
     return this.slice(0, limit, options);
   }
-  async materialize(limit) {
+  async materialize(options) {
+    const scope = typeof options === "object" ? options.scope ?? "result" : "result";
+    const limit = typeof options === "number" ? options : options?.limit;
     const requestedLimit = limit !== void 0 ? Math.max(0, Math.floor(limit)) : void 0;
     const cap = resolveMaterializeLimitCap();
+    const materialize = scope === "full_persisted_dataset" ? this.resolvers.materializeFullPersistedDataset : this.resolvers.materialize;
+    if (!materialize) {
+      throw new Error(
+        'PlayDataset.materialize({ scope: "full_persisted_dataset" }) is only available for a persisted dataset returned by ctx.dataset(...).run().'
+      );
+    }
     if (requestedLimit !== void 0) {
       if (requestedLimit > cap) {
         throw new Error(
           `PlayDataset.materialize(${requestedLimit}) exceeds the hard limit of ${cap} rows. Return the dataset handle instead, or request a smaller bounded slice.`
         );
       }
-      return await this.resolvers.materialize(requestedLimit);
+      return await materialize(requestedLimit);
+    }
+    if (scope === "full_persisted_dataset") {
+      const rows = await materialize(cap + 1);
+      if (rows.length > cap) {
+        throw new Error(
+          `PlayDataset.materialize({ scope: "full_persisted_dataset" }) refuses to load more than ${cap} rows into memory. Pass an explicit bounded limit.`
+        );
+      }
+      return rows;
     }
     const count = await this.count();
     if (count > cap) {
@@ -4432,7 +4631,7 @@ var DeferredPlayDataset = class {
         `PlayDataset.materialize() refuses to load ${count} rows into memory. The hard limit is ${cap}. Return the dataset handle instead or call materialize(limit).`
       );
     }
-    return await this.resolvers.materialize();
+    return await materialize();
   }
   async *[Symbol.asyncIterator]() {
     for await (const row of this.resolvers.iterate()) {
@@ -4761,7 +4960,7 @@ var TARGET_FALLBACK_KEYS = {
   status: [/^email_status$/i, /^status$/i],
   email_status: [/^email_status$/i, /^status$/i]
 };
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function toV2RawToolOutputPath(path) {
@@ -4821,7 +5020,7 @@ function valuesAtSegments(current, segments, path = []) {
     if (!Array.isArray(current)) return [];
     return valuesAtSegments(current[segment], rest, [...path, segment]);
   }
-  if (!isRecord4(current)) return [];
+  if (!isRecord5(current)) return [];
   const directMatches = valuesAtSegments(current[segment], rest, [
     ...path,
     segment
@@ -4851,7 +5050,7 @@ function getValuesAtPath(root, path) {
   return valuesAtSegments(root, parsePath(path)).map((entry) => entry.value);
 }
 function toResultEnvelope(value) {
-  if (isRecord4(value) && "data" in value) {
+  if (isRecord5(value) && "data" in value) {
     const envelope = { data: value.data };
     if ("meta" in value) envelope.meta = value.meta;
     return envelope;
@@ -4904,7 +5103,7 @@ function getAtPath(root, path) {
       current = current[segment];
       continue;
     }
-    if (!isRecord4(current)) return void 0;
+    if (!isRecord5(current)) return void 0;
     current = current[segment];
   }
   return current;
@@ -4921,7 +5120,7 @@ function normalizeString(value) {
 }
 function normalizeRows(value) {
   if (!Array.isArray(value)) return null;
-  return value.map((entry) => isRecord4(entry) ? entry : { value: entry });
+  return value.map((entry) => isRecord5(entry) ? entry : { value: entry });
 }
 function findFirstTargetByPath(result, paths) {
   for (const path of paths ?? []) {
@@ -4980,7 +5179,7 @@ function findFirstTargetByKey(result, target, depth = 0, path = []) {
     }
     return null;
   }
-  if (!isRecord4(result)) return null;
+  if (!isRecord5(result)) return null;
   const patterns = TARGET_FALLBACK_KEYS[target] ?? [
     new RegExp(`^${target}$`, "i")
   ];
@@ -5040,7 +5239,7 @@ function normalizeJobChangeStatus(value) {
 function firstExperienceDate(value) {
   if (!Array.isArray(value)) return null;
   for (const entry of value) {
-    if (!isRecord4(entry)) continue;
+    if (!isRecord5(entry)) continue;
     const date = normalizeString(
       entry.start_date ?? entry.started_at ?? entry.startDate
     );
@@ -5049,10 +5248,10 @@ function firstExperienceDate(value) {
   return null;
 }
 function normalizeJobChange(value) {
-  const record = isRecord4(value) ? value : {};
-  const nested = isRecord4(record.job_change) ? record.job_change : record;
-  const output = isRecord4(nested.output) ? nested.output : nested;
-  const person = isRecord4(output.person) ? output.person : {};
+  const record = isRecord5(value) ? value : {};
+  const nested = isRecord5(record.job_change) ? record.job_change : record;
+  const output = isRecord5(nested.output) ? nested.output : nested;
+  const person = isRecord5(output.person) ? output.person : {};
   const status = normalizeJobChangeStatus(
     output.status ?? output.job_change_status ?? output.job_changed ?? output.changed
   );
@@ -5417,7 +5616,7 @@ function attachToolResultListDataset(result, input) {
     root = replaceAtPath(root, candidate, serialized.preview);
     break;
   }
-  if (isRecord4(root) && isRecord4(root.toolResponse) && Object.prototype.hasOwnProperty.call(root.toolResponse, "raw")) {
+  if (isRecord5(root) && isRecord5(root.toolResponse) && Object.prototype.hasOwnProperty.call(root.toolResponse, "raw")) {
     result.toolResponse.raw = root.toolResponse.raw;
     result.toolOutput.raw = root.toolResponse.raw;
   }
@@ -5435,7 +5634,7 @@ function replaceAtPath(root, path, replacement) {
       copy[segment] = replace(copy[segment], index + 1);
       return copy;
     }
-    if (!isRecord4(current)) return current;
+    if (!isRecord5(current)) return current;
     return {
       ...current,
       [segment]: replace(current[segment], index + 1)
@@ -5756,11 +5955,11 @@ var Deepline = class {
     return new DeeplineContext(options);
   }
 };
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function stringArrayRecord(value) {
-  if (!isRecord5(value)) return {};
+  if (!isRecord6(value)) return {};
   return Object.fromEntries(
     Object.entries(value).map(([key, paths]) => [
       key,
@@ -5772,7 +5971,7 @@ function stringArray(value) {
   return Array.isArray(value) ? value.map(String) : [];
 }
 function emailStatusExtractorConfig(value) {
-  if (!isRecord5(value)) return void 0;
+  if (!isRecord6(value)) return void 0;
   const readPaths = (key) => {
     const paths = stringArray(value[key]).map((path) => path.trim()).filter(Boolean);
     return paths.length > 0 ? paths : void 0;
@@ -5799,7 +5998,7 @@ function emailStatusExtractorConfig(value) {
     const paths = readPaths(key);
     if (paths) config[key] = paths;
   }
-  if (isRecord5(value.statusMap)) {
+  if (isRecord6(value.statusMap)) {
     config.statusMap = value.statusMap;
   }
   if (Array.isArray(value.rules)) {
@@ -5808,10 +6007,10 @@ function emailStatusExtractorConfig(value) {
   return config;
 }
 function extractorDescriptorRecord(value) {
-  if (!isRecord5(value)) return {};
+  if (!isRecord6(value)) return {};
   return Object.fromEntries(
     Object.entries(value).flatMap(([key, descriptor]) => {
-      if (!isRecord5(descriptor)) return [];
+      if (!isRecord6(descriptor)) return [];
       const paths = stringArray(descriptor.paths).map((path) => path.trim()).filter(Boolean);
       if (paths.length === 0) return [];
       const transforms = stringArray(descriptor.transforms).map((transform) => transform.trim()).filter(Boolean);
@@ -5833,7 +6032,7 @@ function extractorDescriptorRecord(value) {
 }
 function rowsFromUnknown(value) {
   if (!Array.isArray(value)) return [];
-  return value.map((row) => isRecord5(row) ? row : { value: row });
+  return value.map((row) => isRecord6(row) ? row : { value: row });
 }
 function finiteNonNegativeInteger(value) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
@@ -5855,8 +6054,8 @@ function stableHash(value) {
 }
 function attachSdkQueryResultDatasetResult(toolId, result, options) {
   if (!options || !isQueryResultDatasetTool(toolId)) return result;
-  const raw = isRecord5(result.toolResponse.raw) ? result.toolResponse.raw : null;
-  const dataset = isRecord5(raw?.dataset) ? raw.dataset : null;
+  const raw = isRecord6(result.toolResponse.raw) ? result.toolResponse.raw : null;
+  const dataset = isRecord6(raw?.dataset) ? raw.dataset : null;
   const totalRows = finiteNonNegativeInteger(dataset?.total_rows);
   const sql = typeof options.input.sql === "string" ? options.input.sql : typeof options.input.query === "string" ? options.input.query : typeof raw?.sql === "string" ? raw.sql : null;
   if (!dataset || totalRows === null || !sql) {
@@ -5886,7 +6085,7 @@ function attachSdkQueryResultDatasetResult(toolId, result, options) {
         } : {}
       }
     });
-    const pageRaw = isRecord5(response.toolResponse?.raw) ? response.toolResponse.raw : null;
+    const pageRaw = isRecord6(response.toolResponse?.raw) ? response.toolResponse.raw : null;
     return rowsFromUnknown(pageRaw?.rows);
   };
   const collectRows = async (limit) => {
@@ -5939,8 +6138,8 @@ function attachSdkQueryResultDatasetResult(toolId, result, options) {
 function toolExecutionEnvelopeToResult(fallbackToolId, response, options) {
   const raw = response.toolResponse?.raw ?? null;
   const meta = response.toolResponse?.meta;
-  const metadata = isRecord5(response._metadata) ? response._metadata.tool : null;
-  const toolMetadata = isRecord5(metadata) ? metadata : {};
+  const metadata = isRecord6(response._metadata) ? response._metadata.tool : null;
+  const toolMetadata = isRecord6(metadata) ? metadata : {};
   return attachSdkQueryResultDatasetResult(
     fallbackToolId,
     createToolExecuteResult({
@@ -5948,7 +6147,7 @@ function toolExecutionEnvelopeToResult(fallbackToolId, response, options) {
       jobId: typeof response.job_id === "string" ? response.job_id : void 0,
       result: {
         data: raw,
-        ...isRecord5(meta) ? { meta } : {}
+        ...isRecord6(meta) ? { meta } : {}
       },
       metadata: {
         toolId: typeof toolMetadata.toolId === "string" ? toolMetadata.toolId : fallbackToolId,
@@ -5964,7 +6163,7 @@ function toolExecutionEnvelopeToResult(fallbackToolId, response, options) {
         cached: false,
         source: "live"
       },
-      meta: isRecord5(response.meta) ? response.meta : void 0
+      meta: isRecord6(response.meta) ? response.meta : void 0
     }),
     options
   );