deepline 0.1.274 → 0.1.276

package/dist/index.js

@@ -438,7 +438,7 @@ var SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: "0.1.274",
+  version: "0.1.276",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -652,19 +652,19 @@ function isAbortLikeError(error) {
   const message = error.message.toLowerCase();
   return name === "aborterror" || message.includes("operation was aborted") || message === "aborted";
 }
-function mapNetworkError(baseUrl, error, targetLabel) {
+function mapNetworkError(baseUrl, error, targetLabel2) {
   const tagged = error;
   const timeoutMs = tagged?.[REQUEST_TIMEOUT_MARKER];
   if (typeof timeoutMs === "number") {
     return {
-      message: `Request to ${targetLabel} timed out after ${timeoutMs}ms while waiting for a response.`,
+      message: `Request to ${targetLabel2} timed out after ${timeoutMs}ms while waiting for a response.`,
       code: "NETWORK_TIMEOUT",
-      details: { timeoutMs, target: targetLabel }
+      details: { timeoutMs, target: targetLabel2 }
     };
   }
   if (tagged?.[REQUEST_ABORT_MARKER]) {
     return {
-      message: `Request to ${targetLabel} was aborted before it completed.`,
+      message: `Request to ${targetLabel2} was aborted before it completed.`,
       code: "NETWORK_ABORTED"
     };
   }
@@ -1325,9 +1325,277 @@ var RUNNER_POST_TERMINAL_DIAGNOSTIC_MAX_BYTES = 64 * 1024;
 // ../shared_libs/play-runtime/ledger-safe-payload.ts
 var ledgerIngressRedactor = createSecretRedactionContext();
 
+// ../shared_libs/play-runtime/activity-observation.ts
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isPlayActivityObservation(value) {
+  if (!isRecord(value) || value.schemaVersion !== 1 || typeof value.activityId !== "string" || !value.activityId.trim() || typeof value.observedAt !== "number" || !Number.isFinite(value.observedAt) || !isRecord(value.target) || !isRecord(value.state)) {
+    return false;
+  }
+  const targetKinds = /* @__PURE__ */ new Set([
+    "provider",
+    "dataset",
+    "lease",
+    "runner",
+    "step",
+    "capacity"
+  ]);
+  const stateKinds = /* @__PURE__ */ new Set([
+    "active",
+    "queued",
+    "waiting",
+    "retrying",
+    "scheduled",
+    "completed",
+    "failed"
+  ]);
+  return typeof value.target.kind === "string" && targetKinds.has(value.target.kind) && typeof value.state.kind === "string" && stateKinds.has(value.state.kind);
+}
+function derivePlayActivityVisibility(input) {
+  const { state } = input.observation;
+  if (state.kind === "failed") return "action";
+  if (state.kind === "waiting") {
+    return state.reason.kind === "external_event" ? "action" : "headline";
+  }
+  if (state.kind === "queued" || state.kind === "scheduled") return "headline";
+  if (state.kind === "retrying") {
+    return state.retryAt - input.now <= 3e4 ? "hidden" : "timeline";
+  }
+  if (state.kind === "active") return "headline";
+  return "timeline";
+}
+function targetLabel(target) {
+  switch (target.kind) {
+    case "provider":
+      return target.label ?? `${target.provider} ${target.operation}`;
+    case "dataset":
+      return target.label ?? `dataset ${target.tableNamespace}`;
+    case "lease":
+      return `${target.resourceKind} ${target.resourceLabel}`;
+    case "runner":
+      return target.label ?? `${target.backend} runner`;
+    case "step":
+      return target.label ?? target.stepId;
+    case "capacity":
+      return target.label ?? `${target.pool} capacity`;
+  }
+}
+function summarizePlayActivity(observation) {
+  const label = targetLabel(observation.target);
+  const { state } = observation;
+  switch (state.kind) {
+    case "active": {
+      const progress = state.progress;
+      const counts = typeof progress?.completed === "number" && typeof progress.total === "number" ? ` (${progress.completed}/${progress.total})` : "";
+      return `Active: ${label}${counts}.`;
+    }
+    case "queued":
+      return `Queued: waiting for ${label}.`;
+    case "waiting":
+      if (state.reason.kind === "external_event") {
+        const provider = state.reason.provider ? ` from ${state.reason.provider}` : "";
+        return `Blocked: waiting for an external event${provider}.`;
+      }
+      if (state.reason.kind === "dataset") {
+        return `Blocked: waiting for dataset ${state.reason.tableNamespace} to become ${state.reason.requiredPhase}.`;
+      }
+      if (state.reason.kind === "lease") {
+        return `Contended: waiting for ${state.reason.resourceKind} lease ${state.reason.resourceLabel}.`;
+      }
+      return `Paused: ${label}; the legacy producer did not report a typed reason.`;
+    case "retrying":
+      return `Delayed: ${label} will retry automatically.`;
+    case "scheduled":
+      return `Scheduled: ${label} will resume automatically.`;
+    case "completed":
+      return `Completed: ${label}.`;
+    case "failed":
+      return `Failed: ${label}.`;
+  }
+}
+function isTerminalActivityState(state) {
+  return state.kind === "completed" || state.kind === "failed";
+}
+function projection(observation, now, classified = true) {
+  return {
+    observation,
+    summary: summarizePlayActivity(observation),
+    visibility: derivePlayActivityVisibility({ observation, now }),
+    classified
+  };
+}
+function projectPlayRunActivity(input) {
+  const now = input.now ?? Date.now();
+  const observedAt = input.updatedAt ?? now;
+  const normalizedStatus = input.status.trim().toLowerCase();
+  if (normalizedStatus === "completed" || normalizedStatus === "failed" || normalizedStatus === "cancelled" || normalizedStatus === "terminated" || normalizedStatus === "timed_out") {
+    return null;
+  }
+  const explicit = [...input.explicit ?? []].filter((candidate) => !isTerminalActivityState(candidate.state)).sort((left, right) => right.observedAt - left.observedAt)[0];
+  if (explicit) return projection(explicit, now);
+  if (input.waitKind === "detached_runner") {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: "runner:managed",
+        target: {
+          kind: "runner",
+          backend: input.runtimeBackend ?? "managed",
+          label: "managed play runner"
+        },
+        state: { kind: "active" },
+        observedAt
+      },
+      now
+    );
+  }
+  if (input.waitKind === "sleep") {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: "run:sleep",
+        target: {
+          kind: "step",
+          stepId: input.activeNodeId ?? "run",
+          label: input.playName ?? "play"
+        },
+        state: {
+          kind: "scheduled",
+          reason: "sleep",
+          resumeAt: input.waitUntil ?? observedAt
+        },
+        observedAt
+      },
+      now
+    );
+  }
+  if (input.waitKind === "integration_event" || input.waitKind === "integration_event_batch") {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: `event:${input.activeNodeId ?? "run"}`,
+        stepId: input.activeNodeId ?? void 0,
+        target: {
+          kind: "step",
+          stepId: input.activeNodeId ?? "run",
+          label: input.playName ?? "play"
+        },
+        state: {
+          kind: "waiting",
+          reason: {
+            kind: "external_event",
+            eventKey: input.eventKey ?? void 0,
+            deadlineAt: input.waitUntil ?? void 0
+          }
+        },
+        observedAt
+      },
+      now
+    );
+  }
+  if (normalizedStatus === "waiting") {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: "run:legacy-wait",
+        target: {
+          kind: "step",
+          stepId: input.activeNodeId ?? "run",
+          label: input.playName ?? "play"
+        },
+        state: { kind: "waiting", reason: { kind: "unknown" } },
+        observedAt
+      },
+      now,
+      false
+    );
+  }
+  const pendingDataset = [...input.datasets ?? []].filter(
+    (dataset) => dataset.phase === "registered" || dataset.complete !== true && dataset.phase !== "failed"
+  ).sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
+  if (pendingDataset) {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: `dataset:${pendingDataset.datasetId ?? pendingDataset.tableNamespace}`,
+        target: {
+          kind: "dataset",
+          tableNamespace: pendingDataset.tableNamespace,
+          operation: "materializing"
+        },
+        state: {
+          kind: "active",
+          progress: {
+            completed: pendingDataset.persistedRows,
+            total: typeof pendingDataset.succeededRows === "number" || typeof pendingDataset.failedRows === "number" ? (pendingDataset.succeededRows ?? 0) + (pendingDataset.failedRows ?? 0) : void 0,
+            failed: pendingDataset.failedRows
+          }
+        },
+        observedAt: pendingDataset.updatedAt ?? observedAt
+      },
+      now
+    );
+  }
+  const activeStep = input.nodeStates?.find(
+    (candidate) => candidate.nodeId === input.activeNodeId
+  ) ?? input.nodeStates?.find((candidate) => candidate.status === "running") ?? null;
+  if (activeStep) {
+    const toolId = activeStep.nodeId.startsWith("tool:") ? activeStep.nodeId.split(":").at(-1)?.trim() || null : null;
+    const provider = toolId?.split(/[._]/)[0]?.trim() || null;
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: `step:${activeStep.nodeId}`,
+        stepId: activeStep.nodeId,
+        target: toolId && provider ? {
+          kind: "provider",
+          provider,
+          operation: toolId,
+          label: activeStep.label ?? toolId
+        } : {
+          kind: "step",
+          stepId: activeStep.nodeId,
+          label: activeStep.label
+        },
+        state: {
+          kind: "active",
+          progress: activeStep.progress ?? void 0
+        },
+        observedAt: activeStep.updatedAt ?? observedAt
+      },
+      now
+    );
+  }
+  if (normalizedStatus === "queued") {
+    return projection(
+      {
+        schemaVersion: 1,
+        activityId: "capacity:worker",
+        target: { kind: "capacity", pool: "worker" },
+        state: { kind: "queued", reason: "capacity" },
+        observedAt
+      },
+      now
+    );
+  }
+  const fallback = {
+    schemaVersion: 1,
+    activityId: "run:legacy",
+    target: {
+      kind: "step",
+      stepId: input.activeNodeId ?? "run",
+      label: input.playName ?? "play"
+    },
+    state: normalizedStatus === "waiting" ? { kind: "waiting", reason: { kind: "unknown" } } : { kind: "active" },
+    observedAt
+  };
+  return projection(fallback, now, normalizedStatus !== "waiting");
+}
+
 // ../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) {
