deepline 0.1.301 → 0.1.303

package/dist/cli/index.js

@@ -191,20 +191,291 @@ var import_node_fs = require("fs");
 var import_node_os = require("os");
 var import_node_path = require("path");
 
-// src/errors.ts
-var DeeplineError = class extends Error {
+// ../shared_libs/tool-execution-error.ts
+var DEEPLINE_ERROR_BRAND = /* @__PURE__ */ Symbol.for("deepline.error.v1");
+var TOOL_EXECUTION_ERROR_BRAND = /* @__PURE__ */ Symbol.for(
+  "deepline.tool-execution-error.v1"
+);
+var PROVIDER_TRANSIENT_ERROR_BRAND = /* @__PURE__ */ Symbol.for(
+  "deepline.provider-transient-error.v1"
+);
+var LEGACY_TOOL_EXECUTION_ERROR_SCHEMA_VERSION = 0;
+var TOOL_EXECUTION_ERROR_SCHEMA_VERSION = 1;
+var TOOL_EXECUTION_ERROR_SCHEMA_HEADER = "x-deepline-tool-error-schema";
+var MAX_IDENTIFIER_LENGTH = 200;
+var MAX_CODE_LENGTH = 160;
+function nativeInstanceOf(constructor, value) {
+  return Reflect.apply(Function.prototype[Symbol.hasInstance], constructor, [
+    value
+  ]);
+}
+function hasBrand(value, brand) {
+  return typeof value === "object" && value !== null && value[brand] === true;
+}
+function applyBrand(value, brand) {
+  if (hasBrand(value, brand)) return;
+  Object.defineProperty(value, brand, {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: true
+  });
+}
+var DeeplineError = class _DeeplineError extends Error {
+  /** HTTP status when the failure crossed an HTTP boundary. */
+  statusCode;
+  /** Stable machine-readable error code when one exists. */
+  code;
+  /** Local diagnostic context; not a portable error contract. */
+  details;
+  /**
+   * Construct a Deepline error.
+   *
+   * SDK and runtime code construct these errors. Application and Play code
+   * normally catches the public subclasses instead.
+   *
+   * @param message Human-readable failure summary.
+   * @param statusCode HTTP status when one exists.
+   * @param code Stable machine-readable code when one exists.
+   * @param details Local diagnostic context; never a portable error contract.
+   */
   constructor(message, statusCode, code, details) {
     super(message);
+    this.name = "DeeplineError";
     this.statusCode = statusCode;
     this.code = code;
     this.details = details;
-    this.name = "DeeplineError";
+    applyBrand(this, DEEPLINE_ERROR_BRAND);
+  }
+  static [Symbol.hasInstance](value) {
+    if (this !== _DeeplineError) return nativeInstanceOf(this, value);
+    return hasBrand(value, DEEPLINE_ERROR_BRAND);
   }
-  statusCode;
-  code;
-  details;
 };
+var ToolExecutionError = class _ToolExecutionError extends DeeplineError {
+  /** Public tool id passed to `tools.execute`. */
+  toolId;
+  /** Provider responsible for the operation, or `null` when unattributed. */
+  provider;
+  /** Provider operation name, or `null` when unavailable. */
+  operation;
+  /** Boundary responsible for the failure. */
+  origin;
+  /** Stable reason family for policy and diagnostics. */
+  category;
+  /**
+   * Whether repeating the same semantic call is delivery-safe.
+   *
+   * This does not mean the error may be ignored. Waterfall fallthrough is
+   * represented by `ProviderTransientError`.
+   */
+  retryable;
+  /** Provider or Deepline request id, or `null` when unavailable. */
+  requestId;
+  /** Suggested same-call retry delay in milliseconds, or `null`. */
+  retryAfterMs;
+  /** Network failure kind, or `null` for non-network failures. */
+  networkKind;
+  /** Network boundary that failed, or `null` for non-network failures. */
+  networkScope;
+  /**
+   * Construct a structured tool error.
+   *
+   * Deepline constructs this from the versioned `tool_error` payload.
+   * Application and Play code should catch it rather than create it.
+   */
+  constructor(message, options) {
+    super(
+      message,
+      options.statusCode ?? void 0,
+      options.code ?? void 0,
+      options.details
+    );
+    this.name = "ToolExecutionError";
+    this.toolId = options.toolId;
+    this.provider = options.provider;
+    this.operation = options.operation;
+    this.origin = options.origin;
+    this.category = options.category;
+    this.retryable = options.retryable;
+    this.requestId = options.requestId;
+    this.retryAfterMs = options.retryAfterMs;
+    this.networkKind = options.networkKind;
+    this.networkScope = options.networkScope;
+    applyBrand(this, TOOL_EXECUTION_ERROR_BRAND);
+    if (isProviderTransientFailure(options)) {
+      applyBrand(this, PROVIDER_TRANSIENT_ERROR_BRAND);
+    }
+  }
+  static [Symbol.hasInstance](value) {
+    if (this !== _ToolExecutionError) return nativeInstanceOf(this, value);
+    return hasBrand(value, TOOL_EXECUTION_ERROR_BRAND);
+  }
+};
+function brandAsToolExecutionError(value) {
+  applyBrand(value, TOOL_EXECUTION_ERROR_BRAND);
+}
+function isProviderTransientFailure(input2) {
+  return input2.origin === "provider" && (input2.category === "rate_limit" || input2.category === "network" || input2.category === "upstream");
+}
+var ProviderTransientError = class _ProviderTransientError extends ToolExecutionError {
+  /** Provider attribution is guaranteed for this subtype. */
+  origin = "provider";
+  /** Constructed by Deepline when a provider-owned transient failure arrives. */
+  constructor(message, options) {
+    super(message, {
+      ...options,
+      origin: "provider",
+      category: options.category
+    });
+    this.name = "ProviderTransientError";
+    this.category = options.category;
+    applyBrand(this, PROVIDER_TRANSIENT_ERROR_BRAND);
+  }
+  static [Symbol.hasInstance](value) {
+    if (this !== _ProviderTransientError) return nativeInstanceOf(this, value);
+    return hasBrand(value, PROVIDER_TRANSIENT_ERROR_BRAND);
+  }
+};
+function brandAsProviderTransientError(value) {
+  applyBrand(value, PROVIDER_TRANSIENT_ERROR_BRAND);
+}
+function boundedString(value, maxLength = MAX_IDENTIFIER_LENGTH) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized ? normalized.slice(0, maxLength) : null;
+}
+function finiteNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && Number.isInteger(value) ? value : null;
+}
+function normalizeToolExecutionOrigin(value, input2) {
+  const normalized = boundedString(value)?.toLowerCase();
+  if (normalized === "caller") return "caller";
+  if (normalized === "provider" || normalized === "provider_network") {
+    return "provider";
+  }
+  if (normalized === "upstream" && boundedString(input2?.provider) && boundedString(input2?.operation)) {
+    return "provider";
+  }
+  if (normalized === "deepline" || normalized === "deepline_billing" || normalized === "deepline_rate_limit" || normalized === "internal" || normalized === "server") {
+    return "deepline";
+  }
+  if (normalized === "provider_account") return "provider";
+  return "unknown";
+}
+function normalizeToolExecutionCategory(value) {
+  switch (boundedString(value)?.toLowerCase()) {
+    case "validation":
+    case "authorization":
+    case "rate_limit":
+    case "network":
+    case "upstream":
+    case "billing":
+    case "conflict":
+    case "internal":
+      return boundedString(value).toLowerCase();
+    case "authentication":
+    case "provider_auth":
+    case "provider_account":
+      return "authentication";
+    case "execution":
+    case "parse":
+    case "stub":
+    case "internal_native_search_performance":
+      return "internal";
+    default:
+      return "unknown";
+  }
+}
+function normalizeNetworkKind(value) {
+  switch (boundedString(value)?.toLowerCase()) {
+    case "timeout":
+    case "dns":
+    case "connect":
+    case "reset":
+    case "unavailable":
+    case "unknown":
+      return boundedString(value).toLowerCase();
+    default:
+      return null;
+  }
+}
+function normalizeNetworkScope(value) {
+  switch (boundedString(value)?.toLowerCase()) {
+    case "client_to_deepline":
+    case "runtime_to_deepline":
+    case "deepline_to_provider":
+      return boundedString(value).toLowerCase();
+    default:
+      return null;
+  }
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeToolExecutionFailure(value) {
+  if (!isRecord(value) || value.schemaVersion !== TOOL_EXECUTION_ERROR_SCHEMA_VERSION) {
+    return null;
+  }
+  const toolId = boundedString(value.toolId);
+  if (!toolId) return null;
+  const provider = boundedString(value.provider);
+  const operation = boundedString(value.operation);
+  const origin = normalizeToolExecutionOrigin(value.origin, {
+    provider,
+    operation
+  });
+  const category = normalizeToolExecutionCategory(value.category);
+  const trustworthy = origin !== "unknown" && category !== "unknown" && typeof value.retryable === "boolean";
+  return {
+    schemaVersion: TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+    toolId,
+    provider,
+    operation,
+    code: boundedString(value.code, MAX_CODE_LENGTH),
+    origin,
+    category,
+    retryable: trustworthy ? value.retryable === true : false,
+    statusCode: finiteNonNegativeInteger(value.statusCode),
+    requestId: boundedString(value.requestId),
+    retryAfterMs: finiteNonNegativeInteger(value.retryAfterMs),
+    networkKind: normalizeNetworkKind(value.networkKind),
+    networkScope: normalizeNetworkScope(value.networkScope)
+  };
+}
+function serializeToolExecutionFailure(error) {
+  if (!(error instanceof ToolExecutionError)) return null;
+  return normalizeToolExecutionFailure({
+    schemaVersion: TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+    toolId: error.toolId,
+    provider: error.provider,
+    operation: error.operation,
+    code: error.code ?? null,
+    origin: error.origin,
+    category: error.category,
+    retryable: error.retryable,
+    statusCode: error.statusCode ?? null,
+    requestId: error.requestId,
+    retryAfterMs: error.retryAfterMs,
+    networkKind: error.networkKind,
+    networkScope: error.networkScope
+  });
+}
+function deserializeToolExecutionFailure(message, value, acceptedSchemaVersion) {
+  if (acceptedSchemaVersion === LEGACY_TOOL_EXECUTION_ERROR_SCHEMA_VERSION) {
+    return null;
+  }
+  const failure = normalizeToolExecutionFailure(value);
+  if (!failure) return null;
+  if (isProviderTransientFailure(failure)) {
+    return new ProviderTransientError(message, failure);
+  }
+  return new ToolExecutionError(message, failure);
+}
+
+// src/errors.ts
 var AuthError = class extends DeeplineError {
+  /** Constructed by the SDK when Deepline rejects the caller's credentials. */
   constructor(message = "Authentication failed. Check your DEEPLINE_API_KEY.") {
     super(message, 401, "AUTH_ERROR");
     this.name = "AuthError";
@@ -213,6 +484,7 @@ var AuthError = class extends DeeplineError {
 var RateLimitError = class extends DeeplineError {
   /** Milliseconds to wait before retrying, from the `Retry-After` response header. Defaults to 5000. */
   retryAfterMs;
+  /** Constructed by the SDK after exhausting HTTP-level rate-limit retries. */
   constructor(retryAfterMs = 5e3, message) {
     super(
       message ?? `Rate limited. Retry after ${retryAfterMs}ms.`,
@@ -223,7 +495,51 @@ var RateLimitError = class extends DeeplineError {
     this.retryAfterMs = retryAfterMs;
   }
 };
+var ToolRateLimitError = class extends RateLimitError {
+  /** Public tool id passed to `tools.execute`. */
+  toolId;
+  /** Provider responsible for the operation, or `null`. */
+  provider;
+  /** Provider operation name, or `null`. */
+  operation;
+  /** Stable machine-readable failure code when one exists. */
+  code;
+  /** Boundary responsible for the failure. */
+  origin;
+  /** Stable reason family for policy and diagnostics. */
+  category;
+  /** Whether repeating the same semantic call is delivery-safe. */
+  retryable;
+  /** Provider or Deepline request id, or `null`. */
+  requestId;
+  /** Network failure kind, or `null` for non-network failures. */
+  networkKind;
+  /** Network boundary that failed, or `null` for non-network failures. */
+  networkScope;
+  /** Constructed by the SDK after a structured tool HTTP 429. */
+  constructor(message, options) {
+    super(options.retryAfterMs ?? 5e3, message);
+    this.name = "ToolRateLimitError";
+    this.statusCode = options.statusCode ?? 429;
+    this.code = options.code ?? void 0;
+    this.toolId = options.toolId;
+    this.provider = options.provider;
+    this.operation = options.operation;
+    this.origin = options.origin;
+    this.category = options.category;
+    this.retryable = options.retryable;
+    this.requestId = options.requestId;
+    this.networkKind = options.networkKind;
+    this.networkScope = options.networkScope;
+    this.details = options.details;
+    brandAsToolExecutionError(this);
+    if (isProviderTransientFailure(this)) {
+      brandAsProviderTransientError(this);
+    }
+  }
+};
 var ConfigError = class extends DeeplineError {
+  /** Construct a local SDK configuration failure. */
   constructor(message) {
     super(message, void 0, "CONFIG_ERROR");
     this.name = "ConfigError";
@@ -679,6 +995,9 @@ var import_node_fs2 = require("fs");
 var import_node_os3 = require("os");
 var import_node_path2 = require("path");
 
+// ../shared_libs/plays/artifact-contract-version.ts
+var CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION = 2;
+
 // src/release.ts
 var SDK_RELEASE = {
   // 0.1.94 is claimed by PR #1527 — this watch-render fix ships as 0.1.95.
@@ -718,7 +1037,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.301",
+  version: "0.1.303",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -734,8 +1053,8 @@ var SDK_RELEASE = {
     },
     playArtifact: {
       name: "play-artifact-runtime",
-      currentVersion: 2,
-      supportedVersions: [1, 2]
+      currentVersion: CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION,
+      supportedVersions: [1, CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION]
     },
     release: {
       name: "production-sdk-release",
@@ -967,6 +1286,9 @@ function providerLabelFromToolId(toolId) {
   const provider = normalized.split(/[_:./-]+/)[0];
   return provider || normalized || "provider";
 }
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 var HttpClient = class {
   constructor(config) {
     this.config = config;
@@ -1102,6 +1424,29 @@ var HttpClient = class {
             signal: controller.signal
           });
           clearTimeout(timeoutId);
+          const body = await response.text();
+          const parsed = parseResponseBody(body);
+          const structuredToolError = options?.toolId && !response.ok ? deserializeToolExecutionFailure(
+            apiErrorMessage(parsed, response.status),
+            isRecord2(parsed) ? parsed.tool_error : null,
+            TOOL_EXECUTION_ERROR_SCHEMA_VERSION
+          ) : null;
+          if (structuredToolError) {
+            if (response.status === 429) {
+              const retryAfter = parseRetryAfter(response);
+              const failure = serializeToolExecutionFailure(structuredToolError);
+              lastError = failure === null ? structuredToolError : new ToolRateLimitError(structuredToolError.message, {
+                ...failure,
+                retryAfterMs: failure.retryAfterMs ?? Math.max(0, retryAfter)
+              });
+              if (attempt < maxRetries) {
+                retryAfterDelayMs = retryAfter;
+                break;
+              }
+              throw lastError;
+            }
+            throw structuredToolError;
+          }
           if (response.status === 429) {
             const retryAfter = parseRetryAfter(response);
             lastError = new RateLimitError(retryAfter);
@@ -1111,8 +1456,6 @@ var HttpClient = class {
             }
             throw lastError;
           }
-          const body = await response.text();
-          const parsed = parseResponseBody(body);
           if (response.status === 401 && !isProviderOriginatedHttpError(parsed) || response.status === 403 && !options?.forbiddenAsApiError) {
             throw new AuthError();
           }
@@ -1177,6 +1520,29 @@ var HttpClient = class {
       lastError,
       describeRequestTarget(path)
     );
+    if (options?.toolId) {
+      const code = mappedNetworkError.code;
+      throw new ToolExecutionError(
+        withCoworkNetworkHint(mappedNetworkError.message),
+        {
+          toolId: options.toolId,
+          provider: providerLabelFromToolId(options.toolId),
+          operation: options.toolId,
+          code,
+          origin: "deepline",
+          category: "network",
+          // A direct client timeout has ambiguous delivery. Fail closed unless
+          // the server returns the authoritative action delivery contract.
+          retryable: false,
+          statusCode: null,
+          requestId: null,
+          retryAfterMs: null,
+          networkKind: code === "NETWORK_TIMEOUT" ? "timeout" : code === "NETWORK_ABORTED" ? "unknown" : "unavailable",
+          networkScope: "client_to_deepline",
+          details: mappedNetworkError.details
+        }
+      );
+    }
     throw new DeeplineError(
       withCoworkNetworkHint(mappedNetworkError.message),
       void 0,
@@ -1618,11 +1984,11 @@ var RUNNER_POST_TERMINAL_DIAGNOSTIC_MAX_BYTES = 64 * 1024;
 var ledgerIngressRedactor = createSecretRedactionContext();
 
 // ../shared_libs/play-runtime/activity-observation.ts
-function isRecord(value) {
+function isRecord3(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)) {
+  if (!isRecord3(value) || value.schemaVersion !== 1 || typeof value.activityId !== "string" || !value.activityId.trim() || typeof value.observedAt !== "number" || !Number.isFinite(value.observedAt) || !isRecord3(value.target) || !isRecord3(value.state)) {
     return false;
   }
   const targetKinds = /* @__PURE__ */ new Set([
@@ -1887,7 +2253,7 @@ function projectPlayRunActivity(input2) {
 
 // ../shared_libs/play-runtime/run-ledger.ts
 var LOG_TAIL_LIMIT = 100;
-function isRecord2(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function finiteNumber(value) {
@@ -1983,21 +2349,21 @@ function createEmptyPlayRunLedgerSnapshot(input2) {
   };
 }
 function normalizePlayRunLedgerSnapshot(value, fallback) {
-  if (!isRecord2(value)) {
+  if (!isRecord4(value)) {
     return createEmptyPlayRunLedgerSnapshot(fallback);
   }
   const orderedStepIds = Array.isArray(value.orderedStepIds) ? value.orderedStepIds.filter(
     (entry) => typeof entry === "string" && Boolean(entry.trim())
   ) : [];
-  const rawSteps = isRecord2(value.stepsById) ? value.stepsById : {};
+  const rawSteps = isRecord4(value.stepsById) ? value.stepsById : {};
   const stepsById = {};
   for (const [stepId, rawStep] of Object.entries(rawSteps)) {
-    if (!stepId.trim() || !isRecord2(rawStep)) continue;
+    if (!stepId.trim() || !isRecord4(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 = isRecord2(rawStep.progress) ? rawStep.progress : null;
+    const rawProgress = isRecord4(rawStep.progress) ? rawStep.progress : null;
     stepsById[stepId] = {
       stepId,
       label: optionalString(rawStep.label),
@@ -2013,10 +2379,10 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       progress: rawProgress ? normalizeStepProgress(rawProgress) : null
     };
   }
-  const rawDatasets = isRecord2(value.datasetsById) ? value.datasetsById : {};
+  const rawDatasets = isRecord4(value.datasetsById) ? value.datasetsById : {};
   const datasetsById = {};
   for (const [datasetId, rawDataset] of Object.entries(rawDatasets)) {
-    if (!datasetId.trim() || !isRecord2(rawDataset)) continue;
+    if (!datasetId.trim() || !isRecord4(rawDataset)) continue;
     const phase = rawDataset.phase === "available" || rawDataset.phase === "failed" ? rawDataset.phase : "registered";
     datasetsById[datasetId] = {
       datasetId,
@@ -2030,7 +2396,7 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       updatedAt: finiteNumber(rawDataset.updatedAt) ?? 0
     };
   }
-  const rawActivities = isRecord2(value.activitiesById) ? value.activitiesById : {};
+  const rawActivities = isRecord4(value.activitiesById) ? value.activitiesById : {};
   const activitiesById = {};
   for (const [activityId, rawActivity] of Object.entries(rawActivities)) {
     if (activityId.trim() && isPlayActivityObservation(rawActivity) && rawActivity.activityId === activityId) {
@@ -2179,18 +2545,18 @@ function normalizePlayRunLiveStatus(value) {
 function isTerminalPlayRunLiveStatus(status) {
   return isTerminalPlayRunLifecycleStatus(status);
 }
-function isRecord3(value) {
+function isRecord5(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 (!isRecord3(result) || !isRecord3(result._metadata)) {
+  if (!isRecord5(result) || !isRecord5(result._metadata)) {
     return null;
   }
   const runLogTail = result._metadata.runLogTail;
-  if (!isRecord3(runLogTail) || !Array.isArray(runLogTail.tail)) {
+  if (!isRecord5(runLogTail) || !Array.isArray(runLogTail.tail)) {
     return null;
   }
   const logTail = runLogTail.tail.filter(
@@ -3084,7 +3450,7 @@ function resolveToolExecuteTimeoutMs(toolId, input2) {
 }
 var RUNS_FAILED_LOG_LIMIT = 20;
 var RUN_LOGS_PAGE_LIMIT = 1e3;
-function isRecord4(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPrebuiltPlayDescription(play) {
@@ -3247,7 +3613,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 = isRecord4(payload.progress) ? payload.progress : {};
+  const progressPayload = isRecord6(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);
@@ -3381,9 +3747,9 @@ var DeeplineClient = class {
     return fields.length > 0 ? { fields } : schema;
   }
   schemaMetadata(schema, key) {
-    if (!isRecord4(schema)) return null;
+    if (!isRecord6(schema)) return null;
     const value = schema[key];
-    return isRecord4(value) ? value : null;
+    return isRecord6(value) ? value : null;
   }
   playRunCommand(play, options) {
     const target = play.reference || play.name;
@@ -3432,7 +3798,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: isRecord4(play.staticPipeline) ? play.staticPipeline : isRecord4(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord4(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
+      staticPipeline: isRecord6(play.staticPipeline) ? play.staticPipeline : isRecord6(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord6(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
       ...csvInput ? { csvInput } : {},
       ...rowOutputSchema ? { rowOutputSchema } : {},
       runCommand: runCommand2,
@@ -3603,6 +3969,9 @@ var DeeplineClient = class {
   async executeTool(toolId, input2, options) {
     const headers = {
       [EXECUTE_RESPONSE_CONTRACT_HEADER]: V2_EXECUTE_RESPONSE_CONTRACT,
+      [TOOL_EXECUTION_ERROR_SCHEMA_HEADER]: String(
+        TOOL_EXECUTION_ERROR_SCHEMA_VERSION
+      ),
       ...options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : {},
       [EXECUTE_RESPONSE_INTENT_HEADER]: options?.responseIntent ?? "raw"
     };
@@ -3617,7 +3986,8 @@ var DeeplineClient = class {
         forbiddenAsApiError: true,
         timeout: options?.timeout ?? resolveToolExecuteTimeoutMs(toolId, input2),
         maxRetries: options?.maxRetries ?? 0,
-        exactUrlOnly: true
+        exactUrlOnly: true,
+        toolId
       }
     );
   }
@@ -8278,14 +8648,14 @@ function sanitizeCsvProjectionInfo(input2) {
   const rows = input2.rows.map(stripCsvProjectionFields);
   return { rows, columns };
 }
-function isRecord5(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSerializedDataset(value) {
-  return isRecord5(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
+  return isRecord7(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
 }
 function isPackagedDatasetOutput(value) {
-  return isRecord5(value) && value.kind === "dataset" && isRecord5(value.preview) && Array.isArray(value.preview.rows);
+  return isRecord7(value) && value.kind === "dataset" && isRecord7(value.preview) && Array.isArray(value.preview.rows);
 }
 function pathParts(path) {
   return path.split(".").map((part) => part.trim()).filter(Boolean);
@@ -8293,7 +8663,7 @@ function pathParts(path) {
 function valueAtPath(root, path) {
   let cursor = root;
   for (const part of pathParts(path)) {
-    if (!isRecord5(cursor)) {
+    if (!isRecord7(cursor)) {
       return void 0;
     }
     cursor = cursor[part];
@@ -8301,17 +8671,17 @@ function valueAtPath(root, path) {
   return cursor;
 }
 function totalRowsForDataset(result, datasetPath) {
-  const metadata = isRecord5(result._metadata) ? result._metadata : null;
+  const metadata = isRecord7(result._metadata) ? result._metadata : null;
   const parentPath = datasetPath.split(".").slice(0, -1).join(".");
   const parent = parentPath ? valueAtPath({ result }, parentPath) : result;
-  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord5(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
+  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord7(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
 }
 function rowArray(value) {
   if (!Array.isArray(value)) {
     return null;
   }
   const rows = value.filter(
-    (row) => isRecord5(row)
+    (row) => isRecord7(row)
   );
   return rows.length === value.length ? rows : null;
 }
@@ -8335,7 +8705,7 @@ function inferColumns(rows) {
   return columns;
 }
 function columnsFromDatasetSummary(summary) {
-  if (!isRecord5(summary) || !isRecord5(summary.columnStats)) {
+  if (!isRecord7(summary) || !isRecord7(summary.columnStats)) {
     return [];
   }
   return Object.keys(summary.columnStats).filter((column) => column);
@@ -8383,7 +8753,7 @@ function canonicalRowsInfoFromCandidate(input2) {
       datasetId: typeof candidate.value.datasetId === "string" ? candidate.value.datasetId : null,
       tableNamespace: typeof candidate.value.tableNamespace === "string" ? candidate.value.tableNamespace : null,
       ...candidate.value.recovered === true ? { recovered: true } : {},
-      ...isRecord5(candidate.value.exportUnavailable) && (candidate.value.exportUnavailable.reason === "empty_dataset" || candidate.value.exportUnavailable.reason === "shared_table_namespace") ? {
+      ...isRecord7(candidate.value.exportUnavailable) && (candidate.value.exportUnavailable.reason === "empty_dataset" || candidate.value.exportUnavailable.reason === "shared_table_namespace") ? {
         exportUnavailableReason: candidate.value.exportUnavailable.reason,
         ...typeof candidate.value.exportUnavailable.message === "string" ? {
           exportUnavailableMessage: candidate.value.exportUnavailable.message
@@ -8431,7 +8801,7 @@ function collectDatasetCandidates(input2) {
     });
     return;
   }
-  if (!isRecord5(input2.value)) {
+  if (!isRecord7(input2.value)) {
     return;
   }
   for (const [key, child] of Object.entries(input2.value)) {
@@ -8448,12 +8818,12 @@ function collectDatasetCandidates(input2) {
   }
 }
 function collectCanonicalRowsInfos(statusOrResult) {
-  const root = isRecord5(statusOrResult) ? statusOrResult : null;
-  const result = isRecord5(root?.result) ? root.result : root;
+  const root = isRecord7(statusOrResult) ? statusOrResult : null;
+  const result = isRecord7(root?.result) ? root.result : root;
   if (!result) {
     return [];
   }
-  const metadata = isRecord5(result._metadata) ? result._metadata : null;
+  const metadata = isRecord7(result._metadata) ? result._metadata : null;
   const totalFromMetadata = metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count;
   const candidates = [
     {
@@ -8477,8 +8847,8 @@ function collectCanonicalRowsInfos(statusOrResult) {
       total: totalFromMetadata ?? result.totalRows ?? result.rowCount ?? result.count
     }
   ];
-  if (isRecord5(result.output)) {
-    const outputMetadata = isRecord5(result.output._metadata) ? result.output._metadata : null;
+  if (isRecord7(result.output)) {
+    const outputMetadata = isRecord7(result.output._metadata) ? result.output._metadata : null;
     const outputTotalFromMetadata = outputMetadata?.totalRows ?? outputMetadata?.rowCount ?? outputMetadata?.count;
     candidates.push(
       {
@@ -8505,14 +8875,14 @@ function collectCanonicalRowsInfos(statusOrResult) {
   }
   if (Array.isArray(result.steps)) {
     result.steps.forEach((step, index) => {
-      if (!isRecord5(step) || !isRecord5(step.output)) {
+      if (!isRecord7(step) || !isRecord7(step.output)) {
         return;
       }
       const source = typeof step.output.path === "string" ? step.output.path : typeof step.id === "string" ? `steps.${step.id}.output` : `steps.${index}.output`;
       candidates.push({
         source,
         value: step.output,
-        total: step.output.rowCount ?? (isRecord5(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord5(step.progress) ? step.progress.total : void 0)
+        total: step.output.rowCount ?? (isRecord7(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord7(step.progress) ? step.progress.total : void 0)
       });
     });
   }
@@ -8540,15 +8910,15 @@ function collectCanonicalRowsInfos(statusOrResult) {
   return infos;
 }
 function collectPackagedDatasetCandidates(statusOrResult) {
-  const root = isRecord5(statusOrResult) ? statusOrResult : null;
+  const root = isRecord7(statusOrResult) ? statusOrResult : null;
   if (!root) {
     return [];
   }
-  const pkg = isRecord5(root.package) ? root.package : root;
+  const pkg = isRecord7(root.package) ? root.package : root;
   const datasets = Array.isArray(pkg.datasets) ? pkg.datasets : [];
   const candidates = [];
   for (const output2 of datasets) {
-    if (!isRecord5(output2) || !isPackagedDatasetOutput(output2)) {
+    if (!isRecord7(output2) || !isPackagedDatasetOutput(output2)) {
       continue;
     }
     const source = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : null;
@@ -8558,18 +8928,18 @@ function collectPackagedDatasetCandidates(statusOrResult) {
     candidates.push({
       source,
       value: output2,
-      total: output2.rowCount ?? (isRecord5(output2.preview) ? output2.preview.totalRows : void 0)
+      total: output2.rowCount ?? (isRecord7(output2.preview) ? output2.preview.totalRows : void 0)
     });
   }
   return candidates;
 }
 function collectPackagedStepDatasetCandidates(statusOrResult) {
-  const root = isRecord5(statusOrResult) ? statusOrResult : null;
+  const root = isRecord7(statusOrResult) ? statusOrResult : null;
   if (!root) return [];
-  const pkg = isRecord5(root.package) ? root.package : root;
+  const pkg = isRecord7(root.package) ? root.package : root;
   const steps = Array.isArray(pkg.steps) ? pkg.steps : [];
   return steps.flatMap((step) => {
-    if (!isRecord5(step) || !isPackagedDatasetOutput(step.output)) return [];
+    if (!isRecord7(step) || !isPackagedDatasetOutput(step.output)) return [];
     const source = typeof step.output.path === "string" && step.output.path.trim() ? step.output.path.trim() : null;
     return source ? [
       {
@@ -8581,8 +8951,8 @@ function collectPackagedStepDatasetCandidates(statusOrResult) {
   });
 }
 function collectSerializedDatasetRowsInfos(statusOrResult) {
-  const root = isRecord5(statusOrResult) ? statusOrResult : null;
-  const result = isRecord5(root?.result) ? root.result : root;
+  const root = isRecord7(statusOrResult) ? statusOrResult : null;
+  const result = isRecord7(root?.result) ? root.result : root;
   const candidates = [];
   if (result) {
     collectDatasetCandidates({
@@ -8590,7 +8960,7 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
       path: "result",
       output: candidates
     });
-    if (isRecord5(result.output)) {
+    if (isRecord7(result.output)) {
       collectDatasetCandidates({
         value: result.output,
         path: "result",
@@ -8668,13 +9038,13 @@ function summarizeSampleValue(value, depth = 0) {
   if (typeof parsed === "number" || typeof parsed === "boolean") return parsed;
   if (depth >= 3) {
     if (Array.isArray(parsed)) return [];
-    if (isRecord5(parsed)) return {};
+    if (isRecord7(parsed)) return {};
     return compactScalar(parsed);
   }
   if (Array.isArray(parsed)) {
     return parsed.slice(0, 3).map((item) => summarizeSampleValue(item, depth + 1));
   }
-  if (isRecord5(parsed)) {
+  if (isRecord7(parsed)) {
     const out = {};
     for (const [key, nested] of Object.entries(parsed)) {
       if (["__dl", "meta", "metadata"].includes(key)) {
@@ -8705,7 +9075,7 @@ function compactCell(value) {
     }
     return `[${parsed.length} items]`;
   }
-  if (isRecord5(parsed)) {
+  if (isRecord7(parsed)) {
     for (const key of ["matched_result", "output"]) {
       if (parsed[key] !== null && parsed[key] !== void 0 && parsed[key] !== "") {
         return compactCell(parsed[key]);
@@ -9770,17 +10140,17 @@ function parsePositiveInteger2(value, flagName) {
   }
   return parsed;
 }
-function isRecord6(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringValue(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function extractionEntries(value) {
-  if (Array.isArray(value)) return value.filter(isRecord6);
-  if (!isRecord6(value)) return [];
+  if (Array.isArray(value)) return value.filter(isRecord8);
+  if (!isRecord8(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord6(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord8(entry) ? { name, ...entry } : { name }
   );
 }
 var PlayBootstrapError = class extends Error {
@@ -10342,7 +10712,7 @@ function readCsvSampleRows(sample) {
     relax_column_count: true,
     trim: true
   });
-  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord6) : [];
+  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord8) : [];
 }
 function readSourceCsvColumnSpecs(csvPath) {
   const sample = readCsvSample(csvPath);
@@ -10375,16 +10745,16 @@ function packagedCsvPathForPlay(csvPath) {
   return portablePath.startsWith(".") ? portablePath : `./${portablePath}`;
 }
 function getterNamesFromTool(tool, kind) {
-  const usageGuidance = isRecord6(tool?.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord6(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord6(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const usageGuidance = isRecord8(tool?.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord8(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord8(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
   const key = kind === "list" ? "extractedLists" : "extractedValues";
   const snakeKey = kind === "list" ? "extracted_lists" : "extracted_values";
   return extractionEntries(resultGuidance[key] ?? resultGuidance[snakeKey]).map((entry) => stringValue(entry.name)).filter(Boolean);
 }
 function targetGettersFromTool(tool) {
-  const record = isRecord6(tool) ? tool : {};
+  const record = isRecord8(tool) ? tool : {};
   const raw = record.targetGetters ?? record.target_getters;
-  if (!isRecord6(raw)) return {};
+  if (!isRecord8(raw)) return {};
   const entries = [];
   for (const [target, value] of Object.entries(raw)) {
     const paths = Array.isArray(value) ? value.map((path) => typeof path === "string" ? path.trim() : "").filter(Boolean) : [];
@@ -10405,10 +10775,10 @@ function listRowCandidateKeysFromTool(tool) {
   return [...keys].sort();
 }
 function inputPropertyNames(schema) {
-  if (!isRecord6(schema)) return [];
-  if (isRecord6(schema.properties)) return Object.keys(schema.properties);
+  if (!isRecord8(schema)) return [];
+  if (isRecord8(schema.properties)) return Object.keys(schema.properties);
   if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord6).map((field) => stringValue(field.name)).filter(Boolean);
+    return schema.fields.filter(isRecord8).map((field) => stringValue(field.name)).filter(Boolean);
   }
   return [];
 }
@@ -10422,7 +10792,7 @@ function schemaFieldDetails(schema) {
   return { required, optional };
 }
 function jsonSchemaTypeExpression(schema) {
-  if (!isRecord6(schema)) return "unknown";
+  if (!isRecord8(schema)) return "unknown";
   const type = schema.type;
   if (Array.isArray(type)) {
     return type.map((entry) => jsonSchemaTypeExpression({ ...schema, type: entry })).join(" | ");
@@ -10452,7 +10822,7 @@ function jsonSchemaTypeExpression(schema) {
   }
 }
 function objectPropertySchema(schema, property) {
-  return isRecord6(schema) && isRecord6(schema.properties) ? schema.properties[property] : null;
+  return isRecord8(schema) && isRecord8(schema.properties) ? schema.properties[property] : null;
 }
 function playOutputHasField(schema, field) {
   return objectPropertySchema(schema, field) != null;
@@ -10628,14 +10998,14 @@ ${indent2.slice(2)}}`;
 }
 function requiredPlayInputFields(play) {
   const schema = play?.inputSchema;
-  if (!isRecord6(schema)) return [];
+  if (!isRecord8(schema)) return [];
   if (Array.isArray(schema.required)) {
     return schema.required.filter(
       (value) => typeof value === "string"
     );
   }
   if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord6).filter(
+    return schema.fields.filter(isRecord8).filter(
       (field) => field.required === true && typeof field.name === "string"
     ).map((field) => String(field.name));
   }
@@ -10816,7 +11186,7 @@ function validateBootstrapRoutes(input2) {
   }
 }
 function staticPipelineSubsteps(pipeline) {
-  if (!isRecord6(pipeline)) return [];
+  if (!isRecord8(pipeline)) return [];
   return [
     ...extractionEntries(pipeline.stages),
     ...extractionEntries(pipeline.substeps)
@@ -10824,7 +11194,7 @@ function staticPipelineSubsteps(pipeline) {
 }
 function playUsesMapBackedRuntime(play) {
   const pipeline = play?.staticPipeline;
-  if (!isRecord6(pipeline)) return false;
+  if (!isRecord8(pipeline)) return false;
   if (stringValue(pipeline.tableNamespace)) return true;
   return staticPipelineSubsteps(pipeline).some((substep) => {
     if (stringValue(substep.type) === "map") return true;
@@ -10833,7 +11203,7 @@ function playUsesMapBackedRuntime(play) {
       aliases: [],
       runCommand: "",
       examples: [],
-      staticPipeline: isRecord6(substep.pipeline) ? substep.pipeline : null
+      staticPipeline: isRecord8(substep.pipeline) ? substep.pipeline : null
     });
   });
 }
@@ -15571,7 +15941,7 @@ function extractPlayValidationErrors(value) {
   if (value instanceof DeeplineError) {
     return extractPlayValidationErrors(value.details);
   }
-  if (!isRecord7(value)) {
+  if (!isRecord9(value)) {
     return [];
   }
   const directErrors = stringArrayField(value, "errors");
@@ -16011,7 +16381,7 @@ function shouldUseLocalOnlyPlayCheck() {
   const value = process.env.DEEPLINE_PLAY_CHECK_LOCAL_ONLY?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
-function isRecord7(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringValue2(value) {
@@ -16021,14 +16391,14 @@ function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
 function extractionEntries2(value) {
-  if (Array.isArray(value)) return value.filter(isRecord7);
-  if (!isRecord7(value)) return [];
+  if (Array.isArray(value)) return value.filter(isRecord9);
+  if (!isRecord9(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord7(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord9(entry) ? { name, ...entry } : { name }
   );
 }
 function firstRawPath(entry) {
-  const details = isRecord7(entry.details) ? entry.details : {};
+  const details = isRecord9(entry.details) ? entry.details : {};
   const paths = [
     ...asArray(details.rawToolOutputPaths),
     ...asArray(details.raw_tool_output_paths),
@@ -16046,12 +16416,12 @@ function checkHintRawPath(value) {
 function collectStaticPipelineToolIds(staticPipeline) {
   const seen = /* @__PURE__ */ new Set();
   const visitPipeline = (pipeline) => {
-    if (!isRecord7(pipeline)) return;
+    if (!isRecord9(pipeline)) return;
     for (const step of [
       ...asArray(pipeline.stages),
       ...asArray(pipeline.substeps)
     ]) {
-      if (!isRecord7(step)) continue;
+      if (!isRecord9(step)) continue;
       if (step.type === "tool") {
         const toolId = stringValue2(step.toolId) || stringValue2(step.tool);
         if (toolId) seen.add(toolId);
@@ -16065,9 +16435,9 @@ function collectStaticPipelineToolIds(staticPipeline) {
   return [...seen].sort();
 }
 function toolGetterHintFromMetadata(toolId, tool) {
-  const usageGuidance = isRecord7(tool.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord7(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord7(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
-  const toolResponse = isRecord7(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord7(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
+  const usageGuidance = isRecord9(tool.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord9(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord9(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const toolResponse = isRecord9(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord9(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
   const lists = extractionEntries2(
     resultGuidance.extractedLists ?? resultGuidance.extracted_lists
   ).map((entry) => ({
@@ -19454,6 +19824,9 @@ function compileEnrichConfigToPlaySource(config, options = {}) {
   const inlineTypeImports = [
     ...new Set(inlineHandlers.flatMap((inline) => inline.typeImports ?? []))
   ].sort();
+  const inlineRuntimeImports = [
+    ...new Set(inlineHandlers.flatMap((inline) => inline.runtimeImports ?? []))
+  ].sort();
   config.commands.forEach((command) => {
     if (isWaterfall(command)) {
       columnSteps.push(
@@ -19529,7 +19902,7 @@ function compileEnrichConfigToPlaySource(config, options = {}) {
   const typeImports = idiomaticGetters ? inlineTypeImports : [.../* @__PURE__ */ new Set([...inlineTypeImports, "DeeplinePlayRuntimeContext"])].sort();
   return [
     ...inlineRunJavascript && configHasRunJavascript(config) ? ["// @ts-nocheck", "/* eslint-disable */", ""] : [],
-    `import { definePlay, steps } from 'deepline';`,
+    `import { ${["definePlay", "steps", ...inlineRuntimeImports].join(", ")} } from 'deepline';`,
     ...typeImports.length > 0 ? [`import type { ${typeImports.join(", ")} } from 'deepline';`] : [],
     ``,
     `type EnrichInput = { file: string; rowStart?: number | null; rowEnd?: number | null };`,
@@ -20345,7 +20718,7 @@ function isMarkedTestAiInferenceCommand(command) {
   if (normalizeEnrichPlayRef(command.tool) !== "run_javascript") {
     return false;
   }
-  return isRecord8(command.payload) && command.payload[ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER] === true;
+  return isRecord10(command.payload) && command.payload[ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER] === true;
 }
 function enrichDebugEnabled(env = process.env) {
   const raw = String(env.DEEPLINE_DEBUG_ENRICH ?? "").trim().toLowerCase();
@@ -20609,7 +20982,7 @@ function rewriteGeneratedPlayRerunForEnrich(status, enrichCommand) {
     if (Array.isArray(value)) {
       return value.map(rewrite);
     }
-    if (!isRecord8(value)) {
+    if (!isRecord10(value)) {
       return value;
     }
     const next = Object.fromEntries(
@@ -20618,7 +20991,7 @@ function rewriteGeneratedPlayRerunForEnrich(status, enrichCommand) {
         key === "rerunCommand" && typeof entry === "string" ? enrichCommand : rewrite(entry)
       ])
     );
-    if (isRecord8(next.next) && typeof next.next.run === "string") {
+    if (isRecord10(next.next) && typeof next.next.run === "string") {
       next.next = { ...next.next, run: enrichCommand };
     }
     return next;
@@ -21089,7 +21462,7 @@ async function resolveWatchedGeneratedPlayStatus(input2) {
   }
   return input2.client.runs.get(runId, { full: true });
 }
-function isRecord8(value) {
+function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 async function captureStdout(run, options = {}) {
@@ -21341,15 +21714,15 @@ function readFirstEnrichDatasetActions(value) {
       return null;
     }
     const record = candidate;
-    const actions = isRecord8(record.actions) ? record.actions : null;
-    const currentQuery = isRecord8(actions?.queryCurrentTable) ? actions.queryCurrentTable : null;
-    const legacyQuery = isRecord8(actions?.query) ? actions.query : null;
+    const actions = isRecord10(record.actions) ? record.actions : null;
+    const currentQuery = isRecord10(actions?.queryCurrentTable) ? actions.queryCurrentTable : null;
+    const legacyQuery = isRecord10(actions?.query) ? actions.query : null;
     const query = currentQuery?.kind === "deepline_db_query" ? currentQuery : legacyQuery?.kind === "deepline_db_query" ? legacyQuery : null;
     if (query?.kind === "deepline_db_query") {
       return {
         dataset: record,
         query,
-        ...isRecord8(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
+        ...isRecord10(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
       };
     }
     if (options.allowLegacy && record.kind === "dataset" && typeof record.queryDatasetCommand === "string" && record.queryDatasetCommand.trim()) {
@@ -21402,7 +21775,7 @@ function enrichCustomerDbJson(input2) {
   const dataset = actions.dataset;
   const sql = actionStringField(query, "sql") ?? parseSqlFromDbQueryCommand(actions.queryDatasetCommand);
   const datasetPath = actionStringField(query, "datasetPath") ?? actionStringField(dataset, "path") ?? actionStringField(dataset, "tableNamespace");
-  const api = isRecord8(query.api) ? query.api : null;
+  const api = isRecord10(query.api) ? query.api : null;
   const apiPath = actionStringField(api ?? {}, "path") ?? "/api/v2/db/query";
   const apiMethod = actionStringField(api ?? {}, "method") ?? "POST";
   if (!datasetPath) {
@@ -21471,11 +21844,11 @@ function sqlStringLiteral(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
 function failureAliasFromCellMeta(cellMeta) {
-  if (!isRecord8(cellMeta)) {
+  if (!isRecord10(cellMeta)) {
     return null;
   }
   for (const [alias, meta] of Object.entries(cellMeta)) {
-    if (!isRecord8(meta)) {
+    if (!isRecord10(meta)) {
       continue;
     }
     const failure = failureCellFromMeta(meta, {});
@@ -21968,7 +22341,7 @@ function exportableSheetRow2(row, sourceRowStart = 0) {
   return fallback;
 }
 function failureCellFromMeta(meta, fallback) {
-  if (!isRecord8(meta)) {
+  if (!isRecord10(meta)) {
     return null;
   }
   const status = typeof meta.status === "string" ? meta.status.trim().toLowerCase() : "";
@@ -21988,7 +22361,7 @@ function failureCellFromMeta(meta, fallback) {
   };
 }
 function applyFailureCellMeta(row, cellMeta, fallback) {
-  if (!isRecord8(cellMeta)) {
+  if (!isRecord10(cellMeta)) {
     return;
   }
   for (const [field, meta] of Object.entries(cellMeta)) {
@@ -22216,7 +22589,7 @@ function stableRowSnapshot(value) {
 }
 function cellFailureError(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (!isRecord8(parsed)) {
+  if (!isRecord10(parsed)) {
     const text = typeof parsed === "string" ? parsed.trim() : "";
     if (/^(?:[A-Za-z0-9_:-]+:\s*)?(?:Error|TypeError|ReferenceError|SyntaxError|RangeError):\s+/.test(
       text
@@ -22224,12 +22597,12 @@ function cellFailureError(value) {
       return { message: text };
     }
   }
-  if (!isRecord8(parsed)) {
+  if (!isRecord10(parsed)) {
     return null;
   }
   const status = typeof parsed.status === "string" ? parsed.status.trim().toLowerCase() : "";
   const directError = typeof parsed.error === "string" ? parsed.error.trim() : typeof parsed.last_error === "string" ? parsed.last_error.trim() : "";
-  const result = isRecord8(parsed.result) ? parsed.result : null;
+  const result = isRecord10(parsed.result) ? parsed.result : null;
   const resultError = typeof result?.error === "string" ? result.error.trim() : typeof result?.message === "string" ? result.message.trim() : "";
   if (!directError && !resultError && status !== "error" && status !== "failed") {
     return null;
@@ -22299,7 +22672,7 @@ function assignFlattenedFailurePath(target, field, value) {
   let cursor = target;
   for (const part of normalized.slice(0, -1)) {
     const existing = cursor[part];
-    if (!isRecord8(existing)) {
+    if (!isRecord10(existing)) {
       const next = {};
       cursor[part] = next;
       cursor = next;
@@ -22463,10 +22836,10 @@ function waterfallExecutionSignal(status, spec) {
   let everyChildStatOnlyConditionSkipped = true;
   const childAliasesWithStats = /* @__PURE__ */ new Set();
   for (const childAlias of childAliases) {
-    for (const stat2 of summaries.map((summary) => summary[childAlias]).filter(isRecord8)) {
+    for (const stat2 of summaries.map((summary) => summary[childAlias]).filter(isRecord10)) {
       sawChildStats = true;
       childAliasesWithStats.add(childAlias);
-      const execution = isRecord8(stat2.execution) ? stat2.execution : null;
+      const execution = isRecord10(stat2.execution) ? stat2.execution : null;
       const executedSummary = parseExecutionSummary(
         execution?.["completed:executed"]
       );
@@ -22496,7 +22869,7 @@ function waterfallExecutionSignal(status, spec) {
 }
 function emptyWaterfallStatsEvidence(status, spec) {
   const summaries = collectColumnStats(status);
-  const parentStats = summaries.map((summary) => summary[spec.alias]).filter(isRecord8);
+  const parentStats = summaries.map((summary) => summary[spec.alias]).filter(isRecord10);
   for (const stat2 of parentStats) {
     const nonEmpty = parseExecutionSummary(stat2.non_empty);
     if (nonEmpty?.total && nonEmpty.count === 0) {
@@ -22510,7 +22883,7 @@ function emptyWaterfallStatsEvidence(status, spec) {
   let selectedRows = 0;
   let sawStatsForEveryChild = true;
   for (const childAlias of childAliases) {
-    const stat2 = summaries.map((summary) => summary[childAlias]).find(isRecord8);
+    const stat2 = summaries.map((summary) => summary[childAlias]).find(isRecord10);
     if (!stat2) {
       sawStatsForEveryChild = false;
       break;
@@ -22519,7 +22892,7 @@ function emptyWaterfallStatsEvidence(status, spec) {
     if ((nonEmpty?.count ?? 0) > 0) {
       return null;
     }
-    const execution = isRecord8(stat2.execution) ? stat2.execution : null;
+    const execution = isRecord10(stat2.execution) ? stat2.execution : null;
     const executed = parseExecutionSummary(execution?.["completed:executed"]);
     const reused = parseExecutionSummary(execution?.["completed:reused"]);
     const skipped = parseExecutionSummary(execution?.["skipped:condition"]);
@@ -22561,11 +22934,11 @@ function collectStatusFailureJobs(input2) {
   const jobs = [];
   aliases.forEach((spec, aliasIndex) => {
     const { alias } = spec;
-    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord8);
+    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord10);
     if (!stat2) {
       return;
     }
-    const execution = isRecord8(stat2.execution) ? stat2.execution : null;
+    const execution = isRecord10(stat2.execution) ? stat2.execution : null;
     const failedCount = Math.min(
       selectedRows,
       Math.max(
@@ -22672,10 +23045,10 @@ function collectColumnStats(status) {
       value.forEach(visit);
       return;
     }
-    if (!isRecord8(value)) {
+    if (!isRecord10(value)) {
       return;
     }
-    if (isRecord8(value.columnStats)) {
+    if (isRecord10(value.columnStats)) {
       summaries.push(value.columnStats);
     }
     Object.values(value).forEach(visit);
@@ -22687,12 +23060,12 @@ function firstAliasExecutionCounts(input2) {
   const aliases = collectConfigScalarAliasOrder(input2.config);
   const summaries = collectColumnStats(input2.status);
   for (const alias of aliases) {
-    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord8);
+    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord10);
     if (!stat2) continue;
     if (input2.forceAliases.has(normalizeAlias2(alias))) {
       return { executed: input2.selectedRows, reused: 0 };
     }
-    const execution = isRecord8(stat2.execution) ? stat2.execution : null;
+    const execution = isRecord10(stat2.execution) ? stat2.execution : null;
     if (!execution) continue;
     return {
       executed: parseExecutionCount(execution["completed:executed"]),
@@ -22719,14 +23092,14 @@ function rewriteEnrichJsonStatus(input2) {
     if (Array.isArray(value)) {
       return value.map(rewrite);
     }
-    if (!isRecord8(value)) {
+    if (!isRecord10(value)) {
       return value;
     }
     const next = {};
     for (const [key, entry] of Object.entries(value)) {
       next[key] = rewrite(entry);
     }
-    if (isRecord8(next.progress)) {
+    if (isRecord10(next.progress)) {
       next.progress = {
         ...next.progress,
         ...selectedRows > 0 ? { total: selectedRows } : {},
@@ -22735,8 +23108,8 @@ function rewriteEnrichJsonStatus(input2) {
         ...failedRows > 0 ? { failed: failedRows, pending: 0 } : {}
       };
     }
-    if (isRecord8(next.summary)) {
-      const rowCounts = isRecord8(next.summary.rowCounts) ? next.summary.rowCounts : null;
+    if (isRecord10(next.summary)) {
+      const rowCounts = isRecord10(next.summary.rowCounts) ? next.summary.rowCounts : null;
       if (failedRows > 0) {
         next.summary = {
           ...next.summary,
@@ -22749,11 +23122,11 @@ function rewriteEnrichJsonStatus(input2) {
         };
       }
     }
-    if (isRecord8(next.columnStats) && selectedRows > 0) {
+    if (isRecord10(next.columnStats) && selectedRows > 0) {
       const columnStats = { ...next.columnStats };
       for (const alias of forcedAliases) {
-        const stat2 = isRecord8(columnStats[alias]) ? columnStats[alias] : null;
-        const execution = isRecord8(stat2?.execution) ? stat2.execution : null;
+        const stat2 = isRecord10(columnStats[alias]) ? columnStats[alias] : null;
+        const execution = isRecord10(stat2?.execution) ? stat2.execution : null;
         if (!stat2 || !execution) continue;
         columnStats[alias] = {
           ...stat2,
@@ -22772,14 +23145,14 @@ function rewriteEnrichJsonStatus(input2) {
     return next;
   };
   const rewritten = rewrite(input2.status);
-  if (failedRows === 0 || !isRecord8(rewritten)) {
+  if (failedRows === 0 || !isRecord10(rewritten)) {
     return rewritten;
   }
   const partialStatus = selectedRows > 0 && failedRows < selectedRows ? "partial_success" : "failed";
   return {
     ...rewritten,
     ...rewritten.status === "completed" || rewritten.status === "failed" ? { status: partialStatus } : {},
-    ...isRecord8(rewritten.run) && (rewritten.run.status === "completed" || rewritten.run.status === "failed") ? { run: { ...rewritten.run, status: partialStatus } } : {}
+    ...isRecord10(rewritten.run) && (rewritten.run.status === "completed" || rewritten.run.status === "failed") ? { run: { ...rewritten.run, status: partialStatus } } : {}
   };
 }
 function summarizeFailedJobError(value) {
@@ -23385,7 +23758,7 @@ function materializeCsvCellValue(value) {
   return value;
 }
 function compactArrayEnvelopeCompleteValue(value) {
-  if (!isRecord8(value) || value.kind !== "array") {
+  if (!isRecord10(value) || value.kind !== "array") {
     return null;
   }
   if (!Array.isArray(value.preview)) {
@@ -23399,7 +23772,7 @@ function compactArrayEnvelopeCompleteValue(value) {
 }
 function disambiguateCompactAiInferencePayload(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (!isRecord8(parsed) || !cellFailureError(parsed)) {
+  if (!isRecord10(parsed) || !cellFailureError(parsed)) {
     return value;
   }
   return {
@@ -23408,14 +23781,14 @@ function disambiguateCompactAiInferencePayload(value) {
   };
 }
 function compactAiInferenceCellForCsv(value) {
-  if (!isRecord8(value)) {
+  if (!isRecord10(value)) {
     return value;
   }
   const extractedJson = value.extracted_json;
   if (extractedJson !== null && extractedJson !== void 0) {
     return disambiguateCompactAiInferencePayload(extractedJson);
   }
-  const result = isRecord8(value.result) ? value.result : null;
+  const result = isRecord10(value.result) ? value.result : null;
   const object = result?.object;
   if (object !== null && object !== void 0) {
     return disambiguateCompactAiInferencePayload(object);
@@ -23432,12 +23805,12 @@ function compactAiInferenceCellForCsv(value) {
 }
 function materializeEnrichAliasCellForCsv(row, alias, options) {
   const direct = row[alias];
-  if (isRecord8(direct)) {
+  if (isRecord10(direct)) {
     const completeArray = compactArrayEnvelopeCompleteValue(direct);
     if (completeArray) {
       return materializeCsvCellValue(completeArray);
     }
-    if (options?.compactAiCell && direct.status === "completed" && (isRecord8(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
+    if (options?.compactAiCell && direct.status === "completed" && (isRecord10(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
       return materializeCsvCellValue(compactAiInferenceCellForCsv(direct));
     }
     if (Object.prototype.hasOwnProperty.call(direct, "matched_result") || Object.prototype.hasOwnProperty.call(direct, "matchedResult") || Object.prototype.hasOwnProperty.call(direct, "result")) {
@@ -23578,11 +23951,11 @@ function normalizeEnrichRowsForCsvExport(rows, config, options) {
 }
 function legacyMetadataFromRow(row) {
   const direct = parseLegacyMetadataCell(row._metadata);
-  if (direct && isRecord8(direct.columns)) {
+  if (direct && isRecord10(direct.columns)) {
     return direct;
   }
   const relocated = parseLegacyMetadataCell(row.metadata);
-  if (relocated && isRecord8(relocated.columns)) {
+  if (relocated && isRecord10(relocated.columns)) {
     return relocated;
   }
   const flattenedColumns = parseLegacyMetadataCell(row["metadata.columns"]);
@@ -23599,7 +23972,7 @@ function legacyMetadataFromRow(row) {
 }
 function parseLegacyMetadataCell(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (isRecord8(parsed)) {
+  if (isRecord10(parsed)) {
     return parsed;
   }
   if (typeof value !== "string") {
@@ -23616,12 +23989,12 @@ function parseLegacyMetadataCell(value) {
   for (const candidate of candidates) {
     try {
       const decoded = JSON.parse(candidate);
-      if (isRecord8(decoded)) {
+      if (isRecord10(decoded)) {
         return decoded;
       }
       if (typeof decoded === "string") {
         const nested = JSON.parse(decoded);
-        if (isRecord8(nested)) {
+        if (isRecord10(nested)) {
           return nested;
         }
       }
@@ -23631,8 +24004,8 @@ function parseLegacyMetadataCell(value) {
   return null;
 }
 function mergeLegacyMetadataRecords(base, enriched) {
-  const baseColumns = isRecord8(base.columns) ? base.columns : null;
-  const enrichedColumns = isRecord8(enriched.columns) ? enriched.columns : null;
+  const baseColumns = isRecord10(base.columns) ? base.columns : null;
+  const enrichedColumns = isRecord10(enriched.columns) ? enriched.columns : null;
   const merged = {
     ...base,
     ...enriched
@@ -28067,7 +28440,7 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
 }
 function extractionContractEntries(entries) {
   return entries.flatMap((entry) => {
-    if (!isRecord9(entry)) return [];
+    if (!isRecord11(entry)) return [];
     const name = stringField2(entry, "name");
     const expression = stringField2(entry, "expression");
     return name && expression ? [{ name, expression }] : [];
@@ -28088,7 +28461,7 @@ function printMonitorTypeFilters(tool) {
   }
   console.log("Deploy filters (set in the monitor payload):");
   for (const name of names) {
-    const field = isRecord9(properties[name]) ? properties[name] : {};
+    const field = isRecord11(properties[name]) ? properties[name] : {};
     const star = required.has(name) ? "*" : "";
     const enumVals = arrayField2(field, "enum").filter(
       (v) => typeof v === "string"
@@ -28100,14 +28473,14 @@ function printMonitorTypeFilters(tool) {
 }
 function printMonitorTypeStreams(tool) {
   const streams = arrayField2(tool, "streams", "output_streams").filter(
-    isRecord9
+    isRecord11
   );
   if (!streams.length) return;
   console.log("");
   console.log("Filter columns (a play's sqlListeners.where, per stream):");
   for (const stream of streams) {
     const name = stringField2(stream, "stream");
-    const cols = arrayField2(stream, "columns").filter(isRecord9).map((col) => stringField2(col, "name")).filter(Boolean);
+    const cols = arrayField2(stream, "columns").filter(isRecord11).map((col) => stringField2(col, "name")).filter(Boolean);
     console.log(`- ${name}: ${cols.join(", ")}`);
   }
 }
@@ -28125,7 +28498,7 @@ function printMonitorTypePricing(tool) {
   }
   console.log("Pricing (Deepline credits per accepted event):");
   for (const key of keys) {
-    const entry = isRecord9(byType[key]) ? byType[key] : {};
+    const entry = isRecord11(byType[key]) ? byType[key] : {};
     const credits = numberField2(entry, "deepline_credits", "deeplineCredits");
     const display = stringField2(entry, "display");
     const shown = display || (credits !== null ? `${formatDecimal(credits)} credits/event` : "see --json");
@@ -28170,8 +28543,8 @@ function printCompactToolContract(tool, requestedToolId) {
     return;
   }
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord9(contract.cost) ? contract.cost : {};
-  const getters = isRecord9(contract.getters) ? contract.getters : {};
+  const cost = isRecord11(contract.cost) ? contract.cost : {};
+  const getters = isRecord11(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const inputFields = recursiveToolInputFieldsForDisplay(
@@ -28190,7 +28563,7 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("");
     console.log("Inputs:");
     for (const field of inputFields) {
-      if (!isRecord9(field)) continue;
+      if (!isRecord11(field)) continue;
       const name = stringField2(field, "name");
       if (!name) continue;
       const required = field.required ? "*" : "";
@@ -28209,7 +28582,7 @@ function printCompactToolContract(tool, requestedToolId) {
   }
   console.log("");
   printToolExamplesOnly(tool, requestedToolId, { includeSamples: false });
-  const starterScript = isRecord9(contract.starterScript) ? contract.starterScript : {};
+  const starterScript = isRecord11(contract.starterScript) ? contract.starterScript : {};
   const starterPath = stringField2(starterScript, "path");
   if (starterPath) {
     console.log("");
@@ -28223,14 +28596,14 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("Getters:");
     if (listGetters.length) console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord9(entry))
+      if (isRecord11(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
     }
     if (valueGetters.length) console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord9(entry))
+      if (isRecord11(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -28247,7 +28620,7 @@ function printToolPricingOnly(tool, requestedToolId, options = {}) {
     return;
   }
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord9(contract.cost) ? contract.cost : {};
+  const cost = isRecord11(contract.cost) ? contract.cost : {};
   const pricingModel = stringField2(cost, "pricingModel") || "unknown";
   const billingMode = stringField2(cost, "billingMode") || "unknown";
   const unit = pricingModel === "per_page" ? "page" : pricingModel === "per_result" ? "result" : pricingModel === "fixed" ? "call" : pricingModel.replace(/^per_/, "") || "unit";
@@ -28319,10 +28692,10 @@ function printToolExamplesOnly(tool, requestedToolId, options = {}) {
     `  input: ${JSON.stringify(sampleInput || {}, null, 2).replace(/\n/g, "\n  ")},`
   );
   console.log("});");
-  const getters = isRecord9(contract.getters) ? contract.getters : {};
+  const getters = isRecord11(contract.getters) ? contract.getters : {};
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
-  const firstGetter = [...valueGetters, ...listGetters].find(isRecord9);
+  const firstGetter = [...valueGetters, ...listGetters].find(isRecord11);
   if (firstGetter) {
     const name = stringField2(firstGetter, "name") || "value";
     const expression = stringField2(firstGetter, "expression");
@@ -28358,7 +28731,7 @@ function printPlayLikeToolUsage(tool, requestedToolId) {
 }
 function printToolGettersOnly(tool, requestedToolId) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const getters = isRecord9(contract.getters) ? contract.getters : {};
+  const getters = isRecord11(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   console.log(`Getters: ${contract.toolId}`);
@@ -28371,7 +28744,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (listGetters.length) {
     console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord9(entry))
+      if (isRecord11(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -28380,7 +28753,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (valueGetters.length) {
     console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord9(entry))
+      if (isRecord11(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -28406,7 +28779,7 @@ function sampleValueForField(field) {
 function samplePayloadForInputFields(fields) {
   return Object.fromEntries(
     fields.slice(0, 4).flatMap((field) => {
-      if (!isRecord9(field)) return [];
+      if (!isRecord11(field)) return [];
       const name = stringField2(field, "name");
       if (!name) return [];
       return [[name, sampleValueForField(field)]];
@@ -28524,12 +28897,12 @@ function formatListedToolCost(tool) {
 }
 function toolInputFieldsForDisplay(inputSchema) {
   if (Array.isArray(inputSchema.fields))
-    return inputSchema.fields.filter(isRecord9);
-  const jsonSchema = isRecord9(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
-  const properties = isRecord9(jsonSchema.properties) ? jsonSchema.properties : {};
+    return inputSchema.fields.filter(isRecord11);
+  const jsonSchema = isRecord11(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  const properties = isRecord11(jsonSchema.properties) ? jsonSchema.properties : {};
   const required = Array.isArray(jsonSchema.required) ? new Set(jsonSchema.required.map(String)) : /* @__PURE__ */ new Set();
   return Object.entries(properties).map(([name, value]) => {
-    const property = isRecord9(value) ? value : {};
+    const property = isRecord11(value) ? value : {};
     return {
       name,
       type: typeof property.type === "string" ? property.type : "unknown",
@@ -28540,10 +28913,10 @@ function toolInputFieldsForDisplay(inputSchema) {
   });
 }
 function canonicalToolJsonSchema(inputSchema) {
-  return isRecord9(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  return isRecord11(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
 }
 function declaredToolJsonSchema(inputSchema) {
-  if (isRecord9(inputSchema.jsonSchema)) {
+  if (isRecord11(inputSchema.jsonSchema)) {
     return inputSchema.jsonSchema;
   }
   return Array.isArray(inputSchema.fields) ? null : inputSchema;
@@ -28568,7 +28941,7 @@ function publicToolInputSchemaForDescribe(inputSchema) {
   };
   const stripDescriptions = (value) => {
     if (Array.isArray(value)) return value.map(stripDescriptions);
-    if (!isRecord9(value)) return value;
+    if (!isRecord11(value)) return value;
     return Object.fromEntries(
       Object.entries(value).flatMap(([key, nested]) => {
         if (key === "description" && typeof nested === "string" && exposesProviderSpend(nested)) {
@@ -28589,7 +28962,7 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
       for (const item of value) collectSchemaIds(item);
       return;
     }
-    if (!isRecord9(value)) return;
+    if (!isRecord11(value)) return;
     if (typeof value.$id === "string" && value.$id.trim()) {
       schemasById.set(value.$id.trim(), value);
     }
@@ -28602,10 +28975,10 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
     let current = root;
     for (const rawSegment of ref.slice(2).split("/")) {
       const segment = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
-      if (!isRecord9(current)) return schema;
+      if (!isRecord11(current)) return schema;
       current = current[segment];
     }
-    return isRecord9(current) ? current : schema;
+    return isRecord11(current) ? current : schema;
   };
   const addField = (field) => {
     const name = typeof field.name === "string" ? field.name : "";
@@ -28620,7 +28993,7 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
     if (ref && activeRefs.has(ref)) return;
     const schema = resolveRef(unresolvedSchema);
     const nextActiveRefs = ref ? /* @__PURE__ */ new Set([...activeRefs, ref]) : activeRefs;
-    const type = Array.isArray(schema.type) ? schema.type.map(String).join("|") : typeof schema.type === "string" ? schema.type : isRecord9(schema.properties) ? "object" : schema.items ? "array" : "unknown";
+    const type = Array.isArray(schema.type) ? schema.type.map(String).join("|") : typeof schema.type === "string" ? schema.type : isRecord11(schema.properties) ? "object" : schema.items ? "array" : "unknown";
     if (path) {
       addField({
         name: path,
@@ -28631,12 +29004,12 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
         ...Object.prototype.hasOwnProperty.call(schema, "default") ? { default: schema.default } : {}
       });
     }
-    const properties = isRecord9(schema.properties) ? schema.properties : {};
+    const properties = isRecord11(schema.properties) ? schema.properties : {};
     const requiredNames = new Set(
       Array.isArray(schema.required) ? schema.required.map(String) : []
     );
     for (const [name, value] of Object.entries(properties)) {
-      if (!isRecord9(value)) continue;
+      if (!isRecord11(value)) continue;
       visit(
         value,
         path ? `${path}.${name}` : name,
@@ -28644,13 +29017,13 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
         nextActiveRefs
       );
     }
-    if (isRecord9(schema.items)) {
+    if (isRecord11(schema.items)) {
       visit(schema.items, `${path}[]`, false, nextActiveRefs);
     }
     for (const keyword of ["anyOf", "oneOf", "allOf"]) {
       const branches = Array.isArray(schema[keyword]) ? schema[keyword] : [];
       for (const branch of branches) {
-        if (isRecord9(branch)) {
+        if (isRecord11(branch)) {
           visit(branch, path, required, nextActiveRefs);
         }
       }
@@ -28678,14 +29051,14 @@ function printJsonPreview(label, payload) {
 }
 function samplePayload(samples, key) {
   const entry = samples[key];
-  if (!isRecord9(entry)) return void 0;
+  if (!isRecord11(entry)) return void 0;
   return Object.prototype.hasOwnProperty.call(entry, "payload") ? entry.payload : entry;
 }
 function commandEnvelopeFromRawResponse(rawResponse) {
-  return isRecord9(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
+  return isRecord11(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
 }
 function apifySyncRecoveryNext(rawResponse) {
-  if (!isRecord9(rawResponse) || rawResponse.status !== "running") return null;
+  if (!isRecord11(rawResponse) || rawResponse.status !== "running") return null;
   const toolResponse = recordField2(rawResponse, "toolResponse");
   const raw = recordField2(toolResponse, "raw");
   if (raw.state !== "awaiting_apify") return null;
@@ -28708,7 +29081,7 @@ function apifySyncRecoveryNext(rawResponse) {
 }
 function listExtractorPathsFromUsageGuidance(tool) {
   const toolExecutionResult = tool.usageGuidance?.toolExecutionResult;
-  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord9(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
+  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord11(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
   return extractedLists.flatMap((entry) => {
     const paths = entry.details?.candidatePaths ?? entry.details?.rawToolOutputPaths;
     if (!Array.isArray(paths)) return [];
@@ -28724,7 +29097,7 @@ function formatDecimal(value) {
 function formatUsd(value) {
   return `$${formatDecimal(value)}`;
 }
-function isRecord9(value) {
+function isRecord11(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringField2(source, ...keys) {
@@ -28751,7 +29124,7 @@ function arrayField2(source, ...keys) {
 function recordField2(source, ...keys) {
   for (const key of keys) {
     const value = source[key];
-    if (isRecord9(value)) return value;
+    if (isRecord11(value)) return value;
   }
   return {};
 }
@@ -28817,7 +29190,7 @@ function parseJsonObjectArgument(raw, flagName) {
     }
     throw invalidJsonError(flagName, message);
   }
-  if (!isRecord9(parsed)) {
+  if (!isRecord11(parsed)) {
     throw invalidJsonError(flagName, "expected an object.");
   }
   return parsed;
@@ -28964,7 +29337,7 @@ function buildToolExecuteBaseEnvelope(input2) {
     kind: summaryEntries.length > 0 ? "object" : "raw",
     summary: input2.summary
   };
-  const envelopeHasCanonicalOutput = isRecord9(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
+  const envelopeHasCanonicalOutput = isRecord11(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
   const envelopeHasDeclaredOutput = Object.prototype.hasOwnProperty.call(
     envelope,
     "output"
@@ -29194,7 +29567,7 @@ async function executeTool(args) {
       {
         ...baseEnvelope,
         local: {
-          ...isRecord9(baseEnvelope.local) ? baseEnvelope.local : {},
+          ...isRecord11(baseEnvelope.local) ? baseEnvelope.local : {},
           payload_file: jsonPath
         }
       },