@kortyx/telemetry-contracts 0.14.0 → 0.17.0

package/dist/index.js

@@ -3,8 +3,8 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -21,11 +21,32 @@ var index_exports = {};
 __export(index_exports, {
   ClearScoreResponseSchema: () => ClearScoreResponseSchema,
   ClearUserFeedbackRequestSchema: () => ClearUserFeedbackRequestSchema,
+  DIAGNOSTIC_LIMITS: () => DIAGNOSTIC_LIMITS,
+  DiagnosticContentSchema: () => DiagnosticContentSchema,
+  DiagnosticCorrelationSchema: () => DiagnosticCorrelationSchema,
+  DiagnosticManifestSchema: () => DiagnosticManifestSchema,
+  DiagnosticNoteSchema: () => DiagnosticNoteSchema,
+  DiagnosticPartSchema: () => DiagnosticPartSchema,
+  DiagnosticResponseSchema: () => DiagnosticResponseSchema,
   EnsureWorkflowTopologyRequestSchema: () => EnsureWorkflowTopologyRequestSchema,
   EnsureWorkflowTopologyResponseSchema: () => EnsureWorkflowTopologyResponseSchema,
   FEEDBACK_FILTERS: () => FEEDBACK_FILTERS,
   FeedbackReasonSchema: () => FeedbackReasonSchema,
   FeedbackSummarySchema: () => FeedbackSummarySchema,
+  PromptAssetSchema: () => PromptAssetSchema,
+  PromptAssignmentSchema: () => PromptAssignmentSchema,
+  PromptBundleSchema: () => PromptBundleSchema,
+  PromptCategorySchema: () => PromptCategorySchema,
+  PromptDetailSchema: () => PromptDetailSchema,
+  PromptEvidenceSchema: () => PromptEvidenceSchema,
+  PromptGroupSchema: () => PromptGroupSchema,
+  PromptLibrarySchema: () => PromptLibrarySchema,
+  PromptMutationSchema: () => PromptMutationSchema,
+  PromptPolicySchema: () => PromptPolicySchema,
+  PromptSelectionSchema: () => PromptSelectionSchema,
+  PromptStoredVersionSchema: () => PromptStoredVersionSchema,
+  PromptTransferRequestSchema: () => PromptTransferRequestSchema,
+  PromptUsageSchema: () => PromptUsageSchema,
   ReviewVerdictSchema: () => ReviewVerdictSchema,
   STUDIO_API_PROTOCOL_VERSION: () => STUDIO_API_PROTOCOL_VERSION,
   STUDIO_TIME_RANGES: () => STUDIO_TIME_RANGES,
@@ -94,15 +115,19 @@ __export(index_exports, {
   WorkflowTopologyEdgeSchema: () => WorkflowTopologyEdgeSchema,
   WorkflowTopologyNodeSchema: () => WorkflowTopologyNodeSchema,
   WorkflowTopologyTransitionSchema: () => WorkflowTopologyTransitionSchema,
+  isPrivateDiagnosticField: () => isPrivateDiagnosticField,
   newerStudioVersion: () => newerStudioVersion,
   projectWorkflowCalls: () => projectWorkflowCalls,
+  redactDiagnosticContent: () => redactDiagnosticContent,
+  redactDiagnosticText: () => redactDiagnosticText,
   resolveStudioInterruptStatus: () => resolveStudioInterruptStatus,
   resolveStudioTimeRange: () => resolveStudioTimeRange,
   studioUpdateRunning: () => studioUpdateRunning,
+  summarizeDiagnostic: () => summarizeDiagnostic,
   summarizeUserFeedback: () => summarizeUserFeedback
 });
 module.exports = __toCommonJS(index_exports);
-var import_zod4 = require("zod");
+var import_zod6 = require("zod");
 
 // src/scores.ts
 var import_zod = require("zod");
@@ -177,94 +202,591 @@ function summarizeUserFeedback(scores) {
   return feedback;
 }
 
-// src/tools.ts
+// src/diagnostics.ts
 var import_zod2 = require("zod");
-var ToolOutcomeSchema = import_zod2.z.enum([
+var DIAGNOSTIC_LIMITS = {
+  bytes: 8 * 1024 * 1024,
+  partBytes: 64 * 1024,
+  parts: 128,
+  nodes: 1e4,
+  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()
+}).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)
+  }).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()
+}).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()
+  }).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)
+}).strict().superRefine((value, ctx) => {
+  if (value.partCount !== Math.ceil(value.byteLength / DIAGNOSTIC_LIMITS.partBytes))
+    ctx.addIssue({
+      code: "custom",
+      path: ["partCount"],
+      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(
+    /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/
+  )
+}).strict();
+var DiagnosticResponseSchema = import_zod2.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 }),
+  content: DiagnosticContentSchema.nullable(),
+  contentChecksum: import_zod2.z.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  contentByteLength: import_zod2.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, "")
+);
+function redactDiagnosticText(value) {
+  return value.replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, "Bearer [REDACTED]").replace(
+    /\b(?:ktyx_(?:test|live)_[^\s"'<>]+|sk-(?:proj-|ant-)?[A-Za-z0-9_-]{12,}|AIza[A-Za-z0-9_-]{20,}|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)/g,
+    "[REDACTED]"
+  ).replace(
+    /(["']?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|password|passwd|secret|token|client[_-]?secret|authorization|cookie)["']?\s*[:=]\s*)(["'])(.*?)\2/gi,
+    "$1$2[REDACTED]$2"
+  ).replace(
+    /(\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|password|passwd|secret|token|client[_-]?secret)\s*[:=]\s*)(?!["'[])[^\s,;}&]+/gi,
+    "$1[REDACTED]"
+  ).replace(
+    /(\b(?:authorization|proxy-authorization)\s*:\s*Basic\s+)[A-Za-z0-9+/=]+/gi,
+    "$1[REDACTED]"
+  ).replace(
+    /([?&](?:api[_-]?key|token|access[_-]?token|password)=)[^&#\s]+/gi,
+    "$1[REDACTED]"
+  ).replace(/(https?:\/\/)[^\s/@:]+:[^\s/@]+@/gi, "$1[REDACTED]@");
+}
+function summarizeDiagnostic(data, depth = 0) {
+  return {
+    type: typeof data.type === "string" ? data.type.slice(0, 256) : "Error",
+    message: typeof data.message === "string" ? data.message.slice(0, 8192) : "Execution reported a fault.",
+    ...typeof data.stack === "string" ? { stack: data.stack.slice(0, 32768) } : {},
+    ...depth < 4 && data.cause && typeof data.cause === "object" && !Array.isArray(data.cause) ? {
+      cause: summarizeDiagnostic(
+        data.cause,
+        depth + 1
+      )
+    } : {}
+  };
+}
+function redactDiagnosticContent(content) {
+  const redactions = [...content.capture.redactions];
+  const omissions = [...content.capture.omissions];
+  let nodes = 0;
+  const visit = (value, path, depth = 0) => {
+    if (++nodes > DIAGNOSTIC_LIMITS.nodes || depth > DIAGNOSTIC_LIMITS.depth) {
+      const reason = depth > DIAGNOSTIC_LIMITS.depth ? "server_depth_limit" : "server_node_limit";
+      if (omissions.length < 1e4)
+        omissions.push({ path: path.slice(0, 4096), reason });
+      return { $omitted: reason };
+    }
+    if (typeof value === "string") {
+      const clean = redactDiagnosticText(value);
+      if (clean !== value && redactions.length < 1e4)
+        redactions.push({
+          path: path.slice(0, 4096),
+          reason: "server_credential_text"
+        });
+      return clean;
+    }
+    if (Array.isArray(value)) {
+      if (value.length > DIAGNOSTIC_LIMITS.properties && omissions.length < 1e4)
+        omissions.push({
+          path: path.slice(0, 4096),
+          reason: "server_collection_limit",
+          originalCount: value.length
+        });
+      return value.slice(0, DIAGNOSTIC_LIMITS.properties).map((item, index) => visit(item, `${path}/${index}`, depth + 1));
+    }
+    if (value && typeof value === "object") {
+      const keys = Object.keys(value);
+      if (keys.length > DIAGNOSTIC_LIMITS.properties && omissions.length < 1e4)
+        omissions.push({
+          path: path.slice(0, 4096),
+          reason: "server_property_limit",
+          originalCount: keys.length
+        });
+      return Object.fromEntries(
+        keys.slice(0, DIAGNOSTIC_LIMITS.properties).map((key) => {
+          const nested = value[key];
+          if (isPrivateDiagnosticField(key)) {
+            if (redactions.length < 1e4 && nested !== "[REDACTED]")
+              redactions.push({
+                path: `${path}/${key}`.slice(0, 4096),
+                reason: "server_credential_field"
+              });
+            return [key, "[REDACTED]"];
+          }
+          return [key, visit(nested, `${path}/${key}`, depth + 1)];
+        })
+      );
+    }
+    return value;
+  };
+  return {
+    ...content,
+    data: visit(content.data, "#/data"),
+    capture: {
+      ...content.capture,
+      status: content.capture.status === "failed" ? "failed" : omissions.length ? "partial" : "complete",
+      omissions: omissions.map((note) => ({
+        ...note,
+        path: redactDiagnosticText(note.path),
+        reason: redactDiagnosticText(note.reason)
+      })),
+      redactions: redactions.map((note) => ({
+        ...note,
+        path: redactDiagnosticText(note.path),
+        reason: redactDiagnosticText(note.reason)
+      }))
+    }
+  };
+}
+
+// src/tools.ts
+var import_zod3 = require("zod");
+var ToolOutcomeSchema = import_zod3.z.enum([
   "success",
   "denied",
   "fault",
   "cancelled"
 ]);
-var ToolObservationSchema = import_zod2.z.object({
-  version: import_zod2.z.literal(1),
-  name: import_zod2.z.string().min(1).max(256),
-  toolCallId: import_zod2.z.string().min(1),
-  attemptId: import_zod2.z.string().min(1),
-  callingMode: import_zod2.z.enum(["direct", "model"]),
-  executed: import_zod2.z.boolean(),
+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(),
   outcome: ToolOutcomeSchema.optional(),
-  denialCode: import_zod2.z.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/).optional(),
-  errorType: import_zod2.z.string().max(256).optional(),
-  errorMessage: import_zod2.z.string().max(8192).optional(),
-  durationMs: import_zod2.z.number().finite().nonnegative().optional(),
-  workflowId: import_zod2.z.string().optional(),
-  nodeId: import_zod2.z.string().optional(),
-  workflowRevisionId: import_zod2.z.string().optional(),
-  runId: import_zod2.z.string().optional(),
-  invocationId: import_zod2.z.string().optional(),
-  parentInvocationId: import_zod2.z.string().optional(),
-  branchId: import_zod2.z.string().optional(),
-  observationKind: import_zod2.z.enum(["reused", "waiting"]).optional(),
-  suspended: import_zod2.z.boolean().optional(),
-  source: import_zod2.z.object({
-    runId: import_zod2.z.string().optional(),
-    invocationId: import_zod2.z.string().optional(),
-    branchId: import_zod2.z.string().optional(),
-    toolCallId: import_zod2.z.string(),
-    attemptId: import_zod2.z.string()
+  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()
   }).strict().optional()
 });
-var WorkflowToolSchema = import_zod2.z.object({
-  name: import_zod2.z.string().min(1).max(256),
-  description: import_zod2.z.string().max(4096).optional(),
-  callingMode: import_zod2.z.enum(["direct", "model"]),
-  provenance: import_zod2.z.enum(["source", "observed"]),
-  inputFields: import_zod2.z.array(
-    import_zod2.z.object({ name: import_zod2.z.string(), type: import_zod2.z.string(), required: import_zod2.z.boolean() }).strict()
+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()
   ).optional()
 }).strict();
-var ToolDiscoverySchema = import_zod2.z.object({
-  status: import_zod2.z.enum(["complete", "unresolved"]),
-  publishedAt: import_zod2.z.string().datetime().optional(),
-  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+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()
 }).strict();
 var StudioToolSchema = WorkflowToolSchema.extend({
-  callingMode: import_zod2.z.enum(["direct", "model", "unknown"]),
-  calls: import_zod2.z.number().nonnegative(),
-  replays: import_zod2.z.number().nonnegative(),
-  successes: import_zod2.z.number().nonnegative(),
-  denials: import_zod2.z.number().nonnegative(),
-  faults: import_zod2.z.number().nonnegative(),
-  cancellations: import_zod2.z.number().nonnegative(),
-  p50DurationMs: import_zod2.z.number().nonnegative().nullable(),
-  p95DurationMs: import_zod2.z.number().nonnegative().nullable()
+  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()
+}).strict();
+
+// 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(),
+  name,
+  parentId: import_zod4.z.uuid().nullable(),
+  revision
+});
+var PromptGroupSchema = import_zod4.z.object({
+  id: import_zod4.z.uuid(),
+  name,
+  revision,
+  members: import_zod4.z.array(
+    import_zod4.z.object({
+      promptId: import_zod4.z.uuid(),
+      version,
+      key: import_browser.PromptKeySchema.optional(),
+      name: name.optional(),
+      archived: import_zod4.z.boolean().optional()
+    })
+  ).max(100),
+  updatedAt: import_zod4.z.string()
+});
+var PromptAssignmentSchema = import_zod4.z.object({
+  tag: import_browser.PromptTagSchema,
+  version,
+  revision,
+  updatedAt: import_zod4.z.string()
+});
+var PromptAssetSchema = import_zod4.z.object({
+  id: import_zod4.z.uuid(),
+  key: import_browser.PromptKeySchema,
+  name,
+  categoryId: import_zod4.z.uuid().nullable(),
+  latestVersion: version,
+  revision,
+  archived: import_zod4.z.boolean(),
+  updatedAt: import_zod4.z.string(),
+  assignments: import_zod4.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 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(),
+    version,
+    hash: import_zod4.z.string()
+  }).nullable()
+});
+var PromptPolicySchema = import_zod4.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()
+});
+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(),
+  version,
+  fullSuite: import_zod4.z.boolean(),
+  usage: import_zod4.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 }))
+});
+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 PromptDetailSchema = import_zod4.z.object({
+  asset: PromptAssetSchema,
+  versions: import_zod4.z.array(PromptStoredVersionSchema),
+  versionsNextCursor: import_zod4.z.string().nullable().optional(),
+  draft: import_browser.PromptContentSchema.nullable(),
+  draftBase: import_zod4.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()
+    })
+  ),
+  policies: import_zod4.z.array(PromptPolicySchema),
+  reviews: import_zod4.z.array(
+    import_zod4.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()
+    })
+  ).optional()
+});
+var PromptMutationSchema = import_zod4.z.discriminatedUnion("action", [
+  import_zod4.z.object({
+    action: import_zod4.z.literal("tag-set"),
+    id: import_zod4.z.uuid(),
+    tag: import_browser.PromptTagSchema.refine(
+      (tag) => tag !== "live",
+      "Use promotion to update live."
+    ),
+    version,
+    expectedRevision: revision
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("tag-remove"),
+    id: import_zod4.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()
+  }).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"),
+    key: import_browser.PromptKeySchema,
+    name,
+    categoryId: import_zod4.z.uuid().nullable().default(null),
+    content: import_browser.PromptContentSchema,
+    note: import_zod4.z.string().trim().max(2e3).default(""),
+    idempotencyKey: import_zod4.z.uuid().optional()
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("draft"),
+    id: import_zod4.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(),
+    expectedRevision: revision
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("save"),
+    id: import_zod4.z.uuid(),
+    content: import_browser.PromptContentSchema,
+    baseVersion: version,
+    expectedHash: import_zod4.z.string().regex(/^[a-f0-9]{64}$/),
+    expectedDraftRevision: revision.optional(),
+    note: import_zod4.z.string().trim().max(2e3).default(""),
+    idempotencyKey: import_zod4.z.uuid()
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("update"),
+    id: import_zod4.z.uuid(),
+    expectedRevision: revision,
+    name: name.optional(),
+    categoryId: import_zod4.z.uuid().nullable().optional(),
+    archived: import_zod4.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)
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("category-update"),
+    id: import_zod4.z.uuid(),
+    expectedRevision: revision,
+    name: name.optional(),
+    parentId: import_zod4.z.uuid().nullable().optional()
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("category-delete"),
+    id: import_zod4.z.uuid(),
+    expectedRevision: revision,
+    destinationId: import_zod4.z.uuid().nullable()
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("group-create"),
+    name,
+    members: import_zod4.z.array(import_zod4.z.object({ promptId: import_zod4.z.uuid(), version })).max(100).optional()
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("group-update"),
+    id: import_zod4.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()
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("group-delete"),
+    id: import_zod4.z.uuid(),
+    expectedRevision: revision
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("promote"),
+    id: import_zod4.z.uuid(),
+    version,
+    expectedRevision: revision,
+    exceptionReason: import_zod4.z.string().trim().min(1).max(2e3).optional(),
+    rollback: import_zod4.z.boolean().default(false)
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("review"),
+    id: import_zod4.z.uuid(),
+    version,
+    note: import_zod4.z.string().trim().min(1).max(2e3)
+  }).strict(),
+  import_zod4.z.object({
+    action: import_zod4.z.literal("policy"),
+    id: import_zod4.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()
+  }).strict(),
+  import_zod4.z.object({ type: import_zod4.z.literal("group"), groupId: import_zod4.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) => {
+      const url = new URL(value);
+      return /^https?:$/.test(url.protocol) && !url.username && !url.password && !url.search;
+    }),
+    projectId: import_zod4.z.string().min(1)
+  }).strict(),
+  prompts: import_zod4.z.array(
+    import_zod4.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)
+    }).strict()
+  ).min(1).max(200),
+  groups: import_zod4.z.array(
+    import_zod4.z.object({
+      name,
+      members: import_zod4.z.array(import_zod4.z.object({ key: import_browser.PromptKeySchema, version })).max(100)
+    }).strict()
+  ).max(100).default([])
+}).strict();
+var PromptTransferRequestSchema = import_zod4.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)
 }).strict();
 
 // src/studio-updates.ts