@@ -1411,30 +1679,33 @@ function createEmptyPlayRunLedgerSnapshot(input) {
     stepsById: {},
     orderedDatasetIds: [],
     datasetsById: {},
+    orderedActivityIds: [],
+    activitiesById: {},
     logTail: [],
     totalLogCount: 0,
     logsTruncated: false,
     activeStepId: null,
+    activeActivityId: null,
     activeArtifactTableNamespace: null,
     resultTableNamespace: null
   };
 }
 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),
@@ -1450,10 +1721,10 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       progress: rawProgress ? normalizeStepProgress(rawProgress) : null
     };
   }
-  const rawDatasets = isRecord(value.datasetsById) ? value.datasetsById : {};
+  const rawDatasets = isRecord2(value.datasetsById) ? value.datasetsById : {};
   const datasetsById = {};
   for (const [datasetId, rawDataset] of Object.entries(rawDatasets)) {
-    if (!datasetId.trim() || !isRecord(rawDataset)) continue;
+    if (!datasetId.trim() || !isRecord2(rawDataset)) continue;
     const phase = rawDataset.phase === "available" || rawDataset.phase === "failed" ? rawDataset.phase : "registered";
     datasetsById[datasetId] = {
       datasetId,
@@ -1467,6 +1738,13 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       updatedAt: finiteNumber(rawDataset.updatedAt) ?? 0
     };
   }
