@kortyx/agent 0.30.0 → 0.31.0

package/dist/index.js

@@ -543,7 +543,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 +735,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();
@@ -4843,10 +4843,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,
@@ -9164,8 +9170,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 +9366,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 +9684,16 @@ async function createStudioEvalJudge(options) {
   EvalRunResultSchema,
   EvalSuiteSchema,
   EvalWireEventSchema,
+  EvaluationMetadataSchema,
   ExecutionRequestError,
   StudioEvalJudgeRequestSchema,
   StudioEvalJudgeResponseSchema,
   StudioEvalStartRequestSchema,
+  StudioEvaluationDetailSchema,
+  StudioEvaluationHistorySchema,
+  StudioEvaluationResultsSchema,
+  StudioEvaluationStartRequestSchema,
+  StudioEvaluationSummarySchema,
   createAgent,
   createChatRouteHandler,
   createCheckpointRouteHandler,