@kortyx/agent 0.34.0 → 0.37.0

package/dist/index.js

@@ -37,8 +37,8 @@ var require_dist = __commonJS({
     var __getOwnPropNames2 = Object.getOwnPropertyNames;
     var __hasOwnProp2 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
-      for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
+      for (var name2 in all)
+        __defProp2(target, name2, { get: all[name2], enumerable: true });
     };
     var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
@@ -65,6 +65,20 @@ var require_dist = __commonJS({
       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,
@@ -145,7 +159,7 @@ var require_dist = __commonJS({
       summarizeUserFeedback: () => summarizeUserFeedback
     });
     module2.exports = __toCommonJS2(index_exports2);
-    var import_zod52 = require("zod");
+    var import_zod62 = require("zod");
     var import_zod12 = require("zod");
     var FEEDBACK_FILTERS = ["positive", "negative", "unrated"];
     var FeedbackSummarySchema = import_zod12.z.object({
@@ -467,30 +481,334 @@ var require_dist = __commonJS({
       p50DurationMs: import_zod32.z.number().nonnegative().nullable(),
       p95DurationMs: import_zod32.z.number().nonnegative().nullable()
     }).strict();
+    var import_browser4 = require("@kortyx/prompts/browser");
     var import_zod42 = require("zod");
-    var StudioReleaseVersionSchema = import_zod42.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
-    var StudioReleaseDeploymentSchema = import_zod42.z.object({
-      strategy: import_zod42.z.enum(["rolling", "recreate"])
+    var name = import_zod42.z.string().trim().min(1).max(200);
+    var version = import_zod42.z.number().int().positive();
+    var revision = import_zod42.z.number().int().nonnegative();
+    var PromptCategorySchema = import_zod42.z.object({
+      id: import_zod42.z.uuid(),
+      name,
+      parentId: import_zod42.z.uuid().nullable(),
+      revision
+    });
+    var PromptGroupSchema = import_zod42.z.object({
+      id: import_zod42.z.uuid(),
+      name,
+      revision,
+      members: import_zod42.z.array(
+        import_zod42.z.object({
+          promptId: import_zod42.z.uuid(),
+          version,
+          key: import_browser4.PromptKeySchema.optional(),
+          name: name.optional(),
+          archived: import_zod42.z.boolean().optional()
+        })
+      ).max(100),
+      updatedAt: import_zod42.z.string()
+    });
+    var PromptAssignmentSchema = import_zod42.z.object({
+      tag: import_browser4.PromptTagSchema,
+      version,
+      revision,
+      updatedAt: import_zod42.z.string()
+    });
+    var PromptAssetSchema = import_zod42.z.object({
+      id: import_zod42.z.uuid(),
+      key: import_browser4.PromptKeySchema,
+      name,
+      categoryId: import_zod42.z.uuid().nullable(),
+      latestVersion: version,
+      revision,
+      archived: import_zod42.z.boolean(),
+      updatedAt: import_zod42.z.string(),
+      assignments: import_zod42.z.array(PromptAssignmentSchema)
+    });
+    var PromptLibrarySchema = import_zod42.z.object({
+      schemaVersion: import_zod42.z.literal(1),
+      assets: import_zod42.z.array(PromptAssetSchema),
+      categories: import_zod42.z.array(PromptCategorySchema),
+      groups: import_zod42.z.array(PromptGroupSchema),
+      totalCount: import_zod42.z.number().int().nonnegative(),
+      nextCursor: import_zod42.z.string().nullable(),
+      permissions: import_zod42.z.object({
+        edit: import_zod42.z.boolean(),
+        promote: import_zod42.z.boolean(),
+        review: import_zod42.z.boolean(),
+        settings: import_zod42.z.boolean()
+      })
+    });
+    var PromptStoredVersionSchema = import_browser4.PromptVersionSchema.extend({
+      promptId: import_zod42.z.uuid(),
+      note: import_zod42.z.string(),
+      author: import_zod42.z.string(),
+      createdAt: import_zod42.z.string(),
+      origin: import_zod42.z.object({
+        apiUrl: import_zod42.z.string(),
+        projectId: import_zod42.z.string(),
+        key: import_zod42.z.string(),
+        version,
+        hash: import_zod42.z.string()
+      }).nullable()
+    });
+    var PromptPolicySchema = import_zod42.z.object({
+      revision,
+      requireTest: import_zod42.z.boolean(),
+      requireChangeNote: import_zod42.z.boolean().default(false),
+      requiredSuites: import_zod42.z.array(import_zod42.z.object({ targetId: name, suiteId: name })).max(100),
+      requiredReviews: import_zod42.z.number().int().min(0).max(10),
+      allowException: import_zod42.z.boolean()
+    });
+    var PromptEvidenceSchema = import_zod42.z.object({
+      environment: import_zod42.z.string(),
+      runId: import_zod42.z.string(),
+      evaluationId: import_zod42.z.string().nullable().optional(),
+      targetId: import_zod42.z.string(),
+      suiteId: import_zod42.z.string(),
+      suiteRevision: import_zod42.z.string().optional(),
+      status: import_zod42.z.string(),
+      version,
+      fullSuite: import_zod42.z.boolean(),
+      usage: import_zod42.z.enum([
+        "verified",
+        "pending",
+        "not-used",
+        "mismatch",
+        "context-differs"
+      ]),
+      groupName: import_zod42.z.string().nullable(),
+      createdAt: import_zod42.z.string(),
+      companions: import_zod42.z.array(import_zod42.z.object({ key: import_browser4.PromptKeySchema, version }))
+    });
+    var PromptUsageSchema = import_zod42.z.object({
+      eventId: import_zod42.z.string(),
+      runId: import_zod42.z.string(),
+      sessionId: import_zod42.z.string().nullable(),
+      nodeId: import_zod42.z.string().nullable(),
+      version: import_zod42.z.number().int(),
+      hash: import_zod42.z.string().nullable(),
+      source: import_zod42.z.string().nullable(),
+      model: import_zod42.z.string().nullable(),
+      environment: import_zod42.z.string(),
+      occurredAt: import_zod42.z.string(),
+      captured: import_zod42.z.boolean()
+    });
+    var PromptDetailSchema = import_zod42.z.object({
+      asset: PromptAssetSchema,
+      versions: import_zod42.z.array(PromptStoredVersionSchema),
+      versionsNextCursor: import_zod42.z.string().nullable().optional(),
+      draft: import_browser4.PromptContentSchema.nullable(),
+      draftBase: import_zod42.z.number().int().nullable(),
+      draftRevision: revision,
+      evidence: import_zod42.z.array(PromptEvidenceSchema),
+      usage: import_zod42.z.array(PromptUsageSchema),
+      activity: import_zod42.z.array(
+        import_zod42.z.object({
+          id: import_zod42.z.string(),
+          action: import_zod42.z.string(),
+          actor: import_zod42.z.string(),
+          details: import_zod42.z.record(import_zod42.z.string(), import_zod42.z.unknown()),
+          createdAt: import_zod42.z.string()
+        })
+      ),
+      policies: import_zod42.z.array(PromptPolicySchema),
+      reviews: import_zod42.z.array(
+        import_zod42.z.object({
+          version,
+          hash: import_zod42.z.string(),
+          independent: import_zod42.z.boolean(),
+          reviewer: import_zod42.z.string(),
+          note: import_zod42.z.string(),
+          createdAt: import_zod42.z.string()
+        })
+      ).optional()
+    });
+    var PromptMutationSchema = import_zod42.z.discriminatedUnion("action", [
+      import_zod42.z.object({
+        action: import_zod42.z.literal("tag-set"),
+        id: import_zod42.z.uuid(),
+        tag: import_browser4.PromptTagSchema.refine(
+          (tag) => tag !== "live",
+          "Use promotion to update live."
+        ),
+        version,
+        expectedRevision: revision
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("tag-remove"),
+        id: import_zod42.z.uuid(),
+        tag: import_browser4.PromptTagSchema.refine(
+          (tag) => tag !== "live",
+          "The live tag cannot be removed manually."
+        ),
+        expectedRevision: revision
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("bulk-update"),
+        assets: import_zod42.z.array(import_zod42.z.object({ id: import_zod42.z.uuid(), expectedRevision: revision })).min(1).max(100),
+        categoryId: import_zod42.z.uuid().nullable().optional(),
+        archived: import_zod42.z.boolean().optional()
+      }).strict().refine(
+        (value) => value.categoryId !== void 0 || value.archived !== void 0,
+        "Choose a category or archive state."
+      ),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("create"),
+        key: import_browser4.PromptKeySchema,
+        name,
+        categoryId: import_zod42.z.uuid().nullable().default(null),
+        content: import_browser4.PromptContentSchema,
+        note: import_zod42.z.string().trim().max(2e3).default(""),
+        idempotencyKey: import_zod42.z.uuid().optional()
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("draft"),
+        id: import_zod42.z.uuid(),
+        content: import_browser4.PromptContentSchema,
+        baseVersion: version,
+        expectedRevision: revision
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("discard-draft"),
+        id: import_zod42.z.uuid(),
+        expectedRevision: revision
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("save"),
+        id: import_zod42.z.uuid(),
+        content: import_browser4.PromptContentSchema,
+        baseVersion: version,
+        expectedHash: import_zod42.z.string().regex(/^[a-f0-9]{64}$/),
+        expectedDraftRevision: revision.optional(),
+        note: import_zod42.z.string().trim().max(2e3).default(""),
+        idempotencyKey: import_zod42.z.uuid()
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("update"),
+        id: import_zod42.z.uuid(),
+        expectedRevision: revision,
+        name: name.optional(),
+        categoryId: import_zod42.z.uuid().nullable().optional(),
+        archived: import_zod42.z.boolean().optional()
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("category-create"),
+        path: import_zod42.z.string().trim().min(1).max(1e3)
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("category-update"),
+        id: import_zod42.z.uuid(),
+        expectedRevision: revision,
+        name: name.optional(),
+        parentId: import_zod42.z.uuid().nullable().optional()
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("category-delete"),
+        id: import_zod42.z.uuid(),
+        expectedRevision: revision,
+        destinationId: import_zod42.z.uuid().nullable()
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("group-create"),
+        name,
+        members: import_zod42.z.array(import_zod42.z.object({ promptId: import_zod42.z.uuid(), version })).max(100).optional()
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("group-update"),
+        id: import_zod42.z.uuid(),
+        expectedRevision: revision,
+        name: name.optional(),
+        members: import_zod42.z.array(import_zod42.z.object({ promptId: import_zod42.z.uuid(), version })).max(100).optional()
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("group-delete"),
+        id: import_zod42.z.uuid(),
+        expectedRevision: revision
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("promote"),
+        id: import_zod42.z.uuid(),
+        version,
+        expectedRevision: revision,
+        exceptionReason: import_zod42.z.string().trim().min(1).max(2e3).optional(),
+        rollback: import_zod42.z.boolean().default(false)
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("review"),
+        id: import_zod42.z.uuid(),
+        version,
+        note: import_zod42.z.string().trim().min(1).max(2e3)
+      }).strict(),
+      import_zod42.z.object({
+        action: import_zod42.z.literal("policy"),
+        id: import_zod42.z.uuid(),
+        policy: PromptPolicySchema
+      }).strict()
+    ]);
+    var PromptSelectionSchema = import_zod42.z.discriminatedUnion("type", [
+      import_zod42.z.object({ type: import_zod42.z.literal("live") }).strict(),
+      import_zod42.z.object({
+        type: import_zod42.z.literal("single"),
+        id: import_zod42.z.string().min(1),
+        version: import_zod42.z.number().int().positive()
+      }).strict(),
+      import_zod42.z.object({ type: import_zod42.z.literal("group"), groupId: import_zod42.z.uuid() }).strict()
+    ]);
+    var PromptBundleSchema = import_zod42.z.object({
+      schemaVersion: import_zod42.z.literal(1),
+      origin: import_zod42.z.object({
+        apiUrl: import_zod42.z.url().refine((value) => {
+          const url = new URL(value);
+          return /^https?:$/.test(url.protocol) && !url.username && !url.password && !url.search;
+        }),
+        projectId: import_zod42.z.string().min(1)
+      }).strict(),
+      prompts: import_zod42.z.array(
+        import_zod42.z.object({
+          key: import_browser4.PromptKeySchema,
+          name,
+          categoryPath: import_zod42.z.string().optional(),
+          versions: import_zod42.z.array(import_browser4.PromptVersionSchema.extend({ note: import_zod42.z.string().max(2e3) })).min(1).max(200)
+        }).strict()
+      ).min(1).max(200),
+      groups: import_zod42.z.array(
+        import_zod42.z.object({
+          name,
+          members: import_zod42.z.array(import_zod42.z.object({ key: import_browser4.PromptKeySchema, version })).max(100)
+        }).strict()
+      ).max(100).default([])
+    }).strict();
+    var PromptTransferRequestSchema = import_zod42.z.object({
+      bundle: PromptBundleSchema,
+      conflicts: import_zod42.z.enum(["error", "append"]).default("error"),
+      rename: import_zod42.z.record(import_browser4.PromptKeySchema, import_browser4.PromptKeySchema).default({}),
+      categories: import_zod42.z.boolean().default(true),
+      groups: import_zod42.z.boolean().default(false)
+    }).strict();
+    var import_zod52 = require("zod");
+    var StudioReleaseVersionSchema = import_zod52.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
+    var StudioReleaseDeploymentSchema = import_zod52.z.object({
+      strategy: import_zod52.z.enum(["rolling", "recreate"])
     });
-    var StudioReleaseSchema = import_zod42.z.object({
-      format: import_zod42.z.literal(1),
-      installer: import_zod42.z.literal(1),
+    var StudioReleaseSchema = import_zod52.z.object({
+      format: import_zod52.z.literal(1),
+      installer: import_zod52.z.literal(1),
       version: StudioReleaseVersionSchema,
-      api: import_zod42.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-api@sha256:[a-f0-9]{64}$/),
-      studio: import_zod42.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-studio@sha256:[a-f0-9]{64}$/),
+      api: import_zod52.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-api@sha256:[a-f0-9]{64}$/),
+      studio: import_zod52.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-studio@sha256:[a-f0-9]{64}$/),
       deployment: StudioReleaseDeploymentSchema.default({
         strategy: "recreate"
       })
     });
-    var StudioUpdateSettingsSchema = import_zod42.z.object({
-      automatic: import_zod42.z.boolean(),
-      hourUtc: import_zod42.z.number().int().min(0).max(23)
+    var StudioUpdateSettingsSchema = import_zod52.z.object({
+      automatic: import_zod52.z.boolean(),
+      hourUtc: import_zod52.z.number().int().min(0).max(23)
     });
-    var StudioUpdateOperationSchema = import_zod42.z.object({
-      id: import_zod42.z.uuid(),
-      from: import_zod42.z.string(),
+    var StudioUpdateOperationSchema = import_zod52.z.object({
+      id: import_zod52.z.uuid(),
+      from: import_zod52.z.string(),
       release: StudioReleaseSchema,
-      phase: import_zod42.z.enum([
+      phase: import_zod52.z.enum([
         "starting",
         "pulling",
         "backup",
@@ -499,16 +817,16 @@ var require_dist = __commonJS({
         "succeeded",
         "failed"
       ]),
-      startedAt: import_zod42.z.iso.datetime(),
-      updatedAt: import_zod42.z.iso.datetime(),
-      backup: import_zod42.z.string().nullable(),
-      messages: import_zod42.z.array(import_zod42.z.string()).max(100)
+      startedAt: import_zod52.z.iso.datetime(),
+      updatedAt: import_zod52.z.iso.datetime(),
+      backup: import_zod52.z.string().nullable(),
+      messages: import_zod52.z.array(import_zod52.z.string()).max(100)
     });
-    var StudioUpdateStatusSchema = import_zod42.z.object({
-      current: import_zod42.z.string().nullable(),
+    var StudioUpdateStatusSchema = import_zod52.z.object({
+      current: import_zod52.z.string().nullable(),
       available: StudioReleaseSchema.nullable(),
-      checkedAt: import_zod42.z.iso.datetime().nullable(),
-      checkError: import_zod42.z.string().nullable(),
+      checkedAt: import_zod52.z.iso.datetime().nullable(),
+      checkError: import_zod52.z.string().nullable(),
       settings: StudioUpdateSettingsSchema,
       operation: StudioUpdateOperationSchema.nullable()
     });
@@ -659,82 +977,82 @@ var require_dist = __commonJS({
       "session.forked",
       "session.rolled_back"
     ];
-    var TelemetryServiceSchema = import_zod52.z.object({
-      name: import_zod52.z.string().min(1),
-      deploymentRef: import_zod52.z.string().min(1).optional()
+    var TelemetryServiceSchema = import_zod62.z.object({
+      name: import_zod62.z.string().min(1),
+      deploymentRef: import_zod62.z.string().min(1).optional()
     }).strict();
-    var WorkflowTopologyNodeSchema = import_zod52.z.object({
-      id: import_zod52.z.string().min(1),
-      label: import_zod52.z.string().optional(),
-      type: import_zod52.z.string().optional(),
-      provider: import_zod52.z.string().optional(),
-      model: import_zod52.z.string().optional(),
-      metadata: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()).optional(),
-      tools: import_zod52.z.array(WorkflowToolSchema).optional(),
+    var WorkflowTopologyNodeSchema = import_zod62.z.object({
+      id: import_zod62.z.string().min(1),
+      label: import_zod62.z.string().optional(),
+      type: import_zod62.z.string().optional(),
+      provider: import_zod62.z.string().optional(),
+      model: import_zod62.z.string().optional(),
+      metadata: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown()).optional(),
+      tools: import_zod62.z.array(WorkflowToolSchema).optional(),
       toolDiscovery: ToolDiscoverySchema.optional()
     }).strict();
-    var WorkflowTopologyEdgeSchema = import_zod52.z.object({
-      sourceNodeId: import_zod52.z.string().min(1),
-      targetNodeId: import_zod52.z.string().min(1),
-      condition: import_zod52.z.string().optional()
+    var WorkflowTopologyEdgeSchema = import_zod62.z.object({
+      sourceNodeId: import_zod62.z.string().min(1),
+      targetNodeId: import_zod62.z.string().min(1),
+      condition: import_zod62.z.string().optional()
     }).strict();
-    var WorkflowTopologyCallSchema = import_zod52.z.object({
-      sourceNodeId: import_zod52.z.string().min(1),
-      targetWorkflowId: import_zod52.z.string().min(1)
+    var WorkflowTopologyCallSchema = import_zod62.z.object({
+      sourceNodeId: import_zod62.z.string().min(1),
+      targetWorkflowId: import_zod62.z.string().min(1)
     }).strict();
-    var WorkflowTopologyTransitionSchema = import_zod52.z.object({
-      sourceNodeId: import_zod52.z.string().min(1).optional(),
-      targetWorkflowId: import_zod52.z.string().min(1),
-      condition: import_zod52.z.string().optional(),
-      intent: import_zod52.z.string().optional(),
-      kind: import_zod52.z.enum(["call", "handoff"]).optional()
+    var WorkflowTopologyTransitionSchema = import_zod62.z.object({
+      sourceNodeId: import_zod62.z.string().min(1).optional(),
+      targetWorkflowId: import_zod62.z.string().min(1),
+      condition: import_zod62.z.string().optional(),
+      intent: import_zod62.z.string().optional(),
+      kind: import_zod62.z.enum(["call", "handoff"]).optional()
     }).strict();
-    var EnsureWorkflowTopologyRequestSchema = import_zod52.z.object({
-      schemaVersion: import_zod52.z.literal(1),
-      environment: import_zod52.z.string().min(1),
+    var EnsureWorkflowTopologyRequestSchema = import_zod62.z.object({
+      schemaVersion: import_zod62.z.literal(1),
+      environment: import_zod62.z.string().min(1),
       service: TelemetryServiceSchema,
-      workflow: import_zod52.z.object({
-        id: import_zod52.z.string().min(1),
-        declaredVersion: import_zod52.z.string().min(1),
-        description: import_zod52.z.string().optional(),
-        tags: import_zod52.z.array(import_zod52.z.string()).optional(),
-        topologyHash: import_zod52.z.string().regex(/^[a-f0-9]{64}$/),
-        nodes: import_zod52.z.array(WorkflowTopologyNodeSchema),
-        edges: import_zod52.z.array(WorkflowTopologyEdgeSchema),
-        transitions: import_zod52.z.array(WorkflowTopologyTransitionSchema).optional(),
-        calls: import_zod52.z.array(WorkflowTopologyCallSchema).optional()
+      workflow: import_zod62.z.object({
+        id: import_zod62.z.string().min(1),
+        declaredVersion: import_zod62.z.string().min(1),
+        description: import_zod62.z.string().optional(),
+        tags: import_zod62.z.array(import_zod62.z.string()).optional(),
+        topologyHash: import_zod62.z.string().regex(/^[a-f0-9]{64}$/),
+        nodes: import_zod62.z.array(WorkflowTopologyNodeSchema),
+        edges: import_zod62.z.array(WorkflowTopologyEdgeSchema),
+        transitions: import_zod62.z.array(WorkflowTopologyTransitionSchema).optional(),
+        calls: import_zod62.z.array(WorkflowTopologyCallSchema).optional()
       }).strict()
     }).strict();
-    var EnsureWorkflowTopologyResponseSchema = import_zod52.z.object({ workflowRevisionId: import_zod52.z.string().min(1), created: import_zod52.z.boolean() }).strict();
-    var TelemetryEventTypeSchema = import_zod52.z.enum(TELEMETRY_EVENT_TYPES);
-    var TelemetryEventSchema = import_zod52.z.object({
-      schemaVersion: import_zod52.z.literal(1),
-      eventId: import_zod52.z.string().min(1),
-      occurredAt: import_zod52.z.string().datetime({ offset: true }),
-      environment: import_zod52.z.string().min(1),
+    var EnsureWorkflowTopologyResponseSchema = import_zod62.z.object({ workflowRevisionId: import_zod62.z.string().min(1), created: import_zod62.z.boolean() }).strict();
+    var TelemetryEventTypeSchema = import_zod62.z.enum(TELEMETRY_EVENT_TYPES);
+    var TelemetryEventSchema = import_zod62.z.object({
+      schemaVersion: import_zod62.z.literal(1),
+      eventId: import_zod62.z.string().min(1),
+      occurredAt: import_zod62.z.string().datetime({ offset: true }),
+      environment: import_zod62.z.string().min(1),
       service: TelemetryServiceSchema,
-      correlation: import_zod52.z.object({
-        invocationId: import_zod52.z.string().optional(),
-        parentInvocationId: import_zod52.z.string().optional(),
-        branchId: import_zod52.z.string().optional(),
-        traceId: import_zod52.z.string().optional(),
-        spanId: import_zod52.z.string().optional(),
-        parentSpanId: import_zod52.z.string().optional(),
-        runId: import_zod52.z.string().min(1),
-        sessionId: import_zod52.z.string().optional(),
-        workflowId: import_zod52.z.string().min(1),
-        workflowRevisionId: import_zod52.z.string().optional(),
-        topologyHash: import_zod52.z.string().regex(/^[a-f0-9]{64}$/).optional(),
-        nodeId: import_zod52.z.string().optional()
+      correlation: import_zod62.z.object({
+        invocationId: import_zod62.z.string().optional(),
+        parentInvocationId: import_zod62.z.string().optional(),
+        branchId: import_zod62.z.string().optional(),
+        traceId: import_zod62.z.string().optional(),
+        spanId: import_zod62.z.string().optional(),
+        parentSpanId: import_zod62.z.string().optional(),
+        runId: import_zod62.z.string().min(1),
+        sessionId: import_zod62.z.string().optional(),
+        workflowId: import_zod62.z.string().min(1),
+        workflowRevisionId: import_zod62.z.string().optional(),
+        topologyHash: import_zod62.z.string().regex(/^[a-f0-9]{64}$/).optional(),
+        nodeId: import_zod62.z.string().optional()
       }).strict(),
-      context: import_zod52.z.object({
-        userId: import_zod52.z.string().optional(),
-        tenantId: import_zod52.z.string().optional(),
-        tags: import_zod52.z.array(import_zod52.z.string()).optional(),
-        metadata: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()).optional()
+      context: import_zod62.z.object({
+        userId: import_zod62.z.string().optional(),
+        tenantId: import_zod62.z.string().optional(),
+        tags: import_zod62.z.array(import_zod62.z.string()).optional(),
+        metadata: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown()).optional()
       }).strict().optional(),
       type: TelemetryEventTypeSchema,
-      payload: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown())
+      payload: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown())
     }).strict().superRefine((event, ctx) => {
       if (!event.type.startsWith("tool.")) return;
       const canonical2 = event.payload.version === 1 || [
@@ -777,20 +1095,20 @@ var require_dist = __commonJS({
           });
       }
     });
-    var TelemetryEventBatchSchema = import_zod52.z.object({ events: import_zod52.z.array(TelemetryEventSchema).min(1) }).strict();
-    var TelemetryEventBatchResponseSchema = import_zod52.z.object({
-      accepted: import_zod52.z.number().int().nonnegative(),
-      inserted: import_zod52.z.number().int().nonnegative(),
-      duplicates: import_zod52.z.number().int().nonnegative()
+    var TelemetryEventBatchSchema = import_zod62.z.object({ events: import_zod62.z.array(TelemetryEventSchema).min(1) }).strict();
+    var TelemetryEventBatchResponseSchema = import_zod62.z.object({
+      accepted: import_zod62.z.number().int().nonnegative(),
+      inserted: import_zod62.z.number().int().nonnegative(),
+      duplicates: import_zod62.z.number().int().nonnegative()
     }).strict();
-    var TelemetryPricingSourceSchema = import_zod52.z.enum([
+    var TelemetryPricingSourceSchema = import_zod62.z.enum([
       "sdk",
       "provider",
       "custom",
       "project-rate-card",
       "default-rate-card"
     ]);
-    var TelemetryPricingUnitSchema = import_zod52.z.enum([
+    var TelemetryPricingUnitSchema = import_zod62.z.enum([
       "token",
       "character",
       "request",
@@ -803,7 +1121,7 @@ var require_dist = __commonJS({
       "minute",
       "custom"
     ]);
-    var TelemetryPricingUsageTypeSchema = import_zod52.z.enum([
+    var TelemetryPricingUsageTypeSchema = import_zod62.z.enum([
       "input",
       "output",
       "reasoning",
@@ -819,42 +1137,42 @@ var require_dist = __commonJS({
       "request",
       "custom"
     ]);
-    var TelemetryUsageItemSchema = import_zod52.z.object({
+    var TelemetryUsageItemSchema = import_zod62.z.object({
       usageType: TelemetryPricingUsageTypeSchema,
-      quantity: import_zod52.z.number().nonnegative(),
+      quantity: import_zod62.z.number().nonnegative(),
       unit: TelemetryPricingUnitSchema,
-      label: import_zod52.z.string().optional()
+      label: import_zod62.z.string().optional()
     }).strict();
-    var TelemetryUnitPriceSchema = import_zod52.z.object({
+    var TelemetryUnitPriceSchema = import_zod62.z.object({
       usageType: TelemetryPricingUsageTypeSchema,
       unit: TelemetryPricingUnitSchema,
-      unitQuantity: import_zod52.z.number().positive().default(1),
-      priceMicros: import_zod52.z.number().int().nonnegative(),
-      label: import_zod52.z.string().optional()
+      unitQuantity: import_zod62.z.number().positive().default(1),
+      priceMicros: import_zod62.z.number().int().nonnegative(),
+      label: import_zod62.z.string().optional()
     }).strict();
-    var TelemetryPricingLineItemSchema = import_zod52.z.object({
+    var TelemetryPricingLineItemSchema = import_zod62.z.object({
       usageType: TelemetryPricingUsageTypeSchema,
-      quantity: import_zod52.z.number().nonnegative(),
+      quantity: import_zod62.z.number().nonnegative(),
       unit: TelemetryPricingUnitSchema,
-      unitQuantity: import_zod52.z.number().positive().default(1),
-      unitPriceMicros: import_zod52.z.number().int().nonnegative().optional(),
-      totalCostMicros: import_zod52.z.number().int().nonnegative().optional(),
-      label: import_zod52.z.string().optional()
+      unitQuantity: import_zod62.z.number().positive().default(1),
+      unitPriceMicros: import_zod62.z.number().int().nonnegative().optional(),
+      totalCostMicros: import_zod62.z.number().int().nonnegative().optional(),
+      label: import_zod62.z.string().optional()
     }).strict().refine(
       (value) => value.totalCostMicros !== void 0 || value.unitPriceMicros !== void 0,
       "line item requires totalCostMicros or unitPriceMicros"
     );
-    var TelemetryPricingHintSchema = import_zod52.z.object({
+    var TelemetryPricingHintSchema = import_zod62.z.object({
       source: TelemetryPricingSourceSchema.extract(["sdk", "provider", "custom"]),
-      currency: import_zod52.z.string().min(3).max(12).default("USD"),
-      actualCostMicros: import_zod52.z.number().int().nonnegative().optional(),
-      lineItems: import_zod52.z.array(TelemetryPricingLineItemSchema).optional(),
-      unitPrices: import_zod52.z.array(TelemetryUnitPriceSchema).optional(),
-      usageItems: import_zod52.z.array(TelemetryUsageItemSchema).optional(),
-      pricingRef: import_zod52.z.string().min(1).optional(),
-      metadata: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()).optional()
+      currency: import_zod62.z.string().min(3).max(12).default("USD"),
+      actualCostMicros: import_zod62.z.number().int().nonnegative().optional(),
+      lineItems: import_zod62.z.array(TelemetryPricingLineItemSchema).optional(),
+      unitPrices: import_zod62.z.array(TelemetryUnitPriceSchema).optional(),
+      usageItems: import_zod62.z.array(TelemetryUsageItemSchema).optional(),
+      pricingRef: import_zod62.z.string().min(1).optional(),
+      metadata: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown()).optional()
     }).strict();
-    var StudioRunStatusSchema = import_zod52.z.enum([
+    var StudioRunStatusSchema = import_zod62.z.enum([
       "running",
       "completed",
       "interrupted",
@@ -870,16 +1188,16 @@ var require_dist = __commonJS({
       "All time",
       "Custom range"
     ];
-    var StudioTimeRangeSchema = import_zod52.z.enum(STUDIO_TIME_RANGES);
-    var StudioTimeRangeQuerySchema = import_zod52.z.object({
+    var StudioTimeRangeSchema = import_zod62.z.enum(STUDIO_TIME_RANGES);
+    var StudioTimeRangeQuerySchema = import_zod62.z.object({
       range: StudioTimeRangeSchema.optional(),
-      startedAfter: import_zod52.z.string().optional(),
-      startedBefore: import_zod52.z.string().optional()
+      startedAfter: import_zod62.z.string().optional(),
+      startedBefore: import_zod62.z.string().optional()
     }).strict();
-    var StudioTimeRangeContextSchema = import_zod52.z.object({
+    var StudioTimeRangeContextSchema = import_zod62.z.object({
       range: StudioTimeRangeSchema,
-      startedAfter: import_zod52.z.string().datetime({ offset: true }).nullable(),
-      startedBefore: import_zod52.z.string().datetime({ offset: true }).nullable()
+      startedAfter: import_zod62.z.string().datetime({ offset: true }).nullable(),
+      startedBefore: import_zod62.z.string().datetime({ offset: true }).nullable()
     }).strict();
     var STUDIO_TIME_RANGE_MILLISECONDS = {
       "Last hour": 60 * 60 * 1e3,
@@ -953,7 +1271,7 @@ var require_dist = __commonJS({
         }
       };
     };
-    var StudioInterruptStatusSchema = import_zod52.z.enum([
+    var StudioInterruptStatusSchema = import_zod62.z.enum([
       "pending",
       "resolved",
       "expired",
@@ -966,329 +1284,329 @@ var require_dist = __commonJS({
       const nowMs = typeof now === "number" ? now : now.getTime();
       return Number.isFinite(expiresAt) && Number.isFinite(nowMs) && expiresAt <= nowMs ? "expired" : input.status;
     };
-    var StudioInterruptTypeSchema = import_zod52.z.enum([
+    var StudioInterruptTypeSchema = import_zod62.z.enum([
       "choice",
       "multi-choice",
       "text",
       "structured",
       "unknown"
     ]);
-    var StudioInterruptInteractionModeSchema = import_zod52.z.enum([
+    var StudioInterruptInteractionModeSchema = import_zod62.z.enum([
       "static-options",
       "dynamic-picker",
       "freeform",
       "unknown"
     ]);
-    var StudioInterruptOptionSchema = import_zod52.z.object({
-      id: import_zod52.z.string().min(1),
-      label: import_zod52.z.string().min(1),
-      description: import_zod52.z.string().nullable()
+    var StudioInterruptOptionSchema = import_zod62.z.object({
+      id: import_zod62.z.string().min(1),
+      label: import_zod62.z.string().min(1),
+      description: import_zod62.z.string().nullable()
     }).strip();
-    var StudioInterruptValueSchema = import_zod52.z.union([
-      import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()),
-      import_zod52.z.array(import_zod52.z.unknown()),
-      import_zod52.z.string(),
-      import_zod52.z.number(),
-      import_zod52.z.boolean()
+    var StudioInterruptValueSchema = import_zod62.z.union([
+      import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown()),
+      import_zod62.z.array(import_zod62.z.unknown()),
+      import_zod62.z.string(),
+      import_zod62.z.number(),
+      import_zod62.z.boolean()
     ]);
-    var StudioResumeOutcomeSchema = import_zod52.z.enum([
+    var StudioResumeOutcomeSchema = import_zod62.z.enum([
       "resumed",
       "resume failed",
       "expired before resume",
       "cancelled"
     ]);
-    var StudioWorkflowHealthSchema = import_zod52.z.enum([
+    var StudioWorkflowHealthSchema = import_zod62.z.enum([
       "unknown",
       "healthy",
       "degraded",
       "failing",
       "idle"
     ]);
-    var StudioPricingStatusSchema = import_zod52.z.enum([
+    var StudioPricingStatusSchema = import_zod62.z.enum([
       "priced",
       "unpriced",
       "unknown"
     ]);
     var StudioPricingSourceSchema = TelemetryPricingSourceSchema.nullable();
-    var StudioChangeResourceSchema = import_zod52.z.enum([
+    var StudioChangeResourceSchema = import_zod62.z.enum([
       "evals",
       "workflows",
       "runs",
       "sessions",
       "interrupts"
     ]);
-    var StudioChangeSchema = import_zod52.z.object({
-      schemaVersion: import_zod52.z.literal(1),
-      changeId: import_zod52.z.string().min(1),
-      emittedAt: import_zod52.z.string().datetime({ offset: true }),
-      organizationId: import_zod52.z.string().min(1),
-      projectId: import_zod52.z.string().min(1),
-      environment: import_zod52.z.string().min(1).optional(),
-      resources: import_zod52.z.array(StudioChangeResourceSchema).min(1)
+    var StudioChangeSchema = import_zod62.z.object({
+      schemaVersion: import_zod62.z.literal(1),
+      changeId: import_zod62.z.string().min(1),
+      emittedAt: import_zod62.z.string().datetime({ offset: true }),
+      organizationId: import_zod62.z.string().min(1),
+      projectId: import_zod62.z.string().min(1),
+      environment: import_zod62.z.string().min(1).optional(),
+      resources: import_zod62.z.array(StudioChangeResourceSchema).min(1)
     }).strict();
-    var StudioMetricSchema = import_zod52.z.object({
-      runCount: import_zod52.z.number().int().nonnegative(),
-      successRate: import_zod52.z.number().min(0).max(100).nullable(),
-      errorRate: import_zod52.z.number().min(0).max(100).nullable(),
-      retryCount: import_zod52.z.number().int().nonnegative().nullable(),
-      interruptRate: import_zod52.z.number().min(0).max(100).nullable(),
-      p50DurationMs: import_zod52.z.number().nonnegative().nullable(),
-      p95DurationMs: import_zod52.z.number().nonnegative().nullable(),
-      averageTokens: import_zod52.z.number().nonnegative().nullable(),
-      averageCost: import_zod52.z.number().nonnegative().nullable(),
-      currency: import_zod52.z.string().nullable()
+    var StudioMetricSchema = import_zod62.z.object({
+      runCount: import_zod62.z.number().int().nonnegative(),
+      successRate: import_zod62.z.number().min(0).max(100).nullable(),
+      errorRate: import_zod62.z.number().min(0).max(100).nullable(),
+      retryCount: import_zod62.z.number().int().nonnegative().nullable(),
+      interruptRate: import_zod62.z.number().min(0).max(100).nullable(),
+      p50DurationMs: import_zod62.z.number().nonnegative().nullable(),
+      p95DurationMs: import_zod62.z.number().nonnegative().nullable(),
+      averageTokens: import_zod62.z.number().nonnegative().nullable(),
+      averageCost: import_zod62.z.number().nonnegative().nullable(),
+      currency: import_zod62.z.string().nullable()
     }).strip();
-    var StudioRunSchema = import_zod52.z.object({
-      id: import_zod52.z.string().min(1),
+    var StudioRunSchema = import_zod62.z.object({
+      id: import_zod62.z.string().min(1),
       feedback: FeedbackSummarySchema.optional(),
-      callerNodeId: import_zod52.z.string().optional(),
-      parentRunId: import_zod52.z.string().optional(),
-      parentWorkflowId: import_zod52.z.string().optional(),
-      invocationId: import_zod52.z.string().optional(),
-      branchId: import_zod52.z.string().optional(),
-      callId: import_zod52.z.string().optional(),
+      callerNodeId: import_zod62.z.string().optional(),
+      parentRunId: import_zod62.z.string().optional(),
+      parentWorkflowId: import_zod62.z.string().optional(),
+      invocationId: import_zod62.z.string().optional(),
+      branchId: import_zod62.z.string().optional(),
+      callId: import_zod62.z.string().optional(),
       status: StudioRunStatusSchema,
-      startedAt: import_zod52.z.string().datetime({ offset: true }),
-      endedAt: import_zod52.z.string().datetime({ offset: true }).nullable(),
-      workflowId: import_zod52.z.string().min(1),
-      workflowIds: import_zod52.z.array(import_zod52.z.string().min(1)),
-      workflowRefs: import_zod52.z.array(
-        import_zod52.z.object({
-          workflowId: import_zod52.z.string().min(1),
-          workflowRevisionId: import_zod52.z.string().nullable(),
-          declaredVersion: import_zod52.z.string().nullable()
+      startedAt: import_zod62.z.string().datetime({ offset: true }),
+      endedAt: import_zod62.z.string().datetime({ offset: true }).nullable(),
+      workflowId: import_zod62.z.string().min(1),
+      workflowIds: import_zod62.z.array(import_zod62.z.string().min(1)),
+      workflowRefs: import_zod62.z.array(
+        import_zod62.z.object({
+          workflowId: import_zod62.z.string().min(1),
+          workflowRevisionId: import_zod62.z.string().nullable(),
+          declaredVersion: import_zod62.z.string().nullable()
         }).strip()
       ),
-      workflowRevisionId: import_zod52.z.string().nullable(),
-      declaredVersion: import_zod52.z.string().nullable(),
-      transitionIds: import_zod52.z.array(import_zod52.z.string().min(1)),
-      path: import_zod52.z.array(import_zod52.z.string()),
-      sessionId: import_zod52.z.string().nullable(),
-      provider: import_zod52.z.string().nullable(),
-      model: import_zod52.z.string().nullable(),
-      models: import_zod52.z.array(import_zod52.z.string()),
-      durationMs: import_zod52.z.number().nonnegative().nullable(),
-      tokens: import_zod52.z.number().int().nonnegative().nullable(),
-      cost: import_zod52.z.number().nonnegative().nullable(),
+      workflowRevisionId: import_zod62.z.string().nullable(),
+      declaredVersion: import_zod62.z.string().nullable(),
+      transitionIds: import_zod62.z.array(import_zod62.z.string().min(1)),
+      path: import_zod62.z.array(import_zod62.z.string()),
+      sessionId: import_zod62.z.string().nullable(),
+      provider: import_zod62.z.string().nullable(),
+      model: import_zod62.z.string().nullable(),
+      models: import_zod62.z.array(import_zod62.z.string()),
+      durationMs: import_zod62.z.number().nonnegative().nullable(),
+      tokens: import_zod62.z.number().int().nonnegative().nullable(),
+      cost: import_zod62.z.number().nonnegative().nullable(),
       pricingStatus: StudioPricingStatusSchema,
       pricingSource: StudioPricingSourceSchema,
-      currency: import_zod52.z.string().nullable(),
-      result: import_zod52.z.string().nullable(),
-      environment: import_zod52.z.string().min(1),
-      userId: import_zod52.z.string().nullable(),
-      tenantId: import_zod52.z.string().nullable(),
-      hasTool: import_zod52.z.boolean(),
-      hasRetry: import_zod52.z.boolean(),
-      interruptNodeId: import_zod52.z.string().nullable(),
-      interruptId: import_zod52.z.string().nullable().optional(),
+      currency: import_zod62.z.string().nullable(),
+      result: import_zod62.z.string().nullable(),
+      environment: import_zod62.z.string().min(1),
+      userId: import_zod62.z.string().nullable(),
+      tenantId: import_zod62.z.string().nullable(),
+      hasTool: import_zod62.z.boolean(),
+      hasRetry: import_zod62.z.boolean(),
+      interruptNodeId: import_zod62.z.string().nullable(),
+      interruptId: import_zod62.z.string().nullable().optional(),
       interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
-      interruptExpiresAt: import_zod52.z.string().datetime({ offset: true }).nullable().optional()
+      interruptExpiresAt: import_zod62.z.string().datetime({ offset: true }).nullable().optional()
     }).strip();
-    var StudioSessionSchema = import_zod52.z.object({
-      id: import_zod52.z.string().min(1),
+    var StudioSessionSchema = import_zod62.z.object({
+      id: import_zod62.z.string().min(1),
       status: StudioRunStatusSchema,
-      lastActivityAt: import_zod52.z.string().datetime({ offset: true }),
-      workflowIds: import_zod52.z.array(import_zod52.z.string()),
-      workflowCount: import_zod52.z.number().int().nonnegative(),
-      activeWorkflowId: import_zod52.z.string().nullable(),
-      activeVersion: import_zod52.z.string().nullable(),
-      userId: import_zod52.z.string().nullable(),
-      tenantId: import_zod52.z.string().nullable(),
-      runs: import_zod52.z.number().int().nonnegative(),
-      succeeded: import_zod52.z.number().int().nonnegative(),
-      failed: import_zod52.z.number().int().nonnegative(),
-      interrupted: import_zod52.z.number().int().nonnegative(),
-      checkpoints: import_zod52.z.number().int().nonnegative(),
-      hasFork: import_zod52.z.boolean(),
-      durationMs: import_zod52.z.number().nonnegative().nullable(),
-      tokens: import_zod52.z.number().int().nonnegative().nullable(),
-      cost: import_zod52.z.number().nonnegative().nullable(),
+      lastActivityAt: import_zod62.z.string().datetime({ offset: true }),
+      workflowIds: import_zod62.z.array(import_zod62.z.string()),
+      workflowCount: import_zod62.z.number().int().nonnegative(),
+      activeWorkflowId: import_zod62.z.string().nullable(),
+      activeVersion: import_zod62.z.string().nullable(),
+      userId: import_zod62.z.string().nullable(),
+      tenantId: import_zod62.z.string().nullable(),
+      runs: import_zod62.z.number().int().nonnegative(),
+      succeeded: import_zod62.z.number().int().nonnegative(),
+      failed: import_zod62.z.number().int().nonnegative(),
+      interrupted: import_zod62.z.number().int().nonnegative(),
+      checkpoints: import_zod62.z.number().int().nonnegative(),
+      hasFork: import_zod62.z.boolean(),
+      durationMs: import_zod62.z.number().nonnegative().nullable(),
+      tokens: import_zod62.z.number().int().nonnegative().nullable(),
+      cost: import_zod62.z.number().nonnegative().nullable(),
       pricingStatus: StudioPricingStatusSchema,
       pricingSource: StudioPricingSourceSchema,
-      currency: import_zod52.z.string().nullable(),
-      latestResult: import_zod52.z.string().nullable(),
-      latestError: import_zod52.z.string().nullable(),
-      pendingInterruptId: import_zod52.z.string().nullable(),
+      currency: import_zod62.z.string().nullable(),
+      latestResult: import_zod62.z.string().nullable(),
+      latestError: import_zod62.z.string().nullable(),
+      pendingInterruptId: import_zod62.z.string().nullable(),
       interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
-      interruptExpiresAt: import_zod52.z.string().datetime({ offset: true }).nullable().optional(),
-      providers: import_zod52.z.array(import_zod52.z.string()),
-      models: import_zod52.z.array(import_zod52.z.string()),
-      tags: import_zod52.z.array(import_zod52.z.string()),
-      environment: import_zod52.z.string().min(1)
+      interruptExpiresAt: import_zod62.z.string().datetime({ offset: true }).nullable().optional(),
+      providers: import_zod62.z.array(import_zod62.z.string()),
+      models: import_zod62.z.array(import_zod62.z.string()),
+      tags: import_zod62.z.array(import_zod62.z.string()),
+      environment: import_zod62.z.string().min(1)
     }).strip();
-    var StudioInterruptSchema = import_zod52.z.object({
-      afterResponseCompleted: import_zod52.z.boolean().optional(),
-      id: import_zod52.z.string().min(1),
+    var StudioInterruptSchema = import_zod62.z.object({
+      afterResponseCompleted: import_zod62.z.boolean().optional(),
+      id: import_zod62.z.string().min(1),
       status: StudioInterruptStatusSchema,
       type: StudioInterruptTypeSchema,
       interactionMode: StudioInterruptInteractionModeSchema,
-      contract: import_zod52.z.string().nullable().default(null),
-      schemaId: import_zod52.z.string().nullable(),
-      schemaVersion: import_zod52.z.string().nullable(),
-      createdAt: import_zod52.z.string().datetime({ offset: true }),
-      resolvedAt: import_zod52.z.string().datetime({ offset: true }).nullable(),
-      expiresAt: import_zod52.z.string().datetime({ offset: true }).nullable(),
-      question: import_zod52.z.string().nullable(),
-      contentCaptured: import_zod52.z.boolean(),
-      request: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()).nullable().default(null),
-      requestCaptured: import_zod52.z.boolean().default(false),
-      optionCount: import_zod52.z.number().int().nonnegative().nullable(),
-      options: import_zod52.z.array(StudioInterruptOptionSchema).nullable(),
-      workflowId: import_zod52.z.string().min(1),
-      nodeId: import_zod52.z.string().nullable(),
-      sessionId: import_zod52.z.string().nullable(),
-      userId: import_zod52.z.string().nullable(),
-      tenantId: import_zod52.z.string().nullable(),
-      response: import_zod52.z.string().nullable(),
+      contract: import_zod62.z.string().nullable().default(null),
+      schemaId: import_zod62.z.string().nullable(),
+      schemaVersion: import_zod62.z.string().nullable(),
+      createdAt: import_zod62.z.string().datetime({ offset: true }),
+      resolvedAt: import_zod62.z.string().datetime({ offset: true }).nullable(),
+      expiresAt: import_zod62.z.string().datetime({ offset: true }).nullable(),
+      question: import_zod62.z.string().nullable(),
+      contentCaptured: import_zod62.z.boolean(),
+      request: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown()).nullable().default(null),
+      requestCaptured: import_zod62.z.boolean().default(false),
+      optionCount: import_zod62.z.number().int().nonnegative().nullable(),
+      options: import_zod62.z.array(StudioInterruptOptionSchema).nullable(),
+      workflowId: import_zod62.z.string().min(1),
+      nodeId: import_zod62.z.string().nullable(),
+      sessionId: import_zod62.z.string().nullable(),
+      userId: import_zod62.z.string().nullable(),
+      tenantId: import_zod62.z.string().nullable(),
+      response: import_zod62.z.string().nullable(),
       responseValue: StudioInterruptValueSchema.nullable().default(null),
-      responseCaptured: import_zod52.z.boolean(),
+      responseCaptured: import_zod62.z.boolean(),
       resumeOutcome: StudioResumeOutcomeSchema.nullable(),
-      resumeError: import_zod52.z.string().nullable(),
-      runId: import_zod52.z.string().min(1),
-      resumeToken: import_zod52.z.string().nullable(),
-      resolvedBy: import_zod52.z.string().nullable(),
-      environment: import_zod52.z.string().min(1)
+      resumeError: import_zod62.z.string().nullable(),
+      runId: import_zod62.z.string().min(1),
+      resumeToken: import_zod62.z.string().nullable(),
+      resolvedBy: import_zod62.z.string().nullable(),
+      environment: import_zod62.z.string().min(1)
     }).strip();
-    var StudioDetailEventSchema = import_zod52.z.object({
-      id: import_zod52.z.string().min(1),
+    var StudioDetailEventSchema = import_zod62.z.object({
+      id: import_zod62.z.string().min(1),
       // Studio readers must preserve future event kinds within the same API major.
-      type: import_zod52.z.string().min(1),
-      occurredAt: import_zod52.z.string().datetime({ offset: true }),
-      receivedAt: import_zod52.z.string().datetime({ offset: true }),
-      environment: import_zod52.z.string().min(1),
-      serviceName: import_zod52.z.string().min(1),
-      deploymentRef: import_zod52.z.string().nullable(),
-      traceId: import_zod52.z.string().nullable(),
-      spanId: import_zod52.z.string().nullable(),
-      parentSpanId: import_zod52.z.string().nullable(),
-      runId: import_zod52.z.string().min(1),
-      sessionId: import_zod52.z.string().nullable(),
-      workflowId: import_zod52.z.string().min(1),
-      workflowRevisionId: import_zod52.z.string().nullable(),
-      nodeId: import_zod52.z.string().nullable(),
-      userId: import_zod52.z.string().nullable(),
-      tenantId: import_zod52.z.string().nullable(),
-      tags: import_zod52.z.array(import_zod52.z.string()),
-      metadata: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()).nullable(),
-      payload: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown())
+      type: import_zod62.z.string().min(1),
+      occurredAt: import_zod62.z.string().datetime({ offset: true }),
+      receivedAt: import_zod62.z.string().datetime({ offset: true }),
+      environment: import_zod62.z.string().min(1),
+      serviceName: import_zod62.z.string().min(1),
+      deploymentRef: import_zod62.z.string().nullable(),
+      traceId: import_zod62.z.string().nullable(),
+      spanId: import_zod62.z.string().nullable(),
+      parentSpanId: import_zod62.z.string().nullable(),
+      runId: import_zod62.z.string().min(1),
+      sessionId: import_zod62.z.string().nullable(),
+      workflowId: import_zod62.z.string().min(1),
+      workflowRevisionId: import_zod62.z.string().nullable(),
+      nodeId: import_zod62.z.string().nullable(),
+      userId: import_zod62.z.string().nullable(),
+      tenantId: import_zod62.z.string().nullable(),
+      tags: import_zod62.z.array(import_zod62.z.string()),
+      metadata: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown()).nullable(),
+      payload: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown())
     }).strip();
-    var StudioWorkflowNodeSchema = import_zod52.z.object({
-      tools: import_zod52.z.array(StudioToolSchema).optional(),
+    var StudioWorkflowNodeSchema = import_zod62.z.object({
+      tools: import_zod62.z.array(StudioToolSchema).optional(),
       toolDiscovery: ToolDiscoverySchema.optional(),
-      id: import_zod52.z.string().min(1),
-      label: import_zod52.z.string(),
-      type: import_zod52.z.string().nullable(),
-      state: import_zod52.z.enum(["healthy", "warning", "failed", "interrupted", "retried"]).nullable(),
-      provider: import_zod52.z.string().nullable(),
-      model: import_zod52.z.string().nullable(),
+      id: import_zod62.z.string().min(1),
+      label: import_zod62.z.string(),
+      type: import_zod62.z.string().nullable(),
+      state: import_zod62.z.enum(["healthy", "warning", "failed", "interrupted", "retried"]).nullable(),
+      provider: import_zod62.z.string().nullable(),
+      model: import_zod62.z.string().nullable(),
       metrics: StudioMetricSchema
     }).strip();
-    var StudioWorkflowInternalEdgeSchema = import_zod52.z.object({
-      id: import_zod52.z.string().min(1),
-      source: import_zod52.z.string().min(1),
-      target: import_zod52.z.string().min(1),
-      condition: import_zod52.z.string().nullable()
+    var StudioWorkflowInternalEdgeSchema = import_zod62.z.object({
+      id: import_zod62.z.string().min(1),
+      source: import_zod62.z.string().min(1),
+      target: import_zod62.z.string().min(1),
+      condition: import_zod62.z.string().nullable()
     }).strip();
-    var StudioWorkflowTransitionSchema = import_zod52.z.object({
-      kind: import_zod52.z.enum(["call", "handoff"]).optional(),
-      id: import_zod52.z.string().min(1),
-      sourceWorkflowId: import_zod52.z.string().min(1),
-      sourceNodeId: import_zod52.z.string().nullable(),
-      targetWorkflowId: import_zod52.z.string().min(1),
-      condition: import_zod52.z.string().nullable(),
-      volume: import_zod52.z.number().int().nonnegative(),
-      successRate: import_zod52.z.number().min(0).max(100).nullable(),
-      medianDurationMs: import_zod52.z.number().nonnegative().nullable(),
-      errorRate: import_zod52.z.number().min(0).max(100).nullable()
+    var StudioWorkflowTransitionSchema = import_zod62.z.object({
+      kind: import_zod62.z.enum(["call", "handoff"]).optional(),
+      id: import_zod62.z.string().min(1),
+      sourceWorkflowId: import_zod62.z.string().min(1),
+      sourceNodeId: import_zod62.z.string().nullable(),
+      targetWorkflowId: import_zod62.z.string().min(1),
+      condition: import_zod62.z.string().nullable(),
+      volume: import_zod62.z.number().int().nonnegative(),
+      successRate: import_zod62.z.number().min(0).max(100).nullable(),
+      medianDurationMs: import_zod62.z.number().nonnegative().nullable(),
+      errorRate: import_zod62.z.number().min(0).max(100).nullable()
     }).strip();
-    var StudioWorkflowSchema = import_zod52.z.object({
-      id: import_zod52.z.string().min(1),
-      name: import_zod52.z.string().min(1),
-      description: import_zod52.z.string().nullable(),
-      versions: import_zod52.z.array(import_zod52.z.string()),
-      activeVersion: import_zod52.z.string().nullable(),
-      activeRevisionId: import_zod52.z.string().nullable(),
+    var StudioWorkflowSchema = import_zod62.z.object({
+      id: import_zod62.z.string().min(1),
+      name: import_zod62.z.string().min(1),
+      description: import_zod62.z.string().nullable(),
+      versions: import_zod62.z.array(import_zod62.z.string()),
+      activeVersion: import_zod62.z.string().nullable(),
+      activeRevisionId: import_zod62.z.string().nullable(),
       health: StudioWorkflowHealthSchema,
-      tags: import_zod52.z.array(import_zod52.z.string()),
-      lastActivityAt: import_zod52.z.string().datetime({ offset: true }).nullable(),
+      tags: import_zod62.z.array(import_zod62.z.string()),
+      lastActivityAt: import_zod62.z.string().datetime({ offset: true }).nullable(),
       metrics: StudioMetricSchema,
-      nodes: import_zod52.z.array(StudioWorkflowNodeSchema),
-      internalEdges: import_zod52.z.array(StudioWorkflowInternalEdgeSchema)
+      nodes: import_zod62.z.array(StudioWorkflowNodeSchema),
+      internalEdges: import_zod62.z.array(StudioWorkflowInternalEdgeSchema)
     }).strip();
-    var StudioRunsResponseSchema = import_zod52.z.object({
-      runs: import_zod52.z.array(StudioRunSchema),
-      totalCount: import_zod52.z.number().int().nonnegative()
+    var StudioRunsResponseSchema = import_zod62.z.object({
+      runs: import_zod62.z.array(StudioRunSchema),
+      totalCount: import_zod62.z.number().int().nonnegative()
     }).strip();
-    var StudioSessionsResponseSchema = import_zod52.z.object({
-      sessions: import_zod52.z.array(StudioSessionSchema),
-      totalCount: import_zod52.z.number().int().nonnegative()
+    var StudioSessionsResponseSchema = import_zod62.z.object({
+      sessions: import_zod62.z.array(StudioSessionSchema),
+      totalCount: import_zod62.z.number().int().nonnegative()
     }).strip();
-    var StudioInterruptsResponseSchema = import_zod52.z.object({
-      interrupts: import_zod52.z.array(StudioInterruptSchema),
-      totalCount: import_zod52.z.number().int().nonnegative()
+    var StudioInterruptsResponseSchema = import_zod62.z.object({
+      interrupts: import_zod62.z.array(StudioInterruptSchema),
+      totalCount: import_zod62.z.number().int().nonnegative()
     }).strip();
-    var StudioRunDetailResponseSchema = import_zod52.z.object({
+    var StudioRunDetailResponseSchema = import_zod62.z.object({
       run: StudioRunSchema,
-      scores: import_zod52.z.array(StudioScoreSchema).optional(),
-      canReview: import_zod52.z.boolean().optional(),
-      reviewActorId: import_zod52.z.string().optional(),
-      events: import_zod52.z.array(StudioDetailEventSchema),
+      scores: import_zod62.z.array(StudioScoreSchema).optional(),
+      canReview: import_zod62.z.boolean().optional(),
+      reviewActorId: import_zod62.z.string().optional(),
+      events: import_zod62.z.array(StudioDetailEventSchema),
       session: StudioSessionSchema.nullable(),
-      interrupts: import_zod52.z.array(StudioInterruptSchema),
-      updatedAt: import_zod52.z.string().datetime({ offset: true })
+      interrupts: import_zod62.z.array(StudioInterruptSchema),
+      updatedAt: import_zod62.z.string().datetime({ offset: true })
     }).strip();
-    var StudioSessionDetailResponseSchema = import_zod52.z.object({
+    var StudioSessionDetailResponseSchema = import_zod62.z.object({
       session: StudioSessionSchema,
-      runs: import_zod52.z.array(StudioRunSchema),
-      events: import_zod52.z.array(StudioDetailEventSchema),
-      interrupts: import_zod52.z.array(StudioInterruptSchema),
-      updatedAt: import_zod52.z.string().datetime({ offset: true })
+      runs: import_zod62.z.array(StudioRunSchema),
+      events: import_zod62.z.array(StudioDetailEventSchema),
+      interrupts: import_zod62.z.array(StudioInterruptSchema),
+      updatedAt: import_zod62.z.string().datetime({ offset: true })
     }).strip();
-    var StudioInterruptDetailResponseSchema = import_zod52.z.object({
+    var StudioInterruptDetailResponseSchema = import_zod62.z.object({
       interrupt: StudioInterruptSchema,
-      events: import_zod52.z.array(StudioDetailEventSchema),
+      events: import_zod62.z.array(StudioDetailEventSchema),
       run: StudioRunSchema.nullable(),
       session: StudioSessionSchema.nullable(),
-      updatedAt: import_zod52.z.string().datetime({ offset: true })
+      updatedAt: import_zod62.z.string().datetime({ offset: true })
     }).strip();
-    var StudioWorkflowsResponseSchema = import_zod52.z.object({
-      workflows: import_zod52.z.array(StudioWorkflowSchema),
-      observedCalls: import_zod52.z.array(
+    var StudioWorkflowsResponseSchema = import_zod62.z.object({
+      workflows: import_zod62.z.array(StudioWorkflowSchema),
+      observedCalls: import_zod62.z.array(
         StudioWorkflowTransitionSchema.extend({
-          runId: import_zod52.z.string(),
-          invocationId: import_zod52.z.string(),
-          branchId: import_zod52.z.string()
+          runId: import_zod62.z.string(),
+          invocationId: import_zod62.z.string(),
+          branchId: import_zod62.z.string()
         })
       ).optional(),
-      transitions: import_zod52.z.array(StudioWorkflowTransitionSchema),
+      transitions: import_zod62.z.array(StudioWorkflowTransitionSchema),
       cohort: StudioTimeRangeContextSchema.extend({
-        workflowId: import_zod52.z.string().nullable(),
-        version: import_zod52.z.string().nullable()
+        workflowId: import_zod62.z.string().nullable(),
+        version: import_zod62.z.string().nullable()
       }).strip()
     }).strip();
-    var StudioCatalogsResponseSchema = import_zod52.z.object({
-      environments: import_zod52.z.array(import_zod52.z.string()),
-      providers: import_zod52.z.array(import_zod52.z.string()),
-      models: import_zod52.z.array(import_zod52.z.string()),
-      workflows: import_zod52.z.array(import_zod52.z.string()),
-      tags: import_zod52.z.array(import_zod52.z.string())
+    var StudioCatalogsResponseSchema = import_zod62.z.object({
+      environments: import_zod62.z.array(import_zod62.z.string()),
+      providers: import_zod62.z.array(import_zod62.z.string()),
+      models: import_zod62.z.array(import_zod62.z.string()),
+      workflows: import_zod62.z.array(import_zod62.z.string()),
+      tags: import_zod62.z.array(import_zod62.z.string())
     }).strip();
-    var StudioContextResponseSchema = import_zod52.z.object({
-      organization: import_zod52.z.object({
-        name: import_zod52.z.string().min(1)
+    var StudioContextResponseSchema = import_zod62.z.object({
+      organization: import_zod62.z.object({
+        name: import_zod62.z.string().min(1)
       }).strip(),
-      project: import_zod52.z.object({
-        name: import_zod52.z.string().min(1)
+      project: import_zod62.z.object({
+        name: import_zod62.z.string().min(1)
       }).strip(),
-      environments: import_zod52.z.array(import_zod52.z.string()),
-      apiKey: import_zod52.z.object({
-        mode: import_zod52.z.enum(["test", "live"]),
-        scopes: import_zod52.z.array(import_zod52.z.string())
+      environments: import_zod62.z.array(import_zod62.z.string()),
+      apiKey: import_zod62.z.object({
+        mode: import_zod62.z.enum(["test", "live"]),
+        scopes: import_zod62.z.array(import_zod62.z.string())
       }).strip().nullable(),
-      api: import_zod52.z.object({
-        status: import_zod52.z.literal("ok"),
-        service: import_zod52.z.literal("kortyx-api"),
-        version: import_zod52.z.string().min(1)
+      api: import_zod62.z.object({
+        status: import_zod62.z.literal("ok"),
+        service: import_zod62.z.literal("kortyx-api"),
+        version: import_zod62.z.string().min(1)
       }).strip()
     }).strip();
   }
@@ -1662,6 +1980,86 @@ var require_internal = __commonJS({
       }
       return execution ?? invoke(safeSpan(void 0));
     }
+    var import_node2 = require("@kortyx/usage-telemetry/node");
+    var package_default2 = {
+      name: "@kortyx/hooks",
+      version: "0.34.0",
+      private: false,
+      description: "Lifecycle hooks and extension points for Kortyx.",
+      keywords: [
+        "ai",
+        "agent",
+        "agents",
+        "orchestration",
+        "framework",
+        "hooks",
+        "kortyx"
+      ],
+      license: "Apache-2.0",
+      homepage: "https://kortyx.io/",
+      bugs: {
+        url: "https://github.com/kortyx-io/kortyx/issues"
+      },
+      author: "Kortyx (https://github.com/kortyx-io)",
+      main: "./dist/index.js",
+      types: "./dist/index.d.ts",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          default: "./dist/index.js"
+        },
+        "./internal": {
+          types: "./dist/internal.d.ts",
+          default: "./dist/internal.js"
+        }
+      },
+      files: [
+        "dist/**",
+        "README.md",
+        "CHANGELOG.md"
+      ],
+      scripts: {
+        build: "tsup",
+        predev: "tsc -p tsconfig.build.json",
+        dev: "tsc --watch",
+        lint: "biome check src",
+        test: "vitest run && pnpm -s type-check",
+        coverage: "vitest run --coverage && pnpm -s type-check",
+        "test:watch": "vitest",
+        "type-check": "tsc --noEmit -p tsconfig.test.json"
+      },
+      dependencies: {
+        "@kortyx/core": "workspace:*",
+        "@kortyx/providers": "workspace:*",
+        "@kortyx/telemetry-contracts": "workspace:*",
+        zod: "catalog:",
+        "@kortyx/prompts": "workspace:*",
+        "@kortyx/usage-telemetry": "workspace:*"
+      },
+      devDependencies: {
+        turbo: "catalog:",
+        typescript: "catalog:",
+        tsup: "catalog:",
+        vitest: "catalog:",
+        "@vitest/coverage-v8": "catalog:"
+      },
+      sideEffects: false,
+      repository: {
+        type: "git",
+        url: "https://github.com/kortyx-io/kortyx.git",
+        directory: "packages/hooks"
+      },
+      publishConfig: {
+        access: "public"
+      }
+    };
+    var client2 = () => (0, import_node2.getUsageTelemetry)("hooks", package_default2.version);
+    var usage2 = {
+      start: (...args) => client2().start(...args),
+      feature: (...args) => client2().feature(...args),
+      measure: (...args) => client2().measure(...args),
+      flush: () => client2().flush()
+    };
     function assertModelFinish(result) {
       if (result.finishReason?.unified !== "content-filter") return;
       throw Object.assign(
@@ -1701,7 +2099,7 @@ var require_internal = __commonJS({
       }
       return providerOptions;
     };
-    async function runReasonEngine(args) {
+    async function runReasonEngineInternal(args) {
       let stream = args.stream ?? args.model.options?.streaming ?? true;
       const emit = args.emit ?? true;
       const temperature = args.temperature ?? args.model.options?.temperature ?? args.defaultTemperature;
@@ -1728,6 +2126,11 @@ var require_internal = __commonJS({
         ...providerOptions !== void 0 ? { providerOptions } : {}
       });
       if (tools?.length && !model.supportsToolStreaming) stream = false;
+      usage2.feature("sdk.model", {
+        streaming: stream,
+        tools: Boolean(tools?.length),
+        provider: args.model.provider.id
+      });
       const messages = args.messages !== void 0 ? args.messages : [
         ...typeof args.system === "string" && args.system.length > 0 ? [{ role: "system", content: args.system }] : [],
         { role: "user", content: String(args.input ?? "") }
@@ -1807,7 +2210,7 @@ var require_internal = __commonJS({
           let continuation;
           let final = "";
           let raw;
-          let usage;
+          let usage22;
           let finishReason;
           let toolCalls;
           let providerMetadata;
@@ -1848,7 +2251,7 @@ var require_internal = __commonJS({
                   raw = chunk.raw;
                 }
                 if (chunk.usage !== void 0) {
-                  usage = chunk.usage;
+                  usage22 = chunk.usage;
                 }
                 if (chunk.finishReason !== void 0) {
                   finishReason = chunk.finishReason;
@@ -1886,7 +2289,7 @@ var require_internal = __commonJS({
             }
           }
           (0, import_core6.throwIfExecutionAborted)(abortSignal);
-          assertModelFinish({ finishReason, usage });
+          assertModelFinish({ finishReason, usage: usage22 });
           if (emit) {
             emitNodeEvent(args.emitEvent, args.nodeId, "text-end", {
               ...commonMeta
@@ -1896,7 +2299,7 @@ var require_internal = __commonJS({
             text: final,
             ...continuation ? { continuation } : {},
             ...raw !== void 0 ? { raw } : {},
-            ...usage !== void 0 ? { usage } : {},
+            ...usage22 !== void 0 ? { usage: usage22 } : {},
             ...finishReason !== void 0 ? { finishReason } : {},
             ...toolCalls !== void 0 ? { toolCalls } : {},
             ...providerMetadata !== void 0 ? { providerMetadata } : {},
@@ -1942,6 +2345,14 @@ var require_internal = __commonJS({
         throw failure2;
       }
     }
+    function runReasonEngine(args) {
+      return usage2.measure("sdk.model", () => runReasonEngineInternal(args), {
+        provider: args.model.provider.id,
+        requested_streaming: args.stream ?? args.model.options?.streaming ?? true,
+        tools: Boolean((args.tools ?? args.model.options?.tools)?.length),
+        format: args.responseFormat?.type ?? args.model.options?.responseFormat?.type ?? "text"
+      });
+    }
     var privateField = /^(?:password|passwd|secret|clientsecret|privatekey|credential|credentials|authorization|bearer|bearertoken|jwt|token|accesstoken|refreshtoken|authtoken|apikey|apisecret|cookie|setcookie|resumehandle|resumetoken)$/;
     function safeTelemetryMetadata2(value) {
       const seen = /* @__PURE__ */ new WeakSet();
@@ -2003,6 +2414,7 @@ var require_dist2 = __commonJS({
       useAbortSignal: () => useAbortSignal,
       useInterrupt: () => useInterrupt,
       useNodeState: () => useNodeState,
+      usePrompt: () => usePrompt,
       useReason: () => useReason2,
       useRuntimeContext: () => useRuntimeContext,
       useStructuredData: () => useStructuredData,
@@ -2013,8 +2425,8 @@ var require_dist2 = __commonJS({
     });
     module2.exports = __toCommonJS2(index_exports2);
     var import_zod12 = require("zod");
-    var import_node_async_hooks = require("async_hooks");
-    var storage = new import_node_async_hooks.AsyncLocalStorage();
+    var import_node_async_hooks2 = require("async_hooks");
+    var storage = new import_node_async_hooks2.AsyncLocalStorage();
     var isRecord5 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
     var normalizeNodeState = (value) => {
       if (Array.isArray(value)) {
@@ -2104,11 +2516,11 @@ var require_dist2 = __commonJS({
       }
       if (changed) ctx.stateDirty = true;
     };
-    var toTokenUsageDelta = (usage) => {
-      if (!usage) return void 0;
-      const input = usage.input ?? 0;
-      const output = usage.output ?? 0;
-      const total = usage.total ?? input + output + (usage.outputIncludesReasoning ? 0 : usage.reasoning ?? 0);
+    var toTokenUsageDelta = (usage22) => {
+      if (!usage22) return void 0;
+      const input = usage22.input ?? 0;
+      const output = usage22.output ?? 0;
+      const total = usage22.total ?? input + output + (usage22.outputIncludesReasoning ? 0 : usage22.reasoning ?? 0);
       if (input === 0 && output === 0 && total === 0) {
         return void 0;
       }
@@ -2118,8 +2530,8 @@ var require_dist2 = __commonJS({
         total
       };
     };
-    function accumulateTokenUsage(usage) {
-      const delta = toTokenUsageDelta(usage);
+    function accumulateTokenUsage(usage22) {
+      const delta = toTokenUsageDelta(usage22);
       if (!delta) return;
       const ctx = getHookContext();
       const current = ctx.tokenUsage ?? {
@@ -2204,11 +2616,91 @@ var require_dist2 = __commonJS({
         runtime: { ...ctx.state.runtime, ...buildRuntimeStateUpdates(ctx) }
       };
     }
+    var import_node2 = require("@kortyx/usage-telemetry/node");
+    var package_default2 = {
+      name: "@kortyx/hooks",
+      version: "0.34.0",
+      private: false,
+      description: "Lifecycle hooks and extension points for Kortyx.",
+      keywords: [
+        "ai",
+        "agent",
+        "agents",
+        "orchestration",
+        "framework",
+        "hooks",
+        "kortyx"
+      ],
+      license: "Apache-2.0",
+      homepage: "https://kortyx.io/",
+      bugs: {
+        url: "https://github.com/kortyx-io/kortyx/issues"
+      },
+      author: "Kortyx (https://github.com/kortyx-io)",
+      main: "./dist/index.js",
+      types: "./dist/index.d.ts",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          default: "./dist/index.js"
+        },
+        "./internal": {
+          types: "./dist/internal.d.ts",
+          default: "./dist/internal.js"
+        }
+      },
+      files: [
+        "dist/**",
+        "README.md",
+        "CHANGELOG.md"
+      ],
+      scripts: {
+        build: "tsup",
+        predev: "tsc -p tsconfig.build.json",
+        dev: "tsc --watch",
+        lint: "biome check src",
+        test: "vitest run && pnpm -s type-check",
+        coverage: "vitest run --coverage && pnpm -s type-check",
+        "test:watch": "vitest",
+        "type-check": "tsc --noEmit -p tsconfig.test.json"
+      },
+      dependencies: {
+        "@kortyx/core": "workspace:*",
+        "@kortyx/providers": "workspace:*",
+        "@kortyx/telemetry-contracts": "workspace:*",
+        zod: "catalog:",
+        "@kortyx/prompts": "workspace:*",
+        "@kortyx/usage-telemetry": "workspace:*"
+      },
+      devDependencies: {
+        turbo: "catalog:",
+        typescript: "catalog:",
+        tsup: "catalog:",
+        vitest: "catalog:",
+        "@vitest/coverage-v8": "catalog:"
+      },
+      sideEffects: false,
+      repository: {
+        type: "git",
+        url: "https://github.com/kortyx-io/kortyx.git",
+        directory: "packages/hooks"
+      },
+      publishConfig: {
+        access: "public"
+      }
+    };
+    var client2 = () => (0, import_node2.getUsageTelemetry)("hooks", package_default2.version);
+    var usage2 = {
+      start: (...args) => client2().start(...args),
+      feature: (...args) => client2().feature(...args),
+      measure: (...args) => client2().measure(...args),
+      flush: () => client2().flush()
+    };
     var optionsSchema = import_zod12.z.object({
       message: import_zod12.z.string().optional(),
       data: import_zod12.z.json().optional()
     }).strict();
-    async function completeResponse(options = {}) {
+    async function completeResponseInternal(options = {}) {
       const ctx = getHookContext();
       const parsed = optionsSchema.parse(options);
       if (!ctx.node.completeResponse) {
@@ -2218,6 +2710,12 @@ var require_dist2 = __commonJS({
       }
       await ctx.node.completeResponse(parsed, snapshotHookState());
     }
+    function completeResponse(options = {}) {
+      return usage2.measure(
+        "sdk.complete_response",
+        () => completeResponseInternal(options)
+      );
+    }
     var import_core6 = require("@kortyx/core");
     var resolveReasonCheckpointKey = (args) => typeof args.id === "string" && args.id.length > 0 ? `__useReason:${args.id}` : `__useReason:auto:${args.autoIndex}`;
     var readReasonCheckpoint = (raw) => {
@@ -2594,7 +3092,7 @@ var require_dist2 = __commonJS({
         return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
       }
     };
-    var emitStructuredData = (args) => {
+    var emitStructuredDataInternal = (args) => {
       const ctx = getHookContext();
       const streamId = typeof args.streamId === "string" && args.streamId.length > 0 ? args.streamId : createStructuredStreamId();
       const dataType = typeof args.dataType === "string" && args.dataType.length > 0 ? args.dataType : "generic";
@@ -2657,7 +3155,17 @@ var require_dist2 = __commonJS({
     };
     var shouldEmitStructured = (cfg) => Boolean(cfg);
     var shouldStreamStructured = (cfg) => Boolean(cfg) && (cfg?.stream ?? true);
-    var import_node_async_hooks2 = require("async_hooks");
+    var emitStructuredData = (args) => {
+      const scope = usage2.start("sdk.structured", { format: args.kind });
+      try {
+        emitStructuredDataInternal(args);
+        scope.end();
+      } catch (error) {
+        scope.fail(error);
+        throw error;
+      }
+    };
+    var import_node_async_hooks22 = require("async_hooks");
     var import_node_crypto32 = require("crypto");
     var import_core22 = require("@kortyx/core");
     var import_errors32 = require("@kortyx/core/errors");
@@ -2947,7 +3455,7 @@ var require_dist2 = __commonJS({
       const serialized = JSON.stringify(value);
       return serialized && Buffer.byteLength(serialized, "utf8") <= 16384 ? { [side]: JSON.parse(serialized) } : { [`${side}Omitted`]: "Content exceeds 16 KiB" };
     }
-    var tools = new import_node_async_hooks2.AsyncLocalStorage();
+    var tools = new import_node_async_hooks22.AsyncLocalStorage();
     function classification(tool, value, thrown, policy = tool.outcomes) {
       const fallback = {
         outcome: thrown ? "fault" : "success"
@@ -3122,6 +3630,11 @@ var require_dist2 = __commonJS({
       }
       ctx.node.consumeExecution?.("maxToolCalls");
       observation.executed = true;
+      const operationUsage = usage2.start("sdk.tool", {
+        calling_mode: args.callingMode,
+        source: args.tool.source === "mcp" ? "mcp" : "native",
+        executed: true
+      });
       const started = performance.now();
       return withSafeTraceSpan2(
         toolTrace(observation),
@@ -3171,9 +3684,13 @@ var require_dist2 = __commonJS({
                   scope.telemetry ?? args.tool.telemetry
                 );
             }
+            if (observation.outcome === "fault") operationUsage.fail(error);
             throw error;
           } finally {
             observation.durationMs = Math.max(0, performance.now() - started);
+            operationUsage.end(
+              observation.outcome === "fault" ? "failed" : observation.outcome ?? "suspended"
+            );
             span.end?.({
               attributes: {
                 ...observation,
@@ -3283,6 +3800,7 @@ var require_dist2 = __commonJS({
     });
     var import_node_crypto52 = require("crypto");
     var import_core42 = require("@kortyx/core");
+    var import_prompts3 = require("@kortyx/prompts");
     var import_node_crypto42 = require("crypto");
     var import_core32 = require("@kortyx/core");
     var import_errors42 = require("@kortyx/core/errors");
@@ -3325,7 +3843,7 @@ var require_dist2 = __commonJS({
       }
       return providerOptions;
     };
-    async function runReasonEngine(args) {
+    async function runReasonEngineInternal(args) {
       let stream = args.stream ?? args.model.options?.streaming ?? true;
       const emit = args.emit ?? true;
       const temperature = args.temperature ?? args.model.options?.temperature ?? args.defaultTemperature;
@@ -3352,6 +3870,11 @@ var require_dist2 = __commonJS({
         ...providerOptions !== void 0 ? { providerOptions } : {}
       });
       if (tools2?.length && !model.supportsToolStreaming) stream = false;
+      usage2.feature("sdk.model", {
+        streaming: stream,
+        tools: Boolean(tools2?.length),
+        provider: args.model.provider.id
+      });
       const messages = args.messages !== void 0 ? args.messages : [
         ...typeof args.system === "string" && args.system.length > 0 ? [{ role: "system", content: args.system }] : [],
         { role: "user", content: String(args.input ?? "") }
@@ -3431,7 +3954,7 @@ var require_dist2 = __commonJS({
           let continuation;
           let final = "";
           let raw;
-          let usage;
+          let usage22;
           let finishReason;
           let toolCalls;
           let providerMetadata;
@@ -3472,7 +3995,7 @@ var require_dist2 = __commonJS({
                   raw = chunk.raw;
                 }
                 if (chunk.usage !== void 0) {
-                  usage = chunk.usage;
+                  usage22 = chunk.usage;
                 }
                 if (chunk.finishReason !== void 0) {
                   finishReason = chunk.finishReason;
@@ -3510,7 +4033,7 @@ var require_dist2 = __commonJS({
             }
           }
           (0, import_core32.throwIfExecutionAborted)(abortSignal);
-          assertModelFinish({ finishReason, usage });
+          assertModelFinish({ finishReason, usage: usage22 });
           if (emit) {
             emitNodeEvent(args.emitEvent, args.nodeId, "text-end", {
               ...commonMeta
@@ -3520,7 +4043,7 @@ var require_dist2 = __commonJS({
             text: final,
             ...continuation ? { continuation } : {},
             ...raw !== void 0 ? { raw } : {},
-            ...usage !== void 0 ? { usage } : {},
+            ...usage22 !== void 0 ? { usage: usage22 } : {},
             ...finishReason !== void 0 ? { finishReason } : {},
             ...toolCalls !== void 0 ? { toolCalls } : {},
             ...providerMetadata !== void 0 ? { providerMetadata } : {},
@@ -3566,6 +4089,14 @@ var require_dist2 = __commonJS({
         throw failure2;
       }
     }
+    function runReasonEngine(args) {
+      return usage2.measure("sdk.model", () => runReasonEngineInternal(args), {
+        provider: args.model.provider.id,
+        requested_streaming: args.stream ?? args.model.options?.streaming ?? true,
+        tools: Boolean((args.tools ?? args.model.options?.tools)?.length),
+        format: args.responseFormat?.type ?? args.model.options?.responseFormat?.type ?? "text"
+      });
+    }
     var createRuntimeId2 = () => {
       try {
         return (0, import_node_crypto52.randomUUID)();
@@ -3582,6 +4113,19 @@ var require_dist2 = __commonJS({
       );
       (0, import_core42.throwIfExecutionAborted)(abortSignal);
       ctx.node.consumeExecution?.("maxModelPasses");
+      const prompt = args.telemetry?.prompt;
+      const identity = prompt?.metadata;
+      if ((0, import_prompts3.isPromptUsageMetadata)(identity)) {
+        const { dependencies, ...parent } = identity;
+        ctx.node.prompts?.recordUsage({ ...parent, model: args.model.modelId });
+        for (const dependency of dependencies ?? [])
+          ctx.node.prompts?.recordUsage({
+            ...dependency,
+            environment: identity.environment,
+            snapshotRevision: identity.snapshotRevision,
+            model: args.model.modelId
+          });
+      }
       try {
         return await runReasonEngine({
           model: args.model,
@@ -3595,7 +4139,12 @@ var require_dist2 = __commonJS({
           responseFormat: args.responseFormat,
           providerOptions: args.providerOptions,
           tools: args.tools,
-          messages: args.messages,
+          messages: args.messages && inputOverride !== void 0 ? args.messages.map(
+            (message, index) => index === args.messages.reduce(
+              (last, item, position) => item.role === "user" ? position : last,
+              -1
+            ) ? { ...message, content: inputOverride } : message
+          ) : args.messages,
           defaultTemperature: ctx.node.config?.model?.temperature,
           stream: args.stream,
           emit: args.emit,
@@ -3608,8 +4157,8 @@ var require_dist2 = __commonJS({
           opId: meta.opId
         });
       } catch (error) {
-        const usage = error?.usage;
-        if (usage) accumulateTokenUsage(usage);
+        const usage22 = error?.usage;
+        if (usage22) accumulateTokenUsage(usage22);
         throw error;
       }
     }
@@ -4490,6 +5039,36 @@ var require_dist2 = __commonJS({
         throw error;
       }
     };
+    var import_prompts22 = require("@kortyx/prompts");
+    function normalizePromptReasonArgs(args) {
+      if (!("prompt" in args)) return args;
+      if (args.input !== void 0 || args.system !== void 0 || "messages" in args)
+        throw new import_prompts22.PromptError(
+          "PROMPT_REASON_CONFLICT",
+          "Use either prompt or input/system/messages in useReason."
+        );
+      const { prompt, ...rest } = args;
+      if (!(0, import_prompts22.isCompiledPrompt)(prompt))
+        throw new import_prompts22.PromptError(
+          "PROMPT_REASON_INVALID",
+          "useReason requires a compiled prompt returned by usePrompt."
+        );
+      return {
+        ...rest,
+        input: prompt.format === "system-user" ? prompt.user ?? "" : prompt.messages.filter((message) => message.role === "user").at(-1)?.content ?? "",
+        ...prompt.format === "system-user" ? { system: prompt.system } : { messages: structuredClone(prompt.messages) },
+        telemetry: {
+          ...args.telemetry,
+          prompt: {
+            name: prompt.ref.id,
+            version: prompt.ref.version,
+            type: prompt.format === "chat" ? "chat" : "text",
+            source: prompt.ref.source,
+            metadata: (0, import_prompts22.promptUsageMetadata)(prompt)
+          }
+        }
+      };
+    }
     var import_zod42 = require("zod");
     var tryStringify2 = (value) => {
       if (typeof value === "string") return value;
@@ -4734,19 +5313,34 @@ ${tryStringify2(args.response)}`
         ...value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value) ? { structuredContent: value } : {}
       };
     };
-    var createInitialMessages = (args) => [
-      ...typeof args.system === "string" || args.interruptInstructions || args.outputInstructions ? [
-        {
-          role: "system",
-          content: [
-            args.system,
-            args.interruptInstructions,
-            args.outputInstructions
-          ].filter((value) => Boolean(value)).join("\n\n")
-        }
-      ] : [],
-      { role: "user", content: String(args.input ?? "") }
-    ];
+    var createInitialMessages = (args) => {
+      if (args.messages) {
+        const ordered = args.messages.map((message) => ({ ...message }));
+        const lastUser = ordered.reduce(
+          (last, message, position) => message.role === "user" ? position : last,
+          -1
+        );
+        if (args.inputOverride && lastUser >= 0)
+          ordered[lastUser] = { ...ordered[lastUser], content: args.input };
+        const instructions = [args.interruptInstructions, args.outputInstructions].filter(Boolean).join("\n\n");
+        if (instructions)
+          ordered.unshift({ role: "system", content: instructions });
+        return ordered;
+      }
+      return [
+        ...typeof args.system === "string" || args.interruptInstructions || args.outputInstructions ? [
+          {
+            role: "system",
+            content: [
+              args.system,
+              args.interruptInstructions,
+              args.outputInstructions
+            ].filter((value) => Boolean(value)).join("\n\n")
+          }
+        ] : [],
+        { role: "user", content: String(args.input ?? "") }
+      ];
+    };
     var runReasonToolLoop = async (args) => {
       const { useReasonArgs, id: id3, traceSpan, checkpointKey } = args;
       const ctx = getHookContext();
@@ -4888,6 +5482,8 @@ ${tryStringify2(args.response)}`
       let completed = false;
       const maxSteps = Math.max(1, useReasonArgs.toolExecution?.maxSteps ?? 3);
       const messages = checkpoint?.messages ?? createInitialMessages({
+        messages: useReasonArgs.messages,
+        inputOverride: Boolean(useReasonArgs.outputSchema),
         system: useReasonArgs.system,
         input: useReasonArgs.outputSchema ? withOutputGuardrails(useReasonArgs.input, useReasonArgs.outputSchema) : useReasonArgs.input,
         ...interruptConfig ? {
@@ -4922,7 +5518,7 @@ ${tryStringify2(args.response)}`
       let finalRaw;
       let finalOutput;
       let aggregatedUsage = steps.reduce(
-        (usage, step) => mergeUsage(usage, step.usage),
+        (usage22, step) => mergeUsage(usage22, step.usage),
         void 0
       );
       let finalFinishReason;
@@ -6023,7 +6619,10 @@ ${tryStringify2(args.response)}`
         }
       );
     }
-    async function useReason(args) {
+    async function useReason(request) {
+      const args = normalizePromptReasonArgs(
+        request
+      );
       try {
         return await runReason(args);
       } finally {
@@ -6321,6 +6920,36 @@ ${tryStringify2(args.response)}`
       } catch {
       }
     }
+    var import_prompts32 = require("@kortyx/prompts");
+    async function usePrompt(reference, options) {
+      const ctx = getHookContext();
+      if (!ctx.node.prompts)
+        throw new import_prompts32.PromptError(
+          "PROMPT_SOURCE_NOT_CONFIGURED",
+          "Configure createAgent({ prompts: createPrompts(...) }) before calling usePrompt."
+        );
+      const stored = ctx.workflowState.__promptSnapshot;
+      const snapshot = await ctx.node.prompts.snapshot(stored);
+      if (!stored) {
+        ctx.workflowState.__promptSnapshot = snapshot;
+        ctx.stateDirty = true;
+      }
+      const key = `__promptPin:${reference.id}:${options.version ?? "assignment"}`;
+      const pin = options.version !== void 0 ? await ctx.node.prompts.pin(
+        reference.id,
+        options.version,
+        ctx.workflowState[key]
+      ) : void 0;
+      if (pin && !ctx.workflowState[key]) {
+        ctx.workflowState[key] = pin;
+        ctx.stateDirty = true;
+      }
+      return ctx.node.prompts.resolve(reference, {
+        ...options,
+        stored: snapshot,
+        ...pin ? { pin } : {}
+      });
+    }
     var import_node_crypto62 = require("crypto");
     var import_core8 = require("@kortyx/core");
     var import_errors82 = require("@kortyx/core/errors");
@@ -6475,14 +7104,14 @@ ${tryStringify2(args.response)}`
           ...content
         });
       };
-      const recordUsage = (usage) => {
-        if (!usage) return;
+      const recordUsage = (usage22) => {
+        if (!usage22) return;
         accumulateTokenUsage({
-          input: usage.input - (record.usage?.input ?? 0),
-          output: usage.output - (record.usage?.output ?? 0),
-          total: usage.total - (record.usage?.total ?? 0)
+          input: usage22.input - (record.usage?.input ?? 0),
+          output: usage22.output - (record.usage?.output ?? 0),
+          total: usage22.total - (record.usage?.total ?? 0)
         });
-        record.usage = usage;
+        record.usage = usage22;
       };
       const cached = record.status === "completed";
       try {
@@ -6938,6 +7567,7 @@ var emitTelemetryEvent = (args) => {
 
 // src/telemetry/topology.ts
 var import_node_crypto2 = require("crypto");
+var import_eval_attribution = require("@kortyx/core/eval-attribution");
 var isRecord2 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 var stableValue = (value) => {
   if (Array.isArray(value)) return value.map(stableValue);
@@ -7090,6 +7720,8 @@ var projectWorkflowTopology = (args) => {
   };
 };
 var prepareWorkflowTelemetry = (args) => {
+  if (args.sessionId)
+    (0, import_eval_attribution.associateEvalExecution)({ sessionId: args.sessionId, runId: args.runId });
   const telemetry = isRecord2(args.config.telemetry) ? args.config.telemetry : void 0;
   if (!telemetry?.reporter || !telemetry.environment || !telemetry.service) {
     return args.config;
@@ -7141,6 +7773,100 @@ var prepareWorkflowTelemetry = (args) => {
   };
 };
 
+// src/usage.ts
+var import_node = require("@kortyx/usage-telemetry/node");
+
+// package.json
+var package_default = {
+  name: "@kortyx/agent",
+  version: "0.37.0",
+  private: false,
+  description: "Agent composition utilities for Kortyx.",
+  keywords: [
+    "ai",
+    "agent",
+    "agents",
+    "orchestration",
+    "framework",
+    "kortyx"
+  ],
+  license: "Apache-2.0",
+  homepage: "https://kortyx.io/",
+  bugs: {
+    url: "https://github.com/kortyx-io/kortyx/issues"
+  },
+  author: "Kortyx (https://github.com/kortyx-io)",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./browser": {
+      types: "./dist/browser.d.ts",
+      default: "./dist/browser.js"
+    },
+    "./evals": {
+      types: "./dist/evals.d.ts",
+      default: "./dist/evals.js"
+    }
+  },
+  files: [
+    "dist/**",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  scripts: {
+    build: "tsup",
+    predev: "tsc -p tsconfig.build.json",
+    dev: "tsc --watch",
+    lint: "biome check src",
+    test: "vitest run && pnpm -s type-check",
+    coverage: "vitest run --coverage && pnpm -s type-check",
+    "test:watch": "vitest",
+    "type-check": "tsc --noEmit -p tsconfig.test.json"
+  },
+  dependencies: {
+    "@kortyx/core": "workspace:*",
+    "@kortyx/providers": "workspace:*",
+    "@kortyx/runtime": "workspace:*",
+    "@kortyx/stream": "workspace:*",
+    "@kortyx/utils": "workspace:*",
+    "@langchain/core": "catalog:",
+    "@langchain/langgraph": "catalog:",
+    zod: "catalog:",
+    "@kortyx/prompts": "workspace:*",
+    "@kortyx/usage-telemetry": "workspace:*"
+  },
+  devDependencies: {
+    "@kortyx/hooks": "workspace:*",
+    turbo: "catalog:",
+    typescript: "catalog:",
+    tsup: "catalog:",
+    vitest: "catalog:",
+    "@vitest/coverage-v8": "catalog:",
+    "@kortyx/openai": "workspace:*",
+    postgres: "^3.4.7"
+  },
+  sideEffects: false,
+  repository: {
+    type: "git",
+    url: "https://github.com/kortyx-io/kortyx.git",
+    directory: "packages/agent"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/usage.ts
+var client = () => (0, import_node.getUsageTelemetry)("agent", package_default.version);
+var usage = {
+  start: (...args) => client().start(...args),
+  measure: (...args) => client().measure(...args)
+};
+
 // src/orchestrator.ts
 var isRecord3 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 var isGraphState = (value) => isRecord3(value) && typeof value.currentWorkflow === "string";
@@ -7175,6 +7901,13 @@ async function orchestrateGraphStream({
   frameworkAdapter,
   executionLeaseRelease
 }) {
+  let usageLimitReached = false;
+  const executionUsage = usage.start("sdk.execution", {
+    continue_on_disconnect: continueOnDisconnect
+  });
+  const responseUsage = emitOutput ? usage.start("sdk.response", { phase: "delivery" }) : { end() {
+  }, fail(_error) {
+  } };
   const out = new import_node_stream.PassThrough({ objectMode: true });
   const visibleMessage = emitOutput && clientTurnId && onResponseFinalized && initialConfig.responseCompleted !== true ? (0, import_stream.createFinalizedChatMessageAccumulator)(clientTurnId) : void 0;
   let responseFinalized = false;
@@ -7182,6 +7915,9 @@ async function orchestrateGraphStream({
     if (!visibleMessage || !onResponseFinalized || !clientTurnId || !sessionId || responseFinalized)
       return;
     responseFinalized = true;
+    responseUsage.end(
+      status2 === "completed" ? "success" : status2 === "interrupted" ? "suspended" : status2
+    );
     try {
       await onResponseFinalized({
         sessionId,
@@ -7198,6 +7934,16 @@ async function orchestrateGraphStream({
   const write = (chunk) => {
     if (isRecord3(chunk) && chunk.type === "done" && isGraphState(chunk.data)) {
       const { __kortyxParallelGraph: _journal, ...runtime } = chunk.data.runtime;
+      if (isRecord3(runtime.__kortyx) && isRecord3(runtime.__kortyx.workflowState)) {
+        runtime.__kortyx = {
+          ...runtime.__kortyx,
+          workflowState: Object.fromEntries(
+            Object.entries(runtime.__kortyx.workflowState).filter(
+              ([key]) => key !== "__promptSnapshot" && !key.startsWith("__promptPin:")
+            )
+          )
+        };
+      }
       chunk = { ...chunk, data: { ...chunk.data, runtime } };
     }
     if (emitOutput && !response.closed) {
@@ -7221,6 +7967,7 @@ async function orchestrateGraphStream({
     requestSignal: continueOnDisconnect ? void 0 : requestSignal,
     executionSignal: executionSignal ? AbortSignal.any([executionSignal, leaseAbort.signal]) : leaseAbort.signal,
     onClosed: () => {
+      responseUsage.end();
       out.write({ type: "done" });
       out.end();
     },
@@ -8207,6 +8954,7 @@ async function orchestrateGraphStream({
       return;
     }
     if ((0, import_core2.isExecutionLimitReached)(err)) {
+      usageLimitReached = true;
       try {
         const snapshot = frameworkAdapter && await (0, import_runtime.captureGraphSnapshot)(frameworkAdapter.checkpointer, runId);
         (0, import_core2.throwIfExecutionAborted)(abortSignal);
@@ -8340,6 +9088,16 @@ async function orchestrateGraphStream({
     await finalizeVisibleResponse(
       outcomeError ? (0, import_core2.isExecutionCancelled)(outcomeError) ? "cancelled" : "failed" : pendingRecordToken || outcomeState.awaitingHumanInput ? "interrupted" : "completed"
     );
+    if (outcomeError) executionUsage.fail(outcomeError);
+    else
+      executionUsage.end(
+        usageLimitReached ? "limit_reached" : pendingRecordToken || outcomeState.awaitingHumanInput ? "suspended" : "success"
+      );
+    if (outcomeError) responseUsage.fail(outcomeError);
+    else
+      responseUsage.end(
+        pendingRecordToken || outcomeState.awaitingHumanInput ? "suspended" : "success"
+      );
     onOutcome?.({
       state: outcomeState,
       pending: pendingRecordToken ? activePendingRequests.get(pendingRecordToken) : void 0,
@@ -8954,6 +9712,10 @@ var import_providers = require("@kortyx/providers");
 var import_runtime5 = require("@kortyx/runtime");
 var import_zod5 = require("zod");
 
+// src/evals/prompt-context.ts
+var import_node_async_hooks = require("async_hooks");
+var promptEvaluationContext = new import_node_async_hooks.AsyncLocalStorage();
+
 // src/execution/execute.ts
 var import_core4 = require("@kortyx/core");
 var import_errors6 = require("@kortyx/core/errors");
@@ -8975,12 +9737,12 @@ var responseSchema = import_zod3.z.discriminatedUnion("type", [
   import_zod3.z.object({ type: import_zod3.z.literal("cancel") }).strict()
 ]);
 function resultFromOutcome(outcome, runId, sessionId) {
-  const usage = outcome.pending?.schema.meta?.__kortyxResumeStatePatch?.tokenUsage ?? outcome.error?.__kortyxHookStatePatch?.tokenUsage ?? outcome.state.runtime?.tokenUsage;
+  const usage2 = outcome.pending?.schema.meta?.__kortyxResumeStatePatch?.tokenUsage ?? outcome.error?.__kortyxHookStatePatch?.tokenUsage ?? outcome.state.runtime?.tokenUsage;
   const info = {
     runId,
     sessionId,
     ...outcome.checkpointId ? { checkpointId: outcome.checkpointId } : {},
-    ...usage ? { usage } : {}
+    ...usage2 ? { usage: usage2 } : {}
   };
   if ((0, import_core4.isExecutionCancelled)(outcome.error))
     return { ...info, status: "cancelled", reason: "Execution cancelled." };
@@ -9034,6 +9796,7 @@ function resultFromOutcome(outcome, runId, sessionId) {
 function runtimeConfig(services, sessionId, context) {
   return {
     session: { id: sessionId },
+    ...services.prompts ? { prompts: services.prompts.start() } : {},
     ...context ? { context } : {},
     getProvider: services.getProvider,
     checkpointer: services.frameworkAdapter.checkpointer,
@@ -9572,7 +10335,8 @@ var createAgentArgsBaseSchema = import_zod5.z.object({
   workflowRegistry: import_zod5.z.unknown().optional(),
   defaultWorkflowId: import_zod5.z.string().optional(),
   frameworkAdapter: import_zod5.z.unknown().optional(),
-  telemetry: import_zod5.z.unknown().optional()
+  telemetry: import_zod5.z.unknown().optional(),
+  prompts: import_zod5.z.unknown().optional()
 }).strict();
 var createAgentArgsSchema = createAgentArgsBaseSchema.superRefine(
   (value, ctx) => {
@@ -9633,7 +10397,7 @@ var clearPendingGraphWrites = async (frameworkAdapter, request) => {
     )
   ]);
 };
-function createAgent(args) {
+function createAgentInternal(args) {
   const parsedArgs = parseCreateAgentArgs(args);
   const {
     limits,
@@ -9643,7 +10407,8 @@ function createAgent(args) {
     workflowRegistry,
     defaultWorkflowId,
     frameworkAdapter,
-    telemetry
+    telemetry,
+    prompts
   } = parsedArgs;
   const resolvedDefaultWorkflowId = defaultWorkflowId;
   const resolvedFrameworkAdapter = frameworkAdapter ?? (0, import_runtime5.createFrameworkAdapterFromEnv)();
@@ -9668,9 +10433,14 @@ function createAgent(args) {
       fallbackId: resolvedDefaultWorkflowId ?? "general-chat"
     });
   })();
+  const registryUsage = usage.start("sdk.registry");
   const registeredWorkflowsPromise = registryPromise.then(
     (registry) => registry?.list?.()
   );
+  void registeredWorkflowsPromise.then(
+    () => registryUsage.end(),
+    (error) => registryUsage.fail(error)
+  );
   const projectTopology = async (options) => {
     const registeredWorkflows = await registeredWorkflowsPromise;
     if (!registeredWorkflows?.length) return [];
@@ -9684,8 +10454,11 @@ function createAgent(args) {
       })
     );
   };
-  const streamChat2 = async (messages, options) => {
+  const streamChatInternal = async (messages, options) => {
     const parsedOptions = parseAgentProcessOptions(options);
+    const promptEvaluation = promptEvaluationContext.getStore();
+    if (promptEvaluation && !prompts)
+      throw new Error("This application has no prompt manager configured.");
     const registry = await registryPromise;
     if (!registry) {
       throw new Error(
@@ -9725,12 +10498,35 @@ function createAgent(args) {
           }
         } : {},
         ...runtimeOptions?.context ? { context: runtimeOptions.context } : {},
-        ...telemetry ? { telemetry } : {}
+        ...telemetry ? { telemetry } : {},
+        ...prompts ? {
+          prompts: prompts.start({
+            ...runtimeOptions?.abortSignal ? { signal: runtimeOptions.abortSignal } : {},
+            ...promptEvaluation ? {
+              snapshot: promptEvaluation.snapshot,
+              onUsage: promptEvaluation.onUsage
+            } : {}
+          })
+        } : {}
       })
     });
   };
-  const listCheckpoints = (sessionId) => resolvedFrameworkAdapter.sessionCheckpoints.list(sessionId);
-  const getCheckpoint = (id3) => resolvedFrameworkAdapter.sessionCheckpoints.get(id3);
+  const streamChat2 = (messages, options) => usage.measure(
+    "sdk.chat.admission",
+    () => streamChatInternal(messages, options),
+    {
+      phase: "admission",
+      continue_on_disconnect: options?.continueOnDisconnect === true
+    }
+  );
+  const listCheckpoints = (sessionId) => usage.measure(
+    "sdk.checkpoint.list",
+    () => resolvedFrameworkAdapter.sessionCheckpoints.list(sessionId)
+  );
+  const getCheckpoint = (id3) => usage.measure(
+    "sdk.checkpoint.read",
+    () => resolvedFrameworkAdapter.sessionCheckpoints.get(id3)
+  );
   const rollbackTo = async (id3) => {
     const target = await resolvedFrameworkAdapter.sessionCheckpoints.get(id3);
     const sourceRunId = target?.runId ?? "unknown";
@@ -9842,27 +10638,76 @@ function createAgent(args) {
       frameworkAdapter: resolvedFrameworkAdapter,
       getProvider: resolvedGetProvider,
       telemetry,
+      prompts,
       knownWorkflowIds: (await registeredWorkflowsPromise)?.map(
         (workflow) => workflow.id
       )
     };
   };
-  const execute = (async (options) => executeWorkflow(await services(), options));
-  const resume = (async (options) => resumeWorkflow(await services(), options));
+  const observe = async (operation, run) => {
+    const scope = usage.start(operation);
+    try {
+      const result = await run();
+      if (result.status === "failed") scope.fail(result.error);
+      else
+        scope.end(
+          result.status === "completed" ? "success" : result.status === "suspended" && result.reason === "limit_reached" ? "limit_reached" : result.status
+        );
+      return result;
+    } catch (error) {
+      scope.fail(error, { phase: "admission" });
+      throw error;
+    }
+  };
+  const execute = ((options) => observe(
+    "sdk.execute",
+    async () => executeWorkflow(await services(), options)
+  ));
+  const resume = ((options) => observe(
+    "sdk.resume",
+    async () => resumeWorkflow(await services(), options)
+  ));
   return {
     ...createInterruptDiscovery(resolvedFrameworkAdapter.pendingRequests),
     execute,
     resume,
     projectTopology,
     streamChat: streamChat2,
+    describePromptContracts: () => (prompts?.definitions ?? []).map((ref) => ({
+      id: ref.id,
+      format: ref.format,
+      variablesSchema: import_zod5.z.toJSONSchema(ref.variables, { io: "input" }),
+      configSchema: import_zod5.z.toJSONSchema(ref.config, { io: "input" })
+    })),
     listCheckpoints,
     getCheckpoint,
-    rollbackTo,
-    fork
+    rollbackTo: (id3) => usage.measure("sdk.checkpoint.rollback", () => rollbackTo(id3)),
+    fork: (id3, options) => usage.measure("sdk.checkpoint.fork", () => fork(id3, options))
   };
 }
+function createAgent(args) {
+  const scope = usage.start("sdk.initialize");
+  try {
+    const agent = createAgentInternal(args);
+    try {
+      scope.end("success", {
+        source: args.workflowRegistry ? "custom" : args.workflows ? "memory" : "file",
+        storage: args.frameworkAdapter?.kind ?? "custom",
+        prompts: Boolean(args.prompts),
+        observability: Boolean(args.telemetry)
+      });
+    } catch {
+      scope.end();
+    }
+    return agent;
+  } catch (error) {
+    scope.fail(error, { phase: "configuration" });
+    throw error;
+  }
+}
 
 // src/evals/contracts.ts
+var import_browser2 = require("@kortyx/prompts/browser");
 var import_zod7 = require("zod");
 
 // src/evals/evidence-policy.ts
@@ -9967,6 +10812,16 @@ var EvalVerdictSchema = import_zod7.z.object({
   evidence: import_zod7.z.array(import_zod7.z.string().min(1))
 }).strict();
 var EvalObservationSchema = import_zod7.z.object({
+  promptUsage: import_zod7.z.array(
+    import_zod7.z.object({
+      id: import_zod7.z.string(),
+      version: import_zod7.z.number().int().positive(),
+      hash: import_zod7.z.string().regex(/^[a-f0-9]{64}$/),
+      environment: import_zod7.z.string(),
+      snapshotRevision: import_zod7.z.string(),
+      model: import_zod7.z.string().optional()
+    }).strict()
+  ).optional(),
   type: import_zod7.z.enum(["answer", "interrupt", "error", "cancelled"]),
   text: import_zod7.z.string(),
   structured: import_zod7.z.array(import_zod7.z.json()),
@@ -10059,9 +10914,12 @@ var EvalStepResultSchema = import_zod7.z.object({
     EvalVerdictSchema.extend({ id: import_zod7.z.string(), text: import_zod7.z.string() })
   )
 }).strict();
+var runtimeExecution = import_zod7.z.object({ sessionId: import_zod7.z.string().min(1), runId: import_zod7.z.string().min(1) }).strict();
 var EvalCaseResultSchema = import_zod7.z.object({
   caseId: id2,
   repetition: import_zod7.z.number().int().positive(),
+  attemptId: import_zod7.z.uuid().optional(),
+  runtimeExecutions: import_zod7.z.array(runtimeExecution).optional(),
   sessionId: import_zod7.z.string(),
   status,
   durationMs: import_zod7.z.number().nonnegative(),
@@ -10110,6 +10968,15 @@ var EvalRunResultSchema = import_zod7.z.object({
 var EvalManifestSchema = import_zod7.z.object({
   schemaVersion: import_zod7.z.literal(1),
   studioJudging: import_zod7.z.literal(true).optional(),
+  promptContracts: import_zod7.z.array(
+    import_zod7.z.object({
+      id: import_zod7.z.string(),
+      format: import_zod7.z.enum(["system-user", "chat"]),
+      variablesSchema: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()),
+      configSchema: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown())
+    }).strict()
+  ).optional(),
+  attemptScheduling: import_zod7.z.literal(true).optional(),
   suites: import_zod7.z.array(EvalSuiteSchema),
   responders: import_zod7.z.array(
     import_zod7.z.object({
@@ -10123,6 +10990,13 @@ var EvalManifestSchema = import_zod7.z.object({
   judge: judge.optional()
 }).strict();
 var EvalProgressSchema = import_zod7.z.discriminatedUnion("type", [
+  import_zod7.z.object({
+    type: import_zod7.z.literal("case-runtime-associated"),
+    caseId: id2,
+    repetition: import_zod7.z.number().int().positive(),
+    attemptId: import_zod7.z.uuid(),
+    execution: runtimeExecution
+  }).strict(),
   import_zod7.z.object({
     type: import_zod7.z.literal("run-started"),
     caseIds: import_zod7.z.array(id2).min(1),
@@ -10138,6 +11012,7 @@ var EvalProgressSchema = import_zod7.z.discriminatedUnion("type", [
   }).strict(),
   import_zod7.z.object({
     type: import_zod7.z.literal("case-started"),
+    attemptId: import_zod7.z.uuid().optional(),
     caseId: id2,
     repetition: import_zod7.z.number().int().positive(),
     sessionId: import_zod7.z.string()
@@ -10151,18 +11026,37 @@ var EvalProgressSchema = import_zod7.z.discriminatedUnion("type", [
   import_zod7.z.object({ type: import_zod7.z.literal("case-completed"), result: EvalCaseResultSchema }).strict()
 ]);
 var EvalRemoteRunRequestSchema = import_zod7.z.object({
+  promptSnapshot: import_browser2.PromptSnapshotSchema.optional(),
+  promptGroupName: import_zod7.z.string().optional(),
   suiteId: id2,
   suiteRevision: import_zod7.z.string().regex(/^[a-f0-9]{64}$/),
   grading: import_zod7.z.enum(["app", "studio"]).optional(),
   judge: EvalJudgeIdentitySchema.optional(),
   caseIds: import_zod7.z.array(id2).min(1).max(100).optional(),
   repetitions: import_zod7.z.number().int().min(1).max(20).default(1),
-  concurrency: import_zod7.z.number().int().min(1).max(20).default(1)
+  concurrency: import_zod7.z.number().int().min(1).max(20).default(1),
+  attempt: import_zod7.z.object({
+    caseId: id2,
+    repetition: import_zod7.z.number().int().min(1).max(20),
+    evaluationId: import_zod7.z.uuid()
+  }).strict().optional()
 }).strict();
 var StudioEvalStartRequestSchema = EvalRemoteRunRequestSchema.omit({
   grading: true,
-  judge: true
+  judge: true,
+  promptSnapshot: true,
+  promptGroupName: true,
+  attempt: true
 }).extend({
+  promptSelection: import_zod7.z.discriminatedUnion("type", [
+    import_zod7.z.object({ type: import_zod7.z.literal("live") }).strict(),
+    import_zod7.z.object({
+      type: import_zod7.z.literal("single"),
+      id: import_zod7.z.string(),
+      version: import_zod7.z.number().int().positive()
+    }).strict(),
+    import_zod7.z.object({ type: import_zod7.z.literal("group"), groupId: import_zod7.z.uuid() }).strict()
+  ]).optional(),
   targetId: import_zod7.z.string().min(1).max(128),
   judge: import_zod7.z.enum(["studio", "app"]).default("studio")
 });
@@ -10198,6 +11092,8 @@ function parseEvalSuite(value) {
 
 // src/evals/create-evals.ts
 var import_node_crypto5 = require("crypto");
+var import_eval_attribution2 = require("@kortyx/core/eval-attribution");
+var import_usage_telemetry = require("@kortyx/usage-telemetry");
 var import_zod8 = require("zod");
 
 // src/evals/evidence.ts
@@ -10325,6 +11221,7 @@ function canonical(value) {
 var getEvalSuiteRevision = (suite) => (0, import_node_crypto4.createHash)("sha256").update(canonical(suite)).digest("hex");
 
 // src/evals/stream.ts
+var import_prompts = require("@kortyx/prompts");
 var import_stream3 = require("@kortyx/stream");
 
 // src/evals/stream-evidence.ts
@@ -10462,6 +11359,17 @@ function captureEvalEvent(chunk) {
 
 // src/evals/stream.ts
 async function executeEvalChat(args) {
+  if (args.promptSnapshot) {
+    const snapshot = await (0, import_prompts.verifyPromptSnapshot)(args.promptSnapshot);
+    const receipts = [];
+    const { promptSnapshot: _, ...executionArgs } = args;
+    const result = await promptEvaluationContext.run(
+      { snapshot, onUsage: (receipt) => receipts.push(receipt) },
+      () => executeEvalChat(executionArgs)
+    );
+    result.observation.promptUsage = receipts;
+    return result;
+  }
   const waiting = args.continuation;
   if (args.command.type === "cancel" && waiting && waiting.length > 1) {
     let failed = false;
@@ -10683,6 +11591,8 @@ function createEvals(options) {
       return {
         schemaVersion: 1,
         studioJudging: true,
+        ...options.agent.describePromptContracts ? { promptContracts: options.agent.describePromptContracts() } : {},
+        attemptScheduling: true,
         suites: clone(suites),
         responders: Object.entries(responders).map(([name, value]) => ({
           name,
@@ -10727,6 +11637,8 @@ function createEvals(options) {
       );
       if (!Number.isSafeInteger(selected.length * repetitions))
         throw new EvalConfigurationError("Too many case repetitions.");
+      if (args.attempt && (!selected.some((item) => item.id === args.attempt?.caseId) || !Number.isSafeInteger(args.attempt.repetition) || args.attempt.repetition < 1 || args.attempt.repetition > repetitions))
+        throw new EvalConfigurationError("Invalid scheduled attempt.");
       const studioGrading = args.grading === "studio";
       if (!studioGrading && !options.judge && selected.some(
         (item) => item.steps.some((step) => step.expect.criteria?.length)
@@ -10739,6 +11651,9 @@ function createEvals(options) {
         throw new EvalConfigurationError(
           "App judge changed. Refresh before running."
         );
+      const evalUsage = usage.start("sdk.eval", {
+        scale: (0, import_usage_telemetry.scale)(selected.length * repetitions)
+      });
       const start = Date.now();
       const result = {
         id: (0, import_node_crypto5.randomUUID)(),
@@ -10763,7 +11678,10 @@ function createEvals(options) {
       const emit = async (event) => {
         if (!args.onProgress || !reporting) return;
         try {
-          await args.onProgress(clone(event));
+          await (0, import_eval_attribution2.withEvalAttribution)(
+            void 0,
+            () => args.onProgress(clone(event))
+          );
         } catch {
           reporting = false;
           result.errors.push(failure("reporting"));
@@ -10778,138 +11696,221 @@ function createEvals(options) {
           controller.abort();
         }, defaults.caseTimeoutMs);
         const signal = args.signal ? AbortSignal.any([args.signal, controller.signal]) : controller.signal;
+        const attemptId = (0, import_node_crypto5.randomUUID)();
+        const runtimeExecutions = [];
         const attemptResult = {
           caseId: item.id,
           repetition,
+          attemptId,
+          runtimeExecutions,
           sessionId: `eval-${(0, import_node_crypto5.randomUUID)()}`,
           status: "passed",
           durationMs: 0,
           steps: [],
           errors: []
         };
-        let phase = "params";
-        let stepIndex;
-        const reportPhase = async (next) => {
-          phase = next;
-          if (args.includeActivity)
+        let associationProgress = Promise.resolve();
+        let acceptingExecutions = true;
+        const executeAttempt = async () => {
+          let phase = "params";
+          let stepIndex;
+          const reportPhase = async (next) => {
+            phase = next;
+            if (args.includeActivity)
+              await emit({
+                type: "case-progress",
+                caseId: item.id,
+                repetition,
+                phase,
+                ...stepIndex !== void 0 ? { stepIndex } : {}
+              });
+          };
+          let context;
+          let continuation;
+          let activeStep;
+          let activeStepReported = false;
+          const history = [];
+          const call = async (readyContext, command, activeSignal) => {
+            const run = (overrides) => executeEvalChat({
+              agent: options.agent,
+              ...args.promptSnapshot ? { promptSnapshot: args.promptSnapshot } : {},
+              command,
+              continuation,
+              history: clone(history),
+              sessionId: attemptResult.sessionId,
+              clientTurnId: (0, import_node_crypto5.randomUUID)(),
+              signal: activeSignal,
+              ...item.workflowId ? { workflowId: item.workflowId } : {},
+              ...overrides
+            });
+            const execution = options.execute ? await options.execute({
+              ...readyContext,
+              signal: activeSignal,
+              command,
+              continuation,
+              history: clone(history),
+              run
+            }) : await run();
+            continuation = execution.continuation;
+            const observation = EvalObservationSchema.parse(
+              execution.observation
+            );
+            if (observation.type === "interrupt" && execution.continuation === void 0)
+              throw new Error(
+                "A waiting interrupt requires a private continuation."
+              );
+            return {
+              observation,
+              ...continuation !== void 0 ? { continuation } : {}
+            };
+          };
+          try {
             await emit({
-              type: "case-progress",
+              type: "case-started",
+              attemptId,
               caseId: item.id,
               repetition,
-              phase,
-              ...stepIndex !== void 0 ? { stepIndex } : {}
+              sessionId: attemptResult.sessionId
             });
-        };
-        let context;
-        let continuation;
-        let activeStep;
-        let activeStepReported = false;
-        const history = [];
-        const call = async (readyContext, command, activeSignal) => {
-          const run = (overrides) => executeEvalChat({
-            agent: options.agent,
-            command,
-            continuation,
-            history: clone(history),
-            sessionId: attemptResult.sessionId,
-            clientTurnId: (0, import_node_crypto5.randomUUID)(),
-            signal: activeSignal,
-            ...item.workflowId ? { workflowId: item.workflowId } : {},
-            ...overrides
-          });
-          const execution = options.execute ? await options.execute({
-            ...readyContext,
-            signal: activeSignal,
-            command,
-            continuation,
-            history: clone(history),
-            run
-          }) : await run();
-          continuation = execution.continuation;
-          const observation = EvalObservationSchema.parse(
-            execution.observation
-          );
-          if (observation.type === "interrupt" && execution.continuation === void 0)
-            throw new Error(
-              "A waiting interrupt requires a private continuation."
-            );
-          return {
-            observation,
-            ...continuation !== void 0 ? { continuation } : {}
-          };
-        };
-        try {
-          await emit({
-            type: "case-started",
-            caseId: item.id,
-            repetition,
-            sessionId: attemptResult.sessionId
-          });
-          signal.throwIfAborted();
-          await reportPhase("params");
-          const params = options.paramsSchema ? await options.paramsSchema.parseAsync(item.params) : item.params;
-          const base = {
-            suiteId: suite.id,
-            case: item,
-            repetition,
-            sessionId: attemptResult.sessionId,
-            params,
-            signal
-          };
-          await reportPhase("setup");
-          const prepared = options.setup ? await options.setup(base) : void 0;
-          context = { ...base, prepared };
-          signal.throwIfAborted();
-          for (const [index, step] of item.steps.entries()) {
-            stepIndex = index;
-            activeStep = void 0;
-            activeStepReported = false;
             signal.throwIfAborted();
-            let command;
-            if (step.message !== void 0)
-              command = { type: "message", message: step.message };
-            else {
-              await reportPhase("responder");
-              const interrupt = attemptResult.steps.at(-1)?.observation.interrupt;
-              let response = step.resume;
-              if (handlerRef(response)) {
-                const responder = responders[response.using];
-                if (typeof responder !== "function" && (responder.schemaId !== interrupt.schemaId || responder.schemaVersion && responder.schemaVersion !== interrupt.schemaVersion))
-                  throw new Error("Incompatible responder.");
-                response = await (typeof responder === "function" ? responder : responder.respond)({
-                  ...context,
-                  interrupt: clone(interrupt),
-                  ...response.params !== void 0 ? { args: response.params } : {}
-                });
-              }
-              command = {
-                type: "resume",
-                // z.json() is inferred as optional under the package's relaxed
-                // declaration build. Runtime validation still requires value.
-                response: EvalResumeResponseSchema.parse(
-                  response
-                )
-              };
-            }
-            signal.throwIfAborted();
-            await reportPhase("execute");
-            const { observation } = await call(context, command, signal);
-            const input = command.type === "message" ? { message: command.message } : { resume: command.response };
-            const evaluated = {
-              index,
-              input,
-              expectation: clone(step.expect),
-              observation,
-              status: "passed",
-              criteria: []
+            await reportPhase("params");
+            const params = options.paramsSchema ? await options.paramsSchema.parseAsync(item.params) : item.params;
+            const base = {
+              suiteId: suite.id,
+              case: item,
+              repetition,
+              sessionId: attemptResult.sessionId,
+              params,
+              signal
             };
-            attemptResult.steps.push(evaluated);
-            activeStep = evaluated;
+            await reportPhase("setup");
+            const prepared = options.setup ? await options.setup(base) : void 0;
+            context = { ...base, prepared };
             signal.throwIfAborted();
-            if (observation.type === "error") throw new Error("Agent failed.");
-            if (observation.type === "cancelled") {
-              evaluated.status = "cancelled";
-              attemptResult.status = "cancelled";
+            for (const [index, step] of item.steps.entries()) {
+              stepIndex = index;
+              activeStep = void 0;
+              activeStepReported = false;
+              signal.throwIfAborted();
+              let command;
+              if (step.message !== void 0)
+                command = { type: "message", message: step.message };
+              else {
+                await reportPhase("responder");
+                const interrupt = attemptResult.steps.at(-1)?.observation.interrupt;
+                let response = step.resume;
+                if (handlerRef(response)) {
+                  const responder = responders[response.using];
+                  if (typeof responder !== "function" && (responder.schemaId !== interrupt.schemaId || responder.schemaVersion && responder.schemaVersion !== interrupt.schemaVersion))
+                    throw new Error("Incompatible responder.");
+                  response = await (typeof responder === "function" ? responder : responder.respond)({
+                    ...context,
+                    interrupt: clone(interrupt),
+                    ...response.params !== void 0 ? { args: response.params } : {}
+                  });
+                }
+                command = {
+                  type: "resume",
+                  // z.json() is inferred as optional under the package's relaxed
+                  // declaration build. Runtime validation still requires value.
+                  response: EvalResumeResponseSchema.parse(
+                    response
+                  )
+                };
+              }
+              signal.throwIfAborted();
+              await reportPhase("execute");
+              const { observation } = await call(context, command, signal);
+              const input = command.type === "message" ? { message: command.message } : { resume: command.response };
+              const evaluated = {
+                index,
+                input,
+                expectation: clone(step.expect),
+                observation,
+                status: "passed",
+                criteria: []
+              };
+              attemptResult.steps.push(evaluated);
+              activeStep = evaluated;
+              signal.throwIfAborted();
+              if (observation.type === "error")
+                throw new Error("Agent failed.");
+              if (observation.type === "cancelled") {
+                evaluated.status = "cancelled";
+                attemptResult.status = "cancelled";
+                await emit({
+                  type: "step-completed",
+                  caseId: item.id,
+                  repetition,
+                  step: evaluated
+                });
+                activeStepReported = true;
+                break;
+              }
+              if (observation.type !== step.expect.type || step.expect.schemaId && step.expect.schemaId !== observation.interrupt?.schemaId || step.expect.schemaVersion && step.expect.schemaVersion !== observation.interrupt?.schemaVersion) {
+                evaluated.status = "failed";
+                evaluated.reason = "The observed interaction did not match the expected answer or interrupt contract.";
+              } else {
+                const outputReason = missingOutputReason(
+                  step.expect.outputs,
+                  observation
+                );
+                if (outputReason) {
+                  evaluated.status = "failed";
+                  evaluated.reason = outputReason;
+                } else {
+                  const reference = step.expect.reference;
+                  if (reference !== void 0) {
+                    await reportPhase("reference");
+                    evaluated.reference = handlerRef(reference) ? import_zod8.z.json().parse(
+                      await references[reference.using]({
+                        ...context,
+                        observation: clone(observation),
+                        ...reference.params !== void 0 ? { args: reference.params } : {}
+                      })
+                    ) : clone(reference);
+                  }
+                  await reportPhase("grading");
+                  evaluated.evidence = createEvalJudgeEvidence(
+                    observation,
+                    suite.evidence,
+                    evidenceFilters
+                  );
+                  if (studioGrading && step.expect.criteria?.length) {
+                    evaluated.status = "ungraded";
+                    attemptResult.status = "ungraded";
+                  }
+                  for (const [criterionIndex, value] of (studioGrading ? [] : step.expect.criteria ?? []).entries()) {
+                    signal.throwIfAborted();
+                    const criterion = typeof value === "string" ? { id: String(criterionIndex), text: value } : value;
+                    evaluated.judgeCalls = (evaluated.judgeCalls ?? 0) + 1;
+                    const verdict = EvalVerdictSchema.parse(
+                      await (0, import_eval_attribution2.withEvalAttribution)(
+                        void 0,
+                        () => options.judge.grade({
+                          criterion,
+                          onUsage: (usage2) => {
+                            if (!signal.aborted) {
+                              evaluated.judgeUsage ??= [];
+                              evaluated.judgeUsage.push(clone(usage2));
+                            }
+                          },
+                          input: clone(input),
+                          ...getEvalGradeEvidence(
+                            evaluated,
+                            attemptResult.steps.slice(0, -1)
+                          ),
+                          signal,
+                          ...evaluated.reference !== void 0 ? { reference: clone(evaluated.reference) } : {}
+                        })
+                      )
+                    );
+                    signal.throwIfAborted();
+                    evaluated.criteria.push({ ...criterion, ...verdict });
+                    if (!verdict.passed) evaluated.status = "failed";
+                  }
+                }
+              }
               await emit({
                 type: "step-completed",
                 caseId: item.id,
@@ -10917,161 +11918,116 @@ function createEvals(options) {
                 step: evaluated
               });
               activeStepReported = true;
-              break;
-            }
-            if (observation.type !== step.expect.type || step.expect.schemaId && step.expect.schemaId !== observation.interrupt?.schemaId || step.expect.schemaVersion && step.expect.schemaVersion !== observation.interrupt?.schemaVersion) {
-              evaluated.status = "failed";
-              evaluated.reason = "The observed interaction did not match the expected answer or interrupt contract.";
-            } else {
-              const outputReason = missingOutputReason(
-                step.expect.outputs,
-                observation
-              );
-              if (outputReason) {
-                evaluated.status = "failed";
-                evaluated.reason = outputReason;
-              } else {
-                const reference = step.expect.reference;
-                if (reference !== void 0) {
-                  await reportPhase("reference");
-                  evaluated.reference = handlerRef(reference) ? import_zod8.z.json().parse(
-                    await references[reference.using]({
-                      ...context,
-                      observation: clone(observation),
-                      ...reference.params !== void 0 ? { args: reference.params } : {}
-                    })
-                  ) : clone(reference);
-                }
-                await reportPhase("grading");
-                evaluated.evidence = createEvalJudgeEvidence(
-                  observation,
-                  suite.evidence,
-                  evidenceFilters
-                );
-                if (studioGrading && step.expect.criteria?.length) {
-                  evaluated.status = "ungraded";
-                  attemptResult.status = "ungraded";
-                }
-                for (const [criterionIndex, value] of (studioGrading ? [] : step.expect.criteria ?? []).entries()) {
-                  signal.throwIfAborted();
-                  const criterion = typeof value === "string" ? { id: String(criterionIndex), text: value } : value;
-                  evaluated.judgeCalls = (evaluated.judgeCalls ?? 0) + 1;
-                  const verdict = EvalVerdictSchema.parse(
-                    await options.judge.grade({
-                      criterion,
-                      onUsage: (usage) => {
-                        if (!signal.aborted) {
-                          evaluated.judgeUsage ??= [];
-                          evaluated.judgeUsage.push(clone(usage));
-                        }
-                      },
-                      input: clone(input),
-                      ...getEvalGradeEvidence(
-                        evaluated,
-                        attemptResult.steps.slice(0, -1)
-                      ),
-                      signal,
-                      ...evaluated.reference !== void 0 ? { reference: clone(evaluated.reference) } : {}
-                    })
-                  );
-                  signal.throwIfAborted();
-                  evaluated.criteria.push({ ...criterion, ...verdict });
-                  if (!verdict.passed) evaluated.status = "failed";
-                }
+              if (evaluated.status === "failed") {
+                attemptResult.status = "failed";
+                break;
               }
+              history.push(
+                {
+                  role: "user",
+                  content: command.type === "message" ? command.message : JSON.stringify(command.response)
+                },
+                { role: "assistant", content: observation.text }
+              );
             }
-            await emit({
-              type: "step-completed",
-              caseId: item.id,
-              repetition,
-              step: evaluated
-            });
-            activeStepReported = true;
-            if (evaluated.status === "failed") {
-              attemptResult.status = "failed";
-              break;
+          } catch {
+            if (signal.aborted) {
+              attemptResult.status = timedOut ? "error" : "cancelled";
+              if (timedOut)
+                attemptResult.errors.push({
+                  phase,
+                  code: "EVAL_TIMEOUT",
+                  message: "Case exceeded its configured time limit."
+                });
+            } else {
+              attemptResult.status = "error";
+              attemptResult.errors.push(failure(phase));
             }
-            history.push(
-              {
-                role: "user",
-                content: command.type === "message" ? command.message : JSON.stringify(command.response)
-              },
-              { role: "assistant", content: observation.text }
-            );
-          }
-        } catch {
-          if (signal.aborted) {
-            attemptResult.status = timedOut ? "error" : "cancelled";
-            if (timedOut)
-              attemptResult.errors.push({
-                phase,
-                code: "EVAL_TIMEOUT",
-                message: "Case exceeded its configured time limit."
+            if (activeStep && !activeStepReported) {
+              activeStep.status = attemptResult.status;
+              activeStep.reason = attemptResult.errors.at(-1)?.message ?? "Case was cancelled.";
+              await emit({
+                type: "step-completed",
+                caseId: item.id,
+                repetition,
+                step: activeStep
               });
-          } else {
-            attemptResult.status = "error";
-            attemptResult.errors.push(failure(phase));
-          }
-          if (activeStep && !activeStepReported) {
-            activeStep.status = attemptResult.status;
-            activeStep.reason = attemptResult.errors.at(-1)?.message ?? "Case was cancelled.";
-            await emit({
-              type: "step-completed",
-              caseId: item.id,
-              repetition,
-              step: activeStep
-            });
-          }
-        } finally {
-          clearTimeout(timer);
-          if (context) {
-            await reportPhase("cleanup");
-            const cleanup = new AbortController();
-            const cleanupTimer = setTimeout(
-              () => cleanup.abort(),
-              defaults.cleanupTimeoutMs
-            );
-            try {
-              if (continuation !== void 0) {
-                try {
-                  const cancelled = await call(
-                    context,
-                    { type: "cancel" },
-                    cleanup.signal
-                  );
-                  if (cancelled.observation.type === "error" || cancelled.continuation !== void 0)
+            }
+          } finally {
+            clearTimeout(timer);
+            if (context) {
+              await reportPhase("cleanup");
+              const cleanup = new AbortController();
+              const cleanupTimer = setTimeout(
+                () => cleanup.abort(),
+                defaults.cleanupTimeoutMs
+              );
+              try {
+                if (continuation !== void 0) {
+                  try {
+                    const cancelled = await call(
+                      context,
+                      { type: "cancel" },
+                      cleanup.signal
+                    );
+                    if (cancelled.observation.type === "error" || cancelled.continuation !== void 0)
+                      attemptResult.errors.push(
+                        failure("cleanup", "EVAL_INTERRUPT_CLEANUP_FAILED")
+                      );
+                    cleanup.signal.throwIfAborted();
+                  } catch {
                     attemptResult.errors.push(
                       failure("cleanup", "EVAL_INTERRUPT_CLEANUP_FAILED")
                     );
+                  }
+                }
+                try {
+                  await options.teardown?.({
+                    ...context,
+                    signal: cleanup.signal,
+                    result: clone(attemptResult)
+                  });
                   cleanup.signal.throwIfAborted();
                 } catch {
-                  attemptResult.errors.push(
-                    failure("cleanup", "EVAL_INTERRUPT_CLEANUP_FAILED")
-                  );
+                  attemptResult.errors.push(failure("cleanup"));
                 }
+              } finally {
+                clearTimeout(cleanupTimer);
               }
-              try {
-                await options.teardown?.({
-                  ...context,
-                  signal: cleanup.signal,
-                  result: clone(attemptResult)
-                });
-                cleanup.signal.throwIfAborted();
-              } catch {
-                attemptResult.errors.push(failure("cleanup"));
-              }
-            } finally {
-              clearTimeout(cleanupTimer);
+              if (attemptResult.errors.some((error) => error.phase === "cleanup"))
+                attemptResult.status = "error";
             }
-            if (attemptResult.errors.some((error) => error.phase === "cleanup"))
-              attemptResult.status = "error";
+            attemptResult.durationMs = Date.now() - started;
           }
-          attemptResult.durationMs = Date.now() - started;
-        }
-        await emit({ type: "case-completed", result: attemptResult });
-        return attemptResult;
+          acceptingExecutions = false;
+          await associationProgress;
+          await emit({ type: "case-completed", result: attemptResult });
+          return attemptResult;
+        };
+        return (0, import_eval_attribution2.withEvalAttribution)(
+          {
+            attemptId,
+            onExecution: (execution) => {
+              if (!acceptingExecutions || runtimeExecutions.some(
+                (entry) => entry.runId === execution.runId && entry.sessionId === execution.sessionId
+              ))
+                return;
+              runtimeExecutions.push(execution);
+              associationProgress = associationProgress.then(
+                () => emit({
+                  type: "case-runtime-associated",
+                  caseId: item.id,
+                  repetition,
+                  attemptId,
+                  execution
+                })
+              );
+            }
+          },
+          executeAttempt
+        );
       };
-      const total = selected.length * repetitions;
+      const total = args.attempt ? 1 : selected.length * repetitions;
       if (args.includeActivity)
         await emit({
           type: "run-started",
@@ -11085,8 +12041,11 @@ function createEvals(options) {
         Array.from({ length: Math.min(concurrency, total) }, async () => {
           while (cursor < total) {
             const index = cursor++;
-            const item = selected[Math.floor(index / repetitions)];
-            completed[index] = await attempt(item, index % repetitions + 1);
+            const item = args.attempt ? selected.find((item2) => item2.id === args.attempt?.caseId) : selected[Math.floor(index / repetitions)];
+            completed[index] = await attempt(
+              item,
+              args.attempt?.repetition ?? index % repetitions + 1
+            );
           }
         })
       );
@@ -11095,6 +12054,9 @@ function createEvals(options) {
         result.counts[item.status] = (result.counts[item.status] ?? 0) + 1;
       result.status = statusFor(result.counts, result.errors);
       result.durationMs = Date.now() - start;
+      evalUsage.end(
+        result.status === "passed" ? "success" : result.status === "failed" ? "quality_failed" : result.status === "error" ? "failed" : result.status
+      );
       return result;
     }
   };
@@ -11109,6 +12071,7 @@ function defineSuite(suite) {
 var import_zod10 = require("zod");
 
 // src/evals/studio-contracts.ts
+var import_browser3 = require("@kortyx/prompts/browser");
 var import_zod9 = require("zod");
 var StudioEvalTargetsResponseSchema = import_zod9.z.object({
   canRun: import_zod9.z.boolean(),
@@ -11194,7 +12157,9 @@ var StudioEvalDetailSchema = import_zod9.z.object({
       grading: import_zod9.z.enum(["app", "studio"]).optional(),
       judge: EvalJudgeIdentitySchema.optional(),
       repetitions: import_zod9.z.number().int().positive(),
-      concurrency: import_zod9.z.number().optional()
+      concurrency: import_zod9.z.number().optional(),
+      promptSnapshot: import_browser3.PromptSnapshotSchema.optional(),
+      promptGroupName: import_zod9.z.string().optional()
     }).optional(),
     suite: EvalSuiteSchema,
     result: EvalRunResultSchema.nullable(),
@@ -11218,6 +12183,7 @@ var EvaluationMetadataSchema = import_zod10.z.object({
 var StudioEvaluationStartRequestSchema = import_zod10.z.object({
   targetId: import_zod10.z.string().trim().min(1),
   name: import_zod10.z.string().trim().min(1).max(200).optional(),
+  promptSelection: StudioEvalStartRequestSchema.shape.promptSelection,
   selection: import_zod10.z.enum(["all", "selected"]),
   suites: import_zod10.z.array(
     import_zod10.z.object({
@@ -11340,7 +12306,7 @@ function createEvalJudge({
           "inputIncludesCacheRead",
           "inputIncludesCacheWrite"
         ];
-        const usage = result.usage && Object.fromEntries(
+        const usage2 = result.usage && Object.fromEntries(
           Object.entries(result.usage).filter(
             ([key, value]) => numericKeys.includes(key) ? typeof value === "number" && Number.isFinite(value) && value >= 0 : booleanKeys.includes(key) && typeof value === "boolean"
           )
@@ -11357,7 +12323,7 @@ function createEvalJudge({
           provider: model.provider.id,
           model: model.modelId,
           occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
-          ...usage ? { usage } : {},
+          ...usage2 ? { usage: usage2 } : {},
           ...pricingContext && Object.keys(pricingContext).length ? { pricingContext } : {},
           ...model.provider.id === "openrouter" && typeof cost === "number" && Number.isFinite(cost) && cost >= 0 && Number.isSafeInteger(Math.round(cost * 1e6)) ? {
             pricing: {
@@ -11379,6 +12345,7 @@ function createEvalJudge({
 
 // src/evals/route-handler.ts
 var import_node_crypto6 = require("crypto");
+var import_prompts2 = require("@kortyx/prompts");
 function createEvalRouteHandler({
   evals,
   serviceKey,
@@ -11396,6 +12363,7 @@ function createEvalRouteHandler({
   const digest = (value) => (0, import_node_crypto6.createHash)("sha256").update(value).digest();
   const expected = digest(`Bearer ${serviceKey}`);
   let active = 0;
+  const evaluations = /* @__PURE__ */ new Map();
   return async (request) => {
     if (!(0, import_node_crypto6.timingSafeEqual)(
       expected,
@@ -11417,7 +12385,7 @@ function createEvalRouteHandler({
     let body;
     try {
       const text = await request.text();
-      if (text.length > 16384)
+      if (text.length > 1048576)
         return Response.json({ error: "Request too large." }, { status: 413 });
       body = EvalRemoteRunRequestSchema.parse(JSON.parse(text));
     } catch {
@@ -11427,6 +12395,28 @@ function createEvalRouteHandler({
       );
     }
     const suite = manifest.suites.find((item) => item.id === body.suiteId);
+    if (body.promptSnapshot) {
+      try {
+        const snapshot = await (0, import_prompts2.verifyPromptSnapshot)(body.promptSnapshot);
+        if (snapshot.source !== "eval" || !manifest.promptContracts?.length)
+          throw new Error("Unsupported prompt evaluation.");
+        for (const contract of manifest.promptContracts) {
+          const version = snapshot.versions[contract.id];
+          if (!version || version.content.format !== contract.format)
+            throw new Error("Prompt contract mismatch.");
+          (0, import_prompts2.validatePromptValue)(
+            contract.configSchema,
+            version.content.config,
+            "Application configuration"
+          );
+        }
+      } catch {
+        return Response.json(
+          { error: "Prompt snapshot does not match the application contract." },
+          { status: 409 }
+        );
+      }
+    }
     if (!suite || body.caseIds?.some((id3) => !suite.cases.some((item) => item.id === id3)) || body.caseIds && new Set(body.caseIds).size !== body.caseIds.length)
       return Response.json(
         { error: "Unknown suite or case selection." },
@@ -11452,14 +12442,32 @@ function createEvalRouteHandler({
         { error: "App judge changed. Refresh before running." },
         { status: 409 }
       );
-    if (active >= maxActiveRuns)
+    if (body.attempt && (!manifest.attemptScheduling || !suite.cases.some((item) => item.id === body.attempt?.caseId) || body.caseIds && !body.caseIds.includes(body.attempt.caseId) || body.attempt.repetition > body.repetitions))
+      return Response.json(
+        { error: "Unsupported or invalid scheduled attempt." },
+        { status: 409 }
+      );
+    const group = body.attempt && evaluations.get(body.attempt.evaluationId);
+    if (group && (group.concurrency !== body.concurrency || group.active >= group.concurrency))
+      return Response.json(
+        { error: "Evaluation concurrency exhausted or changed." },
+        { status: 429 }
+      );
+    if (!group && active >= maxActiveRuns)
       return Response.json(
         { error: "Eval executor is busy." },
         { status: 429 }
       );
     if (request.signal.aborted)
       return Response.json({ error: "Request cancelled." }, { status: 409 });
-    active++;
+    if (body.attempt) {
+      const state = group ?? { active: 0, concurrency: body.concurrency };
+      if (!group) {
+        active++;
+        evaluations.set(body.attempt.evaluationId, state);
+      }
+      state.active++;
+    } else active++;
     const controller = new AbortController();
     const requestSignal = request.signal;
     const abortRequest = () => controller.abort();
@@ -11475,6 +12483,8 @@ function createEvalRouteHandler({
         };
         void evals.run({
           suiteId: body.suiteId,
+          ...body.promptSnapshot ? { promptSnapshot: body.promptSnapshot } : {},
+          ...body.attempt ? { attempt: body.attempt } : {},
           ...body.grading ? { grading: body.grading } : {},
           ...body.judge ? { judgeIdentity: body.judge } : {},
           repetitions: body.repetitions,
@@ -11487,7 +12497,14 @@ function createEvalRouteHandler({
           () => send({ type: "error", message: "Eval runner failed." })
         ).finally(() => {
           requestSignal.removeEventListener("abort", abortRequest);
-          active--;
+          if (body.attempt) {
+            const state = evaluations.get(body.attempt.evaluationId);
+            state.active--;
+            if (!state.active) {
+              evaluations.delete(body.attempt.evaluationId);
+              active--;
+            }
+          } else active--;
           if (!controller.signal.aborted) output.close();
         });
       },
@@ -11607,7 +12624,7 @@ async function createStudioEvalJudge(options) {
         throw new Error(
           "Studio judge identity changed. Refresh before running."
         );
-      for (const usage of response.usage ?? []) input.onUsage?.(usage);
+      for (const usage2 of response.usage ?? []) input.onUsage?.(usage2);
       return response.verdict;
     }
   };