@wix/evalforge-types 0.27.0 → 0.29.0

package/build/index.js

@@ -172,14 +172,27 @@ var TenantEntitySchema = BaseEntitySchema.extend({
   projectId: import_zod.z.string()
 });
 
-// src/common/mcp.ts
+// src/common/github-source.ts
 var import_zod2 = require("zod");
+var GitHubSourceSchema = import_zod2.z.object({
+  /** GitHub org or user, e.g. "wix" */
+  owner: import_zod2.z.string().min(1),
+  /** Repository name, e.g. "skills" */
+  repo: import_zod2.z.string().min(1),
+  /** Folder path within the repo, e.g. "wix-cli/skills/wix-cli-dashboard-page" */
+  path: import_zod2.z.string().min(1),
+  /** Git ref (branch, tag, or SHA), e.g. "master" or "v1.2.0" */
+  ref: import_zod2.z.string().min(1)
+});
+
+// src/common/mcp.ts
+var import_zod3 = require("zod");
 var MCP_SERVERS_JSON_KEY = "mcpServers";
 var MCPEntitySchema = TenantEntitySchema.extend({
   /** Display name for the MCP entity (independent of the server key in config) */
-  name: import_zod2.z.string().min(1),
+  name: import_zod3.z.string().min(1),
   /** Keyed MCP server config — top-level key is the server name, value is its config */
-  config: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown())
+  config: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown())
 });
 var CreateMcpInputSchema = MCPEntitySchema.omit({
   id: true,
@@ -188,10 +201,10 @@ var CreateMcpInputSchema = MCPEntitySchema.omit({
   deleted: true
 });
 var UpdateMcpInputSchema = CreateMcpInputSchema.partial();
-var MCPServerConfigSchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown());
+var MCPServerConfigSchema = import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown());
 
 // src/common/models.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 var ModelIds = /* @__PURE__ */ ((ModelIds2) => {
   ModelIds2["CLAUDE_3_HAIKU_1_0"] = "CLAUDE_3_HAIKU_1_0";
   ModelIds2["CLAUDE_3_OPUS_1_0"] = "CLAUDE_3_OPUS_1_0";
@@ -203,25 +216,29 @@ var ModelIds = /* @__PURE__ */ ((ModelIds2) => {
   ModelIds2["CLAUDE_4_SONNET_1_0"] = "CLAUDE_4_SONNET_1_0";
   return ModelIds2;
 })(ModelIds || {});
