@kortyx/agent 0.38.1 → 0.39.0

package/dist/index.js

@@ -29,1602 +29,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../telemetry-contracts/dist/index.js
-var require_dist = __commonJS({
-  "../telemetry-contracts/dist/index.js"(exports2, module2) {
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-    var __export2 = (target, all) => {
-      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") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
-      }
-      return to;
-    };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
-    var index_exports2 = {};
-    __export2(index_exports2, {
-      ClearScoreResponseSchema: () => ClearScoreResponseSchema,
-      ClearUserFeedbackRequestSchema: () => ClearUserFeedbackRequestSchema,
-      DIAGNOSTIC_LIMITS: () => DIAGNOSTIC_LIMITS,
-      DiagnosticContentSchema: () => DiagnosticContentSchema,
-      DiagnosticCorrelationSchema: () => DiagnosticCorrelationSchema,
-      DiagnosticManifestSchema: () => DiagnosticManifestSchema,
-      DiagnosticNoteSchema: () => DiagnosticNoteSchema,
-      DiagnosticPartSchema: () => DiagnosticPartSchema,
-      DiagnosticResponseSchema: () => DiagnosticResponseSchema,
-      EnsureWorkflowTopologyRequestSchema: () => EnsureWorkflowTopologyRequestSchema,
-      EnsureWorkflowTopologyResponseSchema: () => EnsureWorkflowTopologyResponseSchema,
-      FEEDBACK_FILTERS: () => FEEDBACK_FILTERS,
-      FeedbackReasonSchema: () => FeedbackReasonSchema,
-      FeedbackSummarySchema: () => FeedbackSummarySchema,
-      PromptAssetSchema: () => PromptAssetSchema,
-      PromptAssignmentSchema: () => PromptAssignmentSchema,
-      PromptBundleSchema: () => PromptBundleSchema,
-      PromptCategorySchema: () => PromptCategorySchema,
-      PromptDetailSchema: () => PromptDetailSchema,
-      PromptEvidenceSchema: () => PromptEvidenceSchema,
-      PromptGroupSchema: () => PromptGroupSchema,
-      PromptLibrarySchema: () => PromptLibrarySchema,
-      PromptMutationSchema: () => PromptMutationSchema,
-      PromptPolicySchema: () => PromptPolicySchema,
-      PromptSelectionSchema: () => PromptSelectionSchema,
-      PromptStoredVersionSchema: () => PromptStoredVersionSchema,
-      PromptTransferRequestSchema: () => PromptTransferRequestSchema,
-      PromptUsageSchema: () => PromptUsageSchema,
-      ReviewVerdictSchema: () => ReviewVerdictSchema,
-      STUDIO_API_PROTOCOL_VERSION: () => STUDIO_API_PROTOCOL_VERSION,
-      STUDIO_TIME_RANGES: () => STUDIO_TIME_RANGES,
-      StudioCatalogsResponseSchema: () => StudioCatalogsResponseSchema,
-      StudioChangeResourceSchema: () => StudioChangeResourceSchema,
-      StudioChangeSchema: () => StudioChangeSchema,
-      StudioContextResponseSchema: () => StudioContextResponseSchema,
-      StudioCostSummarySchema: () => StudioCostSummarySchema,
-      StudioDetailEventSchema: () => StudioDetailEventSchema,
-      StudioInterruptDetailResponseSchema: () => StudioInterruptDetailResponseSchema,
-      StudioInterruptInteractionModeSchema: () => StudioInterruptInteractionModeSchema,
-      StudioInterruptOptionSchema: () => StudioInterruptOptionSchema,
-      StudioInterruptSchema: () => StudioInterruptSchema,
-      StudioInterruptStatusSchema: () => StudioInterruptStatusSchema,
-      StudioInterruptTypeSchema: () => StudioInterruptTypeSchema,
-      StudioInterruptValueSchema: () => StudioInterruptValueSchema,
-      StudioInterruptsResponseSchema: () => StudioInterruptsResponseSchema,
-      StudioMetricSchema: () => StudioMetricSchema,
-      StudioPricingSourceSchema: () => StudioPricingSourceSchema,
-      StudioPricingStatusSchema: () => StudioPricingStatusSchema,
-      StudioReleaseDeploymentSchema: () => StudioReleaseDeploymentSchema,
-      StudioReleaseSchema: () => StudioReleaseSchema,
-      StudioReleaseVersionSchema: () => StudioReleaseVersionSchema,
-      StudioResumeOutcomeSchema: () => StudioResumeOutcomeSchema,
-      StudioReviewRequestSchema: () => StudioReviewRequestSchema,
-      StudioRunDetailResponseSchema: () => StudioRunDetailResponseSchema,
-      StudioRunSchema: () => StudioRunSchema,
-      StudioRunStatusSchema: () => StudioRunStatusSchema,
-      StudioRunsResponseSchema: () => StudioRunsResponseSchema,
-      StudioScoreResponseSchema: () => StudioScoreResponseSchema,
-      StudioScoreSchema: () => StudioScoreSchema,
-      StudioSessionDetailResponseSchema: () => StudioSessionDetailResponseSchema,
-      StudioSessionSchema: () => StudioSessionSchema,
-      StudioSessionsResponseSchema: () => StudioSessionsResponseSchema,
-      StudioTimeRangeContextSchema: () => StudioTimeRangeContextSchema,
-      StudioTimeRangeQuerySchema: () => StudioTimeRangeQuerySchema,
-      StudioTimeRangeSchema: () => StudioTimeRangeSchema,
-      StudioToolSchema: () => StudioToolSchema,
-      StudioUpdateOperationSchema: () => StudioUpdateOperationSchema,
-      StudioUpdateSettingsSchema: () => StudioUpdateSettingsSchema,
-      StudioUpdateStatusSchema: () => StudioUpdateStatusSchema,
-      StudioWorkflowHealthSchema: () => StudioWorkflowHealthSchema,
-      StudioWorkflowInternalEdgeSchema: () => StudioWorkflowInternalEdgeSchema,
-      StudioWorkflowNodeSchema: () => StudioWorkflowNodeSchema,
-      StudioWorkflowSchema: () => StudioWorkflowSchema,
-      StudioWorkflowTransitionSchema: () => StudioWorkflowTransitionSchema,
-      StudioWorkflowsResponseSchema: () => StudioWorkflowsResponseSchema,
-      TELEMETRY_EVENT_TYPES: () => TELEMETRY_EVENT_TYPES,
-      TelemetryEventBatchResponseSchema: () => TelemetryEventBatchResponseSchema,
-      TelemetryEventBatchSchema: () => TelemetryEventBatchSchema,
-      TelemetryEventSchema: () => TelemetryEventSchema,
-      TelemetryEventTypeSchema: () => TelemetryEventTypeSchema,
-      TelemetryPricingHintSchema: () => TelemetryPricingHintSchema,
-      TelemetryPricingLineItemSchema: () => TelemetryPricingLineItemSchema,
-      TelemetryPricingSourceSchema: () => TelemetryPricingSourceSchema,
-      TelemetryPricingUnitSchema: () => TelemetryPricingUnitSchema,
-      TelemetryPricingUsageTypeSchema: () => TelemetryPricingUsageTypeSchema,
-      TelemetryServiceSchema: () => TelemetryServiceSchema,
-      TelemetryUnitPriceSchema: () => TelemetryUnitPriceSchema,
-      TelemetryUsageItemSchema: () => TelemetryUsageItemSchema,
-      ToolDiscoverySchema: () => ToolDiscoverySchema,
-      ToolObservationSchema: () => ToolObservationSchema,
-      ToolOutcomeSchema: () => ToolOutcomeSchema,
-      UserFeedbackRequestSchema: () => UserFeedbackRequestSchema,
-      WorkflowToolSchema: () => WorkflowToolSchema,
-      WorkflowTopologyCallSchema: () => WorkflowTopologyCallSchema,
-      WorkflowTopologyEdgeSchema: () => WorkflowTopologyEdgeSchema,
-      WorkflowTopologyNodeSchema: () => WorkflowTopologyNodeSchema,
-      WorkflowTopologyTransitionSchema: () => WorkflowTopologyTransitionSchema,
-      isPrivateDiagnosticField: () => isPrivateDiagnosticField,
-      newerStudioVersion: () => newerStudioVersion,
-      projectWorkflowCalls: () => projectWorkflowCalls,
-      redactDiagnosticContent: () => redactDiagnosticContent,
-      redactDiagnosticText: () => redactDiagnosticText,
-      resolveStudioInterruptStatus: () => resolveStudioInterruptStatus,
-      resolveStudioTimeRange: () => resolveStudioTimeRange,
-      studioUpdateRunning: () => studioUpdateRunning,
-      summarizeDiagnostic: () => summarizeDiagnostic2,
-      summarizeUserFeedback: () => summarizeUserFeedback
-    });
-    module2.exports = __toCommonJS2(index_exports2);
-    var import_zod62 = require("zod");
-    var import_zod14 = require("zod");
-    var FEEDBACK_FILTERS = ["positive", "negative", "unrated"];
-    var FeedbackSummarySchema = import_zod14.z.object({
-      positive: import_zod14.z.number().int().nonnegative(),
-      negative: import_zod14.z.number().int().nonnegative()
-    }).strict();
-    var FeedbackReasonSchema = import_zod14.z.enum([
-      "incorrect",
-      "irrelevant",
-      "incomplete",
-      "unsafe",
-      "other"
-    ]);
-    var ReviewVerdictSchema = import_zod14.z.enum([
-      "correct",
-      "partially-correct",
-      "incorrect"
-    ]);
-    var runId = import_zod14.z.string().trim().min(1).max(512);
-    var actorId = import_zod14.z.string().trim().min(1).max(256);
-    var comment = import_zod14.z.string().trim().max(4e3).nullable().optional();
-    var UserFeedbackRequestSchema = import_zod14.z.object({
-      runId,
-      actorId,
-      value: import_zod14.z.union([import_zod14.z.literal(0), import_zod14.z.literal(1)]),
-      reasons: import_zod14.z.array(FeedbackReasonSchema).max(5).optional(),
-      comment
-    }).strict();
-    var ClearUserFeedbackRequestSchema = UserFeedbackRequestSchema.pick({
-      runId: true,
-      actorId: true
-    });
-    var StudioReviewRequestSchema = import_zod14.z.object({ value: ReviewVerdictSchema, comment }).strict();
-    var BaseScoreSchema = import_zod14.z.object({
-      id: import_zod14.z.string().uuid(),
-      target: import_zod14.z.object({ type: import_zod14.z.literal("run"), runId }).strict(),
-      environment: import_zod14.z.string().min(1),
-      name: import_zod14.z.string().min(1),
-      source: import_zod14.z.enum(["end-user", "human-review", "evaluator"]),
-      actorId,
-      reasons: import_zod14.z.array(FeedbackReasonSchema),
-      comment: import_zod14.z.string().nullable(),
-      createdAt: import_zod14.z.string().datetime({ offset: true }),
-      updatedAt: import_zod14.z.string().datetime({ offset: true })
-    }).strict();
-    var StudioScoreSchema = import_zod14.z.discriminatedUnion("dataType", [
-      BaseScoreSchema.extend({
-        dataType: import_zod14.z.literal("BOOLEAN"),
-        value: import_zod14.z.union([import_zod14.z.literal(0), import_zod14.z.literal(1)])
-      }),
-      BaseScoreSchema.extend({
-        dataType: import_zod14.z.literal("CATEGORICAL"),
-        value: import_zod14.z.string()
-      }),
-      BaseScoreSchema.extend({
-        dataType: import_zod14.z.literal("NUMERIC"),
-        value: import_zod14.z.number().finite()
-      })
-    ]);
-    var StudioScoreResponseSchema = import_zod14.z.object({ score: StudioScoreSchema }).strict();
-    var ClearScoreResponseSchema = import_zod14.z.object({ ok: import_zod14.z.literal(true) }).strict();
-    function summarizeUserFeedback(scores) {
-      const feedback = { positive: 0, negative: 0 };
-      for (const score of scores) {
-        if (score.source !== "end-user" || score.name !== "user-feedback" || score.dataType !== "BOOLEAN")
-          continue;
-        if (score.value === 1) feedback.positive += 1;
-        if (score.value === 0) feedback.negative += 1;
-      }
-      return feedback;
-    }
-    var import_zod22 = require("zod");
-    var DIAGNOSTIC_LIMITS = {
-      bytes: 8 * 1024 * 1024,
-      partBytes: 64 * 1024,
-      parts: 128,
-      nodes: 1e4,
-      depth: 128,
-      properties: 1e3
-    };
-    var DiagnosticNoteSchema = import_zod22.z.object({
-      path: import_zod22.z.string().max(4096),
-      reason: import_zod22.z.string().max(128),
-      originalBytes: import_zod22.z.number().int().nonnegative().optional(),
-      originalCount: import_zod22.z.number().int().nonnegative().optional()
-    }).strict();
-    var DiagnosticContentSchema = import_zod22.z.object({
-      schemaVersion: import_zod22.z.literal(1),
-      data: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.unknown()),
-      capture: import_zod22.z.object({
-        status: import_zod22.z.enum(["complete", "partial", "failed"]),
-        omissions: import_zod22.z.array(DiagnosticNoteSchema).max(1e4),
-        redactions: import_zod22.z.array(DiagnosticNoteSchema).max(1e4)
-      }).strict()
-    }).strict();
-    var DiagnosticCorrelationSchema = import_zod22.z.object({
-      runId: import_zod22.z.string().optional(),
-      workflowId: import_zod22.z.string().optional(),
-      nodeId: import_zod22.z.string().optional(),
-      sessionId: import_zod22.z.string().optional(),
-      invocationId: import_zod22.z.string().optional(),
-      parentInvocationId: import_zod22.z.string().optional(),
-      branchId: import_zod22.z.string().optional(),
-      toolCallId: import_zod22.z.string().optional(),
-      attemptId: import_zod22.z.string().optional(),
-      workflowRevisionId: import_zod22.z.string().optional(),
-      traceId: import_zod22.z.string().optional(),
-      spanId: import_zod22.z.string().optional(),
-      parentSpanId: import_zod22.z.string().optional()
-    }).strict();
-    var DiagnosticManifestSchema = import_zod22.z.object({
-      schemaVersion: import_zod22.z.literal(1),
-      diagnosticId: import_zod22.z.string().uuid(),
-      occurrenceId: import_zod22.z.string().uuid(),
-      occurredAt: import_zod22.z.string().datetime({ offset: true }),
-      environment: import_zod22.z.string().min(1).max(256),
-      service: import_zod22.z.object({
-        name: import_zod22.z.string().min(1).max(256),
-        deploymentRef: import_zod22.z.string().max(1024).optional()
-      }).strict(),
-      correlation: DiagnosticCorrelationSchema,
-      handled: import_zod22.z.boolean(),
-      severity: import_zod22.z.enum(["warning", "error"]),
-      mechanism: import_zod22.z.enum(["span", "report", "tool"]),
-      summary: import_zod22.z.object({ type: import_zod22.z.string().max(256), message: import_zod22.z.string().max(8192) }).strict(),
-      captureStatus: import_zod22.z.enum(["complete", "partial", "failed"]),
-      checksum: import_zod22.z.string().regex(/^[a-f0-9]{64}$/),
-      byteLength: import_zod22.z.number().int().min(1).max(DIAGNOSTIC_LIMITS.bytes),
-      partCount: import_zod22.z.number().int().min(1).max(DIAGNOSTIC_LIMITS.parts)
-    }).strict().superRefine((value, ctx) => {
-      if (value.partCount !== Math.ceil(value.byteLength / DIAGNOSTIC_LIMITS.partBytes))
-        ctx.addIssue({
-          code: "custom",
-          path: ["partCount"],
-          message: "Part count does not match byte length."
-        });
-    });
-    var DiagnosticPartSchema = import_zod22.z.object({
-      index: import_zod22.z.number().int().min(0).max(DIAGNOSTIC_LIMITS.parts - 1),
-      data: import_zod22.z.string().max(Math.ceil(DIAGNOSTIC_LIMITS.partBytes / 3) * 4).regex(
-        /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/
-      )
-    }).strict();
-    var DiagnosticResponseSchema = import_zod22.z.object({
-      manifest: DiagnosticManifestSchema,
-      state: import_zod22.z.enum(["pending", "available", "incomplete", "expired"]),
-      receivedParts: import_zod22.z.number().int().nonnegative(),
-      expiresAt: import_zod22.z.string().datetime({ offset: true }),
-      content: DiagnosticContentSchema.nullable(),
-      contentChecksum: import_zod22.z.string().regex(/^[a-f0-9]{64}$/).nullable(),
-      contentByteLength: import_zod22.z.number().int().nonnegative().nullable()
-    }).strict();
-    var isPrivateDiagnosticField = (key) => /^(?:password|passwd|secret|clientsecret|privatekey|credential|credentials|authorization|proxyauthorization|bearer|bearertoken|jwt|token|accesstoken|refreshtoken|authtoken|apikey|xapikey|apitoken|xauthtoken|xaccesstoken|awsaccesskeyid|awssecretaccesskey|awssessiontoken|xamzsecuritytoken|apisecret|cookie|setcookie|resumehandle|resumetoken)$/.test(
-      key.toLowerCase().replace(/[^a-z0-9]/g, "")
-    );
-    function redactDiagnosticText(value) {
-      return value.replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, "Bearer [REDACTED]").replace(
-        /\b(?:ktyx_(?:test|live)_[^\s"'<>]+|sk-(?:proj-|ant-)?[A-Za-z0-9_-]{12,}|AIza[A-Za-z0-9_-]{20,}|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)/g,
-        "[REDACTED]"
-      ).replace(
-        /(["']?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|password|passwd|secret|token|client[_-]?secret|authorization|cookie)["']?\s*[:=]\s*)(["'])(.*?)\2/gi,
-        "$1$2[REDACTED]$2"
-      ).replace(
-        /(\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|password|passwd|secret|token|client[_-]?secret)\s*[:=]\s*)(?!["'[])[^\s,;}&]+/gi,
-        "$1[REDACTED]"
-      ).replace(
-        /(\b(?:authorization|proxy-authorization)\s*:\s*Basic\s+)[A-Za-z0-9+/=]+/gi,
-        "$1[REDACTED]"
-      ).replace(
-        /([?&](?:api[_-]?key|token|access[_-]?token|password)=)[^&#\s]+/gi,
-        "$1[REDACTED]"
-      ).replace(/(https?:\/\/)[^\s/@:]+:[^\s/@]+@/gi, "$1[REDACTED]@");
-    }
-    function summarizeDiagnostic2(data, depth = 0) {
-      return {
-        type: typeof data.type === "string" ? data.type.slice(0, 256) : "Error",
-        message: typeof data.message === "string" ? data.message.slice(0, 8192) : "Execution reported a fault.",
-        ...typeof data.stack === "string" ? { stack: data.stack.slice(0, 32768) } : {},
-        ...depth < 4 && data.cause && typeof data.cause === "object" && !Array.isArray(data.cause) ? {
-          cause: summarizeDiagnostic2(
-            data.cause,
-            depth + 1
-          )
-        } : {}
-      };
-    }
-    function redactDiagnosticContent(content) {
-      const redactions = [...content.capture.redactions];
-      const omissions = [...content.capture.omissions];
-      let nodes = 0;
-      const visit = (value, path, depth = 0) => {
-        if (++nodes > DIAGNOSTIC_LIMITS.nodes || depth > DIAGNOSTIC_LIMITS.depth) {
-          const reason = depth > DIAGNOSTIC_LIMITS.depth ? "server_depth_limit" : "server_node_limit";
-          if (omissions.length < 1e4)
-            omissions.push({ path: path.slice(0, 4096), reason });
-          return { $omitted: reason };
-        }
-        if (typeof value === "string") {
-          const clean = redactDiagnosticText(value);
-          if (clean !== value && redactions.length < 1e4)
-            redactions.push({
-              path: path.slice(0, 4096),
-              reason: "server_credential_text"
-            });
-          return clean;
-        }
-        if (Array.isArray(value)) {
-          if (value.length > DIAGNOSTIC_LIMITS.properties && omissions.length < 1e4)
-            omissions.push({
-              path: path.slice(0, 4096),
-              reason: "server_collection_limit",
-              originalCount: value.length
-            });
-          return value.slice(0, DIAGNOSTIC_LIMITS.properties).map((item, index) => visit(item, `${path}/${index}`, depth + 1));
-        }
-        if (value && typeof value === "object") {
-          const keys = Object.keys(value);
-          if (keys.length > DIAGNOSTIC_LIMITS.properties && omissions.length < 1e4)
-            omissions.push({
-              path: path.slice(0, 4096),
-              reason: "server_property_limit",
-              originalCount: keys.length
-            });
-          return Object.fromEntries(
-            keys.slice(0, DIAGNOSTIC_LIMITS.properties).map((key) => {
-              const nested = value[key];
-              if (isPrivateDiagnosticField(key)) {
-                if (redactions.length < 1e4 && nested !== "[REDACTED]")
-                  redactions.push({
-                    path: `${path}/${key}`.slice(0, 4096),
-                    reason: "server_credential_field"
-                  });
-                return [key, "[REDACTED]"];
-              }
-              return [key, visit(nested, `${path}/${key}`, depth + 1)];
-            })
-          );
-        }
-        return value;
-      };
-      return {
-        ...content,
-        data: visit(content.data, "#/data"),
-        capture: {
-          ...content.capture,
-          status: content.capture.status === "failed" ? "failed" : omissions.length ? "partial" : "complete",
-          omissions: omissions.map((note) => ({
-            ...note,
-            path: redactDiagnosticText(note.path),
-            reason: redactDiagnosticText(note.reason)
-          })),
-          redactions: redactions.map((note) => ({
-            ...note,
-            path: redactDiagnosticText(note.path),
-            reason: redactDiagnosticText(note.reason)
-          }))
-        }
-      };
-    }
-    var import_zod32 = require("zod");
-    var ToolOutcomeSchema = import_zod32.z.enum([
-      "success",
-      "denied",
-      "fault",
-      "cancelled"
-    ]);
-    var ToolObservationSchema = import_zod32.z.object({
-      version: import_zod32.z.literal(1),
-      name: import_zod32.z.string().min(1).max(256),
-      toolCallId: import_zod32.z.string().min(1),
-      attemptId: import_zod32.z.string().min(1),
-      callingMode: import_zod32.z.enum(["direct", "model"]),
-      executed: import_zod32.z.boolean(),
-      outcome: ToolOutcomeSchema.optional(),
-      denialCode: import_zod32.z.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/).optional(),
-      errorType: import_zod32.z.string().max(256).optional(),
-      errorMessage: import_zod32.z.string().max(8192).optional(),
-      diagnosticId: import_zod32.z.string().uuid().optional(),
-      durationMs: import_zod32.z.number().finite().nonnegative().optional(),
-      workflowId: import_zod32.z.string().optional(),
-      nodeId: import_zod32.z.string().optional(),
-      workflowRevisionId: import_zod32.z.string().optional(),
-      runId: import_zod32.z.string().optional(),
-      invocationId: import_zod32.z.string().optional(),
-      parentInvocationId: import_zod32.z.string().optional(),
-      branchId: import_zod32.z.string().optional(),
-      observationKind: import_zod32.z.enum(["reused", "waiting"]).optional(),
-      suspended: import_zod32.z.boolean().optional(),
-      source: import_zod32.z.object({
-        runId: import_zod32.z.string().optional(),
-        invocationId: import_zod32.z.string().optional(),
-        branchId: import_zod32.z.string().optional(),
-        toolCallId: import_zod32.z.string(),
-        attemptId: import_zod32.z.string()
-      }).strict().optional()
-    });
-    var WorkflowToolSchema = import_zod32.z.object({
-      name: import_zod32.z.string().min(1).max(256),
-      description: import_zod32.z.string().max(4096).optional(),
-      callingMode: import_zod32.z.enum(["direct", "model"]),
-      provenance: import_zod32.z.enum(["source", "observed"]),
-      inputFields: import_zod32.z.array(
-        import_zod32.z.object({ name: import_zod32.z.string(), type: import_zod32.z.string(), required: import_zod32.z.boolean() }).strict()
-      ).optional()
-    }).strict();
-    var ToolDiscoverySchema = import_zod32.z.object({
-      status: import_zod32.z.enum(["complete", "unresolved"]),
-      publishedAt: import_zod32.z.string().datetime().optional(),
-      warnings: import_zod32.z.array(import_zod32.z.string()).optional()
-    }).strict();
-    var StudioToolSchema = WorkflowToolSchema.extend({
-      callingMode: import_zod32.z.enum(["direct", "model", "unknown"]),
-      calls: import_zod32.z.number().nonnegative(),
-      replays: import_zod32.z.number().nonnegative(),
-      successes: import_zod32.z.number().nonnegative(),
-      denials: import_zod32.z.number().nonnegative(),
-      faults: import_zod32.z.number().nonnegative(),
-      cancellations: import_zod32.z.number().nonnegative(),
-      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 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_zod52.z.object({
-      format: import_zod52.z.literal(1),
-      installer: import_zod52.z.literal(1),
-      version: StudioReleaseVersionSchema,
-      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_zod52.z.object({
-      automatic: import_zod52.z.boolean(),
-      hourUtc: import_zod52.z.number().int().min(0).max(23)
-    });
-    var StudioUpdateOperationSchema = import_zod52.z.object({
-      id: import_zod52.z.uuid(),
-      from: import_zod52.z.string(),
-      release: StudioReleaseSchema,
-      phase: import_zod52.z.enum([
-        "starting",
-        "pulling",
-        "backup",
-        "installing",
-        "verifying",
-        "succeeded",
-        "failed"
-      ]),
-      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_zod52.z.object({
-      current: import_zod52.z.string().nullable(),
-      available: StudioReleaseSchema.nullable(),
-      checkedAt: import_zod52.z.iso.datetime().nullable(),
-      checkError: import_zod52.z.string().nullable(),
-      settings: StudioUpdateSettingsSchema,
-      operation: StudioUpdateOperationSchema.nullable()
-    });
-    function newerStudioVersion(candidate, current) {
-      const next = StudioReleaseVersionSchema.parse(candidate).split(".").map(BigInt);
-      const previous = StudioReleaseVersionSchema.parse(current).split(".").map(BigInt);
-      for (let i = 0; i < 3; i++) {
-        if (next[i] !== previous[i]) return (next[i] ?? 0n) > (previous[i] ?? 0n);
-      }
-      return false;
-    }
-    function studioUpdateRunning(operation) {
-      return !!operation && operation.phase !== "succeeded" && operation.phase !== "failed";
-    }
-    var str = (v, fallback = "") => typeof v === "string" ? v : fallback;
-    function projectWorkflowCalls(events) {
-      const groups = /* @__PURE__ */ new Map();
-      for (const event of events) {
-        if (!event.type.startsWith("workflow.call.") || !str(event.payload.invocationId) || !str(event.payload.targetWorkflowId))
-          continue;
-        const key = `${event.runId}:${str(event.payload.branchId, event.runId)}:${event.payload.invocationId}`;
-        const group = groups.get(key) ?? [];
-        if (!group.some((existing) => existing.id === event.id)) group.push(event);
-        groups.set(key, group);
-      }
-      return [...groups.entries()].map(([id3, group]) => {
-        group.sort(
-          (a, b) => Number(a.payload.sequence ?? 0) - Number(b.payload.sequence ?? 0) || a.occurredAt.localeCompare(b.occurredAt) || a.id.localeCompare(b.id)
-        );
-        const first = group[0];
-        const p = first.payload;
-        const call = {
-          id: id3,
-          invocationId: str(p.invocationId),
-          branchId: str(p.branchId, first.runId),
-          parentInvocationId: str(p.parentInvocationId) || null,
-          callId: str(p.callId),
-          callerNodeId: str(p.callerNodeId),
-          callerNodeExecutionId: str(p.callerNodeExecutionId),
-          sourceWorkflowId: str(p.sourceWorkflowId, first.workflowId),
-          targetWorkflowId: str(p.targetWorkflowId),
-          targetVersion: str(p.targetVersion) || null,
-          status: "incomplete",
-          startedAt: first.occurredAt,
-          endedAt: null,
-          activeMs: 0,
-          waitMs: 0,
-          attempts: 0,
-          reused: 0,
-          inherited: false,
-          sourceRunId: null,
-          leaf: null,
-          events: group
-        };
-        let active = null;
-        let waiting = null;
-        for (const event of group) {
-          const at = Date.parse(event.occurredAt);
-          const status2 = event.type.slice("workflow.call.".length);
-          for (const side of [
-            "input",
-            "output",
-            "inputOmitted",
-            "outputOmitted"
-          ])
-            if (side in event.payload) call[side] = event.payload[side];
-          if (status2 === "restored") {
-            call.inherited = true;
-            call.sourceRunId = str(event.payload.sourceRunId) || null;
-            call.status = event.payload.status === "completed" ? "completed" : event.payload.status === "failed" ? "failed" : "interrupted";
-            if (call.status === "interrupted") waiting = at;
-          } else if (status2 === "started" || status2 === "resumed") {
-            if (waiting !== null) call.waitMs += Math.max(0, at - waiting);
-            waiting = null;
-            active = at;
-            call.attempts++;
-            call.status = "running";
-            call.endedAt = null;
-          } else if (status2 === "reused") {
-            call.reused++;
-            call.status = "completed";
-          } else if (status2 === "suspended" || status2 === "completed" || status2 === "failed") {
-            if (active !== null) call.activeMs += Math.max(0, at - active);
-            active = null;
-            call.status = status2 === "suspended" ? "interrupted" : status2;
-            if (status2 === "suspended") {
-              waiting = at;
-              const leaf = event.payload.leaf;
-              if (leaf && typeof leaf === "object") {
-                const value = leaf;
-                call.leaf = {
-                  workflowId: str(value.workflowId),
-                  nodeId: str(value.nodeId),
-                  invocationId: str(value.invocationId)
-                };
-              }
-            } else {
-              call.endedAt = event.occurredAt;
-              call.leaf = null;
-            }
-          }
-        }
-        const cancellation = events.find(
-          (event) => event.type === "run.cancelled" && event.runId === first.runId && (event.payload.branchId ?? event.runId) === call.branchId && event.occurredAt >= (group.at(-1)?.occurredAt ?? first.occurredAt)
-        );
-        if (cancellation && (call.status === "interrupted" || call.status === "running")) {
-          call.status = "cancelled";
-          call.endedAt = cancellation.occurredAt;
-        }
-        return call;
-      }).sort((a, b) => a.startedAt.localeCompare(b.startedAt));
-    }
-    var STUDIO_API_PROTOCOL_VERSION = "1";
-    var TELEMETRY_EVENT_TYPES = [
-      "span.started",
-      "span.ended",
-      "span.failed",
-      "error.reported",
-      "generation.completed",
-      "tool.started",
-      "tool.completed",
-      "tool.failed",
-      "tool.denied",
-      "tool.cancelled",
-      "tool.reused",
-      "tool.waiting",
-      "tool.suspended",
-      "response.completed",
-      "output.emitted",
-      "output.invalidated",
-      "interrupt.created",
-      "interrupt.resolved",
-      "interrupt.expired",
-      "interrupt.cancelled",
-      "run.cancelled",
-      "run.limit_reached",
-      "workflow.suspended",
-      "workflow.resumed",
-      "workflow.transitioned",
-      "workflow.call.started",
-      "workflow.call.suspended",
-      "workflow.call.resumed",
-      "workflow.call.completed",
-      "workflow.call.failed",
-      "workflow.call.reused",
-      "workflow.call.restored",
-      "session.checkpointed",
-      "session.forked",
-      "session.rolled_back"
-    ];
-    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_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_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_zod62.z.object({
-      sourceNodeId: import_zod62.z.string().min(1),
-      targetWorkflowId: import_zod62.z.string().min(1)
-    }).strict();
-    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_zod62.z.object({
-      schemaVersion: import_zod62.z.literal(1),
-      environment: import_zod62.z.string().min(1),
-      service: TelemetryServiceSchema,
-      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_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_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_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_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown())
-    }).strict().superRefine((event, ctx) => {
-      if (!event.type.startsWith("tool.")) return;
-      const canonical3 = event.payload.version === 1 || [
-        "tool.denied",
-        "tool.cancelled",
-        "tool.reused",
-        "tool.waiting",
-        "tool.suspended"
-      ].includes(event.type);
-      if (!canonical3) return;
-      const parsed = ToolObservationSchema.strict().safeParse(event.payload);
-      if (!parsed.success)
-        for (const issue2 of parsed.error.issues)
-          ctx.addIssue({ ...issue2, path: ["payload", ...issue2.path] });
-      else {
-        if ((parsed.data.errorType !== void 0 || parsed.data.errorMessage !== void 0) && parsed.data.outcome !== "fault")
-          ctx.addIssue({
-            code: "custom",
-            path: ["payload"],
-            message: "Error diagnostics require a fault outcome."
-          });
-        const terminalOutcomes = {
-          "tool.completed": "success",
-          "tool.failed": "fault",
-          "tool.denied": "denied",
-          "tool.cancelled": "cancelled"
-        };
-        const expected = terminalOutcomes[event.type];
-        if (expected && parsed.data.outcome !== expected)
-          ctx.addIssue({
-            code: "custom",
-            path: ["payload", "outcome"],
-            message: "Outcome must match the tool event type."
-          });
-        if (event.type === "tool.reused" && (parsed.data.executed || !parsed.data.source))
-          ctx.addIssue({
-            code: "custom",
-            path: ["payload"],
-            message: "Reuse must be unexecuted and reference its source."
-          });
-      }
-    });
-    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_zod62.z.enum([
-      "sdk",
-      "provider",
-      "custom",
-      "project-rate-card",
-      "default-rate-card"
-    ]);
-    var TelemetryPricingUnitSchema = import_zod62.z.enum([
-      "token",
-      "character",
-      "request",
-      "image",
-      "audio_second",
-      "audio_minute",
-      "video_second",
-      "video_minute",
-      "second",
-      "minute",
-      "custom"
-    ]);
-    var TelemetryPricingUsageTypeSchema = import_zod62.z.enum([
-      "input",
-      "output",
-      "reasoning",
-      "cache_read",
-      "cache_write",
-      "embedding",
-      "image_input",
-      "image_output",
-      "audio_input",
-      "audio_output",
-      "video_input",
-      "video_output",
-      "request",
-      "custom"
-    ]);
-    var TelemetryUsageItemSchema = import_zod62.z.object({
-      usageType: TelemetryPricingUsageTypeSchema,
-      quantity: import_zod62.z.number().nonnegative(),
-      unit: TelemetryPricingUnitSchema,
-      label: import_zod62.z.string().optional()
-    }).strict();
-    var TelemetryUnitPriceSchema = import_zod62.z.object({
-      usageType: TelemetryPricingUsageTypeSchema,
-      unit: TelemetryPricingUnitSchema,
-      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_zod62.z.object({
-      usageType: TelemetryPricingUsageTypeSchema,
-      quantity: import_zod62.z.number().nonnegative(),
-      unit: TelemetryPricingUnitSchema,
-      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_zod62.z.object({
-      source: TelemetryPricingSourceSchema.extract(["sdk", "provider", "custom"]),
-      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_zod62.z.enum([
-      "running",
-      "completed",
-      "interrupted",
-      "incomplete",
-      "failed",
-      "cancelled"
-    ]);
-    var STUDIO_TIME_RANGES = [
-      "Last hour",
-      "24 hours",
-      "7 days",
-      "30 days",
-      "All time",
-      "Custom range"
-    ];
-    var StudioTimeRangeSchema = import_zod62.z.enum(STUDIO_TIME_RANGES);
-    var StudioTimeRangeQuerySchema = import_zod62.z.object({
-      range: StudioTimeRangeSchema.optional(),
-      startedAfter: import_zod62.z.string().optional(),
-      startedBefore: import_zod62.z.string().optional()
-    }).strict();
-    var StudioTimeRangeContextSchema = import_zod62.z.object({
-      range: StudioTimeRangeSchema,
-      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,
-      "24 hours": 24 * 60 * 60 * 1e3,
-      "7 days": 7 * 24 * 60 * 60 * 1e3,
-      "30 days": 30 * 24 * 60 * 60 * 1e3
-    };
-    var parseIsoBoundary = (value, label) => {
-      if (!value) {
-        return { ok: false, error: `${label} is required for a custom range.` };
-      }
-      if (!/(?:Z|[+-]\d{2}:\d{2})$/.test(value)) {
-        return {
-          ok: false,
-          error: `${label} must include an explicit UTC offset.`
-        };
-      }
-      const date = new Date(value);
-      return Number.isFinite(date.getTime()) ? { ok: true, date } : { ok: false, error: `${label} must be a valid ISO date and time.` };
-    };
-    var resolveStudioTimeRange = (input, now = /* @__PURE__ */ new Date()) => {
-      const parsedRange = StudioTimeRangeSchema.safeParse(
-        input.range || "24 hours"
-      );
-      if (!parsedRange.success) {
-        return {
-          ok: false,
-          error: `Unknown time range "${input.range}".`
-        };
-      }
-      if (!Number.isFinite(now.getTime())) {
-        return { ok: false, error: "The time range reference date is invalid." };
-      }
-      const range = parsedRange.data;
-      if (range === "All time") {
-        return {
-          ok: true,
-          value: { range, startedAfter: null, startedBefore: null }
-        };
-      }
-      if (range === "Custom range") {
-        const after = parseIsoBoundary(input.startedAfter, "Start time");
-        if ("error" in after) return { ok: false, error: after.error };
-        const before = parseIsoBoundary(input.startedBefore, "End time");
-        if ("error" in before) return { ok: false, error: before.error };
-        if (after.date.getTime() >= before.date.getTime()) {
-          return {
-            ok: false,
-            error: "Start time must be before end time."
-          };
-        }
-        return {
-          ok: true,
-          value: {
-            range,
-            startedAfter: after.date.toISOString(),
-            startedBefore: before.date.toISOString()
-          }
-        };
-      }
-      const duration = STUDIO_TIME_RANGE_MILLISECONDS[range];
-      if (!duration) {
-        return { ok: false, error: `Unknown time range "${range}".` };
-      }
-      return {
-        ok: true,
-        value: {
-          range,
-          startedAfter: new Date(now.getTime() - duration).toISOString(),
-          startedBefore: now.toISOString()
-        }
-      };
-    };
-    var StudioInterruptStatusSchema = import_zod62.z.enum([
-      "pending",
-      "resolved",
-      "expired",
-      "failed",
-      "cancelled"
-    ]);
-    var resolveStudioInterruptStatus = (input, now = Date.now()) => {
-      if (input.status !== "pending" || !input.expiresAt) return input.status;
-      const expiresAt = Date.parse(input.expiresAt);
-      const nowMs = typeof now === "number" ? now : now.getTime();
-      return Number.isFinite(expiresAt) && Number.isFinite(nowMs) && expiresAt <= nowMs ? "expired" : input.status;
-    };
-    var StudioInterruptTypeSchema = import_zod62.z.enum([
-      "choice",
-      "multi-choice",
-      "text",
-      "structured",
-      "unknown"
-    ]);
-    var StudioInterruptInteractionModeSchema = import_zod62.z.enum([
-      "static-options",
-      "dynamic-picker",
-      "freeform",
-      "unknown"
-    ]);
-    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_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_zod62.z.enum([
-      "resumed",
-      "resume failed",
-      "expired before resume",
-      "cancelled"
-    ]);
-    var StudioWorkflowHealthSchema = import_zod62.z.enum([
-      "unknown",
-      "healthy",
-      "degraded",
-      "failing",
-      "idle"
-    ]);
-    var StudioPricingStatusSchema = import_zod62.z.enum([
-      "priced",
-      "unpriced",
-      "unknown"
-    ]);
-    var StudioPricingSourceSchema = TelemetryPricingSourceSchema.nullable();
-    var StudioChangeResourceSchema = import_zod62.z.enum([
-      "evals",
-      "workflows",
-      "runs",
-      "sessions",
-      "interrupts"
-    ]);
-    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 StudioCostSummarySchema = import_zod62.z.object({
-      amounts: import_zod62.z.array(
-        import_zod62.z.object({
-          amount: import_zod62.z.number().nonnegative(),
-          currency: import_zod62.z.string().nullable()
-        }).strip()
-      ),
-      complete: import_zod62.z.boolean()
-    }).strip();
-    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(),
-      averageCostSummary: StudioCostSummarySchema.optional(),
-      currency: import_zod62.z.string().nullable()
-    }).strip();
-    var StudioRunSchema = import_zod62.z.object({
-      id: import_zod62.z.string().min(1),
-      feedback: FeedbackSummarySchema.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_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_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(),
-      costSummary: StudioCostSummarySchema.optional(),
-      pricingStatus: StudioPricingStatusSchema,
-      pricingSource: StudioPricingSourceSchema,
-      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_zod62.z.string().datetime({ offset: true }).nullable().optional()
-    }).strip();
-    var StudioSessionSchema = import_zod62.z.object({
-      id: import_zod62.z.string().min(1),
-      status: StudioRunStatusSchema,
-      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(),
-      costSummary: StudioCostSummarySchema.optional(),
-      pricingStatus: StudioPricingStatusSchema,
-      pricingSource: StudioPricingSourceSchema,
-      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_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_zod62.z.object({
-      afterResponseCompleted: import_zod62.z.boolean().optional(),
-      id: import_zod62.z.string().min(1),
-      status: StudioInterruptStatusSchema,
-      type: StudioInterruptTypeSchema,
-      interactionMode: StudioInterruptInteractionModeSchema,
-      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_zod62.z.boolean(),
-      resumeOutcome: StudioResumeOutcomeSchema.nullable(),
-      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_zod62.z.object({
-      id: import_zod62.z.string().min(1),
-      // Studio readers must preserve future event kinds within the same API major.
-      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_zod62.z.object({
-      tools: import_zod62.z.array(StudioToolSchema).optional(),
-      toolDiscovery: ToolDiscoverySchema.optional(),
-      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_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_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_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_zod62.z.array(import_zod62.z.string()),
-      lastActivityAt: import_zod62.z.string().datetime({ offset: true }).nullable(),
-      metrics: StudioMetricSchema,
-      nodes: import_zod62.z.array(StudioWorkflowNodeSchema),
-      internalEdges: import_zod62.z.array(StudioWorkflowInternalEdgeSchema)
-    }).strip();
-    var StudioRunsResponseSchema = import_zod62.z.object({
-      runs: import_zod62.z.array(StudioRunSchema),
-      totalCount: import_zod62.z.number().int().nonnegative()
-    }).strip();
-    var StudioSessionsResponseSchema = import_zod62.z.object({
-      sessions: import_zod62.z.array(StudioSessionSchema),
-      totalCount: import_zod62.z.number().int().nonnegative()
-    }).strip();
-    var StudioInterruptsResponseSchema = import_zod62.z.object({
-      interrupts: import_zod62.z.array(StudioInterruptSchema),
-      totalCount: import_zod62.z.number().int().nonnegative()
-    }).strip();
-    var StudioRunDetailResponseSchema = import_zod62.z.object({
-      run: StudioRunSchema,
-      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_zod62.z.array(StudioInterruptSchema),
-      updatedAt: import_zod62.z.string().datetime({ offset: true })
-    }).strip();
-    var StudioSessionDetailResponseSchema = import_zod62.z.object({
-      session: StudioSessionSchema,
-      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_zod62.z.object({
-      interrupt: StudioInterruptSchema,
-      events: import_zod62.z.array(StudioDetailEventSchema),
-      run: StudioRunSchema.nullable(),
-      session: StudioSessionSchema.nullable(),
-      updatedAt: import_zod62.z.string().datetime({ offset: true })
-    }).strip();
-    var StudioWorkflowsResponseSchema = import_zod62.z.object({
-      workflows: import_zod62.z.array(StudioWorkflowSchema),
-      observedCalls: import_zod62.z.array(
-        StudioWorkflowTransitionSchema.extend({
-          runId: import_zod62.z.string(),
-          invocationId: import_zod62.z.string(),
-          branchId: import_zod62.z.string()
-        })
-      ).optional(),
-      transitions: import_zod62.z.array(StudioWorkflowTransitionSchema),
-      cohort: StudioTimeRangeContextSchema.extend({
-        workflowId: import_zod62.z.string().nullable(),
-        version: import_zod62.z.string().nullable()
-      }).strip()
-    }).strip();
-    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_zod62.z.object({
-      organization: import_zod62.z.object({
-        name: import_zod62.z.string().min(1)
-      }).strip(),
-      project: import_zod62.z.object({
-        name: import_zod62.z.string().min(1)
-      }).strip(),
-      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_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();
-  }
-});
-
 // ../hooks/dist/internal.js
 var require_internal = __commonJS({
   "../hooks/dist/internal.js"(exports2, module2) {
@@ -1647,7 +51,7 @@ var require_internal = __commonJS({
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var internal_exports = {};
     __export2(internal_exports, {
-      captureDiagnosticContent: () => captureDiagnosticContent,
+      captureDiagnosticContent: () => import_telemetry_contracts4.captureDiagnosticContent,
       errorDiagnostics: () => errorDiagnostics,
       exceptionDiagnostics: () => exceptionDiagnostics,
       isModelTraceSpan: () => isModelTraceSpan,
@@ -1655,255 +59,20 @@ var require_internal = __commonJS({
       safeSpan: () => safeSpan,
       safeStartSpan: () => safeStartSpan2,
       safeTelemetryMetadata: () => safeTelemetryMetadata2,
-      summarizeDiagnostic: () => import_telemetry_contracts3.summarizeDiagnostic,
+      summarizeDiagnostic: () => import_telemetry_contracts32.summarizeDiagnostic,
       withSafeTraceSpan: () => withSafeTraceSpan2
     });
     module2.exports = __toCommonJS2(internal_exports);
-    var import_telemetry_contracts3 = require_dist();
-    var import_errors16 = require("@kortyx/core/errors");
-    var import_telemetry_contracts = require_dist();
-    var encoder = new TextEncoder();
-    var nativeStackGetter = Object.getOwnPropertyDescriptor(
-      new Error(),
-      "stack"
-    )?.get;
-    function nativeStack(object2, getter) {
-      if (!getter || getter !== nativeStackGetter)
-        throw new Error("Custom stack accessor");
-      for (const key of ["name", "message"]) {
-        let cursor = object2;
-        while (cursor) {
-          const descriptor = Object.getOwnPropertyDescriptor(cursor, key);
-          if (descriptor) {
-            if (!("value" in descriptor) || typeof descriptor.value !== "string")
-              throw new Error("Custom error formatting");
-            break;
-          }
-          cursor = Object.getPrototypeOf(cursor);
-        }
-      }
-      const formatter = Object.getOwnPropertyDescriptor(Error, "prepareStackTrace");
-      if (formatter && (!("value" in formatter) || !formatter.writable))
-        throw new Error("Custom stack formatter");
-      Object.defineProperty(Error, "prepareStackTrace", {
-        ...formatter ?? { configurable: true, writable: true },
-        value: void 0
-      });
-      try {
-        return getter.call(object2);
-      } finally {
-        if (formatter) Object.defineProperty(Error, "prepareStackTrace", formatter);
-        else Reflect.deleteProperty(Error, "prepareStackTrace");
-      }
-    }
-    var pointer = (key) => key.replace(/~/g, "~0").replace(/\//g, "~1");
-    function captureDiagnosticContent(error, project) {
-      const omissions = [];
-      const redactions = [];
-      const seen = /* @__PURE__ */ new WeakMap();
-      let nodes = 0;
-      let remaining = import_telemetry_contracts.DIAGNOSTIC_LIMITS.bytes - 64 * 1024;
-      const omit = (path, reason, extra = {}) => {
-        if (omissions.length < 1e3)
-          omissions.push({ path: path.slice(0, 4096), reason, ...extra });
-        return { $omitted: reason };
-      };
-      const visit = (value, path, depth) => {
-        if (++nodes > import_telemetry_contracts.DIAGNOSTIC_LIMITS.nodes) return omit(path, "node_limit");
-        if (depth > import_telemetry_contracts.DIAGNOSTIC_LIMITS.depth) return omit(path, "depth_limit");
-        if (typeof value === "string") {
-          const clean = (0, import_telemetry_contracts.redactDiagnosticText)(value);
-          if (clean !== value && redactions.length < 1e3)
-            redactions.push({
-              path: path.slice(0, 4096),
-              reason: "credential_text"
-            });
-          const bytes = encoder.encode(JSON.stringify(clean)).length;
-          if (bytes > remaining)
-            return omit(path, "byte_limit", {
-              originalBytes: encoder.encode(value).length
-            });
-          remaining -= bytes;
-          return clean;
-        }
-        if (value === null || typeof value === "boolean") return value;
-        if (typeof value === "number")
-          return Number.isFinite(value) ? value : { $type: "number", value: String(value) };
-        if (typeof value === "bigint")
-          return { $type: "bigint", value: value.toString() };
-        if (typeof value === "undefined") return { $type: "undefined" };
-        if (typeof value === "function" || typeof value === "symbol")
-          return omit(path, `unsupported_${typeof value}`);
-        const object2 = value;
-        const reference = seen.get(object2);
-        if (reference) return { $ref: reference };
-        seen.set(object2, path);
-        remaining -= 32;
-        if (remaining < 0) return omit(path, "byte_limit");
-        try {
-          if (value instanceof Date)
-            return { $type: "Date", value: Date.prototype.toISOString.call(value) };
-          if (value instanceof Map || value instanceof Set) {
-            const isMap = value instanceof Map;
-            const iterator = isMap ? Map.prototype.entries.call(value) : Set.prototype.values.call(value);
-            const count = Object.getOwnPropertyDescriptor(
-              isMap ? Map.prototype : Set.prototype,
-              "size"
-            )?.get?.call(value);
-            const entries = [];
-            for (let index = 0; index < Math.min(count, import_telemetry_contracts.DIAGNOSTIC_LIMITS.properties); index++)
-              entries.push(iterator.next().value);
-            if (count > entries.length)
-              omissions.push({
-                path,
-                reason: "collection_limit",
-                originalCount: count
-              });
-            return isMap ? {
-              $type: "Map",
-              entries: visit(entries, `${path}/entries`, depth + 1)
-            } : {
-              $type: "Set",
-              values: visit(entries, `${path}/values`, depth + 1)
-            };
-          }
-          if (Array.isArray(value)) {
-            const count = Math.min(value.length, import_telemetry_contracts.DIAGNOSTIC_LIMITS.properties);
-            const items = Array.from(
-              { length: count },
-              (_, index) => read(value, String(index), `${path}/${index}`, depth)
-            );
-            if (count < value.length)
-              items.push(
-                omit(path, "collection_limit", { originalCount: value.length })
-              );
-            return items;
-          }
-          const keys = Object.getOwnPropertyNames(object2);
-          const result = /* @__PURE__ */ Object.create(null);
-          if (value instanceof Error) {
-            const ownName = Object.getOwnPropertyDescriptor(object2, "name");
-            let type = ownName && "value" in ownName ? ownName.value : void 0;
-            if (typeof type !== "string") {
-              const name = Object.getOwnPropertyDescriptor(
-                Object.getPrototypeOf(value),
-                "name"
-              );
-              type = name && "value" in name ? name.value : "Error";
-            }
-            result.type = visit(
-              typeof type === "string" ? type : "Error",
-              `${path}/type`,
-              depth + 1
-            );
-          }
-          for (const key of keys.slice(0, import_telemetry_contracts.DIAGNOSTIC_LIMITS.properties)) {
-            if (["__proto__", "constructor", "prototype"].includes(key)) {
-              result[key] = omit(`${path}/${pointer(key)}`, "unsafe_key");
-              continue;
-            }
-            remaining -= encoder.encode(key).length + 4;
-            result[key] = read(object2, key, `${path}/${pointer(key)}`, depth);
-          }
-          if (keys.length > import_telemetry_contracts.DIAGNOSTIC_LIMITS.properties)
-            result.$omittedProperties = omit(path, "property_limit", {
-              originalCount: keys.length
-            });
-          return result;
-        } catch {
-          return omit(path, "unreadable_object");
-        }
-      };
-      const read = (object2, key, path, depth) => {
-        if ((0, import_telemetry_contracts.isPrivateDiagnosticField)(key)) {
-          if (redactions.length < 1e3)
-            redactions.push({
-              path: path.slice(0, 4096),
-              reason: "credential_field"
-            });
-          return "[REDACTED]";
-        }
-        try {
-          const property = Object.getOwnPropertyDescriptor(object2, key);
-          if (property && "value" in property)
-            return visit(property.value, path, depth + 1);
-          if (key === "stack" && object2 instanceof Error && property?.get && property.get === nativeStackGetter)
-            return visit(nativeStack(object2, property.get), path, depth + 1);
-          return omit(
-            path,
-            property ? "accessor_not_evaluated" : "unavailable_property"
-          );
-        } catch {
-          return omit(path, "unreadable_property");
-        }
-      };
-      try {
-        const original = project ? project(error) : error;
-        if (project && original === null) return null;
-        const captured = visit(original, "#/data", 0);
-        const upstreamOmissions = (0, import_errors16.errorProperty)(original, "diagnosticOmissions");
-        if (Array.isArray(upstreamOmissions))
-          for (const note of upstreamOmissions.slice(0, 1e3)) {
-            const path = (0, import_errors16.errorProperty)(note, "path");
-            const reason = (0, import_errors16.errorProperty)(note, "reason");
-            if (typeof path === "string" && typeof reason === "string")
-              omissions.push({
-                path: (0, import_telemetry_contracts.redactDiagnosticText)(path).slice(0, 4096),
-                reason: (0, import_telemetry_contracts.redactDiagnosticText)(reason).slice(0, 128)
-              });
-          }
-        const data = captured && typeof captured === "object" && !Array.isArray(captured) ? captured : {
-          type: "Error",
-          message: typeof captured === "string" ? captured : "Execution reported a fault.",
-          value: captured
-        };
-        if (typeof data.message !== "string" && !("message" in data))
-          data.message = "Execution reported a fault.";
-        if (!("type" in data))
-          data.type = typeof data.name === "string" ? data.name : "Error";
-        const content = {
-          schemaVersion: 1,
-          data,
-          capture: {
-            status: omissions.length ? "partial" : "complete",
-            omissions,
-            redactions
-          }
-        };
-        if (encoder.encode(JSON.stringify(content)).length > import_telemetry_contracts.DIAGNOSTIC_LIMITS.bytes)
-          return {
-            schemaVersion: 1,
-            data: {
-              type: "Error",
-              message: "Diagnostic exceeded the capture budget."
-            },
-            capture: {
-              status: "partial",
-              redactions: [],
-              omissions: [{ path: "#/data", reason: "serialized_byte_limit" }]
-            }
-          };
-        return content;
-      } catch {
-        return {
-          schemaVersion: 1,
-          data: { type: "Error", message: "Diagnostic capture failed." },
-          capture: {
-            status: "failed",
-            redactions: [],
-            omissions: [{ path: "#/data", reason: "projection_or_capture_failed" }]
-          }
-        };
-      }
-    }
-    var import_telemetry_contracts2 = require_dist();
+    var import_telemetry_contracts32 = require("@kortyx/telemetry-contracts");
+    var import_telemetry_contracts4 = require("@kortyx/telemetry-contracts");
+    var import_telemetry_contracts22 = require("@kortyx/telemetry-contracts");
     function exceptionDiagnostics(error, project) {
-      const content = captureDiagnosticContent(error, project);
+      const content = (0, import_telemetry_contracts4.captureDiagnosticContent)(error, project);
       return !content || content.capture.status === "failed" ? null : content.data;
     }
     function errorDiagnostics(error, project) {
       const captured = exceptionDiagnostics(error, project);
-      const details = captured ? (0, import_telemetry_contracts2.summarizeDiagnostic)(captured) : null;
+      const details = captured ? (0, import_telemetry_contracts22.summarizeDiagnostic)(captured) : null;
       return details ? {
         errorMessage: details.message.slice(0, 8192),
         ...details.type ? { errorType: details.type.slice(0, 256) } : {}
@@ -1914,7 +83,7 @@ var require_internal = __commonJS({
     }
     var import_node_crypto8 = require("crypto");
     var import_core6 = require("@kortyx/core");
-    var import_errors22 = require("@kortyx/core/errors");
+    var import_errors16 = require("@kortyx/core/errors");
     function safeSpan(span) {
       const guard = (fn) => (...args) => {
         try {
@@ -1996,7 +165,7 @@ var require_internal = __commonJS({
     var import_node2 = require("@kortyx/usage-telemetry/node");
     var package_default2 = {
       name: "@kortyx/hooks",
-      version: "0.34.3",
+      version: "0.35.0",
       private: false,
       description: "Lifecycle hooks and extension points for Kortyx.",
       keywords: [
@@ -2076,7 +245,7 @@ var require_internal = __commonJS({
     function assertModelFinish(result) {
       if (result.finishReason?.unified !== "content-filter") return;
       throw Object.assign(
-        new import_errors22.KortyxError("PROVIDER_REFUSAL", "The provider refused the request.", {
+        new import_errors16.KortyxError("PROVIDER_REFUSAL", "The provider refused the request.", {
           category: "provider",
           retryable: false,
           safeMessage: "The provider refused the request."
@@ -2393,7 +562,7 @@ var require_internal = __commonJS({
 });
 
 // ../hooks/dist/index.js
-var require_dist2 = __commonJS({
+var require_dist = __commonJS({
   "../hooks/dist/index.js"(exports2, module2) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -2437,7 +606,7 @@ var require_dist2 = __commonJS({
       workflowCallFingerprint: () => workflowCallFingerprint
     });
     module2.exports = __toCommonJS2(index_exports2);
-    var import_zod14 = require("zod");
+    var import_zod15 = require("zod");
     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);
@@ -2632,7 +801,7 @@ var require_dist2 = __commonJS({
     var import_node2 = require("@kortyx/usage-telemetry/node");
     var package_default2 = {
       name: "@kortyx/hooks",
-      version: "0.34.3",
+      version: "0.35.0",
       private: false,
       description: "Lifecycle hooks and extension points for Kortyx.",
       keywords: [
@@ -2709,9 +878,9 @@ var require_dist2 = __commonJS({
       measure: (...args) => client2().measure(...args),
       flush: () => client2().flush()
     };
-    var optionsSchema = import_zod14.z.object({
-      message: import_zod14.z.string().optional(),
-      data: import_zod14.z.json().optional()
+    var optionsSchema = import_zod15.z.object({
+      message: import_zod15.z.string().optional(),
+      data: import_zod15.z.json().optional()
     }).strict();
     async function completeResponseInternal(options = {}) {
       const ctx = getHookContext();
@@ -3181,261 +1350,26 @@ var require_dist2 = __commonJS({
     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");
-    var import_telemetry_contracts2 = require_dist();
     var import_errors22 = require("@kortyx/core/errors");
-    var import_telemetry_contracts = require_dist();
-    var encoder = new TextEncoder();
-    var nativeStackGetter = Object.getOwnPropertyDescriptor(
-      new Error(),
-      "stack"
-    )?.get;
-    function nativeStack(object2, getter) {
-      if (!getter || getter !== nativeStackGetter)
-        throw new Error("Custom stack accessor");
-      for (const key of ["name", "message"]) {
-        let cursor = object2;
-        while (cursor) {
-          const descriptor = Object.getOwnPropertyDescriptor(cursor, key);
-          if (descriptor) {
-            if (!("value" in descriptor) || typeof descriptor.value !== "string")
-              throw new Error("Custom error formatting");
-            break;
-          }
-          cursor = Object.getPrototypeOf(cursor);
-        }
-      }
-      const formatter = Object.getOwnPropertyDescriptor(Error, "prepareStackTrace");
-      if (formatter && (!("value" in formatter) || !formatter.writable))
-        throw new Error("Custom stack formatter");
-      Object.defineProperty(Error, "prepareStackTrace", {
-        ...formatter ?? { configurable: true, writable: true },
-        value: void 0
-      });
-      try {
-        return getter.call(object2);
-      } finally {
-        if (formatter) Object.defineProperty(Error, "prepareStackTrace", formatter);
-        else Reflect.deleteProperty(Error, "prepareStackTrace");
-      }
-    }
-    var pointer = (key) => key.replace(/~/g, "~0").replace(/\//g, "~1");
-    function captureDiagnosticContent(error, project) {
-      const omissions = [];
-      const redactions = [];
-      const seen = /* @__PURE__ */ new WeakMap();
-      let nodes = 0;
-      let remaining = import_telemetry_contracts.DIAGNOSTIC_LIMITS.bytes - 64 * 1024;
-      const omit = (path, reason, extra = {}) => {
-        if (omissions.length < 1e3)
-          omissions.push({ path: path.slice(0, 4096), reason, ...extra });
-        return { $omitted: reason };
-      };
-      const visit = (value, path, depth) => {
-        if (++nodes > import_telemetry_contracts.DIAGNOSTIC_LIMITS.nodes) return omit(path, "node_limit");
-        if (depth > import_telemetry_contracts.DIAGNOSTIC_LIMITS.depth) return omit(path, "depth_limit");
-        if (typeof value === "string") {
-          const clean = (0, import_telemetry_contracts.redactDiagnosticText)(value);
-          if (clean !== value && redactions.length < 1e3)
-            redactions.push({
-              path: path.slice(0, 4096),
-              reason: "credential_text"
-            });
-          const bytes = encoder.encode(JSON.stringify(clean)).length;
-          if (bytes > remaining)
-            return omit(path, "byte_limit", {
-              originalBytes: encoder.encode(value).length
-            });
-          remaining -= bytes;
-          return clean;
-        }
-        if (value === null || typeof value === "boolean") return value;
-        if (typeof value === "number")
-          return Number.isFinite(value) ? value : { $type: "number", value: String(value) };
-        if (typeof value === "bigint")
-          return { $type: "bigint", value: value.toString() };
-        if (typeof value === "undefined") return { $type: "undefined" };
-        if (typeof value === "function" || typeof value === "symbol")
-          return omit(path, `unsupported_${typeof value}`);
-        const object2 = value;
-        const reference = seen.get(object2);
-        if (reference) return { $ref: reference };
-        seen.set(object2, path);
-        remaining -= 32;
-        if (remaining < 0) return omit(path, "byte_limit");
-        try {
-          if (value instanceof Date)
-            return { $type: "Date", value: Date.prototype.toISOString.call(value) };
-          if (value instanceof Map || value instanceof Set) {
-            const isMap = value instanceof Map;
-            const iterator = isMap ? Map.prototype.entries.call(value) : Set.prototype.values.call(value);
-            const count = Object.getOwnPropertyDescriptor(
-              isMap ? Map.prototype : Set.prototype,
-              "size"
-            )?.get?.call(value);
-            const entries = [];
-            for (let index = 0; index < Math.min(count, import_telemetry_contracts.DIAGNOSTIC_LIMITS.properties); index++)
-              entries.push(iterator.next().value);
-            if (count > entries.length)
-              omissions.push({
-                path,
-                reason: "collection_limit",
-                originalCount: count
-              });
-            return isMap ? {
-              $type: "Map",
-              entries: visit(entries, `${path}/entries`, depth + 1)
-            } : {
-              $type: "Set",
-              values: visit(entries, `${path}/values`, depth + 1)
-            };
-          }
-          if (Array.isArray(value)) {
-            const count = Math.min(value.length, import_telemetry_contracts.DIAGNOSTIC_LIMITS.properties);
-            const items = Array.from(
-              { length: count },
-              (_, index) => read(value, String(index), `${path}/${index}`, depth)
-            );
-            if (count < value.length)
-              items.push(
-                omit(path, "collection_limit", { originalCount: value.length })
-              );
-            return items;
-          }
-          const keys = Object.getOwnPropertyNames(object2);
-          const result = /* @__PURE__ */ Object.create(null);
-          if (value instanceof Error) {
-            const ownName = Object.getOwnPropertyDescriptor(object2, "name");
-            let type = ownName && "value" in ownName ? ownName.value : void 0;
-            if (typeof type !== "string") {
-              const name = Object.getOwnPropertyDescriptor(
-                Object.getPrototypeOf(value),
-                "name"
-              );
-              type = name && "value" in name ? name.value : "Error";
-            }
-            result.type = visit(
-              typeof type === "string" ? type : "Error",
-              `${path}/type`,
-              depth + 1
-            );
-          }
-          for (const key of keys.slice(0, import_telemetry_contracts.DIAGNOSTIC_LIMITS.properties)) {
-            if (["__proto__", "constructor", "prototype"].includes(key)) {
-              result[key] = omit(`${path}/${pointer(key)}`, "unsafe_key");
-              continue;
-            }
-            remaining -= encoder.encode(key).length + 4;
-            result[key] = read(object2, key, `${path}/${pointer(key)}`, depth);
-          }
-          if (keys.length > import_telemetry_contracts.DIAGNOSTIC_LIMITS.properties)
-            result.$omittedProperties = omit(path, "property_limit", {
-              originalCount: keys.length
-            });
-          return result;
-        } catch {
-          return omit(path, "unreadable_object");
-        }
-      };
-      const read = (object2, key, path, depth) => {
-        if ((0, import_telemetry_contracts.isPrivateDiagnosticField)(key)) {
-          if (redactions.length < 1e3)
-            redactions.push({
-              path: path.slice(0, 4096),
-              reason: "credential_field"
-            });
-          return "[REDACTED]";
-        }
-        try {
-          const property = Object.getOwnPropertyDescriptor(object2, key);
-          if (property && "value" in property)
-            return visit(property.value, path, depth + 1);
-          if (key === "stack" && object2 instanceof Error && property?.get && property.get === nativeStackGetter)
-            return visit(nativeStack(object2, property.get), path, depth + 1);
-          return omit(
-            path,
-            property ? "accessor_not_evaluated" : "unavailable_property"
-          );
-        } catch {
-          return omit(path, "unreadable_property");
-        }
-      };
-      try {
-        const original = project ? project(error) : error;
-        if (project && original === null) return null;
-        const captured = visit(original, "#/data", 0);
-        const upstreamOmissions = (0, import_errors22.errorProperty)(original, "diagnosticOmissions");
-        if (Array.isArray(upstreamOmissions))
-          for (const note of upstreamOmissions.slice(0, 1e3)) {
-            const path = (0, import_errors22.errorProperty)(note, "path");
-            const reason = (0, import_errors22.errorProperty)(note, "reason");
-            if (typeof path === "string" && typeof reason === "string")
-              omissions.push({
-                path: (0, import_telemetry_contracts.redactDiagnosticText)(path).slice(0, 4096),
-                reason: (0, import_telemetry_contracts.redactDiagnosticText)(reason).slice(0, 128)
-              });
-          }
-        const data = captured && typeof captured === "object" && !Array.isArray(captured) ? captured : {
-          type: "Error",
-          message: typeof captured === "string" ? captured : "Execution reported a fault.",
-          value: captured
-        };
-        if (typeof data.message !== "string" && !("message" in data))
-          data.message = "Execution reported a fault.";
-        if (!("type" in data))
-          data.type = typeof data.name === "string" ? data.name : "Error";
-        const content = {
-          schemaVersion: 1,
-          data,
-          capture: {
-            status: omissions.length ? "partial" : "complete",
-            omissions,
-            redactions
-          }
-        };
-        if (encoder.encode(JSON.stringify(content)).length > import_telemetry_contracts.DIAGNOSTIC_LIMITS.bytes)
-          return {
-            schemaVersion: 1,
-            data: {
-              type: "Error",
-              message: "Diagnostic exceeded the capture budget."
-            },
-            capture: {
-              status: "partial",
-              redactions: [],
-              omissions: [{ path: "#/data", reason: "serialized_byte_limit" }]
-            }
-          };
-        return content;
-      } catch {
-        return {
-          schemaVersion: 1,
-          data: { type: "Error", message: "Diagnostic capture failed." },
-          capture: {
-            status: "failed",
-            redactions: [],
-            omissions: [{ path: "#/data", reason: "projection_or_capture_failed" }]
-          }
-        };
-      }
-    }
-    function exceptionDiagnostics(error, project) {
-      const content = captureDiagnosticContent(error, project);
-      return !content || content.capture.status === "failed" ? null : content.data;
-    }
-    function errorDiagnostics(error, project) {
-      const captured = exceptionDiagnostics(error, project);
-      const details = captured ? (0, import_telemetry_contracts2.summarizeDiagnostic)(captured) : null;
-      return details ? {
-        errorMessage: details.message.slice(0, 8192),
-        ...details.type ? { errorType: details.type.slice(0, 256) } : {}
-      } : {};
-    }
-    var import_node_crypto22 = require("crypto");
-    function emitWorkflowCall2(telemetry, type, payload) {
-      const base = telemetry?.correlation;
-      if (!telemetry?.reporter || !telemetry.environment || !telemetry.service || !base?.runId || !base.workflowId)
-        return;
+    var import_telemetry_contracts22 = require("@kortyx/telemetry-contracts");
+    var import_telemetry_contracts4 = require("@kortyx/telemetry-contracts");
+    function exceptionDiagnostics(error, project) {
+      const content = (0, import_telemetry_contracts4.captureDiagnosticContent)(error, project);
+      return !content || content.capture.status === "failed" ? null : content.data;
+    }
+    function errorDiagnostics(error, project) {
+      const captured = exceptionDiagnostics(error, project);
+      const details = captured ? (0, import_telemetry_contracts22.summarizeDiagnostic)(captured) : null;
+      return details ? {
+        errorMessage: details.message.slice(0, 8192),
+        ...details.type ? { errorType: details.type.slice(0, 256) } : {}
+      } : {};
+    }
+    var import_node_crypto22 = require("crypto");
+    function emitWorkflowCall2(telemetry, type, payload) {
+      const base = telemetry?.correlation;
+      if (!telemetry?.reporter || !telemetry.environment || !telemetry.service || !base?.runId || !base.workflowId)
+        return;
       try {
         const active = telemetry.trace?.getActiveContext?.();
         void Promise.resolve(
@@ -3681,7 +1615,7 @@ var require_dist2 = __commonJS({
             return result;
           } catch (error) {
             if (args.abortSignal?.aborted) observation.outcome = "cancelled";
-            else if (!(0, import_errors32.isControlFlowError)(error)) {
+            else if (!(0, import_errors22.isControlFlowError)(error)) {
               const outcome = classification(
                 args.tool,
                 error,
@@ -3816,11 +1750,11 @@ var require_dist2 = __commonJS({
     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");
+    var import_errors32 = require("@kortyx/core/errors");
     function assertModelFinish(result) {
       if (result.finishReason?.unified !== "content-filter") return;
       throw Object.assign(
-        new import_errors42.KortyxError("PROVIDER_REFUSAL", "The provider refused the request.", {
+        new import_errors32.KortyxError("PROVIDER_REFUSAL", "The provider refused the request.", {
           category: "provider",
           retryable: false,
           safeMessage: "The provider refused the request."
@@ -4884,7 +2818,7 @@ var require_dist2 = __commonJS({
         }
       };
     }
-    var import_errors52 = require("@kortyx/core/errors");
+    var import_errors42 = require("@kortyx/core/errors");
     var tryJsonParse = (value) => {
       try {
         return { ok: true, value: JSON.parse(value) };
@@ -4922,12 +2856,12 @@ var require_dist2 = __commonJS({
       }
       return text;
     };
-    var createTruncatedStructuredOutputError = (label, cause) => new import_errors52.ValidationError(
+    var createTruncatedStructuredOutputError = (label, cause) => new import_errors42.ValidationError(
       "OUTPUT_TRUNCATED",
       `${label} was truncated before producing valid structured output. The model stopped due to output length. Increase maxOutputTokens or simplify the requested output.`,
       cause
     );
-    var createInvalidStructuredOutputError = (label, cause) => new import_errors52.ValidationError(
+    var createInvalidStructuredOutputError = (label, cause) => new import_errors42.ValidationError(
       "INVALID_MODEL_JSON",
       `${label} did not produce valid structured output. The model returned text instead of the expected JSON payload. Check the output contract or outputSchema and provider structured-output settings.`,
       cause
@@ -4939,7 +2873,7 @@ var require_dist2 = __commonJS({
       try {
         return parseWithSchema(args.schema, candidate, args.label);
       } catch (error) {
-        if (!(error instanceof import_errors52.ValidationError)) throw error;
+        if (!(error instanceof import_errors42.ValidationError)) throw error;
         const failure = args.finishReason?.unified === "length" ? createTruncatedStructuredOutputError(args.label, error) : typeof candidate === "string" && !validJson ? createInvalidStructuredOutputError(args.label, error) : error;
         if (failure && typeof failure === "object")
           Object.assign(failure, {
@@ -4959,7 +2893,7 @@ var require_dist2 = __commonJS({
           if (typeof candidate === "string" && candidate.trim().length > 0) {
             throw createInvalidStructuredOutputError("useReason output");
           }
-          throw new import_errors52.ValidationError(
+          throw new import_errors42.ValidationError(
             "MODEL_OUTPUT_SCHEMA",
             "useReason first pass with interrupt must return a JSON object."
           );
@@ -4968,7 +2902,7 @@ var require_dist2 = __commonJS({
         let interruptRequired = true;
         if (mode === "optional") {
           if (candidate.decision !== "continue" && candidate.decision !== "interrupt") {
-            throw new import_errors52.ValidationError(
+            throw new import_errors42.ValidationError(
               "MODEL_OUTPUT_SCHEMA",
               'useReason optional interrupt first pass must include decision "continue" or "interrupt".'
             );
@@ -4981,7 +2915,7 @@ var require_dist2 = __commonJS({
               candidate.interrupt
             ].some((value) => value !== null && value !== void 0);
             if (hasUnexpectedRequest) {
-              throw new import_errors52.ValidationError(
+              throw new import_errors42.ValidationError(
                 "MODEL_OUTPUT_SCHEMA",
                 'useReason optional interrupt first pass with decision "continue" must not include an interrupt request.'
               );
@@ -5015,7 +2949,7 @@ var require_dist2 = __commonJS({
               "useReason output"
             );
           } catch (error) {
-            if (!(error instanceof import_errors52.ValidationError)) throw error;
+            if (!(error instanceof import_errors42.ValidationError)) throw error;
             if (args.finishReason?.unified === "length") {
               throw createTruncatedStructuredOutputError("useReason output", error);
             }
@@ -5024,7 +2958,7 @@ var require_dist2 = __commonJS({
         }
         const explicitDraft = typeof candidate.draftText === "string" && candidate.draftText.length > 0 ? candidate.draftText : typeof candidate.text === "string" && candidate.text.length > 0 ? candidate.text : void 0;
         if (!args.outputSchema && !explicitDraft) {
-          throw new import_errors52.ValidationError(
+          throw new import_errors42.ValidationError(
             "MODEL_OUTPUT_SCHEMA",
             "useReason first pass with interrupt requires `draftText` when outputSchema is not provided."
           );
@@ -5290,7 +3224,7 @@ ${tryStringify2(args.response)}`
       });
     };
     var import_core52 = require("@kortyx/core");
-    var import_errors62 = require("@kortyx/core/errors");
+    var import_errors52 = require("@kortyx/core/errors");
     var import_zod52 = require("zod");
     var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
     function schemaPath(schema, path) {
@@ -5526,7 +3460,7 @@ ${tryStringify2(args.response)}`
       const maxSteps = Math.max(1, useReasonArgs.toolExecution?.maxSteps ?? 3);
       const missingReturnCorrections = useReasonArgs.toolExecution?.missingReturnCorrections ?? 0;
       if (!Number.isSafeInteger(missingReturnCorrections) || missingReturnCorrections < 0)
-        throw new import_errors62.KortyxError(
+        throw new import_errors52.KortyxError(
           "INVALID_REASON_CORRECTION_POLICY",
           "Invalid missing return correction budget.",
           {
@@ -5587,7 +3521,7 @@ ${tryStringify2(args.response)}`
       let outputContractCorrections = checkpoint?.outputContractCorrections ?? 0;
       const correctionExhausted = () => {
         const message = `useReason could not complete output-contract correction within toolExecution.maxSteps (${maxSteps}). Select exactly one terminal return contract; multiple emit contracts are allowed. Increase maxSteps to allow correction and output generation.`;
-        return new import_errors62.KortyxError(
+        return new import_errors52.KortyxError(
           "REASON_OUTPUT_CONTRACT_CORRECTION_EXHAUSTED",
           message,
           {
@@ -5684,7 +3618,7 @@ ${tryStringify2(args.response)}`
           aggregatedWarnings = mergeWarnings(aggregatedWarnings, step.warnings);
           const toolCalls = step.toolCalls ?? [];
           if (missingReturnAttempts > 0 && toolCalls.some((call) => !outputByToolName.has(call.name)))
-            throw new import_errors62.KortyxError(
+            throw new import_errors52.KortyxError(
               "REASON_OUTPUT_CORRECTION_TOOL_DISALLOWED",
               "A return correction requested a non-output tool.",
               {
@@ -5727,7 +3661,7 @@ ${tryStringify2(args.response)}`
                 save();
                 continue;
               }
-              throw new import_errors62.KortyxError(
+              throw new import_errors52.KortyxError(
                 "REASON_TERMINAL_OUTPUT_MISSING",
                 "useReason outputs.return requires one terminal output contract call.",
                 {
@@ -5861,7 +3795,7 @@ ${tryStringify2(args.response)}`
                   );
                 if (steps.length >= maxSteps) {
                   const message = `useReason output generation requires another model pass within toolExecution.maxSteps (${maxSteps}). Increase maxSteps to allow outputs to use completed tool and interrupt results.`;
-                  throw new import_errors62.ProviderRequestError(message, {
+                  throw new import_errors52.ProviderRequestError(message, {
                     code: "REASON_OUTPUT_BUDGET_EXHAUSTED",
                     operation: "useReason",
                     safeMessage: message,
@@ -6056,7 +3990,7 @@ ${tryStringify2(args.response)}`
                   `useReason interrupt contract "${resolved.name}" request`
                 );
               } catch (error) {
-                if (!(error instanceof import_errors62.ValidationError)) throw error;
+                if (!(error instanceof import_errors52.ValidationError)) throw error;
                 const result3 = {
                   toolCallId: toolCall.id,
                   name: toolCall.name,
@@ -6266,12 +4200,12 @@ ${tryStringify2(args.response)}`
               }
             } catch (error) {
               (0, import_core52.throwIfExecutionAborted)(abortSignal);
-              if ((0, import_errors62.isControlFlowError)(error)) throw error;
+              if ((0, import_errors52.isControlFlowError)(error)) throw error;
               const result2 = {
                 toolCallId: toolCall.id,
                 name: tool.name,
-                content: (0, import_errors62.serializeFailure)(error).message,
-                failure: (0, import_errors62.serializeFailure)(error),
+                content: (0, import_errors52.serializeFailure)(error).message,
+                failure: (0, import_errors52.serializeFailure)(error),
                 isError: true
               };
               toolResults.push(result2);
@@ -6868,7 +4802,7 @@ ${tryStringify2(args.response)}`
       return [getValue(), setValue];
     }
     var import_core7 = require("@kortyx/core");
-    var import_errors72 = require("@kortyx/core/errors");
+    var import_errors62 = require("@kortyx/core/errors");
     var ParallelChildWaiting = class extends Error {
       name = "ParallelChildWaiting";
     };
@@ -6882,14 +4816,14 @@ ${tryStringify2(args.response)}`
         );
         this.results = results;
         this.name = "ParallelError";
-        this.failure = (0, import_errors72.serializeFailure)({
+        this.failure = (0, import_errors62.serializeFailure)({
           version: 1,
           code: this.code,
           category: "workflow",
           message: this.message,
           retryable: null,
           results: results.map(
-            (result) => result.status === "fulfilled" ? { status: "fulfilled" } : { status: "rejected", failure: (0, import_errors72.serializeFailure)(result.reason) }
+            (result) => result.status === "fulfilled" ? { status: "fulfilled" } : { status: "rejected", failure: (0, import_errors62.serializeFailure)(result.reason) }
           )
         });
       }
@@ -6897,7 +4831,7 @@ ${tryStringify2(args.response)}`
       code = "PARALLEL_FAILED";
       failure;
       toJSON() {
-        return (0, import_errors72.serializeFailure)(this);
+        return (0, import_errors62.serializeFailure)(this);
       }
     };
     function registerWorkflowTask(id3) {
@@ -7072,11 +5006,11 @@ ${tryStringify2(args.response)}`
     }
     var import_node_crypto62 = require("crypto");
     var import_core8 = require("@kortyx/core");
-    var import_errors82 = require("@kortyx/core/errors");
-    var WorkflowCallError = class extends import_errors82.KortyxError {
+    var import_errors72 = require("@kortyx/core/errors");
+    var WorkflowCallError = class extends import_errors72.KortyxError {
       constructor(workflow, message, cause, failure) {
-        const detail = (0, import_errors82.serializeFailure)(
-          failure ?? cause ?? new import_errors82.WorkflowContractError(message)
+        const detail = (0, import_errors72.serializeFailure)(
+          failure ?? cause ?? new import_errors72.WorkflowContractError(message)
         );
         super(detail.code, `Workflow '${workflow}': ${message}`, {
           ...detail,
@@ -7097,12 +5031,12 @@ ${tryStringify2(args.response)}`
         if (v === null || typeof v === "string" || typeof v === "boolean") return v;
         if (typeof v === "number" && Number.isFinite(v)) return v;
         if (typeof v !== "object" || !v || seen.has(v)) {
-          throw new import_errors82.WorkflowContractError(
+          throw new import_errors72.WorkflowContractError(
             "Workflow input and output must be JSON serializable."
           );
         }
         if (!Array.isArray(v) && Object.getPrototypeOf(v) !== Object.prototype) {
-          throw new import_errors82.WorkflowContractError(
+          throw new import_errors72.WorkflowContractError(
             "Workflow input and output must contain plain JSON objects."
           );
         }
@@ -7123,7 +5057,7 @@ ${tryStringify2(args.response)}`
         useWorkflow: (args) => {
           const workflow = workflows[args.workflow];
           if (!workflow || workflow.id !== args.workflow)
-            throw new import_errors82.WorkflowContractError(
+            throw new import_errors72.WorkflowContractError(
               "Workflow registry keys must match definition ids."
             );
           return useWorkflow({ ...args, workflow });
@@ -7149,23 +5083,23 @@ ${tryStringify2(args.response)}`
       (0, import_core8.throwIfExecutionAborted)(ctx.node.abortSignal);
       const service = ctx.node.callWorkflow;
       if (!service)
-        throw new import_errors82.WorkflowContractError(
+        throw new import_errors72.WorkflowContractError(
           "useWorkflow requires an agent workflow registry."
         );
       if (!args.id.trim())
-        throw new import_errors82.WorkflowContractError(
+        throw new import_errors72.WorkflowContractError(
           "useWorkflow requires a stable, nonempty id."
         );
       if (ctx.workflowCallActive && !task.group)
-        throw new import_errors82.WorkflowContractError(
+        throw new import_errors72.WorkflowContractError(
           "Concurrent workflow calls require parallel([...]); otherwise await each call."
         );
       if (ctx.workflowCallIds.has(args.id))
-        throw new import_errors82.WorkflowContractError(
+        throw new import_errors72.WorkflowContractError(
           `Duplicate workflow call id '${args.id}' in one node activation.`
         );
       if (ctx.workflowCallIds.size >= 64)
-        throw new import_errors82.WorkflowContractError(
+        throw new import_errors72.WorkflowContractError(
           "A node may call at most 64 child workflows per activation."
         );
       ctx.workflowCallIds.add(args.id);
@@ -7246,7 +5180,7 @@ ${tryStringify2(args.response)}`
             workflow,
             record2.error ?? "child failed",
             void 0,
-            record2.failure ?? (0, import_errors82.serializeFailure)(void 0)
+            record2.failure ?? (0, import_errors72.serializeFailure)(void 0)
           );
         if (task.group && record2.status === "interrupted" && record2.interrupts.at(-1)?.response === void 0)
           throw new ParallelChildWaiting();
@@ -7254,7 +5188,7 @@ ${tryStringify2(args.response)}`
           let outcome;
           try {
             if (Array.isArray(record2.snapshot) && record2.snapshot.length !== 1)
-              throw new import_errors82.WorkflowContractError("Invalid child workflow snapshot.");
+              throw new import_errors72.WorkflowContractError("Invalid child workflow snapshot.");
             const snapshot = Array.isArray(record2.snapshot) ? record2.snapshot[0] : record2.snapshot;
             report(
               snapshot ? "resumed" : "started",
@@ -7285,7 +5219,7 @@ ${tryStringify2(args.response)}`
               throw error;
             }
             record2.status = "failed";
-            record2.failure = (0, import_errors82.serializeFailure)(error);
+            record2.failure = (0, import_errors72.serializeFailure)(error);
             record2.error = record2.failure.message;
             report("failed", { error: "Child workflow failed" });
             throw new WorkflowCallError(
@@ -7349,6 +5283,7 @@ __export(index_exports, {
   ChatLifecycleHookError: () => ChatLifecycleHookError,
   EvalConfigurationError: () => EvalConfigurationError,
   EvalEvidencePolicySchema: () => EvalEvidencePolicySchema,
+  EvalExecutionSettingsSchema: () => EvalExecutionSettingsSchema,
   EvalIssueSchema: () => EvalIssueSchema,
   EvalJudgeIdentitySchema: () => EvalJudgeIdentitySchema,
   EvalJudgeUsageSchema: () => EvalJudgeUsageSchema,
@@ -7356,10 +5291,14 @@ __export(index_exports, {
   EvalProgressSchema: () => EvalProgressSchema,
   EvalRemoteRunRequestSchema: () => EvalRemoteRunRequestSchema,
   EvalRunResultSchema: () => EvalRunResultSchema,
+  EvalSettingsResponseSchema: () => EvalSettingsResponseSchema,
+  EvalSettingsSchema: () => EvalSettingsSchema,
   EvalSuiteSchema: () => EvalSuiteSchema,
+  EvalTerminationSchema: () => EvalTerminationSchema,
   EvalWireEventSchema: () => EvalWireEventSchema,
   EvaluationMetadataSchema: () => EvaluationMetadataSchema,
   ExecutionRequestError: () => ExecutionRequestError,
+  ResolvedEvalSettingsSchema: () => ResolvedEvalSettingsSchema,
   StudioEvalJudgeRequestSchema: () => StudioEvalJudgeRequestSchema,
   StudioEvalJudgeResponseSchema: () => StudioEvalJudgeResponseSchema,
   StudioEvalStartRequestSchema: () => StudioEvalStartRequestSchema,
@@ -7390,6 +5329,7 @@ __export(index_exports, {
   parseResumeMeta: () => parseResumeMeta,
   projectWorkflowTopology: () => projectWorkflowTopology,
   readRequestJson: () => readRequestJson,
+  resolveEvalSettings: () => resolveEvalSettings,
   streamChat: () => streamChat,
   streamChatFromRoute: () => streamChatFromRoute,
   transformGraphStreamForUI: () => transformGraphStreamForUI,
@@ -7445,6 +5385,7 @@ var ExecutionRequestError = class extends import_errors2.KortyxError {
 var import_node_stream = require("stream");
 var import_core2 = require("@kortyx/core");
 var import_errors4 = require("@kortyx/core/errors");
+var import_eval_attribution2 = require("@kortyx/core/eval-attribution");
 var import_internal = __toESM(require_internal());
 var import_runtime = require("@kortyx/runtime");
 var import_stream = require("@kortyx/stream");
@@ -7906,7 +5847,7 @@ var import_node = require("@kortyx/usage-telemetry/node");
 // package.json
 var package_default = {
   name: "@kortyx/agent",
-  version: "0.38.1",
+  version: "0.39.0",
   private: false,
   description: "Agent composition utilities for Kortyx.",
   keywords: [
@@ -7964,7 +5905,8 @@ var package_default = {
     "@langchain/langgraph": "catalog:",
     zod: "catalog:",
     "@kortyx/prompts": "workspace:*",
-    "@kortyx/usage-telemetry": "workspace:*"
+    "@kortyx/usage-telemetry": "workspace:*",
+    "@kortyx/telemetry-contracts": "workspace:*"
   },
   devDependencies: {
     "@kortyx/hooks": "workspace:*",
@@ -8170,7 +6112,8 @@ async function orchestrateGraphStream({
     isRecord3(config.context) ? { userId: config.context.userId, tenantId: config.context.tenantId } : {}
   );
   const telemetryConfig = isRecord3(config.telemetry) ? config.telemetry : {};
-  const errorChunk = (error, existingDiagnosticId) => {
+  const errorChunk = (error, existingDiagnosticId, original = true) => {
+    if (original) (0, import_eval_attribution2.observeEvalError)(error);
     const failure = (0, import_errors4.serializeFailure)(error);
     let diagnosticId = existingDiagnosticId;
     if (!diagnosticId) {
@@ -8457,7 +6400,8 @@ async function orchestrateGraphStream({
       write(
         errorChunk(
           outcomeError,
-          payload?.diagnosticId
+          payload?.diagnosticId,
+          false
         )
       );
       write({ type: "done" });
@@ -10195,7 +8139,7 @@ function createInterruptDiscovery(store) {
 
 // src/telemetry/workflow-call-branch.ts
 var import_node_crypto3 = require("crypto");
-var import_hooks = __toESM(require_dist2());
+var import_hooks = __toESM(require_dist());
 function restoreWorkflowCallBranch(requests, telemetry, sourceRunId) {
   const branchId = (0, import_node_crypto3.randomUUID)();
   const emitted = /* @__PURE__ */ new Set();
@@ -10888,7 +8832,8 @@ function createAgent(args) {
 // src/evals/contracts.ts
 var import_errors8 = require("@kortyx/core/errors");
 var import_browser2 = require("@kortyx/prompts/browser");
-var import_zod8 = require("zod");
+var import_telemetry_contracts = require("@kortyx/telemetry-contracts");
+var import_zod9 = require("zod");
 
 // src/evals/evidence-policy.ts
 var import_zod7 = require("zod");
@@ -10928,30 +8873,126 @@ var EvalEvidencePolicySchema = import_zod7.z.object({
   ]).optional()
 }).strict();
 
+// src/evals/settings.ts
+var import_zod8 = require("zod");
+var timeout = import_zod8.z.number().int().min(1).max(2147483647);
+var EvalSettingsSchema = import_zod8.z.object({
+  repetitions: import_zod8.z.number().int().min(1).max(20).optional(),
+  concurrency: import_zod8.z.number().int().min(1).max(20).optional(),
+  caseTimeoutMs: timeout.optional(),
+  runTimeoutMs: timeout.optional(),
+  judge: import_zod8.z.enum(["studio", "app"]).optional()
+}).strict();
+var EvalExecutionSettingsSchema = import_zod8.z.object({
+  defaults: EvalSettingsSchema.omit({ runTimeoutMs: true, judge: true }),
+  limits: import_zod8.z.object({
+    concurrency: import_zod8.z.number().int().positive().max(20).optional(),
+    caseTimeoutMs: timeout.optional()
+  }).strict(),
+  overrides: import_zod8.z.array(import_zod8.z.enum(["repetitions", "concurrency", "caseTimeoutMs"]))
+}).strict();
+var ResolvedEvalSettingsSchema = import_zod8.z.object({
+  values: EvalSettingsSchema.required(),
+  sources: import_zod8.z.record(
+    import_zod8.z.enum([
+      "repetitions",
+      "concurrency",
+      "caseTimeoutMs",
+      "runTimeoutMs",
+      "judge"
+    ]),
+    import_zod8.z.enum(["run", "studio", "sdk", "sdk-default", "studio-default"])
+  )
+}).strict();
+var EvalSettingsResponseSchema = import_zod8.z.object({
+  defaults: EvalSettingsSchema,
+  installation: EvalSettingsSchema,
+  maxRunTimeoutMs: timeout,
+  canEdit: import_zod8.z.boolean()
+});
+var EvalTerminationSchema = import_zod8.z.object({
+  code: import_zod8.z.enum([
+    "EVAL_RUN_TIMEOUT",
+    "EVAL_CANCELLED",
+    "EVAL_LEASE_LOST",
+    "EVAL_EXECUTION_UNKNOWN",
+    "EVAL_EXECUTOR_FAILED"
+  ]),
+  message: import_zod8.z.string(),
+  timeoutMs: timeout.optional(),
+  phase: import_zod8.z.string().optional(),
+  cleanup: import_zod8.z.enum(["signalled", "unknown"]).optional(),
+  diagnosticId: import_zod8.z.string().uuid().optional()
+}).strict();
+function resolveEvalSettings(overrides = {}, studio = {}, execution, installation = {}, maxRunTimeoutMs = 2147483647) {
+  const values = {
+    repetitions: 1,
+    concurrency: 1,
+    caseTimeoutMs: 6e4,
+    runTimeoutMs: 30 * 6e4,
+    judge: "studio"
+  };
+  const sources = {
+    repetitions: "sdk-default",
+    concurrency: "sdk-default",
+    caseTimeoutMs: "sdk-default",
+    runTimeoutMs: "studio-default",
+    judge: "studio-default"
+  };
+  for (const [input, source] of [
+    [execution?.defaults ?? {}, "sdk"],
+    [installation, "studio"],
+    [studio, "studio"],
+    [overrides, "run"]
+  ]) {
+    const parsed = EvalSettingsSchema.parse(input);
+    for (const key of Object.keys(parsed)) {
+      if (parsed[key] !== void 0) {
+        Object.assign(values, { [key]: parsed[key] });
+        sources[key] = source;
+      }
+    }
+  }
+  if (values.runTimeoutMs > maxRunTimeoutMs)
+    throw new Error(
+      `Evaluation timeout exceeds the administrator maximum of ${maxRunTimeoutMs} ms.`
+    );
+  for (const key of ["concurrency", "caseTimeoutMs"]) {
+    const max = execution?.limits[key];
+    if (max !== void 0 && values[key] > max)
+      throw new Error(`${key} exceeds the application maximum of ${max}.`);
+  }
+  if (!execution?.overrides.includes("caseTimeoutMs") && (overrides.caseTimeoutMs !== void 0 || studio.caseTimeoutMs !== void 0 || installation.caseTimeoutMs !== void 0))
+    throw new Error(
+      "Update the consumer SDK to support case timeout overrides."
+    );
+  return { values, sources };
+}
+
 // src/evals/contracts.ts
-var id2 = import_zod8.z.string().trim().min(1).max(256);
-var failureDescriptor = import_zod8.z.custom(import_errors8.isFailureDescriptor).transform(
+var id2 = import_zod9.z.string().trim().min(1).max(256);
+var failureDescriptor = import_zod9.z.custom(import_errors8.isFailureDescriptor).transform(
   (value) => JSON.parse(JSON.stringify((0, import_errors8.serializeFailure)(value)))
 );
-var handler = import_zod8.z.object({ using: id2, params: import_zod8.z.json().optional() }).strict();
-var EvalResumeResponseSchema = import_zod8.z.discriminatedUnion("type", [
-  import_zod8.z.object({ type: import_zod8.z.literal("text"), text: import_zod8.z.string() }).strict(),
-  import_zod8.z.object({ type: import_zod8.z.literal("select"), ids: import_zod8.z.array(import_zod8.z.string()) }).strict(),
-  import_zod8.z.object({ type: import_zod8.z.literal("value"), value: import_zod8.z.json() }).strict(),
-  import_zod8.z.object({ type: import_zod8.z.literal("cancel") }).strict()
+var handler = import_zod9.z.object({ using: id2, params: import_zod9.z.json().optional() }).strict();
+var EvalResumeResponseSchema = import_zod9.z.discriminatedUnion("type", [
+  import_zod9.z.object({ type: import_zod9.z.literal("text"), text: import_zod9.z.string() }).strict(),
+  import_zod9.z.object({ type: import_zod9.z.literal("select"), ids: import_zod9.z.array(import_zod9.z.string()) }).strict(),
+  import_zod9.z.object({ type: import_zod9.z.literal("value"), value: import_zod9.z.json() }).strict(),
+  import_zod9.z.object({ type: import_zod9.z.literal("cancel") }).strict()
 ]);
-var expectation = import_zod8.z.object({
-  type: import_zod8.z.enum(["answer", "interrupt"]),
+var expectation = import_zod9.z.object({
+  type: import_zod9.z.enum(["answer", "interrupt"]),
   schemaId: id2.optional(),
   schemaVersion: id2.optional(),
-  outputs: import_zod8.z.array(import_zod8.z.object({ schemaId: id2, schemaVersion: id2.optional() }).strict()).optional(),
-  criteria: import_zod8.z.array(
-    import_zod8.z.union([
-      import_zod8.z.string().trim().min(1),
-      import_zod8.z.object({ id: id2, text: import_zod8.z.string().trim().min(1) }).strict()
+  outputs: import_zod9.z.array(import_zod9.z.object({ schemaId: id2, schemaVersion: id2.optional() }).strict()).optional(),
+  criteria: import_zod9.z.array(
+    import_zod9.z.union([
+      import_zod9.z.string().trim().min(1),
+      import_zod9.z.object({ id: id2, text: import_zod9.z.string().trim().min(1) }).strict()
     ])
   ).optional(),
-  reference: import_zod8.z.json().optional()
+  reference: import_zod9.z.json().optional()
 }).strict().superRefine((value, ctx) => {
   if (value.type === "answer" && (value.schemaId || value.schemaVersion))
     ctx.addIssue({
@@ -10967,21 +9008,21 @@ var expectation = import_zod8.z.object({
       message: "Criterion IDs must be unique within a step."
     });
 });
-var EvalSuiteSchema = import_zod8.z.object({
+var EvalSuiteSchema = import_zod9.z.object({
   evidence: EvalEvidencePolicySchema.optional(),
   id: id2,
-  name: import_zod8.z.string().optional(),
-  cases: import_zod8.z.array(
-    import_zod8.z.object({
+  name: import_zod9.z.string().optional(),
+  cases: import_zod9.z.array(
+    import_zod9.z.object({
       id: id2,
-      name: import_zod8.z.string().optional(),
-      params: import_zod8.z.json().optional(),
+      name: import_zod9.z.string().optional(),
+      params: import_zod9.z.json().optional(),
       workflowId: id2.optional(),
-      steps: import_zod8.z.array(
-        import_zod8.z.union([
-          import_zod8.z.object({ message: import_zod8.z.string().min(1), expect: expectation }).strict(),
-          import_zod8.z.object({
-            resume: import_zod8.z.union([EvalResumeResponseSchema, handler]),
+      steps: import_zod9.z.array(
+        import_zod9.z.union([
+          import_zod9.z.object({ message: import_zod9.z.string().min(1), expect: expectation }).strict(),
+          import_zod9.z.object({
+            resume: import_zod9.z.union([EvalResumeResponseSchema, handler]),
             expect: expectation
           }).strict()
         ])
@@ -10989,44 +9030,44 @@ var EvalSuiteSchema = import_zod8.z.object({
     }).strict()
   ).min(1)
 }).strict();
-var EvalVerdictSchema = import_zod8.z.object({
-  passed: import_zod8.z.boolean(),
-  reason: import_zod8.z.string().trim().min(1),
-  evidence: import_zod8.z.array(import_zod8.z.string().min(1))
+var EvalVerdictSchema = import_zod9.z.object({
+  passed: import_zod9.z.boolean(),
+  reason: import_zod9.z.string().trim().min(1),
+  evidence: import_zod9.z.array(import_zod9.z.string().min(1))
 }).strict();
-var EvalObservationSchema = import_zod8.z.object({
+var EvalObservationSchema = import_zod9.z.object({
   failure: failureDescriptor.optional(),
-  diagnosticId: import_zod8.z.uuid().optional(),
-  promptUsage: import_zod8.z.array(
-    import_zod8.z.object({
-      id: import_zod8.z.string(),
-      version: import_zod8.z.number().int().positive(),
-      hash: import_zod8.z.string().regex(/^[a-f0-9]{64}$/),
-      environment: import_zod8.z.string(),
-      snapshotRevision: import_zod8.z.string(),
-      model: import_zod8.z.string().optional()
+  diagnosticId: import_zod9.z.uuid().optional(),
+  promptUsage: import_zod9.z.array(
+    import_zod9.z.object({
+      id: import_zod9.z.string(),
+      version: import_zod9.z.number().int().positive(),
+      hash: import_zod9.z.string().regex(/^[a-f0-9]{64}$/),
+      environment: import_zod9.z.string(),
+      snapshotRevision: import_zod9.z.string(),
+      model: import_zod9.z.string().optional()
     }).strict()
   ).optional(),
-  type: import_zod8.z.enum(["answer", "interrupt", "error", "cancelled"]),
-  text: import_zod8.z.string(),
-  structured: import_zod8.z.array(import_zod8.z.json()),
-  events: import_zod8.z.array(import_zod8.z.json()).optional(),
-  runId: import_zod8.z.string().optional(),
-  checkpointId: import_zod8.z.string().optional(),
-  interrupt: import_zod8.z.object({
-    requestId: import_zod8.z.string(),
-    kind: import_zod8.z.enum(["text", "choice", "multi-choice", "custom"]),
-    question: import_zod8.z.string().optional(),
-    schemaId: import_zod8.z.string().optional(),
-    schemaVersion: import_zod8.z.string().optional(),
-    options: import_zod8.z.array(
-      import_zod8.z.object({
-        id: import_zod8.z.string(),
-        label: import_zod8.z.string(),
-        description: import_zod8.z.string().optional()
+  type: import_zod9.z.enum(["answer", "interrupt", "error", "cancelled"]),
+  text: import_zod9.z.string(),
+  structured: import_zod9.z.array(import_zod9.z.json()),
+  events: import_zod9.z.array(import_zod9.z.json()).optional(),
+  runId: import_zod9.z.string().optional(),
+  checkpointId: import_zod9.z.string().optional(),
+  interrupt: import_zod9.z.object({
+    requestId: import_zod9.z.string(),
+    kind: import_zod9.z.enum(["text", "choice", "multi-choice", "custom"]),
+    question: import_zod9.z.string().optional(),
+    schemaId: import_zod9.z.string().optional(),
+    schemaVersion: import_zod9.z.string().optional(),
+    options: import_zod9.z.array(
+      import_zod9.z.object({
+        id: import_zod9.z.string(),
+        label: import_zod9.z.string(),
+        description: import_zod9.z.string().optional()
       }).strict()
     ),
-    request: import_zod8.z.json().optional()
+    request: import_zod9.z.json().optional()
   }).strict().optional()
 }).strict().superRefine((value, ctx) => {
   if (value.type === "interrupt" !== Boolean(value.interrupt))
@@ -11035,11 +9076,16 @@ var EvalObservationSchema = import_zod8.z.object({
       message: "Interrupt observations require exactly one interrupt."
     });
 });
-var status = import_zod8.z.enum(["passed", "failed", "error", "cancelled", "ungraded"]);
-var EvalIssueSchema = import_zod8.z.object({
+var status = import_zod9.z.enum(["passed", "failed", "error", "cancelled", "ungraded"]);
+var EvalIssueSchema = import_zod9.z.object({
+  exception: import_telemetry_contracts.DiagnosticContentSchema.optional(),
+  details: import_zod9.z.object({
+    timeoutMs: import_zod9.z.number().positive().optional(),
+    httpStatus: import_zod9.z.number().int().min(100).max(599).optional()
+  }).strict().optional(),
   failure: failureDescriptor.optional(),
-  diagnosticId: import_zod8.z.uuid().optional(),
-  phase: import_zod8.z.enum([
+  diagnosticId: import_zod9.z.uuid().optional(),
+  phase: import_zod9.z.enum([
     "params",
     "setup",
     "execute",
@@ -11050,196 +9096,200 @@ var EvalIssueSchema = import_zod8.z.object({
     "cleanup",
     "reporting"
   ]),
-  code: import_zod8.z.string(),
-  message: import_zod8.z.string()
+  code: import_zod9.z.string(),
+  message: import_zod9.z.string()
 }).strict();
 var issue = EvalIssueSchema;
-var EvalJudgeUsageSchema = import_zod8.z.object({
-  provider: import_zod8.z.string().min(1),
-  model: import_zod8.z.string().min(1),
-  occurredAt: import_zod8.z.iso.datetime(),
-  usage: import_zod8.z.object({
-    input: import_zod8.z.number().finite().nonnegative().optional(),
-    output: import_zod8.z.number().finite().nonnegative().optional(),
-    total: import_zod8.z.number().finite().nonnegative().optional(),
-    reasoning: import_zod8.z.number().finite().nonnegative().optional(),
-    cacheRead: import_zod8.z.number().finite().nonnegative().optional(),
-    cacheWrite: import_zod8.z.number().finite().nonnegative().optional(),
-    cacheWrite1h: import_zod8.z.number().finite().nonnegative().optional(),
-    outputIncludesReasoning: import_zod8.z.boolean().optional(),
-    inputIncludesCacheRead: import_zod8.z.boolean().optional(),
-    inputIncludesCacheWrite: import_zod8.z.boolean().optional()
+var EvalJudgeUsageSchema = import_zod9.z.object({
+  provider: import_zod9.z.string().min(1),
+  model: import_zod9.z.string().min(1),
+  occurredAt: import_zod9.z.iso.datetime(),
+  usage: import_zod9.z.object({
+    input: import_zod9.z.number().finite().nonnegative().optional(),
+    output: import_zod9.z.number().finite().nonnegative().optional(),
+    total: import_zod9.z.number().finite().nonnegative().optional(),
+    reasoning: import_zod9.z.number().finite().nonnegative().optional(),
+    cacheRead: import_zod9.z.number().finite().nonnegative().optional(),
+    cacheWrite: import_zod9.z.number().finite().nonnegative().optional(),
+    cacheWrite1h: import_zod9.z.number().finite().nonnegative().optional(),
+    outputIncludesReasoning: import_zod9.z.boolean().optional(),
+    inputIncludesCacheRead: import_zod9.z.boolean().optional(),
+    inputIncludesCacheWrite: import_zod9.z.boolean().optional()
   }).strict().optional(),
-  pricingContext: import_zod8.z.object({
-    serviceTier: import_zod8.z.string().min(1).max(100).optional(),
-    inferenceGeo: import_zod8.z.string().min(1).max(100).optional(),
-    speed: import_zod8.z.string().min(1).max(100).optional()
+  pricingContext: import_zod9.z.object({
+    serviceTier: import_zod9.z.string().min(1).max(100).optional(),
+    inferenceGeo: import_zod9.z.string().min(1).max(100).optional(),
+    speed: import_zod9.z.string().min(1).max(100).optional()
   }).strict().optional(),
-  pricing: import_zod8.z.object({
-    source: import_zod8.z.literal("provider"),
-    currency: import_zod8.z.literal("USD"),
-    actualCostMicros: import_zod8.z.number().int().nonnegative().safe()
+  pricing: import_zod9.z.object({
+    source: import_zod9.z.literal("provider"),
+    currency: import_zod9.z.literal("USD"),
+    actualCostMicros: import_zod9.z.number().int().nonnegative().safe()
   }).strict().optional()
 }).strict();
-var EvalStepResultSchema = import_zod8.z.object({
-  evidence: import_zod8.z.object({
-    version: import_zod8.z.literal("compact-v1"),
-    history: import_zod8.z.boolean(),
+var EvalStepResultSchema = import_zod9.z.object({
+  evidence: import_zod9.z.object({
+    version: import_zod9.z.literal("compact-v1"),
+    history: import_zod9.z.boolean(),
     observation: EvalObservationSchema
   }).strict().optional(),
-  index: import_zod8.z.number().int().nonnegative(),
-  input: import_zod8.z.union([
-    import_zod8.z.object({ message: import_zod8.z.string() }).strict(),
-    import_zod8.z.object({ resume: EvalResumeResponseSchema }).strict()
+  index: import_zod9.z.number().int().nonnegative(),
+  input: import_zod9.z.union([
+    import_zod9.z.object({ message: import_zod9.z.string() }).strict(),
+    import_zod9.z.object({ resume: EvalResumeResponseSchema }).strict()
   ]),
   expectation,
   observation: EvalObservationSchema,
-  reference: import_zod8.z.json().optional(),
+  reference: import_zod9.z.json().optional(),
   status,
-  reason: import_zod8.z.string().optional(),
-  judgeCalls: import_zod8.z.number().int().nonnegative().optional(),
-  judgeUsage: import_zod8.z.array(EvalJudgeUsageSchema).optional(),
-  criteria: import_zod8.z.array(
-    EvalVerdictSchema.extend({ id: import_zod8.z.string(), text: import_zod8.z.string() })
+  reason: import_zod9.z.string().optional(),
+  judgeCalls: import_zod9.z.number().int().nonnegative().optional(),
+  judgeUsage: import_zod9.z.array(EvalJudgeUsageSchema).optional(),
+  criteria: import_zod9.z.array(
+    EvalVerdictSchema.extend({ id: import_zod9.z.string(), text: import_zod9.z.string() })
   )
 }).strict();
-var runtimeExecution = import_zod8.z.object({ sessionId: import_zod8.z.string().min(1), runId: import_zod8.z.string().min(1) }).strict();
-var EvalCaseResultSchema = import_zod8.z.object({
+var runtimeExecution = import_zod9.z.object({ sessionId: import_zod9.z.string().min(1), runId: import_zod9.z.string().min(1) }).strict();
+var EvalCaseResultSchema = import_zod9.z.object({
   verification: EvalVerdictSchema.optional(),
-  phaseDurationsMs: import_zod8.z.partialRecord(issue.shape.phase, import_zod8.z.number().finite().nonnegative()).optional(),
+  phaseDurationsMs: import_zod9.z.partialRecord(issue.shape.phase, import_zod9.z.number().finite().nonnegative()).optional(),
   caseId: id2,
-  repetition: import_zod8.z.number().int().positive(),
-  attemptId: import_zod8.z.uuid().optional(),
-  runtimeExecutions: import_zod8.z.array(runtimeExecution).optional(),
-  sessionId: import_zod8.z.string(),
+  repetition: import_zod9.z.number().int().positive(),
+  attemptId: import_zod9.z.uuid().optional(),
+  runtimeExecutions: import_zod9.z.array(runtimeExecution).optional(),
+  sessionId: import_zod9.z.string(),
   status,
-  durationMs: import_zod8.z.number().nonnegative(),
-  steps: import_zod8.z.array(EvalStepResultSchema),
-  errors: import_zod8.z.array(issue)
+  durationMs: import_zod9.z.number().nonnegative(),
+  steps: import_zod9.z.array(EvalStepResultSchema),
+  errors: import_zod9.z.array(issue)
 }).strict();
-var EvalJudgeIdentitySchema = import_zod8.z.object({
+var EvalJudgeIdentitySchema = import_zod9.z.object({
   id: id2,
   version: id2,
-  location: import_zod8.z.enum(["app", "studio"]).optional()
+  location: import_zod9.z.enum(["app", "studio"]).optional()
 }).strict();
 var judge = EvalJudgeIdentitySchema;
-var StudioEvalJudgeRequestSchema = import_zod8.z.object({
+var StudioEvalJudgeRequestSchema = import_zod9.z.object({
   environment: id2,
   judge: EvalJudgeIdentitySchema,
-  criterion: import_zod8.z.object({ id: id2, text: import_zod8.z.string().trim().min(1).max(16384) }).strict(),
+  criterion: import_zod9.z.object({ id: id2, text: import_zod9.z.string().trim().min(1).max(16384) }).strict(),
   input: EvalStepResultSchema.shape.input,
   observation: EvalObservationSchema,
-  reference: import_zod8.z.json().optional(),
-  conversation: import_zod8.z.array(EvalStepResultSchema).max(100)
+  reference: import_zod9.z.json().optional(),
+  conversation: import_zod9.z.array(EvalStepResultSchema).max(100)
 }).strict();
-var StudioEvalJudgeResponseSchema = import_zod8.z.object({
+var StudioEvalJudgeResponseSchema = import_zod9.z.object({
   judge: EvalJudgeIdentitySchema,
   verdict: EvalVerdictSchema,
-  usage: import_zod8.z.array(EvalJudgeUsageSchema).optional()
+  usage: import_zod9.z.array(EvalJudgeUsageSchema).optional()
 }).strict();
-var EvalRunResultSchema = import_zod8.z.object({
-  id: import_zod8.z.uuid(),
+var EvalRunResultSchema = import_zod9.z.object({
+  id: import_zod9.z.uuid(),
   suiteId: id2,
-  suiteRevision: import_zod8.z.string().regex(/^[a-f0-9]{64}$/),
+  suiteRevision: import_zod9.z.string().regex(/^[a-f0-9]{64}$/),
   suite: EvalSuiteSchema,
   judge: judge.optional(),
-  startedAt: import_zod8.z.iso.datetime(),
-  durationMs: import_zod8.z.number().nonnegative(),
+  startedAt: import_zod9.z.iso.datetime(),
+  durationMs: import_zod9.z.number().nonnegative(),
   status,
-  counts: import_zod8.z.object({
-    passed: import_zod8.z.number().int().nonnegative(),
-    failed: import_zod8.z.number().int().nonnegative(),
-    error: import_zod8.z.number().int().nonnegative(),
-    cancelled: import_zod8.z.number().int().nonnegative(),
-    ungraded: import_zod8.z.number().int().nonnegative().optional()
+  counts: import_zod9.z.object({
+    passed: import_zod9.z.number().int().nonnegative(),
+    failed: import_zod9.z.number().int().nonnegative(),
+    error: import_zod9.z.number().int().nonnegative(),
+    cancelled: import_zod9.z.number().int().nonnegative(),
+    ungraded: import_zod9.z.number().int().nonnegative().optional()
   }).strict(),
-  cases: import_zod8.z.array(EvalCaseResultSchema),
-  errors: import_zod8.z.array(issue)
+  cases: import_zod9.z.array(EvalCaseResultSchema),
+  errors: import_zod9.z.array(issue)
 }).strict();
-var EvalManifestSchema = import_zod8.z.object({
-  schemaVersion: import_zod8.z.literal(1),
-  studioJudging: import_zod8.z.literal(true).optional(),
-  promptContracts: import_zod8.z.array(
-    import_zod8.z.object({
-      id: import_zod8.z.string(),
-      format: import_zod8.z.enum(["system-user", "chat"]),
-      variablesSchema: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()),
-      configSchema: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown())
+var EvalManifestSchema = import_zod9.z.object({
+  execution: EvalExecutionSettingsSchema.optional(),
+  schemaVersion: import_zod9.z.literal(1),
+  studioJudging: import_zod9.z.literal(true).optional(),
+  promptContracts: import_zod9.z.array(
+    import_zod9.z.object({
+      id: import_zod9.z.string(),
+      format: import_zod9.z.enum(["system-user", "chat"]),
+      variablesSchema: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()),
+      configSchema: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown())
     }).strict()
   ).optional(),
-  attemptScheduling: import_zod8.z.literal(true).optional(),
-  suites: import_zod8.z.array(EvalSuiteSchema),
-  responders: import_zod8.z.array(
-    import_zod8.z.object({
+  attemptScheduling: import_zod9.z.literal(true).optional(),
+  suites: import_zod9.z.array(EvalSuiteSchema),
+  responders: import_zod9.z.array(
+    import_zod9.z.object({
       name: id2,
       schemaId: id2.optional(),
       schemaVersion: id2.optional()
     }).strict()
   ),
-  references: import_zod8.z.array(id2),
-  paramsSchema: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).optional(),
+  references: import_zod9.z.array(id2),
+  paramsSchema: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).optional(),
   judge: judge.optional()
 }).strict();
-var EvalProgressSchema = import_zod8.z.discriminatedUnion("type", [
-  import_zod8.z.object({
-    type: import_zod8.z.literal("case-dispatch"),
+var EvalProgressSchema = import_zod9.z.discriminatedUnion("type", [
+  import_zod9.z.object({
+    type: import_zod9.z.literal("case-dispatch"),
     caseId: id2,
-    repetition: import_zod8.z.number().int().positive(),
-    status: import_zod8.z.enum(["queued", "retrying", "reconnecting"]),
-    retryAt: import_zod8.z.iso.datetime().optional(),
-    httpStatus: import_zod8.z.number().int().min(100).max(599).optional(),
-    executionId: import_zod8.z.uuid().optional(),
-    generation: import_zod8.z.uuid().optional()
+    repetition: import_zod9.z.number().int().positive(),
+    status: import_zod9.z.enum(["queued", "retrying", "reconnecting"]),
+    retryAt: import_zod9.z.iso.datetime().optional(),
+    httpStatus: import_zod9.z.number().int().min(100).max(599).optional(),
+    executionId: import_zod9.z.uuid().optional(),
+    generation: import_zod9.z.uuid().optional()
   }).strict(),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("case-runtime-associated"),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("case-runtime-associated"),
     caseId: id2,
-    repetition: import_zod8.z.number().int().positive(),
-    attemptId: import_zod8.z.uuid(),
+    repetition: import_zod9.z.number().int().positive(),
+    attemptId: import_zod9.z.uuid(),
     execution: runtimeExecution
   }).strict(),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("run-started"),
-    caseIds: import_zod8.z.array(id2).min(1),
-    repetitions: import_zod8.z.number().int().positive(),
-    concurrency: import_zod8.z.number().int().positive()
+  import_zod9.z.object({
+    type: import_zod9.z.literal("run-started"),
+    caseIds: import_zod9.z.array(id2).min(1),
+    repetitions: import_zod9.z.number().int().positive(),
+    concurrency: import_zod9.z.number().int().positive()
   }).strict(),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("case-progress"),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("case-progress"),
     caseId: id2,
-    repetition: import_zod8.z.number().int().positive(),
+    repetition: import_zod9.z.number().int().positive(),
     phase: issue.shape.phase,
-    stepIndex: import_zod8.z.number().int().nonnegative().optional()
+    stepIndex: import_zod9.z.number().int().nonnegative().optional()
   }).strict(),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("case-started"),
-    attemptId: import_zod8.z.uuid().optional(),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("case-started"),
+    attemptId: import_zod9.z.uuid().optional(),
     caseId: id2,
-    repetition: import_zod8.z.number().int().positive(),
-    sessionId: import_zod8.z.string()
+    repetition: import_zod9.z.number().int().positive(),
+    sessionId: import_zod9.z.string()
   }).strict(),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("step-completed"),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("step-completed"),
     caseId: id2,
-    repetition: import_zod8.z.number().int().positive(),
+    repetition: import_zod9.z.number().int().positive(),
     step: EvalStepResultSchema
   }).strict(),
-  import_zod8.z.object({ type: import_zod8.z.literal("case-completed"), result: EvalCaseResultSchema }).strict()
+  import_zod9.z.object({ type: import_zod9.z.literal("case-completed"), result: EvalCaseResultSchema }).strict()
 ]);
-var EvalRemoteRunRequestSchema = import_zod8.z.object({
+var EvalRemoteRunRequestSchema = import_zod9.z.object({
   promptSnapshot: import_browser2.PromptSnapshotSchema.optional(),
-  promptGroupName: import_zod8.z.string().optional(),
+  promptGroupName: import_zod9.z.string().optional(),
+  caseTimeoutMs: EvalSettingsSchema.shape.caseTimeoutMs,
+  runTimeoutMs: EvalSettingsSchema.shape.runTimeoutMs,
+  resolvedSettings: ResolvedEvalSettingsSchema.optional(),
   suiteId: id2,
-  suiteRevision: import_zod8.z.string().regex(/^[a-f0-9]{64}$/),
-  grading: import_zod8.z.enum(["app", "studio"]).optional(),
+  suiteRevision: import_zod9.z.string().regex(/^[a-f0-9]{64}$/),
+  grading: import_zod9.z.enum(["app", "studio"]).optional(),
   judge: EvalJudgeIdentitySchema.optional(),
-  caseIds: import_zod8.z.array(id2).min(1).max(100).optional(),
-  repetitions: import_zod8.z.number().int().min(1).max(20).default(1),
-  concurrency: import_zod8.z.number().int().min(1).max(20).default(1),
-  attempt: import_zod8.z.object({
+  caseIds: import_zod9.z.array(id2).min(1).max(100).optional(),
+  repetitions: import_zod9.z.number().int().min(1).max(20).default(1),
+  concurrency: import_zod9.z.number().int().min(1).max(20).default(1),
+  attempt: import_zod9.z.object({
     caseId: id2,
-    repetition: import_zod8.z.number().int().min(1).max(20),
-    evaluationId: import_zod8.z.uuid()
+    repetition: import_zod9.z.number().int().min(1).max(20),
+    evaluationId: import_zod9.z.uuid()
   }).strict().optional()
 }).strict();
 var StudioEvalStartRequestSchema = EvalRemoteRunRequestSchema.omit({
@@ -11249,39 +9299,42 @@ var StudioEvalStartRequestSchema = EvalRemoteRunRequestSchema.omit({
   promptGroupName: true,
   attempt: true
 }).extend({
-  promptSelection: import_zod8.z.discriminatedUnion("type", [
-    import_zod8.z.object({ type: import_zod8.z.literal("live") }).strict(),
-    import_zod8.z.object({
-      type: import_zod8.z.literal("single"),
-      id: import_zod8.z.string(),
-      version: import_zod8.z.number().int().positive()
+  promptSelection: import_zod9.z.discriminatedUnion("type", [
+    import_zod9.z.object({ type: import_zod9.z.literal("live") }).strict(),
+    import_zod9.z.object({
+      type: import_zod9.z.literal("single"),
+      id: import_zod9.z.string(),
+      version: import_zod9.z.number().int().positive()
     }).strict(),
-    import_zod8.z.object({ type: import_zod8.z.literal("group"), groupId: import_zod8.z.uuid() }).strict()
+    import_zod9.z.object({ type: import_zod9.z.literal("group"), groupId: import_zod9.z.uuid() }).strict()
   ]).optional(),
-  targetId: import_zod8.z.string().min(1).max(128),
-  judge: import_zod8.z.enum(["studio", "app"]).default("studio")
+  targetId: import_zod9.z.string().min(1).max(128),
+  judge: import_zod9.z.enum(["studio", "app"]).optional(),
+  repetitions: EvalSettingsSchema.shape.repetitions,
+  concurrency: EvalSettingsSchema.shape.concurrency
 });
-var EvalWireEventSchema = import_zod8.z.discriminatedUnion("type", [
-  import_zod8.z.object({
-    type: import_zod8.z.literal("execution-status"),
-    state: import_zod8.z.enum(["queued", "running", "completed", "cancelled", "unknown"])
+var EvalWireEventSchema = import_zod9.z.discriminatedUnion("type", [
+  import_zod9.z.object({
+    type: import_zod9.z.literal("execution-status"),
+    state: import_zod9.z.enum(["queued", "running", "completed", "cancelled", "unknown"])
   }).strict(),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("progress"),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("progress"),
     event: EvalProgressSchema,
-    sequence: import_zod8.z.number().int().positive().optional()
+    sequence: import_zod9.z.number().int().positive().optional()
   }).strict(),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("result"),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("result"),
     result: EvalRunResultSchema,
-    sequence: import_zod8.z.number().int().positive().optional()
+    sequence: import_zod9.z.number().int().positive().optional()
   }).strict(),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("error"),
-    message: import_zod8.z.string(),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("error"),
+    exception: import_telemetry_contracts.DiagnosticContentSchema.optional(),
+    message: import_zod9.z.string(),
     failure: failureDescriptor.optional(),
-    diagnosticId: import_zod8.z.uuid().optional(),
-    sequence: import_zod8.z.number().int().positive().optional()
+    diagnosticId: import_zod9.z.uuid().optional(),
+    sequence: import_zod9.z.number().int().positive().optional()
   }).strict()
 ]);
 var EvalConfigurationError = class extends Error {
@@ -11311,13 +9364,14 @@ 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_eval_attribution3 = require("@kortyx/core/eval-attribution");
 var import_usage_telemetry = require("@kortyx/usage-telemetry");
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 
 // src/evals/errors.ts
 var import_errors9 = require("@kortyx/core/errors");
-var import_zod9 = require("zod");
+var import_telemetry_contracts2 = require("@kortyx/telemetry-contracts");
+var import_zod10 = require("zod");
 var messages = {
   params: "Case parameters failed validation.",
   setup: "Case setup failed.",
@@ -11333,6 +9387,9 @@ function createEvalIssue(phase, error, options = {}) {
   const control = (0, import_errors9.isControlFlowError)(error);
   const declared = !control && ((0, import_errors9.isFailureDescriptor)(error) || (0, import_errors9.isFailureDescriptor)((0, import_errors9.errorProperty)(error, "failure")));
   const failure = (0, import_errors9.serializeFailure)(control ? void 0 : error);
+  const exception = !control && error !== void 0 ? (0, import_telemetry_contracts2.captureDiagnosticContent)(error) : null;
+  const rawMessage = typeof error === "string" ? error : (0, import_errors9.errorProperty)(error, "message");
+  const originalMessage = typeof rawMessage === "string" ? (0, import_telemetry_contracts2.redactDiagnosticText)(rawMessage) : void 0;
   let diagnosticId = options.diagnosticId ?? (0, import_errors9.errorProperty)(error, "diagnosticId");
   if (!control && !diagnosticId && options.reportError) {
     try {
@@ -11340,12 +9397,16 @@ function createEvalIssue(phase, error, options = {}) {
     } catch {
     }
   }
+  const candidate = (0, import_errors9.errorProperty)(error, "statusCode") ?? (0, import_errors9.errorProperty)(error, "status");
+  const httpStatus = typeof candidate === "number" && Number.isInteger(candidate) && candidate >= 100 && candidate <= 599 ? candidate : void 0;
   return {
+    ...exception ? { exception } : {},
+    ...httpStatus ? { details: { httpStatus } } : {},
     phase,
     code: declared ? failure.code : options.code ?? "EVAL_HOOK_FAILED",
-    message: declared ? failure.message : messages[phase],
+    message: originalMessage ?? (declared ? failure.message : `${messages[phase]}${httpStatus ? ` HTTP ${httpStatus}.` : ""}`),
     failure,
-    ...typeof diagnosticId === "string" && import_zod9.z.uuid().safeParse(diagnosticId).success ? { diagnosticId } : {}
+    ...typeof diagnosticId === "string" && import_zod10.z.uuid().safeParse(diagnosticId).success ? { diagnosticId } : {}
   };
 }
 
@@ -11852,12 +9913,28 @@ function createEvals(options) {
     correlation,
     ...code ? { code } : {}
   });
+  for (const key of ["concurrency", "caseTimeoutMs"]) {
+    const max = options.limits?.[key];
+    if (max !== void 0 && defaults[key] > positive(max, `limits.${key}`))
+      throw new EvalConfigurationError(
+        `${key} default exceeds its application limit.`
+      );
+  }
   return {
     listSuites() {
       return clone(suites);
     },
     describe() {
       return {
+        execution: {
+          defaults: {
+            ...options.defaults?.repetitions !== void 0 ? { repetitions: options.defaults.repetitions } : {},
+            ...options.defaults?.concurrency !== void 0 ? { concurrency: options.defaults.concurrency } : {},
+            ...options.defaults?.caseTimeoutMs !== void 0 ? { caseTimeoutMs: options.defaults.caseTimeoutMs } : {}
+          },
+          limits: options.limits ?? {},
+          overrides: ["repetitions", "concurrency", "caseTimeoutMs"]
+        },
         schemaVersion: 1,
         studioJudging: true,
         ...options.agent.describePromptContracts ? { promptContracts: options.agent.describePromptContracts() } : {},
@@ -11872,7 +9949,7 @@ function createEvals(options) {
         })),
         references: Object.keys(references),
         ...options.paramsSchema ? {
-          paramsSchema: import_zod10.z.toJSONSchema(options.paramsSchema, {
+          paramsSchema: import_zod11.z.toJSONSchema(options.paramsSchema, {
             io: "input"
           })
         } : {},
@@ -11886,252 +9963,368 @@ function createEvals(options) {
       };
     },
     async run(args) {
-      const suite = suites.find((value) => value.id === args.suiteId);
-      if (!suite)
-        throw new EvalConfigurationError(`Unknown suite: ${args.suiteId}`);
-      if (args.caseIds && (!args.caseIds.length || new Set(args.caseIds).size !== args.caseIds.length || args.caseIds.some(
-        (id3) => !suite.cases.some((item) => item.id === id3)
-      )))
-        throw new EvalConfigurationError("Select unique existing case IDs.");
-      const repetitions = positive(
-        args.repetitions ?? defaults.repetitions,
-        "repetitions"
-      );
-      const concurrency = positive(
-        args.concurrency ?? defaults.concurrency,
-        "concurrency"
-      );
-      const selected = suite.cases.filter(
-        (item) => !args.caseIds || args.caseIds.includes(item.id)
-      );
-      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)
-      ))
-        throw new EvalConfigurationError(
-          "Local runs with criteria require a judge. Run from Studio or provide a code judge."
-        );
-      const selectedJudge = studioGrading ? args.judgeIdentity : options.judge;
-      if (!studioGrading && args.judgeIdentity && (!options.judge || args.judgeIdentity.id !== options.judge.id || args.judgeIdentity.version !== options.judge.version || args.judgeIdentity.location !== options.judge.location))
-        throw new EvalConfigurationError(
-          "App judge changed. Refresh before running."
-        );
+      let usagePhase = "configuration";
       const evalUsage = usage.start("sdk.eval", {
-        scale: (0, import_usage_telemetry.scale)(selected.length * repetitions)
+        case_timeout_override: args.caseTimeoutMs !== void 0,
+        settings_override: args.caseTimeoutMs !== void 0 || args.concurrency !== void 0 || args.repetitions !== void 0
       });
-      const start = Date.now();
-      const result = {
-        id: (0, import_node_crypto5.randomUUID)(),
-        suiteId: suite.id,
-        suiteRevision: getEvalSuiteRevision(suite),
-        suite: clone(suite),
-        ...selectedJudge ? {
-          judge: {
-            id: selectedJudge.id,
-            version: selectedJudge.version,
-            ...selectedJudge.location ? { location: selectedJudge.location } : {}
-          }
-        } : {},
-        startedAt: new Date(start).toISOString(),
-        durationMs: 0,
-        status: "passed",
-        counts: { passed: 0, failed: 0, error: 0, cancelled: 0 },
-        cases: [],
-        errors: []
-      };
-      let reporting = true;
-      const emit = async (event) => {
-        if (!args.onProgress || !reporting) return;
-        try {
-          await (0, import_eval_attribution2.withEvalAttribution)(
-            void 0,
-            () => args.onProgress(clone(event))
+      try {
+        const suite = suites.find((value) => value.id === args.suiteId);
+        if (!suite)
+          throw new EvalConfigurationError(`Unknown suite: ${args.suiteId}`);
+        if (args.caseIds && (!args.caseIds.length || new Set(args.caseIds).size !== args.caseIds.length || args.caseIds.some(
+          (id3) => !suite.cases.some((item) => item.id === id3)
+        )))
+          throw new EvalConfigurationError("Select unique existing case IDs.");
+        const repetitions = positive(
+          args.repetitions ?? defaults.repetitions,
+          "repetitions"
+        );
+        const concurrency = positive(
+          args.concurrency ?? defaults.concurrency,
+          "concurrency"
+        );
+        const caseTimeoutMs = positive(
+          args.caseTimeoutMs ?? defaults.caseTimeoutMs,
+          "caseTimeoutMs"
+        );
+        if (caseTimeoutMs > 2147483647)
+          throw new EvalConfigurationError(
+            "caseTimeoutMs exceeds the supported timer range."
           );
-        } catch (error) {
-          reporting = false;
-          result.errors.push(issueFor("reporting", error));
+        for (const [key, value] of [
+          ["concurrency", concurrency],
+          ["caseTimeoutMs", caseTimeoutMs]
+        ]) {
+          const max = options.limits?.[key];
+          if (max !== void 0 && value > max)
+            throw new EvalConfigurationError(
+              `${key} exceeds the application maximum of ${max}.`
+            );
         }
-      };
-      const attempt = async (item, repetition) => {
-        const started = Date.now();
-        const controller = new AbortController();
-        let timedOut = false;
-        let timer;
-        const deadline = (milliseconds) => {
-          clearTimeout(timer);
-          timer = setTimeout(() => {
-            timedOut = true;
-            controller.abort();
-          }, milliseconds);
-        };
-        deadline(defaults.setupTimeoutMs);
-        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",
+        const selected = suite.cases.filter(
+          (item) => !args.caseIds || args.caseIds.includes(item.id)
+        );
+        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)
+        ))
+          throw new EvalConfigurationError(
+            "Local runs with criteria require a judge. Run from Studio or provide a code judge."
+          );
+        const selectedJudge = studioGrading ? args.judgeIdentity : options.judge;
+        if (!studioGrading && args.judgeIdentity && (!options.judge || args.judgeIdentity.id !== options.judge.id || args.judgeIdentity.version !== options.judge.version || args.judgeIdentity.location !== options.judge.location))
+          throw new EvalConfigurationError(
+            "App judge changed. Refresh before running."
+          );
+        usagePhase = "execution";
+        const start = Date.now();
+        const result = {
+          id: (0, import_node_crypto5.randomUUID)(),
+          suiteId: suite.id,
+          suiteRevision: getEvalSuiteRevision(suite),
+          suite: clone(suite),
+          ...selectedJudge ? {
+            judge: {
+              id: selectedJudge.id,
+              version: selectedJudge.version,
+              ...selectedJudge.location ? { location: selectedJudge.location } : {}
+            }
+          } : {},
+          startedAt: new Date(start).toISOString(),
           durationMs: 0,
-          steps: [],
-          errors: [],
-          phaseDurationsMs: {}
+          status: "passed",
+          counts: { passed: 0, failed: 0, error: 0, cancelled: 0 },
+          cases: [],
+          errors: []
         };
-        let associationProgress = Promise.resolve();
-        let acceptingExecutions = true;
-        const executeAttempt = async () => {
-          let phase = "params";
-          let phaseStarted = Date.now();
-          const recordPhase = () => {
-            const now = Date.now();
-            const durations = attemptResult.phaseDurationsMs;
-            durations[phase] = (durations[phase] ?? 0) + now - phaseStarted;
-            phaseStarted = now;
+        let reporting = true;
+        const emit = async (event) => {
+          if (!args.onProgress || !reporting) return;
+          try {
+            await (0, import_eval_attribution3.withEvalAttribution)(
+              void 0,
+              () => args.onProgress?.(clone(event))
+            );
+          } catch (error) {
+            reporting = false;
+            result.errors.push(issueFor("reporting", error));
+          }
+        };
+        const attempt = async (item, repetition) => {
+          const started = Date.now();
+          const controller = new AbortController();
+          let timedOut = false;
+          let timer;
+          const deadline = (milliseconds) => {
+            clearTimeout(timer);
+            timer = setTimeout(() => {
+              timedOut = true;
+              controller.abort();
+            }, milliseconds);
           };
-          const phaseIssue = (error, code) => issueFor(
-            phase,
-            error,
-            {
-              correlation: { sessionId: attemptResult.sessionId, attemptId }
-            },
-            code
-          );
-          let stepIndex;
-          const reportPhase = async (next) => {
-            recordPhase();
-            phase = next;
-            if (args.includeActivity)
-              await emit({
-                type: "case-progress",
-                caseId: item.id,
-                repetition,
-                phase,
-                ...stepIndex !== void 0 ? { stepIndex } : {}
-              });
+          deadline(defaults.setupTimeoutMs);
+          const signal = args.signal ? AbortSignal.any([args.signal, controller.signal]) : controller.signal;
+          let originalExecutionError;
+          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: [],
+            phaseDurationsMs: {}
           };
-          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
+          let associationProgress = Promise.resolve();
+          let acceptingExecutions = true;
+          const executeAttempt = async () => {
+            let phase = "params";
+            let phaseStarted = Date.now();
+            const recordPhase = () => {
+              const now = Date.now();
+              const durations = attemptResult.phaseDurationsMs;
+              durations[phase] = (durations[phase] ?? 0) + now - phaseStarted;
+              phaseStarted = now;
+            };
+            const phaseIssue = (error, code) => issueFor(
+              phase,
+              error,
+              {
+                correlation: {
+                  sessionId: attemptResult.sessionId,
+                  attemptId
+                }
+              },
+              code
             );
-            if (observation.type === "interrupt" && execution.continuation === void 0)
-              throw new Error(
-                "A waiting interrupt requires a private continuation."
-              );
-            return {
-              observation,
-              ...continuation !== void 0 ? { continuation } : {}
+            let stepIndex;
+            const reportPhase = async (next) => {
+              recordPhase();
+              phase = next;
+              if (args.includeActivity)
+                await emit({
+                  type: "case-progress",
+                  caseId: item.id,
+                  repetition,
+                  phase,
+                  ...stepIndex !== void 0 ? { stepIndex } : {}
+                });
             };
-          };
-          try {
-            await emit({
-              type: "case-started",
-              attemptId,
-              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
+            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 } : {}
+              };
             };
-            await reportPhase("setup");
-            const prepared = options.setup ? await options.setup(base) : void 0;
-            context = { ...base, prepared };
-            signal.throwIfAborted();
-            deadline(defaults.caseTimeoutMs);
-            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
-                  )
-                };
-              }
+            try {
+              await emit({
+                type: "case-started",
+                attemptId,
+                caseId: item.id,
+                repetition,
+                sessionId: attemptResult.sessionId
+              });
               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") {
-                const issue2 = createEvalIssue("execute", observation.failure, {
-                  ...observation.diagnosticId ? { diagnosticId: observation.diagnosticId } : {}
-                });
-                attemptResult.errors.push(issue2);
-                attemptResult.status = evaluated.status = "error";
-                evaluated.reason = issue2.message;
+              deadline(caseTimeoutMs);
+              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");
+                originalExecutionError = void 0;
+                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") {
+                  const issue2 = createEvalIssue(
+                    "execute",
+                    originalExecutionError ?? observation.failure ?? observation.text,
+                    {
+                      ...observation.diagnosticId ? { diagnosticId: observation.diagnosticId } : {}
+                    }
+                  );
+                  attemptResult.errors.push(issue2);
+                  attemptResult.status = evaluated.status = "error";
+                  evaluated.reason = issue2.message;
+                  await emit({
+                    type: "step-completed",
+                    caseId: item.id,
+                    repetition,
+                    step: evaluated
+                  });
+                  activeStepReported = true;
+                  break;
+                }
+                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_zod11.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_attribution3.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,
@@ -12139,255 +10332,191 @@ function createEvals(options) {
                   step: evaluated
                 });
                 activeStepReported = true;
-                break;
+                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 }
+                );
+              }
+              if (options.verify && attemptResult.status !== "cancelled" && attemptResult.status !== "error") {
+                stepIndex = void 0;
+                deadline(defaults.verificationTimeoutMs);
+                await reportPhase("verification");
+                const verification = EvalVerdictSchema.parse(
+                  await options.verify({
+                    ...context,
+                    result: clone(attemptResult)
+                  })
+                );
+                signal.throwIfAborted();
+                attemptResult.verification = verification;
+                if (!verification.passed) attemptResult.status = "failed";
               }
-              if (observation.type === "cancelled") {
-                evaluated.status = "cancelled";
-                attemptResult.status = "cancelled";
+            } catch (error) {
+              if (signal.aborted) {
+                attemptResult.status = timedOut ? "error" : "cancelled";
+                if (timedOut)
+                  attemptResult.errors.push({
+                    ...phaseIssue(error),
+                    details: {
+                      timeoutMs: phase === "params" || phase === "setup" ? defaults.setupTimeoutMs : phase === "verification" ? defaults.verificationTimeoutMs : caseTimeoutMs
+                    },
+                    code: phase === "params" || phase === "setup" ? "EVAL_SETUP_TIMEOUT" : phase === "verification" ? "EVAL_VERIFICATION_TIMEOUT" : "EVAL_TIMEOUT",
+                    message: phase === "params" || phase === "setup" ? "Case setup exceeded its configured time limit." : phase === "verification" ? "Case verification exceeded its configured time limit." : "Case execution exceeded its configured time limit."
+                  });
+              } else {
+                attemptResult.status = "error";
+                attemptResult.errors.push(phaseIssue(error));
+              }
+              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: evaluated
+                  step: activeStep
                 });
-                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
+            } finally {
+              clearTimeout(timer);
+              if (context) {
+                await reportPhase("cleanup");
+                const cleanup = new AbortController();
+                const cleanupTimer = setTimeout(
+                  () => cleanup.abort(),
+                  defaults.cleanupTimeoutMs
                 );
-                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_zod10.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));
+                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(
+                          createEvalIssue(
+                            "cleanup",
+                            cancelled.observation.failure,
+                            {
+                              code: "EVAL_INTERRUPT_CLEANUP_FAILED",
+                              ...cancelled.observation.diagnosticId ? {
+                                diagnosticId: cancelled.observation.diagnosticId
+                              } : {}
                             }
-                          },
-                          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,
-                repetition,
-                step: evaluated
-              });
-              activeStepReported = true;
-              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 }
-              );
-            }
-            if (options.verify && attemptResult.status !== "cancelled" && attemptResult.status !== "error") {
-              stepIndex = void 0;
-              deadline(defaults.verificationTimeoutMs);
-              await reportPhase("verification");
-              const verification = EvalVerdictSchema.parse(
-                await options.verify({
-                  ...context,
-                  result: clone(attemptResult)
-                })
-              );
-              signal.throwIfAborted();
-              attemptResult.verification = verification;
-              if (!verification.passed) attemptResult.status = "failed";
-            }
-          } catch (error) {
-            if (signal.aborted) {
-              attemptResult.status = timedOut ? "error" : "cancelled";
-              if (timedOut)
-                attemptResult.errors.push({
-                  ...phaseIssue(error),
-                  code: phase === "params" || phase === "setup" ? "EVAL_SETUP_TIMEOUT" : phase === "verification" ? "EVAL_VERIFICATION_TIMEOUT" : "EVAL_TIMEOUT",
-                  message: phase === "params" || phase === "setup" ? "Case setup exceeded its configured time limit." : phase === "verification" ? "Case verification exceeded its configured time limit." : "Case execution exceeded its configured time limit."
-                });
-            } else {
-              attemptResult.status = "error";
-              attemptResult.errors.push(phaseIssue(error));
-            }
-            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)
+                          )
+                        );
+                      cleanup.signal.throwIfAborted();
+                    } catch (error) {
                       attemptResult.errors.push(
-                        createEvalIssue(
-                          "cleanup",
-                          cancelled.observation.failure,
-                          {
-                            code: "EVAL_INTERRUPT_CLEANUP_FAILED",
-                            ...cancelled.observation.diagnosticId ? {
-                              diagnosticId: cancelled.observation.diagnosticId
-                            } : {}
-                          }
-                        )
+                        phaseIssue(error, "EVAL_INTERRUPT_CLEANUP_FAILED")
                       );
+                    }
+                  }
+                  try {
+                    await options.teardown?.({
+                      ...context,
+                      signal: cleanup.signal,
+                      result: clone(attemptResult)
+                    });
                     cleanup.signal.throwIfAborted();
                   } catch (error) {
-                    attemptResult.errors.push(
-                      phaseIssue(error, "EVAL_INTERRUPT_CLEANUP_FAILED")
-                    );
+                    attemptResult.errors.push(phaseIssue(error));
                   }
+                } finally {
+                  clearTimeout(cleanupTimer);
                 }
-                try {
-                  await options.teardown?.({
-                    ...context,
-                    signal: cleanup.signal,
-                    result: clone(attemptResult)
-                  });
-                  cleanup.signal.throwIfAborted();
-                } catch (error) {
-                  attemptResult.errors.push(phaseIssue(error));
-                }
-              } 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";
+              recordPhase();
+              attemptResult.durationMs = Date.now() - started;
             }
-            recordPhase();
-            attemptResult.durationMs = Date.now() - started;
-          }
-          acceptingExecutions = false;
-          await associationProgress;
-          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_attribution3.withEvalAttribution)(
+            {
+              attemptId,
+              onError: (error) => {
+                originalExecutionError = error;
+              },
+              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
+          );
         };
-        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
-                })
+        const total = args.attempt ? 1 : selected.length * repetitions;
+        if (args.includeActivity)
+          await emit({
+            type: "run-started",
+            caseIds: selected.map((item) => item.id),
+            repetitions,
+            concurrency
+          });
+        const completed = new Array(total);
+        let cursor = 0;
+        await Promise.all(
+          Array.from({ length: Math.min(concurrency, total) }, async () => {
+            while (cursor < total) {
+              const index = cursor++;
+              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
               );
             }
-          },
-          executeAttempt
+          })
         );
-      };
-      const total = args.attempt ? 1 : selected.length * repetitions;
-      if (args.includeActivity)
-        await emit({
-          type: "run-started",
-          caseIds: selected.map((item) => item.id),
-          repetitions,
-          concurrency
-        });
-      const completed = new Array(total);
-      let cursor = 0;
-      await Promise.all(
-        Array.from({ length: Math.min(concurrency, total) }, async () => {
-          while (cursor < total) {
-            const index = cursor++;
-            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
-            );
+        result.cases = completed;
+        for (const item of completed)
+          result.counts[item.status] = (result.counts[item.status] ?? 0) + 1;
+        result.status = statusFor(result.counts, result.errors);
+        result.durationMs = Date.now() - start;
+        const failedIssue = result.errors[0] ?? result.cases.find((item) => item.errors.length)?.errors[0];
+        evalUsage.end(
+          result.status === "passed" ? "success" : result.status === "failed" ? "quality_failed" : result.status === "error" ? "failed" : result.status,
+          {
+            scale: (0, import_usage_telemetry.scale)(selected.length * repetitions),
+            phase: usagePhase,
+            ...result.status === "error" ? {
+              ...(0, import_usage_telemetry.classifyUsageError)(failedIssue).properties,
+              eval_phase: failedIssue?.phase
+            } : {}
           }
-        })
-      );
-      result.cases = completed;
-      for (const item of completed)
-        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;
+        );
+        return result;
+      } catch (error) {
+        evalUsage.fail(error, { phase: usagePhase });
+        throw error;
+      }
     }
   };
 }
@@ -12398,23 +10527,24 @@ function defineSuite(suite) {
 }
 
 // src/evals/evaluation-contracts.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 
 // src/evals/studio-contracts.ts
 var import_browser3 = require("@kortyx/prompts/browser");
-var import_zod11 = require("zod");
-var StudioEvalTargetsResponseSchema = import_zod11.z.object({
-  canRun: import_zod11.z.boolean(),
+var import_zod12 = require("zod");
+var StudioEvalTargetsResponseSchema = import_zod12.z.object({
+  canRun: import_zod12.z.boolean(),
+  settings: EvalSettingsResponseSchema.optional(),
   studioJudge: EvalJudgeIdentitySchema.nullable().optional(),
-  targets: import_zod11.z.array(
-    import_zod11.z.object({
-      id: import_zod11.z.string(),
-      name: import_zod11.z.string(),
-      environment: import_zod11.z.string(),
-      error: import_zod11.z.string().nullable(),
+  targets: import_zod12.z.array(
+    import_zod12.z.object({
+      id: import_zod12.z.string(),
+      name: import_zod12.z.string(),
+      environment: import_zod12.z.string(),
+      error: import_zod12.z.string().nullable(),
       // Safe discovery diagnostics; optional for compatibility with older APIs.
-      diagnostic: import_zod11.z.object({
-        code: import_zod11.z.enum([
+      diagnostic: import_zod12.z.object({
+        code: import_zod12.z.enum([
           "environment_forbidden",
           "environment_unavailable",
           "endpoint_not_found",
@@ -12423,44 +10553,47 @@ var StudioEvalTargetsResponseSchema = import_zod11.z.object({
           "endpoint_unreachable",
           "manifest_invalid"
         ]),
-        httpStatus: import_zod11.z.number().int().min(100).max(599).optional()
+        httpStatus: import_zod12.z.number().int().min(100).max(599).optional()
       }).nullable().optional(),
       manifest: EvalManifestSchema.nullable(),
-      revisions: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.string())
+      revisions: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string())
     })
   )
 });
-var EvalCostAmountSchema = import_zod11.z.object({
-  costSummary: import_zod11.z.object({
-    amounts: import_zod11.z.array(
-      import_zod11.z.object({
-        amount: import_zod11.z.number().finite().nonnegative(),
-        currency: import_zod11.z.string().nullable()
+var EvalCostAmountSchema = import_zod12.z.object({
+  costSummary: import_zod12.z.object({
+    amounts: import_zod12.z.array(
+      import_zod12.z.object({
+        amount: import_zod12.z.number().finite().nonnegative(),
+        currency: import_zod12.z.string().nullable()
       })
     ),
-    complete: import_zod11.z.boolean()
+    complete: import_zod12.z.boolean()
   }).optional(),
-  amount: import_zod11.z.number().finite().nonnegative().nullable(),
-  currency: import_zod11.z.string().nullable(),
-  status: import_zod11.z.enum(["complete", "partial", "unavailable"]),
-  calls: import_zod11.z.number().int().nonnegative(),
-  unpricedCalls: import_zod11.z.number().int().nonnegative(),
-  estimated: import_zod11.z.boolean()
+  amount: import_zod12.z.number().finite().nonnegative().nullable(),
+  currency: import_zod12.z.string().nullable(),
+  status: import_zod12.z.enum(["complete", "partial", "unavailable"]),
+  calls: import_zod12.z.number().int().nonnegative(),
+  unpricedCalls: import_zod12.z.number().int().nonnegative(),
+  estimated: import_zod12.z.boolean()
 });
-var EvalCostsSchema = import_zod11.z.object({
+var EvalCostsSchema = import_zod12.z.object({
   workflow: EvalCostAmountSchema,
   judge: EvalCostAmountSchema,
   total: EvalCostAmountSchema
 });
-var StudioEvalRunSummarySchema = import_zod11.z.object({
-  id: import_zod11.z.uuid(),
-  evaluationId: import_zod11.z.uuid().nullable().optional(),
-  targetId: import_zod11.z.string(),
-  targetName: import_zod11.z.string(),
-  environment: import_zod11.z.string(),
-  suiteId: import_zod11.z.string(),
-  suiteRevision: import_zod11.z.string(),
-  status: import_zod11.z.enum([
+var StudioEvalRunSummarySchema = import_zod12.z.object({
+  issue: EvalIssueSchema.nullable().optional(),
+  termination: EvalTerminationSchema.nullable().optional(),
+  resolvedSettings: ResolvedEvalSettingsSchema.optional(),
+  id: import_zod12.z.uuid(),
+  evaluationId: import_zod12.z.uuid().nullable().optional(),
+  targetId: import_zod12.z.string(),
+  targetName: import_zod12.z.string(),
+  environment: import_zod12.z.string(),
+  suiteId: import_zod12.z.string(),
+  suiteRevision: import_zod12.z.string(),
+  status: import_zod12.z.enum([
     "queued",
     "running",
     "passed",
@@ -12468,49 +10601,52 @@ var StudioEvalRunSummarySchema = import_zod11.z.object({
     "error",
     "cancelled"
   ]),
-  createdAt: import_zod11.z.string(),
-  startedAt: import_zod11.z.string().nullable(),
-  endedAt: import_zod11.z.string().nullable(),
-  error: import_zod11.z.string().nullable(),
-  cancelRequestedAt: import_zod11.z.string().nullable(),
+  createdAt: import_zod12.z.string(),
+  startedAt: import_zod12.z.string().nullable(),
+  endedAt: import_zod12.z.string().nullable(),
+  error: import_zod12.z.string().nullable(),
+  cancelRequestedAt: import_zod12.z.string().nullable(),
   costs: EvalCostsSchema.optional(),
-  counts: import_zod11.z.object({
-    passed: import_zod11.z.number(),
-    failed: import_zod11.z.number(),
-    error: import_zod11.z.number(),
-    cancelled: import_zod11.z.number()
+  counts: import_zod12.z.object({
+    passed: import_zod12.z.number(),
+    failed: import_zod12.z.number(),
+    error: import_zod12.z.number(),
+    cancelled: import_zod12.z.number()
   }).nullable().optional(),
-  suiteName: import_zod11.z.string().nullable().optional(),
-  totalAttempts: import_zod11.z.number().int().nonnegative().optional(),
-  completedAttempts: import_zod11.z.number().int().nonnegative().optional(),
-  phase: import_zod11.z.string().optional()
+  suiteName: import_zod12.z.string().nullable().optional(),
+  totalAttempts: import_zod12.z.number().int().nonnegative().optional(),
+  completedAttempts: import_zod12.z.number().int().nonnegative().optional(),
+  phase: import_zod12.z.string().optional()
 });
-var StudioEvalHistorySchema = import_zod11.z.object({
-  runs: import_zod11.z.array(StudioEvalRunSummarySchema)
+var StudioEvalHistorySchema = import_zod12.z.object({
+  runs: import_zod12.z.array(StudioEvalRunSummarySchema)
 });
-var StudioEvalDetailSchema = import_zod11.z.object({
+var StudioEvalDetailSchema = import_zod12.z.object({
   run: StudioEvalRunSummarySchema.extend({
-    caseCosts: import_zod11.z.record(import_zod11.z.string(), EvalCostsSchema).optional(),
-    request: import_zod11.z.object({
-      caseIds: import_zod11.z.array(import_zod11.z.string()).optional(),
-      grading: import_zod11.z.enum(["app", "studio"]).optional(),
+    caseCosts: import_zod12.z.record(import_zod12.z.string(), EvalCostsSchema).optional(),
+    request: import_zod12.z.object({
+      caseIds: import_zod12.z.array(import_zod12.z.string()).optional(),
+      grading: import_zod12.z.enum(["app", "studio"]).optional(),
       judge: EvalJudgeIdentitySchema.optional(),
-      repetitions: import_zod11.z.number().int().positive(),
-      concurrency: import_zod11.z.number().optional(),
+      repetitions: import_zod12.z.number().int().positive(),
+      concurrency: import_zod12.z.number().optional(),
+      caseTimeoutMs: import_zod12.z.number().optional(),
+      runTimeoutMs: import_zod12.z.number().optional(),
+      resolvedSettings: ResolvedEvalSettingsSchema.optional(),
       promptSnapshot: import_browser3.PromptSnapshotSchema.optional(),
-      promptGroupName: import_zod11.z.string().optional()
+      promptGroupName: import_zod12.z.string().optional()
     }).optional(),
     suite: EvalSuiteSchema,
     result: EvalRunResultSchema.nullable(),
-    events: import_zod11.z.array(import_zod11.z.object({ id: import_zod11.z.number(), event: EvalProgressSchema }))
+    events: import_zod12.z.array(import_zod12.z.object({ id: import_zod12.z.number(), event: EvalProgressSchema }))
   })
 });
 
 // src/evals/evaluation-contracts.ts
-var EvaluationMetadataSchema = import_zod12.z.object({
-  source: import_zod12.z.enum(["manual", "deployment", "schedule", "ci"]).default("manual"),
-  commit: import_zod12.z.string().trim().min(1).max(100).optional(),
-  deploymentUrl: import_zod12.z.url().refine((value) => {
+var EvaluationMetadataSchema = import_zod13.z.object({
+  source: import_zod13.z.enum(["manual", "deployment", "schedule", "ci"]).default("manual"),
+  commit: import_zod13.z.string().trim().min(1).max(100).optional(),
+  deploymentUrl: import_zod13.z.url().refine((value) => {
     try {
       const url = new URL(value);
       return ["https:", "http:"].includes(url.protocol) && !url.username && !url.password;
@@ -12519,67 +10655,84 @@ var EvaluationMetadataSchema = import_zod12.z.object({
     }
   }, "Expected an HTTP(S) URL without credentials").optional()
 }).strict();
-var StudioEvaluationStartRequestSchema = import_zod12.z.object({
-  targetId: import_zod12.z.string().trim().min(1),
-  name: import_zod12.z.string().trim().min(1).max(200).optional(),
+var StudioEvaluationStartRequestSchema = import_zod13.z.object({
+  targetId: import_zod13.z.string().trim().min(1),
+  name: import_zod13.z.string().trim().min(1).max(200).optional(),
   promptSelection: StudioEvalStartRequestSchema.shape.promptSelection,
-  selection: import_zod12.z.enum(["all", "selected"]),
-  suites: import_zod12.z.array(
-    import_zod12.z.object({
-      suiteId: import_zod12.z.string().min(1),
-      suiteRevision: import_zod12.z.string().regex(/^[a-f0-9]{64}$/),
-      caseIds: import_zod12.z.array(import_zod12.z.string().min(1)).min(1).max(100).optional()
+  selection: import_zod13.z.enum(["all", "selected"]),
+  suites: import_zod13.z.array(
+    import_zod13.z.object({
+      suiteId: import_zod13.z.string().min(1),
+      suiteRevision: import_zod13.z.string().regex(/^[a-f0-9]{64}$/),
+      caseIds: import_zod13.z.array(import_zod13.z.string().min(1)).min(1).max(100).optional()
     }).strict()
   ).min(1).max(100),
-  judge: import_zod12.z.enum(["studio", "app"]).default("studio"),
-  repetitions: import_zod12.z.number().int().min(1).max(20).default(1),
-  concurrency: import_zod12.z.number().int().min(1).max(20).default(1),
+  ...EvalSettingsSchema.shape,
   metadata: EvaluationMetadataSchema.default({ source: "manual" }),
-  idempotencyKey: import_zod12.z.string().trim().min(1).max(200).optional()
+  idempotencyKey: import_zod13.z.string().trim().min(1).max(200).optional()
 }).strict();
-var StudioEvaluationSummarySchema = import_zod12.z.object({
-  id: import_zod12.z.uuid(),
-  name: import_zod12.z.string(),
-  targetId: import_zod12.z.string(),
-  targetName: import_zod12.z.string(),
-  environment: import_zod12.z.string(),
-  selection: import_zod12.z.enum(["all", "selected"]),
+var StudioEvaluationSummarySchema = import_zod13.z.object({
+  termination: EvalTerminationSchema.nullable().optional(),
+  resolvedSettings: ResolvedEvalSettingsSchema.optional(),
+  interruptedSuites: import_zod13.z.number().int().nonnegative().optional(),
+  failures: import_zod13.z.array(
+    import_zod13.z.object({
+      suiteRunId: import_zod13.z.uuid(),
+      caseId: import_zod13.z.string().optional(),
+      repetition: import_zod13.z.number().int().positive().optional(),
+      phase: import_zod13.z.string(),
+      code: import_zod13.z.string(),
+      message: import_zod13.z.string(),
+      diagnosticId: import_zod13.z.string().uuid().optional()
+    })
+  ).optional(),
+  pendingAttempts: import_zod13.z.object({
+    notStarted: import_zod13.z.number().int().nonnegative(),
+    executing: import_zod13.z.number().int().nonnegative(),
+    awaitingGrading: import_zod13.z.number().int().nonnegative()
+  }).optional(),
+  id: import_zod13.z.uuid(),
+  name: import_zod13.z.string(),
+  targetId: import_zod13.z.string(),
+  targetName: import_zod13.z.string(),
+  environment: import_zod13.z.string(),
+  selection: import_zod13.z.enum(["all", "selected"]),
   metadata: EvaluationMetadataSchema,
   judge: EvalJudgeIdentitySchema.optional(),
   status: StudioEvalRunSummarySchema.shape.status,
-  createdAt: import_zod12.z.string(),
-  startedAt: import_zod12.z.string().nullable(),
-  endedAt: import_zod12.z.string().nullable(),
-  cancelRequestedAt: import_zod12.z.string().nullable(),
-  suiteCount: import_zod12.z.number().int().nonnegative(),
-  completedSuites: import_zod12.z.number().int().nonnegative(),
-  totalAttempts: import_zod12.z.number().int().nonnegative(),
-  completedAttempts: import_zod12.z.number().int().nonnegative(),
-  counts: import_zod12.z.object({
-    passed: import_zod12.z.number(),
-    failed: import_zod12.z.number(),
-    error: import_zod12.z.number(),
-    cancelled: import_zod12.z.number()
+  createdAt: import_zod13.z.string(),
+  startedAt: import_zod13.z.string().nullable(),
+  endedAt: import_zod13.z.string().nullable(),
+  cancelRequestedAt: import_zod13.z.string().nullable(),
+  suiteCount: import_zod13.z.number().int().nonnegative(),
+  completedSuites: import_zod13.z.number().int().nonnegative(),
+  totalAttempts: import_zod13.z.number().int().nonnegative(),
+  completedAttempts: import_zod13.z.number().int().nonnegative(),
+  counts: import_zod13.z.object({
+    passed: import_zod13.z.number(),
+    failed: import_zod13.z.number(),
+    error: import_zod13.z.number(),
+    cancelled: import_zod13.z.number()
   }),
   costs: EvalCostsSchema.optional(),
-  legacy: import_zod12.z.boolean().optional()
+  legacy: import_zod13.z.boolean().optional()
 });
-var StudioEvaluationHistorySchema = import_zod12.z.object({
-  runs: import_zod12.z.array(StudioEvaluationSummarySchema)
+var StudioEvaluationHistorySchema = import_zod13.z.object({
+  runs: import_zod13.z.array(StudioEvaluationSummarySchema)
 });
-var StudioEvaluationDetailSchema = import_zod12.z.object({
+var StudioEvaluationDetailSchema = import_zod13.z.object({
   run: StudioEvaluationSummarySchema.extend({
-    suites: import_zod12.z.array(StudioEvalRunSummarySchema)
+    suites: import_zod13.z.array(StudioEvalRunSummarySchema)
   })
 });
-var StudioEvaluationResultsSchema = import_zod12.z.object({
+var StudioEvaluationResultsSchema = import_zod13.z.object({
   run: StudioEvaluationSummarySchema.extend({
-    suites: import_zod12.z.array(StudioEvalDetailSchema.shape.run)
+    suites: import_zod13.z.array(StudioEvalDetailSchema.shape.run)
   })
 });
 
 // src/evals/judge.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 function createEvalJudge({
   model,
   id: id3 = `${model.provider.id}/${model.modelId}`,
@@ -12606,7 +10759,7 @@ function createEvalJudge({
         responseFormat: {
           type: "json",
           name: "eval_verdict",
-          schema: import_zod13.z.toJSONSchema(EvalVerdictSchema)
+          schema: import_zod14.z.toJSONSchema(EvalVerdictSchema)
         }
       });
       const result = await judge2.invoke([
@@ -12730,6 +10883,7 @@ function createEvalExecutionTransport({
     await store.append(job.id, owner, {
       type: "error",
       message: issue2.message,
+      exception: issue2.exception,
       failure: issue2.failure,
       ...issue2.diagnosticId ? { diagnosticId: issue2.diagnosticId } : {}
     });
@@ -12771,6 +10925,7 @@ function createEvalExecutionTransport({
         suiteId: body.suiteId,
         repetitions: body.repetitions,
         concurrency: body.concurrency,
+        ...body.caseTimeoutMs !== void 0 ? { caseTimeoutMs: body.caseTimeoutMs } : {},
         signal: controller.signal,
         ...body.attempt ? { attempt: body.attempt } : {},
         ...body.caseIds ? { caseIds: body.caseIds } : {},
@@ -12846,10 +11001,16 @@ function createEvalExecutionTransport({
     "x-kortyx-eval-generation": await store.generation()
   });
   const problem = (error, negotiated) => {
+    const issue2 = createEvalIssue("reporting", error);
     const failure = (0, import_errors13.serializeFailure)(error);
     const busy = failure.code === "EVAL_EXECUTOR_BUSY";
     return Response.json(
-      { error: failure.message, failure, ...busy ? { accepted: false } : {} },
+      {
+        error: issue2.message,
+        issue: issue2,
+        failure,
+        ...busy ? { accepted: false } : {}
+      },
       {
         status: busy ? negotiated ? 503 : 429 : !negotiated && failure.code === "EVAL_CONCURRENCY_CHANGED" ? 429 : failure.status ?? 503,
         headers: {
@@ -13186,6 +11347,15 @@ function createEvalRouteHandler({
         { error: "Unsupported or invalid scheduled attempt." },
         { status: 409 }
       );
+    for (const key of ["concurrency", "caseTimeoutMs"]) {
+      const maximum = manifest.execution?.limits[key];
+      const value = body[key] ?? manifest.execution?.defaults[key];
+      if (maximum !== void 0 && value !== void 0 && value > maximum)
+        return Response.json(
+          { error: `${key} exceeds the application maximum of ${maximum}.` },
+          { status: 400 }
+        );
+    }
     if (request.signal.aborted)
       return Response.json({ error: "Request cancelled." }, { status: 409 });
     return execution.submit(request, body);
@@ -13194,11 +11364,12 @@ function createEvalRouteHandler({
 }
 
 // src/evals/studio-judge.ts
+var import_telemetry_contracts3 = require("@kortyx/telemetry-contracts");
 async function readJson(response, signal) {
-  if (!response.ok || !response.body) {
-    await response.body?.cancel().catch(() => {
-    });
-    throw new Error("Studio judge is unavailable or rejected the request.");
+  if (!response.body) {
+    throw new Error(
+      `Studio judge returned HTTP ${response.status} with no response body.`
+    );
   }
   const reader = response.body.getReader();
   const abort = () => {
@@ -13220,7 +11391,18 @@ async function readJson(response, signal) {
       text += decoder.decode(part.value, { stream: true });
     }
     signal.throwIfAborted();
-    return JSON.parse(text + decoder.decode());
+    text += decoder.decode();
+    if (!response.ok)
+      throw Object.assign(
+        new Error(
+          `Studio judge returned HTTP ${response.status}: ${(0, import_telemetry_contracts3.redactDiagnosticText)(text)}`
+        ),
+        {
+          statusCode: response.status,
+          responseBody: (0, import_telemetry_contracts3.redactDiagnosticText)(text)
+        }
+      );
+    return JSON.parse(text);
   } finally {
     signal.removeEventListener("abort", abort);
     await reader.cancel().catch(() => {
@@ -13304,6 +11486,7 @@ async function createStudioEvalJudge(options) {
   ChatLifecycleHookError,
   EvalConfigurationError,
   EvalEvidencePolicySchema,
+  EvalExecutionSettingsSchema,
   EvalIssueSchema,
   EvalJudgeIdentitySchema,
   EvalJudgeUsageSchema,
@@ -13311,10 +11494,14 @@ async function createStudioEvalJudge(options) {
   EvalProgressSchema,
   EvalRemoteRunRequestSchema,
   EvalRunResultSchema,
+  EvalSettingsResponseSchema,
+  EvalSettingsSchema,
   EvalSuiteSchema,
+  EvalTerminationSchema,
   EvalWireEventSchema,
   EvaluationMetadataSchema,
   ExecutionRequestError,
+  ResolvedEvalSettingsSchema,
   StudioEvalJudgeRequestSchema,
   StudioEvalJudgeResponseSchema,
   StudioEvalStartRequestSchema,
@@ -13345,6 +11532,7 @@ async function createStudioEvalJudge(options) {
   parseResumeMeta,
   projectWorkflowTopology,
   readRequestJson,
+  resolveEvalSettings,
   streamChat,
   streamChatFromRoute,
   transformGraphStreamForUI,