+  const rawActivities = isRecord2(value.activitiesById) ? value.activitiesById : {};
+  const activitiesById = {};
+  for (const [activityId, rawActivity] of Object.entries(rawActivities)) {
+    if (activityId.trim() && isPlayActivityObservation(rawActivity) && rawActivity.activityId === activityId) {
+      activitiesById[activityId] = rawActivity;
+    }
+  }
   const createdAt = finiteNumber(value.createdAt) ?? fallback.createdAt ?? null;
   const startedAt = finiteNumber(value.startedAt) ?? fallback.startedAt ?? null;
   const finishedAt = finiteNumber(value.finishedAt) ?? fallback.finishedAt ?? null;
@@ -1490,6 +1768,10 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       (datasetId) => typeof datasetId === "string" && Boolean(datasetsById[datasetId])
     ),
     datasetsById,
+    orderedActivityIds: (Array.isArray(value.orderedActivityIds) ? value.orderedActivityIds : Object.keys(activitiesById)).filter(
+      (activityId) => typeof activityId === "string" && Boolean(activitiesById[activityId])
+    ),
+    activitiesById,
     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.
@@ -1499,6 +1781,7 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
     ),
     logsTruncated: value.logsTruncated === true,
     activeStepId: optionalNullableString(value.activeStepId),
+    activeActivityId: optionalNullableString(value.activeActivityId),
     activeArtifactTableNamespace: optionalNullableString(
       value.activeArtifactTableNamespace
     ),