-var ModelIdsSchema = import_zod3.z.enum(ModelIds);
-var ModelConfigSchema = import_zod3.z.object({
+var ModelIdsSchema = import_zod4.z.enum(ModelIds);
+var nullToUndefined = (val) => val === null ? void 0 : val;
+var ModelConfigSchema = import_zod4.z.object({
   model: ModelIdsSchema,
-  temperature: import_zod3.z.number().min(0).max(1).optional(),
-  maxTokens: import_zod3.z.number().min(1).optional()
+  temperature: import_zod4.z.preprocess(
+    nullToUndefined,
+    import_zod4.z.number().min(0).max(1).optional()
+  ),
+  maxTokens: import_zod4.z.preprocess(nullToUndefined, import_zod4.z.number().min(1).optional())
 });
-var ModelPricingSchema = import_zod3.z.object({
-  inputPer1M: import_zod3.z.number(),
-  outputPer1M: import_zod3.z.number()
+var ModelPricingSchema = import_zod4.z.object({
+  inputPer1M: import_zod4.z.number(),
+  outputPer1M: import_zod4.z.number()
 });
-var ModelSchema = import_zod3.z.object({
+var ModelSchema = import_zod4.z.object({
   /** AI Gateway model ID */
   id: ModelIdsSchema,
   /** Display name */
-  name: import_zod3.z.string(),
+  name: import_zod4.z.string(),
   /** Provider (always 'anthropic') */
-  provider: import_zod3.z.literal("anthropic"),
+  provider: import_zod4.z.literal("anthropic"),
   /** Provider's model identifier (e.g., "claude-3-5-sonnet-20241022") */
-  providerModelId: import_zod3.z.string(),
+  providerModelId: import_zod4.z.string(),
   /** Pricing per 1M tokens */
   pricing: ModelPricingSchema
 });
@@ -294,10 +311,10 @@ var TargetSchema = TenantEntitySchema.extend({
 });
 
 // src/target/agent.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 var AgentSchema = TargetSchema.extend({
   /** Command to run the agent */
-  runCommand: import_zod4.z.string(),
+  runCommand: import_zod5.z.string(),
   /** Optional model configuration override */
   modelConfig: ModelConfigSchema.optional()
 });
@@ -312,61 +329,51 @@ var UpdateAgentInputSchema = CreateAgentInputSchema.partial().extend({
 });
 
 // src/target/skill.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var SKILL_FOLDER_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 var SEMVER_REGEX = /^\d+\.\d+\.\d+$/;
-var SkillVersionOriginSchema = import_zod5.z.enum(["manual", "pr", "master"]);
+var SkillVersionOriginSchema = import_zod6.z.enum(["manual", "pr", "master"]);
 function isValidSkillFolderName(name) {
   return typeof name === "string" && name.length > 0 && SKILL_FOLDER_NAME_REGEX.test(name.trim());
 }
-var SkillMetadataSchema = import_zod5.z.object({
-  name: import_zod5.z.string(),
-  description: import_zod5.z.string(),
-  allowedTools: import_zod5.z.array(import_zod5.z.string()).optional(),
-  skills: import_zod5.z.array(import_zod5.z.string()).optional()
-});
-var GitHubSourceSchema = import_zod5.z.object({
-  /** GitHub org or user, e.g. "wix" */
-  owner: import_zod5.z.string().min(1),
-  /** Repository name, e.g. "skills" */
-  repo: import_zod5.z.string().min(1),
-  /** Folder path to the skill directory, e.g. "wix-cli/skills/wix-cli-dashboard-page" */
-  path: import_zod5.z.string().min(1),
-  /** Git ref (branch, tag, or SHA), e.g. "master" or "v1.2.0" */
-  ref: import_zod5.z.string().min(1)
+var SkillMetadataSchema = import_zod6.z.object({
+  name: import_zod6.z.string(),
+  description: import_zod6.z.string(),
+  allowedTools: import_zod6.z.array(import_zod6.z.string()).optional(),
+  skills: import_zod6.z.array(import_zod6.z.string()).optional()
 });
-var SkillFileSchema = import_zod5.z.object({
+var SkillFileSchema = import_zod6.z.object({
   /** Relative path within the skill directory, e.g. "SKILL.md" or "references/API_SPEC.md" */
-  path: import_zod5.z.string().min(1),
+  path: import_zod6.z.string().min(1),
   /** File content (UTF-8 text) */
-  content: import_zod5.z.string()
+  content: import_zod6.z.string()
 });
-var SkillVersionSchema = import_zod5.z.object({
-  id: import_zod5.z.string(),
-  projectId: import_zod5.z.string(),
-  skillId: import_zod5.z.string(),
+var SkillVersionSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  projectId: import_zod6.z.string(),
+  skillId: import_zod6.z.string(),
   /** Semver string (e.g. "1.2.0") or Falcon fingerprint */
-  version: import_zod5.z.string(),
+  version: import_zod6.z.string(),
   /** How this version was created */
   origin: SkillVersionOriginSchema,
   /** Where this snapshot was taken from */
   source: GitHubSourceSchema.optional(),
   /** Frozen snapshot of all files in the skill directory */
-  files: import_zod5.z.array(SkillFileSchema).optional(),
+  files: import_zod6.z.array(SkillFileSchema).optional(),
   /** Optional notes about this version (changelog, reason for change) */
-  notes: import_zod5.z.string().optional(),
-  createdAt: import_zod5.z.string()
+  notes: import_zod6.z.string().optional(),
+  createdAt: import_zod6.z.string()
 });
-var CreateSkillVersionInputSchema = import_zod5.z.object({
+var CreateSkillVersionInputSchema = import_zod6.z.object({
   /** GitHub source to snapshot from. If not provided, uses the Skill's source. */
   source: GitHubSourceSchema.optional(),
   /** Version string for this snapshot (e.g. "1.0.0", "1.0.3"). */
-  version: import_zod5.z.string().min(1),
-  notes: import_zod5.z.string().optional(),
+  version: import_zod6.z.string().min(1),
+  notes: import_zod6.z.string().optional(),
   /** Origin of this version. Defaults to 'manual' in backend. */
   origin: SkillVersionOriginSchema.optional(),
   /** Pre-edited files to store directly (bypasses GitHub fetch when provided) */
-  files: import_zod5.z.array(SkillFileSchema).optional()
+  files: import_zod6.z.array(SkillFileSchema).optional()
 });
 var SkillSchema = TargetSchema.extend({
   /** GitHub source reference for live content fetching */
@@ -382,15 +389,15 @@ var SkillInputBaseSchema = SkillSchema.omit({
   source: true
 }).extend({
   /** Optional - not stored on Skill; content description lives in SkillVersion */
-  description: import_zod5.z.string().optional(),
+  description: import_zod6.z.string().optional(),
   /** GitHub source reference for live content fetching */
   source: GitHubSourceSchema.optional()
 });
-var InitialVersionInputSchema = import_zod5.z.object({
-  files: import_zod5.z.array(SkillFileSchema).optional(),
-  notes: import_zod5.z.string().optional(),
+var InitialVersionInputSchema = import_zod6.z.object({
+  files: import_zod6.z.array(SkillFileSchema).optional(),
+  notes: import_zod6.z.string().optional(),
   source: GitHubSourceSchema.optional(),
-  version: import_zod5.z.string().optional(),
+  version: import_zod6.z.string().optional(),
   origin: SkillVersionOriginSchema.optional()
 });
 var CreateSkillInputSchema = SkillInputBaseSchema.extend({
@@ -408,10 +415,10 @@ var SkillWithLatestVersionSchema = SkillSchema.extend({
 });
 
 // src/target/skills-group.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 var SkillsGroupSchema = TenantEntitySchema.extend({
   /** IDs of skills in this group */
-  skillIds: import_zod6.z.array(import_zod6.z.string())
+  skillIds: import_zod7.z.array(import_zod7.z.string())
 });
 var CreateSkillsGroupInputSchema = SkillsGroupSchema.omit({
   id: true,
@@ -422,10 +429,10 @@ var CreateSkillsGroupInputSchema = SkillsGroupSchema.omit({
 var UpdateSkillsGroupInputSchema = CreateSkillsGroupInputSchema.partial();
 
 // src/target/sub-agent.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var SubAgentSchema = TargetSchema.extend({
   /** The full sub-agent markdown content (YAML frontmatter + body) */
-  subAgentMd: import_zod7.z.string()
+  subAgentMd: import_zod8.z.string()
 });
 var SubAgentInputBaseSchema = SubAgentSchema.omit({
   id: true,
@@ -437,10 +444,10 @@ var CreateSubAgentInputSchema = SubAgentInputBaseSchema;
 var UpdateSubAgentInputSchema = SubAgentInputBaseSchema.partial();
 
 // src/test/index.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/test/base.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var TestType = /* @__PURE__ */ ((TestType2) => {
   TestType2["LLM"] = "LLM";
   TestType2["TOOL"] = "TOOL";
@@ -453,7 +460,7 @@ var TestType = /* @__PURE__ */ ((TestType2) => {
   TestType2["PLAYWRIGHT_NL"] = "PLAYWRIGHT_NL";
   return TestType2;
 })(TestType || {});
-var TestTypeSchema = import_zod8.z.enum(TestType);
+var TestTypeSchema = import_zod9.z.enum(TestType);
 var TestImportance = /* @__PURE__ */ ((TestImportance2) => {
   TestImportance2["LOW"] = "low";
   TestImportance2["MEDIUM"] = "medium";
@@ -461,153 +468,153 @@ var TestImportance = /* @__PURE__ */ ((TestImportance2) => {
   TestImportance2["CRITICAL"] = "critical";
   return TestImportance2;
 })(TestImportance || {});
-var TestImportanceSchema = import_zod8.z.enum(TestImportance);
-var BaseTestSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
+var TestImportanceSchema = import_zod9.z.enum(TestImportance);
+var BaseTestSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
   type: TestTypeSchema,
-  name: import_zod8.z.string().min(3),
-  description: import_zod8.z.string().optional(),
+  name: import_zod9.z.string().min(3),
+  description: import_zod9.z.string().optional(),
   importance: TestImportanceSchema.optional()
 });
 
 // src/test/llm.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var LLMTestSchema = BaseTestSchema.extend({
-  type: import_zod9.z.literal("LLM" /* LLM */),
+  type: import_zod10.z.literal("LLM" /* LLM */),
   /** Maximum steps for the LLM to take */
-  maxSteps: import_zod9.z.number().min(1).max(100),
+  maxSteps: import_zod10.z.number().min(1).max(100),
   /** Prompt to send to the evaluator */
-  prompt: import_zod9.z.string().min(1),
+  prompt: import_zod10.z.string().min(1),
   /** ID of the evaluator agent to use */
-  evaluatorId: import_zod9.z.string()
+  evaluatorId: import_zod10.z.string()
 });
 
 // src/test/tool.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var ToolTestSchema = BaseTestSchema.extend({
-  type: import_zod10.z.literal("TOOL" /* TOOL */),
+  type: import_zod11.z.literal("TOOL" /* TOOL */),
   /** Name of the tool that should be called */
-  toolName: import_zod10.z.string().min(3),
+  toolName: import_zod11.z.string().min(3),
   /** Expected arguments for the tool call */
-  args: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()),
+  args: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()),
   /** Expected content in the tool results */
-  resultsContent: import_zod10.z.string()
+  resultsContent: import_zod11.z.string()
 });
 
 // src/test/site-config.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var SiteConfigTestSchema = BaseTestSchema.extend({
-  type: import_zod11.z.literal("SITE_CONFIG" /* SITE_CONFIG */),
+  type: import_zod12.z.literal("SITE_CONFIG" /* SITE_CONFIG */),
   /** URL to call */
-  url: import_zod11.z.string().url(),
+  url: import_zod12.z.string().url(),
   /** HTTP method */
-  method: import_zod11.z.enum(["GET", "POST"]),
+  method: import_zod12.z.enum(["GET", "POST"]),
   /** Request body (for POST) */
-  body: import_zod11.z.string().optional(),
+  body: import_zod12.z.string().optional(),
   /** Expected HTTP status code */
-  expectedStatusCode: import_zod11.z.number().int().min(100).max(599),
+  expectedStatusCode: import_zod12.z.number().int().min(100).max(599),
   /** Expected response content */
-  expectedResponse: import_zod11.z.string().optional(),
+  expectedResponse: import_zod12.z.string().optional(),
   /** JMESPath expression to extract from response */
-  expectedResponseJMESPath: import_zod11.z.string().optional()
+  expectedResponseJMESPath: import_zod12.z.string().optional()
 });
 
 // src/test/command-execution.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var AllowedCommands = [
   "yarn install --no-immutable && yarn build",
   "npm run build",
   "yarn typecheck"
 ];
 var CommandExecutionTestSchema = BaseTestSchema.extend({
-  type: import_zod12.z.literal("COMMAND_EXECUTION" /* COMMAND_EXECUTION */),
+  type: import_zod13.z.literal("COMMAND_EXECUTION" /* COMMAND_EXECUTION */),
   /** Command to execute (must be in AllowedCommands) */
-  command: import_zod12.z.string().refine((value) => AllowedCommands.includes(value), {
+  command: import_zod13.z.string().refine((value) => AllowedCommands.includes(value), {
     message: `Command must be one of: ${AllowedCommands.join(", ")}`
   }),
   /** Expected exit code (default: 0) */
-  expectedExitCode: import_zod12.z.number().default(0).optional()
+  expectedExitCode: import_zod13.z.number().default(0).optional()
 });
 
 // src/test/file-presence.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var FilePresenceTestSchema = BaseTestSchema.extend({
-  type: import_zod13.z.literal("FILE_PRESENCE" /* FILE_PRESENCE */),
+  type: import_zod14.z.literal("FILE_PRESENCE" /* FILE_PRESENCE */),
   /** Paths to check */
-  paths: import_zod13.z.array(import_zod13.z.string()),
+  paths: import_zod14.z.array(import_zod14.z.string()),
   /** Whether files should exist (true) or not exist (false) */
-  shouldExist: import_zod13.z.boolean()
+  shouldExist: import_zod14.z.boolean()
 });
 
 // src/test/file-content.ts
-var import_zod14 = require("zod");
-var FileContentCheckSchema = import_zod14.z.object({
+var import_zod15 = require("zod");
+var FileContentCheckSchema = import_zod15.z.object({
   /** Strings that must be present in the file */
-  contains: import_zod14.z.array(import_zod14.z.string()).optional(),
+  contains: import_zod15.z.array(import_zod15.z.string()).optional(),
   /** Strings that must NOT be present in the file */
-  notContains: import_zod14.z.array(import_zod14.z.string()).optional(),
+  notContains: import_zod15.z.array(import_zod15.z.string()).optional(),
   /** Regex pattern the content must match */
-  matches: import_zod14.z.string().optional(),
+  matches: import_zod15.z.string().optional(),
   /** JSON path checks for structured content */
-  jsonPath: import_zod14.z.array(
-    import_zod14.z.object({
-      path: import_zod14.z.string(),
-      value: import_zod14.z.unknown()
+  jsonPath: import_zod15.z.array(
+    import_zod15.z.object({
+      path: import_zod15.z.string(),
+      value: import_zod15.z.unknown()
     })
   ).optional(),
   /** Lines that should be added (for diff checking) */
-  added: import_zod14.z.array(import_zod14.z.string()).optional(),
+  added: import_zod15.z.array(import_zod15.z.string()).optional(),
   /** Lines that should be removed (for diff checking) */
-  removed: import_zod14.z.array(import_zod14.z.string()).optional()
+  removed: import_zod15.z.array(import_zod15.z.string()).optional()
 });
 var FileContentTestSchema = BaseTestSchema.extend({
-  type: import_zod14.z.literal("FILE_CONTENT" /* FILE_CONTENT */),
+  type: import_zod15.z.literal("FILE_CONTENT" /* FILE_CONTENT */),
   /** Path to the file to check */
-  path: import_zod14.z.string(),
+  path: import_zod15.z.string(),
   /** Content checks to perform */
   checks: FileContentCheckSchema
 });
 
 // src/test/build-check.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 var BuildCheckTestSchema = BaseTestSchema.extend({
-  type: import_zod15.z.literal("BUILD_CHECK" /* BUILD_CHECK */),
+  type: import_zod16.z.literal("BUILD_CHECK" /* BUILD_CHECK */),
   /** Build command to execute */
-  command: import_zod15.z.string(),
+  command: import_zod16.z.string(),
   /** Whether the build should succeed */
-  expectSuccess: import_zod15.z.boolean(),
+  expectSuccess: import_zod16.z.boolean(),
   /** Maximum allowed warnings (optional) */
-  allowedWarnings: import_zod15.z.number().optional(),
+  allowedWarnings: import_zod16.z.number().optional(),
   /** Timeout in milliseconds */
-  timeout: import_zod15.z.number().optional()
+  timeout: import_zod16.z.number().optional()
 });
 
 // src/test/vitest.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 var VitestTestSchema = BaseTestSchema.extend({
-  type: import_zod16.z.literal("VITEST" /* VITEST */),
+  type: import_zod17.z.literal("VITEST" /* VITEST */),
   /** Test file content */
-  testFile: import_zod16.z.string(),
+  testFile: import_zod17.z.string(),
   /** Name of the test file */
-  testFileName: import_zod16.z.string(),
+  testFileName: import_zod17.z.string(),
   /** Minimum pass rate required (0-100) */
-  minPassRate: import_zod16.z.number().min(0).max(100)
+  minPassRate: import_zod17.z.number().min(0).max(100)
 });
 
 // src/test/playwright-nl.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var PlaywrightNLTestSchema = BaseTestSchema.extend({
-  type: import_zod17.z.literal("PLAYWRIGHT_NL" /* PLAYWRIGHT_NL */),
+  type: import_zod18.z.literal("PLAYWRIGHT_NL" /* PLAYWRIGHT_NL */),
   /** Natural language steps to execute */
-  steps: import_zod17.z.array(import_zod17.z.string()),
+  steps: import_zod18.z.array(import_zod18.z.string()),
   /** Expected outcome description */
-  expectedOutcome: import_zod17.z.string(),
+  expectedOutcome: import_zod18.z.string(),
   /** Timeout in milliseconds */
-  timeout: import_zod17.z.number().optional()
+  timeout: import_zod18.z.number().optional()
 });
 
 // src/test/index.ts
-var TestSchema = import_zod18.z.discriminatedUnion("type", [
+var TestSchema = import_zod19.z.discriminatedUnion("type", [
   LLMTestSchema,
   ToolTestSchema,
   SiteConfigTestSchema,
@@ -620,66 +627,66 @@ var TestSchema = import_zod18.z.discriminatedUnion("type", [
 ]);
 
 // src/scenario/assertions.ts
-var import_zod19 = require("zod");
-var SkillWasCalledAssertionSchema = import_zod19.z.object({
-  type: import_zod19.z.literal("skill_was_called"),
+var import_zod20 = require("zod");
+var SkillWasCalledAssertionSchema = import_zod20.z.object({
+  type: import_zod20.z.literal("skill_was_called"),
   /** Names of the skills that must have been called (matched against trace Skill tool args) */
-  skillNames: import_zod19.z.array(import_zod19.z.string().min(1)).min(1)
+  skillNames: import_zod20.z.array(import_zod20.z.string().min(1)).min(1)
 });
-var BuildPassedAssertionSchema = import_zod19.z.object({
-  type: import_zod19.z.literal("build_passed"),
+var BuildPassedAssertionSchema = import_zod20.z.object({
+  type: import_zod20.z.literal("build_passed"),
   /** Command to run (default: "yarn build") */
-  command: import_zod19.z.string().optional(),
+  command: import_zod20.z.string().optional(),
   /** Expected exit code (default: 0) */
-  expectedExitCode: import_zod19.z.number().int().optional()
+  expectedExitCode: import_zod20.z.number().int().optional()
 });
-var LlmJudgeAssertionSchema = import_zod19.z.object({
-  type: import_zod19.z.literal("llm_judge"),
+var LlmJudgeAssertionSchema = import_zod20.z.object({
+  type: import_zod20.z.literal("llm_judge"),
   /** Prompt template; placeholders: {{output}}, {{cwd}}, {{changedFiles}}, {{trace}} */
-  prompt: import_zod19.z.string(),
+  prompt: import_zod20.z.string(),
   /** Optional system prompt for the judge (default asks for JSON with score) */
-  systemPrompt: import_zod19.z.string().optional(),
+  systemPrompt: import_zod20.z.string().optional(),
   /** Minimum score to pass (0-100, default 70) */
-  minScore: import_zod19.z.number().int().min(0).max(100).optional(),
+  minScore: import_zod20.z.number().int().min(0).max(100).optional(),
   /** Model for the judge (e.g. claude-3-5-haiku) */
-  model: import_zod19.z.string().optional(),
-  maxTokens: import_zod19.z.number().int().optional(),
-  temperature: import_zod19.z.number().min(0).max(1).optional()
+  model: import_zod20.z.string().optional(),
+  maxTokens: import_zod20.z.number().int().optional(),
+  temperature: import_zod20.z.number().min(0).max(1).optional()
 });
-var AssertionSchema = import_zod19.z.union([
+var AssertionSchema = import_zod20.z.union([
   SkillWasCalledAssertionSchema,
   BuildPassedAssertionSchema,
   LlmJudgeAssertionSchema
 ]);
 
 // src/scenario/environment.ts
-var import_zod20 = require("zod");
-var LocalProjectConfigSchema = import_zod20.z.object({
+var import_zod21 = require("zod");
+var LocalProjectConfigSchema = import_zod21.z.object({
   /** Template ID to use for the local project */
-  templateId: import_zod20.z.string().optional(),
+  templateId: import_zod21.z.string().optional(),
   /** Files to create in the project */
-  files: import_zod20.z.array(
-    import_zod20.z.object({
-      path: import_zod20.z.string().min(1),
-      content: import_zod20.z.string().min(1)
+  files: import_zod21.z.array(
+    import_zod21.z.object({
+      path: import_zod21.z.string().min(1),
+      content: import_zod21.z.string().min(1)
     })
   ).optional()
 });
-var MetaSiteConfigSchema = import_zod20.z.object({
-  configurations: import_zod20.z.array(
-    import_zod20.z.object({
-      name: import_zod20.z.string().min(1),
-      apiCalls: import_zod20.z.array(
-        import_zod20.z.object({
-          url: import_zod20.z.string().url(),
-          method: import_zod20.z.enum(["POST", "PUT"]),
-          body: import_zod20.z.string()
+var MetaSiteConfigSchema = import_zod21.z.object({
+  configurations: import_zod21.z.array(
+    import_zod21.z.object({
+      name: import_zod21.z.string().min(1),
+      apiCalls: import_zod21.z.array(
+        import_zod21.z.object({
+          url: import_zod21.z.string().url(),
+          method: import_zod21.z.enum(["POST", "PUT"]),
+          body: import_zod21.z.string()
         })
       )
     })
   ).optional()
 });
-var EnvironmentSchema = import_zod20.z.object({
+var EnvironmentSchema = import_zod21.z.object({
   /** Local project configuration */
   localProject: LocalProjectConfigSchema.optional(),
   /** Meta site configuration */
@@ -687,54 +694,54 @@ var EnvironmentSchema = import_zod20.z.object({
 });
 
 // src/scenario/test-scenario.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 
 // src/assertion/assertion.ts
-var import_zod21 = require("zod");
-var AssertionTypeSchema = import_zod21.z.enum([
+var import_zod22 = require("zod");
+var AssertionTypeSchema = import_zod22.z.enum([
   "skill_was_called",
   "build_passed",
   "llm_judge"
 ]);
-var AssertionParameterTypeSchema = import_zod21.z.enum([
+var AssertionParameterTypeSchema = import_zod22.z.enum([
   "string",
   "number",
   "boolean"
 ]);
-var AssertionParameterSchema = import_zod21.z.object({
+var AssertionParameterSchema = import_zod22.z.object({
   /** Parameter name (used as key in params object) */
-  name: import_zod21.z.string().min(1),
+  name: import_zod22.z.string().min(1),
   /** Display label for the parameter */
-  label: import_zod21.z.string().min(1),
+  label: import_zod22.z.string().min(1),
   /** Parameter type */
   type: AssertionParameterTypeSchema,
   /** Whether this parameter is required */
-  required: import_zod21.z.boolean(),
+  required: import_zod22.z.boolean(),
   /** Default value (optional, used when not provided) */
-  defaultValue: import_zod21.z.union([import_zod21.z.string(), import_zod21.z.number(), import_zod21.z.boolean()]).optional(),
+  defaultValue: import_zod22.z.union([import_zod22.z.string(), import_zod22.z.number(), import_zod22.z.boolean()]).optional(),
   /** If true, parameter is hidden by default behind "Show advanced options" */
-  advanced: import_zod21.z.boolean().optional()
+  advanced: import_zod22.z.boolean().optional()
 });
-var ScenarioAssertionLinkSchema = import_zod21.z.object({
+var ScenarioAssertionLinkSchema = import_zod22.z.object({
   /** ID of the assertion (can be system assertion like 'system:skill_was_called' or custom assertion UUID) */
-  assertionId: import_zod21.z.string(),
+  assertionId: import_zod22.z.string(),
   /** Parameter values for this assertion in this scenario */
-  params: import_zod21.z.record(
-    import_zod21.z.string(),
-    import_zod21.z.union([import_zod21.z.string(), import_zod21.z.number(), import_zod21.z.boolean(), import_zod21.z.null()])
+  params: import_zod22.z.record(
+    import_zod22.z.string(),
+    import_zod22.z.union([import_zod22.z.string(), import_zod22.z.number(), import_zod22.z.boolean(), import_zod22.z.null()])
   ).optional()
 });
-var SkillWasCalledConfigSchema = import_zod21.z.object({
+var SkillWasCalledConfigSchema = import_zod22.z.object({
   /** Names of the skills that must have been called */
-  skillNames: import_zod21.z.array(import_zod21.z.string().min(1)).min(1)
+  skillNames: import_zod22.z.array(import_zod22.z.string().min(1)).min(1)
 });
-var BuildPassedConfigSchema = import_zod21.z.strictObject({
+var BuildPassedConfigSchema = import_zod22.z.strictObject({
   /** Command to run (default: "yarn build") */
-  command: import_zod21.z.string().optional(),
+  command: import_zod22.z.string().optional(),
   /** Expected exit code (default: 0) */
-  expectedExitCode: import_zod21.z.number().int().optional()
+  expectedExitCode: import_zod22.z.number().int().optional()
 });
-var LlmJudgeConfigSchema = import_zod21.z.object({
+var LlmJudgeConfigSchema = import_zod22.z.object({
   /**
    * Prompt template with placeholders:
    * - {{output}}: agent's final output
@@ -745,28 +752,28 @@ var LlmJudgeConfigSchema = import_zod21.z.object({
    * - {{trace}}: step-by-step trace of tool calls
    * - Custom parameters defined in the parameters array
    */
-  prompt: import_zod21.z.string().min(1),
+  prompt: import_zod22.z.string().min(1),
   /** Optional system prompt for the judge */
-  systemPrompt: import_zod21.z.string().optional(),
+  systemPrompt: import_zod22.z.string().optional(),
   /** Minimum score to pass (0-100, default 70) */
-  minScore: import_zod21.z.number().int().min(0).max(100).optional(),
+  minScore: import_zod22.z.number().int().min(0).max(100).optional(),
   /** Model for the judge (e.g. claude-3-5-haiku-20241022) */
-  model: import_zod21.z.string().optional(),
+  model: import_zod22.z.string().optional(),
   /** Max output tokens */
-  maxTokens: import_zod21.z.number().int().optional(),
+  maxTokens: import_zod22.z.number().int().optional(),
   /** Temperature (0-1) */
-  temperature: import_zod21.z.number().min(0).max(1).optional(),
+  temperature: import_zod22.z.number().min(0).max(1).optional(),
   /** User-defined parameters for this assertion */
-  parameters: import_zod21.z.array(AssertionParameterSchema).optional()
+  parameters: import_zod22.z.array(AssertionParameterSchema).optional()
 });
-var AssertionConfigSchema = import_zod21.z.union([
+var AssertionConfigSchema = import_zod22.z.union([
   LlmJudgeConfigSchema,
   // requires prompt - check first
   SkillWasCalledConfigSchema,
   // requires skillName
   BuildPassedConfigSchema,
   // all optional, uses strictObject to reject unknown keys
-  import_zod21.z.object({})
+  import_zod22.z.object({})
   // fallback empty config
 ]);
 var CustomAssertionSchema = TenantEntitySchema.extend({
@@ -811,23 +818,23 @@ function getLlmJudgeConfig(assertion) {
 }
 
 // src/scenario/test-scenario.ts
-var ExpectedFileSchema = import_zod22.z.object({
+var ExpectedFileSchema = import_zod23.z.object({
   /** Relative path where the file should be created */
-  path: import_zod22.z.string(),
+  path: import_zod23.z.string(),
   /** Optional expected content */
-  content: import_zod22.z.string().optional()
+  content: import_zod23.z.string().optional()
 });
 var TestScenarioSchema = TenantEntitySchema.extend({
   /** The prompt sent to the agent to trigger the task */
-  triggerPrompt: import_zod22.z.string().min(10),
+  triggerPrompt: import_zod23.z.string().min(10),
   /** ID of the template to use for this scenario (null = no template) */
-  templateId: import_zod22.z.string().nullish(),
+  templateId: import_zod23.z.string().nullish(),
   /** Inline assertions to evaluate for this scenario (legacy) */
-  assertions: import_zod22.z.array(AssertionSchema).optional(),
+  assertions: import_zod23.z.array(AssertionSchema).optional(),
   /** IDs of saved assertions to evaluate (from assertions table) - legacy, use assertionLinks */
-  assertionIds: import_zod22.z.array(import_zod22.z.string()).optional(),
+  assertionIds: import_zod23.z.array(import_zod23.z.string()).optional(),
   /** Linked assertions with per-scenario parameter values */
-  assertionLinks: import_zod22.z.array(ScenarioAssertionLinkSchema).optional()
+  assertionLinks: import_zod23.z.array(ScenarioAssertionLinkSchema).optional()
 });
 var CreateTestScenarioInputSchema = TestScenarioSchema.omit({
   id: true,
@@ -838,10 +845,10 @@ var CreateTestScenarioInputSchema = TestScenarioSchema.omit({
 var UpdateTestScenarioInputSchema = CreateTestScenarioInputSchema.partial();
 
 // src/suite/test-suite.ts
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 var TestSuiteSchema = TenantEntitySchema.extend({
   /** IDs of test scenarios in this suite */
-  scenarioIds: import_zod23.z.array(import_zod23.z.string())
+  scenarioIds: import_zod24.z.array(import_zod24.z.string())
 });
 var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
   id: true,
@@ -852,21 +859,21 @@ var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
 var UpdateTestSuiteInputSchema = CreateTestSuiteInputSchema.partial();
 
 // src/evaluation/metrics.ts
-var import_zod24 = require("zod");
-var TokenUsageSchema = import_zod24.z.object({
-  prompt: import_zod24.z.number(),
-  completion: import_zod24.z.number(),
-  total: import_zod24.z.number()
-});
-var EvalMetricsSchema = import_zod24.z.object({
-  totalAssertions: import_zod24.z.number(),
-  passed: import_zod24.z.number(),
-  failed: import_zod24.z.number(),
-  skipped: import_zod24.z.number(),
-  errors: import_zod24.z.number(),
-  passRate: import_zod24.z.number(),
-  avgDuration: import_zod24.z.number(),
-  totalDuration: import_zod24.z.number()
+var import_zod25 = require("zod");
+var TokenUsageSchema = import_zod25.z.object({
+  prompt: import_zod25.z.number(),
+  completion: import_zod25.z.number(),
+  total: import_zod25.z.number()
+});
+var EvalMetricsSchema = import_zod25.z.object({
+  totalAssertions: import_zod25.z.number(),
+  passed: import_zod25.z.number(),
+  failed: import_zod25.z.number(),
+  skipped: import_zod25.z.number(),
+  errors: import_zod25.z.number(),
+  passRate: import_zod25.z.number(),
+  avgDuration: import_zod25.z.number(),
+  totalDuration: import_zod25.z.number()
 });
 var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["PENDING"] = "pending";
@@ -876,7 +883,7 @@ var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["CANCELLED"] = "cancelled";
   return EvalStatus2;
 })(EvalStatus || {});
-var EvalStatusSchema = import_zod24.z.enum(EvalStatus);
+var EvalStatusSchema = import_zod25.z.enum(EvalStatus);
 var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["COMPLETION"] = "completion";
   LLMStepType2["TOOL_USE"] = "tool_use";
@@ -884,52 +891,52 @@ var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["THINKING"] = "thinking";
   return LLMStepType2;
 })(LLMStepType || {});
-var LLMTraceStepSchema = import_zod24.z.object({
-  id: import_zod24.z.string(),
-  stepNumber: import_zod24.z.number(),
-  type: import_zod24.z.enum(LLMStepType),
-  model: import_zod24.z.string(),
-  provider: import_zod24.z.string(),
-  startedAt: import_zod24.z.string(),
-  durationMs: import_zod24.z.number(),
+var LLMTraceStepSchema = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  stepNumber: import_zod25.z.number(),
+  type: import_zod25.z.enum(LLMStepType),
+  model: import_zod25.z.string(),
+  provider: import_zod25.z.string(),
+  startedAt: import_zod25.z.string(),
+  durationMs: import_zod25.z.number(),
   tokenUsage: TokenUsageSchema,
-  costUsd: import_zod24.z.number(),
-  toolName: import_zod24.z.string().optional(),
-  toolArguments: import_zod24.z.string().optional(),
-  inputPreview: import_zod24.z.string().optional(),
-  outputPreview: import_zod24.z.string().optional(),
-  success: import_zod24.z.boolean(),
-  error: import_zod24.z.string().optional()
-});
-var LLMBreakdownStatsSchema = import_zod24.z.object({
-  count: import_zod24.z.number(),
-  durationMs: import_zod24.z.number(),
-  tokens: import_zod24.z.number(),
-  costUsd: import_zod24.z.number()
-});
-var LLMTraceSummarySchema = import_zod24.z.object({
-  totalSteps: import_zod24.z.number(),
-  totalDurationMs: import_zod24.z.number(),
+  costUsd: import_zod25.z.number(),
+  toolName: import_zod25.z.string().optional(),
+  toolArguments: import_zod25.z.string().optional(),
+  inputPreview: import_zod25.z.string().optional(),
+  outputPreview: import_zod25.z.string().optional(),
+  success: import_zod25.z.boolean(),
+  error: import_zod25.z.string().optional()
+});
+var LLMBreakdownStatsSchema = import_zod25.z.object({
+  count: import_zod25.z.number(),
+  durationMs: import_zod25.z.number(),
+  tokens: import_zod25.z.number(),
+  costUsd: import_zod25.z.number()
+});
+var LLMTraceSummarySchema = import_zod25.z.object({
+  totalSteps: import_zod25.z.number(),
+  totalDurationMs: import_zod25.z.number(),
   totalTokens: TokenUsageSchema,
-  totalCostUsd: import_zod24.z.number(),
-  stepTypeBreakdown: import_zod24.z.record(import_zod24.z.string(), LLMBreakdownStatsSchema).optional(),
-  modelBreakdown: import_zod24.z.record(import_zod24.z.string(), LLMBreakdownStatsSchema),
-  modelsUsed: import_zod24.z.array(import_zod24.z.string())
-});
-var LLMTraceSchema = import_zod24.z.object({
-  id: import_zod24.z.string(),
-  steps: import_zod24.z.array(LLMTraceStepSchema),
+  totalCostUsd: import_zod25.z.number(),
+  stepTypeBreakdown: import_zod25.z.record(import_zod25.z.string(), LLMBreakdownStatsSchema).optional(),
+  modelBreakdown: import_zod25.z.record(import_zod25.z.string(), LLMBreakdownStatsSchema),
+  modelsUsed: import_zod25.z.array(import_zod25.z.string())
+});
+var LLMTraceSchema = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  steps: import_zod25.z.array(LLMTraceStepSchema),
   summary: LLMTraceSummarySchema
 });
 
 // src/evaluation/eval-result.ts
-var import_zod27 = require("zod");
+var import_zod28 = require("zod");
 
 // src/evaluation/eval-run.ts
-var import_zod26 = require("zod");
+var import_zod27 = require("zod");
 
 // src/evaluation/live-trace.ts
-var import_zod25 = require("zod");
+var import_zod26 = require("zod");
 var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["THINKING"] = "thinking";
   LiveTraceEventType2["TOOL_USE"] = "tool_use";
@@ -943,37 +950,37 @@ var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["USER"] = "user";
   return LiveTraceEventType2;
 })(LiveTraceEventType || {});
-var LiveTraceEventSchema = import_zod25.z.object({
+var LiveTraceEventSchema = import_zod26.z.object({
   /** The evaluation run ID */
-  evalRunId: import_zod25.z.string(),
+  evalRunId: import_zod26.z.string(),
   /** The scenario ID being executed */
-  scenarioId: import_zod25.z.string(),
+  scenarioId: import_zod26.z.string(),
   /** The scenario name for display */
-  scenarioName: import_zod25.z.string(),
+  scenarioName: import_zod26.z.string(),
   /** The target ID (skill, agent, etc.) */
-  targetId: import_zod25.z.string(),
+  targetId: import_zod26.z.string(),
   /** The target name for display */
-  targetName: import_zod25.z.string(),
+  targetName: import_zod26.z.string(),
   /** Step number in the current scenario execution */
-  stepNumber: import_zod25.z.number(),
+  stepNumber: import_zod26.z.number(),
   /** Type of trace event */
-  type: import_zod25.z.enum(LiveTraceEventType),
+  type: import_zod26.z.enum(LiveTraceEventType),
   /** Tool name if this is a tool_use event */
-  toolName: import_zod25.z.string().optional(),
+  toolName: import_zod26.z.string().optional(),
   /** Tool arguments preview (truncated JSON) */
-  toolArgs: import_zod25.z.string().optional(),
+  toolArgs: import_zod26.z.string().optional(),
   /** Output preview (truncated text) */
-  outputPreview: import_zod25.z.string().optional(),
+  outputPreview: import_zod26.z.string().optional(),
   /** File path for file operations */
-  filePath: import_zod25.z.string().optional(),
+  filePath: import_zod26.z.string().optional(),
   /** Elapsed time in milliseconds for progress events */
-  elapsedMs: import_zod25.z.number().optional(),
+  elapsedMs: import_zod26.z.number().optional(),
   /** Thinking/reasoning text from Claude */
-  thinking: import_zod25.z.string().optional(),
+  thinking: import_zod26.z.string().optional(),
   /** Timestamp when this event occurred */
-  timestamp: import_zod25.z.string(),
+  timestamp: import_zod26.z.string(),
   /** Whether this is the final event for this scenario */
-  isComplete: import_zod25.z.boolean()
+  isComplete: import_zod26.z.boolean()
 });
 var TRACE_EVENT_PREFIX = "TRACE_EVENT:";
 function parseTraceEventLine(line) {
@@ -1001,14 +1008,14 @@ var TriggerType = /* @__PURE__ */ ((TriggerType2) => {
   TriggerType2["MANUAL"] = "MANUAL";
   return TriggerType2;
 })(TriggerType || {});
-var TriggerMetadataSchema = import_zod26.z.object({
-  version: import_zod26.z.string().optional(),
-  resourceUpdated: import_zod26.z.array(import_zod26.z.string()).optional()
+var TriggerMetadataSchema = import_zod27.z.object({
+  version: import_zod27.z.string().optional(),
+  resourceUpdated: import_zod27.z.array(import_zod27.z.string()).optional()
 });
-var TriggerSchema = import_zod26.z.object({
-  id: import_zod26.z.string(),
+var TriggerSchema = import_zod27.z.object({
+  id: import_zod27.z.string(),
   metadata: TriggerMetadataSchema.optional(),
-  type: import_zod26.z.enum(TriggerType)
+  type: import_zod27.z.enum(TriggerType)
 });
 var FailureCategory = /* @__PURE__ */ ((FailureCategory2) => {
   FailureCategory2["MISSING_FILE"] = "missing_file";
@@ -1026,28 +1033,28 @@ var FailureSeverity = /* @__PURE__ */ ((FailureSeverity2) => {
   FailureSeverity2["LOW"] = "low";
   return FailureSeverity2;
 })(FailureSeverity || {});
-var DiffLineTypeSchema = import_zod26.z.enum(["added", "removed", "unchanged"]);
-var DiffLineSchema = import_zod26.z.object({
+var DiffLineTypeSchema = import_zod27.z.enum(["added", "removed", "unchanged"]);
+var DiffLineSchema = import_zod27.z.object({
   type: DiffLineTypeSchema,
-  content: import_zod26.z.string(),
-  lineNumber: import_zod26.z.number()
-});
-var DiffContentSchema = import_zod26.z.object({
-  path: import_zod26.z.string(),
-  expected: import_zod26.z.string(),
-  actual: import_zod26.z.string(),
-  diffLines: import_zod26.z.array(DiffLineSchema),
-  renamedFrom: import_zod26.z.string().optional()
-});
-var CommandExecutionSchema = import_zod26.z.object({
-  command: import_zod26.z.string(),
-  exitCode: import_zod26.z.number(),
-  output: import_zod26.z.string().optional(),
-  duration: import_zod26.z.number()
-});
-var FileModificationSchema = import_zod26.z.object({
-  path: import_zod26.z.string(),
-  action: import_zod26.z.enum(["created", "modified", "deleted"])
+  content: import_zod27.z.string(),
+  lineNumber: import_zod27.z.number()
+});
+var DiffContentSchema = import_zod27.z.object({
+  path: import_zod27.z.string(),
+  expected: import_zod27.z.string(),
+  actual: import_zod27.z.string(),
+  diffLines: import_zod27.z.array(DiffLineSchema),
+  renamedFrom: import_zod27.z.string().optional()
+});
+var CommandExecutionSchema = import_zod27.z.object({
+  command: import_zod27.z.string(),
+  exitCode: import_zod27.z.number(),
+  output: import_zod27.z.string().optional(),
+  duration: import_zod27.z.number()
+});
+var FileModificationSchema = import_zod27.z.object({
+  path: import_zod27.z.string(),
+  action: import_zod27.z.enum(["created", "modified", "deleted"])
 });
 var TemplateFileStatus = /* @__PURE__ */ ((TemplateFileStatus2) => {
   TemplateFileStatus2["NEW"] = "new";
@@ -1055,81 +1062,81 @@ var TemplateFileStatus = /* @__PURE__ */ ((TemplateFileStatus2) => {
   TemplateFileStatus2["UNCHANGED"] = "unchanged";
   return TemplateFileStatus2;
 })(TemplateFileStatus || {});
-var TemplateFileSchema = import_zod26.z.object({
+var TemplateFileSchema = import_zod27.z.object({
   /** Relative path within the template */
-  path: import_zod26.z.string(),
+  path: import_zod27.z.string(),
   /** Full file content after execution */
-  content: import_zod26.z.string(),
+  content: import_zod27.z.string(),
   /** File status (new, modified, unchanged) */
-  status: import_zod26.z.enum(["new", "modified", "unchanged"])
-});
-var ApiCallSchema = import_zod26.z.object({
-  endpoint: import_zod26.z.string(),
-  tokensUsed: import_zod26.z.number(),
-  duration: import_zod26.z.number()
-});
-var ExecutionTraceSchema = import_zod26.z.object({
-  commands: import_zod26.z.array(CommandExecutionSchema),
-  filesModified: import_zod26.z.array(FileModificationSchema),
-  apiCalls: import_zod26.z.array(ApiCallSchema),
-  totalDuration: import_zod26.z.number()
-});
-var FailureAnalysisSchema = import_zod26.z.object({
-  category: import_zod26.z.enum(FailureCategory),
-  severity: import_zod26.z.enum(FailureSeverity),
-  summary: import_zod26.z.string(),
-  details: import_zod26.z.string(),
-  rootCause: import_zod26.z.string(),
-  suggestedFix: import_zod26.z.string(),
-  relatedAssertions: import_zod26.z.array(import_zod26.z.string()),
-  codeSnippet: import_zod26.z.string().optional(),
-  similarIssues: import_zod26.z.array(import_zod26.z.string()).optional(),
-  patternId: import_zod26.z.string().optional(),
+  status: import_zod27.z.enum(["new", "modified", "unchanged"])
+});
+var ApiCallSchema = import_zod27.z.object({
+  endpoint: import_zod27.z.string(),
+  tokensUsed: import_zod27.z.number(),
+  duration: import_zod27.z.number()
+});
+var ExecutionTraceSchema = import_zod27.z.object({
+  commands: import_zod27.z.array(CommandExecutionSchema),
+  filesModified: import_zod27.z.array(FileModificationSchema),
+  apiCalls: import_zod27.z.array(ApiCallSchema),
+  totalDuration: import_zod27.z.number()
+});
+var FailureAnalysisSchema = import_zod27.z.object({
+  category: import_zod27.z.enum(FailureCategory),
+  severity: import_zod27.z.enum(FailureSeverity),
+  summary: import_zod27.z.string(),
+  details: import_zod27.z.string(),
+  rootCause: import_zod27.z.string(),
+  suggestedFix: import_zod27.z.string(),
+  relatedAssertions: import_zod27.z.array(import_zod27.z.string()),
+  codeSnippet: import_zod27.z.string().optional(),
+  similarIssues: import_zod27.z.array(import_zod27.z.string()).optional(),
+  patternId: import_zod27.z.string().optional(),
   // Extended fields for detailed debugging
   diff: DiffContentSchema.optional(),
   executionTrace: ExecutionTraceSchema.optional()
 });
 var EvalRunSchema = TenantEntitySchema.extend({
   /** Agent ID for this run */
-  agentId: import_zod26.z.string().optional(),
+  agentId: import_zod27.z.string().optional(),
   /** Skills group ID for this run */
-  skillsGroupId: import_zod26.z.string().optional(),
+  skillsGroupId: import_zod27.z.string().optional(),
   /** Map of skillId to skillVersionId for this run */
-  skillVersions: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.string()).optional(),
+  skillVersions: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.string()).optional(),
   /** Scenario IDs to run */
-  scenarioIds: import_zod26.z.array(import_zod26.z.string()),
+  scenarioIds: import_zod27.z.array(import_zod27.z.string()),
   /** Current status */
   status: EvalStatusSchema,
   /** Progress percentage (0-100) */
-  progress: import_zod26.z.number(),
+  progress: import_zod27.z.number(),
   /** Results for each scenario/target combination (lazy to break eval-result ↔ eval-run cycle) */
-  results: import_zod26.z.array(import_zod26.z.lazy(() => EvalRunResultSchema)),
+  results: import_zod27.z.array(import_zod27.z.lazy(() => EvalRunResultSchema)),
   /** Aggregated metrics across all results */
   aggregateMetrics: EvalMetricsSchema,
   /** Failure analyses */
-  failureAnalyses: import_zod26.z.array(FailureAnalysisSchema).optional(),
+  failureAnalyses: import_zod27.z.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: import_zod26.z.string().optional(),
+  startedAt: import_zod27.z.string().optional(),
   /** When the run completed */
-  completedAt: import_zod26.z.string().optional(),
+  completedAt: import_zod27.z.string().optional(),
   /** Live trace events captured during execution (for playback on results page) */
-  liveTraceEvents: import_zod26.z.array(LiveTraceEventSchema).optional(),
+  liveTraceEvents: import_zod27.z.array(LiveTraceEventSchema).optional(),
   /** Remote job ID for tracking execution in Dev Machines */
-  jobId: import_zod26.z.string().optional(),
+  jobId: import_zod27.z.string().optional(),
   /** Remote job status from the Dev Machine API (PENDING, RUNNING, COMPLETED, FAILED, CANCELLED) */
-  jobStatus: import_zod26.z.string().optional(),
+  jobStatus: import_zod27.z.string().optional(),
   /** Remote job error message if the job failed */
-  jobError: import_zod26.z.string().optional(),
+  jobError: import_zod27.z.string().optional(),
   /** Timestamp of the last job status check */
-  jobStatusCheckedAt: import_zod26.z.string().optional(),
+  jobStatusCheckedAt: import_zod27.z.string().optional(),
   /** MCP server IDs to enable for this run (optional) */
-  mcpIds: import_zod26.z.array(import_zod26.z.string()).optional(),
+  mcpIds: import_zod27.z.array(import_zod27.z.string()).optional(),
   /** Sub-agent IDs to enable for this run (optional) */
-  subAgentIds: import_zod26.z.array(import_zod26.z.string()).optional()
+  subAgentIds: import_zod27.z.array(import_zod27.z.string()).optional()
 });
 var CreateEvalRunInputSchema = EvalRunSchema.omit({
   id: true,
@@ -1142,28 +1149,28 @@ var CreateEvalRunInputSchema = EvalRunSchema.omit({
   startedAt: true,
   completedAt: true
 });
-var EvaluationProgressSchema = import_zod26.z.object({
-  runId: import_zod26.z.string(),
-  targetId: import_zod26.z.string(),
-  totalScenarios: import_zod26.z.number(),
-  completedScenarios: import_zod26.z.number(),
-  scenarioProgress: import_zod26.z.array(
-    import_zod26.z.object({
-      scenarioId: import_zod26.z.string(),
-      currentStep: import_zod26.z.string(),
-      error: import_zod26.z.string().optional()
+var EvaluationProgressSchema = import_zod27.z.object({
+  runId: import_zod27.z.string(),
+  targetId: import_zod27.z.string(),
+  totalScenarios: import_zod27.z.number(),
+  completedScenarios: import_zod27.z.number(),
+  scenarioProgress: import_zod27.z.array(
+    import_zod27.z.object({
+      scenarioId: import_zod27.z.string(),
+      currentStep: import_zod27.z.string(),
+      error: import_zod27.z.string().optional()
     })
   ),
-  createdAt: import_zod26.z.number()
+  createdAt: import_zod27.z.number()
 });
-var EvaluationLogSchema = import_zod26.z.object({
-  runId: import_zod26.z.string(),
-  scenarioId: import_zod26.z.string(),
-  log: import_zod26.z.object({
-    level: import_zod26.z.enum(["info", "error", "debug"]),
-    message: import_zod26.z.string().optional(),
-    args: import_zod26.z.array(import_zod26.z.any()).optional(),
-    error: import_zod26.z.string().optional()
+var EvaluationLogSchema = import_zod27.z.object({
+  runId: import_zod27.z.string(),
+  scenarioId: import_zod27.z.string(),
+  log: import_zod27.z.object({
+    level: import_zod27.z.enum(["info", "error", "debug"]),
+    message: import_zod27.z.string().optional(),
+    args: import_zod27.z.array(import_zod27.z.any()).optional(),
+    error: import_zod27.z.string().optional()
   })
 });
 var LLM_TIMEOUT = 12e4;
@@ -1176,95 +1183,95 @@ var AssertionResultStatus = /* @__PURE__ */ ((AssertionResultStatus2) => {
   AssertionResultStatus2["ERROR"] = "error";
   return AssertionResultStatus2;
 })(AssertionResultStatus || {});
-var AssertionResultSchema = import_zod27.z.object({
-  id: import_zod27.z.string(),
-  assertionId: import_zod27.z.string(),
-  assertionType: import_zod27.z.string(),
-  assertionName: import_zod27.z.string(),
-  status: import_zod27.z.enum(AssertionResultStatus),
-  message: import_zod27.z.string().optional(),
-  expected: import_zod27.z.string().optional(),
-  actual: import_zod27.z.string().optional(),
-  duration: import_zod27.z.number().optional(),
-  details: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.unknown()).optional(),
-  llmTraceSteps: import_zod27.z.array(LLMTraceStepSchema).optional()
-});
-var EvalRunResultSchema = import_zod27.z.object({
-  id: import_zod27.z.string(),
-  targetId: import_zod27.z.string(),
-  targetName: import_zod27.z.string().optional(),
+var AssertionResultSchema = import_zod28.z.object({
+  id: import_zod28.z.string(),
+  assertionId: import_zod28.z.string(),
+  assertionType: import_zod28.z.string(),
+  assertionName: import_zod28.z.string(),
+  status: import_zod28.z.enum(AssertionResultStatus),
+  message: import_zod28.z.string().optional(),
+  expected: import_zod28.z.string().optional(),
+  actual: import_zod28.z.string().optional(),
+  duration: import_zod28.z.number().optional(),
+  details: import_zod28.z.record(import_zod28.z.string(), import_zod28.z.unknown()).optional(),
+  llmTraceSteps: import_zod28.z.array(LLMTraceStepSchema).optional()
+});
+var EvalRunResultSchema = import_zod28.z.object({
+  id: import_zod28.z.string(),
+  targetId: import_zod28.z.string(),
+  targetName: import_zod28.z.string().optional(),
   /** SkillVersion ID used for this evaluation (for version tracking) */
-  skillVersionId: import_zod27.z.string().optional(),
+  skillVersionId: import_zod28.z.string().optional(),
   /** SkillVersion semver string (e.g., "1.0.0", "1.2.3") for display */
-  skillVersion: import_zod27.z.string().optional(),
-  scenarioId: import_zod27.z.string(),
-  scenarioName: import_zod27.z.string(),
+  skillVersion: import_zod28.z.string().optional(),
+  scenarioId: import_zod28.z.string(),
+  scenarioName: import_zod28.z.string(),
   modelConfig: ModelConfigSchema.optional(),
-  assertionResults: import_zod27.z.array(AssertionResultSchema),
+  assertionResults: import_zod28.z.array(AssertionResultSchema),
   metrics: EvalMetricsSchema.optional(),
-  passed: import_zod27.z.number(),
-  failed: import_zod27.z.number(),
-  passRate: import_zod27.z.number(),
-  duration: import_zod27.z.number(),
-  outputText: import_zod27.z.string().optional(),
-  files: import_zod27.z.array(ExpectedFileSchema).optional(),
-  fileDiffs: import_zod27.z.array(DiffContentSchema).optional(),
+  passed: import_zod28.z.number(),
+  failed: import_zod28.z.number(),
+  passRate: import_zod28.z.number(),
+  duration: import_zod28.z.number(),
+  outputText: import_zod28.z.string().optional(),
+  files: import_zod28.z.array(ExpectedFileSchema).optional(),
+  fileDiffs: import_zod28.z.array(DiffContentSchema).optional(),
   /** Full template files after execution with status indicators */
-  templateFiles: import_zod27.z.array(TemplateFileSchema).optional(),
-  startedAt: import_zod27.z.string().optional(),
-  completedAt: import_zod27.z.string().optional(),
+  templateFiles: import_zod28.z.array(TemplateFileSchema).optional(),
+  startedAt: import_zod28.z.string().optional(),
+  completedAt: import_zod28.z.string().optional(),
   llmTrace: LLMTraceSchema.optional()
 });
-var PromptResultSchema = import_zod27.z.object({
-  text: import_zod27.z.string(),
-  files: import_zod27.z.array(import_zod27.z.unknown()).optional(),
-  finishReason: import_zod27.z.string().optional(),
-  reasoning: import_zod27.z.string().optional(),
-  reasoningDetails: import_zod27.z.unknown().optional(),
-  toolCalls: import_zod27.z.array(import_zod27.z.unknown()).optional(),
-  toolResults: import_zod27.z.array(import_zod27.z.unknown()).optional(),
-  warnings: import_zod27.z.array(import_zod27.z.unknown()).optional(),
-  sources: import_zod27.z.array(import_zod27.z.unknown()).optional(),
-  steps: import_zod27.z.array(import_zod27.z.unknown()),
-  generationTimeMs: import_zod27.z.number(),
-  prompt: import_zod27.z.string(),
-  systemPrompt: import_zod27.z.string(),
-  usage: import_zod27.z.object({
-    totalTokens: import_zod27.z.number().optional(),
-    totalMicrocentsSpent: import_zod27.z.number().optional()
+var PromptResultSchema = import_zod28.z.object({
+  text: import_zod28.z.string(),
+  files: import_zod28.z.array(import_zod28.z.unknown()).optional(),
+  finishReason: import_zod28.z.string().optional(),
+  reasoning: import_zod28.z.string().optional(),
+  reasoningDetails: import_zod28.z.unknown().optional(),
+  toolCalls: import_zod28.z.array(import_zod28.z.unknown()).optional(),
+  toolResults: import_zod28.z.array(import_zod28.z.unknown()).optional(),
+  warnings: import_zod28.z.array(import_zod28.z.unknown()).optional(),
+  sources: import_zod28.z.array(import_zod28.z.unknown()).optional(),
+  steps: import_zod28.z.array(import_zod28.z.unknown()),
+  generationTimeMs: import_zod28.z.number(),
+  prompt: import_zod28.z.string(),
+  systemPrompt: import_zod28.z.string(),
+  usage: import_zod28.z.object({
+    totalTokens: import_zod28.z.number().optional(),
+    totalMicrocentsSpent: import_zod28.z.number().optional()
   })
 });
-var EvaluationResultSchema = import_zod27.z.object({
-  id: import_zod27.z.string(),
-  runId: import_zod27.z.string(),
-  timestamp: import_zod27.z.number(),
+var EvaluationResultSchema = import_zod28.z.object({
+  id: import_zod28.z.string(),
+  runId: import_zod28.z.string(),
+  timestamp: import_zod28.z.number(),
   promptResult: PromptResultSchema,
-  testResults: import_zod27.z.array(import_zod27.z.unknown()),
-  tags: import_zod27.z.array(import_zod27.z.string()).optional(),
-  feedback: import_zod27.z.string().optional(),
-  score: import_zod27.z.number(),
-  suiteId: import_zod27.z.string().optional()
-});
-var LeanEvaluationResultSchema = import_zod27.z.object({
-  id: import_zod27.z.string(),
-  runId: import_zod27.z.string(),
-  timestamp: import_zod27.z.number(),
-  tags: import_zod27.z.array(import_zod27.z.string()).optional(),
-  scenarioId: import_zod27.z.string(),
-  scenarioVersion: import_zod27.z.number().optional(),
-  targetId: import_zod27.z.string(),
-  targetVersion: import_zod27.z.number().optional(),
-  suiteId: import_zod27.z.string().optional(),
-  score: import_zod27.z.number(),
-  time: import_zod27.z.number().optional(),
-  microcentsSpent: import_zod27.z.number().optional()
+  testResults: import_zod28.z.array(import_zod28.z.unknown()),
+  tags: import_zod28.z.array(import_zod28.z.string()).optional(),
+  feedback: import_zod28.z.string().optional(),
+  score: import_zod28.z.number(),
+  suiteId: import_zod28.z.string().optional()
+});
+var LeanEvaluationResultSchema = import_zod28.z.object({
+  id: import_zod28.z.string(),
+  runId: import_zod28.z.string(),
+  timestamp: import_zod28.z.number(),
+  tags: import_zod28.z.array(import_zod28.z.string()).optional(),
+  scenarioId: import_zod28.z.string(),
+  scenarioVersion: import_zod28.z.number().optional(),
+  targetId: import_zod28.z.string(),
+  targetVersion: import_zod28.z.number().optional(),
+  suiteId: import_zod28.z.string().optional(),
+  score: import_zod28.z.number(),
+  time: import_zod28.z.number().optional(),
+  microcentsSpent: import_zod28.z.number().optional()
 });
 
 // src/project/project.ts
-var import_zod28 = require("zod");
+var import_zod29 = require("zod");
 var ProjectSchema = BaseEntitySchema.extend({
-  appId: import_zod28.z.string().optional().describe("The ID of the app in Dev Center"),
-  appSecret: import_zod28.z.string().optional().describe("The secret of the app in Dev Center")
+  appId: import_zod29.z.string().optional().describe("The ID of the app in Dev Center"),
+  appSecret: import_zod29.z.string().optional().describe("The secret of the app in Dev Center")
 });
 var CreateProjectInputSchema = ProjectSchema.omit({
   id: true,
@@ -1275,10 +1282,9 @@ var CreateProjectInputSchema = ProjectSchema.omit({
 var UpdateProjectInputSchema = CreateProjectInputSchema.partial();
 
 // src/template/template.ts
-var import_zod29 = require("zod");
 var TemplateSchema = TenantEntitySchema.extend({
-  /** URL to download the template from */
-  downloadUrl: import_zod29.z.url()
+  /** GitHub source reference for fetching template files */
+  source: GitHubSourceSchema.optional()
 });
 var CreateTemplateInputSchema = TemplateSchema.omit({
   id: true,