@kortyx/agent 0.30.0 → 0.31.1

package/dist/index.js

@@ -29,6 +29,1271 @@ 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 name in all)
+        __defProp2(target, name, { get: all[name], 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,
+      ReviewVerdictSchema: () => ReviewVerdictSchema,
+      STUDIO_API_PROTOCOL_VERSION: () => STUDIO_API_PROTOCOL_VERSION,
+      STUDIO_TIME_RANGES: () => STUDIO_TIME_RANGES,
+      StudioCatalogsResponseSchema: () => StudioCatalogsResponseSchema,
+      StudioChangeResourceSchema: () => StudioChangeResourceSchema,
+      StudioChangeSchema: () => StudioChangeSchema,
+      StudioContextResponseSchema: () => StudioContextResponseSchema,
+      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_zod52 = require("zod");
+    var import_zod11 = require("zod");
+    var FEEDBACK_FILTERS = ["positive", "negative", "unrated"];
+    var FeedbackSummarySchema = import_zod11.z.object({
+      positive: import_zod11.z.number().int().nonnegative(),
+      negative: import_zod11.z.number().int().nonnegative()
+    }).strict();
+    var FeedbackReasonSchema = import_zod11.z.enum([
+      "incorrect",
+      "irrelevant",
+      "incomplete",
+      "unsafe",
+      "other"
+    ]);
+    var ReviewVerdictSchema = import_zod11.z.enum([
+      "correct",
+      "partially-correct",
+      "incorrect"
+    ]);
+    var runId = import_zod11.z.string().trim().min(1).max(512);
+    var actorId = import_zod11.z.string().trim().min(1).max(256);
+    var comment = import_zod11.z.string().trim().max(4e3).nullable().optional();
+    var UserFeedbackRequestSchema = import_zod11.z.object({
+      runId,
+      actorId,
+      value: import_zod11.z.union([import_zod11.z.literal(0), import_zod11.z.literal(1)]),
+      reasons: import_zod11.z.array(FeedbackReasonSchema).max(5).optional(),
+      comment
+    }).strict();
+    var ClearUserFeedbackRequestSchema = UserFeedbackRequestSchema.pick({
+      runId: true,
+      actorId: true
+    });
+    var StudioReviewRequestSchema = import_zod11.z.object({ value: ReviewVerdictSchema, comment }).strict();
+    var BaseScoreSchema = import_zod11.z.object({
+      id: import_zod11.z.string().uuid(),
+      target: import_zod11.z.object({ type: import_zod11.z.literal("run"), runId }).strict(),
+      environment: import_zod11.z.string().min(1),
+      name: import_zod11.z.string().min(1),
+      source: import_zod11.z.enum(["end-user", "human-review", "evaluator"]),
+      actorId,
+      reasons: import_zod11.z.array(FeedbackReasonSchema),
+      comment: import_zod11.z.string().nullable(),
+      createdAt: import_zod11.z.string().datetime({ offset: true }),
+      updatedAt: import_zod11.z.string().datetime({ offset: true })
+    }).strict();
+    var StudioScoreSchema = import_zod11.z.discriminatedUnion("dataType", [
+      BaseScoreSchema.extend({
+        dataType: import_zod11.z.literal("BOOLEAN"),
+        value: import_zod11.z.union([import_zod11.z.literal(0), import_zod11.z.literal(1)])
+      }),
+      BaseScoreSchema.extend({
+        dataType: import_zod11.z.literal("CATEGORICAL"),
+        value: import_zod11.z.string()
+      }),
+      BaseScoreSchema.extend({
+        dataType: import_zod11.z.literal("NUMERIC"),
+        value: import_zod11.z.number().finite()
+      })
+    ]);
+    var StudioScoreResponseSchema = import_zod11.z.object({ score: StudioScoreSchema }).strict();
+    var ClearScoreResponseSchema = import_zod11.z.object({ ok: import_zod11.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_zod42 = require("zod");
+    var StudioReleaseVersionSchema = import_zod42.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
+    var StudioReleaseDeploymentSchema = import_zod42.z.object({
+      strategy: import_zod42.z.enum(["rolling", "recreate"])
+    });
+    var StudioReleaseSchema = import_zod42.z.object({
+      format: import_zod42.z.literal(1),
+      installer: import_zod42.z.literal(1),
+      version: StudioReleaseVersionSchema,
+      api: import_zod42.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-api@sha256:[a-f0-9]{64}$/),
+      studio: import_zod42.z.string().regex(/^ghcr\.io\/kortyx-io\/kortyx-studio@sha256:[a-f0-9]{64}$/),
+      deployment: StudioReleaseDeploymentSchema.default({
+        strategy: "recreate"
+      })
+    });
+    var StudioUpdateSettingsSchema = import_zod42.z.object({
+      automatic: import_zod42.z.boolean(),
+      hourUtc: import_zod42.z.number().int().min(0).max(23)
+    });
+    var StudioUpdateOperationSchema = import_zod42.z.object({
+      id: import_zod42.z.uuid(),
+      from: import_zod42.z.string(),
+      release: StudioReleaseSchema,
+      phase: import_zod42.z.enum([
+        "starting",
+        "pulling",
+        "backup",
+        "installing",
+        "verifying",
+        "succeeded",
+        "failed"
+      ]),
+      startedAt: import_zod42.z.iso.datetime(),
+      updatedAt: import_zod42.z.iso.datetime(),
+      backup: import_zod42.z.string().nullable(),
+      messages: import_zod42.z.array(import_zod42.z.string()).max(100)
+    });
+    var StudioUpdateStatusSchema = import_zod42.z.object({
+      current: import_zod42.z.string().nullable(),
+      available: StudioReleaseSchema.nullable(),
+      checkedAt: import_zod42.z.iso.datetime().nullable(),
+      checkError: import_zod42.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(([id2, 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: id2,
+          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_zod52.z.object({
+      name: import_zod52.z.string().min(1),
+      deploymentRef: import_zod52.z.string().min(1).optional()
+    }).strict();
+    var WorkflowTopologyNodeSchema = import_zod52.z.object({
+      id: import_zod52.z.string().min(1),
+      label: import_zod52.z.string().optional(),
+      type: import_zod52.z.string().optional(),
+      provider: import_zod52.z.string().optional(),
+      model: import_zod52.z.string().optional(),
+      metadata: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()).optional(),
+      tools: import_zod52.z.array(WorkflowToolSchema).optional(),
+      toolDiscovery: ToolDiscoverySchema.optional()
+    }).strict();
+    var WorkflowTopologyEdgeSchema = import_zod52.z.object({
+      sourceNodeId: import_zod52.z.string().min(1),
+      targetNodeId: import_zod52.z.string().min(1),
+      condition: import_zod52.z.string().optional()
+    }).strict();
+    var WorkflowTopologyCallSchema = import_zod52.z.object({
+      sourceNodeId: import_zod52.z.string().min(1),
+      targetWorkflowId: import_zod52.z.string().min(1)
+    }).strict();
+    var WorkflowTopologyTransitionSchema = import_zod52.z.object({
+      sourceNodeId: import_zod52.z.string().min(1).optional(),
+      targetWorkflowId: import_zod52.z.string().min(1),
+      condition: import_zod52.z.string().optional(),
+      intent: import_zod52.z.string().optional(),
+      kind: import_zod52.z.enum(["call", "handoff"]).optional()
+    }).strict();
+    var EnsureWorkflowTopologyRequestSchema = import_zod52.z.object({
+      schemaVersion: import_zod52.z.literal(1),
+      environment: import_zod52.z.string().min(1),
+      service: TelemetryServiceSchema,
+      workflow: import_zod52.z.object({
+        id: import_zod52.z.string().min(1),
+        declaredVersion: import_zod52.z.string().min(1),
+        description: import_zod52.z.string().optional(),
+        tags: import_zod52.z.array(import_zod52.z.string()).optional(),
+        topologyHash: import_zod52.z.string().regex(/^[a-f0-9]{64}$/),
+        nodes: import_zod52.z.array(WorkflowTopologyNodeSchema),
+        edges: import_zod52.z.array(WorkflowTopologyEdgeSchema),
+        transitions: import_zod52.z.array(WorkflowTopologyTransitionSchema).optional(),
+        calls: import_zod52.z.array(WorkflowTopologyCallSchema).optional()
+      }).strict()
+    }).strict();
+    var EnsureWorkflowTopologyResponseSchema = import_zod52.z.object({ workflowRevisionId: import_zod52.z.string().min(1), created: import_zod52.z.boolean() }).strict();
+    var TelemetryEventTypeSchema = import_zod52.z.enum(TELEMETRY_EVENT_TYPES);
+    var TelemetryEventSchema = import_zod52.z.object({
+      schemaVersion: import_zod52.z.literal(1),
+      eventId: import_zod52.z.string().min(1),
+      occurredAt: import_zod52.z.string().datetime({ offset: true }),
+      environment: import_zod52.z.string().min(1),
+      service: TelemetryServiceSchema,
+      correlation: import_zod52.z.object({
+        invocationId: import_zod52.z.string().optional(),
+        parentInvocationId: import_zod52.z.string().optional(),
+        branchId: import_zod52.z.string().optional(),
+        traceId: import_zod52.z.string().optional(),
+        spanId: import_zod52.z.string().optional(),
+        parentSpanId: import_zod52.z.string().optional(),
+        runId: import_zod52.z.string().min(1),
+        sessionId: import_zod52.z.string().optional(),
+        workflowId: import_zod52.z.string().min(1),
+        workflowRevisionId: import_zod52.z.string().optional(),
+        topologyHash: import_zod52.z.string().regex(/^[a-f0-9]{64}$/).optional(),
+        nodeId: import_zod52.z.string().optional()
+      }).strict(),
+      context: import_zod52.z.object({
+        userId: import_zod52.z.string().optional(),
+        tenantId: import_zod52.z.string().optional(),
+        tags: import_zod52.z.array(import_zod52.z.string()).optional(),
+        metadata: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()).optional()
+      }).strict().optional(),
+      type: TelemetryEventTypeSchema,
+      payload: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown())
+    }).strict().superRefine((event, ctx) => {
+      if (!event.type.startsWith("tool.")) return;
+      const canonical2 = event.payload.version === 1 || [
+        "tool.denied",
+        "tool.cancelled",
+        "tool.reused",
+        "tool.waiting",
+        "tool.suspended"
+      ].includes(event.type);
+      if (!canonical2) 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_zod52.z.object({ events: import_zod52.z.array(TelemetryEventSchema).min(1) }).strict();
+    var TelemetryEventBatchResponseSchema = import_zod52.z.object({
+      accepted: import_zod52.z.number().int().nonnegative(),
+      inserted: import_zod52.z.number().int().nonnegative(),
+      duplicates: import_zod52.z.number().int().nonnegative()
+    }).strict();
+    var TelemetryPricingSourceSchema = import_zod52.z.enum([
+      "sdk",
+      "provider",
+      "custom",
+      "project-rate-card",
+      "default-rate-card"
+    ]);
+    var TelemetryPricingUnitSchema = import_zod52.z.enum([
+      "token",
+      "character",
+      "request",
+      "image",
+      "audio_second",
+      "audio_minute",
+      "video_second",
+      "video_minute",
+      "second",
+      "minute",
+      "custom"
+    ]);
+    var TelemetryPricingUsageTypeSchema = import_zod52.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_zod52.z.object({
+      usageType: TelemetryPricingUsageTypeSchema,
+      quantity: import_zod52.z.number().nonnegative(),
+      unit: TelemetryPricingUnitSchema,
+      label: import_zod52.z.string().optional()
+    }).strict();
+    var TelemetryUnitPriceSchema = import_zod52.z.object({
+      usageType: TelemetryPricingUsageTypeSchema,
+      unit: TelemetryPricingUnitSchema,
+      unitQuantity: import_zod52.z.number().positive().default(1),
+      priceMicros: import_zod52.z.number().int().nonnegative(),
+      label: import_zod52.z.string().optional()
+    }).strict();
+    var TelemetryPricingLineItemSchema = import_zod52.z.object({
+      usageType: TelemetryPricingUsageTypeSchema,
+      quantity: import_zod52.z.number().nonnegative(),
+      unit: TelemetryPricingUnitSchema,
+      unitQuantity: import_zod52.z.number().positive().default(1),
+      unitPriceMicros: import_zod52.z.number().int().nonnegative().optional(),
+      totalCostMicros: import_zod52.z.number().int().nonnegative().optional(),
+      label: import_zod52.z.string().optional()
+    }).strict().refine(
+      (value) => value.totalCostMicros !== void 0 || value.unitPriceMicros !== void 0,
+      "line item requires totalCostMicros or unitPriceMicros"
+    );
+    var TelemetryPricingHintSchema = import_zod52.z.object({
+      source: TelemetryPricingSourceSchema.extract(["sdk", "provider", "custom"]),
+      currency: import_zod52.z.string().min(3).max(12).default("USD"),
+      actualCostMicros: import_zod52.z.number().int().nonnegative().optional(),
+      lineItems: import_zod52.z.array(TelemetryPricingLineItemSchema).optional(),
+      unitPrices: import_zod52.z.array(TelemetryUnitPriceSchema).optional(),
+      usageItems: import_zod52.z.array(TelemetryUsageItemSchema).optional(),
+      pricingRef: import_zod52.z.string().min(1).optional(),
+      metadata: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()).optional()
+    }).strict();
+    var StudioRunStatusSchema = import_zod52.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_zod52.z.enum(STUDIO_TIME_RANGES);
+    var StudioTimeRangeQuerySchema = import_zod52.z.object({
+      range: StudioTimeRangeSchema.optional(),
+      startedAfter: import_zod52.z.string().optional(),
+      startedBefore: import_zod52.z.string().optional()
+    }).strict();
+    var StudioTimeRangeContextSchema = import_zod52.z.object({
+      range: StudioTimeRangeSchema,
+      startedAfter: import_zod52.z.string().datetime({ offset: true }).nullable(),
+      startedBefore: import_zod52.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_zod52.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_zod52.z.enum([
+      "choice",
+      "multi-choice",
+      "text",
+      "structured",
+      "unknown"
+    ]);
+    var StudioInterruptInteractionModeSchema = import_zod52.z.enum([
+      "static-options",
+      "dynamic-picker",
+      "freeform",
+      "unknown"
+    ]);
+    var StudioInterruptOptionSchema = import_zod52.z.object({
+      id: import_zod52.z.string().min(1),
+      label: import_zod52.z.string().min(1),
+      description: import_zod52.z.string().nullable()
+    }).strip();
+    var StudioInterruptValueSchema = import_zod52.z.union([
+      import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()),
+      import_zod52.z.array(import_zod52.z.unknown()),
+      import_zod52.z.string(),
+      import_zod52.z.number(),
+      import_zod52.z.boolean()
+    ]);
+    var StudioResumeOutcomeSchema = import_zod52.z.enum([
+      "resumed",
+      "resume failed",
+      "expired before resume",
+      "cancelled"
+    ]);
+    var StudioWorkflowHealthSchema = import_zod52.z.enum([
+      "unknown",
+      "healthy",
+      "degraded",
+      "failing",
+      "idle"
+    ]);
+    var StudioPricingStatusSchema = import_zod52.z.enum([
+      "priced",
+      "unpriced",
+      "unknown"
+    ]);
+    var StudioPricingSourceSchema = TelemetryPricingSourceSchema.nullable();
+    var StudioChangeResourceSchema = import_zod52.z.enum([
+      "evals",
+      "workflows",
+      "runs",
+      "sessions",
+      "interrupts"
+    ]);
+    var StudioChangeSchema = import_zod52.z.object({
+      schemaVersion: import_zod52.z.literal(1),
+      changeId: import_zod52.z.string().min(1),
+      emittedAt: import_zod52.z.string().datetime({ offset: true }),
+      organizationId: import_zod52.z.string().min(1),
+      projectId: import_zod52.z.string().min(1),
+      environment: import_zod52.z.string().min(1).optional(),
+      resources: import_zod52.z.array(StudioChangeResourceSchema).min(1)
+    }).strict();
+    var StudioMetricSchema = import_zod52.z.object({
+      runCount: import_zod52.z.number().int().nonnegative(),
+      successRate: import_zod52.z.number().min(0).max(100).nullable(),
+      errorRate: import_zod52.z.number().min(0).max(100).nullable(),
+      retryCount: import_zod52.z.number().int().nonnegative().nullable(),
+      interruptRate: import_zod52.z.number().min(0).max(100).nullable(),
+      p50DurationMs: import_zod52.z.number().nonnegative().nullable(),
+      p95DurationMs: import_zod52.z.number().nonnegative().nullable(),
+      averageTokens: import_zod52.z.number().nonnegative().nullable(),
+      averageCost: import_zod52.z.number().nonnegative().nullable(),
+      currency: import_zod52.z.string().nullable()
+    }).strip();
+    var StudioRunSchema = import_zod52.z.object({
+      id: import_zod52.z.string().min(1),
+      feedback: FeedbackSummarySchema.optional(),
+      callerNodeId: import_zod52.z.string().optional(),
+      parentRunId: import_zod52.z.string().optional(),
+      parentWorkflowId: import_zod52.z.string().optional(),
+      invocationId: import_zod52.z.string().optional(),
+      branchId: import_zod52.z.string().optional(),
+      callId: import_zod52.z.string().optional(),
+      status: StudioRunStatusSchema,
+      startedAt: import_zod52.z.string().datetime({ offset: true }),
+      endedAt: import_zod52.z.string().datetime({ offset: true }).nullable(),
+      workflowId: import_zod52.z.string().min(1),
+      workflowIds: import_zod52.z.array(import_zod52.z.string().min(1)),
+      workflowRefs: import_zod52.z.array(
+        import_zod52.z.object({
+          workflowId: import_zod52.z.string().min(1),
+          workflowRevisionId: import_zod52.z.string().nullable(),
+          declaredVersion: import_zod52.z.string().nullable()
+        }).strip()
+      ),
+      workflowRevisionId: import_zod52.z.string().nullable(),
+      declaredVersion: import_zod52.z.string().nullable(),
+      transitionIds: import_zod52.z.array(import_zod52.z.string().min(1)),
+      path: import_zod52.z.array(import_zod52.z.string()),
+      sessionId: import_zod52.z.string().nullable(),
+      provider: import_zod52.z.string().nullable(),
+      model: import_zod52.z.string().nullable(),
+      models: import_zod52.z.array(import_zod52.z.string()),
+      durationMs: import_zod52.z.number().nonnegative().nullable(),
+      tokens: import_zod52.z.number().int().nonnegative().nullable(),
+      cost: import_zod52.z.number().nonnegative().nullable(),
+      pricingStatus: StudioPricingStatusSchema,
+      pricingSource: StudioPricingSourceSchema,
+      currency: import_zod52.z.string().nullable(),
+      result: import_zod52.z.string().nullable(),
+      environment: import_zod52.z.string().min(1),
+      userId: import_zod52.z.string().nullable(),
+      tenantId: import_zod52.z.string().nullable(),
+      hasTool: import_zod52.z.boolean(),
+      hasRetry: import_zod52.z.boolean(),
+      interruptNodeId: import_zod52.z.string().nullable(),
+      interruptId: import_zod52.z.string().nullable().optional(),
+      interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
+      interruptExpiresAt: import_zod52.z.string().datetime({ offset: true }).nullable().optional()
+    }).strip();
+    var StudioSessionSchema = import_zod52.z.object({
+      id: import_zod52.z.string().min(1),
+      status: StudioRunStatusSchema,
+      lastActivityAt: import_zod52.z.string().datetime({ offset: true }),
+      workflowIds: import_zod52.z.array(import_zod52.z.string()),
+      workflowCount: import_zod52.z.number().int().nonnegative(),
+      activeWorkflowId: import_zod52.z.string().nullable(),
+      activeVersion: import_zod52.z.string().nullable(),
+      userId: import_zod52.z.string().nullable(),
+      tenantId: import_zod52.z.string().nullable(),
+      runs: import_zod52.z.number().int().nonnegative(),
+      succeeded: import_zod52.z.number().int().nonnegative(),
+      failed: import_zod52.z.number().int().nonnegative(),
+      interrupted: import_zod52.z.number().int().nonnegative(),
+      checkpoints: import_zod52.z.number().int().nonnegative(),
+      hasFork: import_zod52.z.boolean(),
+      durationMs: import_zod52.z.number().nonnegative().nullable(),
+      tokens: import_zod52.z.number().int().nonnegative().nullable(),
+      cost: import_zod52.z.number().nonnegative().nullable(),
+      pricingStatus: StudioPricingStatusSchema,
+      pricingSource: StudioPricingSourceSchema,
+      currency: import_zod52.z.string().nullable(),
+      latestResult: import_zod52.z.string().nullable(),
+      latestError: import_zod52.z.string().nullable(),
+      pendingInterruptId: import_zod52.z.string().nullable(),
+      interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
+      interruptExpiresAt: import_zod52.z.string().datetime({ offset: true }).nullable().optional(),
+      providers: import_zod52.z.array(import_zod52.z.string()),
+      models: import_zod52.z.array(import_zod52.z.string()),
+      tags: import_zod52.z.array(import_zod52.z.string()),
+      environment: import_zod52.z.string().min(1)
+    }).strip();
+    var StudioInterruptSchema = import_zod52.z.object({
+      afterResponseCompleted: import_zod52.z.boolean().optional(),
+      id: import_zod52.z.string().min(1),
+      status: StudioInterruptStatusSchema,
+      type: StudioInterruptTypeSchema,
+      interactionMode: StudioInterruptInteractionModeSchema,
+      contract: import_zod52.z.string().nullable().default(null),
+      schemaId: import_zod52.z.string().nullable(),
+      schemaVersion: import_zod52.z.string().nullable(),
+      createdAt: import_zod52.z.string().datetime({ offset: true }),
+      resolvedAt: import_zod52.z.string().datetime({ offset: true }).nullable(),
+      expiresAt: import_zod52.z.string().datetime({ offset: true }).nullable(),
+      question: import_zod52.z.string().nullable(),
+      contentCaptured: import_zod52.z.boolean(),
+      request: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()).nullable().default(null),
+      requestCaptured: import_zod52.z.boolean().default(false),
+      optionCount: import_zod52.z.number().int().nonnegative().nullable(),
+      options: import_zod52.z.array(StudioInterruptOptionSchema).nullable(),
+      workflowId: import_zod52.z.string().min(1),
+      nodeId: import_zod52.z.string().nullable(),
+      sessionId: import_zod52.z.string().nullable(),
+      userId: import_zod52.z.string().nullable(),
+      tenantId: import_zod52.z.string().nullable(),
+      response: import_zod52.z.string().nullable(),
+      responseValue: StudioInterruptValueSchema.nullable().default(null),
+      responseCaptured: import_zod52.z.boolean(),
+      resumeOutcome: StudioResumeOutcomeSchema.nullable(),
+      resumeError: import_zod52.z.string().nullable(),
+      runId: import_zod52.z.string().min(1),
+      resumeToken: import_zod52.z.string().nullable(),
+      resolvedBy: import_zod52.z.string().nullable(),
+      environment: import_zod52.z.string().min(1)
+    }).strip();
+    var StudioDetailEventSchema = import_zod52.z.object({
+      id: import_zod52.z.string().min(1),
+      // Studio readers must preserve future event kinds within the same API major.
+      type: import_zod52.z.string().min(1),
+      occurredAt: import_zod52.z.string().datetime({ offset: true }),
+      receivedAt: import_zod52.z.string().datetime({ offset: true }),
+      environment: import_zod52.z.string().min(1),
+      serviceName: import_zod52.z.string().min(1),
+      deploymentRef: import_zod52.z.string().nullable(),
+      traceId: import_zod52.z.string().nullable(),
+      spanId: import_zod52.z.string().nullable(),
+      parentSpanId: import_zod52.z.string().nullable(),
+      runId: import_zod52.z.string().min(1),
+      sessionId: import_zod52.z.string().nullable(),
+      workflowId: import_zod52.z.string().min(1),
+      workflowRevisionId: import_zod52.z.string().nullable(),
+      nodeId: import_zod52.z.string().nullable(),
+      userId: import_zod52.z.string().nullable(),
+      tenantId: import_zod52.z.string().nullable(),
+      tags: import_zod52.z.array(import_zod52.z.string()),
+      metadata: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()).nullable(),
+      payload: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown())
+    }).strip();
+    var StudioWorkflowNodeSchema = import_zod52.z.object({
+      tools: import_zod52.z.array(StudioToolSchema).optional(),
+      toolDiscovery: ToolDiscoverySchema.optional(),
+      id: import_zod52.z.string().min(1),
+      label: import_zod52.z.string(),
+      type: import_zod52.z.string().nullable(),
+      state: import_zod52.z.enum(["healthy", "warning", "failed", "interrupted", "retried"]).nullable(),
+      provider: import_zod52.z.string().nullable(),
+      model: import_zod52.z.string().nullable(),
+      metrics: StudioMetricSchema
+    }).strip();
+    var StudioWorkflowInternalEdgeSchema = import_zod52.z.object({
+      id: import_zod52.z.string().min(1),
+      source: import_zod52.z.string().min(1),
+      target: import_zod52.z.string().min(1),
+      condition: import_zod52.z.string().nullable()
+    }).strip();
+    var StudioWorkflowTransitionSchema = import_zod52.z.object({
+      kind: import_zod52.z.enum(["call", "handoff"]).optional(),
+      id: import_zod52.z.string().min(1),
+      sourceWorkflowId: import_zod52.z.string().min(1),
+      sourceNodeId: import_zod52.z.string().nullable(),
+      targetWorkflowId: import_zod52.z.string().min(1),
+      condition: import_zod52.z.string().nullable(),
+      volume: import_zod52.z.number().int().nonnegative(),
+      successRate: import_zod52.z.number().min(0).max(100).nullable(),
+      medianDurationMs: import_zod52.z.number().nonnegative().nullable(),
+      errorRate: import_zod52.z.number().min(0).max(100).nullable()
+    }).strip();
+    var StudioWorkflowSchema = import_zod52.z.object({
+      id: import_zod52.z.string().min(1),
+      name: import_zod52.z.string().min(1),
+      description: import_zod52.z.string().nullable(),
+      versions: import_zod52.z.array(import_zod52.z.string()),
+      activeVersion: import_zod52.z.string().nullable(),
+      activeRevisionId: import_zod52.z.string().nullable(),
+      health: StudioWorkflowHealthSchema,
+      tags: import_zod52.z.array(import_zod52.z.string()),
+      lastActivityAt: import_zod52.z.string().datetime({ offset: true }).nullable(),
+      metrics: StudioMetricSchema,
+      nodes: import_zod52.z.array(StudioWorkflowNodeSchema),
+      internalEdges: import_zod52.z.array(StudioWorkflowInternalEdgeSchema)
+    }).strip();
+    var StudioRunsResponseSchema = import_zod52.z.object({
+      runs: import_zod52.z.array(StudioRunSchema),
+      totalCount: import_zod52.z.number().int().nonnegative()
+    }).strip();
+    var StudioSessionsResponseSchema = import_zod52.z.object({
+      sessions: import_zod52.z.array(StudioSessionSchema),
+      totalCount: import_zod52.z.number().int().nonnegative()
+    }).strip();
+    var StudioInterruptsResponseSchema = import_zod52.z.object({
+      interrupts: import_zod52.z.array(StudioInterruptSchema),
+      totalCount: import_zod52.z.number().int().nonnegative()
+    }).strip();
+    var StudioRunDetailResponseSchema = import_zod52.z.object({
+      run: StudioRunSchema,
+      scores: import_zod52.z.array(StudioScoreSchema).optional(),
+      canReview: import_zod52.z.boolean().optional(),
+      reviewActorId: import_zod52.z.string().optional(),
+      events: import_zod52.z.array(StudioDetailEventSchema),
+      session: StudioSessionSchema.nullable(),
+      interrupts: import_zod52.z.array(StudioInterruptSchema),
+      updatedAt: import_zod52.z.string().datetime({ offset: true })
+    }).strip();
+    var StudioSessionDetailResponseSchema = import_zod52.z.object({
+      session: StudioSessionSchema,
+      runs: import_zod52.z.array(StudioRunSchema),
+      events: import_zod52.z.array(StudioDetailEventSchema),
+      interrupts: import_zod52.z.array(StudioInterruptSchema),
+      updatedAt: import_zod52.z.string().datetime({ offset: true })
+    }).strip();
+    var StudioInterruptDetailResponseSchema = import_zod52.z.object({
+      interrupt: StudioInterruptSchema,
+      events: import_zod52.z.array(StudioDetailEventSchema),
+      run: StudioRunSchema.nullable(),
+      session: StudioSessionSchema.nullable(),
+      updatedAt: import_zod52.z.string().datetime({ offset: true })
+    }).strip();
+    var StudioWorkflowsResponseSchema = import_zod52.z.object({
+      workflows: import_zod52.z.array(StudioWorkflowSchema),
+      observedCalls: import_zod52.z.array(
+        StudioWorkflowTransitionSchema.extend({
+          runId: import_zod52.z.string(),
+          invocationId: import_zod52.z.string(),
+          branchId: import_zod52.z.string()
+        })
+      ).optional(),
+      transitions: import_zod52.z.array(StudioWorkflowTransitionSchema),
+      cohort: StudioTimeRangeContextSchema.extend({
+        workflowId: import_zod52.z.string().nullable(),
+        version: import_zod52.z.string().nullable()
+      }).strip()
+    }).strip();
+    var StudioCatalogsResponseSchema = import_zod52.z.object({
+      environments: import_zod52.z.array(import_zod52.z.string()),
+      providers: import_zod52.z.array(import_zod52.z.string()),
+      models: import_zod52.z.array(import_zod52.z.string()),
+      workflows: import_zod52.z.array(import_zod52.z.string()),
+      tags: import_zod52.z.array(import_zod52.z.string())
+    }).strip();
+    var StudioContextResponseSchema = import_zod52.z.object({
+      organization: import_zod52.z.object({
+        name: import_zod52.z.string().min(1)
+      }).strip(),
+      project: import_zod52.z.object({
+        name: import_zod52.z.string().min(1)
+      }).strip(),
+      environments: import_zod52.z.array(import_zod52.z.string()),
+      apiKey: import_zod52.z.object({
+        mode: import_zod52.z.enum(["test", "live"]),
+        scopes: import_zod52.z.array(import_zod52.z.string())
+      }).strip().nullable(),
+      api: import_zod52.z.object({
+        status: import_zod52.z.literal("ok"),
+        service: import_zod52.z.literal("kortyx-api"),
+        version: import_zod52.z.string().min(1)
+      }).strip()
+    }).strip();
+  }
+});
+
 // ../hooks/dist/internal.js
 var require_internal = __commonJS({
   "../hooks/dist/internal.js"(exports2, module2) {
@@ -51,6 +1316,7 @@ var require_internal = __commonJS({
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var internal_exports = {};
     __export2(internal_exports, {
+      captureDiagnosticContent: () => captureDiagnosticContent,
       errorDiagnostics: () => errorDiagnostics,
       exceptionDiagnostics: () => exceptionDiagnostics,
       isModelTraceSpan: () => isModelTraceSpan,
@@ -58,55 +1324,258 @@ var require_internal = __commonJS({
       safeSpan: () => safeSpan,
       safeStartSpan: () => safeStartSpan2,
       safeTelemetryMetadata: () => safeTelemetryMetadata2,
+      summarizeDiagnostic: () => import_telemetry_contracts3.summarizeDiagnostic,
       withSafeTraceSpan: () => withSafeTraceSpan2
     });
     module2.exports = __toCommonJS2(internal_exports);
+    var import_telemetry_contracts3 = require_dist();
     var import_errors8 = require("@kortyx/core/errors");
-    var MAX_STACK_LENGTH = 32768;
-    var MAX_CAUSE_DEPTH = 4;
-    var projectDetails = (value, depth, seen) => {
-      const objectValue = value && typeof value === "object" ? value : void 0;
-      if (objectValue) {
-        if (seen.has(objectValue))
-          return { type: "Error", message: "Circular error cause." };
-        seen.add(objectValue);
-      }
-      const name = (0, import_errors8.errorProperty)(value, "name") ?? (value instanceof Error ? value.name : void 0);
-      const message = (0, import_errors8.errorProperty)(value, "message");
-      const stack = (0, import_errors8.errorProperty)(value, "stack") ?? (value instanceof Error ? (() => {
+    var import_telemetry_contracts = require_dist();
+    var encoder = new TextEncoder();
+    var nativeStackGetter = Object.getOwnPropertyDescriptor(
+      new Error(),
+      "stack"
+    )?.get;
+    function nativeStack(object, getter) {
+      if (!getter || getter !== nativeStackGetter)
+        throw new Error("Custom stack accessor");
+      for (const key of ["name", "message"]) {
+        let cursor = object;
+        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(object);
+      } 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 object = value;
+        const reference = seen.get(object);
+        if (reference) return { $ref: reference };
+        seen.set(object, path);
+        remaining -= 32;
+        if (remaining < 0) return omit(path, "byte_limit");
         try {
-          return value.stack;
+          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(object);
+          const result = /* @__PURE__ */ Object.create(null);
+          if (value instanceof Error) {
+            const ownName = Object.getOwnPropertyDescriptor(object, "name");
+            let type = ownName && "value" in ownName ? ownName.value : void 0;
+            if (typeof type !== "string") {
+              const 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(object, 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 void 0;
+          return omit(path, "unreadable_object");
+        }
+      };
+      const read = (object, 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(object, key);
+          if (property && "value" in property)
+            return visit(property.value, path, depth + 1);
+          if (key === "stack" && object instanceof Error && property?.get && property.get === nativeStackGetter)
+            return visit(nativeStack(object, property.get), path, depth + 1);
+          return omit(
+            path,
+            property ? "accessor_not_evaluated" : "unavailable_property"
+          );
+        } catch {
+          return omit(path, "unreadable_property");
         }
-      })() : void 0);
-      const cause = depth < MAX_CAUSE_DEPTH ? (0, import_errors8.errorProperty)(value, "cause") : null;
-      return {
-        type: typeof name === "string" ? name.slice(0, 256) : "Error",
-        message: (typeof value === "string" ? value : typeof message === "string" ? message : "Execution reported a fault.").slice(0, 8192),
-        ...typeof stack === "string" ? { stack: stack.slice(0, MAX_STACK_LENGTH) } : {},
-        ...cause !== null && cause !== void 0 ? { cause: projectDetails(cause, depth + 1, seen) } : {}
       };
-    };
-    var sanitizeProjectedDetails = (details, depth = 0) => ({
-      ...typeof details.type === "string" ? { type: details.type.slice(0, 256) } : {},
-      message: typeof details.message === "string" ? details.message.slice(0, 8192) : "Execution reported a fault.",
-      ...typeof details.stack === "string" ? { stack: details.stack.slice(0, MAX_STACK_LENGTH) } : {},
-      ...depth < MAX_CAUSE_DEPTH && details.cause ? { cause: sanitizeProjectedDetails(details.cause, depth + 1) } : {}
-    });
-    function exceptionDiagnostics(error, project) {
       try {
-        const details = project ? project(error) : projectDetails(error, 0, /* @__PURE__ */ new WeakSet());
-        return details ? sanitizeProjectedDetails(details) : null;
+        const original = project ? project(error) : error;
+        if (project && original === null) return null;
+        const captured = visit(original, "#/data", 0);
+        const upstreamOmissions = (0, import_errors8.errorProperty)(original, "diagnosticOmissions");
+        if (Array.isArray(upstreamOmissions))
+          for (const note of upstreamOmissions.slice(0, 1e3)) {
+            const path = (0, import_errors8.errorProperty)(note, "path");
+            const reason = (0, import_errors8.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 null;
+        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();
+    function exceptionDiagnostics(error, project) {
+      const content = captureDiagnosticContent(error, project);
+      return !content || content.capture.status === "failed" ? null : content.data;
+    }
     function errorDiagnostics(error, project) {
-      const details = exceptionDiagnostics(error, project);
+      const captured = exceptionDiagnostics(error, project);
+      const details = captured ? (0, import_telemetry_contracts2.summarizeDiagnostic)(captured) : null;
       return details ? {
-        errorMessage: details.message,
-        ...details.type ? { errorType: details.type } : {}
+        errorMessage: details.message.slice(0, 8192),
+        ...details.type ? { errorType: details.type.slice(0, 256) } : {}
       } : {};
     }
     function isModelTraceSpan(name) {
@@ -500,7 +1969,7 @@ var require_internal = __commonJS({
 });
 
 // ../hooks/dist/index.js
-var require_dist = __commonJS({
+var require_dist2 = __commonJS({
   "../hooks/dist/index.js"(exports2, module2) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -543,7 +2012,7 @@ var require_dist = __commonJS({
       workflowCallFingerprint: () => workflowCallFingerprint
     });
     module2.exports = __toCommonJS2(index_exports2);
-    var import_zod9 = require("zod");
+    var import_zod11 = require("zod");
     var import_node_async_hooks = require("async_hooks");
     var storage = new import_node_async_hooks.AsyncLocalStorage();
     var isRecord5 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -735,9 +2204,9 @@ var require_dist = __commonJS({
         runtime: { ...ctx.state.runtime, ...buildRuntimeStateUpdates(ctx) }
       };
     }
-    var optionsSchema = import_zod9.z.object({
-      message: import_zod9.z.string().optional(),
-      data: import_zod9.z.json().optional()
+    var optionsSchema = import_zod11.z.object({
+      message: import_zod11.z.string().optional(),
+      data: import_zod11.z.json().optional()
     }).strict();
     async function completeResponse(options = {}) {
       const ctx = getHookContext();
@@ -1187,52 +2656,253 @@ var require_dist = __commonJS({
     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 MAX_STACK_LENGTH = 32768;
-    var MAX_CAUSE_DEPTH = 4;
-    var projectDetails = (value, depth, seen) => {
-      const objectValue = value && typeof value === "object" ? value : void 0;
-      if (objectValue) {
-        if (seen.has(objectValue))
-          return { type: "Error", message: "Circular error cause." };
-        seen.add(objectValue);
-      }
-      const name = (0, import_errors22.errorProperty)(value, "name") ?? (value instanceof Error ? value.name : void 0);
-      const message = (0, import_errors22.errorProperty)(value, "message");
-      const stack = (0, import_errors22.errorProperty)(value, "stack") ?? (value instanceof Error ? (() => {
+    var import_telemetry_contracts = require_dist();
+    var encoder = new TextEncoder();
+    var nativeStackGetter = Object.getOwnPropertyDescriptor(
+      new Error(),
+      "stack"
+    )?.get;
+    function nativeStack(object, getter) {
+      if (!getter || getter !== nativeStackGetter)
+        throw new Error("Custom stack accessor");
+      for (const key of ["name", "message"]) {
+        let cursor = object;
+        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(object);
+      } 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 object = value;
+        const reference = seen.get(object);
+        if (reference) return { $ref: reference };
+        seen.set(object, path);
+        remaining -= 32;
+        if (remaining < 0) return omit(path, "byte_limit");
         try {
-          return value.stack;
+          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(object);
+          const result = /* @__PURE__ */ Object.create(null);
+          if (value instanceof Error) {
+            const ownName = Object.getOwnPropertyDescriptor(object, "name");
+            let type = ownName && "value" in ownName ? ownName.value : void 0;
+            if (typeof type !== "string") {
+              const 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(object, 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 void 0;
+          return omit(path, "unreadable_object");
+        }
+      };
+      const read = (object, 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(object, key);
+          if (property && "value" in property)
+            return visit(property.value, path, depth + 1);
+          if (key === "stack" && object instanceof Error && property?.get && property.get === nativeStackGetter)
+            return visit(nativeStack(object, property.get), path, depth + 1);
+          return omit(
+            path,
+            property ? "accessor_not_evaluated" : "unavailable_property"
+          );
+        } catch {
+          return omit(path, "unreadable_property");
         }
-      })() : void 0);
-      const cause = depth < MAX_CAUSE_DEPTH ? (0, import_errors22.errorProperty)(value, "cause") : null;
-      return {
-        type: typeof name === "string" ? name.slice(0, 256) : "Error",
-        message: (typeof value === "string" ? value : typeof message === "string" ? message : "Execution reported a fault.").slice(0, 8192),
-        ...typeof stack === "string" ? { stack: stack.slice(0, MAX_STACK_LENGTH) } : {},
-        ...cause !== null && cause !== void 0 ? { cause: projectDetails(cause, depth + 1, seen) } : {}
       };
-    };
-    var sanitizeProjectedDetails = (details, depth = 0) => ({
-      ...typeof details.type === "string" ? { type: details.type.slice(0, 256) } : {},
-      message: typeof details.message === "string" ? details.message.slice(0, 8192) : "Execution reported a fault.",
-      ...typeof details.stack === "string" ? { stack: details.stack.slice(0, MAX_STACK_LENGTH) } : {},
-      ...depth < MAX_CAUSE_DEPTH && details.cause ? { cause: sanitizeProjectedDetails(details.cause, depth + 1) } : {}
-    });
-    function exceptionDiagnostics(error, project) {
       try {
-        const details = project ? project(error) : projectDetails(error, 0, /* @__PURE__ */ new WeakSet());
-        return details ? sanitizeProjectedDetails(details) : null;
+        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 null;
+        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 details = exceptionDiagnostics(error, project);
+      const captured = exceptionDiagnostics(error, project);
+      const details = captured ? (0, import_telemetry_contracts2.summarizeDiagnostic)(captured) : null;
       return details ? {
-        errorMessage: details.message,
-        ...details.type ? { errorType: details.type } : {}
+        errorMessage: details.message.slice(0, 8192),
+        ...details.type ? { errorType: details.type.slice(0, 256) } : {}
       } : {};
     }
     var import_node_crypto22 = require("crypto");
@@ -1320,10 +2990,40 @@ var require_dist = __commonJS({
     function captureToolError(observation, error, policy, returned = false) {
       try {
         const reported = returned && error && typeof error === "object" && "isError" in error && error.isError === true && "content" in error && typeof error.content === "string" ? { name: "ToolError", message: error.content } : error;
+        let projected = false;
+        let projection;
+        let projectionFailure;
+        let projectionFailed = false;
+        const project = policy?.error ? (original) => {
+          if (!projected) {
+            projected = true;
+            try {
+              projection = policy.error?.(original);
+            } catch (error2) {
+              projectionFailure = error2;
+              projectionFailed = true;
+            }
+          }
+          if (projectionFailed) throw projectionFailure;
+          return projection ?? null;
+        } : void 0;
         Object.assign(
           observation,
-          errorDiagnostics(policy?.error ? error : reported, policy?.error)
+          errorDiagnostics(policy?.error ? error : reported, project)
+        );
+        const diagnosticId = getHookContext().reasonTrace?.reportError?.(
+          policy?.error ? error : reported,
+          {
+            mechanism: "tool",
+            ...project ? { error: project } : {},
+            correlation: {
+              toolCallId: observation.toolCallId,
+              attemptId: observation.attemptId
+            }
+          }
         );
+        if (typeof diagnosticId === "string")
+          observation.diagnosticId = diagnosticId;
       } catch {
       }
     }
@@ -4843,10 +6543,16 @@ __export(index_exports, {
   EvalRunResultSchema: () => EvalRunResultSchema,
   EvalSuiteSchema: () => EvalSuiteSchema,
   EvalWireEventSchema: () => EvalWireEventSchema,
+  EvaluationMetadataSchema: () => EvaluationMetadataSchema,
   ExecutionRequestError: () => ExecutionRequestError,
   StudioEvalJudgeRequestSchema: () => StudioEvalJudgeRequestSchema,
   StudioEvalJudgeResponseSchema: () => StudioEvalJudgeResponseSchema,
   StudioEvalStartRequestSchema: () => StudioEvalStartRequestSchema,
+  StudioEvaluationDetailSchema: () => StudioEvaluationDetailSchema,
+  StudioEvaluationHistorySchema: () => StudioEvaluationHistorySchema,
+  StudioEvaluationResultsSchema: () => StudioEvaluationResultsSchema,
+  StudioEvaluationStartRequestSchema: () => StudioEvaluationStartRequestSchema,
+  StudioEvaluationSummarySchema: () => StudioEvaluationSummarySchema,
   createAgent: () => createAgent,
   createChatRouteHandler: () => createChatRouteHandler,
   createCheckpointRouteHandler: () => createCheckpointRouteHandler,
@@ -7505,7 +9211,7 @@ function createInterruptDiscovery(store) {
 
 // src/telemetry/workflow-call-branch.ts
 var import_node_crypto3 = require("crypto");
-var import_hooks = __toESM(require_dist());
+var import_hooks = __toESM(require_dist2());
 function restoreWorkflowCallBranch(requests, telemetry, sourceRunId) {
   const branchId = (0, import_node_crypto3.randomUUID)();
   const emitted = /* @__PURE__ */ new Set();
@@ -9164,8 +10870,176 @@ function defineSuite(suite) {
   return suite;
 }
 
-// src/evals/judge.ts
+// src/evals/evaluation-contracts.ts
+var import_zod9 = require("zod");
+
+// src/evals/studio-contracts.ts
 var import_zod8 = require("zod");
+var StudioEvalTargetsResponseSchema = import_zod8.z.object({
+  canRun: import_zod8.z.boolean(),
+  studioJudge: EvalJudgeIdentitySchema.nullable().optional(),
+  targets: import_zod8.z.array(
+    import_zod8.z.object({
+      id: import_zod8.z.string(),
+      name: import_zod8.z.string(),
+      environment: import_zod8.z.string(),
+      error: import_zod8.z.string().nullable(),
+      // Safe discovery diagnostics; optional for compatibility with older APIs.
+      diagnostic: import_zod8.z.object({
+        code: import_zod8.z.enum([
+          "environment_forbidden",
+          "environment_unavailable",
+          "endpoint_not_found",
+          "endpoint_unauthorized",
+          "endpoint_http_error",
+          "endpoint_unreachable",
+          "manifest_invalid"
+        ]),
+        httpStatus: import_zod8.z.number().int().min(100).max(599).optional()
+      }).nullable().optional(),
+      manifest: EvalManifestSchema.nullable(),
+      revisions: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string())
+    })
+  )
+});
+var EvalCostAmountSchema = import_zod8.z.object({
+  amount: import_zod8.z.number().finite().nonnegative().nullable(),
+  currency: import_zod8.z.string().nullable(),
+  status: import_zod8.z.enum(["complete", "partial", "unavailable"]),
+  calls: import_zod8.z.number().int().nonnegative(),
+  unpricedCalls: import_zod8.z.number().int().nonnegative(),
+  estimated: import_zod8.z.boolean()
+});
+var EvalCostsSchema = import_zod8.z.object({
+  workflow: EvalCostAmountSchema,
+  judge: EvalCostAmountSchema,
+  total: EvalCostAmountSchema
+});
+var StudioEvalRunSummarySchema = import_zod8.z.object({
+  id: import_zod8.z.uuid(),
+  evaluationId: import_zod8.z.uuid().nullable().optional(),
+  targetId: import_zod8.z.string(),
+  targetName: import_zod8.z.string(),
+  environment: import_zod8.z.string(),
+  suiteId: import_zod8.z.string(),
+  suiteRevision: import_zod8.z.string(),
+  status: import_zod8.z.enum([
+    "queued",
+    "running",
+    "passed",
+    "failed",
+    "error",
+    "cancelled"
+  ]),
+  createdAt: import_zod8.z.string(),
+  startedAt: import_zod8.z.string().nullable(),
+  endedAt: import_zod8.z.string().nullable(),
+  error: import_zod8.z.string().nullable(),
+  cancelRequestedAt: import_zod8.z.string().nullable(),
+  costs: EvalCostsSchema.optional(),
+  counts: import_zod8.z.object({
+    passed: import_zod8.z.number(),
+    failed: import_zod8.z.number(),
+    error: import_zod8.z.number(),
+    cancelled: import_zod8.z.number()
+  }).nullable().optional(),
+  suiteName: import_zod8.z.string().nullable().optional(),
+  totalAttempts: import_zod8.z.number().int().nonnegative().optional(),
+  completedAttempts: import_zod8.z.number().int().nonnegative().optional(),
+  phase: import_zod8.z.string().optional()
+});
+var StudioEvalHistorySchema = import_zod8.z.object({
+  runs: import_zod8.z.array(StudioEvalRunSummarySchema)
+});
+var StudioEvalDetailSchema = import_zod8.z.object({
+  run: StudioEvalRunSummarySchema.extend({
+    caseCosts: import_zod8.z.record(import_zod8.z.string(), EvalCostsSchema).optional(),
+    request: import_zod8.z.object({
+      caseIds: import_zod8.z.array(import_zod8.z.string()).optional(),
+      grading: import_zod8.z.enum(["app", "studio"]).optional(),
+      judge: EvalJudgeIdentitySchema.optional(),
+      repetitions: import_zod8.z.number().int().positive(),
+      concurrency: import_zod8.z.number().optional()
+    }).optional(),
+    suite: EvalSuiteSchema,
+    result: EvalRunResultSchema.nullable(),
+    events: import_zod8.z.array(import_zod8.z.object({ id: import_zod8.z.number(), event: EvalProgressSchema }))
+  })
+});
+
+// src/evals/evaluation-contracts.ts
+var EvaluationMetadataSchema = import_zod9.z.object({
+  source: import_zod9.z.enum(["manual", "deployment", "schedule", "ci"]).default("manual"),
+  commit: import_zod9.z.string().trim().min(1).max(100).optional(),
+  deploymentUrl: import_zod9.z.url().refine((value) => {
+    try {
+      const url = new URL(value);
+      return ["https:", "http:"].includes(url.protocol) && !url.username && !url.password;
+    } catch {
+      return false;
+    }
+  }, "Expected an HTTP(S) URL without credentials").optional()
+}).strict();
+var StudioEvaluationStartRequestSchema = import_zod9.z.object({
+  targetId: import_zod9.z.string().trim().min(1),
+  name: import_zod9.z.string().trim().min(1).max(200).optional(),
+  selection: import_zod9.z.enum(["all", "selected"]),
+  suites: import_zod9.z.array(
+    import_zod9.z.object({
+      suiteId: import_zod9.z.string().min(1),
+      suiteRevision: import_zod9.z.string().regex(/^[a-f0-9]{64}$/),
+      caseIds: import_zod9.z.array(import_zod9.z.string().min(1)).min(1).max(100).optional()
+    }).strict()
+  ).min(1).max(100),
+  judge: import_zod9.z.enum(["studio", "app"]).default("studio"),
+  repetitions: import_zod9.z.number().int().min(1).max(20).default(1),
+  concurrency: import_zod9.z.number().int().min(1).max(4).default(1),
+  metadata: EvaluationMetadataSchema.default({ source: "manual" }),
+  idempotencyKey: import_zod9.z.string().trim().min(1).max(200).optional()
+}).strict();
+var StudioEvaluationSummarySchema = import_zod9.z.object({
+  id: import_zod9.z.uuid(),
+  name: import_zod9.z.string(),
+  targetId: import_zod9.z.string(),
+  targetName: import_zod9.z.string(),
+  environment: import_zod9.z.string(),
+  selection: import_zod9.z.enum(["all", "selected"]),
+  metadata: EvaluationMetadataSchema,
+  judge: EvalJudgeIdentitySchema.optional(),
+  status: StudioEvalRunSummarySchema.shape.status,
+  createdAt: import_zod9.z.string(),
+  startedAt: import_zod9.z.string().nullable(),
+  endedAt: import_zod9.z.string().nullable(),
+  cancelRequestedAt: import_zod9.z.string().nullable(),
+  suiteCount: import_zod9.z.number().int().nonnegative(),
+  completedSuites: import_zod9.z.number().int().nonnegative(),
+  totalAttempts: import_zod9.z.number().int().nonnegative(),
+  completedAttempts: import_zod9.z.number().int().nonnegative(),
+  counts: import_zod9.z.object({
+    passed: import_zod9.z.number(),
+    failed: import_zod9.z.number(),
+    error: import_zod9.z.number(),
+    cancelled: import_zod9.z.number()
+  }),
+  costs: EvalCostsSchema.optional(),
+  legacy: import_zod9.z.boolean().optional()
+});
+var StudioEvaluationHistorySchema = import_zod9.z.object({
+  runs: import_zod9.z.array(StudioEvaluationSummarySchema)
+});
+var StudioEvaluationDetailSchema = import_zod9.z.object({
+  run: StudioEvaluationSummarySchema.extend({
+    suites: import_zod9.z.array(StudioEvalRunSummarySchema)
+  })
+});
+var StudioEvaluationResultsSchema = import_zod9.z.object({
+  run: StudioEvaluationSummarySchema.extend({
+    suites: import_zod9.z.array(StudioEvalDetailSchema.shape.run)
+  })
+});
+
+// src/evals/judge.ts
+var import_zod10 = require("zod");
 function createEvalJudge({
   model,
   id: id2 = `${model.provider.id}/${model.modelId}`,
@@ -9192,7 +11066,7 @@ function createEvalJudge({
         responseFormat: {
           type: "json",
           name: "eval_verdict",
-          schema: import_zod8.z.toJSONSchema(EvalVerdictSchema)
+          schema: import_zod10.z.toJSONSchema(EvalVerdictSchema)
         }
       });
       const result = await judge2.invoke([
@@ -9510,10 +11384,16 @@ async function createStudioEvalJudge(options) {
   EvalRunResultSchema,
   EvalSuiteSchema,
   EvalWireEventSchema,
+  EvaluationMetadataSchema,
   ExecutionRequestError,
   StudioEvalJudgeRequestSchema,
   StudioEvalJudgeResponseSchema,
   StudioEvalStartRequestSchema,
+  StudioEvaluationDetailSchema,
+  StudioEvaluationHistorySchema,
+  StudioEvaluationResultsSchema,
+  StudioEvaluationStartRequestSchema,
+  StudioEvaluationSummarySchema,
   createAgent,
   createChatRouteHandler,
   createCheckpointRouteHandler,