@@ -1585,18 +1868,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(
@@ -1656,6 +1939,10 @@ function buildSnapshotFromLedger(snapshot) {
     datasets: snapshot.orderedDatasetIds.map((datasetId) => snapshot.datasetsById[datasetId]).filter(
       (dataset) => Boolean(dataset)
     ),
+    activities: snapshot.orderedActivityIds.map((activityId) => snapshot.activitiesById[activityId]).filter(
+      (activity) => Boolean(activity)
+    ),
+    activeActivity: snapshot.activeActivityId ? snapshot.activitiesById[snapshot.activeActivityId] ?? null : null,
     nodeStates,
     activeNodeId: snapshot.activeStepId ?? null,
     ...rowOutcomes ? { rowOutcomes } : {}
@@ -1672,14 +1959,29 @@ function buildPlayRunStatusSnapshot(input) {
     finishedAt: input.run.finishedAt ?? null
   });
   const terminalRunLogTail = extractTerminalRunLogTail(input.run.result);
-  if (terminalRunLogTail && terminalRunLogTail.totalLogCount > ledgerSnapshot.totalLogCount) {
-    return buildSnapshotFromLedger({
-      ...ledgerSnapshot,
-      logTail: terminalRunLogTail.logTail,
-      totalLogCount: terminalRunLogTail.totalLogCount
-    });
-  }
-  return buildSnapshotFromLedger(ledgerSnapshot);
+  const projectedSnapshot = terminalRunLogTail && terminalRunLogTail.totalLogCount > ledgerSnapshot.totalLogCount ? buildSnapshotFromLedger({
+    ...ledgerSnapshot,
+    logTail: terminalRunLogTail.logTail,
+    totalLogCount: terminalRunLogTail.totalLogCount
+  }) : buildSnapshotFromLedger(ledgerSnapshot);
+  const activity = projectPlayRunActivity({
+    runId: input.run.workflowId,
+    playName: input.run.name,
+    status: projectedSnapshot.status,
+    updatedAt: projectedSnapshot.updatedAt,
+    waitKind: input.run.waitKind ?? input.run.wait?.kind ?? null,
+    waitUntil: input.run.waitUntil,
+    eventKey: input.run.wait?.eventKey ?? null,
+    runtimeBackend: input.run.runtimeBackend,
+    activeNodeId: input.run.activeBoundaryId ?? projectedSnapshot.activeNodeId,
+    nodeStates: projectedSnapshot.nodeStates,
+    datasets: projectedSnapshot.datasets,
+    explicit: projectedSnapshot.activities
+  });
+  return {
+    ...projectedSnapshot,
+    activity
+  };
 }
 function makeRunStreamEvent(input) {
   return {
@@ -1900,7 +2202,8 @@ function diffPlayRunStreamEvents(input) {
         payload: {
           runId: snapshot.runId,
           status: snapshot.status,
-          updatedAt: snapshot.updatedAt
+          updatedAt: snapshot.updatedAt,
+          ...snapshot.activity ? { activity: snapshot.activity } : {}
         }
       })
     );
@@ -2420,7 +2723,7 @@ function resolveToolExecuteTimeoutMs(toolId, input) {
 }
 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) {
@@ -2577,7 +2880,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);
@@ -2711,9 +3014,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;
@@ -2762,7 +3065,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,
@@ -2840,6 +3143,14 @@ var DeeplineClient = class {
     );
     return res.tools;
   }
+  /** List discoverable providers without requiring a local plugin catalog. */
+  async listProviders(options) {
+    const suffix = options?.changed ? "?changed=true" : "";
+    const res = await this.http.get(
+      `/api/v2/tools/providers${suffix}`
+    );
+    return res.providers;
+  }
   /**
    * Search available tools using Deepline's ranked backend search.
    *
@@ -5434,7 +5745,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) {
@@ -5494,7 +5805,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
@@ -5524,7 +5835,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;
@@ -5577,7 +5888,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;
@@ -5594,7 +5905,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 ?? []) {
@@ -5653,7 +5964,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")
   ];
@@ -5713,7 +6024,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
     );
@@ -5722,10 +6033,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
   );
@@ -6090,7 +6401,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;
   }
@@ -6108,7 +6419,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)
@@ -6429,11 +6740,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,
@@ -6445,7 +6756,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;
@@ -6472,7 +6783,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)) {
@@ -6481,10 +6792,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);
@@ -6506,7 +6817,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) {
@@ -6528,8 +6839,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) {
@@ -6559,7 +6870,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) => {
@@ -6612,8 +6923,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({
@@ -6621,7 +6932,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,
@@ -6637,7 +6948,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
   );