@kortyx/agent 0.38.1 → 0.40.0

package/dist/evals.js

@@ -24,6 +24,7 @@ __export(evals_exports, {
   EvalCostAmountSchema: () => EvalCostAmountSchema,
   EvalCostsSchema: () => EvalCostsSchema,
   EvalEvidencePolicySchema: () => EvalEvidencePolicySchema,
+  EvalExecutionSettingsSchema: () => EvalExecutionSettingsSchema,
   EvalIssueSchema: () => EvalIssueSchema,
   EvalJudgeIdentitySchema: () => EvalJudgeIdentitySchema,
   EvalJudgeUsageSchema: () => EvalJudgeUsageSchema,
@@ -33,11 +34,15 @@ __export(evals_exports, {
   EvalRemoteRunRequestSchema: () => EvalRemoteRunRequestSchema,
   EvalResumeResponseSchema: () => EvalResumeResponseSchema,
   EvalRunResultSchema: () => EvalRunResultSchema,
+  EvalSettingsResponseSchema: () => EvalSettingsResponseSchema,
+  EvalSettingsSchema: () => EvalSettingsSchema,
   EvalStepResultSchema: () => EvalStepResultSchema,
   EvalSuiteSchema: () => EvalSuiteSchema,
+  EvalTerminationSchema: () => EvalTerminationSchema,
   EvalVerdictSchema: () => EvalVerdictSchema,
   EvalWireEventSchema: () => EvalWireEventSchema,
   EvaluationMetadataSchema: () => EvaluationMetadataSchema,
+  ResolvedEvalSettingsSchema: () => ResolvedEvalSettingsSchema,
   StudioEvalDetailSchema: () => StudioEvalDetailSchema,
   StudioEvalHistorySchema: () => StudioEvalHistorySchema,
   StudioEvalJudgeRequestSchema: () => StudioEvalJudgeRequestSchema,
@@ -54,14 +59,16 @@ __export(evals_exports, {
   createStudioEvalJudge: () => createStudioEvalJudge,
   defineSuite: () => defineSuite,
   getEvalGradeEvidence: () => getEvalGradeEvidence,
-  parseEvalSuite: () => parseEvalSuite
+  parseEvalSuite: () => parseEvalSuite,
+  resolveEvalSettings: () => resolveEvalSettings
 });
 module.exports = __toCommonJS(evals_exports);
 
 // src/evals/contracts.ts
 var import_errors = require("@kortyx/core/errors");
 var import_browser = require("@kortyx/prompts/browser");
-var import_zod2 = require("zod");
+var import_telemetry_contracts = require("@kortyx/telemetry-contracts");
+var import_zod3 = require("zod");
 
 // src/evals/evidence-policy.ts
 var import_zod = require("zod");
@@ -101,30 +108,126 @@ var EvalEvidencePolicySchema = import_zod.z.object({
   ]).optional()
 }).strict();
 
+// src/evals/settings.ts
+var import_zod2 = require("zod");
+var timeout = import_zod2.z.number().int().min(1).max(2147483647);
+var EvalSettingsSchema = import_zod2.z.object({
+  repetitions: import_zod2.z.number().int().min(1).max(20).optional(),
+  concurrency: import_zod2.z.number().int().min(1).max(20).optional(),
+  caseTimeoutMs: timeout.optional(),
+  runTimeoutMs: timeout.optional(),
+  judge: import_zod2.z.enum(["studio", "app"]).optional()
+}).strict();
+var EvalExecutionSettingsSchema = import_zod2.z.object({
+  defaults: EvalSettingsSchema.omit({ runTimeoutMs: true, judge: true }),
+  limits: import_zod2.z.object({
+    concurrency: import_zod2.z.number().int().positive().max(20).optional(),
+    caseTimeoutMs: timeout.optional()
+  }).strict(),
+  overrides: import_zod2.z.array(import_zod2.z.enum(["repetitions", "concurrency", "caseTimeoutMs"]))
+}).strict();
+var ResolvedEvalSettingsSchema = import_zod2.z.object({
+  values: EvalSettingsSchema.required(),
+  sources: import_zod2.z.record(
+    import_zod2.z.enum([
+      "repetitions",
+      "concurrency",
+      "caseTimeoutMs",
+      "runTimeoutMs",
+      "judge"
+    ]),
+    import_zod2.z.enum(["run", "studio", "sdk", "sdk-default", "studio-default"])
+  )
+}).strict();
+var EvalSettingsResponseSchema = import_zod2.z.object({
+  defaults: EvalSettingsSchema,
+  installation: EvalSettingsSchema,
+  maxRunTimeoutMs: timeout,
+  canEdit: import_zod2.z.boolean()
+});
+var EvalTerminationSchema = import_zod2.z.object({
+  code: import_zod2.z.enum([
+    "EVAL_RUN_TIMEOUT",
+    "EVAL_CANCELLED",
+    "EVAL_LEASE_LOST",
+    "EVAL_EXECUTION_UNKNOWN",
+    "EVAL_EXECUTOR_FAILED"
+  ]),
+  message: import_zod2.z.string(),
+  timeoutMs: timeout.optional(),
+  phase: import_zod2.z.string().optional(),
+  cleanup: import_zod2.z.enum(["signalled", "unknown"]).optional(),
+  diagnosticId: import_zod2.z.string().uuid().optional()
+}).strict();
+function resolveEvalSettings(overrides = {}, studio = {}, execution, installation = {}, maxRunTimeoutMs = 2147483647) {
+  const values = {
+    repetitions: 1,
+    concurrency: 1,
+    caseTimeoutMs: 6e4,
+    runTimeoutMs: 30 * 6e4,
+    judge: "studio"
+  };
+  const sources = {
+    repetitions: "sdk-default",
+    concurrency: "sdk-default",
+    caseTimeoutMs: "sdk-default",
+    runTimeoutMs: "studio-default",
+    judge: "studio-default"
+  };
+  for (const [input, source] of [
+    [execution?.defaults ?? {}, "sdk"],
+    [installation, "studio"],
+    [studio, "studio"],
+    [overrides, "run"]
+  ]) {
+    const parsed = EvalSettingsSchema.parse(input);
+    for (const key of Object.keys(parsed)) {
+      if (parsed[key] !== void 0) {
+        Object.assign(values, { [key]: parsed[key] });
+        sources[key] = source;
+      }
+    }
+  }
+  if (values.runTimeoutMs > maxRunTimeoutMs)
+    throw new Error(
+      `Evaluation timeout exceeds the administrator maximum of ${maxRunTimeoutMs} ms.`
+    );
+  for (const key of ["concurrency", "caseTimeoutMs"]) {
+    const max = execution?.limits[key];
+    if (max !== void 0 && values[key] > max)
+      throw new Error(`${key} exceeds the application maximum of ${max}.`);
+  }
+  if (!execution?.overrides.includes("caseTimeoutMs") && (overrides.caseTimeoutMs !== void 0 || studio.caseTimeoutMs !== void 0 || installation.caseTimeoutMs !== void 0))
+    throw new Error(
+      "Update the consumer SDK to support case timeout overrides."
+    );
+  return { values, sources };
+}
+
 // src/evals/contracts.ts
-var id2 = import_zod2.z.string().trim().min(1).max(256);
-var failureDescriptor = import_zod2.z.custom(import_errors.isFailureDescriptor).transform(
+var id2 = import_zod3.z.string().trim().min(1).max(256);
+var failureDescriptor = import_zod3.z.custom(import_errors.isFailureDescriptor).transform(
   (value) => JSON.parse(JSON.stringify((0, import_errors.serializeFailure)(value)))
 );
-var handler = import_zod2.z.object({ using: id2, params: import_zod2.z.json().optional() }).strict();
-var EvalResumeResponseSchema = import_zod2.z.discriminatedUnion("type", [
-  import_zod2.z.object({ type: import_zod2.z.literal("text"), text: import_zod2.z.string() }).strict(),
-  import_zod2.z.object({ type: import_zod2.z.literal("select"), ids: import_zod2.z.array(import_zod2.z.string()) }).strict(),
-  import_zod2.z.object({ type: import_zod2.z.literal("value"), value: import_zod2.z.json() }).strict(),
-  import_zod2.z.object({ type: import_zod2.z.literal("cancel") }).strict()
+var handler = import_zod3.z.object({ using: id2, params: import_zod3.z.json().optional() }).strict();
+var EvalResumeResponseSchema = import_zod3.z.discriminatedUnion("type", [
+  import_zod3.z.object({ type: import_zod3.z.literal("text"), text: import_zod3.z.string() }).strict(),
+  import_zod3.z.object({ type: import_zod3.z.literal("select"), ids: import_zod3.z.array(import_zod3.z.string()) }).strict(),
+  import_zod3.z.object({ type: import_zod3.z.literal("value"), value: import_zod3.z.json() }).strict(),
+  import_zod3.z.object({ type: import_zod3.z.literal("cancel") }).strict()
 ]);
-var expectation = import_zod2.z.object({
-  type: import_zod2.z.enum(["answer", "interrupt"]),
+var expectation = import_zod3.z.object({
+  type: import_zod3.z.enum(["answer", "interrupt"]),
   schemaId: id2.optional(),
   schemaVersion: id2.optional(),
-  outputs: import_zod2.z.array(import_zod2.z.object({ schemaId: id2, schemaVersion: id2.optional() }).strict()).optional(),
-  criteria: import_zod2.z.array(
-    import_zod2.z.union([
-      import_zod2.z.string().trim().min(1),
-      import_zod2.z.object({ id: id2, text: import_zod2.z.string().trim().min(1) }).strict()
+  outputs: import_zod3.z.array(import_zod3.z.object({ schemaId: id2, schemaVersion: id2.optional() }).strict()).optional(),
+  criteria: import_zod3.z.array(
+    import_zod3.z.union([
+      import_zod3.z.string().trim().min(1),
+      import_zod3.z.object({ id: id2, text: import_zod3.z.string().trim().min(1) }).strict()
     ])
   ).optional(),
-  reference: import_zod2.z.json().optional()
+  reference: import_zod3.z.json().optional()
 }).strict().superRefine((value, ctx) => {
   if (value.type === "answer" && (value.schemaId || value.schemaVersion))
     ctx.addIssue({
@@ -140,21 +243,21 @@ var expectation = import_zod2.z.object({
       message: "Criterion IDs must be unique within a step."
     });
 });
-var EvalSuiteSchema = import_zod2.z.object({
+var EvalSuiteSchema = import_zod3.z.object({
   evidence: EvalEvidencePolicySchema.optional(),
   id: id2,
-  name: import_zod2.z.string().optional(),
-  cases: import_zod2.z.array(
-    import_zod2.z.object({
+  name: import_zod3.z.string().optional(),
+  cases: import_zod3.z.array(
+    import_zod3.z.object({
       id: id2,
-      name: import_zod2.z.string().optional(),
-      params: import_zod2.z.json().optional(),
+      name: import_zod3.z.string().optional(),
+      params: import_zod3.z.json().optional(),
       workflowId: id2.optional(),
-      steps: import_zod2.z.array(
-        import_zod2.z.union([
-          import_zod2.z.object({ message: import_zod2.z.string().min(1), expect: expectation }).strict(),
-          import_zod2.z.object({
-            resume: import_zod2.z.union([EvalResumeResponseSchema, handler]),
+      steps: import_zod3.z.array(
+        import_zod3.z.union([
+          import_zod3.z.object({ message: import_zod3.z.string().min(1), expect: expectation }).strict(),
+          import_zod3.z.object({
+            resume: import_zod3.z.union([EvalResumeResponseSchema, handler]),
             expect: expectation
           }).strict()
         ])
@@ -162,44 +265,44 @@ var EvalSuiteSchema = import_zod2.z.object({
     }).strict()
   ).min(1)
 }).strict();
-var EvalVerdictSchema = import_zod2.z.object({
-  passed: import_zod2.z.boolean(),
-  reason: import_zod2.z.string().trim().min(1),
-  evidence: import_zod2.z.array(import_zod2.z.string().min(1))
+var EvalVerdictSchema = import_zod3.z.object({
+  passed: import_zod3.z.boolean(),
+  reason: import_zod3.z.string().trim().min(1),
+  evidence: import_zod3.z.array(import_zod3.z.string().min(1))
 }).strict();
-var EvalObservationSchema = import_zod2.z.object({
+var EvalObservationSchema = import_zod3.z.object({
   failure: failureDescriptor.optional(),
-  diagnosticId: import_zod2.z.uuid().optional(),
-  promptUsage: import_zod2.z.array(
-    import_zod2.z.object({
-      id: import_zod2.z.string(),
-      version: import_zod2.z.number().int().positive(),
-      hash: import_zod2.z.string().regex(/^[a-f0-9]{64}$/),
-      environment: import_zod2.z.string(),
-      snapshotRevision: import_zod2.z.string(),
-      model: import_zod2.z.string().optional()
+  diagnosticId: import_zod3.z.uuid().optional(),
+  promptUsage: import_zod3.z.array(
+    import_zod3.z.object({
+      id: import_zod3.z.string(),
+      version: import_zod3.z.number().int().positive(),
+      hash: import_zod3.z.string().regex(/^[a-f0-9]{64}$/),
+      environment: import_zod3.z.string(),
+      snapshotRevision: import_zod3.z.string(),
+      model: import_zod3.z.string().optional()
     }).strict()
   ).optional(),
-  type: import_zod2.z.enum(["answer", "interrupt", "error", "cancelled"]),
-  text: import_zod2.z.string(),
-  structured: import_zod2.z.array(import_zod2.z.json()),
-  events: import_zod2.z.array(import_zod2.z.json()).optional(),
-  runId: import_zod2.z.string().optional(),
-  checkpointId: import_zod2.z.string().optional(),
-  interrupt: import_zod2.z.object({
-    requestId: import_zod2.z.string(),
-    kind: import_zod2.z.enum(["text", "choice", "multi-choice", "custom"]),
-    question: import_zod2.z.string().optional(),
-    schemaId: import_zod2.z.string().optional(),
-    schemaVersion: import_zod2.z.string().optional(),
-    options: import_zod2.z.array(
-      import_zod2.z.object({
-        id: import_zod2.z.string(),
-        label: import_zod2.z.string(),
-        description: import_zod2.z.string().optional()
+  type: import_zod3.z.enum(["answer", "interrupt", "error", "cancelled"]),
+  text: import_zod3.z.string(),
+  structured: import_zod3.z.array(import_zod3.z.json()),
+  events: import_zod3.z.array(import_zod3.z.json()).optional(),
+  runId: import_zod3.z.string().optional(),
+  checkpointId: import_zod3.z.string().optional(),
+  interrupt: import_zod3.z.object({
+    requestId: import_zod3.z.string(),
+    kind: import_zod3.z.enum(["text", "choice", "multi-choice", "custom"]),
+    question: import_zod3.z.string().optional(),
+    schemaId: import_zod3.z.string().optional(),
+    schemaVersion: import_zod3.z.string().optional(),
+    options: import_zod3.z.array(
+      import_zod3.z.object({
+        id: import_zod3.z.string(),
+        label: import_zod3.z.string(),
+        description: import_zod3.z.string().optional()
       }).strict()
     ),
-    request: import_zod2.z.json().optional()
+    request: import_zod3.z.json().optional()
   }).strict().optional()
 }).strict().superRefine((value, ctx) => {
   if (value.type === "interrupt" !== Boolean(value.interrupt))
@@ -208,11 +311,16 @@ var EvalObservationSchema = import_zod2.z.object({
       message: "Interrupt observations require exactly one interrupt."
     });
 });
-var status = import_zod2.z.enum(["passed", "failed", "error", "cancelled", "ungraded"]);
-var EvalIssueSchema = import_zod2.z.object({
+var status = import_zod3.z.enum(["passed", "failed", "error", "cancelled", "ungraded"]);
+var EvalIssueSchema = import_zod3.z.object({
+  exception: import_telemetry_contracts.DiagnosticContentSchema.optional(),
+  details: import_zod3.z.object({
+    timeoutMs: import_zod3.z.number().positive().optional(),
+    httpStatus: import_zod3.z.number().int().min(100).max(599).optional()
+  }).strict().optional(),
   failure: failureDescriptor.optional(),
-  diagnosticId: import_zod2.z.uuid().optional(),
-  phase: import_zod2.z.enum([
+  diagnosticId: import_zod3.z.uuid().optional(),
+  phase: import_zod3.z.enum([
     "params",
     "setup",
     "execute",
@@ -223,196 +331,200 @@ var EvalIssueSchema = import_zod2.z.object({
     "cleanup",
     "reporting"
   ]),
-  code: import_zod2.z.string(),
-  message: import_zod2.z.string()
+  code: import_zod3.z.string(),
+  message: import_zod3.z.string()
 }).strict();
 var issue = EvalIssueSchema;
-var EvalJudgeUsageSchema = import_zod2.z.object({
-  provider: import_zod2.z.string().min(1),
-  model: import_zod2.z.string().min(1),
-  occurredAt: import_zod2.z.iso.datetime(),
-  usage: import_zod2.z.object({
-    input: import_zod2.z.number().finite().nonnegative().optional(),
-    output: import_zod2.z.number().finite().nonnegative().optional(),
-    total: import_zod2.z.number().finite().nonnegative().optional(),
-    reasoning: import_zod2.z.number().finite().nonnegative().optional(),
-    cacheRead: import_zod2.z.number().finite().nonnegative().optional(),
-    cacheWrite: import_zod2.z.number().finite().nonnegative().optional(),
-    cacheWrite1h: import_zod2.z.number().finite().nonnegative().optional(),
-    outputIncludesReasoning: import_zod2.z.boolean().optional(),
-    inputIncludesCacheRead: import_zod2.z.boolean().optional(),
-    inputIncludesCacheWrite: import_zod2.z.boolean().optional()
+var EvalJudgeUsageSchema = import_zod3.z.object({
+  provider: import_zod3.z.string().min(1),
+  model: import_zod3.z.string().min(1),
+  occurredAt: import_zod3.z.iso.datetime(),
+  usage: import_zod3.z.object({
+    input: import_zod3.z.number().finite().nonnegative().optional(),
+    output: import_zod3.z.number().finite().nonnegative().optional(),
+    total: import_zod3.z.number().finite().nonnegative().optional(),
+    reasoning: import_zod3.z.number().finite().nonnegative().optional(),
+    cacheRead: import_zod3.z.number().finite().nonnegative().optional(),
+    cacheWrite: import_zod3.z.number().finite().nonnegative().optional(),
+    cacheWrite1h: import_zod3.z.number().finite().nonnegative().optional(),
+    outputIncludesReasoning: import_zod3.z.boolean().optional(),
+    inputIncludesCacheRead: import_zod3.z.boolean().optional(),
+    inputIncludesCacheWrite: import_zod3.z.boolean().optional()
   }).strict().optional(),
-  pricingContext: import_zod2.z.object({
-    serviceTier: import_zod2.z.string().min(1).max(100).optional(),
-    inferenceGeo: import_zod2.z.string().min(1).max(100).optional(),
-    speed: import_zod2.z.string().min(1).max(100).optional()
+  pricingContext: import_zod3.z.object({
+    serviceTier: import_zod3.z.string().min(1).max(100).optional(),
+    inferenceGeo: import_zod3.z.string().min(1).max(100).optional(),
+    speed: import_zod3.z.string().min(1).max(100).optional()
   }).strict().optional(),
-  pricing: import_zod2.z.object({
-    source: import_zod2.z.literal("provider"),
-    currency: import_zod2.z.literal("USD"),
-    actualCostMicros: import_zod2.z.number().int().nonnegative().safe()
+  pricing: import_zod3.z.object({
+    source: import_zod3.z.literal("provider"),
+    currency: import_zod3.z.literal("USD"),
+    actualCostMicros: import_zod3.z.number().int().nonnegative().safe()
   }).strict().optional()
 }).strict();
-var EvalStepResultSchema = import_zod2.z.object({
-  evidence: import_zod2.z.object({
-    version: import_zod2.z.literal("compact-v1"),
-    history: import_zod2.z.boolean(),
+var EvalStepResultSchema = import_zod3.z.object({
+  evidence: import_zod3.z.object({
+    version: import_zod3.z.literal("compact-v1"),
+    history: import_zod3.z.boolean(),
     observation: EvalObservationSchema
   }).strict().optional(),
-  index: import_zod2.z.number().int().nonnegative(),
-  input: import_zod2.z.union([
-    import_zod2.z.object({ message: import_zod2.z.string() }).strict(),
-    import_zod2.z.object({ resume: EvalResumeResponseSchema }).strict()
+  index: import_zod3.z.number().int().nonnegative(),
+  input: import_zod3.z.union([
+    import_zod3.z.object({ message: import_zod3.z.string() }).strict(),
+    import_zod3.z.object({ resume: EvalResumeResponseSchema }).strict()
   ]),
   expectation,
   observation: EvalObservationSchema,
-  reference: import_zod2.z.json().optional(),
+  reference: import_zod3.z.json().optional(),
   status,
-  reason: import_zod2.z.string().optional(),
-  judgeCalls: import_zod2.z.number().int().nonnegative().optional(),
-  judgeUsage: import_zod2.z.array(EvalJudgeUsageSchema).optional(),
-  criteria: import_zod2.z.array(
-    EvalVerdictSchema.extend({ id: import_zod2.z.string(), text: import_zod2.z.string() })
+  reason: import_zod3.z.string().optional(),
+  judgeCalls: import_zod3.z.number().int().nonnegative().optional(),
+  judgeUsage: import_zod3.z.array(EvalJudgeUsageSchema).optional(),
+  criteria: import_zod3.z.array(
+    EvalVerdictSchema.extend({ id: import_zod3.z.string(), text: import_zod3.z.string() })
   )
 }).strict();
-var runtimeExecution = import_zod2.z.object({ sessionId: import_zod2.z.string().min(1), runId: import_zod2.z.string().min(1) }).strict();
-var EvalCaseResultSchema = import_zod2.z.object({
+var runtimeExecution = import_zod3.z.object({ sessionId: import_zod3.z.string().min(1), runId: import_zod3.z.string().min(1) }).strict();
+var EvalCaseResultSchema = import_zod3.z.object({
   verification: EvalVerdictSchema.optional(),
-  phaseDurationsMs: import_zod2.z.partialRecord(issue.shape.phase, import_zod2.z.number().finite().nonnegative()).optional(),
+  phaseDurationsMs: import_zod3.z.partialRecord(issue.shape.phase, import_zod3.z.number().finite().nonnegative()).optional(),
   caseId: id2,
-  repetition: import_zod2.z.number().int().positive(),
-  attemptId: import_zod2.z.uuid().optional(),
-  runtimeExecutions: import_zod2.z.array(runtimeExecution).optional(),
-  sessionId: import_zod2.z.string(),
+  repetition: import_zod3.z.number().int().positive(),
+  attemptId: import_zod3.z.uuid().optional(),
+  runtimeExecutions: import_zod3.z.array(runtimeExecution).optional(),
+  sessionId: import_zod3.z.string(),
   status,
-  durationMs: import_zod2.z.number().nonnegative(),
-  steps: import_zod2.z.array(EvalStepResultSchema),
-  errors: import_zod2.z.array(issue)
+  durationMs: import_zod3.z.number().nonnegative(),
+  steps: import_zod3.z.array(EvalStepResultSchema),
+  errors: import_zod3.z.array(issue)
 }).strict();
-var EvalJudgeIdentitySchema = import_zod2.z.object({
+var EvalJudgeIdentitySchema = import_zod3.z.object({
   id: id2,
   version: id2,
-  location: import_zod2.z.enum(["app", "studio"]).optional()
+  location: import_zod3.z.enum(["app", "studio"]).optional()
 }).strict();
 var judge = EvalJudgeIdentitySchema;
-var StudioEvalJudgeRequestSchema = import_zod2.z.object({
+var StudioEvalJudgeRequestSchema = import_zod3.z.object({
   environment: id2,
   judge: EvalJudgeIdentitySchema,
-  criterion: import_zod2.z.object({ id: id2, text: import_zod2.z.string().trim().min(1).max(16384) }).strict(),
+  criterion: import_zod3.z.object({ id: id2, text: import_zod3.z.string().trim().min(1).max(16384) }).strict(),
   input: EvalStepResultSchema.shape.input,
   observation: EvalObservationSchema,
-  reference: import_zod2.z.json().optional(),
-  conversation: import_zod2.z.array(EvalStepResultSchema).max(100)
+  reference: import_zod3.z.json().optional(),
+  conversation: import_zod3.z.array(EvalStepResultSchema).max(100)
 }).strict();
-var StudioEvalJudgeResponseSchema = import_zod2.z.object({
+var StudioEvalJudgeResponseSchema = import_zod3.z.object({
   judge: EvalJudgeIdentitySchema,
   verdict: EvalVerdictSchema,
-  usage: import_zod2.z.array(EvalJudgeUsageSchema).optional()
+  usage: import_zod3.z.array(EvalJudgeUsageSchema).optional()
 }).strict();
-var EvalRunResultSchema = import_zod2.z.object({
-  id: import_zod2.z.uuid(),
+var EvalRunResultSchema = import_zod3.z.object({
+  id: import_zod3.z.uuid(),
   suiteId: id2,
-  suiteRevision: import_zod2.z.string().regex(/^[a-f0-9]{64}$/),
+  suiteRevision: import_zod3.z.string().regex(/^[a-f0-9]{64}$/),
   suite: EvalSuiteSchema,
   judge: judge.optional(),
-  startedAt: import_zod2.z.iso.datetime(),
-  durationMs: import_zod2.z.number().nonnegative(),
+  startedAt: import_zod3.z.iso.datetime(),
+  durationMs: import_zod3.z.number().nonnegative(),
   status,
-  counts: import_zod2.z.object({
-    passed: import_zod2.z.number().int().nonnegative(),
-    failed: import_zod2.z.number().int().nonnegative(),
-    error: import_zod2.z.number().int().nonnegative(),
-    cancelled: import_zod2.z.number().int().nonnegative(),
-    ungraded: import_zod2.z.number().int().nonnegative().optional()
+  counts: import_zod3.z.object({
+    passed: import_zod3.z.number().int().nonnegative(),
+    failed: import_zod3.z.number().int().nonnegative(),
+    error: import_zod3.z.number().int().nonnegative(),
+    cancelled: import_zod3.z.number().int().nonnegative(),
+    ungraded: import_zod3.z.number().int().nonnegative().optional()
   }).strict(),
-  cases: import_zod2.z.array(EvalCaseResultSchema),
-  errors: import_zod2.z.array(issue)
+  cases: import_zod3.z.array(EvalCaseResultSchema),
+  errors: import_zod3.z.array(issue)
 }).strict();
-var EvalManifestSchema = import_zod2.z.object({
-  schemaVersion: import_zod2.z.literal(1),
-  studioJudging: import_zod2.z.literal(true).optional(),
-  promptContracts: import_zod2.z.array(
-    import_zod2.z.object({
-      id: import_zod2.z.string(),
-      format: import_zod2.z.enum(["system-user", "chat"]),
-      variablesSchema: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()),
-      configSchema: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown())
+var EvalManifestSchema = import_zod3.z.object({
+  execution: EvalExecutionSettingsSchema.optional(),
+  schemaVersion: import_zod3.z.literal(1),
+  studioJudging: import_zod3.z.literal(true).optional(),
+  promptContracts: import_zod3.z.array(
+    import_zod3.z.object({
+      id: import_zod3.z.string(),
+      format: import_zod3.z.enum(["system-user", "chat"]),
+      variablesSchema: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()),
+      configSchema: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown())
     }).strict()
   ).optional(),
-  attemptScheduling: import_zod2.z.literal(true).optional(),
-  suites: import_zod2.z.array(EvalSuiteSchema),
-  responders: import_zod2.z.array(
-    import_zod2.z.object({
+  attemptScheduling: import_zod3.z.literal(true).optional(),
+  suites: import_zod3.z.array(EvalSuiteSchema),
+  responders: import_zod3.z.array(
+    import_zod3.z.object({
       name: id2,
       schemaId: id2.optional(),
       schemaVersion: id2.optional()
     }).strict()
   ),
-  references: import_zod2.z.array(id2),
-  paramsSchema: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
+  references: import_zod3.z.array(id2),
+  paramsSchema: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional(),
   judge: judge.optional()
 }).strict();
-var EvalProgressSchema = import_zod2.z.discriminatedUnion("type", [
-  import_zod2.z.object({
-    type: import_zod2.z.literal("case-dispatch"),
+var EvalProgressSchema = import_zod3.z.discriminatedUnion("type", [
+  import_zod3.z.object({
+    type: import_zod3.z.literal("case-dispatch"),
     caseId: id2,
-    repetition: import_zod2.z.number().int().positive(),
-    status: import_zod2.z.enum(["queued", "retrying", "reconnecting"]),
-    retryAt: import_zod2.z.iso.datetime().optional(),
-    httpStatus: import_zod2.z.number().int().min(100).max(599).optional(),
-    executionId: import_zod2.z.uuid().optional(),
-    generation: import_zod2.z.uuid().optional()
+    repetition: import_zod3.z.number().int().positive(),
+    status: import_zod3.z.enum(["queued", "retrying", "reconnecting"]),
+    retryAt: import_zod3.z.iso.datetime().optional(),
+    httpStatus: import_zod3.z.number().int().min(100).max(599).optional(),
+    executionId: import_zod3.z.uuid().optional(),
+    generation: import_zod3.z.uuid().optional()
   }).strict(),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("case-runtime-associated"),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("case-runtime-associated"),
     caseId: id2,
-    repetition: import_zod2.z.number().int().positive(),
-    attemptId: import_zod2.z.uuid(),
+    repetition: import_zod3.z.number().int().positive(),
+    attemptId: import_zod3.z.uuid(),
     execution: runtimeExecution
   }).strict(),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("run-started"),
-    caseIds: import_zod2.z.array(id2).min(1),
-    repetitions: import_zod2.z.number().int().positive(),
-    concurrency: import_zod2.z.number().int().positive()
+  import_zod3.z.object({
+    type: import_zod3.z.literal("run-started"),
+    caseIds: import_zod3.z.array(id2).min(1),
+    repetitions: import_zod3.z.number().int().positive(),
+    concurrency: import_zod3.z.number().int().positive()
   }).strict(),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("case-progress"),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("case-progress"),
     caseId: id2,
-    repetition: import_zod2.z.number().int().positive(),
+    repetition: import_zod3.z.number().int().positive(),
     phase: issue.shape.phase,
-    stepIndex: import_zod2.z.number().int().nonnegative().optional()
+    stepIndex: import_zod3.z.number().int().nonnegative().optional()
   }).strict(),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("case-started"),
-    attemptId: import_zod2.z.uuid().optional(),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("case-started"),
+    attemptId: import_zod3.z.uuid().optional(),
     caseId: id2,
-    repetition: import_zod2.z.number().int().positive(),
-    sessionId: import_zod2.z.string()
+    repetition: import_zod3.z.number().int().positive(),
+    sessionId: import_zod3.z.string()
   }).strict(),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("step-completed"),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("step-completed"),
     caseId: id2,
-    repetition: import_zod2.z.number().int().positive(),
+    repetition: import_zod3.z.number().int().positive(),
     step: EvalStepResultSchema
   }).strict(),
-  import_zod2.z.object({ type: import_zod2.z.literal("case-completed"), result: EvalCaseResultSchema }).strict()
+  import_zod3.z.object({ type: import_zod3.z.literal("case-completed"), result: EvalCaseResultSchema }).strict()
 ]);
-var EvalRemoteRunRequestSchema = import_zod2.z.object({
+var EvalRemoteRunRequestSchema = import_zod3.z.object({
   promptSnapshot: import_browser.PromptSnapshotSchema.optional(),
-  promptGroupName: import_zod2.z.string().optional(),
+  promptGroupName: import_zod3.z.string().optional(),
+  caseTimeoutMs: EvalSettingsSchema.shape.caseTimeoutMs,
+  runTimeoutMs: EvalSettingsSchema.shape.runTimeoutMs,
+  resolvedSettings: ResolvedEvalSettingsSchema.optional(),
   suiteId: id2,
-  suiteRevision: import_zod2.z.string().regex(/^[a-f0-9]{64}$/),
-  grading: import_zod2.z.enum(["app", "studio"]).optional(),
+  suiteRevision: import_zod3.z.string().regex(/^[a-f0-9]{64}$/),
+  grading: import_zod3.z.enum(["app", "studio"]).optional(),
   judge: EvalJudgeIdentitySchema.optional(),
-  caseIds: import_zod2.z.array(id2).min(1).max(100).optional(),
-  repetitions: import_zod2.z.number().int().min(1).max(20).default(1),
-  concurrency: import_zod2.z.number().int().min(1).max(20).default(1),
-  attempt: import_zod2.z.object({
+  caseIds: import_zod3.z.array(id2).min(1).max(100).optional(),
+  repetitions: import_zod3.z.number().int().min(1).max(20).default(1),
+  concurrency: import_zod3.z.number().int().min(1).max(20).default(1),
+  attempt: import_zod3.z.object({
     caseId: id2,
-    repetition: import_zod2.z.number().int().min(1).max(20),
-    evaluationId: import_zod2.z.uuid()
+    repetition: import_zod3.z.number().int().min(1).max(20),
+    evaluationId: import_zod3.z.uuid()
   }).strict().optional()
 }).strict();
 var StudioEvalStartRequestSchema = EvalRemoteRunRequestSchema.omit({
@@ -422,39 +534,42 @@ var StudioEvalStartRequestSchema = EvalRemoteRunRequestSchema.omit({
   promptGroupName: true,
   attempt: true
 }).extend({
-  promptSelection: import_zod2.z.discriminatedUnion("type", [
-    import_zod2.z.object({ type: import_zod2.z.literal("live") }).strict(),
-    import_zod2.z.object({
-      type: import_zod2.z.literal("single"),
-      id: import_zod2.z.string(),
-      version: import_zod2.z.number().int().positive()
+  promptSelection: import_zod3.z.discriminatedUnion("type", [
+    import_zod3.z.object({ type: import_zod3.z.literal("live") }).strict(),
+    import_zod3.z.object({
+      type: import_zod3.z.literal("single"),
+      id: import_zod3.z.string(),
+      version: import_zod3.z.number().int().positive()
     }).strict(),
-    import_zod2.z.object({ type: import_zod2.z.literal("group"), groupId: import_zod2.z.uuid() }).strict()
+    import_zod3.z.object({ type: import_zod3.z.literal("group"), groupId: import_zod3.z.uuid() }).strict()
   ]).optional(),
-  targetId: import_zod2.z.string().min(1).max(128),
-  judge: import_zod2.z.enum(["studio", "app"]).default("studio")
+  targetId: import_zod3.z.string().min(1).max(128),
+  judge: import_zod3.z.enum(["studio", "app"]).optional(),
+  repetitions: EvalSettingsSchema.shape.repetitions,
+  concurrency: EvalSettingsSchema.shape.concurrency
 });
-var EvalWireEventSchema = import_zod2.z.discriminatedUnion("type", [
-  import_zod2.z.object({
-    type: import_zod2.z.literal("execution-status"),
-    state: import_zod2.z.enum(["queued", "running", "completed", "cancelled", "unknown"])
+var EvalWireEventSchema = import_zod3.z.discriminatedUnion("type", [
+  import_zod3.z.object({
+    type: import_zod3.z.literal("execution-status"),
+    state: import_zod3.z.enum(["queued", "running", "completed", "cancelled", "unknown"])
   }).strict(),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("progress"),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("progress"),
     event: EvalProgressSchema,
-    sequence: import_zod2.z.number().int().positive().optional()
+    sequence: import_zod3.z.number().int().positive().optional()
   }).strict(),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("result"),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("result"),
     result: EvalRunResultSchema,
-    sequence: import_zod2.z.number().int().positive().optional()
+    sequence: import_zod3.z.number().int().positive().optional()
   }).strict(),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("error"),
-    message: import_zod2.z.string(),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("error"),
+    exception: import_telemetry_contracts.DiagnosticContentSchema.optional(),
+    message: import_zod3.z.string(),
     failure: failureDescriptor.optional(),
-    diagnosticId: import_zod2.z.uuid().optional(),
-    sequence: import_zod2.z.number().int().positive().optional()
+    diagnosticId: import_zod3.z.uuid().optional(),
+    sequence: import_zod3.z.number().int().positive().optional()
   }).strict()
 ]);
 var EvalConfigurationError = class extends Error {
@@ -489,7 +604,8 @@ function defineSuite(suite) {
 
 // src/evals/errors.ts
 var import_errors2 = require("@kortyx/core/errors");
-var import_zod3 = require("zod");
+var import_telemetry_contracts2 = require("@kortyx/telemetry-contracts");
+var import_zod4 = require("zod");
 var messages = {
   params: "Case parameters failed validation.",
   setup: "Case setup failed.",
@@ -505,6 +621,9 @@ function createEvalIssue(phase, error, options = {}) {
   const control = (0, import_errors2.isControlFlowError)(error);
   const declared = !control && ((0, import_errors2.isFailureDescriptor)(error) || (0, import_errors2.isFailureDescriptor)((0, import_errors2.errorProperty)(error, "failure")));
   const failure = (0, import_errors2.serializeFailure)(control ? void 0 : error);
+  const exception = !control && error !== void 0 ? (0, import_telemetry_contracts2.captureDiagnosticContent)(error) : null;
+  const rawMessage = typeof error === "string" ? error : (0, import_errors2.errorProperty)(error, "message");
+  const originalMessage = typeof rawMessage === "string" ? (0, import_telemetry_contracts2.redactDiagnosticText)(rawMessage) : void 0;
   let diagnosticId = options.diagnosticId ?? (0, import_errors2.errorProperty)(error, "diagnosticId");
   if (!control && !diagnosticId && options.reportError) {
     try {
@@ -512,33 +631,38 @@ function createEvalIssue(phase, error, options = {}) {
     } catch {
     }
   }
+  const candidate = (0, import_errors2.errorProperty)(error, "statusCode") ?? (0, import_errors2.errorProperty)(error, "status");
+  const httpStatus = typeof candidate === "number" && Number.isInteger(candidate) && candidate >= 100 && candidate <= 599 ? candidate : void 0;
   return {
+    ...exception ? { exception } : {},
+    ...httpStatus ? { details: { httpStatus } } : {},
     phase,
     code: declared ? failure.code : options.code ?? "EVAL_HOOK_FAILED",
-    message: declared ? failure.message : messages[phase],
+    message: originalMessage ?? (declared ? failure.message : `${messages[phase]}${httpStatus ? ` HTTP ${httpStatus}.` : ""}`),
     failure,
-    ...typeof diagnosticId === "string" && import_zod3.z.uuid().safeParse(diagnosticId).success ? { diagnosticId } : {}
+    ...typeof diagnosticId === "string" && import_zod4.z.uuid().safeParse(diagnosticId).success ? { diagnosticId } : {}
   };
 }
 
 // src/evals/evaluation-contracts.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // src/evals/studio-contracts.ts
 var import_browser2 = require("@kortyx/prompts/browser");
-var import_zod4 = require("zod");
-var StudioEvalTargetsResponseSchema = import_zod4.z.object({
-  canRun: import_zod4.z.boolean(),
+var import_zod5 = require("zod");
+var StudioEvalTargetsResponseSchema = import_zod5.z.object({
+  canRun: import_zod5.z.boolean(),
+  settings: EvalSettingsResponseSchema.optional(),
   studioJudge: EvalJudgeIdentitySchema.nullable().optional(),
-  targets: import_zod4.z.array(
-    import_zod4.z.object({
-      id: import_zod4.z.string(),
-      name: import_zod4.z.string(),
-      environment: import_zod4.z.string(),
-      error: import_zod4.z.string().nullable(),
+  targets: import_zod5.z.array(
+    import_zod5.z.object({
+      id: import_zod5.z.string(),
+      name: import_zod5.z.string(),
+      environment: import_zod5.z.string(),
+      error: import_zod5.z.string().nullable(),
       // Safe discovery diagnostics; optional for compatibility with older APIs.
-      diagnostic: import_zod4.z.object({
-        code: import_zod4.z.enum([
+      diagnostic: import_zod5.z.object({
+        code: import_zod5.z.enum([
           "environment_forbidden",
           "environment_unavailable",
           "endpoint_not_found",
@@ -547,44 +671,47 @@ var StudioEvalTargetsResponseSchema = import_zod4.z.object({
           "endpoint_unreachable",
           "manifest_invalid"
         ]),
-        httpStatus: import_zod4.z.number().int().min(100).max(599).optional()
+        httpStatus: import_zod5.z.number().int().min(100).max(599).optional()
       }).nullable().optional(),
       manifest: EvalManifestSchema.nullable(),
-      revisions: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string())
+      revisions: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string())
     })
   )
 });
-var EvalCostAmountSchema = import_zod4.z.object({
-  costSummary: import_zod4.z.object({
-    amounts: import_zod4.z.array(
-      import_zod4.z.object({
-        amount: import_zod4.z.number().finite().nonnegative(),
-        currency: import_zod4.z.string().nullable()
+var EvalCostAmountSchema = import_zod5.z.object({
+  costSummary: import_zod5.z.object({
+    amounts: import_zod5.z.array(
+      import_zod5.z.object({
+        amount: import_zod5.z.number().finite().nonnegative(),
+        currency: import_zod5.z.string().nullable()
       })
     ),
-    complete: import_zod4.z.boolean()
+    complete: import_zod5.z.boolean()
   }).optional(),
-  amount: import_zod4.z.number().finite().nonnegative().nullable(),
-  currency: import_zod4.z.string().nullable(),
-  status: import_zod4.z.enum(["complete", "partial", "unavailable"]),
-  calls: import_zod4.z.number().int().nonnegative(),
-  unpricedCalls: import_zod4.z.number().int().nonnegative(),
-  estimated: import_zod4.z.boolean()
+  amount: import_zod5.z.number().finite().nonnegative().nullable(),
+  currency: import_zod5.z.string().nullable(),
+  status: import_zod5.z.enum(["complete", "partial", "unavailable"]),
+  calls: import_zod5.z.number().int().nonnegative(),
+  unpricedCalls: import_zod5.z.number().int().nonnegative(),
+  estimated: import_zod5.z.boolean()
 });
-var EvalCostsSchema = import_zod4.z.object({
+var EvalCostsSchema = import_zod5.z.object({
   workflow: EvalCostAmountSchema,
   judge: EvalCostAmountSchema,
   total: EvalCostAmountSchema
 });
-var StudioEvalRunSummarySchema = import_zod4.z.object({
-  id: import_zod4.z.uuid(),
-  evaluationId: import_zod4.z.uuid().nullable().optional(),
-  targetId: import_zod4.z.string(),
-  targetName: import_zod4.z.string(),
-  environment: import_zod4.z.string(),
-  suiteId: import_zod4.z.string(),
-  suiteRevision: import_zod4.z.string(),
-  status: import_zod4.z.enum([
+var StudioEvalRunSummarySchema = import_zod5.z.object({
+  issue: EvalIssueSchema.nullable().optional(),
+  termination: EvalTerminationSchema.nullable().optional(),
+  resolvedSettings: ResolvedEvalSettingsSchema.optional(),
+  id: import_zod5.z.uuid(),
+  evaluationId: import_zod5.z.uuid().nullable().optional(),
+  targetId: import_zod5.z.string(),
+  targetName: import_zod5.z.string(),
+  environment: import_zod5.z.string(),
+  suiteId: import_zod5.z.string(),
+  suiteRevision: import_zod5.z.string(),
+  status: import_zod5.z.enum([
     "queued",
     "running",
     "passed",
@@ -592,49 +719,52 @@ var StudioEvalRunSummarySchema = import_zod4.z.object({
     "error",
     "cancelled"
   ]),
-  createdAt: import_zod4.z.string(),
-  startedAt: import_zod4.z.string().nullable(),
-  endedAt: import_zod4.z.string().nullable(),
-  error: import_zod4.z.string().nullable(),
-  cancelRequestedAt: import_zod4.z.string().nullable(),
+  createdAt: import_zod5.z.string(),
+  startedAt: import_zod5.z.string().nullable(),
+  endedAt: import_zod5.z.string().nullable(),
+  error: import_zod5.z.string().nullable(),
+  cancelRequestedAt: import_zod5.z.string().nullable(),
   costs: EvalCostsSchema.optional(),
-  counts: import_zod4.z.object({
-    passed: import_zod4.z.number(),
-    failed: import_zod4.z.number(),
-    error: import_zod4.z.number(),
-    cancelled: import_zod4.z.number()
+  counts: import_zod5.z.object({
+    passed: import_zod5.z.number(),
+    failed: import_zod5.z.number(),
+    error: import_zod5.z.number(),
+    cancelled: import_zod5.z.number()
   }).nullable().optional(),
-  suiteName: import_zod4.z.string().nullable().optional(),
-  totalAttempts: import_zod4.z.number().int().nonnegative().optional(),
-  completedAttempts: import_zod4.z.number().int().nonnegative().optional(),
-  phase: import_zod4.z.string().optional()
+  suiteName: import_zod5.z.string().nullable().optional(),
+  totalAttempts: import_zod5.z.number().int().nonnegative().optional(),
+  completedAttempts: import_zod5.z.number().int().nonnegative().optional(),
+  phase: import_zod5.z.string().optional()
 });
-var StudioEvalHistorySchema = import_zod4.z.object({
-  runs: import_zod4.z.array(StudioEvalRunSummarySchema)
+var StudioEvalHistorySchema = import_zod5.z.object({
+  runs: import_zod5.z.array(StudioEvalRunSummarySchema)
 });
-var StudioEvalDetailSchema = import_zod4.z.object({
+var StudioEvalDetailSchema = import_zod5.z.object({
   run: StudioEvalRunSummarySchema.extend({
-    caseCosts: import_zod4.z.record(import_zod4.z.string(), EvalCostsSchema).optional(),
-    request: import_zod4.z.object({
-      caseIds: import_zod4.z.array(import_zod4.z.string()).optional(),
-      grading: import_zod4.z.enum(["app", "studio"]).optional(),
+    caseCosts: import_zod5.z.record(import_zod5.z.string(), EvalCostsSchema).optional(),
+    request: import_zod5.z.object({
+      caseIds: import_zod5.z.array(import_zod5.z.string()).optional(),
+      grading: import_zod5.z.enum(["app", "studio"]).optional(),
       judge: EvalJudgeIdentitySchema.optional(),
-      repetitions: import_zod4.z.number().int().positive(),
-      concurrency: import_zod4.z.number().optional(),
+      repetitions: import_zod5.z.number().int().positive(),
+      concurrency: import_zod5.z.number().optional(),
+      caseTimeoutMs: import_zod5.z.number().optional(),
+      runTimeoutMs: import_zod5.z.number().optional(),
+      resolvedSettings: ResolvedEvalSettingsSchema.optional(),
       promptSnapshot: import_browser2.PromptSnapshotSchema.optional(),
-      promptGroupName: import_zod4.z.string().optional()
+      promptGroupName: import_zod5.z.string().optional()
     }).optional(),
     suite: EvalSuiteSchema,
     result: EvalRunResultSchema.nullable(),
-    events: import_zod4.z.array(import_zod4.z.object({ id: import_zod4.z.number(), event: EvalProgressSchema }))
+    events: import_zod5.z.array(import_zod5.z.object({ id: import_zod5.z.number(), event: EvalProgressSchema }))
   })
 });
 
 // src/evals/evaluation-contracts.ts
-var EvaluationMetadataSchema = import_zod5.z.object({
-  source: import_zod5.z.enum(["manual", "deployment", "schedule", "ci"]).default("manual"),
-  commit: import_zod5.z.string().trim().min(1).max(100).optional(),
-  deploymentUrl: import_zod5.z.url().refine((value) => {
+var EvaluationMetadataSchema = import_zod6.z.object({
+  source: import_zod6.z.enum(["manual", "deployment", "schedule", "ci"]).default("manual"),
+  commit: import_zod6.z.string().trim().min(1).max(100).optional(),
+  deploymentUrl: import_zod6.z.url().refine((value) => {
     try {
       const url = new URL(value);
       return ["https:", "http:"].includes(url.protocol) && !url.username && !url.password;
@@ -643,62 +773,79 @@ var EvaluationMetadataSchema = import_zod5.z.object({
     }
   }, "Expected an HTTP(S) URL without credentials").optional()
 }).strict();
-var StudioEvaluationStartRequestSchema = import_zod5.z.object({
-  targetId: import_zod5.z.string().trim().min(1),
-  name: import_zod5.z.string().trim().min(1).max(200).optional(),
+var StudioEvaluationStartRequestSchema = import_zod6.z.object({
+  targetId: import_zod6.z.string().trim().min(1),
+  name: import_zod6.z.string().trim().min(1).max(200).optional(),
   promptSelection: StudioEvalStartRequestSchema.shape.promptSelection,
-  selection: import_zod5.z.enum(["all", "selected"]),
-  suites: import_zod5.z.array(
-    import_zod5.z.object({
-      suiteId: import_zod5.z.string().min(1),
-      suiteRevision: import_zod5.z.string().regex(/^[a-f0-9]{64}$/),
-      caseIds: import_zod5.z.array(import_zod5.z.string().min(1)).min(1).max(100).optional()
+  selection: import_zod6.z.enum(["all", "selected"]),
+  suites: import_zod6.z.array(
+    import_zod6.z.object({
+      suiteId: import_zod6.z.string().min(1),
+      suiteRevision: import_zod6.z.string().regex(/^[a-f0-9]{64}$/),
+      caseIds: import_zod6.z.array(import_zod6.z.string().min(1)).min(1).max(100).optional()
     }).strict()
   ).min(1).max(100),
-  judge: import_zod5.z.enum(["studio", "app"]).default("studio"),
-  repetitions: import_zod5.z.number().int().min(1).max(20).default(1),
-  concurrency: import_zod5.z.number().int().min(1).max(20).default(1),
+  ...EvalSettingsSchema.shape,
   metadata: EvaluationMetadataSchema.default({ source: "manual" }),
-  idempotencyKey: import_zod5.z.string().trim().min(1).max(200).optional()
+  idempotencyKey: import_zod6.z.string().trim().min(1).max(200).optional()
 }).strict();
-var StudioEvaluationSummarySchema = import_zod5.z.object({
-  id: import_zod5.z.uuid(),
-  name: import_zod5.z.string(),
-  targetId: import_zod5.z.string(),
-  targetName: import_zod5.z.string(),
-  environment: import_zod5.z.string(),
-  selection: import_zod5.z.enum(["all", "selected"]),
+var StudioEvaluationSummarySchema = import_zod6.z.object({
+  termination: EvalTerminationSchema.nullable().optional(),
+  resolvedSettings: ResolvedEvalSettingsSchema.optional(),
+  interruptedSuites: import_zod6.z.number().int().nonnegative().optional(),
+  failures: import_zod6.z.array(
+    import_zod6.z.object({
+      suiteRunId: import_zod6.z.uuid(),
+      caseId: import_zod6.z.string().optional(),
+      repetition: import_zod6.z.number().int().positive().optional(),
+      phase: import_zod6.z.string(),
+      code: import_zod6.z.string(),
+      message: import_zod6.z.string(),
+      diagnosticId: import_zod6.z.string().uuid().optional()
+    })
+  ).optional(),
+  pendingAttempts: import_zod6.z.object({
+    notStarted: import_zod6.z.number().int().nonnegative(),
+    executing: import_zod6.z.number().int().nonnegative(),
+    awaitingGrading: import_zod6.z.number().int().nonnegative()
+  }).optional(),
+  id: import_zod6.z.uuid(),
+  name: import_zod6.z.string(),
+  targetId: import_zod6.z.string(),
+  targetName: import_zod6.z.string(),
+  environment: import_zod6.z.string(),
+  selection: import_zod6.z.enum(["all", "selected"]),
   metadata: EvaluationMetadataSchema,
   judge: EvalJudgeIdentitySchema.optional(),
   status: StudioEvalRunSummarySchema.shape.status,
-  createdAt: import_zod5.z.string(),
-  startedAt: import_zod5.z.string().nullable(),
-  endedAt: import_zod5.z.string().nullable(),
-  cancelRequestedAt: import_zod5.z.string().nullable(),
-  suiteCount: import_zod5.z.number().int().nonnegative(),
-  completedSuites: import_zod5.z.number().int().nonnegative(),
-  totalAttempts: import_zod5.z.number().int().nonnegative(),
-  completedAttempts: import_zod5.z.number().int().nonnegative(),
-  counts: import_zod5.z.object({
-    passed: import_zod5.z.number(),
-    failed: import_zod5.z.number(),
-    error: import_zod5.z.number(),
-    cancelled: import_zod5.z.number()
+  createdAt: import_zod6.z.string(),
+  startedAt: import_zod6.z.string().nullable(),
+  endedAt: import_zod6.z.string().nullable(),
+  cancelRequestedAt: import_zod6.z.string().nullable(),
+  suiteCount: import_zod6.z.number().int().nonnegative(),
+  completedSuites: import_zod6.z.number().int().nonnegative(),
+  totalAttempts: import_zod6.z.number().int().nonnegative(),
+  completedAttempts: import_zod6.z.number().int().nonnegative(),
+  counts: import_zod6.z.object({
+    passed: import_zod6.z.number(),
+    failed: import_zod6.z.number(),
+    error: import_zod6.z.number(),
+    cancelled: import_zod6.z.number()
   }),
   costs: EvalCostsSchema.optional(),
-  legacy: import_zod5.z.boolean().optional()
+  legacy: import_zod6.z.boolean().optional()
 });
-var StudioEvaluationHistorySchema = import_zod5.z.object({
-  runs: import_zod5.z.array(StudioEvaluationSummarySchema)
+var StudioEvaluationHistorySchema = import_zod6.z.object({
+  runs: import_zod6.z.array(StudioEvaluationSummarySchema)
 });
-var StudioEvaluationDetailSchema = import_zod5.z.object({
+var StudioEvaluationDetailSchema = import_zod6.z.object({
   run: StudioEvaluationSummarySchema.extend({
-    suites: import_zod5.z.array(StudioEvalRunSummarySchema)
+    suites: import_zod6.z.array(StudioEvalRunSummarySchema)
   })
 });
-var StudioEvaluationResultsSchema = import_zod5.z.object({
+var StudioEvaluationResultsSchema = import_zod6.z.object({
   run: StudioEvaluationSummarySchema.extend({
-    suites: import_zod5.z.array(StudioEvalDetailSchema.shape.run)
+    suites: import_zod6.z.array(StudioEvalDetailSchema.shape.run)
   })
 });
 
@@ -795,11 +942,12 @@ function getEvalGradeEvidence(step, previous) {
 }
 
 // src/evals/studio-judge.ts
+var import_telemetry_contracts3 = require("@kortyx/telemetry-contracts");
 async function readJson(response, signal) {
-  if (!response.ok || !response.body) {
-    await response.body?.cancel().catch(() => {
-    });
-    throw new Error("Studio judge is unavailable or rejected the request.");
+  if (!response.body) {
+    throw new Error(
+      `Studio judge returned HTTP ${response.status} with no response body.`
+    );
   }
   const reader = response.body.getReader();
   const abort = () => {
@@ -821,7 +969,18 @@ async function readJson(response, signal) {
       text += decoder.decode(part.value, { stream: true });
     }
     signal.throwIfAborted();
-    return JSON.parse(text + decoder.decode());
+    text += decoder.decode();
+    if (!response.ok)
+      throw Object.assign(
+        new Error(
+          `Studio judge returned HTTP ${response.status}: ${(0, import_telemetry_contracts3.redactDiagnosticText)(text)}`
+        ),
+        {
+          statusCode: response.status,
+          responseBody: (0, import_telemetry_contracts3.redactDiagnosticText)(text)
+        }
+      );
+    return JSON.parse(text);
   } finally {
     signal.removeEventListener("abort", abort);
     await reader.cancel().catch(() => {
@@ -907,6 +1066,7 @@ async function createStudioEvalJudge(options) {
   EvalCostAmountSchema,
   EvalCostsSchema,
   EvalEvidencePolicySchema,
+  EvalExecutionSettingsSchema,
   EvalIssueSchema,
   EvalJudgeIdentitySchema,
   EvalJudgeUsageSchema,
@@ -916,11 +1076,15 @@ async function createStudioEvalJudge(options) {
   EvalRemoteRunRequestSchema,
   EvalResumeResponseSchema,
   EvalRunResultSchema,
+  EvalSettingsResponseSchema,
+  EvalSettingsSchema,
   EvalStepResultSchema,
   EvalSuiteSchema,
+  EvalTerminationSchema,
   EvalVerdictSchema,
   EvalWireEventSchema,
   EvaluationMetadataSchema,
+  ResolvedEvalSettingsSchema,
   StudioEvalDetailSchema,
   StudioEvalHistorySchema,
   StudioEvalJudgeRequestSchema,
@@ -937,6 +1101,7 @@ async function createStudioEvalJudge(options) {
   createStudioEvalJudge,
   defineSuite,
   getEvalGradeEvidence,
-  parseEvalSuite
+  parseEvalSuite,
+  resolveEvalSettings
 });
 //# sourceMappingURL=evals.js.map