@kortyx/telemetry-contracts 0.17.2 → 0.19.0

package/dist/index.js

@@ -8,9 +8,9 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -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,
@@ -48,7 +52,9 @@ __export(index_exports, {
   PromptTransferRequestSchema: () => PromptTransferRequestSchema,
   PromptUsageSchema: () => PromptUsageSchema,
   ReviewVerdictSchema: () => ReviewVerdictSchema,
+  SAMPLE_PROJECT: () => SAMPLE_PROJECT,
   STUDIO_API_PROTOCOL_VERSION: () => STUDIO_API_PROTOCOL_VERSION,
+  STUDIO_TABLE_FIELDS: () => STUDIO_TABLE_FIELDS,
   STUDIO_TIME_RANGES: () => STUDIO_TIME_RANGES,
   StudioCatalogsResponseSchema: () => StudioCatalogsResponseSchema,
   StudioChangeResourceSchema: () => StudioChangeResourceSchema,
@@ -76,11 +82,23 @@ __export(index_exports, {
   StudioRunSchema: () => StudioRunSchema,
   StudioRunStatusSchema: () => StudioRunStatusSchema,
   StudioRunsResponseSchema: () => StudioRunsResponseSchema,
+  StudioSavedViewDefinitionSchema: () => StudioSavedViewDefinitionSchema,
   StudioScoreResponseSchema: () => StudioScoreResponseSchema,
   StudioScoreSchema: () => StudioScoreSchema,
   StudioSessionDetailResponseSchema: () => StudioSessionDetailResponseSchema,
   StudioSessionSchema: () => StudioSessionSchema,
   StudioSessionsResponseSchema: () => StudioSessionsResponseSchema,
+  StudioTableConfigurationSchema: () => StudioTableConfigurationSchema,
+  StudioTableDefaultsSchema: () => StudioTableDefaultsSchema,
+  StudioTableIdSchema: () => StudioTableIdSchema,
+  StudioTableLayoutSchema: () => StudioTableLayoutSchema,
+  StudioTablePreferenceOperationSchema: () => StudioTablePreferenceOperationSchema,
+  StudioTablePreferenceResponseSchema: () => StudioTablePreferenceResponseSchema,
+  StudioTablePreferenceScopeSchema: () => StudioTablePreferenceScopeSchema,
+  StudioTablePreferenceWriteSchema: () => StudioTablePreferenceWriteSchema,
+  StudioTablePreferencesSchema: () => StudioTablePreferencesSchema,
+  StudioTableQueryPreferencesSchema: () => StudioTableQueryPreferencesSchema,
+  StudioTableViewSchema: () => StudioTableViewSchema,
   StudioTimeRangeContextSchema: () => StudioTimeRangeContextSchema,
   StudioTimeRangeQuerySchema: () => StudioTimeRangeQuerySchema,
   StudioTimeRangeSchema: () => StudioTimeRangeSchema,
@@ -95,6 +113,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 +136,29 @@ __export(index_exports, {
   WorkflowTopologyEdgeSchema: () => WorkflowTopologyEdgeSchema,
   WorkflowTopologyNodeSchema: () => WorkflowTopologyNodeSchema,
   WorkflowTopologyTransitionSchema: () => WorkflowTopologyTransitionSchema,
+  applyTablePreferenceOperation: () => applyTablePreferenceOperation,
+  captureDiagnosticContent: () => captureDiagnosticContent,
+  emptyTablePreferences: () => emptyTablePreferences,
+  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_zod8 = require("zod");
 
 // src/scores.ts
 var import_zod = require("zod");
@@ -203,8 +233,410 @@ function summarizeUserFeedback(scores) {
   return feedback;
 }
 
-// src/diagnostics.ts
+// src/table-preferences.ts
+var import_zod3 = require("zod");
+
+// src/table-filters.ts
 var import_zod2 = require("zod");
+var TableFilterRuleSchema = import_zod2.z.object({
+  field: import_zod2.z.string().min(1).max(80),
+  operator: import_zod2.z.enum([
+    "contains",
+    "notContains",
+    "is",
+    "isNot",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "between",
+    "present",
+    "missing"
+  ]),
+  values: import_zod2.z.array(
+    import_zod2.z.union([import_zod2.z.string().min(1).max(512), import_zod2.z.number().finite(), import_zod2.z.boolean()])
+  ).max(30)
+}).strict();
+var TableFiltersSchema = import_zod2.z.object({
+  match: import_zod2.z.enum(["all", "any"]),
+  rules: import_zod2.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 = (key2, label, kind = "text", unit) => ({ key: key2, 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 key2 = resource === "sessions" && alias === "provider" ? "providers" : resource === "sessions" && alias === "version" ? "activeVersion" : resource === "interrupts" && alias === "workflow" ? "workflowId" : original;
+    const definition = fields.find((f) => f.key === key2);
+    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: key2,
+      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/table-preferences.ts
+var StudioTableIdSchema = import_zod3.z.enum([
+  "runs",
+  "sessions",
+  "interrupts",
+  "prompts",
+  "prompt-groups",
+  "prompt-runs",
+  "prompt-evals",
+  "evaluations",
+  "eval-comparison",
+  "eval-cases",
+  "evaluation-suites",
+  "legacy-eval-runs",
+  "eval-suites"
+]);
+var key = import_zod3.z.string().min(1).max(80);
+var StudioTableLayoutSchema = import_zod3.z.object({
+  widths: import_zod3.z.record(key, import_zod3.z.number().finite().min(1).max(1e4)).refine((v) => Object.keys(v).length <= 256),
+  order: import_zod3.z.array(key).max(256),
+  hidden: import_zod3.z.array(key).max(256),
+  pinned: import_zod3.z.record(key, import_zod3.z.enum(["left", "right"]).optional()).refine((v) => Object.keys(v).length <= 256)
+}).strict();
+var StudioTableQueryPreferencesSchema = import_zod3.z.object({
+  sort: import_zod3.z.string().max(80),
+  dir: import_zod3.z.enum(["asc", "desc"]),
+  pageSize: import_zod3.z.number().int().min(1).max(250)
+}).strict();
+var StudioSavedViewDefinitionSchema = import_zod3.z.object({
+  name: import_zod3.z.string().trim().min(1).max(80),
+  filters: TableFiltersSchema,
+  layout: StudioTableLayoutSchema,
+  scope: import_zod3.z.record(key, import_zod3.z.string().max(512)).refine((v) => Object.keys(v).length <= 32),
+  sort: import_zod3.z.string().max(80).optional(),
+  direction: import_zod3.z.enum(["asc", "desc"]).optional(),
+  pageSize: import_zod3.z.number().int().min(1).max(250).optional()
+}).strict();
+var StudioTableViewSchema = StudioSavedViewDefinitionSchema.extend({
+  id: import_zod3.z.uuid()
+});
+var StudioTableDefaultsSchema = import_zod3.z.object({
+  layout: StudioTableLayoutSchema.optional(),
+  query: StudioTableQueryPreferencesSchema.optional()
+}).strict();
+var StudioTableConfigurationSchema = import_zod3.z.object({
+  schemaVersion: import_zod3.z.literal(1),
+  defaults: StudioTableDefaultsSchema,
+  views: import_zod3.z.array(StudioTableViewSchema).max(30).refine((v) => new Set(v.map((x) => x.id)).size === v.length)
+}).strict();
+var StudioTablePreferencesSchema = StudioTableConfigurationSchema.extend({ revision: import_zod3.z.number().int().min(0) });
+var StudioTablePreferenceScopeSchema = import_zod3.z.object({
+  cacheKey: import_zod3.z.string().regex(/^[a-f0-9]{64}$/),
+  ownerKind: import_zod3.z.enum(["project", "user"])
+});
+var StudioTablePreferenceOperationSchema = import_zod3.z.discriminatedUnion(
+  "kind",
+  [
+    import_zod3.z.object({ kind: import_zod3.z.literal("defaults"), patch: StudioTableDefaultsSchema }).strict(),
+    import_zod3.z.object({ kind: import_zod3.z.literal("putView"), view: StudioTableViewSchema }).strict(),
+    import_zod3.z.object({ kind: import_zod3.z.literal("deleteView"), id: import_zod3.z.uuid() }).strict()
+  ]
+);
+var StudioTablePreferenceWriteSchema = import_zod3.z.object({
+  scopeKey: import_zod3.z.string().regex(/^[a-f0-9]{64}$/),
+  expectedRevision: import_zod3.z.number().int().min(0),
+  operation: StudioTablePreferenceOperationSchema
+}).strict();
+function emptyTablePreferences() {
+  return { schemaVersion: 1, revision: 0, defaults: {}, views: [] };
+}
+function applyTablePreferenceOperation(state, operation) {
+  if (operation.kind === "defaults")
+    return { ...state, defaults: { ...state.defaults, ...operation.patch } };
+  if (operation.kind === "deleteView")
+    return {
+      ...state,
+      views: state.views.filter((v) => v.id !== operation.id)
+    };
+  const exists = state.views.some((v) => v.id === operation.view.id);
+  return StudioTablePreferencesSchema.parse({
+    ...state,
+    views: exists ? state.views.map(
+      (v) => v.id === operation.view.id ? operation.view : v
+    ) : [...state.views, operation.view]
+  });
+}
+var StudioTablePreferenceResponseSchema = import_zod3.z.object({
+  scope: StudioTablePreferenceScopeSchema,
+  preferences: StudioTablePreferencesSchema
+});
+
+// src/diagnostics.ts
+var import_zod4 = require("zod");
 var DIAGNOSTIC_LIMITS = {
   bytes: 8 * 1024 * 1024,
   partBytes: 64 * 1024,
@@ -213,55 +645,60 @@ var DIAGNOSTIC_LIMITS = {
   depth: 128,
   properties: 1e3
 };
-var DiagnosticNoteSchema = import_zod2.z.object({
-  path: import_zod2.z.string().max(4096),
-  reason: import_zod2.z.string().max(128),
-  originalBytes: import_zod2.z.number().int().nonnegative().optional(),
-  originalCount: import_zod2.z.number().int().nonnegative().optional()
+var DiagnosticNoteSchema = import_zod4.z.object({
+  path: import_zod4.z.string().max(4096),
+  reason: import_zod4.z.string().max(128),
+  originalBytes: import_zod4.z.number().int().nonnegative().optional(),
+  originalCount: import_zod4.z.number().int().nonnegative().optional()
 }).strict();
-var DiagnosticContentSchema = import_zod2.z.object({
-  schemaVersion: import_zod2.z.literal(1),
-  data: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()),
-  capture: import_zod2.z.object({
-    status: import_zod2.z.enum(["complete", "partial", "failed"]),
-    omissions: import_zod2.z.array(DiagnosticNoteSchema).max(1e4),
-    redactions: import_zod2.z.array(DiagnosticNoteSchema).max(1e4)
+var DiagnosticContentSchema = import_zod4.z.object({
+  schemaVersion: import_zod4.z.literal(1),
+  data: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()),
+  capture: import_zod4.z.object({
+    status: import_zod4.z.enum(["complete", "partial", "failed"]),
+    omissions: import_zod4.z.array(DiagnosticNoteSchema).max(1e4),
+    redactions: import_zod4.z.array(DiagnosticNoteSchema).max(1e4)
   }).strict()
 }).strict();
-var DiagnosticCorrelationSchema = import_zod2.z.object({
-  runId: import_zod2.z.string().optional(),
-  workflowId: import_zod2.z.string().optional(),
-  nodeId: import_zod2.z.string().optional(),
-  sessionId: import_zod2.z.string().optional(),
-  invocationId: import_zod2.z.string().optional(),
-  parentInvocationId: import_zod2.z.string().optional(),
-  branchId: import_zod2.z.string().optional(),
-  toolCallId: import_zod2.z.string().optional(),
-  attemptId: import_zod2.z.string().optional(),
-  workflowRevisionId: import_zod2.z.string().optional(),
-  traceId: import_zod2.z.string().optional(),
-  spanId: import_zod2.z.string().optional(),
-  parentSpanId: import_zod2.z.string().optional()
+var DiagnosticCorrelationSchema = import_zod4.z.object({
+  runId: import_zod4.z.string().optional(),
+  evaluationId: import_zod4.z.string().optional(),
+  suiteRunId: import_zod4.z.string().optional(),
+  caseId: import_zod4.z.string().optional(),
+  repetition: import_zod4.z.string().optional(),
+  phase: import_zod4.z.string().optional(),
+  workflowId: import_zod4.z.string().optional(),
+  nodeId: import_zod4.z.string().optional(),
+  sessionId: import_zod4.z.string().optional(),
+  invocationId: import_zod4.z.string().optional(),
+  parentInvocationId: import_zod4.z.string().optional(),
+  branchId: import_zod4.z.string().optional(),
+  toolCallId: import_zod4.z.string().optional(),
+  attemptId: import_zod4.z.string().optional(),
+  workflowRevisionId: import_zod4.z.string().optional(),
+  traceId: import_zod4.z.string().optional(),
+  spanId: import_zod4.z.string().optional(),
+  parentSpanId: import_zod4.z.string().optional()
 }).strict();
-var DiagnosticManifestSchema = import_zod2.z.object({
-  schemaVersion: import_zod2.z.literal(1),
-  diagnosticId: import_zod2.z.string().uuid(),
-  occurrenceId: import_zod2.z.string().uuid(),
-  occurredAt: import_zod2.z.string().datetime({ offset: true }),
-  environment: import_zod2.z.string().min(1).max(256),
-  service: import_zod2.z.object({
-    name: import_zod2.z.string().min(1).max(256),
-    deploymentRef: import_zod2.z.string().max(1024).optional()
+var DiagnosticManifestSchema = import_zod4.z.object({
+  schemaVersion: import_zod4.z.literal(1),
+  diagnosticId: import_zod4.z.string().uuid(),
+  occurrenceId: import_zod4.z.string().uuid(),
+  occurredAt: import_zod4.z.string().datetime({ offset: true }),
+  environment: import_zod4.z.string().min(1).max(256),
+  service: import_zod4.z.object({
+    name: import_zod4.z.string().min(1).max(256),
+    deploymentRef: import_zod4.z.string().max(1024).optional()
   }).strict(),
   correlation: DiagnosticCorrelationSchema,
-  handled: import_zod2.z.boolean(),
-  severity: import_zod2.z.enum(["warning", "error"]),
-  mechanism: import_zod2.z.enum(["span", "report", "tool"]),
-  summary: import_zod2.z.object({ type: import_zod2.z.string().max(256), message: import_zod2.z.string().max(8192) }).strict(),
-  captureStatus: import_zod2.z.enum(["complete", "partial", "failed"]),
-  checksum: import_zod2.z.string().regex(/^[a-f0-9]{64}$/),
-  byteLength: import_zod2.z.number().int().min(1).max(DIAGNOSTIC_LIMITS.bytes),
-  partCount: import_zod2.z.number().int().min(1).max(DIAGNOSTIC_LIMITS.parts)
+  handled: import_zod4.z.boolean(),
+  severity: import_zod4.z.enum(["warning", "error"]),
+  mechanism: import_zod4.z.enum(["span", "report", "tool"]),
+  summary: import_zod4.z.object({ type: import_zod4.z.string().max(256), message: import_zod4.z.string().max(8192) }).strict(),
+  captureStatus: import_zod4.z.enum(["complete", "partial", "failed"]),
+  checksum: import_zod4.z.string().regex(/^[a-f0-9]{64}$/),
+  byteLength: import_zod4.z.number().int().min(1).max(DIAGNOSTIC_LIMITS.bytes),
+  partCount: import_zod4.z.number().int().min(1).max(DIAGNOSTIC_LIMITS.parts)
 }).strict().superRefine((value, ctx) => {
   if (value.partCount !== Math.ceil(value.byteLength / DIAGNOSTIC_LIMITS.partBytes))
     ctx.addIssue({
@@ -270,23 +707,23 @@ var DiagnosticManifestSchema = import_zod2.z.object({
       message: "Part count does not match byte length."
     });
 });
-var DiagnosticPartSchema = import_zod2.z.object({
-  index: import_zod2.z.number().int().min(0).max(DIAGNOSTIC_LIMITS.parts - 1),
-  data: import_zod2.z.string().max(Math.ceil(DIAGNOSTIC_LIMITS.partBytes / 3) * 4).regex(
+var DiagnosticPartSchema = import_zod4.z.object({
+  index: import_zod4.z.number().int().min(0).max(DIAGNOSTIC_LIMITS.parts - 1),
+  data: import_zod4.z.string().max(Math.ceil(DIAGNOSTIC_LIMITS.partBytes / 3) * 4).regex(
     /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/
   )
 }).strict();
-var DiagnosticResponseSchema = import_zod2.z.object({
+var DiagnosticResponseSchema = import_zod4.z.object({
   manifest: DiagnosticManifestSchema,
-  state: import_zod2.z.enum(["pending", "available", "incomplete", "expired"]),
-  receivedParts: import_zod2.z.number().int().nonnegative(),
-  expiresAt: import_zod2.z.string().datetime({ offset: true }),
+  state: import_zod4.z.enum(["pending", "available", "incomplete", "expired"]),
+  receivedParts: import_zod4.z.number().int().nonnegative(),
+  expiresAt: import_zod4.z.string().datetime({ offset: true }),
   content: DiagnosticContentSchema.nullable(),
-  contentChecksum: import_zod2.z.string().regex(/^[a-f0-9]{64}$/).nullable(),
-  contentByteLength: import_zod2.z.number().int().nonnegative().nullable()
+  contentChecksum: import_zod4.z.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  contentByteLength: import_zod4.z.number().int().nonnegative().nullable()
 }).strict();
-var isPrivateDiagnosticField = (key) => /^(?:password|passwd|secret|clientsecret|privatekey|credential|credentials|authorization|proxyauthorization|bearer|bearertoken|jwt|token|accesstoken|refreshtoken|authtoken|apikey|xapikey|apitoken|xauthtoken|xaccesstoken|awsaccesskeyid|awssecretaccesskey|awssessiontoken|xamzsecuritytoken|apisecret|cookie|setcookie|resumehandle|resumetoken)$/.test(
-  key.toLowerCase().replace(/[^a-z0-9]/g, "")
+var isPrivateDiagnosticField = (key2) => /^(?:password|passwd|secret|clientsecret|privatekey|credential|credentials|authorization|proxyauthorization|bearer|bearertoken|jwt|token|accesstoken|refreshtoken|authtoken|apikey|xapikey|apitoken|xauthtoken|xaccesstoken|awsaccesskeyid|awssecretaccesskey|awssessiontoken|xamzsecuritytoken|apisecret|cookie|setcookie|resumehandle|resumetoken)$/.test(
+  key2.toLowerCase().replace(/[^a-z0-9]/g, "")
 );
 function redactDiagnosticText(value) {
   return value.replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, "Bearer [REDACTED]").replace(
@@ -357,17 +794,17 @@ function redactDiagnosticContent(content) {
           originalCount: keys.length
         });
       return Object.fromEntries(
-        keys.slice(0, DIAGNOSTIC_LIMITS.properties).map((key) => {
-          const nested = value[key];
-          if (isPrivateDiagnosticField(key)) {
+        keys.slice(0, DIAGNOSTIC_LIMITS.properties).map((key2) => {
+          const nested = value[key2];
+          if (isPrivateDiagnosticField(key2)) {
             if (redactions.length < 1e4 && nested !== "[REDACTED]")
               redactions.push({
-                path: `${path}/${key}`.slice(0, 4096),
+                path: `${path}/${key2}`.slice(0, 4096),
                 reason: "server_credential_field"
               });
-            return [key, "[REDACTED]"];
+            return [key2, "[REDACTED]"];
           }
-          return [key, visit(nested, `${path}/${key}`, depth + 1)];
+          return [key2, visit(nested, `${path}/${key2}`, depth + 1)];
         })
       );
     }
@@ -393,217 +830,512 @@ function redactDiagnosticContent(content) {
   };
 }
 
+// src/sample-project.ts
+var SAMPLE_PROJECT = {
+  id: "kortyx-sample",
+  name: "Sample project",
+  version: 5,
+  recordedAt: "2026-10-01T12:00:00.000Z",
+  referenceTime: "2026-10-01T12:10:00.000Z",
+  workflowId: "sample-support-assistant",
+  revisionId: "10000000-0000-4000-8000-000000000001",
+  runs: {
+    success: "sample-support-success",
+    failure: "sample-support-failure",
+    approval: "sample-support-approval",
+    followUp: "sample-support-follow-up",
+    baseline: "sample-support-baseline"
+  },
+  sessions: {
+    success: "sample-session-success",
+    failure: "sample-session-failure",
+    approval: "sample-session-approval",
+    followUp: "sample-session-success",
+    baseline: "sample-session-baseline"
+  },
+  specialistWorkflowIds: {
+    research: "sample-order-research",
+    resolution: "sample-order-resolution"
+  },
+  specialistRevisionIds: {
+    research: "10000000-0000-4000-8000-000000000020",
+    resolution: "10000000-0000-4000-8000-000000000021"
+  },
+  evaluationIds: {
+    baseline: "10000000-0000-4000-8000-000000000030",
+    candidate: "10000000-0000-4000-8000-000000000031",
+    latest: "10000000-0000-4000-8000-000000000003"
+  },
+  candidateEvalRunId: "10000000-0000-4000-8000-000000000032",
+  pendingApprovalId: "sample-pending-credit-review",
+  pendingChoiceId: "sample-pending-parcel-choice",
+  diagnosticIds: {
+    budgetLimit: "30000000-0000-4000-8000-e6dfcc9c117a"
+  },
+  interruptId: "sample-refund-approval",
+  promptId: "10000000-0000-4000-8000-000000000002",
+  evaluationId: "10000000-0000-4000-8000-000000000003",
+  evalRunId: "10000000-0000-4000-8000-000000000004",
+  baselineEvalRunId: "10000000-0000-4000-8000-000000000005",
+  caseId: "order-status",
+  gradingCaseId: "delivery-note",
+  targetId: "sample-support",
+  suiteId: "sample-support-quality",
+  anchors: {
+    selector: "sample-project-selector",
+    notice: "sample-project-notice",
+    visibility: "sample-project-visibility"
+  }
+};
+
 // src/tools.ts
-var import_zod3 = require("zod");
-var ToolOutcomeSchema = import_zod3.z.enum([
+var import_zod5 = require("zod");
+var ToolOutcomeSchema = import_zod5.z.enum([
   "success",
   "denied",
   "fault",
   "cancelled"
 ]);
-var ToolObservationSchema = import_zod3.z.object({
-  version: import_zod3.z.literal(1),
-  name: import_zod3.z.string().min(1).max(256),
-  toolCallId: import_zod3.z.string().min(1),
-  attemptId: import_zod3.z.string().min(1),
-  callingMode: import_zod3.z.enum(["direct", "model"]),
-  executed: import_zod3.z.boolean(),
+var ToolObservationSchema = import_zod5.z.object({
+  version: import_zod5.z.literal(1),
+  name: import_zod5.z.string().min(1).max(256),
+  toolCallId: import_zod5.z.string().min(1),
+  attemptId: import_zod5.z.string().min(1),
+  callingMode: import_zod5.z.enum(["direct", "model"]),
+  executed: import_zod5.z.boolean(),
   outcome: ToolOutcomeSchema.optional(),
-  denialCode: import_zod3.z.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/).optional(),
-  errorType: import_zod3.z.string().max(256).optional(),
-  errorMessage: import_zod3.z.string().max(8192).optional(),
-  diagnosticId: import_zod3.z.string().uuid().optional(),
-  durationMs: import_zod3.z.number().finite().nonnegative().optional(),
-  workflowId: import_zod3.z.string().optional(),
-  nodeId: import_zod3.z.string().optional(),
-  workflowRevisionId: import_zod3.z.string().optional(),
-  runId: import_zod3.z.string().optional(),
-  invocationId: import_zod3.z.string().optional(),
-  parentInvocationId: import_zod3.z.string().optional(),
-  branchId: import_zod3.z.string().optional(),
-  observationKind: import_zod3.z.enum(["reused", "waiting"]).optional(),
-  suspended: import_zod3.z.boolean().optional(),
-  source: import_zod3.z.object({
-    runId: import_zod3.z.string().optional(),
-    invocationId: import_zod3.z.string().optional(),
-    branchId: import_zod3.z.string().optional(),
-    toolCallId: import_zod3.z.string(),
-    attemptId: import_zod3.z.string()
+  denialCode: import_zod5.z.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/).optional(),
+  errorType: import_zod5.z.string().max(256).optional(),
+  errorMessage: import_zod5.z.string().max(8192).optional(),
+  diagnosticId: import_zod5.z.string().uuid().optional(),
+  durationMs: import_zod5.z.number().finite().nonnegative().optional(),
+  workflowId: import_zod5.z.string().optional(),
+  nodeId: import_zod5.z.string().optional(),
+  workflowRevisionId: import_zod5.z.string().optional(),
+  runId: import_zod5.z.string().optional(),
+  invocationId: import_zod5.z.string().optional(),
+  parentInvocationId: import_zod5.z.string().optional(),
+  branchId: import_zod5.z.string().optional(),
+  observationKind: import_zod5.z.enum(["reused", "waiting"]).optional(),
+  suspended: import_zod5.z.boolean().optional(),
+  source: import_zod5.z.object({
+    runId: import_zod5.z.string().optional(),
+    invocationId: import_zod5.z.string().optional(),
+    branchId: import_zod5.z.string().optional(),
+    toolCallId: import_zod5.z.string(),
+    attemptId: import_zod5.z.string()
   }).strict().optional()
 });
-var WorkflowToolSchema = import_zod3.z.object({
-  name: import_zod3.z.string().min(1).max(256),
-  description: import_zod3.z.string().max(4096).optional(),
-  callingMode: import_zod3.z.enum(["direct", "model"]),
-  provenance: import_zod3.z.enum(["source", "observed"]),
-  inputFields: import_zod3.z.array(
-    import_zod3.z.object({ name: import_zod3.z.string(), type: import_zod3.z.string(), required: import_zod3.z.boolean() }).strict()
+var WorkflowToolSchema = import_zod5.z.object({
+  name: import_zod5.z.string().min(1).max(256),
+  description: import_zod5.z.string().max(4096).optional(),
+  callingMode: import_zod5.z.enum(["direct", "model"]),
+  provenance: import_zod5.z.enum(["source", "observed"]),
+  inputFields: import_zod5.z.array(
+    import_zod5.z.object({ name: import_zod5.z.string(), type: import_zod5.z.string(), required: import_zod5.z.boolean() }).strict()
   ).optional()
 }).strict();
-var ToolDiscoverySchema = import_zod3.z.object({
-  status: import_zod3.z.enum(["complete", "unresolved"]),
-  publishedAt: import_zod3.z.string().datetime().optional(),
-  warnings: import_zod3.z.array(import_zod3.z.string()).optional()
+var ToolDiscoverySchema = import_zod5.z.object({
+  status: import_zod5.z.enum(["complete", "unresolved"]),
+  publishedAt: import_zod5.z.string().datetime().optional(),
+  warnings: import_zod5.z.array(import_zod5.z.string()).optional()
 }).strict();
 var StudioToolSchema = WorkflowToolSchema.extend({
-  callingMode: import_zod3.z.enum(["direct", "model", "unknown"]),
-  calls: import_zod3.z.number().nonnegative(),
-  replays: import_zod3.z.number().nonnegative(),
-  successes: import_zod3.z.number().nonnegative(),
-  denials: import_zod3.z.number().nonnegative(),
-  faults: import_zod3.z.number().nonnegative(),
-  cancellations: import_zod3.z.number().nonnegative(),
-  p50DurationMs: import_zod3.z.number().nonnegative().nullable(),
-  p95DurationMs: import_zod3.z.number().nonnegative().nullable()
+  callingMode: import_zod5.z.enum(["direct", "model", "unknown"]),
+  calls: import_zod5.z.number().nonnegative(),
+  replays: import_zod5.z.number().nonnegative(),
+  successes: import_zod5.z.number().nonnegative(),
+  denials: import_zod5.z.number().nonnegative(),
+  faults: import_zod5.z.number().nonnegative(),
+  cancellations: import_zod5.z.number().nonnegative(),
+  p50DurationMs: import_zod5.z.number().nonnegative().nullable(),
+  p95DurationMs: import_zod5.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 key2 of ["name", "message"]) {
+    let cursor = object;
+    while (cursor) {
+      const descriptor = Object.getOwnPropertyDescriptor(cursor, key2);
+      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 = (key2) => key2.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 key2 of keys.slice(0, DIAGNOSTIC_LIMITS.properties)) {
+        if (["__proto__", "constructor", "prototype"].includes(key2)) {
+          result[key2] = omit(`${path}/${pointer(key2)}`, "unsafe_key");
+          continue;
+        }
+        remaining -= encoder.encode(key2).length + 4;
+        result[key2] = read(object, key2, `${path}/${pointer(key2)}`, 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, key2, path, depth) => {
+    if (isPrivateDiagnosticField(key2)) {
+      if (redactions.length < 1e3)
+        redactions.push({
+          path: path.slice(0, 4096),
+          reason: "credential_field"
+        });
+      return "[REDACTED]";
+    }
+    try {
+      const property = Object.getOwnPropertyDescriptor(object, key2);
+      if (property && "value" in property)
+        return visit(property.value, path, depth + 1);
+      if (key2 === "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");
-var name = import_zod4.z.string().trim().min(1).max(200);
-var version = import_zod4.z.number().int().positive();
-var revision = import_zod4.z.number().int().nonnegative();
-var PromptCategorySchema = import_zod4.z.object({
-  id: import_zod4.z.uuid(),
+var import_zod6 = require("zod");
+var name = import_zod6.z.string().trim().min(1).max(200);
+var version = import_zod6.z.number().int().positive();
+var revision = import_zod6.z.number().int().nonnegative();
+var PromptCategorySchema = import_zod6.z.object({
+  id: import_zod6.z.uuid(),
   name,
-  parentId: import_zod4.z.uuid().nullable(),
+  parentId: import_zod6.z.uuid().nullable(),
   revision
 });
-var PromptGroupSchema = import_zod4.z.object({
-  id: import_zod4.z.uuid(),
+var PromptGroupSchema = import_zod6.z.object({
+  id: import_zod6.z.uuid(),
   name,
   revision,
-  members: import_zod4.z.array(
-    import_zod4.z.object({
-      promptId: import_zod4.z.uuid(),
+  members: import_zod6.z.array(
+    import_zod6.z.object({
+      promptId: import_zod6.z.uuid(),
       version,
       key: import_browser.PromptKeySchema.optional(),
       name: name.optional(),
-      archived: import_zod4.z.boolean().optional()
+      archived: import_zod6.z.boolean().optional()
     })
   ).max(100),
-  updatedAt: import_zod4.z.string()
+  updatedAt: import_zod6.z.string()
 });
-var PromptAssignmentSchema = import_zod4.z.object({
+var PromptAssignmentSchema = import_zod6.z.object({
   tag: import_browser.PromptTagSchema,
   version,
   revision,
-  updatedAt: import_zod4.z.string()
+  updatedAt: import_zod6.z.string()
 });
-var PromptAssetSchema = import_zod4.z.object({
-  id: import_zod4.z.uuid(),
+var PromptAssetSchema = import_zod6.z.object({
+  id: import_zod6.z.uuid(),
   key: import_browser.PromptKeySchema,
   name,
-  categoryId: import_zod4.z.uuid().nullable(),
+  categoryId: import_zod6.z.uuid().nullable(),
   latestVersion: version,
   revision,
-  archived: import_zod4.z.boolean(),
-  updatedAt: import_zod4.z.string(),
-  assignments: import_zod4.z.array(PromptAssignmentSchema)
+  archived: import_zod6.z.boolean(),
+  updatedAt: import_zod6.z.string(),
+  assignments: import_zod6.z.array(PromptAssignmentSchema)
 });
-var PromptLibrarySchema = import_zod4.z.object({
-  schemaVersion: import_zod4.z.literal(1),
-  assets: import_zod4.z.array(PromptAssetSchema),
-  categories: import_zod4.z.array(PromptCategorySchema),
-  groups: import_zod4.z.array(PromptGroupSchema),
-  totalCount: import_zod4.z.number().int().nonnegative(),
-  nextCursor: import_zod4.z.string().nullable(),
-  permissions: import_zod4.z.object({
-    edit: import_zod4.z.boolean(),
-    promote: import_zod4.z.boolean(),
-    review: import_zod4.z.boolean(),
-    settings: import_zod4.z.boolean()
+var PromptLibrarySchema = import_zod6.z.object({
+  schemaVersion: import_zod6.z.literal(1),
+  assets: import_zod6.z.array(PromptAssetSchema),
+  categories: import_zod6.z.array(PromptCategorySchema),
+  groups: import_zod6.z.array(PromptGroupSchema),
+  totalCount: import_zod6.z.number().int().nonnegative(),
+  nextCursor: import_zod6.z.string().nullable(),
+  permissions: import_zod6.z.object({
+    edit: import_zod6.z.boolean(),
+    promote: import_zod6.z.boolean(),
+    review: import_zod6.z.boolean(),
+    settings: import_zod6.z.boolean()
   })
 });
 var PromptStoredVersionSchema = import_browser.PromptVersionSchema.extend({
-  promptId: import_zod4.z.uuid(),
-  note: import_zod4.z.string(),
-  author: import_zod4.z.string(),
-  createdAt: import_zod4.z.string(),
-  origin: import_zod4.z.object({
-    apiUrl: import_zod4.z.string(),
-    projectId: import_zod4.z.string(),
-    key: import_zod4.z.string(),
+  promptId: import_zod6.z.uuid(),
+  note: import_zod6.z.string(),
+  author: import_zod6.z.string(),
+  createdAt: import_zod6.z.string(),
+  origin: import_zod6.z.object({
+    apiUrl: import_zod6.z.string(),
+    projectId: import_zod6.z.string(),
+    key: import_zod6.z.string(),
     version,
-    hash: import_zod4.z.string()
+    hash: import_zod6.z.string()
   }).nullable()
 });
-var PromptPolicySchema = import_zod4.z.object({
+var PromptPolicySchema = import_zod6.z.object({
   revision,
-  requireTest: import_zod4.z.boolean(),
-  requireChangeNote: import_zod4.z.boolean().default(false),
-  requiredSuites: import_zod4.z.array(import_zod4.z.object({ targetId: name, suiteId: name })).max(100),
-  requiredReviews: import_zod4.z.number().int().min(0).max(10),
-  allowException: import_zod4.z.boolean()
+  requireTest: import_zod6.z.boolean(),
+  requireChangeNote: import_zod6.z.boolean().default(false),
+  requiredSuites: import_zod6.z.array(import_zod6.z.object({ targetId: name, suiteId: name })).max(100),
+  requiredReviews: import_zod6.z.number().int().min(0).max(10),
+  allowException: import_zod6.z.boolean()
 });
-var PromptEvidenceSchema = import_zod4.z.object({
-  environment: import_zod4.z.string(),
-  runId: import_zod4.z.string(),
-  evaluationId: import_zod4.z.string().nullable().optional(),
-  targetId: import_zod4.z.string(),
-  suiteId: import_zod4.z.string(),
-  suiteRevision: import_zod4.z.string().optional(),
-  status: import_zod4.z.string(),
+var PromptEvidenceSchema = import_zod6.z.object({
+  environment: import_zod6.z.string(),
+  runId: import_zod6.z.string(),
+  evaluationId: import_zod6.z.string().nullable().optional(),
+  targetId: import_zod6.z.string(),
+  suiteId: import_zod6.z.string(),
+  suiteRevision: import_zod6.z.string().optional(),
+  status: import_zod6.z.string(),
   version,
-  fullSuite: import_zod4.z.boolean(),
-  usage: import_zod4.z.enum([
+  fullSuite: import_zod6.z.boolean(),
+  usage: import_zod6.z.enum([
     "verified",
     "pending",
     "not-used",
     "mismatch",
     "context-differs"
   ]),
-  groupName: import_zod4.z.string().nullable(),
-  createdAt: import_zod4.z.string(),
-  companions: import_zod4.z.array(import_zod4.z.object({ key: import_browser.PromptKeySchema, version }))
+  groupName: import_zod6.z.string().nullable(),
+  createdAt: import_zod6.z.string(),
+  companions: import_zod6.z.array(import_zod6.z.object({ key: import_browser.PromptKeySchema, version }))
 });
-var PromptUsageSchema = import_zod4.z.object({
-  eventId: import_zod4.z.string(),
-  runId: import_zod4.z.string(),
-  sessionId: import_zod4.z.string().nullable(),
-  nodeId: import_zod4.z.string().nullable(),
-  version: import_zod4.z.number().int(),
-  hash: import_zod4.z.string().nullable(),
-  source: import_zod4.z.string().nullable(),
-  model: import_zod4.z.string().nullable(),
-  environment: import_zod4.z.string(),
-  occurredAt: import_zod4.z.string(),
-  captured: import_zod4.z.boolean()
+var PromptUsageSchema = import_zod6.z.object({
+  eventId: import_zod6.z.string(),
+  runId: import_zod6.z.string(),
+  sessionId: import_zod6.z.string().nullable(),
+  nodeId: import_zod6.z.string().nullable(),
+  version: import_zod6.z.number().int(),
+  hash: import_zod6.z.string().nullable(),
+  source: import_zod6.z.string().nullable(),
+  model: import_zod6.z.string().nullable(),
+  environment: import_zod6.z.string(),
+  occurredAt: import_zod6.z.string(),
+  captured: import_zod6.z.boolean()
 });
-var PromptDetailSchema = import_zod4.z.object({
+var PromptDetailSchema = import_zod6.z.object({
   asset: PromptAssetSchema,
-  versions: import_zod4.z.array(PromptStoredVersionSchema),
-  versionsNextCursor: import_zod4.z.string().nullable().optional(),
+  versions: import_zod6.z.array(PromptStoredVersionSchema),
+  versionsNextCursor: import_zod6.z.string().nullable().optional(),
   draft: import_browser.PromptContentSchema.nullable(),
-  draftBase: import_zod4.z.number().int().nullable(),
+  draftBase: import_zod6.z.number().int().nullable(),
   draftRevision: revision,
-  evidence: import_zod4.z.array(PromptEvidenceSchema),
-  usage: import_zod4.z.array(PromptUsageSchema),
-  activity: import_zod4.z.array(
-    import_zod4.z.object({
-      id: import_zod4.z.string(),
-      action: import_zod4.z.string(),
-      actor: import_zod4.z.string(),
-      details: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()),
-      createdAt: import_zod4.z.string()
+  evidence: import_zod6.z.array(PromptEvidenceSchema),
+  usage: import_zod6.z.array(PromptUsageSchema),
+  activity: import_zod6.z.array(
+    import_zod6.z.object({
+      id: import_zod6.z.string(),
+      action: import_zod6.z.string(),
+      actor: import_zod6.z.string(),
+      details: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()),
+      createdAt: import_zod6.z.string()
     })
   ),
-  policies: import_zod4.z.array(PromptPolicySchema),
-  reviews: import_zod4.z.array(
-    import_zod4.z.object({
+  policies: import_zod6.z.array(PromptPolicySchema),
+  reviews: import_zod6.z.array(
+    import_zod6.z.object({
       version,
-      hash: import_zod4.z.string(),
-      independent: import_zod4.z.boolean(),
-      reviewer: import_zod4.z.string(),
-      note: import_zod4.z.string(),
-      createdAt: import_zod4.z.string()
+      hash: import_zod6.z.string(),
+      independent: import_zod6.z.boolean(),
+      reviewer: import_zod6.z.string(),
+      note: import_zod6.z.string(),
+      createdAt: import_zod6.z.string()
     })
   ).optional()
 });
-var PromptMutationSchema = import_zod4.z.discriminatedUnion("action", [
-  import_zod4.z.object({
-    action: import_zod4.z.literal("tag-set"),
-    id: import_zod4.z.uuid(),
+var PromptMutationSchema = import_zod6.z.discriminatedUnion("action", [
+  import_zod6.z.object({
+    action: import_zod6.z.literal("tag-set"),
+    id: import_zod6.z.uuid(),
     tag: import_browser.PromptTagSchema.refine(
       (tag) => tag !== "live",
       "Use promotion to update live."
@@ -611,183 +1343,183 @@ var PromptMutationSchema = import_zod4.z.discriminatedUnion("action", [
     version,
     expectedRevision: revision
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("tag-remove"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("tag-remove"),
+    id: import_zod6.z.uuid(),
     tag: import_browser.PromptTagSchema.refine(
       (tag) => tag !== "live",
       "The live tag cannot be removed manually."
     ),
     expectedRevision: revision
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("bulk-update"),
-    assets: import_zod4.z.array(import_zod4.z.object({ id: import_zod4.z.uuid(), expectedRevision: revision })).min(1).max(100),
-    categoryId: import_zod4.z.uuid().nullable().optional(),
-    archived: import_zod4.z.boolean().optional()
+  import_zod6.z.object({
+    action: import_zod6.z.literal("bulk-update"),
+    assets: import_zod6.z.array(import_zod6.z.object({ id: import_zod6.z.uuid(), expectedRevision: revision })).min(1).max(100),
+    categoryId: import_zod6.z.uuid().nullable().optional(),
+    archived: import_zod6.z.boolean().optional()
   }).strict().refine(
     (value) => value.categoryId !== void 0 || value.archived !== void 0,
     "Choose a category or archive state."
   ),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("create"),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("create"),
     key: import_browser.PromptKeySchema,
     name,
-    categoryId: import_zod4.z.uuid().nullable().default(null),
+    categoryId: import_zod6.z.uuid().nullable().default(null),
     content: import_browser.PromptContentSchema,
-    note: import_zod4.z.string().trim().max(2e3).default(""),
-    idempotencyKey: import_zod4.z.uuid().optional()
+    note: import_zod6.z.string().trim().max(2e3).default(""),
+    idempotencyKey: import_zod6.z.uuid().optional()
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("draft"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("draft"),
+    id: import_zod6.z.uuid(),
     content: import_browser.PromptContentSchema,
     baseVersion: version,
     expectedRevision: revision
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("discard-draft"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("discard-draft"),
+    id: import_zod6.z.uuid(),
     expectedRevision: revision
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("save"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("save"),
+    id: import_zod6.z.uuid(),
     content: import_browser.PromptContentSchema,
     baseVersion: version,
-    expectedHash: import_zod4.z.string().regex(/^[a-f0-9]{64}$/),
+    expectedHash: import_zod6.z.string().regex(/^[a-f0-9]{64}$/),
     expectedDraftRevision: revision.optional(),
-    note: import_zod4.z.string().trim().max(2e3).default(""),
-    idempotencyKey: import_zod4.z.uuid()
+    note: import_zod6.z.string().trim().max(2e3).default(""),
+    idempotencyKey: import_zod6.z.uuid()
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("update"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("update"),
+    id: import_zod6.z.uuid(),
     expectedRevision: revision,
     name: name.optional(),
-    categoryId: import_zod4.z.uuid().nullable().optional(),
-    archived: import_zod4.z.boolean().optional()
+    categoryId: import_zod6.z.uuid().nullable().optional(),
+    archived: import_zod6.z.boolean().optional()
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("category-create"),
-    path: import_zod4.z.string().trim().min(1).max(1e3)
+  import_zod6.z.object({
+    action: import_zod6.z.literal("category-create"),
+    path: import_zod6.z.string().trim().min(1).max(1e3)
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("category-update"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("category-update"),
+    id: import_zod6.z.uuid(),
     expectedRevision: revision,
     name: name.optional(),
-    parentId: import_zod4.z.uuid().nullable().optional()
+    parentId: import_zod6.z.uuid().nullable().optional()
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("category-delete"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("category-delete"),
+    id: import_zod6.z.uuid(),
     expectedRevision: revision,
-    destinationId: import_zod4.z.uuid().nullable()
+    destinationId: import_zod6.z.uuid().nullable()
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("group-create"),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("group-create"),
     name,
-    members: import_zod4.z.array(import_zod4.z.object({ promptId: import_zod4.z.uuid(), version })).max(100).optional()
+    members: import_zod6.z.array(import_zod6.z.object({ promptId: import_zod6.z.uuid(), version })).max(100).optional()
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("group-update"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("group-update"),
+    id: import_zod6.z.uuid(),
     expectedRevision: revision,
     name: name.optional(),
-    members: import_zod4.z.array(import_zod4.z.object({ promptId: import_zod4.z.uuid(), version })).max(100).optional()
+    members: import_zod6.z.array(import_zod6.z.object({ promptId: import_zod6.z.uuid(), version })).max(100).optional()
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("group-delete"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("group-delete"),
+    id: import_zod6.z.uuid(),
     expectedRevision: revision
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("promote"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("promote"),
+    id: import_zod6.z.uuid(),
     version,
     expectedRevision: revision,
-    exceptionReason: import_zod4.z.string().trim().min(1).max(2e3).optional(),
-    rollback: import_zod4.z.boolean().default(false)
+    exceptionReason: import_zod6.z.string().trim().min(1).max(2e3).optional(),
+    rollback: import_zod6.z.boolean().default(false)
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("review"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("review"),
+    id: import_zod6.z.uuid(),
     version,
-    note: import_zod4.z.string().trim().min(1).max(2e3)
+    note: import_zod6.z.string().trim().min(1).max(2e3)
   }).strict(),
-  import_zod4.z.object({
-    action: import_zod4.z.literal("policy"),
-    id: import_zod4.z.uuid(),
+  import_zod6.z.object({
+    action: import_zod6.z.literal("policy"),
+    id: import_zod6.z.uuid(),
     policy: PromptPolicySchema
   }).strict()
 ]);
-var PromptSelectionSchema = import_zod4.z.discriminatedUnion("type", [
-  import_zod4.z.object({ type: import_zod4.z.literal("live") }).strict(),
-  import_zod4.z.object({
-    type: import_zod4.z.literal("single"),
-    id: import_zod4.z.string().min(1),
-    version: import_zod4.z.number().int().positive()
+var PromptSelectionSchema = import_zod6.z.discriminatedUnion("type", [
+  import_zod6.z.object({ type: import_zod6.z.literal("live") }).strict(),
+  import_zod6.z.object({
+    type: import_zod6.z.literal("single"),
+    id: import_zod6.z.string().min(1),
+    version: import_zod6.z.number().int().positive()
   }).strict(),
-  import_zod4.z.object({ type: import_zod4.z.literal("group"), groupId: import_zod4.z.uuid() }).strict()
+  import_zod6.z.object({ type: import_zod6.z.literal("group"), groupId: import_zod6.z.uuid() }).strict()
 ]);
-var PromptBundleSchema = import_zod4.z.object({
-  schemaVersion: import_zod4.z.literal(1),
-  origin: import_zod4.z.object({
-    apiUrl: import_zod4.z.url().refine((value) => {
+var PromptBundleSchema = import_zod6.z.object({
+  schemaVersion: import_zod6.z.literal(1),
+  origin: import_zod6.z.object({
+    apiUrl: import_zod6.z.url().refine((value) => {
       const url = new URL(value);
       return /^https?:$/.test(url.protocol) && !url.username && !url.password && !url.search;
     }),
-    projectId: import_zod4.z.string().min(1)
+    projectId: import_zod6.z.string().min(1)
   }).strict(),
-  prompts: import_zod4.z.array(
-    import_zod4.z.object({
+  prompts: import_zod6.z.array(
+    import_zod6.z.object({
       key: import_browser.PromptKeySchema,
       name,
-      categoryPath: import_zod4.z.string().optional(),
-      versions: import_zod4.z.array(import_browser.PromptVersionSchema.extend({ note: import_zod4.z.string().max(2e3) })).min(1).max(200)
+      categoryPath: import_zod6.z.string().optional(),
+      versions: import_zod6.z.array(import_browser.PromptVersionSchema.extend({ note: import_zod6.z.string().max(2e3) })).min(1).max(200)
     }).strict()
   ).min(1).max(200),
-  groups: import_zod4.z.array(
-    import_zod4.z.object({
+  groups: import_zod6.z.array(
+    import_zod6.z.object({
       name,
-      members: import_zod4.z.array(import_zod4.z.object({ key: import_browser.PromptKeySchema, version })).max(100)
+      members: import_zod6.z.array(import_zod6.z.object({ key: import_browser.PromptKeySchema, version })).max(100)
     }).strict()
   ).max(100).default([])
 }).strict();
-var PromptTransferRequestSchema = import_zod4.z.object({
+var PromptTransferRequestSchema = import_zod6.z.object({
   bundle: PromptBundleSchema,
-  conflicts: import_zod4.z.enum(["error", "append"]).default("error"),
-  rename: import_zod4.z.record(import_browser.PromptKeySchema, import_browser.PromptKeySchema).default({}),
-  categories: import_zod4.z.boolean().default(true),
-  groups: import_zod4.z.boolean().default(false)
+  conflicts: import_zod6.z.enum(["error", "append"]).default("error"),
+  rename: import_zod6.z.record(import_browser.PromptKeySchema, import_browser.PromptKeySchema).default({}),
+  categories: import_zod6.z.boolean().default(true),
+  groups: import_zod6.z.boolean().default(false)
 }).strict();
 
 // src/studio-updates.ts
-var import_zod5 = require("zod");
-var StudioReleaseVersionSchema = import_zod5.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
-var StudioReleaseDeploymentSchema = import_zod5.z.object({
-  strategy: import_zod5.z.enum(["rolling", "recreate"])
+var import_zod7 = require("zod");
+var StudioReleaseVersionSchema = import_zod7.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
+var StudioReleaseDeploymentSchema = import_zod7.z.object({
+  strategy: import_zod7.z.enum(["rolling", "recreate"])
 });
-var StudioReleaseSchema = import_zod5.z.object({
-  format: import_zod5.z.literal(1),
-  installer: import_zod5.z.literal(1),
+var StudioReleaseSchema = import_zod7.z.object({
+  format: import_zod7.z.literal(1),
+  installer: import_zod7.z.literal(1),
   version: StudioReleaseVersionSchema,
-  api: import_zod5.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-api@sha256:[a-f0-9]{64}$/),
-  studio: import_zod5.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-studio@sha256:[a-f0-9]{64}$/),
+  api: import_zod7.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-api@sha256:[a-f0-9]{64}$/),
+  studio: import_zod7.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-studio@sha256:[a-f0-9]{64}$/),
   deployment: StudioReleaseDeploymentSchema.default({
     strategy: "recreate"
   })
 });
-var StudioUpdateSettingsSchema = import_zod5.z.object({
-  automatic: import_zod5.z.boolean(),
-  hourUtc: import_zod5.z.number().int().min(0).max(23)
+var StudioUpdateSettingsSchema = import_zod7.z.object({
+  automatic: import_zod7.z.boolean(),
+  hourUtc: import_zod7.z.number().int().min(0).max(23)
 });
-var StudioUpdateOperationSchema = import_zod5.z.object({
-  id: import_zod5.z.uuid(),
-  from: import_zod5.z.string(),
+var StudioUpdateOperationSchema = import_zod7.z.object({
+  id: import_zod7.z.uuid(),
+  from: import_zod7.z.string(),
   release: StudioReleaseSchema,
-  phase: import_zod5.z.enum([
+  phase: import_zod7.z.enum([
     "starting",
     "pulling",
     "backup",
@@ -796,16 +1528,16 @@ var StudioUpdateOperationSchema = import_zod5.z.object({
     "succeeded",
     "failed"
   ]),
-  startedAt: import_zod5.z.iso.datetime(),
-  updatedAt: import_zod5.z.iso.datetime(),
-  backup: import_zod5.z.string().nullable(),
-  messages: import_zod5.z.array(import_zod5.z.string()).max(100)
+  startedAt: import_zod7.z.iso.datetime(),
+  updatedAt: import_zod7.z.iso.datetime(),
+  backup: import_zod7.z.string().nullable(),
+  messages: import_zod7.z.array(import_zod7.z.string()).max(100)
 });
-var StudioUpdateStatusSchema = import_zod5.z.object({
-  current: import_zod5.z.string().nullable(),
+var StudioUpdateStatusSchema = import_zod7.z.object({
+  current: import_zod7.z.string().nullable(),
   available: StudioReleaseSchema.nullable(),
-  checkedAt: import_zod5.z.iso.datetime().nullable(),
-  checkError: import_zod5.z.string().nullable(),
+  checkedAt: import_zod7.z.iso.datetime().nullable(),
+  checkError: import_zod7.z.string().nullable(),
   settings: StudioUpdateSettingsSchema,
   operation: StudioUpdateOperationSchema.nullable()
 });
@@ -828,10 +1560,10 @@ function projectWorkflowCalls(events) {
   for (const event of events) {
     if (!event.type.startsWith("workflow.call.") || !str(event.payload.invocationId) || !str(event.payload.targetWorkflowId))
       continue;
-    const key = `${event.runId}:${str(event.payload.branchId, event.runId)}:${event.payload.invocationId}`;
-    const group = groups.get(key) ?? [];
+    const key2 = `${event.runId}:${str(event.payload.branchId, event.runId)}:${event.payload.invocationId}`;
+    const group = groups.get(key2) ?? [];
     if (!group.some((existing) => existing.id === event.id)) group.push(event);
-    groups.set(key, group);
+    groups.set(key2, group);
   }
   return [...groups.entries()].map(([id, group]) => {
     group.sort(
@@ -960,82 +1692,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_zod8.z.object({
+  name: import_zod8.z.string().min(1),
+  deploymentRef: import_zod8.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_zod8.z.object({
+  id: import_zod8.z.string().min(1),
+  label: import_zod8.z.string().optional(),
+  type: import_zod8.z.string().optional(),
+  provider: import_zod8.z.string().optional(),
+  model: import_zod8.z.string().optional(),
+  metadata: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).optional(),
+  tools: import_zod8.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_zod8.z.object({
+  sourceNodeId: import_zod8.z.string().min(1),
+  targetNodeId: import_zod8.z.string().min(1),
+  condition: import_zod8.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_zod8.z.object({
+  sourceNodeId: import_zod8.z.string().min(1),
+  targetWorkflowId: import_zod8.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_zod8.z.object({
+  sourceNodeId: import_zod8.z.string().min(1).optional(),
+  targetWorkflowId: import_zod8.z.string().min(1),
+  condition: import_zod8.z.string().optional(),
+  intent: import_zod8.z.string().optional(),
+  kind: import_zod8.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_zod8.z.object({
+  schemaVersion: import_zod8.z.literal(1),
+  environment: import_zod8.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_zod8.z.object({
+    id: import_zod8.z.string().min(1),
+    declaredVersion: import_zod8.z.string().min(1),
+    description: import_zod8.z.string().optional(),
+    tags: import_zod8.z.array(import_zod8.z.string()).optional(),
+    topologyHash: import_zod8.z.string().regex(/^[a-f0-9]{64}$/),
+    nodes: import_zod8.z.array(WorkflowTopologyNodeSchema),
+    edges: import_zod8.z.array(WorkflowTopologyEdgeSchema),
+    transitions: import_zod8.z.array(WorkflowTopologyTransitionSchema).optional(),
+    calls: import_zod8.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_zod8.z.object({ workflowRevisionId: import_zod8.z.string().min(1), created: import_zod8.z.boolean() }).strict();
+var TelemetryEventTypeSchema = import_zod8.z.enum(TELEMETRY_EVENT_TYPES);
+var TelemetryEventSchema = import_zod8.z.object({
+  schemaVersion: import_zod8.z.literal(1),
+  eventId: import_zod8.z.string().min(1),
+  occurredAt: import_zod8.z.string().datetime({ offset: true }),
+  environment: import_zod8.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_zod8.z.object({
+    invocationId: import_zod8.z.string().optional(),
+    parentInvocationId: import_zod8.z.string().optional(),
+    branchId: import_zod8.z.string().optional(),
+    traceId: import_zod8.z.string().optional(),
+    spanId: import_zod8.z.string().optional(),
+    parentSpanId: import_zod8.z.string().optional(),
+    runId: import_zod8.z.string().min(1),
+    sessionId: import_zod8.z.string().optional(),
+    workflowId: import_zod8.z.string().min(1),
+    workflowRevisionId: import_zod8.z.string().optional(),
+    topologyHash: import_zod8.z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    nodeId: import_zod8.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_zod8.z.object({
+    userId: import_zod8.z.string().optional(),
+    tenantId: import_zod8.z.string().optional(),
+    tags: import_zod8.z.array(import_zod8.z.string()).optional(),
+    metadata: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).optional()
   }).strict().optional(),
   type: TelemetryEventTypeSchema,
-  payload: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown())
+  payload: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown())
 }).strict().superRefine((event, ctx) => {
   if (!event.type.startsWith("tool.")) return;
   const canonical = event.payload.version === 1 || [
@@ -1078,20 +1810,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_zod8.z.object({ events: import_zod8.z.array(TelemetryEventSchema).min(1) }).strict();
+var TelemetryEventBatchResponseSchema = import_zod8.z.object({
+  accepted: import_zod8.z.number().int().nonnegative(),
+  inserted: import_zod8.z.number().int().nonnegative(),
+  duplicates: import_zod8.z.number().int().nonnegative()
 }).strict();
-var TelemetryPricingSourceSchema = import_zod6.z.enum([
+var TelemetryPricingSourceSchema = import_zod8.z.enum([
   "sdk",
   "provider",
   "custom",
   "project-rate-card",
   "default-rate-card"
 ]);
-var TelemetryPricingUnitSchema = import_zod6.z.enum([
+var TelemetryPricingUnitSchema = import_zod8.z.enum([
   "token",
   "character",
   "request",
@@ -1104,7 +1836,7 @@ var TelemetryPricingUnitSchema = import_zod6.z.enum([
   "minute",
   "custom"
 ]);
-var TelemetryPricingUsageTypeSchema = import_zod6.z.enum([
+var TelemetryPricingUsageTypeSchema = import_zod8.z.enum([
   "input",
   "output",
   "reasoning",
@@ -1120,42 +1852,42 @@ var TelemetryPricingUsageTypeSchema = import_zod6.z.enum([
   "request",
   "custom"
 ]);
-var TelemetryUsageItemSchema = import_zod6.z.object({
+var TelemetryUsageItemSchema = import_zod8.z.object({
   usageType: TelemetryPricingUsageTypeSchema,
-  quantity: import_zod6.z.number().nonnegative(),
+  quantity: import_zod8.z.number().nonnegative(),
   unit: TelemetryPricingUnitSchema,
-  label: import_zod6.z.string().optional()
+  label: import_zod8.z.string().optional()
 }).strict();
-var TelemetryUnitPriceSchema = import_zod6.z.object({
+var TelemetryUnitPriceSchema = import_zod8.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_zod8.z.number().positive().default(1),
+  priceMicros: import_zod8.z.number().int().nonnegative(),
+  label: import_zod8.z.string().optional()
 }).strict();
-var TelemetryPricingLineItemSchema = import_zod6.z.object({
+var TelemetryPricingLineItemSchema = import_zod8.z.object({
   usageType: TelemetryPricingUsageTypeSchema,
-  quantity: import_zod6.z.number().nonnegative(),
+  quantity: import_zod8.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_zod8.z.number().positive().default(1),
+  unitPriceMicros: import_zod8.z.number().int().nonnegative().optional(),
+  totalCostMicros: import_zod8.z.number().int().nonnegative().optional(),
+  label: import_zod8.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_zod8.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_zod8.z.string().min(3).max(12).default("USD"),
+  actualCostMicros: import_zod8.z.number().int().nonnegative().optional(),
+  lineItems: import_zod8.z.array(TelemetryPricingLineItemSchema).optional(),
+  unitPrices: import_zod8.z.array(TelemetryUnitPriceSchema).optional(),
+  usageItems: import_zod8.z.array(TelemetryUsageItemSchema).optional(),
+  pricingRef: import_zod8.z.string().min(1).optional(),
+  metadata: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).optional()
 }).strict();
-var StudioRunStatusSchema = import_zod6.z.enum([
+var StudioRunStatusSchema = import_zod8.z.enum([
   "running",
   "completed",
   "interrupted",
@@ -1171,16 +1903,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_zod8.z.enum(STUDIO_TIME_RANGES);
+var StudioTimeRangeQuerySchema = import_zod8.z.object({
   range: StudioTimeRangeSchema.optional(),
-  startedAfter: import_zod6.z.string().optional(),
-  startedBefore: import_zod6.z.string().optional()
+  startedAfter: import_zod8.z.string().optional(),
+  startedBefore: import_zod8.z.string().optional()
 }).strict();
-var StudioTimeRangeContextSchema = import_zod6.z.object({
+var StudioTimeRangeContextSchema = import_zod8.z.object({
   range: StudioTimeRangeSchema,
-  startedAfter: import_zod6.z.string().datetime({ offset: true }).nullable(),
-  startedBefore: import_zod6.z.string().datetime({ offset: true }).nullable()
+  startedAfter: import_zod8.z.string().datetime({ offset: true }).nullable(),
+  startedBefore: import_zod8.z.string().datetime({ offset: true }).nullable()
 }).strict();
 var STUDIO_TIME_RANGE_MILLISECONDS = {
   "Last hour": 60 * 60 * 1e3,
@@ -1254,7 +1986,7 @@ var resolveStudioTimeRange = (input, now = /* @__PURE__ */ new Date()) => {
     }
   };
 };
-var StudioInterruptStatusSchema = import_zod6.z.enum([
+var StudioInterruptStatusSchema = import_zod8.z.enum([
   "pending",
   "resolved",
   "expired",
@@ -1267,341 +1999,342 @@ 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_zod8.z.enum([
   "choice",
   "multi-choice",
   "text",
   "structured",
   "unknown"
 ]);
-var StudioInterruptInteractionModeSchema = import_zod6.z.enum([
+var StudioInterruptInteractionModeSchema = import_zod8.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_zod8.z.object({
+  id: import_zod8.z.string().min(1),
+  label: import_zod8.z.string().min(1),
+  description: import_zod8.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_zod8.z.union([
+  import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()),
+  import_zod8.z.array(import_zod8.z.unknown()),
+  import_zod8.z.string(),
+  import_zod8.z.number(),
+  import_zod8.z.boolean()
 ]);
-var StudioResumeOutcomeSchema = import_zod6.z.enum([
+var StudioResumeOutcomeSchema = import_zod8.z.enum([
   "resumed",
   "resume failed",
   "expired before resume",
   "cancelled"
 ]);
-var StudioWorkflowHealthSchema = import_zod6.z.enum([
+var StudioWorkflowHealthSchema = import_zod8.z.enum([
   "unknown",
   "healthy",
   "degraded",
   "failing",
   "idle"
 ]);
-var StudioPricingStatusSchema = import_zod6.z.enum([
+var StudioPricingStatusSchema = import_zod8.z.enum([
   "priced",
   "unpriced",
   "unknown"
 ]);
 var StudioPricingSourceSchema = TelemetryPricingSourceSchema.nullable();
-var StudioChangeResourceSchema = import_zod6.z.enum([
+var StudioChangeResourceSchema = import_zod8.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_zod8.z.object({
+  schemaVersion: import_zod8.z.literal(1),
+  changeId: import_zod8.z.string().min(1),
+  emittedAt: import_zod8.z.string().datetime({ offset: true }),
+  organizationId: import_zod8.z.string().min(1),
+  projectId: import_zod8.z.string().min(1),
+  environment: import_zod8.z.string().min(1).optional(),
+  resources: import_zod8.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_zod8.z.object({
+  amounts: import_zod8.z.array(
+    import_zod8.z.object({
+      amount: import_zod8.z.number().nonnegative(),
+      currency: import_zod8.z.string().nullable()
     }).strip()
   ),
-  complete: import_zod6.z.boolean()
+  complete: import_zod8.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_zod8.z.object({
+  runCount: import_zod8.z.number().int().nonnegative(),
+  successRate: import_zod8.z.number().min(0).max(100).nullable(),
+  errorRate: import_zod8.z.number().min(0).max(100).nullable(),
+  retryCount: import_zod8.z.number().int().nonnegative().nullable(),
+  interruptRate: import_zod8.z.number().min(0).max(100).nullable(),
+  p50DurationMs: import_zod8.z.number().nonnegative().nullable(),
+  p95DurationMs: import_zod8.z.number().nonnegative().nullable(),
+  averageTokens: import_zod8.z.number().nonnegative().nullable(),
+  averageCost: import_zod8.z.number().nonnegative().nullable(),
   averageCostSummary: StudioCostSummarySchema.optional(),
-  currency: import_zod6.z.string().nullable()
+  currency: import_zod8.z.string().nullable()
 }).strip();
-var StudioRunSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
+var StudioRunSchema = import_zod8.z.object({
+  id: import_zod8.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_zod8.z.string().optional(),
+  parentRunId: import_zod8.z.string().optional(),
+  parentWorkflowId: import_zod8.z.string().optional(),
+  invocationId: import_zod8.z.string().optional(),
+  branchId: import_zod8.z.string().optional(),
+  callId: import_zod8.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_zod8.z.string().datetime({ offset: true }),
+  endedAt: import_zod8.z.string().datetime({ offset: true }).nullable(),
+  workflowId: import_zod8.z.string().min(1),
+  workflowIds: import_zod8.z.array(import_zod8.z.string().min(1)),
+  workflowRefs: import_zod8.z.array(
+    import_zod8.z.object({
+      workflowId: import_zod8.z.string().min(1),
+      workflowRevisionId: import_zod8.z.string().nullable(),
+      declaredVersion: import_zod8.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_zod8.z.string().nullable(),
+  declaredVersion: import_zod8.z.string().nullable(),
+  transitionIds: import_zod8.z.array(import_zod8.z.string().min(1)),
+  path: import_zod8.z.array(import_zod8.z.string()),
+  sessionId: import_zod8.z.string().nullable(),
+  provider: import_zod8.z.string().nullable(),
+  model: import_zod8.z.string().nullable(),
+  models: import_zod8.z.array(import_zod8.z.string()),
+  durationMs: import_zod8.z.number().nonnegative().nullable(),
+  tokens: import_zod8.z.number().int().nonnegative().nullable(),
+  cost: import_zod8.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_zod8.z.string().nullable(),
+  result: import_zod8.z.string().nullable(),
+  environment: import_zod8.z.string().min(1),
+  userId: import_zod8.z.string().nullable(),
+  tenantId: import_zod8.z.string().nullable(),
+  hasTool: import_zod8.z.boolean(),
+  hasRetry: import_zod8.z.boolean(),
+  interruptNodeId: import_zod8.z.string().nullable(),
+  interruptId: import_zod8.z.string().nullable().optional(),
   interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
-  interruptExpiresAt: import_zod6.z.string().datetime({ offset: true }).nullable().optional()
+  interruptExpiresAt: import_zod8.z.string().datetime({ offset: true }).nullable().optional()
 }).strip();
-var StudioSessionSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
+var StudioSessionSchema = import_zod8.z.object({
+  id: import_zod8.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_zod8.z.string().datetime({ offset: true }),
+  workflowIds: import_zod8.z.array(import_zod8.z.string()),
+  workflowCount: import_zod8.z.number().int().nonnegative(),
+  activeWorkflowId: import_zod8.z.string().nullable(),
+  activeVersion: import_zod8.z.string().nullable(),
+  userId: import_zod8.z.string().nullable(),
+  tenantId: import_zod8.z.string().nullable(),
+  runs: import_zod8.z.number().int().nonnegative(),
+  succeeded: import_zod8.z.number().int().nonnegative(),
+  failed: import_zod8.z.number().int().nonnegative(),
+  interrupted: import_zod8.z.number().int().nonnegative(),
+  checkpoints: import_zod8.z.number().int().nonnegative(),
+  hasFork: import_zod8.z.boolean(),
+  durationMs: import_zod8.z.number().nonnegative().nullable(),
+  tokens: import_zod8.z.number().int().nonnegative().nullable(),
+  cost: import_zod8.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_zod8.z.string().nullable(),
+  latestResult: import_zod8.z.string().nullable(),
+  latestError: import_zod8.z.string().nullable(),
+  pendingInterruptId: import_zod8.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_zod8.z.string().datetime({ offset: true }).nullable().optional(),
+  providers: import_zod8.z.array(import_zod8.z.string()),
+  models: import_zod8.z.array(import_zod8.z.string()),
+  tags: import_zod8.z.array(import_zod8.z.string()),
+  environment: import_zod8.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_zod8.z.object({
+  afterResponseCompleted: import_zod8.z.boolean().optional(),
+  id: import_zod8.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_zod8.z.string().nullable().default(null),
+  schemaId: import_zod8.z.string().nullable(),
+  schemaVersion: import_zod8.z.string().nullable(),
+  createdAt: import_zod8.z.string().datetime({ offset: true }),
+  resolvedAt: import_zod8.z.string().datetime({ offset: true }).nullable(),
+  expiresAt: import_zod8.z.string().datetime({ offset: true }).nullable(),
+  question: import_zod8.z.string().nullable(),
+  contentCaptured: import_zod8.z.boolean(),
+  request: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).nullable().default(null),
+  requestCaptured: import_zod8.z.boolean().default(false),
+  optionCount: import_zod8.z.number().int().nonnegative().nullable(),
+  options: import_zod8.z.array(StudioInterruptOptionSchema).nullable(),
+  workflowId: import_zod8.z.string().min(1),
+  nodeId: import_zod8.z.string().nullable(),
+  sessionId: import_zod8.z.string().nullable(),
+  userId: import_zod8.z.string().nullable(),
+  tenantId: import_zod8.z.string().nullable(),
+  response: import_zod8.z.string().nullable(),
   responseValue: StudioInterruptValueSchema.nullable().default(null),
-  responseCaptured: import_zod6.z.boolean(),
+  responseCaptured: import_zod8.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_zod8.z.string().nullable(),
+  runId: import_zod8.z.string().min(1),
+  resumeToken: import_zod8.z.string().nullable(),
+  resolvedBy: import_zod8.z.string().nullable(),
+  environment: import_zod8.z.string().min(1)
 }).strip();
-var StudioDetailEventSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
+var StudioDetailEventSchema = import_zod8.z.object({
+  id: import_zod8.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_zod8.z.string().min(1),
+  occurredAt: import_zod8.z.string().datetime({ offset: true }),
+  receivedAt: import_zod8.z.string().datetime({ offset: true }),
+  environment: import_zod8.z.string().min(1),
+  serviceName: import_zod8.z.string().min(1),
+  deploymentRef: import_zod8.z.string().nullable(),
+  traceId: import_zod8.z.string().nullable(),
+  spanId: import_zod8.z.string().nullable(),
+  parentSpanId: import_zod8.z.string().nullable(),
+  runId: import_zod8.z.string().min(1),
+  sessionId: import_zod8.z.string().nullable(),
+  workflowId: import_zod8.z.string().min(1),
+  workflowRevisionId: import_zod8.z.string().nullable(),
+  nodeId: import_zod8.z.string().nullable(),
+  userId: import_zod8.z.string().nullable(),
+  tenantId: import_zod8.z.string().nullable(),
+  tags: import_zod8.z.array(import_zod8.z.string()),
+  metadata: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).nullable(),
+  payload: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown())
 }).strip();
-var StudioWorkflowNodeSchema = import_zod6.z.object({
-  tools: import_zod6.z.array(StudioToolSchema).optional(),
+var StudioWorkflowNodeSchema = import_zod8.z.object({
+  tools: import_zod8.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_zod8.z.string().min(1),
+  label: import_zod8.z.string(),
+  type: import_zod8.z.string().nullable(),
+  state: import_zod8.z.enum(["healthy", "warning", "failed", "interrupted", "retried"]).nullable(),
+  provider: import_zod8.z.string().nullable(),
+  model: import_zod8.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_zod8.z.object({
+  id: import_zod8.z.string().min(1),
+  source: import_zod8.z.string().min(1),
+  target: import_zod8.z.string().min(1),
+  condition: import_zod8.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_zod8.z.object({
+  kind: import_zod8.z.enum(["call", "handoff"]).optional(),
+  id: import_zod8.z.string().min(1),
+  sourceWorkflowId: import_zod8.z.string().min(1),
+  sourceNodeId: import_zod8.z.string().nullable(),
+  targetWorkflowId: import_zod8.z.string().min(1),
+  condition: import_zod8.z.string().nullable(),
+  volume: import_zod8.z.number().int().nonnegative(),
+  successRate: import_zod8.z.number().min(0).max(100).nullable(),
+  medianDurationMs: import_zod8.z.number().nonnegative().nullable(),
+  errorRate: import_zod8.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_zod8.z.object({
+  id: import_zod8.z.string().min(1),
+  name: import_zod8.z.string().min(1),
+  description: import_zod8.z.string().nullable(),
+  versions: import_zod8.z.array(import_zod8.z.string()),
+  activeVersion: import_zod8.z.string().nullable(),
+  activeRevisionId: import_zod8.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_zod8.z.array(import_zod8.z.string()),
+  lastActivityAt: import_zod8.z.string().datetime({ offset: true }).nullable(),
   metrics: StudioMetricSchema,
-  nodes: import_zod6.z.array(StudioWorkflowNodeSchema),
-  internalEdges: import_zod6.z.array(StudioWorkflowInternalEdgeSchema)
+  nodes: import_zod8.z.array(StudioWorkflowNodeSchema),
+  internalEdges: import_zod8.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_zod8.z.object({
+  runs: import_zod8.z.array(StudioRunSchema),
+  totalCount: import_zod8.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_zod8.z.object({
+  sessions: import_zod8.z.array(StudioSessionSchema),
+  totalCount: import_zod8.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_zod8.z.object({
+  interrupts: import_zod8.z.array(StudioInterruptSchema),
+  totalCount: import_zod8.z.number().int().nonnegative()
 }).strip();
-var StudioRunDetailResponseSchema = import_zod6.z.object({
+var StudioRunDetailResponseSchema = import_zod8.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_zod8.z.array(StudioScoreSchema).optional(),
+  canReview: import_zod8.z.boolean().optional(),
+  reviewActorId: import_zod8.z.string().optional(),
+  events: import_zod8.z.array(StudioDetailEventSchema),
   session: StudioSessionSchema.nullable(),
-  interrupts: import_zod6.z.array(StudioInterruptSchema),
-  updatedAt: import_zod6.z.string().datetime({ offset: true })
+  interrupts: import_zod8.z.array(StudioInterruptSchema),
+  updatedAt: import_zod8.z.string().datetime({ offset: true })
 }).strip();
-var StudioSessionDetailResponseSchema = import_zod6.z.object({
+var StudioSessionDetailResponseSchema = import_zod8.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_zod8.z.array(StudioRunSchema),
+  events: import_zod8.z.array(StudioDetailEventSchema),
+  interrupts: import_zod8.z.array(StudioInterruptSchema),
+  updatedAt: import_zod8.z.string().datetime({ offset: true })
 }).strip();
-var StudioInterruptDetailResponseSchema = import_zod6.z.object({
+var StudioInterruptDetailResponseSchema = import_zod8.z.object({
   interrupt: StudioInterruptSchema,
-  events: import_zod6.z.array(StudioDetailEventSchema),
+  events: import_zod8.z.array(StudioDetailEventSchema),
   run: StudioRunSchema.nullable(),
   session: StudioSessionSchema.nullable(),
-  updatedAt: import_zod6.z.string().datetime({ offset: true })
+  updatedAt: import_zod8.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_zod8.z.object({
+  workflows: import_zod8.z.array(StudioWorkflowSchema),
+  observedCalls: import_zod8.z.array(
     StudioWorkflowTransitionSchema.extend({
-      runId: import_zod6.z.string(),
-      invocationId: import_zod6.z.string(),
-      branchId: import_zod6.z.string()
+      runId: import_zod8.z.string(),
+      invocationId: import_zod8.z.string(),
+      branchId: import_zod8.z.string()
     })
   ).optional(),
-  transitions: import_zod6.z.array(StudioWorkflowTransitionSchema),
+  transitions: import_zod8.z.array(StudioWorkflowTransitionSchema),
   cohort: StudioTimeRangeContextSchema.extend({
-    workflowId: import_zod6.z.string().nullable(),
-    version: import_zod6.z.string().nullable()
+    workflowId: import_zod8.z.string().nullable(),
+    version: import_zod8.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_zod8.z.object({
+  environments: import_zod8.z.array(import_zod8.z.string()),
+  providers: import_zod8.z.array(import_zod8.z.string()),
+  models: import_zod8.z.array(import_zod8.z.string()),
+  workflows: import_zod8.z.array(import_zod8.z.string()),
+  tags: import_zod8.z.array(import_zod8.z.string())
 }).strip();
-var StudioContextResponseSchema = import_zod6.z.object({
-  organization: import_zod6.z.object({
-    name: import_zod6.z.string().min(1)
+var StudioContextResponseSchema = import_zod8.z.object({
+  tablePreferenceScope: StudioTablePreferenceScopeSchema.nullable().optional(),
+  organization: import_zod8.z.object({
+    name: import_zod8.z.string().min(1)
   }).strip(),
-  project: import_zod6.z.object({
-    name: import_zod6.z.string().min(1)
+  project: import_zod8.z.object({
+    name: import_zod8.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_zod8.z.array(import_zod8.z.string()),
+  apiKey: import_zod8.z.object({
+    mode: import_zod8.z.enum(["test", "live"]),
+    scopes: import_zod8.z.array(import_zod8.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_zod8.z.object({
+    status: import_zod8.z.literal("ok"),
+    service: import_zod8.z.literal("kortyx-api"),
+    version: import_zod8.z.string().min(1)
   }).strip()
 }).strip();
 // Annotate the CommonJS export names for ESM import in node:
@@ -1615,11 +2348,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,
@@ -1635,7 +2372,9 @@ var StudioContextResponseSchema = import_zod6.z.object({
   PromptTransferRequestSchema,
   PromptUsageSchema,
   ReviewVerdictSchema,
+  SAMPLE_PROJECT,
   STUDIO_API_PROTOCOL_VERSION,
+  STUDIO_TABLE_FIELDS,
   STUDIO_TIME_RANGES,
   StudioCatalogsResponseSchema,
   StudioChangeResourceSchema,
@@ -1663,11 +2402,23 @@ var StudioContextResponseSchema = import_zod6.z.object({
   StudioRunSchema,
   StudioRunStatusSchema,
   StudioRunsResponseSchema,
+  StudioSavedViewDefinitionSchema,
   StudioScoreResponseSchema,
   StudioScoreSchema,
   StudioSessionDetailResponseSchema,
   StudioSessionSchema,
   StudioSessionsResponseSchema,
+  StudioTableConfigurationSchema,
+  StudioTableDefaultsSchema,
+  StudioTableIdSchema,
+  StudioTableLayoutSchema,
+  StudioTablePreferenceOperationSchema,
+  StudioTablePreferenceResponseSchema,
+  StudioTablePreferenceScopeSchema,
+  StudioTablePreferenceWriteSchema,
+  StudioTablePreferencesSchema,
+  StudioTableQueryPreferencesSchema,
+  StudioTableViewSchema,
   StudioTimeRangeContextSchema,
   StudioTimeRangeQuerySchema,
   StudioTimeRangeSchema,
@@ -1682,6 +2433,8 @@ var StudioContextResponseSchema = import_zod6.z.object({
   StudioWorkflowTransitionSchema,
   StudioWorkflowsResponseSchema,
   TELEMETRY_EVENT_TYPES,
+  TableFilterRuleSchema,
+  TableFiltersSchema,
   TelemetryEventBatchResponseSchema,
   TelemetryEventBatchSchema,
   TelemetryEventSchema,
@@ -1703,15 +2456,25 @@ var StudioContextResponseSchema = import_zod6.z.object({
   WorkflowTopologyEdgeSchema,
   WorkflowTopologyNodeSchema,
   WorkflowTopologyTransitionSchema,
+  applyTablePreferenceOperation,
+  captureDiagnosticContent,
+  emptyTablePreferences,
+  filterOperators,
   isPrivateDiagnosticField,
+  matchesTableFilters,
+  matchesTableRule,
   newerStudioVersion,
   projectWorkflowCalls,
+  readStudioTableFilters,
   redactDiagnosticContent,
   redactDiagnosticText,
   resolveStudioInterruptStatus,
   resolveStudioTimeRange,
   studioUpdateRunning,
   summarizeDiagnostic,
-  summarizeUserFeedback
+  summarizeUserFeedback,
+  tablePassRate,
+  tableQueueMs,
+  validateTableFilters
 });
 //# sourceMappingURL=index.js.map