@wix/evalforge-types 0.6.0 → 0.7.0

package/build/index.mjs

@@ -374,34 +374,67 @@ var TestSchema = z17.discriminatedUnion("type", [
   PlaywrightNLTestSchema
 ]);
 
-// src/scenario/environment.ts
+// src/scenario/assertions.ts
 import { z as z18 } from "zod";
-var LocalProjectConfigSchema = z18.object({
+var SkillWasCalledAssertionSchema = z18.object({
+  type: z18.literal("skill_was_called"),
+  /** Name of the skill that must have been called (matched against trace Skill tool args) */
+  skillName: z18.string()
+});
+var BuildPassedAssertionSchema = z18.object({
+  type: z18.literal("build_passed"),
+  /** Command to run (default: "yarn build") */
+  command: z18.string().optional(),
+  /** Expected exit code (default: 0) */
+  expectedExitCode: z18.number().int().optional()
+});
+var LlmJudgeAssertionSchema = z18.object({
+  type: z18.literal("llm_judge"),
+  /** Prompt template; placeholders: {{output}}, {{cwd}}, {{changedFiles}}, {{trace}} */
+  prompt: z18.string(),
+  /** Optional system prompt for the judge (default asks for JSON with score) */
+  systemPrompt: z18.string().optional(),
+  /** Minimum score to pass (0–100, default 70) */
+  minScore: z18.number().int().min(0).max(100).optional(),
+  /** Model for the judge (e.g. claude-3-5-haiku) */
+  model: z18.string().optional(),
+  maxTokens: z18.number().int().optional(),
+  temperature: z18.number().min(0).max(1).optional()
+});
+var AssertionSchema = z18.discriminatedUnion("type", [
+  SkillWasCalledAssertionSchema,
+  BuildPassedAssertionSchema,
+  LlmJudgeAssertionSchema
+]);
+
+// src/scenario/environment.ts
+import { z as z19 } from "zod";
+var LocalProjectConfigSchema = z19.object({
   /** Template ID to use for the local project */
-  templateId: z18.string().optional(),
+  templateId: z19.string().optional(),
   /** Files to create in the project */
-  files: z18.array(
-    z18.object({
-      path: z18.string().min(1),
-      content: z18.string().min(1)
+  files: z19.array(
+    z19.object({
+      path: z19.string().min(1),
+      content: z19.string().min(1)
     })
   ).optional()
 });
-var MetaSiteConfigSchema = z18.object({
-  configurations: z18.array(
-    z18.object({
-      name: z18.string().min(1),
-      apiCalls: z18.array(
-        z18.object({
-          url: z18.string().url(),
-          method: z18.enum(["POST", "PUT"]),
-          body: z18.string()
+var MetaSiteConfigSchema = z19.object({
+  configurations: z19.array(
+    z19.object({
+      name: z19.string().min(1),
+      apiCalls: z19.array(
+        z19.object({
+          url: z19.string().url(),
+          method: z19.enum(["POST", "PUT"]),
+          body: z19.string()
         })
       )
     })
   ).optional()
 });
-var EnvironmentSchema = z18.object({
+var EnvironmentSchema = z19.object({
   /** Local project configuration */
   localProject: LocalProjectConfigSchema.optional(),
   /** Meta site configuration */
@@ -409,18 +442,20 @@ var EnvironmentSchema = z18.object({
 });
 
 // src/scenario/test-scenario.ts
-import { z as z19 } from "zod";
-var ExpectedFileSchema = z19.object({
+import { z as z20 } from "zod";
+var ExpectedFileSchema = z20.object({
   /** Relative path where the file should be created */
-  path: z19.string(),
+  path: z20.string(),
   /** Optional expected content */
-  content: z19.string().optional()
+  content: z20.string().optional()
 });
 var TestScenarioSchema = TenantEntitySchema.extend({
   /** The prompt sent to the agent to trigger the task */
-  triggerPrompt: z19.string().min(10),
+  triggerPrompt: z20.string().min(10),
   /** ID of the template to use for this scenario */
-  templateId: z19.string().optional()
+  templateId: z20.string().optional(),
+  /** Assertions to evaluate for this scenario */
+  assertions: z20.array(AssertionSchema).optional()
 });
 var CreateTestScenarioInputSchema = TestScenarioSchema.omit({
   id: true,
@@ -431,10 +466,10 @@ var CreateTestScenarioInputSchema = TestScenarioSchema.omit({
 var UpdateTestScenarioInputSchema = CreateTestScenarioInputSchema.partial();
 
 // src/suite/test-suite.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var TestSuiteSchema = TenantEntitySchema.extend({
   /** IDs of test scenarios in this suite */
-  scenarioIds: z20.array(z20.string())
+  scenarioIds: z21.array(z21.string())
 });
 var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
   id: true,
@@ -445,21 +480,21 @@ var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
 var UpdateTestSuiteInputSchema = CreateTestSuiteInputSchema.partial();
 
 // src/evaluation/metrics.ts
-import { z as z21 } from "zod";
-var TokenUsageSchema = z21.object({
-  prompt: z21.number(),
-  completion: z21.number(),
-  total: z21.number()
-});
-var EvalMetricsSchema = z21.object({
-  totalAssertions: z21.number(),
-  passed: z21.number(),
-  failed: z21.number(),
-  skipped: z21.number(),
-  errors: z21.number(),
-  passRate: z21.number(),
-  avgDuration: z21.number(),
-  totalDuration: z21.number()
+import { z as z22 } from "zod";
+var TokenUsageSchema = z22.object({
+  prompt: z22.number(),
+  completion: z22.number(),
+  total: z22.number()
+});
+var EvalMetricsSchema = z22.object({
+  totalAssertions: z22.number(),
+  passed: z22.number(),
+  failed: z22.number(),
+  skipped: z22.number(),
+  errors: z22.number(),
+  passRate: z22.number(),
+  avgDuration: z22.number(),
+  totalDuration: z22.number()
 });
 var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["PENDING"] = "pending";
@@ -469,7 +504,7 @@ var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["CANCELLED"] = "cancelled";
   return EvalStatus2;
 })(EvalStatus || {});
-var EvalStatusSchema = z21.enum(EvalStatus);
+var EvalStatusSchema = z22.enum(EvalStatus);
 var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["COMPLETION"] = "completion";
   LLMStepType2["TOOL_USE"] = "tool_use";
@@ -477,52 +512,52 @@ var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["THINKING"] = "thinking";
   return LLMStepType2;
 })(LLMStepType || {});
-var LLMTraceStepSchema = z21.object({
-  id: z21.string(),
-  stepNumber: z21.number(),
-  type: z21.enum(LLMStepType),
-  model: z21.string(),
-  provider: z21.string(),
-  startedAt: z21.string(),
-  durationMs: z21.number(),
+var LLMTraceStepSchema = z22.object({
+  id: z22.string(),
+  stepNumber: z22.number(),
+  type: z22.enum(LLMStepType),
+  model: z22.string(),
+  provider: z22.string(),
+  startedAt: z22.string(),
+  durationMs: z22.number(),
   tokenUsage: TokenUsageSchema,
-  costUsd: z21.number(),
-  toolName: z21.string().optional(),
-  toolArguments: z21.string().optional(),
-  inputPreview: z21.string().optional(),
-  outputPreview: z21.string().optional(),
-  success: z21.boolean(),
-  error: z21.string().optional()
-});
-var LLMBreakdownStatsSchema = z21.object({
-  count: z21.number(),
-  durationMs: z21.number(),
-  tokens: z21.number(),
-  costUsd: z21.number()
-});
-var LLMTraceSummarySchema = z21.object({
-  totalSteps: z21.number(),
-  totalDurationMs: z21.number(),
+  costUsd: z22.number(),
+  toolName: z22.string().optional(),
+  toolArguments: z22.string().optional(),
+  inputPreview: z22.string().optional(),
+  outputPreview: z22.string().optional(),
+  success: z22.boolean(),
+  error: z22.string().optional()
+});
+var LLMBreakdownStatsSchema = z22.object({
+  count: z22.number(),
+  durationMs: z22.number(),
+  tokens: z22.number(),
+  costUsd: z22.number()
+});
+var LLMTraceSummarySchema = z22.object({
+  totalSteps: z22.number(),
+  totalDurationMs: z22.number(),
   totalTokens: TokenUsageSchema,
-  totalCostUsd: z21.number(),
-  stepTypeBreakdown: z21.record(z21.string(), LLMBreakdownStatsSchema).optional(),
-  modelBreakdown: z21.record(z21.string(), LLMBreakdownStatsSchema),
-  modelsUsed: z21.array(z21.string())
-});
-var LLMTraceSchema = z21.object({
-  id: z21.string(),
-  steps: z21.array(LLMTraceStepSchema),
+  totalCostUsd: z22.number(),
+  stepTypeBreakdown: z22.record(z22.string(), LLMBreakdownStatsSchema).optional(),
+  modelBreakdown: z22.record(z22.string(), LLMBreakdownStatsSchema),
+  modelsUsed: z22.array(z22.string())
+});
+var LLMTraceSchema = z22.object({
+  id: z22.string(),
+  steps: z22.array(LLMTraceStepSchema),
   summary: LLMTraceSummarySchema
 });
 
 // src/evaluation/eval-result.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // src/evaluation/eval-run.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/evaluation/live-trace.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["THINKING"] = "thinking";
   LiveTraceEventType2["TOOL_USE"] = "tool_use";
@@ -531,31 +566,31 @@ var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["DIAGNOSTIC"] = "diagnostic";
   return LiveTraceEventType2;
 })(LiveTraceEventType || {});
-var LiveTraceEventSchema = z22.object({
+var LiveTraceEventSchema = z23.object({
   /** The evaluation run ID */
-  evalRunId: z22.string(),
+  evalRunId: z23.string(),
   /** The scenario ID being executed */
-  scenarioId: z22.string(),
+  scenarioId: z23.string(),
   /** The scenario name for display */
-  scenarioName: z22.string(),
+  scenarioName: z23.string(),
   /** The target ID (skill, agent, etc.) */
-  targetId: z22.string(),
+  targetId: z23.string(),
   /** The target name for display */
-  targetName: z22.string(),
+  targetName: z23.string(),
   /** Step number in the current scenario execution */
-  stepNumber: z22.number(),
+  stepNumber: z23.number(),
   /** Type of trace event */
-  type: z22.enum(LiveTraceEventType),
+  type: z23.enum(LiveTraceEventType),
   /** Tool name if this is a tool_use event */
-  toolName: z22.string().optional(),
+  toolName: z23.string().optional(),
   /** Tool arguments preview (truncated JSON) */
-  toolArgs: z22.string().optional(),
+  toolArgs: z23.string().optional(),
   /** Output preview (truncated text) */
-  outputPreview: z22.string().optional(),
+  outputPreview: z23.string().optional(),
   /** Timestamp when this event occurred */
-  timestamp: z22.string(),
+  timestamp: z23.string(),
   /** Whether this is the final event for this scenario */
-  isComplete: z22.boolean()
+  isComplete: z23.boolean()
 });
 var TRACE_EVENT_PREFIX = "TRACE_EVENT:";
 function parseTraceEventLine(line) {
@@ -583,14 +618,14 @@ var TriggerType = /* @__PURE__ */ ((TriggerType2) => {
   TriggerType2["MANUAL"] = "MANUAL";
   return TriggerType2;
 })(TriggerType || {});
-var TriggerMetadataSchema = z23.object({
-  version: z23.string().optional(),
-  resourceUpdated: z23.array(z23.string()).optional()
+var TriggerMetadataSchema = z24.object({
+  version: z24.string().optional(),
+  resourceUpdated: z24.array(z24.string()).optional()
 });
-var TriggerSchema = z23.object({
-  id: z23.string(),
+var TriggerSchema = z24.object({
+  id: z24.string(),
   metadata: TriggerMetadataSchema.optional(),
-  type: z23.enum(TriggerType)
+  type: z24.enum(TriggerType)
 });
 var FailureCategory = /* @__PURE__ */ ((FailureCategory2) => {
   FailureCategory2["MISSING_FILE"] = "missing_file";
@@ -608,89 +643,89 @@ var FailureSeverity = /* @__PURE__ */ ((FailureSeverity2) => {
   FailureSeverity2["LOW"] = "low";
   return FailureSeverity2;
 })(FailureSeverity || {});
-var DiffLineTypeSchema = z23.enum(["added", "removed", "unchanged"]);
-var DiffLineSchema = z23.object({
+var DiffLineTypeSchema = z24.enum(["added", "removed", "unchanged"]);
+var DiffLineSchema = z24.object({
   type: DiffLineTypeSchema,
-  content: z23.string(),
-  lineNumber: z23.number()
-});
-var DiffContentSchema = z23.object({
-  path: z23.string(),
-  expected: z23.string(),
-  actual: z23.string(),
-  diffLines: z23.array(DiffLineSchema)
-});
-var CommandExecutionSchema = z23.object({
-  command: z23.string(),
-  exitCode: z23.number(),
-  output: z23.string().optional(),
-  duration: z23.number()
-});
-var FileModificationSchema = z23.object({
-  path: z23.string(),
-  action: z23.enum(["created", "modified", "deleted"])
-});
-var ApiCallSchema = z23.object({
-  endpoint: z23.string(),
-  tokensUsed: z23.number(),
-  duration: z23.number()
-});
-var ExecutionTraceSchema = z23.object({
-  commands: z23.array(CommandExecutionSchema),
-  filesModified: z23.array(FileModificationSchema),
-  apiCalls: z23.array(ApiCallSchema),
-  totalDuration: z23.number()
-});
-var FailureAnalysisSchema = z23.object({
-  category: z23.enum(FailureCategory),
-  severity: z23.enum(FailureSeverity),
-  summary: z23.string(),
-  details: z23.string(),
-  rootCause: z23.string(),
-  suggestedFix: z23.string(),
-  relatedAssertions: z23.array(z23.string()),
-  codeSnippet: z23.string().optional(),
-  similarIssues: z23.array(z23.string()).optional(),
-  patternId: z23.string().optional(),
+  content: z24.string(),
+  lineNumber: z24.number()
+});
+var DiffContentSchema = z24.object({
+  path: z24.string(),
+  expected: z24.string(),
+  actual: z24.string(),
+  diffLines: z24.array(DiffLineSchema)
+});
+var CommandExecutionSchema = z24.object({
+  command: z24.string(),
+  exitCode: z24.number(),
+  output: z24.string().optional(),
+  duration: z24.number()
+});
+var FileModificationSchema = z24.object({
+  path: z24.string(),
+  action: z24.enum(["created", "modified", "deleted"])
+});
+var ApiCallSchema = z24.object({
+  endpoint: z24.string(),
+  tokensUsed: z24.number(),
+  duration: z24.number()
+});
+var ExecutionTraceSchema = z24.object({
+  commands: z24.array(CommandExecutionSchema),
+  filesModified: z24.array(FileModificationSchema),
+  apiCalls: z24.array(ApiCallSchema),
+  totalDuration: z24.number()
+});
+var FailureAnalysisSchema = z24.object({
+  category: z24.enum(FailureCategory),
+  severity: z24.enum(FailureSeverity),
+  summary: z24.string(),
+  details: z24.string(),
+  rootCause: z24.string(),
+  suggestedFix: z24.string(),
+  relatedAssertions: z24.array(z24.string()),
+  codeSnippet: z24.string().optional(),
+  similarIssues: z24.array(z24.string()).optional(),
+  patternId: z24.string().optional(),
   // Extended fields for detailed debugging
   diff: DiffContentSchema.optional(),
   executionTrace: ExecutionTraceSchema.optional()
 });
 var EvalRunSchema = TenantEntitySchema.extend({
   /** Agent ID for this run */
-  agentId: z23.string().optional(),
+  agentId: z24.string().optional(),
   /** Skills group ID for this run */
-  skillsGroupId: z23.string().optional(),
+  skillsGroupId: z24.string().optional(),
   /** Scenario IDs to run */
-  scenarioIds: z23.array(z23.string()),
+  scenarioIds: z24.array(z24.string()),
   /** Current status */
   status: EvalStatusSchema,
   /** Progress percentage (0-100) */
-  progress: z23.number(),
+  progress: z24.number(),
   /** Results for each scenario/target combination */
-  results: z23.array(EvalRunResultSchema),
+  results: z24.array(EvalRunResultSchema),
   /** Aggregated metrics across all results */
   aggregateMetrics: EvalMetricsSchema,
   /** Failure analyses */
-  failureAnalyses: z23.array(FailureAnalysisSchema).optional(),
+  failureAnalyses: z24.array(FailureAnalysisSchema).optional(),
   /** Aggregated LLM trace summary */
   llmTraceSummary: LLMTraceSummarySchema.optional(),
   /** What triggered this run */
   trigger: TriggerSchema.optional(),
   /** When the run started (set when evaluation is triggered) */
-  startedAt: z23.string().optional(),
+  startedAt: z24.string().optional(),
   /** When the run completed */
-  completedAt: z23.string().optional(),
+  completedAt: z24.string().optional(),
   /** Live trace events captured during execution (for playback on results page) */
-  liveTraceEvents: z23.array(LiveTraceEventSchema).optional(),
+  liveTraceEvents: z24.array(LiveTraceEventSchema).optional(),
   /** Remote job ID for tracking execution in Dev Machines */
-  jobId: z23.string().optional(),
+  jobId: z24.string().optional(),
   /** Remote job status from the Dev Machine API (PENDING, RUNNING, COMPLETED, FAILED, CANCELLED) */
-  jobStatus: z23.string().optional(),
+  jobStatus: z24.string().optional(),
   /** Remote job error message if the job failed */
-  jobError: z23.string().optional(),
+  jobError: z24.string().optional(),
   /** Timestamp of the last job status check */
-  jobStatusCheckedAt: z23.string().optional()
+  jobStatusCheckedAt: z24.string().optional()
 });
 var CreateEvalRunInputSchema = EvalRunSchema.omit({
   id: true,
@@ -703,28 +738,28 @@ var CreateEvalRunInputSchema = EvalRunSchema.omit({
   startedAt: true,
   completedAt: true
 });
-var EvaluationProgressSchema = z23.object({
-  runId: z23.string(),
-  targetId: z23.string(),
-  totalScenarios: z23.number(),
-  completedScenarios: z23.number(),
-  scenarioProgress: z23.array(
-    z23.object({
-      scenarioId: z23.string(),
-      currentStep: z23.string(),
-      error: z23.string().optional()
+var EvaluationProgressSchema = z24.object({
+  runId: z24.string(),
+  targetId: z24.string(),
+  totalScenarios: z24.number(),
+  completedScenarios: z24.number(),
+  scenarioProgress: z24.array(
+    z24.object({
+      scenarioId: z24.string(),
+      currentStep: z24.string(),
+      error: z24.string().optional()
     })
   ),
-  createdAt: z23.number()
+  createdAt: z24.number()
 });
-var EvaluationLogSchema = z23.object({
-  runId: z23.string(),
-  scenarioId: z23.string(),
-  log: z23.object({
-    level: z23.enum(["info", "error", "debug"]),
-    message: z23.string().optional(),
-    args: z23.array(z23.any()).optional(),
-    error: z23.string().optional()
+var EvaluationLogSchema = z24.object({
+  runId: z24.string(),
+  scenarioId: z24.string(),
+  log: z24.object({
+    level: z24.enum(["info", "error", "debug"]),
+    message: z24.string().optional(),
+    args: z24.array(z24.any()).optional(),
+    error: z24.string().optional()
   })
 });
 var LLM_TIMEOUT = 12e4;
@@ -737,90 +772,89 @@ var AssertionResultStatus = /* @__PURE__ */ ((AssertionResultStatus2) => {
   AssertionResultStatus2["ERROR"] = "error";
   return AssertionResultStatus2;
 })(AssertionResultStatus || {});
-var AssertionResultSchema = z24.object({
-  id: z24.string(),
-  assertionId: z24.string(),
-  assertionType: z24.string(),
-  assertionName: z24.string(),
-  status: z24.enum(AssertionResultStatus),
-  message: z24.string().optional(),
-  expected: z24.string().optional(),
-  actual: z24.string().optional(),
-  duration: z24.number().optional(),
-  details: z24.record(z24.string(), z24.unknown()).optional(),
-  llmTraceSteps: z24.array(LLMTraceStepSchema).optional()
-});
-var EvalRunResultSchema = z24.object({
-  id: z24.string(),
-  targetId: z24.string(),
-  targetName: z24.string().optional(),
-  scenarioId: z24.string(),
-  scenarioName: z24.string(),
+var AssertionResultSchema = z25.object({
+  id: z25.string(),
+  assertionId: z25.string(),
+  assertionType: z25.string(),
+  assertionName: z25.string(),
+  status: z25.enum(AssertionResultStatus),
+  message: z25.string().optional(),
+  expected: z25.string().optional(),
+  actual: z25.string().optional(),
+  duration: z25.number().optional(),
+  details: z25.record(z25.string(), z25.unknown()).optional(),
+  llmTraceSteps: z25.array(LLMTraceStepSchema).optional()
+});
+var EvalRunResultSchema = z25.object({
+  id: z25.string(),
+  targetId: z25.string(),
+  targetName: z25.string().optional(),
+  scenarioId: z25.string(),
+  scenarioName: z25.string(),
   modelConfig: ModelConfigSchema.optional(),
-  assertionResults: z24.array(AssertionResultSchema),
+  assertionResults: z25.array(AssertionResultSchema),
   metrics: EvalMetricsSchema.optional(),
-  passed: z24.number(),
-  failed: z24.number(),
-  passRate: z24.number(),
-  duration: z24.number(),
-  outputText: z24.string().optional(),
-  files: z24.array(ExpectedFileSchema).optional(),
-  /** File diffs showing changes made by the agent during execution */
-  fileDiffs: z24.array(DiffContentSchema).optional(),
-  startedAt: z24.string().optional(),
-  completedAt: z24.string().optional(),
+  passed: z25.number(),
+  failed: z25.number(),
+  passRate: z25.number(),
+  duration: z25.number(),
+  outputText: z25.string().optional(),
+  files: z25.array(ExpectedFileSchema).optional(),
+  fileDiffs: z25.array(DiffContentSchema).optional(),
+  startedAt: z25.string().optional(),
+  completedAt: z25.string().optional(),
   llmTrace: LLMTraceSchema.optional()
 });
-var PromptResultSchema = z24.object({
-  text: z24.string(),
-  files: z24.array(z24.unknown()).optional(),
-  finishReason: z24.string().optional(),
-  reasoning: z24.string().optional(),
-  reasoningDetails: z24.unknown().optional(),
-  toolCalls: z24.array(z24.unknown()).optional(),
-  toolResults: z24.array(z24.unknown()).optional(),
-  warnings: z24.array(z24.unknown()).optional(),
-  sources: z24.array(z24.unknown()).optional(),
-  steps: z24.array(z24.unknown()),
-  generationTimeMs: z24.number(),
-  prompt: z24.string(),
-  systemPrompt: z24.string(),
-  usage: z24.object({
-    totalTokens: z24.number().optional(),
-    totalMicrocentsSpent: z24.number().optional()
+var PromptResultSchema = z25.object({
+  text: z25.string(),
+  files: z25.array(z25.unknown()).optional(),
+  finishReason: z25.string().optional(),
+  reasoning: z25.string().optional(),
+  reasoningDetails: z25.unknown().optional(),
+  toolCalls: z25.array(z25.unknown()).optional(),
+  toolResults: z25.array(z25.unknown()).optional(),
+  warnings: z25.array(z25.unknown()).optional(),
+  sources: z25.array(z25.unknown()).optional(),
+  steps: z25.array(z25.unknown()),
+  generationTimeMs: z25.number(),
+  prompt: z25.string(),
+  systemPrompt: z25.string(),
+  usage: z25.object({
+    totalTokens: z25.number().optional(),
+    totalMicrocentsSpent: z25.number().optional()
   })
 });
-var EvaluationResultSchema = z24.object({
-  id: z24.string(),
-  runId: z24.string(),
-  timestamp: z24.number(),
+var EvaluationResultSchema = z25.object({
+  id: z25.string(),
+  runId: z25.string(),
+  timestamp: z25.number(),
   promptResult: PromptResultSchema,
-  testResults: z24.array(z24.unknown()),
-  tags: z24.array(z24.string()).optional(),
-  feedback: z24.string().optional(),
-  score: z24.number(),
-  suiteId: z24.string().optional()
-});
-var LeanEvaluationResultSchema = z24.object({
-  id: z24.string(),
-  runId: z24.string(),
-  timestamp: z24.number(),
-  tags: z24.array(z24.string()).optional(),
-  scenarioId: z24.string(),
-  scenarioVersion: z24.number().optional(),
-  targetId: z24.string(),
-  targetVersion: z24.number().optional(),
-  suiteId: z24.string().optional(),
-  score: z24.number(),
-  time: z24.number().optional(),
-  microcentsSpent: z24.number().optional()
+  testResults: z25.array(z25.unknown()),
+  tags: z25.array(z25.string()).optional(),
+  feedback: z25.string().optional(),
+  score: z25.number(),
+  suiteId: z25.string().optional()
+});
+var LeanEvaluationResultSchema = z25.object({
+  id: z25.string(),
+  runId: z25.string(),
+  timestamp: z25.number(),
+  tags: z25.array(z25.string()).optional(),
+  scenarioId: z25.string(),
+  scenarioVersion: z25.number().optional(),
+  targetId: z25.string(),
+  targetVersion: z25.number().optional(),
+  suiteId: z25.string().optional(),
+  score: z25.number(),
+  time: z25.number().optional(),
+  microcentsSpent: z25.number().optional()
 });
 
 // src/project/project.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var ProjectSchema = BaseEntitySchema.extend({
-  appId: z25.string().optional().describe("The ID of the app in Dev Center"),
-  appSecret: z25.string().optional().describe("The secret of the app in Dev Center")
+  appId: z26.string().optional().describe("The ID of the app in Dev Center"),
+  appSecret: z26.string().optional().describe("The secret of the app in Dev Center")
 });
 var CreateProjectInputSchema = ProjectSchema.omit({
   id: true,
@@ -831,10 +865,10 @@ var CreateProjectInputSchema = ProjectSchema.omit({
 var UpdateProjectInputSchema = CreateProjectInputSchema.partial();
 
 // src/template/template.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var TemplateSchema = TenantEntitySchema.extend({
   /** URL to download the template from */
-  downloadUrl: z26.url()
+  downloadUrl: z27.url()
 });
 var CreateTemplateInputSchema = TemplateSchema.omit({
   id: true,
@@ -851,9 +885,11 @@ export {
   ApiCallSchema,
   AssertionResultSchema,
   AssertionResultStatus,
+  AssertionSchema,
   BaseEntitySchema,
   BaseTestSchema,
   BuildCheckTestSchema,
+  BuildPassedAssertionSchema,
   CommandExecutionSchema,
   CommandExecutionTestSchema,
   CreateAgentInputSchema,
@@ -895,6 +931,7 @@ export {
   LeanEvaluationResultSchema,
   LiveTraceEventSchema,
   LiveTraceEventType,
+  LlmJudgeAssertionSchema,
   LocalProjectConfigSchema,
   MCPServerConfigSchema,
   MetaSiteConfigSchema,
@@ -910,6 +947,7 @@ export {
   SkillMetadataSchema,
   SkillSchema,
   SkillVersionSchema,
+  SkillWasCalledAssertionSchema,
   SkillsGroupSchema,
   TRACE_EVENT_PREFIX,
   TargetSchema,