-var import_zod3 = require("zod");
-var StudioReleaseVersionSchema = import_zod3.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
-var StudioReleaseDeploymentSchema = import_zod3.z.object({
-  strategy: import_zod3.z.enum(["rolling", "recreate"])
+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 StudioReleaseSchema = import_zod3.z.object({
-  format: import_zod3.z.literal(1),
-  installer: import_zod3.z.literal(1),
+var StudioReleaseSchema = import_zod5.z.object({
+  format: import_zod5.z.literal(1),
+  installer: import_zod5.z.literal(1),
   version: StudioReleaseVersionSchema,
-  api: import_zod3.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-api@sha256:[a-f0-9]{64}$/),
-  studio: import_zod3.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-studio@sha256:[a-f0-9]{64}$/),
+  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}$/),
   deployment: StudioReleaseDeploymentSchema.default({
     strategy: "recreate"
   })
 });
-var StudioUpdateSettingsSchema = import_zod3.z.object({
-  automatic: import_zod3.z.boolean(),
-  hourUtc: import_zod3.z.number().int().min(0).max(23)
+var StudioUpdateSettingsSchema = import_zod5.z.object({
+  automatic: import_zod5.z.boolean(),
+  hourUtc: import_zod5.z.number().int().min(0).max(23)
 });
-var StudioUpdateOperationSchema = import_zod3.z.object({
-  id: import_zod3.z.uuid(),
-  from: import_zod3.z.string(),
+var StudioUpdateOperationSchema = import_zod5.z.object({
+  id: import_zod5.z.uuid(),
+  from: import_zod5.z.string(),
   release: StudioReleaseSchema,
-  phase: import_zod3.z.enum([
+  phase: import_zod5.z.enum([
     "starting",
     "pulling",
     "backup",
@@ -273,16 +795,16 @@ var StudioUpdateOperationSchema = import_zod3.z.object({
     "succeeded",
     "failed"
   ]),
-  startedAt: import_zod3.z.iso.datetime(),
-  updatedAt: import_zod3.z.iso.datetime(),
-  backup: import_zod3.z.string().nullable(),
-  messages: import_zod3.z.array(import_zod3.z.string()).max(100)
+  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)
 });
-var StudioUpdateStatusSchema = import_zod3.z.object({
-  current: import_zod3.z.string().nullable(),
+var StudioUpdateStatusSchema = import_zod5.z.object({
+  current: import_zod5.z.string().nullable(),
   available: StudioReleaseSchema.nullable(),
-  checkedAt: import_zod3.z.iso.datetime().nullable(),
-  checkError: import_zod3.z.string().nullable(),
+  checkedAt: import_zod5.z.iso.datetime().nullable(),
+  checkError: import_zod5.z.string().nullable(),
   settings: StudioUpdateSettingsSchema,
   operation: StudioUpdateOperationSchema.nullable()
 });
@@ -437,82 +959,82 @@ var TELEMETRY_EVENT_TYPES = [
   "session.forked",
   "session.rolled_back"
 ];
-var TelemetryServiceSchema = import_zod4.z.object({
-  name: import_zod4.z.string().min(1),
-  deploymentRef: import_zod4.z.string().min(1).optional()
+var TelemetryServiceSchema = import_zod6.z.object({
+  name: import_zod6.z.string().min(1),
+  deploymentRef: import_zod6.z.string().min(1).optional()
 }).strict();
-var WorkflowTopologyNodeSchema = import_zod4.z.object({
-  id: import_zod4.z.string().min(1),
-  label: import_zod4.z.string().optional(),
-  type: import_zod4.z.string().optional(),
-  provider: import_zod4.z.string().optional(),
-  model: import_zod4.z.string().optional(),
-  metadata: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional(),
-  tools: import_zod4.z.array(WorkflowToolSchema).optional(),
+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(),
   toolDiscovery: ToolDiscoverySchema.optional()
 }).strict();
-var WorkflowTopologyEdgeSchema = import_zod4.z.object({
-  sourceNodeId: import_zod4.z.string().min(1),
-  targetNodeId: import_zod4.z.string().min(1),
-  condition: import_zod4.z.string().optional()
+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()
 }).strict();
-var WorkflowTopologyCallSchema = import_zod4.z.object({
-  sourceNodeId: import_zod4.z.string().min(1),
-  targetWorkflowId: import_zod4.z.string().min(1)
+var WorkflowTopologyCallSchema = import_zod6.z.object({
+  sourceNodeId: import_zod6.z.string().min(1),
+  targetWorkflowId: import_zod6.z.string().min(1)
 }).strict();
-var WorkflowTopologyTransitionSchema = import_zod4.z.object({
-  sourceNodeId: import_zod4.z.string().min(1).optional(),
-  targetWorkflowId: import_zod4.z.string().min(1),
-  condition: import_zod4.z.string().optional(),
-  intent: import_zod4.z.string().optional(),
-  kind: import_zod4.z.enum(["call", "handoff"]).optional()
+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()
 }).strict();
-var EnsureWorkflowTopologyRequestSchema = import_zod4.z.object({
-  schemaVersion: import_zod4.z.literal(1),
-  environment: import_zod4.z.string().min(1),
+var EnsureWorkflowTopologyRequestSchema = import_zod6.z.object({
+  schemaVersion: import_zod6.z.literal(1),
+  environment: import_zod6.z.string().min(1),
   service: TelemetryServiceSchema,
-  workflow: import_zod4.z.object({
-    id: import_zod4.z.string().min(1),
-    declaredVersion: import_zod4.z.string().min(1),
-    description: import_zod4.z.string().optional(),
-    tags: import_zod4.z.array(import_zod4.z.string()).optional(),
-    topologyHash: import_zod4.z.string().regex(/^[a-f0-9]{64}$/),
-    nodes: import_zod4.z.array(WorkflowTopologyNodeSchema),
-    edges: import_zod4.z.array(WorkflowTopologyEdgeSchema),
-    transitions: import_zod4.z.array(WorkflowTopologyTransitionSchema).optional(),
-    calls: import_zod4.z.array(WorkflowTopologyCallSchema).optional()
+  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()
   }).strict()
 }).strict();
-var EnsureWorkflowTopologyResponseSchema = import_zod4.z.object({ workflowRevisionId: import_zod4.z.string().min(1), created: import_zod4.z.boolean() }).strict();
-var TelemetryEventTypeSchema = import_zod4.z.enum(TELEMETRY_EVENT_TYPES);
-var TelemetryEventSchema = import_zod4.z.object({
-  schemaVersion: import_zod4.z.literal(1),
-  eventId: import_zod4.z.string().min(1),
-  occurredAt: import_zod4.z.string().datetime({ offset: true }),
-  environment: import_zod4.z.string().min(1),
+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),
   service: TelemetryServiceSchema,
-  correlation: import_zod4.z.object({
-    invocationId: import_zod4.z.string().optional(),
-    parentInvocationId: import_zod4.z.string().optional(),
-    branchId: import_zod4.z.string().optional(),
-    traceId: import_zod4.z.string().optional(),
-    spanId: import_zod4.z.string().optional(),
-    parentSpanId: import_zod4.z.string().optional(),
-    runId: import_zod4.z.string().min(1),
-    sessionId: import_zod4.z.string().optional(),
-    workflowId: import_zod4.z.string().min(1),
-    workflowRevisionId: import_zod4.z.string().optional(),
-    topologyHash: import_zod4.z.string().regex(/^[a-f0-9]{64}$/).optional(),
-    nodeId: import_zod4.z.string().optional()
+  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()
   }).strict(),
-  context: import_zod4.z.object({
-    userId: import_zod4.z.string().optional(),
-    tenantId: import_zod4.z.string().optional(),
-    tags: import_zod4.z.array(import_zod4.z.string()).optional(),
-    metadata: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
+  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()
   }).strict().optional(),
   type: TelemetryEventTypeSchema,
-  payload: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown())
+  payload: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown())
 }).strict().superRefine((event, ctx) => {
   if (!event.type.startsWith("tool.")) return;
   const canonical = event.payload.version === 1 || [
@@ -555,20 +1077,20 @@ var TelemetryEventSchema = import_zod4.z.object({
       });
   }
 });
-var TelemetryEventBatchSchema = import_zod4.z.object({ events: import_zod4.z.array(TelemetryEventSchema).min(1) }).strict();
-var TelemetryEventBatchResponseSchema = import_zod4.z.object({
-  accepted: import_zod4.z.number().int().nonnegative(),
-  inserted: import_zod4.z.number().int().nonnegative(),
-  duplicates: import_zod4.z.number().int().nonnegative()
+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()
 }).strict();
-var TelemetryPricingSourceSchema = import_zod4.z.enum([
+var TelemetryPricingSourceSchema = import_zod6.z.enum([
   "sdk",
   "provider",
   "custom",
   "project-rate-card",
   "default-rate-card"
 ]);
-var TelemetryPricingUnitSchema = import_zod4.z.enum([
+var TelemetryPricingUnitSchema = import_zod6.z.enum([
   "token",
   "character",
   "request",
@@ -581,7 +1103,7 @@ var TelemetryPricingUnitSchema = import_zod4.z.enum([
   "minute",
   "custom"
 ]);
-var TelemetryPricingUsageTypeSchema = import_zod4.z.enum([
+var TelemetryPricingUsageTypeSchema = import_zod6.z.enum([
   "input",
   "output",
   "reasoning",
@@ -597,42 +1119,42 @@ var TelemetryPricingUsageTypeSchema = import_zod4.z.enum([
   "request",
   "custom"
 ]);
-var TelemetryUsageItemSchema = import_zod4.z.object({
+var TelemetryUsageItemSchema = import_zod6.z.object({
   usageType: TelemetryPricingUsageTypeSchema,
-  quantity: import_zod4.z.number().nonnegative(),
+  quantity: import_zod6.z.number().nonnegative(),
   unit: TelemetryPricingUnitSchema,
-  label: import_zod4.z.string().optional()
+  label: import_zod6.z.string().optional()
 }).strict();
-var TelemetryUnitPriceSchema = import_zod4.z.object({
+var TelemetryUnitPriceSchema = import_zod6.z.object({
   usageType: TelemetryPricingUsageTypeSchema,
   unit: TelemetryPricingUnitSchema,
-  unitQuantity: import_zod4.z.number().positive().default(1),
-  priceMicros: import_zod4.z.number().int().nonnegative(),
-  label: import_zod4.z.string().optional()
+  unitQuantity: import_zod6.z.number().positive().default(1),
+  priceMicros: import_zod6.z.number().int().nonnegative(),
+  label: import_zod6.z.string().optional()
 }).strict();
-var TelemetryPricingLineItemSchema = import_zod4.z.object({
+var TelemetryPricingLineItemSchema = import_zod6.z.object({
   usageType: TelemetryPricingUsageTypeSchema,
-  quantity: import_zod4.z.number().nonnegative(),
+  quantity: import_zod6.z.number().nonnegative(),
   unit: TelemetryPricingUnitSchema,
-  unitQuantity: import_zod4.z.number().positive().default(1),
-  unitPriceMicros: import_zod4.z.number().int().nonnegative().optional(),
-  totalCostMicros: import_zod4.z.number().int().nonnegative().optional(),
-  label: import_zod4.z.string().optional()
+  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()
 }).strict().refine(
   (value) => value.totalCostMicros !== void 0 || value.unitPriceMicros !== void 0,
   "line item requires totalCostMicros or unitPriceMicros"
 );
-var TelemetryPricingHintSchema = import_zod4.z.object({
+var TelemetryPricingHintSchema = import_zod6.z.object({
   source: TelemetryPricingSourceSchema.extract(["sdk", "provider", "custom"]),
-  currency: import_zod4.z.string().min(3).max(12).default("USD"),
-  actualCostMicros: import_zod4.z.number().int().nonnegative().optional(),
-  lineItems: import_zod4.z.array(TelemetryPricingLineItemSchema).optional(),
-  unitPrices: import_zod4.z.array(TelemetryUnitPriceSchema).optional(),
-  usageItems: import_zod4.z.array(TelemetryUsageItemSchema).optional(),
-  pricingRef: import_zod4.z.string().min(1).optional(),
-  metadata: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
+  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()
 }).strict();
-var StudioRunStatusSchema = import_zod4.z.enum([
+var StudioRunStatusSchema = import_zod6.z.enum([
   "running",
   "completed",
   "interrupted",
@@ -648,16 +1170,16 @@ var STUDIO_TIME_RANGES = [
   "All time",
   "Custom range"
 ];
-var StudioTimeRangeSchema = import_zod4.z.enum(STUDIO_TIME_RANGES);
-var StudioTimeRangeQuerySchema = import_zod4.z.object({
+var StudioTimeRangeSchema = import_zod6.z.enum(STUDIO_TIME_RANGES);
+var StudioTimeRangeQuerySchema = import_zod6.z.object({
   range: StudioTimeRangeSchema.optional(),
-  startedAfter: import_zod4.z.string().optional(),
-  startedBefore: import_zod4.z.string().optional()
+  startedAfter: import_zod6.z.string().optional(),
+  startedBefore: import_zod6.z.string().optional()
 }).strict();
-var StudioTimeRangeContextSchema = import_zod4.z.object({
+var StudioTimeRangeContextSchema = import_zod6.z.object({
   range: StudioTimeRangeSchema,
-  startedAfter: import_zod4.z.string().datetime({ offset: true }).nullable(),
-  startedBefore: import_zod4.z.string().datetime({ offset: true }).nullable()
+  startedAfter: import_zod6.z.string().datetime({ offset: true }).nullable(),
+  startedBefore: import_zod6.z.string().datetime({ offset: true }).nullable()
 }).strict();
 var STUDIO_TIME_RANGE_MILLISECONDS = {
   "Last hour": 60 * 60 * 1e3,
@@ -731,7 +1253,7 @@ var resolveStudioTimeRange = (input, now = /* @__PURE__ */ new Date()) => {
     }
   };
 };
-var StudioInterruptStatusSchema = import_zod4.z.enum([
+var StudioInterruptStatusSchema = import_zod6.z.enum([
   "pending",
   "resolved",
   "expired",
@@ -744,340 +1266,361 @@ 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_zod4.z.enum([
+var StudioInterruptTypeSchema = import_zod6.z.enum([
   "choice",
   "multi-choice",
   "text",
   "structured",
   "unknown"
 ]);
-var StudioInterruptInteractionModeSchema = import_zod4.z.enum([
+var StudioInterruptInteractionModeSchema = import_zod6.z.enum([
   "static-options",
   "dynamic-picker",
   "freeform",
   "unknown"
 ]);
-var StudioInterruptOptionSchema = import_zod4.z.object({
-  id: import_zod4.z.string().min(1),
-  label: import_zod4.z.string().min(1),
-  description: import_zod4.z.string().nullable()
+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()
 }).strip();
-var StudioInterruptValueSchema = import_zod4.z.union([
-  import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()),
-  import_zod4.z.array(import_zod4.z.unknown()),
-  import_zod4.z.string(),
-  import_zod4.z.number(),
-  import_zod4.z.boolean()
+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 StudioResumeOutcomeSchema = import_zod4.z.enum([
+var StudioResumeOutcomeSchema = import_zod6.z.enum([
   "resumed",
   "resume failed",
   "expired before resume",
   "cancelled"
 ]);
-var StudioWorkflowHealthSchema = import_zod4.z.enum([
+var StudioWorkflowHealthSchema = import_zod6.z.enum([
   "unknown",
   "healthy",
   "degraded",
   "failing",
   "idle"
 ]);
-var StudioPricingStatusSchema = import_zod4.z.enum([
+var StudioPricingStatusSchema = import_zod6.z.enum([
   "priced",
   "unpriced",
   "unknown"
 ]);
 var StudioPricingSourceSchema = TelemetryPricingSourceSchema.nullable();
-var StudioChangeResourceSchema = import_zod4.z.enum([
+var StudioChangeResourceSchema = import_zod6.z.enum([
   "evals",
   "workflows",
   "runs",
   "sessions",
   "interrupts"
 ]);
-var StudioChangeSchema = import_zod4.z.object({
-  schemaVersion: import_zod4.z.literal(1),
-  changeId: import_zod4.z.string().min(1),
-  emittedAt: import_zod4.z.string().datetime({ offset: true }),
-  organizationId: import_zod4.z.string().min(1),
-  projectId: import_zod4.z.string().min(1),
-  environment: import_zod4.z.string().min(1).optional(),
-  resources: import_zod4.z.array(StudioChangeResourceSchema).min(1)
+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)
 }).strict();
-var StudioMetricSchema = import_zod4.z.object({
-  runCount: import_zod4.z.number().int().nonnegative(),
-  successRate: import_zod4.z.number().min(0).max(100).nullable(),
-  errorRate: import_zod4.z.number().min(0).max(100).nullable(),
-  retryCount: import_zod4.z.number().int().nonnegative().nullable(),
-  interruptRate: import_zod4.z.number().min(0).max(100).nullable(),
-  p50DurationMs: import_zod4.z.number().nonnegative().nullable(),
-  p95DurationMs: import_zod4.z.number().nonnegative().nullable(),
-  averageTokens: import_zod4.z.number().nonnegative().nullable(),
-  averageCost: import_zod4.z.number().nonnegative().nullable(),
-  currency: import_zod4.z.string().nullable()
+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(),
+  currency: import_zod6.z.string().nullable()
 }).strip();
-var StudioRunSchema = import_zod4.z.object({
-  id: import_zod4.z.string().min(1),
+var StudioRunSchema = import_zod6.z.object({
+  id: import_zod6.z.string().min(1),
   feedback: FeedbackSummarySchema.optional(),
-  callerNodeId: import_zod4.z.string().optional(),
-  parentRunId: import_zod4.z.string().optional(),
-  parentWorkflowId: import_zod4.z.string().optional(),
-  invocationId: import_zod4.z.string().optional(),
-  branchId: import_zod4.z.string().optional(),
-  callId: import_zod4.z.string().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(),
   status: StudioRunStatusSchema,
-  startedAt: import_zod4.z.string().datetime({ offset: true }),
-  endedAt: import_zod4.z.string().datetime({ offset: true }).nullable(),
-  workflowId: import_zod4.z.string().min(1),
-  workflowIds: import_zod4.z.array(import_zod4.z.string().min(1)),
-  workflowRefs: import_zod4.z.array(
-    import_zod4.z.object({
-      workflowId: import_zod4.z.string().min(1),
-      workflowRevisionId: import_zod4.z.string().nullable(),
-      declaredVersion: import_zod4.z.string().nullable()
+  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()
     }).strip()
   ),
-  workflowRevisionId: import_zod4.z.string().nullable(),
-  declaredVersion: import_zod4.z.string().nullable(),
-  transitionIds: import_zod4.z.array(import_zod4.z.string().min(1)),
-  path: import_zod4.z.array(import_zod4.z.string()),
-  sessionId: import_zod4.z.string().nullable(),
-  provider: import_zod4.z.string().nullable(),
-  model: import_zod4.z.string().nullable(),
-  models: import_zod4.z.array(import_zod4.z.string()),
-  durationMs: import_zod4.z.number().nonnegative().nullable(),
-  tokens: import_zod4.z.number().int().nonnegative().nullable(),
-  cost: import_zod4.z.number().nonnegative().nullable(),
+  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(),
   pricingStatus: StudioPricingStatusSchema,
   pricingSource: StudioPricingSourceSchema,
-  currency: import_zod4.z.string().nullable(),
-  result: import_zod4.z.string().nullable(),
-  environment: import_zod4.z.string().min(1),
-  userId: import_zod4.z.string().nullable(),
-  tenantId: import_zod4.z.string().nullable(),
-  hasTool: import_zod4.z.boolean(),
-  hasRetry: import_zod4.z.boolean(),
-  interruptNodeId: import_zod4.z.string().nullable(),
-  interruptId: import_zod4.z.string().nullable().optional(),
+  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(),
   interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
-  interruptExpiresAt: import_zod4.z.string().datetime({ offset: true }).nullable().optional()
+  interruptExpiresAt: import_zod6.z.string().datetime({ offset: true }).nullable().optional()
 }).strip();
-var StudioSessionSchema = import_zod4.z.object({
-  id: import_zod4.z.string().min(1),
+var StudioSessionSchema = import_zod6.z.object({
+  id: import_zod6.z.string().min(1),
   status: StudioRunStatusSchema,
-  lastActivityAt: import_zod4.z.string().datetime({ offset: true }),
-  workflowIds: import_zod4.z.array(import_zod4.z.string()),
-  workflowCount: import_zod4.z.number().int().nonnegative(),
-  activeWorkflowId: import_zod4.z.string().nullable(),
-  activeVersion: import_zod4.z.string().nullable(),
-  userId: import_zod4.z.string().nullable(),
-  tenantId: import_zod4.z.string().nullable(),
-  runs: import_zod4.z.number().int().nonnegative(),
-  succeeded: import_zod4.z.number().int().nonnegative(),
-  failed: import_zod4.z.number().int().nonnegative(),
-  interrupted: import_zod4.z.number().int().nonnegative(),
-  checkpoints: import_zod4.z.number().int().nonnegative(),
-  hasFork: import_zod4.z.boolean(),
-  durationMs: import_zod4.z.number().nonnegative().nullable(),
-  tokens: import_zod4.z.number().int().nonnegative().nullable(),
-  cost: import_zod4.z.number().nonnegative().nullable(),
+  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(),
   pricingStatus: StudioPricingStatusSchema,
   pricingSource: StudioPricingSourceSchema,
-  currency: import_zod4.z.string().nullable(),
-  latestResult: import_zod4.z.string().nullable(),
-  latestError: import_zod4.z.string().nullable(),
-  pendingInterruptId: import_zod4.z.string().nullable(),
+  currency: import_zod6.z.string().nullable(),
+  latestResult: import_zod6.z.string().nullable(),
+  latestError: import_zod6.z.string().nullable(),
+  pendingInterruptId: import_zod6.z.string().nullable(),
   interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
-  interruptExpiresAt: import_zod4.z.string().datetime({ offset: true }).nullable().optional(),
-  providers: import_zod4.z.array(import_zod4.z.string()),
-  models: import_zod4.z.array(import_zod4.z.string()),
-  tags: import_zod4.z.array(import_zod4.z.string()),
-  environment: import_zod4.z.string().min(1)
+  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)
 }).strip();
-var StudioInterruptSchema = import_zod4.z.object({
-  afterResponseCompleted: import_zod4.z.boolean().optional(),
-  id: import_zod4.z.string().min(1),
+var StudioInterruptSchema = import_zod6.z.object({
+  afterResponseCompleted: import_zod6.z.boolean().optional(),
+  id: import_zod6.z.string().min(1),
   status: StudioInterruptStatusSchema,
   type: StudioInterruptTypeSchema,
   interactionMode: StudioInterruptInteractionModeSchema,
-  contract: import_zod4.z.string().nullable().default(null),
-  schemaId: import_zod4.z.string().nullable(),
-  schemaVersion: import_zod4.z.string().nullable(),
-  createdAt: import_zod4.z.string().datetime({ offset: true }),
-  resolvedAt: import_zod4.z.string().datetime({ offset: true }).nullable(),
-  expiresAt: import_zod4.z.string().datetime({ offset: true }).nullable(),
-  question: import_zod4.z.string().nullable(),
-  contentCaptured: import_zod4.z.boolean(),
-  request: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).nullable().default(null),
-  requestCaptured: import_zod4.z.boolean().default(false),
-  optionCount: import_zod4.z.number().int().nonnegative().nullable(),
-  options: import_zod4.z.array(StudioInterruptOptionSchema).nullable(),
-  workflowId: import_zod4.z.string().min(1),
-  nodeId: import_zod4.z.string().nullable(),
-  sessionId: import_zod4.z.string().nullable(),
-  userId: import_zod4.z.string().nullable(),
-  tenantId: import_zod4.z.string().nullable(),
-  response: import_zod4.z.string().nullable(),
+  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(),
   responseValue: StudioInterruptValueSchema.nullable().default(null),
-  responseCaptured: import_zod4.z.boolean(),
+  responseCaptured: import_zod6.z.boolean(),
   resumeOutcome: StudioResumeOutcomeSchema.nullable(),
-  resumeError: import_zod4.z.string().nullable(),
-  runId: import_zod4.z.string().min(1),
-  resumeToken: import_zod4.z.string().nullable(),
-  resolvedBy: import_zod4.z.string().nullable(),
-  environment: import_zod4.z.string().min(1)
+  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)
 }).strip();
-var StudioDetailEventSchema = import_zod4.z.object({
-  id: import_zod4.z.string().min(1),
+var StudioDetailEventSchema = import_zod6.z.object({
+  id: import_zod6.z.string().min(1),
   // Studio readers must preserve future event kinds within the same API major.
-  type: import_zod4.z.string().min(1),
-  occurredAt: import_zod4.z.string().datetime({ offset: true }),
-  receivedAt: import_zod4.z.string().datetime({ offset: true }),
-  environment: import_zod4.z.string().min(1),
-  serviceName: import_zod4.z.string().min(1),
-  deploymentRef: import_zod4.z.string().nullable(),
-  traceId: import_zod4.z.string().nullable(),
-  spanId: import_zod4.z.string().nullable(),
-  parentSpanId: import_zod4.z.string().nullable(),
-  runId: import_zod4.z.string().min(1),
-  sessionId: import_zod4.z.string().nullable(),
-  workflowId: import_zod4.z.string().min(1),
-  workflowRevisionId: import_zod4.z.string().nullable(),
-  nodeId: import_zod4.z.string().nullable(),
-  userId: import_zod4.z.string().nullable(),
-  tenantId: import_zod4.z.string().nullable(),
-  tags: import_zod4.z.array(import_zod4.z.string()),
-  metadata: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).nullable(),
-  payload: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown())
+  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())
 }).strip();
-var StudioWorkflowNodeSchema = import_zod4.z.object({
-  tools: import_zod4.z.array(StudioToolSchema).optional(),
+var StudioWorkflowNodeSchema = import_zod6.z.object({
+  tools: import_zod6.z.array(StudioToolSchema).optional(),
   toolDiscovery: ToolDiscoverySchema.optional(),
-  id: import_zod4.z.string().min(1),
-  label: import_zod4.z.string(),
-  type: import_zod4.z.string().nullable(),
-  state: import_zod4.z.enum(["healthy", "warning", "failed", "interrupted", "retried"]).nullable(),
-  provider: import_zod4.z.string().nullable(),
-  model: import_zod4.z.string().nullable(),
+  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(),
   metrics: StudioMetricSchema
 }).strip();
-var StudioWorkflowInternalEdgeSchema = import_zod4.z.object({
-  id: import_zod4.z.string().min(1),
-  source: import_zod4.z.string().min(1),
-  target: import_zod4.z.string().min(1),
-  condition: import_zod4.z.string().nullable()
+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()
 }).strip();
-var StudioWorkflowTransitionSchema = import_zod4.z.object({
-  kind: import_zod4.z.enum(["call", "handoff"]).optional(),
-  id: import_zod4.z.string().min(1),
-  sourceWorkflowId: import_zod4.z.string().min(1),
-  sourceNodeId: import_zod4.z.string().nullable(),
-  targetWorkflowId: import_zod4.z.string().min(1),
-  condition: import_zod4.z.string().nullable(),
-  volume: import_zod4.z.number().int().nonnegative(),
-  successRate: import_zod4.z.number().min(0).max(100).nullable(),
-  medianDurationMs: import_zod4.z.number().nonnegative().nullable(),
-  errorRate: import_zod4.z.number().min(0).max(100).nullable()
+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()
 }).strip();
-var StudioWorkflowSchema = import_zod4.z.object({
-  id: import_zod4.z.string().min(1),
-  name: import_zod4.z.string().min(1),
-  description: import_zod4.z.string().nullable(),
-  versions: import_zod4.z.array(import_zod4.z.string()),
-  activeVersion: import_zod4.z.string().nullable(),
-  activeRevisionId: import_zod4.z.string().nullable(),
+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(),
   health: StudioWorkflowHealthSchema,
-  tags: import_zod4.z.array(import_zod4.z.string()),
-  lastActivityAt: import_zod4.z.string().datetime({ offset: true }).nullable(),
+  tags: import_zod6.z.array(import_zod6.z.string()),
+  lastActivityAt: import_zod6.z.string().datetime({ offset: true }).nullable(),
   metrics: StudioMetricSchema,
-  nodes: import_zod4.z.array(StudioWorkflowNodeSchema),
-  internalEdges: import_zod4.z.array(StudioWorkflowInternalEdgeSchema)
+  nodes: import_zod6.z.array(StudioWorkflowNodeSchema),
+  internalEdges: import_zod6.z.array(StudioWorkflowInternalEdgeSchema)
 }).strip();
-var StudioRunsResponseSchema = import_zod4.z.object({
-  runs: import_zod4.z.array(StudioRunSchema),
-  totalCount: import_zod4.z.number().int().nonnegative()
+var StudioRunsResponseSchema = import_zod6.z.object({
+  runs: import_zod6.z.array(StudioRunSchema),
+  totalCount: import_zod6.z.number().int().nonnegative()
 }).strip();
-var StudioSessionsResponseSchema = import_zod4.z.object({
-  sessions: import_zod4.z.array(StudioSessionSchema),
-  totalCount: import_zod4.z.number().int().nonnegative()
+var StudioSessionsResponseSchema = import_zod6.z.object({
+  sessions: import_zod6.z.array(StudioSessionSchema),
+  totalCount: import_zod6.z.number().int().nonnegative()
 }).strip();
-var StudioInterruptsResponseSchema = import_zod4.z.object({
-  interrupts: import_zod4.z.array(StudioInterruptSchema),
-  totalCount: import_zod4.z.number().int().nonnegative()
+var StudioInterruptsResponseSchema = import_zod6.z.object({
+  interrupts: import_zod6.z.array(StudioInterruptSchema),
+  totalCount: import_zod6.z.number().int().nonnegative()
 }).strip();
-var StudioRunDetailResponseSchema = import_zod4.z.object({
+var StudioRunDetailResponseSchema = import_zod6.z.object({
   run: StudioRunSchema,
-  scores: import_zod4.z.array(StudioScoreSchema).optional(),
-  canReview: import_zod4.z.boolean().optional(),
-  reviewActorId: import_zod4.z.string().optional(),
-  events: import_zod4.z.array(StudioDetailEventSchema),
+  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),
   session: StudioSessionSchema.nullable(),
-  interrupts: import_zod4.z.array(StudioInterruptSchema),
-  updatedAt: import_zod4.z.string().datetime({ offset: true })
+  interrupts: import_zod6.z.array(StudioInterruptSchema),
+  updatedAt: import_zod6.z.string().datetime({ offset: true })
 }).strip();
-var StudioSessionDetailResponseSchema = import_zod4.z.object({
+var StudioSessionDetailResponseSchema = import_zod6.z.object({
   session: StudioSessionSchema,
-  runs: import_zod4.z.array(StudioRunSchema),
-  events: import_zod4.z.array(StudioDetailEventSchema),
-  interrupts: import_zod4.z.array(StudioInterruptSchema),
-  updatedAt: import_zod4.z.string().datetime({ offset: true })
+  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 })
 }).strip();
-var StudioInterruptDetailResponseSchema = import_zod4.z.object({
+var StudioInterruptDetailResponseSchema = import_zod6.z.object({
   interrupt: StudioInterruptSchema,
-  events: import_zod4.z.array(StudioDetailEventSchema),
+  events: import_zod6.z.array(StudioDetailEventSchema),
   run: StudioRunSchema.nullable(),
   session: StudioSessionSchema.nullable(),
-  updatedAt: import_zod4.z.string().datetime({ offset: true })
+  updatedAt: import_zod6.z.string().datetime({ offset: true })
 }).strip();
-var StudioWorkflowsResponseSchema = import_zod4.z.object({
-  workflows: import_zod4.z.array(StudioWorkflowSchema),
-  observedCalls: import_zod4.z.array(
+var StudioWorkflowsResponseSchema = import_zod6.z.object({
+  workflows: import_zod6.z.array(StudioWorkflowSchema),
+  observedCalls: import_zod6.z.array(
     StudioWorkflowTransitionSchema.extend({
-      runId: import_zod4.z.string(),
-      invocationId: import_zod4.z.string(),
-      branchId: import_zod4.z.string()
+      runId: import_zod6.z.string(),
+      invocationId: import_zod6.z.string(),
+      branchId: import_zod6.z.string()
     })
   ).optional(),
-  transitions: import_zod4.z.array(StudioWorkflowTransitionSchema),
+  transitions: import_zod6.z.array(StudioWorkflowTransitionSchema),
   cohort: StudioTimeRangeContextSchema.extend({
-    workflowId: import_zod4.z.string().nullable(),
-    version: import_zod4.z.string().nullable()
+    workflowId: import_zod6.z.string().nullable(),
+    version: import_zod6.z.string().nullable()
   }).strip()
 }).strip();
-var StudioCatalogsResponseSchema = import_zod4.z.object({
-  environments: import_zod4.z.array(import_zod4.z.string()),
-  providers: import_zod4.z.array(import_zod4.z.string()),
-  models: import_zod4.z.array(import_zod4.z.string()),
-  workflows: import_zod4.z.array(import_zod4.z.string()),
-  tags: import_zod4.z.array(import_zod4.z.string())
+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())
 }).strip();
-var StudioContextResponseSchema = import_zod4.z.object({
-  organization: import_zod4.z.object({
-    name: import_zod4.z.string().min(1)
+var StudioContextResponseSchema = import_zod6.z.object({
+  organization: import_zod6.z.object({
+    name: import_zod6.z.string().min(1)
   }).strip(),
-  project: import_zod4.z.object({
-    name: import_zod4.z.string().min(1)
+  project: import_zod6.z.object({
+    name: import_zod6.z.string().min(1)
   }).strip(),
-  environments: import_zod4.z.array(import_zod4.z.string()),
-  apiKey: import_zod4.z.object({
-    mode: import_zod4.z.enum(["test", "live"]),
-    scopes: import_zod4.z.array(import_zod4.z.string())
+  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())
   }).strip().nullable(),
-  api: import_zod4.z.object({
-    status: import_zod4.z.literal("ok"),
-    service: import_zod4.z.literal("kortyx-api"),
-    version: import_zod4.z.string().min(1)
+  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)
   }).strip()
 }).strip();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ClearScoreResponseSchema,
   ClearUserFeedbackRequestSchema,
+  DIAGNOSTIC_LIMITS,
+  DiagnosticContentSchema,
+  DiagnosticCorrelationSchema,
+  DiagnosticManifestSchema,
+  DiagnosticNoteSchema,
+  DiagnosticPartSchema,
+  DiagnosticResponseSchema,
   EnsureWorkflowTopologyRequestSchema,
   EnsureWorkflowTopologyResponseSchema,
   FEEDBACK_FILTERS,
   FeedbackReasonSchema,
   FeedbackSummarySchema,
+  PromptAssetSchema,
+  PromptAssignmentSchema,
+  PromptBundleSchema,
+  PromptCategorySchema,
+  PromptDetailSchema,
+  PromptEvidenceSchema,
+  PromptGroupSchema,
+  PromptLibrarySchema,
+  PromptMutationSchema,
+  PromptPolicySchema,
+  PromptSelectionSchema,
+  PromptStoredVersionSchema,
+  PromptTransferRequestSchema,
+  PromptUsageSchema,
   ReviewVerdictSchema,
   STUDIO_API_PROTOCOL_VERSION,
   STUDIO_TIME_RANGES,
@@ -1146,11 +1689,15 @@ var StudioContextResponseSchema = import_zod4.z.object({
   WorkflowTopologyEdgeSchema,
   WorkflowTopologyNodeSchema,
   WorkflowTopologyTransitionSchema,
+  isPrivateDiagnosticField,
   newerStudioVersion,
   projectWorkflowCalls,
+  redactDiagnosticContent,
+  redactDiagnosticText,
   resolveStudioInterruptStatus,
   resolveStudioTimeRange,
   studioUpdateRunning,
+  summarizeDiagnostic,
   summarizeUserFeedback
 });
 //# sourceMappingURL=index.js.map