@kortyx/telemetry-contracts 0.15.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") {
@@ -33,6 +33,20 @@ __export(index_exports, {
   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,
@@ -113,7 +127,7 @@ __export(index_exports, {
   summarizeUserFeedback: () => summarizeUserFeedback
 });
 module.exports = __toCommonJS(index_exports);
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // src/scores.ts
 var import_zod = require("zod");
@@ -442,31 +456,337 @@ var StudioToolSchema = WorkflowToolSchema.extend({
   p95DurationMs: import_zod3.z.number().nonnegative().nullable()
 }).strict();
 
-// src/studio-updates.ts
+// src/prompts.ts
+var import_browser = require("@kortyx/prompts/browser");
 var import_zod4 = require("zod");
-var StudioReleaseVersionSchema = import_zod4.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
-var StudioReleaseDeploymentSchema = import_zod4.z.object({
-  strategy: import_zod4.z.enum(["rolling", "recreate"])
+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 StudioReleaseSchema = import_zod4.z.object({
-  format: import_zod4.z.literal(1),
-  installer: import_zod4.z.literal(1),
+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_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_zod5.z.object({
+  format: import_zod5.z.literal(1),
+  installer: import_zod5.z.literal(1),
   version: StudioReleaseVersionSchema,
-  api: import_zod4.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-api@sha256:[a-f0-9]{64}$/),
-  studio: import_zod4.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_zod4.z.object({
-  automatic: import_zod4.z.boolean(),
-  hourUtc: import_zod4.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_zod4.z.object({
-  id: import_zod4.z.uuid(),
-  from: import_zod4.z.string(),
+var StudioUpdateOperationSchema = import_zod5.z.object({
+  id: import_zod5.z.uuid(),
+  from: import_zod5.z.string(),
   release: StudioReleaseSchema,
-  phase: import_zod4.z.enum([
+  phase: import_zod5.z.enum([
     "starting",
     "pulling",
     "backup",
@@ -475,16 +795,16 @@ var StudioUpdateOperationSchema = import_zod4.z.object({
     "succeeded",
     "failed"
   ]),
-  startedAt: import_zod4.z.iso.datetime(),
-  updatedAt: import_zod4.z.iso.datetime(),
-  backup: import_zod4.z.string().nullable(),
-  messages: import_zod4.z.array(import_zod4.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_zod4.z.object({
-  current: import_zod4.z.string().nullable(),
+var StudioUpdateStatusSchema = import_zod5.z.object({
+  current: import_zod5.z.string().nullable(),
   available: StudioReleaseSchema.nullable(),
-  checkedAt: import_zod4.z.iso.datetime().nullable(),
-  checkError: import_zod4.z.string().nullable(),
+  checkedAt: import_zod5.z.iso.datetime().nullable(),
+  checkError: import_zod5.z.string().nullable(),
   settings: StudioUpdateSettingsSchema,
   operation: StudioUpdateOperationSchema.nullable()
 });
@@ -639,82 +959,82 @@ var TELEMETRY_EVENT_TYPES = [
   "session.forked",
   "session.rolled_back"
 ];
-var TelemetryServiceSchema = import_zod5.z.object({
-  name: import_zod5.z.string().min(1),
-  deploymentRef: import_zod5.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_zod5.z.object({
-  id: import_zod5.z.string().min(1),
-  label: import_zod5.z.string().optional(),
-  type: import_zod5.z.string().optional(),
-  provider: import_zod5.z.string().optional(),
-  model: import_zod5.z.string().optional(),
-  metadata: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional(),
-  tools: import_zod5.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_zod5.z.object({
-  sourceNodeId: import_zod5.z.string().min(1),
-  targetNodeId: import_zod5.z.string().min(1),
-  condition: import_zod5.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_zod5.z.object({
-  sourceNodeId: import_zod5.z.string().min(1),
-  targetWorkflowId: import_zod5.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_zod5.z.object({
-  sourceNodeId: import_zod5.z.string().min(1).optional(),
-  targetWorkflowId: import_zod5.z.string().min(1),
-  condition: import_zod5.z.string().optional(),
-  intent: import_zod5.z.string().optional(),
-  kind: import_zod5.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_zod5.z.object({
-  schemaVersion: import_zod5.z.literal(1),
-  environment: import_zod5.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_zod5.z.object({
-    id: import_zod5.z.string().min(1),
-    declaredVersion: import_zod5.z.string().min(1),
-    description: import_zod5.z.string().optional(),
-    tags: import_zod5.z.array(import_zod5.z.string()).optional(),
-    topologyHash: import_zod5.z.string().regex(/^[a-f0-9]{64}$/),
-    nodes: import_zod5.z.array(WorkflowTopologyNodeSchema),
-    edges: import_zod5.z.array(WorkflowTopologyEdgeSchema),
-    transitions: import_zod5.z.array(WorkflowTopologyTransitionSchema).optional(),
-    calls: import_zod5.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_zod5.z.object({ workflowRevisionId: import_zod5.z.string().min(1), created: import_zod5.z.boolean() }).strict();
-var TelemetryEventTypeSchema = import_zod5.z.enum(TELEMETRY_EVENT_TYPES);
-var TelemetryEventSchema = import_zod5.z.object({
-  schemaVersion: import_zod5.z.literal(1),
-  eventId: import_zod5.z.string().min(1),
-  occurredAt: import_zod5.z.string().datetime({ offset: true }),
-  environment: import_zod5.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_zod5.z.object({
-    invocationId: import_zod5.z.string().optional(),
-    parentInvocationId: import_zod5.z.string().optional(),
-    branchId: import_zod5.z.string().optional(),
-    traceId: import_zod5.z.string().optional(),
-    spanId: import_zod5.z.string().optional(),
-    parentSpanId: import_zod5.z.string().optional(),
-    runId: import_zod5.z.string().min(1),
-    sessionId: import_zod5.z.string().optional(),
-    workflowId: import_zod5.z.string().min(1),
-    workflowRevisionId: import_zod5.z.string().optional(),
-    topologyHash: import_zod5.z.string().regex(/^[a-f0-9]{64}$/).optional(),
-    nodeId: import_zod5.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_zod5.z.object({
-    userId: import_zod5.z.string().optional(),
-    tenantId: import_zod5.z.string().optional(),
-    tags: import_zod5.z.array(import_zod5.z.string()).optional(),
-    metadata: import_zod5.z.record(import_zod5.z.string(), import_zod5.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_zod5.z.record(import_zod5.z.string(), import_zod5.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 || [
@@ -757,20 +1077,20 @@ var TelemetryEventSchema = import_zod5.z.object({
       });
   }
 });
-var TelemetryEventBatchSchema = import_zod5.z.object({ events: import_zod5.z.array(TelemetryEventSchema).min(1) }).strict();
-var TelemetryEventBatchResponseSchema = import_zod5.z.object({
-  accepted: import_zod5.z.number().int().nonnegative(),
-  inserted: import_zod5.z.number().int().nonnegative(),
-  duplicates: import_zod5.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_zod5.z.enum([
+var TelemetryPricingSourceSchema = import_zod6.z.enum([
   "sdk",
   "provider",
   "custom",
   "project-rate-card",
   "default-rate-card"
 ]);
-var TelemetryPricingUnitSchema = import_zod5.z.enum([
+var TelemetryPricingUnitSchema = import_zod6.z.enum([
   "token",
   "character",
   "request",
@@ -783,7 +1103,7 @@ var TelemetryPricingUnitSchema = import_zod5.z.enum([
   "minute",
   "custom"
 ]);
-var TelemetryPricingUsageTypeSchema = import_zod5.z.enum([
+var TelemetryPricingUsageTypeSchema = import_zod6.z.enum([
   "input",
   "output",
   "reasoning",
@@ -799,42 +1119,42 @@ var TelemetryPricingUsageTypeSchema = import_zod5.z.enum([
   "request",
   "custom"
 ]);
-var TelemetryUsageItemSchema = import_zod5.z.object({
+var TelemetryUsageItemSchema = import_zod6.z.object({
   usageType: TelemetryPricingUsageTypeSchema,
-  quantity: import_zod5.z.number().nonnegative(),
+  quantity: import_zod6.z.number().nonnegative(),
   unit: TelemetryPricingUnitSchema,
-  label: import_zod5.z.string().optional()
+  label: import_zod6.z.string().optional()
 }).strict();
-var TelemetryUnitPriceSchema = import_zod5.z.object({
+var TelemetryUnitPriceSchema = import_zod6.z.object({
   usageType: TelemetryPricingUsageTypeSchema,
   unit: TelemetryPricingUnitSchema,
-  unitQuantity: import_zod5.z.number().positive().default(1),
-  priceMicros: import_zod5.z.number().int().nonnegative(),
-  label: import_zod5.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_zod5.z.object({
+var TelemetryPricingLineItemSchema = import_zod6.z.object({
   usageType: TelemetryPricingUsageTypeSchema,
-  quantity: import_zod5.z.number().nonnegative(),
+  quantity: import_zod6.z.number().nonnegative(),
   unit: TelemetryPricingUnitSchema,
-  unitQuantity: import_zod5.z.number().positive().default(1),
-  unitPriceMicros: import_zod5.z.number().int().nonnegative().optional(),
-  totalCostMicros: import_zod5.z.number().int().nonnegative().optional(),
-  label: import_zod5.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_zod5.z.object({
+var TelemetryPricingHintSchema = import_zod6.z.object({
   source: TelemetryPricingSourceSchema.extract(["sdk", "provider", "custom"]),
-  currency: import_zod5.z.string().min(3).max(12).default("USD"),
-  actualCostMicros: import_zod5.z.number().int().nonnegative().optional(),
-  lineItems: import_zod5.z.array(TelemetryPricingLineItemSchema).optional(),
-  unitPrices: import_zod5.z.array(TelemetryUnitPriceSchema).optional(),
-  usageItems: import_zod5.z.array(TelemetryUsageItemSchema).optional(),
-  pricingRef: import_zod5.z.string().min(1).optional(),
-  metadata: import_zod5.z.record(import_zod5.z.string(), import_zod5.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_zod5.z.enum([
+var StudioRunStatusSchema = import_zod6.z.enum([
   "running",
   "completed",
   "interrupted",
@@ -850,16 +1170,16 @@ var STUDIO_TIME_RANGES = [
   "All time",
   "Custom range"
 ];
-var StudioTimeRangeSchema = import_zod5.z.enum(STUDIO_TIME_RANGES);
-var StudioTimeRangeQuerySchema = import_zod5.z.object({
+var StudioTimeRangeSchema = import_zod6.z.enum(STUDIO_TIME_RANGES);
+var StudioTimeRangeQuerySchema = import_zod6.z.object({
   range: StudioTimeRangeSchema.optional(),
-  startedAfter: import_zod5.z.string().optional(),
-  startedBefore: import_zod5.z.string().optional()
+  startedAfter: import_zod6.z.string().optional(),
+  startedBefore: import_zod6.z.string().optional()
 }).strict();
-var StudioTimeRangeContextSchema = import_zod5.z.object({
+var StudioTimeRangeContextSchema = import_zod6.z.object({
   range: StudioTimeRangeSchema,
-  startedAfter: import_zod5.z.string().datetime({ offset: true }).nullable(),
-  startedBefore: import_zod5.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,
@@ -933,7 +1253,7 @@ var resolveStudioTimeRange = (input, now = /* @__PURE__ */ new Date()) => {
     }
   };
 };
-var StudioInterruptStatusSchema = import_zod5.z.enum([
+var StudioInterruptStatusSchema = import_zod6.z.enum([
   "pending",
   "resolved",
   "expired",
@@ -946,329 +1266,329 @@ 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_zod5.z.enum([
+var StudioInterruptTypeSchema = import_zod6.z.enum([
   "choice",
   "multi-choice",
   "text",
   "structured",
   "unknown"
 ]);
-var StudioInterruptInteractionModeSchema = import_zod5.z.enum([
+var StudioInterruptInteractionModeSchema = import_zod6.z.enum([
   "static-options",
   "dynamic-picker",
   "freeform",
   "unknown"
 ]);
-var StudioInterruptOptionSchema = import_zod5.z.object({
-  id: import_zod5.z.string().min(1),
-  label: import_zod5.z.string().min(1),
-  description: import_zod5.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_zod5.z.union([
-  import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()),
-  import_zod5.z.array(import_zod5.z.unknown()),
-  import_zod5.z.string(),
-  import_zod5.z.number(),
-  import_zod5.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_zod5.z.enum([
+var StudioResumeOutcomeSchema = import_zod6.z.enum([
   "resumed",
   "resume failed",
   "expired before resume",
   "cancelled"
 ]);
-var StudioWorkflowHealthSchema = import_zod5.z.enum([
+var StudioWorkflowHealthSchema = import_zod6.z.enum([
   "unknown",
   "healthy",
   "degraded",
   "failing",
   "idle"
 ]);
-var StudioPricingStatusSchema = import_zod5.z.enum([
+var StudioPricingStatusSchema = import_zod6.z.enum([
   "priced",
   "unpriced",
   "unknown"
 ]);
 var StudioPricingSourceSchema = TelemetryPricingSourceSchema.nullable();
-var StudioChangeResourceSchema = import_zod5.z.enum([
+var StudioChangeResourceSchema = import_zod6.z.enum([
   "evals",
   "workflows",
   "runs",
   "sessions",
   "interrupts"
 ]);
-var StudioChangeSchema = import_zod5.z.object({
-  schemaVersion: import_zod5.z.literal(1),
-  changeId: import_zod5.z.string().min(1),
-  emittedAt: import_zod5.z.string().datetime({ offset: true }),
-  organizationId: import_zod5.z.string().min(1),
-  projectId: import_zod5.z.string().min(1),
-  environment: import_zod5.z.string().min(1).optional(),
-  resources: import_zod5.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_zod5.z.object({
-  runCount: import_zod5.z.number().int().nonnegative(),
-  successRate: import_zod5.z.number().min(0).max(100).nullable(),
-  errorRate: import_zod5.z.number().min(0).max(100).nullable(),
-  retryCount: import_zod5.z.number().int().nonnegative().nullable(),
-  interruptRate: import_zod5.z.number().min(0).max(100).nullable(),
-  p50DurationMs: import_zod5.z.number().nonnegative().nullable(),
-  p95DurationMs: import_zod5.z.number().nonnegative().nullable(),
-  averageTokens: import_zod5.z.number().nonnegative().nullable(),
-  averageCost: import_zod5.z.number().nonnegative().nullable(),
-  currency: import_zod5.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_zod5.z.object({
-  id: import_zod5.z.string().min(1),
+var StudioRunSchema = import_zod6.z.object({
+  id: import_zod6.z.string().min(1),
   feedback: FeedbackSummarySchema.optional(),
-  callerNodeId: import_zod5.z.string().optional(),
-  parentRunId: import_zod5.z.string().optional(),
-  parentWorkflowId: import_zod5.z.string().optional(),
-  invocationId: import_zod5.z.string().optional(),
-  branchId: import_zod5.z.string().optional(),
-  callId: import_zod5.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_zod5.z.string().datetime({ offset: true }),
-  endedAt: import_zod5.z.string().datetime({ offset: true }).nullable(),
-  workflowId: import_zod5.z.string().min(1),
-  workflowIds: import_zod5.z.array(import_zod5.z.string().min(1)),
-  workflowRefs: import_zod5.z.array(
-    import_zod5.z.object({
-      workflowId: import_zod5.z.string().min(1),
-      workflowRevisionId: import_zod5.z.string().nullable(),
-      declaredVersion: import_zod5.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_zod5.z.string().nullable(),
-  declaredVersion: import_zod5.z.string().nullable(),
-  transitionIds: import_zod5.z.array(import_zod5.z.string().min(1)),
-  path: import_zod5.z.array(import_zod5.z.string()),
-  sessionId: import_zod5.z.string().nullable(),
-  provider: import_zod5.z.string().nullable(),
-  model: import_zod5.z.string().nullable(),
-  models: import_zod5.z.array(import_zod5.z.string()),
-  durationMs: import_zod5.z.number().nonnegative().nullable(),
-  tokens: import_zod5.z.number().int().nonnegative().nullable(),
-  cost: import_zod5.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_zod5.z.string().nullable(),
-  result: import_zod5.z.string().nullable(),
-  environment: import_zod5.z.string().min(1),
-  userId: import_zod5.z.string().nullable(),
-  tenantId: import_zod5.z.string().nullable(),
-  hasTool: import_zod5.z.boolean(),
-  hasRetry: import_zod5.z.boolean(),
-  interruptNodeId: import_zod5.z.string().nullable(),
-  interruptId: import_zod5.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_zod5.z.string().datetime({ offset: true }).nullable().optional()
+  interruptExpiresAt: import_zod6.z.string().datetime({ offset: true }).nullable().optional()
 }).strip();
-var StudioSessionSchema = import_zod5.z.object({
-  id: import_zod5.z.string().min(1),
+var StudioSessionSchema = import_zod6.z.object({
+  id: import_zod6.z.string().min(1),
   status: StudioRunStatusSchema,
-  lastActivityAt: import_zod5.z.string().datetime({ offset: true }),
-  workflowIds: import_zod5.z.array(import_zod5.z.string()),
-  workflowCount: import_zod5.z.number().int().nonnegative(),
-  activeWorkflowId: import_zod5.z.string().nullable(),
-  activeVersion: import_zod5.z.string().nullable(),
-  userId: import_zod5.z.string().nullable(),
-  tenantId: import_zod5.z.string().nullable(),
-  runs: import_zod5.z.number().int().nonnegative(),
-  succeeded: import_zod5.z.number().int().nonnegative(),
-  failed: import_zod5.z.number().int().nonnegative(),
-  interrupted: import_zod5.z.number().int().nonnegative(),
-  checkpoints: import_zod5.z.number().int().nonnegative(),
-  hasFork: import_zod5.z.boolean(),
-  durationMs: import_zod5.z.number().nonnegative().nullable(),
-  tokens: import_zod5.z.number().int().nonnegative().nullable(),
-  cost: import_zod5.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_zod5.z.string().nullable(),
-  latestResult: import_zod5.z.string().nullable(),
-  latestError: import_zod5.z.string().nullable(),
-  pendingInterruptId: import_zod5.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_zod5.z.string().datetime({ offset: true }).nullable().optional(),
-  providers: import_zod5.z.array(import_zod5.z.string()),
-  models: import_zod5.z.array(import_zod5.z.string()),
-  tags: import_zod5.z.array(import_zod5.z.string()),
-  environment: import_zod5.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_zod5.z.object({
-  afterResponseCompleted: import_zod5.z.boolean().optional(),
-  id: import_zod5.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_zod5.z.string().nullable().default(null),
-  schemaId: import_zod5.z.string().nullable(),
-  schemaVersion: import_zod5.z.string().nullable(),
-  createdAt: import_zod5.z.string().datetime({ offset: true }),
-  resolvedAt: import_zod5.z.string().datetime({ offset: true }).nullable(),
-  expiresAt: import_zod5.z.string().datetime({ offset: true }).nullable(),
-  question: import_zod5.z.string().nullable(),
-  contentCaptured: import_zod5.z.boolean(),
-  request: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).nullable().default(null),
-  requestCaptured: import_zod5.z.boolean().default(false),
-  optionCount: import_zod5.z.number().int().nonnegative().nullable(),
-  options: import_zod5.z.array(StudioInterruptOptionSchema).nullable(),
-  workflowId: import_zod5.z.string().min(1),
-  nodeId: import_zod5.z.string().nullable(),
-  sessionId: import_zod5.z.string().nullable(),
-  userId: import_zod5.z.string().nullable(),
-  tenantId: import_zod5.z.string().nullable(),
-  response: import_zod5.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_zod5.z.boolean(),
+  responseCaptured: import_zod6.z.boolean(),
   resumeOutcome: StudioResumeOutcomeSchema.nullable(),
-  resumeError: import_zod5.z.string().nullable(),
-  runId: import_zod5.z.string().min(1),
-  resumeToken: import_zod5.z.string().nullable(),
-  resolvedBy: import_zod5.z.string().nullable(),
-  environment: import_zod5.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_zod5.z.object({
-  id: import_zod5.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_zod5.z.string().min(1),
-  occurredAt: import_zod5.z.string().datetime({ offset: true }),
-  receivedAt: import_zod5.z.string().datetime({ offset: true }),
-  environment: import_zod5.z.string().min(1),
-  serviceName: import_zod5.z.string().min(1),
-  deploymentRef: import_zod5.z.string().nullable(),
-  traceId: import_zod5.z.string().nullable(),
-  spanId: import_zod5.z.string().nullable(),
-  parentSpanId: import_zod5.z.string().nullable(),
-  runId: import_zod5.z.string().min(1),
-  sessionId: import_zod5.z.string().nullable(),
-  workflowId: import_zod5.z.string().min(1),
-  workflowRevisionId: import_zod5.z.string().nullable(),
-  nodeId: import_zod5.z.string().nullable(),
-  userId: import_zod5.z.string().nullable(),
-  tenantId: import_zod5.z.string().nullable(),
-  tags: import_zod5.z.array(import_zod5.z.string()),
-  metadata: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).nullable(),
-  payload: import_zod5.z.record(import_zod5.z.string(), import_zod5.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_zod5.z.object({
-  tools: import_zod5.z.array(StudioToolSchema).optional(),
+var StudioWorkflowNodeSchema = import_zod6.z.object({
+  tools: import_zod6.z.array(StudioToolSchema).optional(),
   toolDiscovery: ToolDiscoverySchema.optional(),
-  id: import_zod5.z.string().min(1),
-  label: import_zod5.z.string(),
-  type: import_zod5.z.string().nullable(),
-  state: import_zod5.z.enum(["healthy", "warning", "failed", "interrupted", "retried"]).nullable(),
-  provider: import_zod5.z.string().nullable(),
-  model: import_zod5.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_zod5.z.object({
-  id: import_zod5.z.string().min(1),
-  source: import_zod5.z.string().min(1),
-  target: import_zod5.z.string().min(1),
-  condition: import_zod5.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_zod5.z.object({
-  kind: import_zod5.z.enum(["call", "handoff"]).optional(),
-  id: import_zod5.z.string().min(1),
-  sourceWorkflowId: import_zod5.z.string().min(1),
-  sourceNodeId: import_zod5.z.string().nullable(),
-  targetWorkflowId: import_zod5.z.string().min(1),
-  condition: import_zod5.z.string().nullable(),
-  volume: import_zod5.z.number().int().nonnegative(),
-  successRate: import_zod5.z.number().min(0).max(100).nullable(),
-  medianDurationMs: import_zod5.z.number().nonnegative().nullable(),
-  errorRate: import_zod5.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_zod5.z.object({
-  id: import_zod5.z.string().min(1),
-  name: import_zod5.z.string().min(1),
-  description: import_zod5.z.string().nullable(),
-  versions: import_zod5.z.array(import_zod5.z.string()),
-  activeVersion: import_zod5.z.string().nullable(),
-  activeRevisionId: import_zod5.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_zod5.z.array(import_zod5.z.string()),
-  lastActivityAt: import_zod5.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_zod5.z.array(StudioWorkflowNodeSchema),
-  internalEdges: import_zod5.z.array(StudioWorkflowInternalEdgeSchema)
+  nodes: import_zod6.z.array(StudioWorkflowNodeSchema),
+  internalEdges: import_zod6.z.array(StudioWorkflowInternalEdgeSchema)
 }).strip();
-var StudioRunsResponseSchema = import_zod5.z.object({
-  runs: import_zod5.z.array(StudioRunSchema),
-  totalCount: import_zod5.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_zod5.z.object({
-  sessions: import_zod5.z.array(StudioSessionSchema),
-  totalCount: import_zod5.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_zod5.z.object({
-  interrupts: import_zod5.z.array(StudioInterruptSchema),
-  totalCount: import_zod5.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_zod5.z.object({
+var StudioRunDetailResponseSchema = import_zod6.z.object({
   run: StudioRunSchema,
-  scores: import_zod5.z.array(StudioScoreSchema).optional(),
-  canReview: import_zod5.z.boolean().optional(),
-  reviewActorId: import_zod5.z.string().optional(),
-  events: import_zod5.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_zod5.z.array(StudioInterruptSchema),
-  updatedAt: import_zod5.z.string().datetime({ offset: true })
+  interrupts: import_zod6.z.array(StudioInterruptSchema),
+  updatedAt: import_zod6.z.string().datetime({ offset: true })
 }).strip();
-var StudioSessionDetailResponseSchema = import_zod5.z.object({
+var StudioSessionDetailResponseSchema = import_zod6.z.object({
   session: StudioSessionSchema,
-  runs: import_zod5.z.array(StudioRunSchema),
-  events: import_zod5.z.array(StudioDetailEventSchema),
-  interrupts: import_zod5.z.array(StudioInterruptSchema),
-  updatedAt: import_zod5.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_zod5.z.object({
+var StudioInterruptDetailResponseSchema = import_zod6.z.object({
   interrupt: StudioInterruptSchema,
-  events: import_zod5.z.array(StudioDetailEventSchema),
+  events: import_zod6.z.array(StudioDetailEventSchema),
   run: StudioRunSchema.nullable(),
   session: StudioSessionSchema.nullable(),
-  updatedAt: import_zod5.z.string().datetime({ offset: true })
+  updatedAt: import_zod6.z.string().datetime({ offset: true })
 }).strip();
-var StudioWorkflowsResponseSchema = import_zod5.z.object({
-  workflows: import_zod5.z.array(StudioWorkflowSchema),
-  observedCalls: import_zod5.z.array(
+var StudioWorkflowsResponseSchema = import_zod6.z.object({
+  workflows: import_zod6.z.array(StudioWorkflowSchema),
+  observedCalls: import_zod6.z.array(
     StudioWorkflowTransitionSchema.extend({
-      runId: import_zod5.z.string(),
-      invocationId: import_zod5.z.string(),
-      branchId: import_zod5.z.string()
+      runId: import_zod6.z.string(),
+      invocationId: import_zod6.z.string(),
+      branchId: import_zod6.z.string()
     })
   ).optional(),
-  transitions: import_zod5.z.array(StudioWorkflowTransitionSchema),
+  transitions: import_zod6.z.array(StudioWorkflowTransitionSchema),
   cohort: StudioTimeRangeContextSchema.extend({
-    workflowId: import_zod5.z.string().nullable(),
-    version: import_zod5.z.string().nullable()
+    workflowId: import_zod6.z.string().nullable(),
+    version: import_zod6.z.string().nullable()
   }).strip()
 }).strip();
-var StudioCatalogsResponseSchema = import_zod5.z.object({
-  environments: import_zod5.z.array(import_zod5.z.string()),
-  providers: import_zod5.z.array(import_zod5.z.string()),
-  models: import_zod5.z.array(import_zod5.z.string()),
-  workflows: import_zod5.z.array(import_zod5.z.string()),
-  tags: import_zod5.z.array(import_zod5.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_zod5.z.object({
-  organization: import_zod5.z.object({
-    name: import_zod5.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_zod5.z.object({
-    name: import_zod5.z.string().min(1)
+  project: import_zod6.z.object({
+    name: import_zod6.z.string().min(1)
   }).strip(),
-  environments: import_zod5.z.array(import_zod5.z.string()),
-  apiKey: import_zod5.z.object({
-    mode: import_zod5.z.enum(["test", "live"]),
-    scopes: import_zod5.z.array(import_zod5.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_zod5.z.object({
-    status: import_zod5.z.literal("ok"),
-    service: import_zod5.z.literal("kortyx-api"),
-    version: import_zod5.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:
@@ -1287,6 +1607,20 @@ var StudioContextResponseSchema = import_zod5.z.object({
   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,