@kortyx/telemetry-contracts 0.17.2 → 0.18.0

package/dist/index.js

@@ -28,11 +28,15 @@ __export(index_exports, {
   DiagnosticNoteSchema: () => DiagnosticNoteSchema,
   DiagnosticPartSchema: () => DiagnosticPartSchema,
   DiagnosticResponseSchema: () => DiagnosticResponseSchema,
+  EMPTY_TABLE_FILTERS: () => EMPTY_TABLE_FILTERS,
+  EVALUATION_TABLE_FILTER_FIELDS: () => EVALUATION_TABLE_FILTER_FIELDS,
   EnsureWorkflowTopologyRequestSchema: () => EnsureWorkflowTopologyRequestSchema,
   EnsureWorkflowTopologyResponseSchema: () => EnsureWorkflowTopologyResponseSchema,
   FEEDBACK_FILTERS: () => FEEDBACK_FILTERS,
   FeedbackReasonSchema: () => FeedbackReasonSchema,
   FeedbackSummarySchema: () => FeedbackSummarySchema,
+  LEGACY_TABLE_FILTERS: () => LEGACY_TABLE_FILTERS,
+  PROMPT_TABLE_FILTER_FIELDS: () => PROMPT_TABLE_FILTER_FIELDS,
   PromptAssetSchema: () => PromptAssetSchema,
   PromptAssignmentSchema: () => PromptAssignmentSchema,
   PromptBundleSchema: () => PromptBundleSchema,
@@ -49,6 +53,7 @@ __export(index_exports, {
   PromptUsageSchema: () => PromptUsageSchema,
   ReviewVerdictSchema: () => ReviewVerdictSchema,
   STUDIO_API_PROTOCOL_VERSION: () => STUDIO_API_PROTOCOL_VERSION,
+  STUDIO_TABLE_FIELDS: () => STUDIO_TABLE_FIELDS,
   STUDIO_TIME_RANGES: () => STUDIO_TIME_RANGES,
   StudioCatalogsResponseSchema: () => StudioCatalogsResponseSchema,
   StudioChangeResourceSchema: () => StudioChangeResourceSchema,
@@ -95,6 +100,8 @@ __export(index_exports, {
   StudioWorkflowTransitionSchema: () => StudioWorkflowTransitionSchema,
   StudioWorkflowsResponseSchema: () => StudioWorkflowsResponseSchema,
   TELEMETRY_EVENT_TYPES: () => TELEMETRY_EVENT_TYPES,
+  TableFilterRuleSchema: () => TableFilterRuleSchema,
+  TableFiltersSchema: () => TableFiltersSchema,
   TelemetryEventBatchResponseSchema: () => TelemetryEventBatchResponseSchema,
   TelemetryEventBatchSchema: () => TelemetryEventBatchSchema,
   TelemetryEventSchema: () => TelemetryEventSchema,
@@ -116,19 +123,27 @@ __export(index_exports, {
   WorkflowTopologyEdgeSchema: () => WorkflowTopologyEdgeSchema,
   WorkflowTopologyNodeSchema: () => WorkflowTopologyNodeSchema,
   WorkflowTopologyTransitionSchema: () => WorkflowTopologyTransitionSchema,
+  captureDiagnosticContent: () => captureDiagnosticContent,
+  filterOperators: () => filterOperators,
   isPrivateDiagnosticField: () => isPrivateDiagnosticField,
+  matchesTableFilters: () => matchesTableFilters,
+  matchesTableRule: () => matchesTableRule,
   newerStudioVersion: () => newerStudioVersion,
   projectWorkflowCalls: () => projectWorkflowCalls,
+  readStudioTableFilters: () => readStudioTableFilters,
   redactDiagnosticContent: () => redactDiagnosticContent,
   redactDiagnosticText: () => redactDiagnosticText,
   resolveStudioInterruptStatus: () => resolveStudioInterruptStatus,
   resolveStudioTimeRange: () => resolveStudioTimeRange,
   studioUpdateRunning: () => studioUpdateRunning,
   summarizeDiagnostic: () => summarizeDiagnostic,
-  summarizeUserFeedback: () => summarizeUserFeedback
+  summarizeUserFeedback: () => summarizeUserFeedback,
+  tablePassRate: () => tablePassRate,
+  tableQueueMs: () => tableQueueMs,
+  validateTableFilters: () => validateTableFilters
 });
 module.exports = __toCommonJS(index_exports);
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/scores.ts
 var import_zod = require("zod");
@@ -230,6 +245,11 @@ var DiagnosticContentSchema = import_zod2.z.object({
 }).strict();
 var DiagnosticCorrelationSchema = import_zod2.z.object({
   runId: import_zod2.z.string().optional(),
+  evaluationId: import_zod2.z.string().optional(),
+  suiteRunId: import_zod2.z.string().optional(),
+  caseId: import_zod2.z.string().optional(),
+  repetition: import_zod2.z.string().optional(),
+  phase: import_zod2.z.string().optional(),
   workflowId: import_zod2.z.string().optional(),
   nodeId: import_zod2.z.string().optional(),
   sessionId: import_zod2.z.string().optional(),
@@ -457,6 +477,243 @@ var StudioToolSchema = WorkflowToolSchema.extend({
   p95DurationMs: import_zod3.z.number().nonnegative().nullable()
 }).strict();
 
+// src/diagnostic-capture.ts
+var import_errors = require("@kortyx/core/errors");
+var encoder = new TextEncoder();
+var nativeStackGetter = Object.getOwnPropertyDescriptor(
+  new Error(),
+  "stack"
+)?.get;
+function nativeStack(object, getter) {
+  if (!getter || getter !== nativeStackGetter)
+    throw new Error("Custom stack accessor");
+  for (const key of ["name", "message"]) {
+    let cursor = object;
+    while (cursor) {
+      const descriptor = Object.getOwnPropertyDescriptor(cursor, key);
+      if (descriptor) {
+        if (!("value" in descriptor) || typeof descriptor.value !== "string")
+          throw new Error("Custom error formatting");
+        break;
+      }
+      cursor = Object.getPrototypeOf(cursor);
+    }
+  }
+  const formatter = Object.getOwnPropertyDescriptor(Error, "prepareStackTrace");
+  if (formatter && (!("value" in formatter) || !formatter.writable))
+    throw new Error("Custom stack formatter");
+  Object.defineProperty(Error, "prepareStackTrace", {
+    ...formatter ?? { configurable: true, writable: true },
+    value: void 0
+  });
+  try {
+    return getter.call(object);
+  } finally {
+    if (formatter) Object.defineProperty(Error, "prepareStackTrace", formatter);
+    else Reflect.deleteProperty(Error, "prepareStackTrace");
+  }
+}
+var pointer = (key) => key.replace(/~/g, "~0").replace(/\//g, "~1");
+function captureDiagnosticContent(error, project) {
+  const omissions = [];
+  const redactions = [];
+  const seen = /* @__PURE__ */ new WeakMap();
+  let nodes = 0;
+  let remaining = DIAGNOSTIC_LIMITS.bytes - 64 * 1024;
+  const omit = (path, reason, extra = {}) => {
+    if (omissions.length < 1e3)
+      omissions.push({ path: path.slice(0, 4096), reason, ...extra });
+    return { $omitted: reason };
+  };
+  const visit = (value, path, depth) => {
+    if (++nodes > DIAGNOSTIC_LIMITS.nodes) return omit(path, "node_limit");
+    if (depth > DIAGNOSTIC_LIMITS.depth) return omit(path, "depth_limit");
+    if (typeof value === "string") {
+      const clean = redactDiagnosticText(value);
+      if (clean !== value && redactions.length < 1e3)
+        redactions.push({
+          path: path.slice(0, 4096),
+          reason: "credential_text"
+        });
+      const bytes = encoder.encode(JSON.stringify(clean)).length;
+      if (bytes > remaining)
+        return omit(path, "byte_limit", {
+          originalBytes: encoder.encode(value).length
+        });
+      remaining -= bytes;
+      return clean;
+    }
+    if (value === null || typeof value === "boolean") return value;
+    if (typeof value === "number")
+      return Number.isFinite(value) ? value : { $type: "number", value: String(value) };
+    if (typeof value === "bigint")
+      return { $type: "bigint", value: value.toString() };
+    if (typeof value === "undefined") return { $type: "undefined" };
+    if (typeof value === "function" || typeof value === "symbol")
+      return omit(path, `unsupported_${typeof value}`);
+    const object = value;
+    const reference = seen.get(object);
+    if (reference) return { $ref: reference };
+    seen.set(object, path);
+    remaining -= 32;
+    if (remaining < 0) return omit(path, "byte_limit");
+    try {
+      if (value instanceof Date)
+        return { $type: "Date", value: Date.prototype.toISOString.call(value) };
+      if (value instanceof Map || value instanceof Set) {
+        const isMap = value instanceof Map;
+        const iterator = isMap ? Map.prototype.entries.call(value) : Set.prototype.values.call(value);
+        const count = Object.getOwnPropertyDescriptor(
+          isMap ? Map.prototype : Set.prototype,
+          "size"
+        )?.get?.call(value);
+        const entries = [];
+        for (let index = 0; index < Math.min(count, DIAGNOSTIC_LIMITS.properties); index++)
+          entries.push(iterator.next().value);
+        if (count > entries.length)
+          omissions.push({
+            path,
+            reason: "collection_limit",
+            originalCount: count
+          });
+        return isMap ? {
+          $type: "Map",
+          entries: visit(entries, `${path}/entries`, depth + 1)
+        } : {
+          $type: "Set",
+          values: visit(entries, `${path}/values`, depth + 1)
+        };
+      }
+      if (Array.isArray(value)) {
+        const count = Math.min(value.length, DIAGNOSTIC_LIMITS.properties);
+        const items = Array.from(
+          { length: count },
+          (_, index) => read(value, String(index), `${path}/${index}`, depth)
+        );
+        if (count < value.length)
+          items.push(
+            omit(path, "collection_limit", { originalCount: value.length })
+          );
+        return items;
+      }
+      const keys = Object.getOwnPropertyNames(object);
+      const result = /* @__PURE__ */ Object.create(null);
+      if (value instanceof Error) {
+        const ownName = Object.getOwnPropertyDescriptor(object, "name");
+        let type = ownName && "value" in ownName ? ownName.value : void 0;
+        if (typeof type !== "string") {
+          const name2 = Object.getOwnPropertyDescriptor(
+            Object.getPrototypeOf(value),
+            "name"
+          );
+          type = name2 && "value" in name2 ? name2.value : "Error";
+        }
+        result.type = visit(
+          typeof type === "string" ? type : "Error",
+          `${path}/type`,
+          depth + 1
+        );
+      }
+      for (const key of keys.slice(0, DIAGNOSTIC_LIMITS.properties)) {
+        if (["__proto__", "constructor", "prototype"].includes(key)) {
+          result[key] = omit(`${path}/${pointer(key)}`, "unsafe_key");
+          continue;
+        }
+        remaining -= encoder.encode(key).length + 4;
+        result[key] = read(object, key, `${path}/${pointer(key)}`, depth);
+      }
+      if (keys.length > DIAGNOSTIC_LIMITS.properties)
+        result.$omittedProperties = omit(path, "property_limit", {
+          originalCount: keys.length
+        });
+      return result;
+    } catch {
+      return omit(path, "unreadable_object");
+    }
+  };
+  const read = (object, key, path, depth) => {
+    if (isPrivateDiagnosticField(key)) {
+      if (redactions.length < 1e3)
+        redactions.push({
+          path: path.slice(0, 4096),
+          reason: "credential_field"
+        });
+      return "[REDACTED]";
+    }
+    try {
+      const property = Object.getOwnPropertyDescriptor(object, key);
+      if (property && "value" in property)
+        return visit(property.value, path, depth + 1);
+      if (key === "stack" && object instanceof Error && property?.get && property.get === nativeStackGetter)
+        return visit(nativeStack(object, property.get), path, depth + 1);
+      return omit(
+        path,
+        property ? "accessor_not_evaluated" : "unavailable_property"
+      );
+    } catch {
+      return omit(path, "unreadable_property");
+    }
+  };
+  try {
+    const original = project ? project(error) : error;
+    if (project && original === null) return null;
+    const captured = visit(original, "#/data", 0);
+    const upstreamOmissions = (0, import_errors.errorProperty)(original, "diagnosticOmissions");
+    if (Array.isArray(upstreamOmissions))
+      for (const note of upstreamOmissions.slice(0, 1e3)) {
+        const path = (0, import_errors.errorProperty)(note, "path");
+        const reason = (0, import_errors.errorProperty)(note, "reason");
+        if (typeof path === "string" && typeof reason === "string")
+          omissions.push({
+            path: redactDiagnosticText(path).slice(0, 4096),
+            reason: redactDiagnosticText(reason).slice(0, 128)
+          });
+      }
+    const data = captured && typeof captured === "object" && !Array.isArray(captured) ? captured : {
+      type: "Error",
+      message: typeof captured === "string" ? captured : "Execution reported a fault.",
+      value: captured
+    };
+    if (typeof data.message !== "string" && !("message" in data))
+      data.message = "Execution reported a fault.";
+    if (!("type" in data))
+      data.type = typeof data.name === "string" ? data.name : "Error";
+    const content = {
+      schemaVersion: 1,
+      data,
+      capture: {
+        status: omissions.length ? "partial" : "complete",
+        omissions,
+        redactions
+      }
+    };
+    if (encoder.encode(JSON.stringify(content)).length > DIAGNOSTIC_LIMITS.bytes)
+      return {
+        schemaVersion: 1,
+        data: {
+          type: "Error",
+          message: "Diagnostic exceeded the capture budget."
+        },
+        capture: {
+          status: "partial",
+          redactions: [],
+          omissions: [{ path: "#/data", reason: "serialized_byte_limit" }]
+        }
+      };
+    return content;
+  } catch {
+    return {
+      schemaVersion: 1,
+      data: { type: "Error", message: "Diagnostic capture failed." },
+      capture: {
+        status: "failed",
+        redactions: [],
+        omissions: [{ path: "#/data", reason: "projection_or_capture_failed" }]
+      }
+    };
+  }
+}
+
 // src/prompts.ts
 var import_browser = require("@kortyx/prompts/browser");
 var import_zod4 = require("zod");
@@ -821,6 +1078,314 @@ function studioUpdateRunning(operation) {
   return !!operation && operation.phase !== "succeeded" && operation.phase !== "failed";
 }
 
+// src/table-filters.ts
+var import_zod6 = require("zod");
+var TableFilterRuleSchema = import_zod6.z.object({
+  field: import_zod6.z.string().min(1).max(80),
+  operator: import_zod6.z.enum([
+    "contains",
+    "notContains",
+    "is",
+    "isNot",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "between",
+    "present",
+    "missing"
+  ]),
+  values: import_zod6.z.array(
+    import_zod6.z.union([import_zod6.z.string().min(1).max(512), import_zod6.z.number().finite(), import_zod6.z.boolean()])
+  ).max(30)
+}).strict();
+var TableFiltersSchema = import_zod6.z.object({
+  match: import_zod6.z.enum(["all", "any"]),
+  rules: import_zod6.z.array(TableFilterRuleSchema).max(32)
+}).strict().refine(
+  (value) => JSON.stringify(value).length <= 32768,
+  "Filters must fit within 32 KiB."
+);
+var EMPTY_TABLE_FILTERS = { match: "all", rules: [] };
+var filterOperators = (kind) => [
+  ...kind === "text" ? ["contains", "notContains"] : [],
+  "is",
+  "isNot",
+  ...kind === "number" || kind === "date" ? ["gt", "gte", "lt", "lte", "between"] : [],
+  "present",
+  "missing"
+];
+function validateTableFilters(filters, fields) {
+  const parsed = TableFiltersSchema.safeParse(filters);
+  if (!parsed.success) throw new Error("Enter valid values for every filter.");
+  for (const rule of filters.rules) {
+    const field2 = fields.find((item) => item.key === rule.field);
+    if (!field2 || !filterOperators(field2.kind).includes(rule.operator))
+      throw new Error("Unsupported filter field or operator.");
+    const noValue = rule.operator === "present" || rule.operator === "missing";
+    if (noValue ? rule.values.length !== 0 : rule.operator === "between" ? rule.values.length !== 2 : !rule.values.length)
+      throw new Error("Invalid number of filter values.");
+    for (const value of rule.values) {
+      if (field2.kind === "number" && typeof value !== "number")
+        throw new Error("Numeric filters require numbers.");
+      if (field2.kind === "boolean" && typeof value !== "boolean")
+        throw new Error("Boolean filters require true or false.");
+      if ((field2.kind === "text" || field2.kind === "enum" || field2.kind === "date") && typeof value !== "string")
+        throw new Error("Text filters require strings.");
+      if (field2.kind === "date" && (typeof value !== "string" || !Number.isFinite(Date.parse(value)) || !/(Z|[+-]\d{2}:\d{2})$/.test(value)))
+        throw new Error("Date filters require ISO timestamps with an offset.");
+    }
+    if (rule.operator === "between" && (field2.kind === "date" ? Date.parse(String(rule.values[0])) > Date.parse(String(rule.values[1])) : Number(rule.values[0]) > Number(rule.values[1])))
+      throw new Error("Filter minimum must not exceed maximum.");
+  }
+  return filters;
+}
+function matchesTableRule(value, rule, kind) {
+  const values = (Array.isArray(value) ? value : [value]).filter(
+    (item) => item !== null && item !== void 0 && item !== ""
+  );
+  if (rule.operator === "present") return values.length > 0;
+  if (rule.operator === "missing") return values.length === 0;
+  if (!values.length) return false;
+  const equal = (a, b) => typeof a === "string" && typeof b === "string" ? kind === "date" ? Date.parse(a) === Date.parse(b) : a.toLowerCase() === b.toLowerCase() : a === b;
+  const contains = () => values.some(
+    (a) => rule.values.some(
+      (b) => String(a).toLowerCase().includes(String(b).toLowerCase())
+    )
+  );
+  if (rule.operator === "contains") return contains();
+  if (rule.operator === "notContains") return !contains();
+  if (rule.operator === "is")
+    return values.some((a) => rule.values.some((b) => equal(a, b)));
+  if (rule.operator === "isNot")
+    return !values.some((a) => rule.values.some((b) => equal(a, b)));
+  return values.some((a) => {
+    const comparable = typeof a === "string" && a.includes("T") && (a.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(a)) ? Date.parse(a) : Number(a);
+    const bounds = rule.values.map(
+      (b) => typeof b === "string" ? Date.parse(b) : Number(b)
+    );
+    switch (rule.operator) {
+      case "gt":
+        return comparable > bounds[0];
+      case "gte":
+        return comparable >= bounds[0];
+      case "lt":
+        return comparable < bounds[0];
+      case "lte":
+        return comparable <= bounds[0];
+      case "between":
+        return comparable >= bounds[0] && comparable <= bounds[1];
+      default:
+        return false;
+    }
+  });
+}
+function matchesTableFilters(filters, read, fields) {
+  if (!filters.rules.length) return true;
+  const match = (rule) => matchesTableRule(
+    read(rule.field),
+    rule,
+    fields?.find((f) => f.key === rule.field)?.kind
+  );
+  return filters.match === "any" ? filters.rules.some(match) : filters.rules.every(match);
+}
+var field = (key, label, kind = "text", unit) => ({ key, label, kind, ...unit ? { unit } : {} });
+var identity = [field("userId", "User ID"), field("tenantId", "Tenant ID")];
+var metrics = [
+  field("durationMs", "Duration", "number", "ms"),
+  field("tokens", "Tokens", "number"),
+  field("cost", "Cost", "number", "currency units"),
+  field("currency", "Currency", "enum")
+];
+var STUDIO_TABLE_FIELDS = {
+  runs: [
+    field("id", "Run ID"),
+    field("execution", "Execution", "enum"),
+    field("parentRunId", "Parent run ID"),
+    field("callId", "Call ID"),
+    field("status", "Status", "enum"),
+    field("startedAt", "Started", "date"),
+    field("endedAt", "Ended", "date"),
+    ...identity,
+    field("environment", "Environment", "enum"),
+    field("pricingStatus", "Pricing status", "enum"),
+    field("feedback", "Feedback", "enum"),
+    field("workflowIds", "Workflow"),
+    field("versions", "Version"),
+    field("path", "Path"),
+    field("sessionId", "Session ID"),
+    field("provider", "Provider", "enum"),
+    field("models", "Model"),
+    ...metrics,
+    field("result", "Result"),
+    field("hasTool", "Has tool call", "boolean"),
+    field("toolName", "Tool name"),
+    field("toolOutcome", "Tool outcome", "enum"),
+    field("toolMode", "Called by", "enum"),
+    field("transitionIds", "Workflow transition")
+  ],
+  sessions: [
+    field("id", "Session ID"),
+    field("status", "Status", "enum"),
+    field("lastActivityAt", "Last activity", "date"),
+    field("environment", "Environment", "enum"),
+    ...identity,
+    field("workflowIds", "Workflow"),
+    field("activeVersion", "Version"),
+    field("runs", "Runs", "number"),
+    field("succeeded", "Successful runs", "number"),
+    field("failed", "Failed runs", "number"),
+    field("interrupted", "Interrupted runs", "number"),
+    field("checkpoints", "Checkpoints", "number"),
+    field("hasFork", "Has branch", "boolean"),
+    ...metrics,
+    field("latestResult", "Latest result"),
+    field("latestError", "Latest error"),
+    field("pendingInterruptId", "Pending interrupt"),
+    field("hasError", "Has error", "boolean"),
+    field("hasInterrupt", "Has interrupt", "boolean"),
+    field("hasCheckpoint", "Has checkpoint", "boolean"),
+    field("providers", "Provider", "enum"),
+    field("models", "Model"),
+    field("tags", "Tags")
+  ],
+  interrupts: [
+    field("id", "Interrupt ID"),
+    field("status", "Status", "enum"),
+    field("createdAt", "Created", "date"),
+    field("expiresAt", "Expires", "date"),
+    field("resolvedAt", "Resolved", "date"),
+    field("environment", "Environment", "enum"),
+    field("age", "Age", "number", "minutes"),
+    field("resolutionMs", "Resolution time", "number", "ms"),
+    field("type", "Type", "enum"),
+    field("question", "Request"),
+    field("contract", "Contract"),
+    field("schemaId", "Schema ID"),
+    field("workflowId", "Workflow"),
+    field("nodeId", "Node"),
+    field("sessionId", "Session ID"),
+    ...identity,
+    field("response", "Response"),
+    field("resolvedBy", "Resolved by"),
+    field("resumeOutcome", "Resume outcome", "enum"),
+    field("resumeError", "Resume error"),
+    field("runId", "Run ID")
+  ]
+};
+var LEGACY_TABLE_FILTERS = {
+  toolName: ["toolName", "contains"],
+  toolOutcome: ["toolOutcome", "is"],
+  toolMode: ["toolMode", "is"],
+  error: ["hasError", "is"],
+  interrupt: ["hasInterrupt", "is"],
+  checkpoint: ["hasCheckpoint", "is"],
+  fork: ["hasFork", "is"],
+  transition: ["transitionIds", "is"],
+  status: ["status", "is"],
+  provider: ["provider", "is"],
+  workflow: ["workflowIds", "is"],
+  version: ["versions", "is"],
+  path: ["path", "is"],
+  session: ["sessionId", "contains"],
+  model: ["models", "contains"],
+  result: ["result", "contains"],
+  feedback: ["feedback", "is"],
+  tool: ["hasTool", "is"],
+  user: ["userId", "contains"],
+  tenant: ["tenantId", "contains"],
+  tags: ["tags", "contains"],
+  node: ["nodeId", "contains"],
+  resolver: ["resolvedBy", "contains"],
+  outcome: ["resumeOutcome", "is"],
+  type: ["type", "is"],
+  minCost: ["cost", "gte"],
+  maxCost: ["cost", "lte"],
+  minTokens: ["tokens", "gte"],
+  maxTokens: ["tokens", "lte"],
+  minDuration: ["durationMs", "gte"],
+  maxDuration: ["durationMs", "lte"],
+  minAge: ["age", "gte"],
+  maxAge: ["age", "lte"]
+};
+function readStudioTableFilters(query, resource) {
+  const fields = STUDIO_TABLE_FIELDS[resource];
+  const filters = query.tableFilters ? TableFiltersSchema.parse(JSON.parse(query.tableFilters)) : { match: "all", rules: [] };
+  const rules = [...filters.rules];
+  for (const [alias, [original, operator]] of Object.entries(
+    LEGACY_TABLE_FILTERS
+  )) {
+    const raw = query[alias];
+    if (!raw) continue;
+    if (resource === "interrupts" && alias === "error") {
+      if (raw === "true" || raw === "1")
+        rules.push({ field: "resumeError", operator: "present", values: [] });
+      continue;
+    }
+    const key = resource === "sessions" && alias === "provider" ? "providers" : resource === "sessions" && alias === "version" ? "activeVersion" : resource === "interrupts" && alias === "workflow" ? "workflowId" : original;
+    const definition = fields.find((f) => f.key === key);
+    if (!definition) continue;
+    const values = definition.kind === "number" ? [Number(raw) * (alias.endsWith("Duration") ? 1e3 : 1)] : definition.kind === "boolean" ? [raw === "true" || raw === "1"] : operator === "is" ? raw.split(",").filter(Boolean) : [raw];
+    rules.push({
+      field: key,
+      operator: resource === "interrupts" && alias === "workflow" ? "contains" : operator,
+      values
+    });
+  }
+  return validateTableFilters(
+    TableFiltersSchema.parse({ ...filters, rules }),
+    fields
+  );
+}
+var PROMPT_TABLE_FILTER_FIELDS = [
+  field("name", "Prompt"),
+  field("key", "Key"),
+  field("category", "Category"),
+  field("categoryId", "Category ID"),
+  field("live", "Is live", "boolean"),
+  field("liveVersion", "Live version", "number"),
+  field("latestVersion", "Newest version", "number"),
+  field("updatedAt", "Updated", "date"),
+  field("assignedTags", "Assigned tags"),
+  field("assignedVersions", "Assigned versions"),
+  field("versionsBehindLive", "Versions behind live", "number")
+];
+var EVALUATION_TABLE_FILTER_FIELDS = [
+  field("name", "Evaluation run"),
+  field("id", "Evaluation ID"),
+  field("selection", "Suite selection", "enum"),
+  field("suiteCount", "Suites", "number"),
+  field("judge", "Judge"),
+  field("judgeVersion", "Judge version"),
+  field("passRate", "Pass rate (%)", "number"),
+  field("queueMs", "Queue time (ms)", "number"),
+  field("status", "Status", "enum"),
+  field("completedSuites", "Completed suites", "number"),
+  field("completedAttempts", "Graded attempts", "number"),
+  field("totalAttempts", "Total attempts", "number"),
+  field("passed", "Passed", "number"),
+  field("failed", "Failed", "number"),
+  field("error", "Errors", "number"),
+  field("cancelled", "Cancelled", "number"),
+  field("applicationId", "Application ID"),
+  field("application", "Application"),
+  field("environment", "Environment", "enum"),
+  field("trigger", "Trigger", "enum"),
+  field("commit", "Commit"),
+  field("createdAt", "Created", "date"),
+  field("cost", "Cost", "number"),
+  field("duration", "Duration (ms)", "number")
+];
+function tablePassRate(counts) {
+  const total = counts ? counts.passed + counts.failed + counts.error : 0;
+  return counts && total > 0 ? counts.passed / total * 100 : void 0;
+}
+function tableQueueMs(createdAt, startedAt) {
+  if (!startedAt) return void 0;
+  const value = Date.parse(startedAt) - Date.parse(createdAt);
+  return Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+
 // src/workflow-calls.ts
 var str = (v, fallback = "") => typeof v === "string" ? v : fallback;
 function projectWorkflowCalls(events) {
@@ -960,82 +1525,82 @@ var TELEMETRY_EVENT_TYPES = [
   "session.forked",
   "session.rolled_back"
 ];
-var TelemetryServiceSchema = import_zod6.z.object({
-  name: import_zod6.z.string().min(1),
-  deploymentRef: import_zod6.z.string().min(1).optional()
+var TelemetryServiceSchema = import_zod7.z.object({
+  name: import_zod7.z.string().min(1),
+  deploymentRef: import_zod7.z.string().min(1).optional()
 }).strict();
-var WorkflowTopologyNodeSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
-  label: import_zod6.z.string().optional(),
-  type: import_zod6.z.string().optional(),
-  provider: import_zod6.z.string().optional(),
-  model: import_zod6.z.string().optional(),
-  metadata: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).optional(),
-  tools: import_zod6.z.array(WorkflowToolSchema).optional(),
+var WorkflowTopologyNodeSchema = import_zod7.z.object({
+  id: import_zod7.z.string().min(1),
+  label: import_zod7.z.string().optional(),
+  type: import_zod7.z.string().optional(),
+  provider: import_zod7.z.string().optional(),
+  model: import_zod7.z.string().optional(),
+  metadata: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).optional(),
+  tools: import_zod7.z.array(WorkflowToolSchema).optional(),
   toolDiscovery: ToolDiscoverySchema.optional()
 }).strict();
-var WorkflowTopologyEdgeSchema = import_zod6.z.object({
-  sourceNodeId: import_zod6.z.string().min(1),
-  targetNodeId: import_zod6.z.string().min(1),
-  condition: import_zod6.z.string().optional()
+var WorkflowTopologyEdgeSchema = import_zod7.z.object({
+  sourceNodeId: import_zod7.z.string().min(1),
+  targetNodeId: import_zod7.z.string().min(1),
+  condition: import_zod7.z.string().optional()
 }).strict();
-var WorkflowTopologyCallSchema = import_zod6.z.object({
-  sourceNodeId: import_zod6.z.string().min(1),
-  targetWorkflowId: import_zod6.z.string().min(1)
+var WorkflowTopologyCallSchema = import_zod7.z.object({
+  sourceNodeId: import_zod7.z.string().min(1),
+  targetWorkflowId: import_zod7.z.string().min(1)
 }).strict();
-var WorkflowTopologyTransitionSchema = import_zod6.z.object({
-  sourceNodeId: import_zod6.z.string().min(1).optional(),
-  targetWorkflowId: import_zod6.z.string().min(1),
-  condition: import_zod6.z.string().optional(),
-  intent: import_zod6.z.string().optional(),
-  kind: import_zod6.z.enum(["call", "handoff"]).optional()
+var WorkflowTopologyTransitionSchema = import_zod7.z.object({
+  sourceNodeId: import_zod7.z.string().min(1).optional(),
+  targetWorkflowId: import_zod7.z.string().min(1),
+  condition: import_zod7.z.string().optional(),
+  intent: import_zod7.z.string().optional(),
+  kind: import_zod7.z.enum(["call", "handoff"]).optional()
 }).strict();
-var EnsureWorkflowTopologyRequestSchema = import_zod6.z.object({
-  schemaVersion: import_zod6.z.literal(1),
-  environment: import_zod6.z.string().min(1),
+var EnsureWorkflowTopologyRequestSchema = import_zod7.z.object({
+  schemaVersion: import_zod7.z.literal(1),
+  environment: import_zod7.z.string().min(1),
   service: TelemetryServiceSchema,
-  workflow: import_zod6.z.object({
-    id: import_zod6.z.string().min(1),
-    declaredVersion: import_zod6.z.string().min(1),
-    description: import_zod6.z.string().optional(),
-    tags: import_zod6.z.array(import_zod6.z.string()).optional(),
-    topologyHash: import_zod6.z.string().regex(/^[a-f0-9]{64}$/),
-    nodes: import_zod6.z.array(WorkflowTopologyNodeSchema),
-    edges: import_zod6.z.array(WorkflowTopologyEdgeSchema),
-    transitions: import_zod6.z.array(WorkflowTopologyTransitionSchema).optional(),
-    calls: import_zod6.z.array(WorkflowTopologyCallSchema).optional()
+  workflow: import_zod7.z.object({
+    id: import_zod7.z.string().min(1),
+    declaredVersion: import_zod7.z.string().min(1),
+    description: import_zod7.z.string().optional(),
+    tags: import_zod7.z.array(import_zod7.z.string()).optional(),
+    topologyHash: import_zod7.z.string().regex(/^[a-f0-9]{64}$/),
+    nodes: import_zod7.z.array(WorkflowTopologyNodeSchema),
+    edges: import_zod7.z.array(WorkflowTopologyEdgeSchema),
+    transitions: import_zod7.z.array(WorkflowTopologyTransitionSchema).optional(),
+    calls: import_zod7.z.array(WorkflowTopologyCallSchema).optional()
   }).strict()
 }).strict();
-var EnsureWorkflowTopologyResponseSchema = import_zod6.z.object({ workflowRevisionId: import_zod6.z.string().min(1), created: import_zod6.z.boolean() }).strict();
-var TelemetryEventTypeSchema = import_zod6.z.enum(TELEMETRY_EVENT_TYPES);
-var TelemetryEventSchema = import_zod6.z.object({
-  schemaVersion: import_zod6.z.literal(1),
-  eventId: import_zod6.z.string().min(1),
-  occurredAt: import_zod6.z.string().datetime({ offset: true }),
-  environment: import_zod6.z.string().min(1),
+var EnsureWorkflowTopologyResponseSchema = import_zod7.z.object({ workflowRevisionId: import_zod7.z.string().min(1), created: import_zod7.z.boolean() }).strict();
+var TelemetryEventTypeSchema = import_zod7.z.enum(TELEMETRY_EVENT_TYPES);
+var TelemetryEventSchema = import_zod7.z.object({
+  schemaVersion: import_zod7.z.literal(1),
+  eventId: import_zod7.z.string().min(1),
+  occurredAt: import_zod7.z.string().datetime({ offset: true }),
+  environment: import_zod7.z.string().min(1),
   service: TelemetryServiceSchema,
-  correlation: import_zod6.z.object({
-    invocationId: import_zod6.z.string().optional(),
-    parentInvocationId: import_zod6.z.string().optional(),
-    branchId: import_zod6.z.string().optional(),
-    traceId: import_zod6.z.string().optional(),
-    spanId: import_zod6.z.string().optional(),
-    parentSpanId: import_zod6.z.string().optional(),
-    runId: import_zod6.z.string().min(1),
-    sessionId: import_zod6.z.string().optional(),
-    workflowId: import_zod6.z.string().min(1),
-    workflowRevisionId: import_zod6.z.string().optional(),
-    topologyHash: import_zod6.z.string().regex(/^[a-f0-9]{64}$/).optional(),
-    nodeId: import_zod6.z.string().optional()
+  correlation: import_zod7.z.object({
+    invocationId: import_zod7.z.string().optional(),
+    parentInvocationId: import_zod7.z.string().optional(),
+    branchId: import_zod7.z.string().optional(),
+    traceId: import_zod7.z.string().optional(),
+    spanId: import_zod7.z.string().optional(),
+    parentSpanId: import_zod7.z.string().optional(),
+    runId: import_zod7.z.string().min(1),
+    sessionId: import_zod7.z.string().optional(),
+    workflowId: import_zod7.z.string().min(1),
+    workflowRevisionId: import_zod7.z.string().optional(),
+    topologyHash: import_zod7.z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    nodeId: import_zod7.z.string().optional()
   }).strict(),
-  context: import_zod6.z.object({
-    userId: import_zod6.z.string().optional(),
-    tenantId: import_zod6.z.string().optional(),
-    tags: import_zod6.z.array(import_zod6.z.string()).optional(),
-    metadata: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).optional()
+  context: import_zod7.z.object({
+    userId: import_zod7.z.string().optional(),
+    tenantId: import_zod7.z.string().optional(),
+    tags: import_zod7.z.array(import_zod7.z.string()).optional(),
+    metadata: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).optional()
   }).strict().optional(),
   type: TelemetryEventTypeSchema,
-  payload: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown())
+  payload: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown())
 }).strict().superRefine((event, ctx) => {
   if (!event.type.startsWith("tool.")) return;
   const canonical = event.payload.version === 1 || [
@@ -1078,20 +1643,20 @@ var TelemetryEventSchema = import_zod6.z.object({
       });
   }
 });
-var TelemetryEventBatchSchema = import_zod6.z.object({ events: import_zod6.z.array(TelemetryEventSchema).min(1) }).strict();
-var TelemetryEventBatchResponseSchema = import_zod6.z.object({
-  accepted: import_zod6.z.number().int().nonnegative(),
-  inserted: import_zod6.z.number().int().nonnegative(),
-  duplicates: import_zod6.z.number().int().nonnegative()
+var TelemetryEventBatchSchema = import_zod7.z.object({ events: import_zod7.z.array(TelemetryEventSchema).min(1) }).strict();
+var TelemetryEventBatchResponseSchema = import_zod7.z.object({
+  accepted: import_zod7.z.number().int().nonnegative(),
+  inserted: import_zod7.z.number().int().nonnegative(),
+  duplicates: import_zod7.z.number().int().nonnegative()
 }).strict();
-var TelemetryPricingSourceSchema = import_zod6.z.enum([
+var TelemetryPricingSourceSchema = import_zod7.z.enum([
   "sdk",
   "provider",
   "custom",
   "project-rate-card",
   "default-rate-card"
 ]);
-var TelemetryPricingUnitSchema = import_zod6.z.enum([
+var TelemetryPricingUnitSchema = import_zod7.z.enum([
   "token",
   "character",
   "request",
@@ -1104,7 +1669,7 @@ var TelemetryPricingUnitSchema = import_zod6.z.enum([
   "minute",
   "custom"
 ]);
-var TelemetryPricingUsageTypeSchema = import_zod6.z.enum([
+var TelemetryPricingUsageTypeSchema = import_zod7.z.enum([
   "input",
   "output",
   "reasoning",
@@ -1120,42 +1685,42 @@ var TelemetryPricingUsageTypeSchema = import_zod6.z.enum([
   "request",
   "custom"
 ]);
-var TelemetryUsageItemSchema = import_zod6.z.object({
+var TelemetryUsageItemSchema = import_zod7.z.object({
   usageType: TelemetryPricingUsageTypeSchema,
-  quantity: import_zod6.z.number().nonnegative(),
+  quantity: import_zod7.z.number().nonnegative(),
   unit: TelemetryPricingUnitSchema,
-  label: import_zod6.z.string().optional()
+  label: import_zod7.z.string().optional()
 }).strict();
-var TelemetryUnitPriceSchema = import_zod6.z.object({
+var TelemetryUnitPriceSchema = import_zod7.z.object({
   usageType: TelemetryPricingUsageTypeSchema,
   unit: TelemetryPricingUnitSchema,
-  unitQuantity: import_zod6.z.number().positive().default(1),
-  priceMicros: import_zod6.z.number().int().nonnegative(),
-  label: import_zod6.z.string().optional()
+  unitQuantity: import_zod7.z.number().positive().default(1),
+  priceMicros: import_zod7.z.number().int().nonnegative(),
+  label: import_zod7.z.string().optional()
 }).strict();
-var TelemetryPricingLineItemSchema = import_zod6.z.object({
+var TelemetryPricingLineItemSchema = import_zod7.z.object({
   usageType: TelemetryPricingUsageTypeSchema,
-  quantity: import_zod6.z.number().nonnegative(),
+  quantity: import_zod7.z.number().nonnegative(),
   unit: TelemetryPricingUnitSchema,
-  unitQuantity: import_zod6.z.number().positive().default(1),
-  unitPriceMicros: import_zod6.z.number().int().nonnegative().optional(),
-  totalCostMicros: import_zod6.z.number().int().nonnegative().optional(),
-  label: import_zod6.z.string().optional()
+  unitQuantity: import_zod7.z.number().positive().default(1),
+  unitPriceMicros: import_zod7.z.number().int().nonnegative().optional(),
+  totalCostMicros: import_zod7.z.number().int().nonnegative().optional(),
+  label: import_zod7.z.string().optional()
 }).strict().refine(
   (value) => value.totalCostMicros !== void 0 || value.unitPriceMicros !== void 0,
   "line item requires totalCostMicros or unitPriceMicros"
 );
-var TelemetryPricingHintSchema = import_zod6.z.object({
+var TelemetryPricingHintSchema = import_zod7.z.object({
   source: TelemetryPricingSourceSchema.extract(["sdk", "provider", "custom"]),
-  currency: import_zod6.z.string().min(3).max(12).default("USD"),
-  actualCostMicros: import_zod6.z.number().int().nonnegative().optional(),
-  lineItems: import_zod6.z.array(TelemetryPricingLineItemSchema).optional(),
-  unitPrices: import_zod6.z.array(TelemetryUnitPriceSchema).optional(),
-  usageItems: import_zod6.z.array(TelemetryUsageItemSchema).optional(),
-  pricingRef: import_zod6.z.string().min(1).optional(),
-  metadata: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).optional()
+  currency: import_zod7.z.string().min(3).max(12).default("USD"),
+  actualCostMicros: import_zod7.z.number().int().nonnegative().optional(),
+  lineItems: import_zod7.z.array(TelemetryPricingLineItemSchema).optional(),
+  unitPrices: import_zod7.z.array(TelemetryUnitPriceSchema).optional(),
+  usageItems: import_zod7.z.array(TelemetryUsageItemSchema).optional(),
+  pricingRef: import_zod7.z.string().min(1).optional(),
+  metadata: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).optional()
 }).strict();
-var StudioRunStatusSchema = import_zod6.z.enum([
+var StudioRunStatusSchema = import_zod7.z.enum([
   "running",
   "completed",
   "interrupted",
@@ -1171,16 +1736,16 @@ var STUDIO_TIME_RANGES = [
   "All time",
   "Custom range"
 ];
-var StudioTimeRangeSchema = import_zod6.z.enum(STUDIO_TIME_RANGES);
-var StudioTimeRangeQuerySchema = import_zod6.z.object({
+var StudioTimeRangeSchema = import_zod7.z.enum(STUDIO_TIME_RANGES);
+var StudioTimeRangeQuerySchema = import_zod7.z.object({
   range: StudioTimeRangeSchema.optional(),
-  startedAfter: import_zod6.z.string().optional(),
-  startedBefore: import_zod6.z.string().optional()
+  startedAfter: import_zod7.z.string().optional(),
+  startedBefore: import_zod7.z.string().optional()
 }).strict();
-var StudioTimeRangeContextSchema = import_zod6.z.object({
+var StudioTimeRangeContextSchema = import_zod7.z.object({
   range: StudioTimeRangeSchema,
-  startedAfter: import_zod6.z.string().datetime({ offset: true }).nullable(),
-  startedBefore: import_zod6.z.string().datetime({ offset: true }).nullable()
+  startedAfter: import_zod7.z.string().datetime({ offset: true }).nullable(),
+  startedBefore: import_zod7.z.string().datetime({ offset: true }).nullable()
 }).strict();
 var STUDIO_TIME_RANGE_MILLISECONDS = {
   "Last hour": 60 * 60 * 1e3,
@@ -1254,7 +1819,7 @@ var resolveStudioTimeRange = (input, now = /* @__PURE__ */ new Date()) => {
     }
   };
 };
-var StudioInterruptStatusSchema = import_zod6.z.enum([
+var StudioInterruptStatusSchema = import_zod7.z.enum([
   "pending",
   "resolved",
   "expired",
@@ -1267,341 +1832,341 @@ var resolveStudioInterruptStatus = (input, now = Date.now()) => {
   const nowMs = typeof now === "number" ? now : now.getTime();
   return Number.isFinite(expiresAt) && Number.isFinite(nowMs) && expiresAt <= nowMs ? "expired" : input.status;
 };
-var StudioInterruptTypeSchema = import_zod6.z.enum([
+var StudioInterruptTypeSchema = import_zod7.z.enum([
   "choice",
   "multi-choice",
   "text",
   "structured",
   "unknown"
 ]);
-var StudioInterruptInteractionModeSchema = import_zod6.z.enum([
+var StudioInterruptInteractionModeSchema = import_zod7.z.enum([
   "static-options",
   "dynamic-picker",
   "freeform",
   "unknown"
 ]);
-var StudioInterruptOptionSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
-  label: import_zod6.z.string().min(1),
-  description: import_zod6.z.string().nullable()
+var StudioInterruptOptionSchema = import_zod7.z.object({
+  id: import_zod7.z.string().min(1),
+  label: import_zod7.z.string().min(1),
+  description: import_zod7.z.string().nullable()
 }).strip();
-var StudioInterruptValueSchema = import_zod6.z.union([
-  import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()),
-  import_zod6.z.array(import_zod6.z.unknown()),
-  import_zod6.z.string(),
-  import_zod6.z.number(),
-  import_zod6.z.boolean()
+var StudioInterruptValueSchema = import_zod7.z.union([
+  import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()),
+  import_zod7.z.array(import_zod7.z.unknown()),
+  import_zod7.z.string(),
+  import_zod7.z.number(),
+  import_zod7.z.boolean()
 ]);
-var StudioResumeOutcomeSchema = import_zod6.z.enum([
+var StudioResumeOutcomeSchema = import_zod7.z.enum([
   "resumed",
   "resume failed",
   "expired before resume",
   "cancelled"
 ]);
-var StudioWorkflowHealthSchema = import_zod6.z.enum([
+var StudioWorkflowHealthSchema = import_zod7.z.enum([
   "unknown",
   "healthy",
   "degraded",
   "failing",
   "idle"
 ]);
-var StudioPricingStatusSchema = import_zod6.z.enum([
+var StudioPricingStatusSchema = import_zod7.z.enum([
   "priced",
   "unpriced",
   "unknown"
 ]);
 var StudioPricingSourceSchema = TelemetryPricingSourceSchema.nullable();
-var StudioChangeResourceSchema = import_zod6.z.enum([
+var StudioChangeResourceSchema = import_zod7.z.enum([
   "evals",
   "workflows",
   "runs",
   "sessions",
   "interrupts"
 ]);
-var StudioChangeSchema = import_zod6.z.object({
-  schemaVersion: import_zod6.z.literal(1),
-  changeId: import_zod6.z.string().min(1),
-  emittedAt: import_zod6.z.string().datetime({ offset: true }),
-  organizationId: import_zod6.z.string().min(1),
-  projectId: import_zod6.z.string().min(1),
-  environment: import_zod6.z.string().min(1).optional(),
-  resources: import_zod6.z.array(StudioChangeResourceSchema).min(1)
+var StudioChangeSchema = import_zod7.z.object({
+  schemaVersion: import_zod7.z.literal(1),
+  changeId: import_zod7.z.string().min(1),
+  emittedAt: import_zod7.z.string().datetime({ offset: true }),
+  organizationId: import_zod7.z.string().min(1),
+  projectId: import_zod7.z.string().min(1),
+  environment: import_zod7.z.string().min(1).optional(),
+  resources: import_zod7.z.array(StudioChangeResourceSchema).min(1)
 }).strict();
-var StudioCostSummarySchema = import_zod6.z.object({
-  amounts: import_zod6.z.array(
-    import_zod6.z.object({
-      amount: import_zod6.z.number().nonnegative(),
-      currency: import_zod6.z.string().nullable()
+var StudioCostSummarySchema = import_zod7.z.object({
+  amounts: import_zod7.z.array(
+    import_zod7.z.object({
+      amount: import_zod7.z.number().nonnegative(),
+      currency: import_zod7.z.string().nullable()
     }).strip()
   ),
-  complete: import_zod6.z.boolean()
+  complete: import_zod7.z.boolean()
 }).strip();
-var StudioMetricSchema = import_zod6.z.object({
-  runCount: import_zod6.z.number().int().nonnegative(),
-  successRate: import_zod6.z.number().min(0).max(100).nullable(),
-  errorRate: import_zod6.z.number().min(0).max(100).nullable(),
-  retryCount: import_zod6.z.number().int().nonnegative().nullable(),
-  interruptRate: import_zod6.z.number().min(0).max(100).nullable(),
-  p50DurationMs: import_zod6.z.number().nonnegative().nullable(),
-  p95DurationMs: import_zod6.z.number().nonnegative().nullable(),
-  averageTokens: import_zod6.z.number().nonnegative().nullable(),
-  averageCost: import_zod6.z.number().nonnegative().nullable(),
+var StudioMetricSchema = import_zod7.z.object({
+  runCount: import_zod7.z.number().int().nonnegative(),
+  successRate: import_zod7.z.number().min(0).max(100).nullable(),
+  errorRate: import_zod7.z.number().min(0).max(100).nullable(),
+  retryCount: import_zod7.z.number().int().nonnegative().nullable(),
+  interruptRate: import_zod7.z.number().min(0).max(100).nullable(),
+  p50DurationMs: import_zod7.z.number().nonnegative().nullable(),
+  p95DurationMs: import_zod7.z.number().nonnegative().nullable(),
+  averageTokens: import_zod7.z.number().nonnegative().nullable(),
+  averageCost: import_zod7.z.number().nonnegative().nullable(),
   averageCostSummary: StudioCostSummarySchema.optional(),
-  currency: import_zod6.z.string().nullable()
+  currency: import_zod7.z.string().nullable()
 }).strip();
-var StudioRunSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
+var StudioRunSchema = import_zod7.z.object({
+  id: import_zod7.z.string().min(1),
   feedback: FeedbackSummarySchema.optional(),
-  callerNodeId: import_zod6.z.string().optional(),
-  parentRunId: import_zod6.z.string().optional(),
-  parentWorkflowId: import_zod6.z.string().optional(),
-  invocationId: import_zod6.z.string().optional(),
-  branchId: import_zod6.z.string().optional(),
-  callId: import_zod6.z.string().optional(),
+  callerNodeId: import_zod7.z.string().optional(),
+  parentRunId: import_zod7.z.string().optional(),
+  parentWorkflowId: import_zod7.z.string().optional(),
+  invocationId: import_zod7.z.string().optional(),
+  branchId: import_zod7.z.string().optional(),
+  callId: import_zod7.z.string().optional(),
   status: StudioRunStatusSchema,
-  startedAt: import_zod6.z.string().datetime({ offset: true }),
-  endedAt: import_zod6.z.string().datetime({ offset: true }).nullable(),
-  workflowId: import_zod6.z.string().min(1),
-  workflowIds: import_zod6.z.array(import_zod6.z.string().min(1)),
-  workflowRefs: import_zod6.z.array(
-    import_zod6.z.object({
-      workflowId: import_zod6.z.string().min(1),
-      workflowRevisionId: import_zod6.z.string().nullable(),
-      declaredVersion: import_zod6.z.string().nullable()
+  startedAt: import_zod7.z.string().datetime({ offset: true }),
+  endedAt: import_zod7.z.string().datetime({ offset: true }).nullable(),
+  workflowId: import_zod7.z.string().min(1),
+  workflowIds: import_zod7.z.array(import_zod7.z.string().min(1)),
+  workflowRefs: import_zod7.z.array(
+    import_zod7.z.object({
+      workflowId: import_zod7.z.string().min(1),
+      workflowRevisionId: import_zod7.z.string().nullable(),
+      declaredVersion: import_zod7.z.string().nullable()
     }).strip()
   ),
-  workflowRevisionId: import_zod6.z.string().nullable(),
-  declaredVersion: import_zod6.z.string().nullable(),
-  transitionIds: import_zod6.z.array(import_zod6.z.string().min(1)),
-  path: import_zod6.z.array(import_zod6.z.string()),
-  sessionId: import_zod6.z.string().nullable(),
-  provider: import_zod6.z.string().nullable(),
-  model: import_zod6.z.string().nullable(),
-  models: import_zod6.z.array(import_zod6.z.string()),
-  durationMs: import_zod6.z.number().nonnegative().nullable(),
-  tokens: import_zod6.z.number().int().nonnegative().nullable(),
-  cost: import_zod6.z.number().nonnegative().nullable(),
+  workflowRevisionId: import_zod7.z.string().nullable(),
+  declaredVersion: import_zod7.z.string().nullable(),
+  transitionIds: import_zod7.z.array(import_zod7.z.string().min(1)),
+  path: import_zod7.z.array(import_zod7.z.string()),
+  sessionId: import_zod7.z.string().nullable(),
+  provider: import_zod7.z.string().nullable(),
+  model: import_zod7.z.string().nullable(),
+  models: import_zod7.z.array(import_zod7.z.string()),
+  durationMs: import_zod7.z.number().nonnegative().nullable(),
+  tokens: import_zod7.z.number().int().nonnegative().nullable(),
+  cost: import_zod7.z.number().nonnegative().nullable(),
   costSummary: StudioCostSummarySchema.optional(),
   pricingStatus: StudioPricingStatusSchema,
   pricingSource: StudioPricingSourceSchema,
-  currency: import_zod6.z.string().nullable(),
-  result: import_zod6.z.string().nullable(),
-  environment: import_zod6.z.string().min(1),
-  userId: import_zod6.z.string().nullable(),
-  tenantId: import_zod6.z.string().nullable(),
-  hasTool: import_zod6.z.boolean(),
-  hasRetry: import_zod6.z.boolean(),
-  interruptNodeId: import_zod6.z.string().nullable(),
-  interruptId: import_zod6.z.string().nullable().optional(),
+  currency: import_zod7.z.string().nullable(),
+  result: import_zod7.z.string().nullable(),
+  environment: import_zod7.z.string().min(1),
+  userId: import_zod7.z.string().nullable(),
+  tenantId: import_zod7.z.string().nullable(),
+  hasTool: import_zod7.z.boolean(),
+  hasRetry: import_zod7.z.boolean(),
+  interruptNodeId: import_zod7.z.string().nullable(),
+  interruptId: import_zod7.z.string().nullable().optional(),
   interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
-  interruptExpiresAt: import_zod6.z.string().datetime({ offset: true }).nullable().optional()
+  interruptExpiresAt: import_zod7.z.string().datetime({ offset: true }).nullable().optional()
 }).strip();
-var StudioSessionSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
+var StudioSessionSchema = import_zod7.z.object({
+  id: import_zod7.z.string().min(1),
   status: StudioRunStatusSchema,
-  lastActivityAt: import_zod6.z.string().datetime({ offset: true }),
-  workflowIds: import_zod6.z.array(import_zod6.z.string()),
-  workflowCount: import_zod6.z.number().int().nonnegative(),
-  activeWorkflowId: import_zod6.z.string().nullable(),
-  activeVersion: import_zod6.z.string().nullable(),
-  userId: import_zod6.z.string().nullable(),
-  tenantId: import_zod6.z.string().nullable(),
-  runs: import_zod6.z.number().int().nonnegative(),
-  succeeded: import_zod6.z.number().int().nonnegative(),
-  failed: import_zod6.z.number().int().nonnegative(),
-  interrupted: import_zod6.z.number().int().nonnegative(),
-  checkpoints: import_zod6.z.number().int().nonnegative(),
-  hasFork: import_zod6.z.boolean(),
-  durationMs: import_zod6.z.number().nonnegative().nullable(),
-  tokens: import_zod6.z.number().int().nonnegative().nullable(),
-  cost: import_zod6.z.number().nonnegative().nullable(),
+  lastActivityAt: import_zod7.z.string().datetime({ offset: true }),
+  workflowIds: import_zod7.z.array(import_zod7.z.string()),
+  workflowCount: import_zod7.z.number().int().nonnegative(),
+  activeWorkflowId: import_zod7.z.string().nullable(),
+  activeVersion: import_zod7.z.string().nullable(),
+  userId: import_zod7.z.string().nullable(),
+  tenantId: import_zod7.z.string().nullable(),
+  runs: import_zod7.z.number().int().nonnegative(),
+  succeeded: import_zod7.z.number().int().nonnegative(),
+  failed: import_zod7.z.number().int().nonnegative(),
+  interrupted: import_zod7.z.number().int().nonnegative(),
+  checkpoints: import_zod7.z.number().int().nonnegative(),
+  hasFork: import_zod7.z.boolean(),
+  durationMs: import_zod7.z.number().nonnegative().nullable(),
+  tokens: import_zod7.z.number().int().nonnegative().nullable(),
+  cost: import_zod7.z.number().nonnegative().nullable(),
   costSummary: StudioCostSummarySchema.optional(),
   pricingStatus: StudioPricingStatusSchema,
   pricingSource: StudioPricingSourceSchema,
-  currency: import_zod6.z.string().nullable(),
-  latestResult: import_zod6.z.string().nullable(),
-  latestError: import_zod6.z.string().nullable(),
-  pendingInterruptId: import_zod6.z.string().nullable(),
+  currency: import_zod7.z.string().nullable(),
+  latestResult: import_zod7.z.string().nullable(),
+  latestError: import_zod7.z.string().nullable(),
+  pendingInterruptId: import_zod7.z.string().nullable(),
   interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
-  interruptExpiresAt: import_zod6.z.string().datetime({ offset: true }).nullable().optional(),
-  providers: import_zod6.z.array(import_zod6.z.string()),
-  models: import_zod6.z.array(import_zod6.z.string()),
-  tags: import_zod6.z.array(import_zod6.z.string()),
-  environment: import_zod6.z.string().min(1)
+  interruptExpiresAt: import_zod7.z.string().datetime({ offset: true }).nullable().optional(),
+  providers: import_zod7.z.array(import_zod7.z.string()),
+  models: import_zod7.z.array(import_zod7.z.string()),
+  tags: import_zod7.z.array(import_zod7.z.string()),
+  environment: import_zod7.z.string().min(1)
 }).strip();
-var StudioInterruptSchema = import_zod6.z.object({
-  afterResponseCompleted: import_zod6.z.boolean().optional(),
-  id: import_zod6.z.string().min(1),
+var StudioInterruptSchema = import_zod7.z.object({
+  afterResponseCompleted: import_zod7.z.boolean().optional(),
+  id: import_zod7.z.string().min(1),
   status: StudioInterruptStatusSchema,
   type: StudioInterruptTypeSchema,
   interactionMode: StudioInterruptInteractionModeSchema,
-  contract: import_zod6.z.string().nullable().default(null),
-  schemaId: import_zod6.z.string().nullable(),
-  schemaVersion: import_zod6.z.string().nullable(),
-  createdAt: import_zod6.z.string().datetime({ offset: true }),
-  resolvedAt: import_zod6.z.string().datetime({ offset: true }).nullable(),
-  expiresAt: import_zod6.z.string().datetime({ offset: true }).nullable(),
-  question: import_zod6.z.string().nullable(),
-  contentCaptured: import_zod6.z.boolean(),
-  request: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).nullable().default(null),
-  requestCaptured: import_zod6.z.boolean().default(false),
-  optionCount: import_zod6.z.number().int().nonnegative().nullable(),
-  options: import_zod6.z.array(StudioInterruptOptionSchema).nullable(),
-  workflowId: import_zod6.z.string().min(1),
-  nodeId: import_zod6.z.string().nullable(),
-  sessionId: import_zod6.z.string().nullable(),
-  userId: import_zod6.z.string().nullable(),
-  tenantId: import_zod6.z.string().nullable(),
-  response: import_zod6.z.string().nullable(),
+  contract: import_zod7.z.string().nullable().default(null),
+  schemaId: import_zod7.z.string().nullable(),
+  schemaVersion: import_zod7.z.string().nullable(),
+  createdAt: import_zod7.z.string().datetime({ offset: true }),
+  resolvedAt: import_zod7.z.string().datetime({ offset: true }).nullable(),
+  expiresAt: import_zod7.z.string().datetime({ offset: true }).nullable(),
+  question: import_zod7.z.string().nullable(),
+  contentCaptured: import_zod7.z.boolean(),
+  request: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).nullable().default(null),
+  requestCaptured: import_zod7.z.boolean().default(false),
+  optionCount: import_zod7.z.number().int().nonnegative().nullable(),
+  options: import_zod7.z.array(StudioInterruptOptionSchema).nullable(),
+  workflowId: import_zod7.z.string().min(1),
+  nodeId: import_zod7.z.string().nullable(),
+  sessionId: import_zod7.z.string().nullable(),
+  userId: import_zod7.z.string().nullable(),
+  tenantId: import_zod7.z.string().nullable(),
+  response: import_zod7.z.string().nullable(),
   responseValue: StudioInterruptValueSchema.nullable().default(null),
-  responseCaptured: import_zod6.z.boolean(),
+  responseCaptured: import_zod7.z.boolean(),
   resumeOutcome: StudioResumeOutcomeSchema.nullable(),
-  resumeError: import_zod6.z.string().nullable(),
-  runId: import_zod6.z.string().min(1),
-  resumeToken: import_zod6.z.string().nullable(),
-  resolvedBy: import_zod6.z.string().nullable(),
-  environment: import_zod6.z.string().min(1)
+  resumeError: import_zod7.z.string().nullable(),
+  runId: import_zod7.z.string().min(1),
+  resumeToken: import_zod7.z.string().nullable(),
+  resolvedBy: import_zod7.z.string().nullable(),
+  environment: import_zod7.z.string().min(1)
 }).strip();
-var StudioDetailEventSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
+var StudioDetailEventSchema = import_zod7.z.object({
+  id: import_zod7.z.string().min(1),
   // Studio readers must preserve future event kinds within the same API major.
-  type: import_zod6.z.string().min(1),
-  occurredAt: import_zod6.z.string().datetime({ offset: true }),
-  receivedAt: import_zod6.z.string().datetime({ offset: true }),
-  environment: import_zod6.z.string().min(1),
-  serviceName: import_zod6.z.string().min(1),
-  deploymentRef: import_zod6.z.string().nullable(),
-  traceId: import_zod6.z.string().nullable(),
-  spanId: import_zod6.z.string().nullable(),
-  parentSpanId: import_zod6.z.string().nullable(),
-  runId: import_zod6.z.string().min(1),
-  sessionId: import_zod6.z.string().nullable(),
-  workflowId: import_zod6.z.string().min(1),
-  workflowRevisionId: import_zod6.z.string().nullable(),
-  nodeId: import_zod6.z.string().nullable(),
-  userId: import_zod6.z.string().nullable(),
-  tenantId: import_zod6.z.string().nullable(),
-  tags: import_zod6.z.array(import_zod6.z.string()),
-  metadata: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).nullable(),
-  payload: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown())
+  type: import_zod7.z.string().min(1),
+  occurredAt: import_zod7.z.string().datetime({ offset: true }),
+  receivedAt: import_zod7.z.string().datetime({ offset: true }),
+  environment: import_zod7.z.string().min(1),
+  serviceName: import_zod7.z.string().min(1),
+  deploymentRef: import_zod7.z.string().nullable(),
+  traceId: import_zod7.z.string().nullable(),
+  spanId: import_zod7.z.string().nullable(),
+  parentSpanId: import_zod7.z.string().nullable(),
+  runId: import_zod7.z.string().min(1),
+  sessionId: import_zod7.z.string().nullable(),
+  workflowId: import_zod7.z.string().min(1),
+  workflowRevisionId: import_zod7.z.string().nullable(),
+  nodeId: import_zod7.z.string().nullable(),
+  userId: import_zod7.z.string().nullable(),
+  tenantId: import_zod7.z.string().nullable(),
+  tags: import_zod7.z.array(import_zod7.z.string()),
+  metadata: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).nullable(),
+  payload: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown())
 }).strip();
-var StudioWorkflowNodeSchema = import_zod6.z.object({
-  tools: import_zod6.z.array(StudioToolSchema).optional(),
+var StudioWorkflowNodeSchema = import_zod7.z.object({
+  tools: import_zod7.z.array(StudioToolSchema).optional(),
   toolDiscovery: ToolDiscoverySchema.optional(),
-  id: import_zod6.z.string().min(1),
-  label: import_zod6.z.string(),
-  type: import_zod6.z.string().nullable(),
-  state: import_zod6.z.enum(["healthy", "warning", "failed", "interrupted", "retried"]).nullable(),
-  provider: import_zod6.z.string().nullable(),
-  model: import_zod6.z.string().nullable(),
+  id: import_zod7.z.string().min(1),
+  label: import_zod7.z.string(),
+  type: import_zod7.z.string().nullable(),
+  state: import_zod7.z.enum(["healthy", "warning", "failed", "interrupted", "retried"]).nullable(),
+  provider: import_zod7.z.string().nullable(),
+  model: import_zod7.z.string().nullable(),
   metrics: StudioMetricSchema
 }).strip();
-var StudioWorkflowInternalEdgeSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
-  source: import_zod6.z.string().min(1),
-  target: import_zod6.z.string().min(1),
-  condition: import_zod6.z.string().nullable()
+var StudioWorkflowInternalEdgeSchema = import_zod7.z.object({
+  id: import_zod7.z.string().min(1),
+  source: import_zod7.z.string().min(1),
+  target: import_zod7.z.string().min(1),
+  condition: import_zod7.z.string().nullable()
 }).strip();
-var StudioWorkflowTransitionSchema = import_zod6.z.object({
-  kind: import_zod6.z.enum(["call", "handoff"]).optional(),
-  id: import_zod6.z.string().min(1),
-  sourceWorkflowId: import_zod6.z.string().min(1),
-  sourceNodeId: import_zod6.z.string().nullable(),
-  targetWorkflowId: import_zod6.z.string().min(1),
-  condition: import_zod6.z.string().nullable(),
-  volume: import_zod6.z.number().int().nonnegative(),
-  successRate: import_zod6.z.number().min(0).max(100).nullable(),
-  medianDurationMs: import_zod6.z.number().nonnegative().nullable(),
-  errorRate: import_zod6.z.number().min(0).max(100).nullable()
+var StudioWorkflowTransitionSchema = import_zod7.z.object({
+  kind: import_zod7.z.enum(["call", "handoff"]).optional(),
+  id: import_zod7.z.string().min(1),
+  sourceWorkflowId: import_zod7.z.string().min(1),
+  sourceNodeId: import_zod7.z.string().nullable(),
+  targetWorkflowId: import_zod7.z.string().min(1),
+  condition: import_zod7.z.string().nullable(),
+  volume: import_zod7.z.number().int().nonnegative(),
+  successRate: import_zod7.z.number().min(0).max(100).nullable(),
+  medianDurationMs: import_zod7.z.number().nonnegative().nullable(),
+  errorRate: import_zod7.z.number().min(0).max(100).nullable()
 }).strip();
-var StudioWorkflowSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
-  name: import_zod6.z.string().min(1),
-  description: import_zod6.z.string().nullable(),
-  versions: import_zod6.z.array(import_zod6.z.string()),
-  activeVersion: import_zod6.z.string().nullable(),
-  activeRevisionId: import_zod6.z.string().nullable(),
+var StudioWorkflowSchema = import_zod7.z.object({
+  id: import_zod7.z.string().min(1),
+  name: import_zod7.z.string().min(1),
+  description: import_zod7.z.string().nullable(),
+  versions: import_zod7.z.array(import_zod7.z.string()),
+  activeVersion: import_zod7.z.string().nullable(),
+  activeRevisionId: import_zod7.z.string().nullable(),
   health: StudioWorkflowHealthSchema,
-  tags: import_zod6.z.array(import_zod6.z.string()),
-  lastActivityAt: import_zod6.z.string().datetime({ offset: true }).nullable(),
+  tags: import_zod7.z.array(import_zod7.z.string()),
+  lastActivityAt: import_zod7.z.string().datetime({ offset: true }).nullable(),
   metrics: StudioMetricSchema,
-  nodes: import_zod6.z.array(StudioWorkflowNodeSchema),
-  internalEdges: import_zod6.z.array(StudioWorkflowInternalEdgeSchema)
+  nodes: import_zod7.z.array(StudioWorkflowNodeSchema),
+  internalEdges: import_zod7.z.array(StudioWorkflowInternalEdgeSchema)
 }).strip();
-var StudioRunsResponseSchema = import_zod6.z.object({
-  runs: import_zod6.z.array(StudioRunSchema),
-  totalCount: import_zod6.z.number().int().nonnegative()
+var StudioRunsResponseSchema = import_zod7.z.object({
+  runs: import_zod7.z.array(StudioRunSchema),
+  totalCount: import_zod7.z.number().int().nonnegative()
 }).strip();
-var StudioSessionsResponseSchema = import_zod6.z.object({
-  sessions: import_zod6.z.array(StudioSessionSchema),
-  totalCount: import_zod6.z.number().int().nonnegative()
+var StudioSessionsResponseSchema = import_zod7.z.object({
+  sessions: import_zod7.z.array(StudioSessionSchema),
+  totalCount: import_zod7.z.number().int().nonnegative()
 }).strip();
-var StudioInterruptsResponseSchema = import_zod6.z.object({
-  interrupts: import_zod6.z.array(StudioInterruptSchema),
-  totalCount: import_zod6.z.number().int().nonnegative()
+var StudioInterruptsResponseSchema = import_zod7.z.object({
+  interrupts: import_zod7.z.array(StudioInterruptSchema),
+  totalCount: import_zod7.z.number().int().nonnegative()
 }).strip();
-var StudioRunDetailResponseSchema = import_zod6.z.object({
+var StudioRunDetailResponseSchema = import_zod7.z.object({
   run: StudioRunSchema,
-  scores: import_zod6.z.array(StudioScoreSchema).optional(),
-  canReview: import_zod6.z.boolean().optional(),
-  reviewActorId: import_zod6.z.string().optional(),
-  events: import_zod6.z.array(StudioDetailEventSchema),
+  scores: import_zod7.z.array(StudioScoreSchema).optional(),
+  canReview: import_zod7.z.boolean().optional(),
+  reviewActorId: import_zod7.z.string().optional(),
+  events: import_zod7.z.array(StudioDetailEventSchema),
   session: StudioSessionSchema.nullable(),
-  interrupts: import_zod6.z.array(StudioInterruptSchema),
-  updatedAt: import_zod6.z.string().datetime({ offset: true })
+  interrupts: import_zod7.z.array(StudioInterruptSchema),
+  updatedAt: import_zod7.z.string().datetime({ offset: true })
 }).strip();
-var StudioSessionDetailResponseSchema = import_zod6.z.object({
+var StudioSessionDetailResponseSchema = import_zod7.z.object({
   session: StudioSessionSchema,
-  runs: import_zod6.z.array(StudioRunSchema),
-  events: import_zod6.z.array(StudioDetailEventSchema),
-  interrupts: import_zod6.z.array(StudioInterruptSchema),
-  updatedAt: import_zod6.z.string().datetime({ offset: true })
+  runs: import_zod7.z.array(StudioRunSchema),
+  events: import_zod7.z.array(StudioDetailEventSchema),
+  interrupts: import_zod7.z.array(StudioInterruptSchema),
+  updatedAt: import_zod7.z.string().datetime({ offset: true })
 }).strip();
-var StudioInterruptDetailResponseSchema = import_zod6.z.object({
+var StudioInterruptDetailResponseSchema = import_zod7.z.object({
   interrupt: StudioInterruptSchema,
-  events: import_zod6.z.array(StudioDetailEventSchema),
+  events: import_zod7.z.array(StudioDetailEventSchema),
   run: StudioRunSchema.nullable(),
   session: StudioSessionSchema.nullable(),
-  updatedAt: import_zod6.z.string().datetime({ offset: true })
+  updatedAt: import_zod7.z.string().datetime({ offset: true })
 }).strip();
-var StudioWorkflowsResponseSchema = import_zod6.z.object({
-  workflows: import_zod6.z.array(StudioWorkflowSchema),
-  observedCalls: import_zod6.z.array(
+var StudioWorkflowsResponseSchema = import_zod7.z.object({
+  workflows: import_zod7.z.array(StudioWorkflowSchema),
+  observedCalls: import_zod7.z.array(
     StudioWorkflowTransitionSchema.extend({
-      runId: import_zod6.z.string(),
-      invocationId: import_zod6.z.string(),
-      branchId: import_zod6.z.string()
+      runId: import_zod7.z.string(),
+      invocationId: import_zod7.z.string(),
+      branchId: import_zod7.z.string()
     })
   ).optional(),
-  transitions: import_zod6.z.array(StudioWorkflowTransitionSchema),
+  transitions: import_zod7.z.array(StudioWorkflowTransitionSchema),
   cohort: StudioTimeRangeContextSchema.extend({
-    workflowId: import_zod6.z.string().nullable(),
-    version: import_zod6.z.string().nullable()
+    workflowId: import_zod7.z.string().nullable(),
+    version: import_zod7.z.string().nullable()
   }).strip()
 }).strip();
-var StudioCatalogsResponseSchema = import_zod6.z.object({
-  environments: import_zod6.z.array(import_zod6.z.string()),
-  providers: import_zod6.z.array(import_zod6.z.string()),
-  models: import_zod6.z.array(import_zod6.z.string()),
-  workflows: import_zod6.z.array(import_zod6.z.string()),
-  tags: import_zod6.z.array(import_zod6.z.string())
+var StudioCatalogsResponseSchema = import_zod7.z.object({
+  environments: import_zod7.z.array(import_zod7.z.string()),
+  providers: import_zod7.z.array(import_zod7.z.string()),
+  models: import_zod7.z.array(import_zod7.z.string()),
+  workflows: import_zod7.z.array(import_zod7.z.string()),
+  tags: import_zod7.z.array(import_zod7.z.string())
 }).strip();
-var StudioContextResponseSchema = import_zod6.z.object({
-  organization: import_zod6.z.object({
-    name: import_zod6.z.string().min(1)
+var StudioContextResponseSchema = import_zod7.z.object({
+  organization: import_zod7.z.object({
+    name: import_zod7.z.string().min(1)
   }).strip(),
-  project: import_zod6.z.object({
-    name: import_zod6.z.string().min(1)
+  project: import_zod7.z.object({
+    name: import_zod7.z.string().min(1)
   }).strip(),
-  environments: import_zod6.z.array(import_zod6.z.string()),
-  apiKey: import_zod6.z.object({
-    mode: import_zod6.z.enum(["test", "live"]),
-    scopes: import_zod6.z.array(import_zod6.z.string())
+  environments: import_zod7.z.array(import_zod7.z.string()),
+  apiKey: import_zod7.z.object({
+    mode: import_zod7.z.enum(["test", "live"]),
+    scopes: import_zod7.z.array(import_zod7.z.string())
   }).strip().nullable(),
-  api: import_zod6.z.object({
-    status: import_zod6.z.literal("ok"),
-    service: import_zod6.z.literal("kortyx-api"),
-    version: import_zod6.z.string().min(1)
+  api: import_zod7.z.object({
+    status: import_zod7.z.literal("ok"),
+    service: import_zod7.z.literal("kortyx-api"),
+    version: import_zod7.z.string().min(1)
   }).strip()
 }).strip();
 // Annotate the CommonJS export names for ESM import in node:
@@ -1615,11 +2180,15 @@ var StudioContextResponseSchema = import_zod6.z.object({
   DiagnosticNoteSchema,
   DiagnosticPartSchema,
   DiagnosticResponseSchema,
+  EMPTY_TABLE_FILTERS,
+  EVALUATION_TABLE_FILTER_FIELDS,
   EnsureWorkflowTopologyRequestSchema,
   EnsureWorkflowTopologyResponseSchema,
   FEEDBACK_FILTERS,
   FeedbackReasonSchema,
   FeedbackSummarySchema,
+  LEGACY_TABLE_FILTERS,
+  PROMPT_TABLE_FILTER_FIELDS,
   PromptAssetSchema,
   PromptAssignmentSchema,
   PromptBundleSchema,
@@ -1636,6 +2205,7 @@ var StudioContextResponseSchema = import_zod6.z.object({
   PromptUsageSchema,
   ReviewVerdictSchema,
   STUDIO_API_PROTOCOL_VERSION,
+  STUDIO_TABLE_FIELDS,
   STUDIO_TIME_RANGES,
   StudioCatalogsResponseSchema,
   StudioChangeResourceSchema,
@@ -1682,6 +2252,8 @@ var StudioContextResponseSchema = import_zod6.z.object({
   StudioWorkflowTransitionSchema,
   StudioWorkflowsResponseSchema,
   TELEMETRY_EVENT_TYPES,
+  TableFilterRuleSchema,
+  TableFiltersSchema,
   TelemetryEventBatchResponseSchema,
   TelemetryEventBatchSchema,
   TelemetryEventSchema,
@@ -1703,15 +2275,23 @@ var StudioContextResponseSchema = import_zod6.z.object({
   WorkflowTopologyEdgeSchema,
   WorkflowTopologyNodeSchema,
   WorkflowTopologyTransitionSchema,
+  captureDiagnosticContent,
+  filterOperators,
   isPrivateDiagnosticField,
+  matchesTableFilters,
+  matchesTableRule,
   newerStudioVersion,
   projectWorkflowCalls,
+  readStudioTableFilters,
   redactDiagnosticContent,
   redactDiagnosticText,
   resolveStudioInterruptStatus,
   resolveStudioTimeRange,
   studioUpdateRunning,
   summarizeDiagnostic,
-  summarizeUserFeedback
+  summarizeUserFeedback,
+  tablePassRate,
+  tableQueueMs,
+  validateTableFilters
 });
 //# sourceMappingURL=index.js.map