@wix/evalforge-evaluator 0.98.0 → 0.100.0

package/build/index.js

@@ -207,6 +207,53 @@ function createApiClient(serverUrl, options = "") {
 
 // src/fetch-evaluation-data.ts
 var import_evalforge_types = require("@wix/evalforge-types");
+
+// src/resolve-placeholders.ts
+var PLACEHOLDER_PATTERN = /\{\{([^}]+)\}\}/g;
+function findPlaceholders(value) {
+  const keys = /* @__PURE__ */ new Set();
+  collectPlaceholders(value, keys);
+  return [...keys];
+}
+function collectPlaceholders(value, keys) {
+  if (typeof value === "string") {
+    for (const match of value.matchAll(PLACEHOLDER_PATTERN)) {
+      keys.add(match[1].trim());
+    }
+  } else if (Array.isArray(value)) {
+    for (const item of value) {
+      collectPlaceholders(item, keys);
+    }
+  } else if (typeof value === "object" && value !== null) {
+    for (const val of Object.values(value)) {
+      collectPlaceholders(val, keys);
+    }
+  }
+}
+function resolveValue(value, placeholders) {
+  if (typeof value === "string") {
+    return value.replace(PLACEHOLDER_PATTERN, (match, key) => {
+      const trimmed = key.trim();
+      return trimmed in placeholders ? placeholders[trimmed] : match;
+    });
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveValue(item, placeholders));
+  }
+  if (typeof value === "object" && value !== null) {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = resolveValue(v, placeholders);
+    }
+    return result;
+  }
+  return value;
+}
+function resolvePlaceholdersInString(text, placeholders) {
+  return resolveValue(text, placeholders);
+}
+
+// src/fetch-evaluation-data.ts
 function parseSkillNamesFromParams(value) {
   if (typeof value !== "string") {
     return [];
@@ -222,13 +269,11 @@ function applyParamsToAssertion(assertion, params) {
     return assertion;
   }
   if (assertion.type === "llm_judge") {
-    let prompt = assertion.prompt;
+    const stringParams = {};
     for (const [key, value] of Object.entries(params)) {
-      const placeholder = `{{${key}}}`;
-      const escapedPlaceholder = placeholder.replace(/[{}]/g, "\\$&");
-      const replacement = String(value ?? "");
-      prompt = prompt.replace(new RegExp(escapedPlaceholder, "g"), replacement);
+      stringParams[key] = String(value ?? "");
     }
+    const prompt = resolvePlaceholdersInString(assertion.prompt, stringParams);
     return {
       ...assertion,
       prompt,
@@ -337,9 +382,9 @@ async function fetchEvaluationData(api, projectId2, evalRunId2) {
   const scenarios = await Promise.all(
     evalRun.scenarioIds.map((id) => api.getScenario(projectId2, id))
   );
-  let codeAgent = null;
+  let agent = null;
   if (evalRun.agentId) {
-    codeAgent = await api.getAgent(projectId2, evalRun.agentId);
+    agent = await api.getAgent(projectId2, evalRun.agentId);
   }
   let skills = [];
   let skillsGroup = null;
@@ -440,7 +485,7 @@ async function fetchEvaluationData(api, projectId2, evalRunId2) {
   const skillsGroupName = skillsGroup?.name ?? "";
   return {
     evalRun,
-    codeAgent,
+    agent,
     skills,
     skillsGroup,
     skillsGroupName,
@@ -459,56 +504,18 @@ var import_eval_assertions = require("@wix/eval-assertions");
 var import_fs = require("fs");
 var import_os = require("os");
 var import_path2 = __toESM(require("path"));
-var import_evalforge_github_client2 = require("@wix/evalforge-github-client");
+var import_evalforge_github_client = require("@wix/evalforge-github-client");
 
-// src/run-scenario/agents/claude-code/write-skills.ts
+// src/run-scenario/utils/write-files.ts
 var import_promises = require("fs/promises");
 var import_path = require("path");
-var import_evalforge_github_client = require("@wix/evalforge-github-client");
-async function writeSkillsToFilesystem(cwd, skills, fetchFn = import_evalforge_github_client.fetchGitHubFolder) {
-  await Promise.all(
-    skills.map((skill) => writeSkillToFilesystem(cwd, skill, fetchFn))
-  );
-}
-async function writeSkillToFilesystem(cwd, skill, fetchFn = import_evalforge_github_client.fetchGitHubFolder) {
-  const skillName = skill.name;
-  const skillDir = (0, import_path.join)(cwd, ".claude", "skills", skillName);
-  await (0, import_promises.mkdir)(skillDir, { recursive: true });
-  const version = skill.latestVersion;
-  if (version?.files && version.files.length > 0) {
-    await writeSkillFiles(skillDir, version.files);
-    console.log(
-      `[Skill] ${skillName}: wrote ${version.files.length} file(s) from snapshot`
-    );
-  } else if (skill.source) {
-    try {
-      const files = await fetchFn(skill.source, {
-        userAgent: "EvalForge-Evaluator"
-      });
-      await writeSkillFiles(skillDir, files);
-      console.log(
-        `[Skill] ${skillName}: wrote ${files.length} file(s) from GitHub (live)`
-      );
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      console.error(
-        `[Skill] ${skillName}: GitHub fetch failed: ${message}, no files to fall back to`
-      );
-      throw new Error(
-        `Failed to write skill ${skillName} to filesystem: ${message}`
-      );
-    }
-  } else {
-    throw new Error(`Skill ${skillName} has no files and no source configured`);
-  }
-}
-async function writeSkillFiles(skillDir, files) {
-  const resolvedBase = (0, import_path.resolve)(skillDir);
+async function writeFilesToDirectory(targetDir, files) {
+  const resolvedBase = (0, import_path.resolve)(targetDir);
   for (const file of files) {
-    const filePath = (0, import_path.resolve)(skillDir, file.path);
+    const filePath = (0, import_path.resolve)(targetDir, file.path);
     if (!filePath.startsWith(resolvedBase + import_path.sep) && filePath !== resolvedBase) {
       throw new Error(
-        `Path traversal detected in skill file: "${file.path}" resolves outside skill directory`
+        `Path traversal detected: "${file.path}" resolves outside target directory`
       );
     }
     await (0, import_promises.mkdir)((0, import_path.dirname)(filePath), { recursive: true });
@@ -524,10 +531,10 @@ async function fetchAndWriteTemplateFiles(template, workDir) {
     );
     return;
   }
-  const files = await (0, import_evalforge_github_client2.fetchGitHubFolder)(template.source, {
+  const files = await (0, import_evalforge_github_client.fetchGitHubFolder)(template.source, {
     userAgent: "EvalForge-Evaluator"
   });
-  await writeSkillFiles(workDir, files);
+  await writeFilesToDirectory(workDir, files);
 }
 function writeWixEnvFile(workDir) {
   const configPath = import_path2.default.join(workDir, "wix.config.json");
@@ -581,86 +588,76 @@ var import_crypto2 = require("crypto");
 
 // src/run-scenario/agents/registry.ts
 var AgentAdapterRegistry = class {
-  /**
-   * Map of run commands to their registered adapters.
-   * Multiple commands can map to the same adapter.
-   */
-  adapters = /* @__PURE__ */ new Map();
-  /**
-   * Set of all registered adapter instances (for getAll).
-   */
+  /** Map of CLI commands to their registered adapters. */
+  commandMap = /* @__PURE__ */ new Map();
+  /** Map of adapter IDs to their registered adapters. */
+  idMap = /* @__PURE__ */ new Map();
+  /** Set of all registered adapter instances (for getAll). */
   registeredAdapters = /* @__PURE__ */ new Set();
   /**
    * Register an agent adapter.
    *
-   * The adapter will be registered for all commands in its supportedCommands array.
-   * If a command is already registered, it will be overwritten with a warning.
-   *
-   * @param adapter - The adapter to register
+   * The adapter is registered by its ID and for all commands in its supportedCommands array.
+   * If a command or ID is already registered, it will be overwritten with a warning.
    */
   register(adapter) {
     this.registeredAdapters.add(adapter);
+    this.idMap.set(adapter.id, adapter);
     for (const command of adapter.supportedCommands) {
-      if (this.adapters.has(command)) {
-        const existing = this.adapters.get(command);
+      if (this.commandMap.has(command)) {
+        const existing = this.commandMap.get(command);
         console.warn(
           `[AgentAdapterRegistry] Command "${command}" already registered by adapter "${existing.id}". Overwriting with adapter "${adapter.id}".`
         );
       }
-      this.adapters.set(command, adapter);
+      this.commandMap.set(command, adapter);
     }
   }
-  /**
-   * Get an adapter by run command.
-   *
-   * @param runCommand - The run command to look up
-   * @returns The registered adapter, or undefined if not found
-   */
-  get(runCommand) {
-    return this.adapters.get(runCommand);
+  /** Get an adapter by CLI command. */
+  getByCommand(command) {
+    return this.commandMap.get(command);
   }
-  /**
-   * Check if a command has a registered adapter.
-   *
-   * @param runCommand - The run command to check
-   * @returns True if an adapter is registered for this command
-   */
-  has(runCommand) {
-    return this.adapters.has(runCommand);
+  /** Get an adapter by adapter ID. */
+  getById(adapterId) {
+    return this.idMap.get(adapterId);
   }
   /**
-   * Get all registered adapters.
-   *
-   * @returns Array of all unique registered adapters
+   * Unified lookup: tries CLI command first, then adapter ID.
+   * Use this when the identifier could be either a command or an adapter ID.
    */
+  resolve(identifier) {
+    return this.commandMap.get(identifier) ?? this.idMap.get(identifier);
+  }
+  /** Check if a command or adapter ID has a registered adapter. */
+  has(identifier) {
+    return this.commandMap.has(identifier) || this.idMap.has(identifier);
+  }
+  /** Get all registered adapters. */
   getAll() {
     return Array.from(this.registeredAdapters);
   }
-  /**
-   * Get all supported commands.
-   *
-   * @returns Array of all registered run commands
-   */
+  /** Get all supported CLI commands. */
   getSupportedCommands() {
-    return Array.from(this.adapters.keys());
+    return Array.from(this.commandMap.keys());
+  }
+  /** Get all registered adapter IDs. */
+  getAdapterIds() {
+    return Array.from(this.idMap.keys());
   }
   /**
    * Unregister an adapter by its ID.
-   *
    * Removes the adapter and all its command mappings.
-   *
-   * @param adapterId - The ID of the adapter to remove
-   * @returns True if the adapter was found and removed
    */
   unregister(adapterId) {
     let found = false;
     for (const adapter of this.registeredAdapters) {
       if (adapter.id === adapterId) {
         this.registeredAdapters.delete(adapter);
+        this.idMap.delete(adapterId);
         found = true;
         for (const command of adapter.supportedCommands) {
-          if (this.adapters.get(command) === adapter) {
-            this.adapters.delete(command);
+          if (this.commandMap.get(command) === adapter) {
+            this.commandMap.delete(command);
           }
         }
         break;
@@ -668,22 +665,21 @@ var AgentAdapterRegistry = class {
     }
     return found;
   }
-  /**
-   * Clear all registered adapters.
-   * Primarily useful for testing.
-   */
+  /** Clear all registered adapters. Primarily useful for testing. */
   clear() {
-    this.adapters.clear();
+    this.commandMap.clear();
+    this.idMap.clear();
     this.registeredAdapters.clear();
   }
 };
 var defaultRegistry = new AgentAdapterRegistry();
-function getAdapter(runCommand) {
-  const adapter = defaultRegistry.get(runCommand);
+function getAdapter(identifier) {
+  const adapter = defaultRegistry.resolve(identifier);
   if (!adapter) {
-    const supported = defaultRegistry.getSupportedCommands();
+    const commands = defaultRegistry.getSupportedCommands();
+    const ids = defaultRegistry.getAdapterIds();
     throw new Error(
-      `No agent adapter registered for command "${runCommand}". Supported commands: ${supported.length > 0 ? supported.join(", ") : "(none registered)"}`
+      `No agent adapter registered for "${identifier}". Supported commands: ${commands.length > 0 ? commands.join(", ") : "(none)"}. Registered adapters: ${ids.length > 0 ? ids.join(", ") : "(none)"}`
     );
   }
   return adapter;
@@ -694,12 +690,97 @@ var import_evalforge_types4 = require("@wix/evalforge-types");
 
 // src/run-scenario/agents/claude-code/execute.ts
 var import_evalforge_types3 = require("@wix/evalforge-types");
-var import_crypto = require("crypto");
 
-// src/run-scenario/agents/claude-code/write-mcp.ts
+// src/run-scenario/agents/claude-code/write-skills.ts
 var import_promises2 = require("fs/promises");
 var import_path3 = require("path");
+var import_evalforge_github_client2 = require("@wix/evalforge-github-client");
+async function writeSkillsToFilesystem(cwd, skills, fetchFn = import_evalforge_github_client2.fetchGitHubFolder) {
+  await Promise.all(
+    skills.map((skill) => writeSkillToFilesystem(cwd, skill, fetchFn))
+  );
+}
+async function writeSkillToFilesystem(cwd, skill, fetchFn = import_evalforge_github_client2.fetchGitHubFolder) {
+  const skillName = skill.name;
+  const skillDir = (0, import_path3.join)(cwd, ".claude", "skills", skillName);
+  await (0, import_promises2.mkdir)(skillDir, { recursive: true });
+  const version = skill.latestVersion;
+  if (version?.files && version.files.length > 0) {
+    await writeFilesToDirectory(skillDir, version.files);
+    console.log(
+      `[Skill] ${skillName}: wrote ${version.files.length} file(s) from snapshot`
+    );
+  } else if (skill.source) {
+    try {
+      const files = await fetchFn(skill.source, {
+        userAgent: "EvalForge-Evaluator"
+      });
+      await writeFilesToDirectory(skillDir, files);
+      console.log(
+        `[Skill] ${skillName}: wrote ${files.length} file(s) from GitHub (live)`
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(
+        `[Skill] ${skillName}: GitHub fetch failed: ${message}, no files to fall back to`
+      );
+      throw new Error(
+        `Failed to write skill ${skillName} to filesystem: ${message}`
+      );
+    }
+  } else {
+    throw new Error(`Skill ${skillName} has no files and no source configured`);
+  }
+}
+
+// src/run-scenario/agents/claude-code/execute.ts
+var import_crypto = require("crypto");
+
+// src/run-scenario/agents/claude-code/write-mcp.ts
+var import_promises4 = require("fs/promises");
+var import_path5 = require("path");
 var import_evalforge_types2 = require("@wix/evalforge-types");
+
+// src/run-scenario/agents/claude-code/resolve-mcp-placeholders.ts
+var import_promises3 = require("fs/promises");
+var import_path4 = require("path");
+var import_os2 = require("os");
+var WIX_AUTH_FILE = (0, import_path4.join)((0, import_os2.homedir)(), ".wix", "auth", "api-key.json");
+async function loadWixAuthPlaceholders(authFilePath = WIX_AUTH_FILE) {
+  try {
+    const content = await (0, import_promises3.readFile)(authFilePath, "utf-8");
+    const auth = JSON.parse(content);
+    if (!auth.token || !auth.userInfo?.userId) {
+      return {};
+    }
+    return {
+      "wix-auth-token": auth.token,
+      "wix-auth-user-id": auth.userInfo.userId
+    };
+  } catch (err) {
+    console.warn(
+      `[MCP] Could not load Wix auth file: ${err.message}`
+    );
+    return {};
+  }
+}
+async function resolveMcpPlaceholders(mcpServers, authFilePath) {
+  const needed = findPlaceholders(mcpServers);
+  if (needed.length === 0) {
+    return mcpServers;
+  }
+  const placeholders = await loadWixAuthPlaceholders(authFilePath);
+  const unresolved = needed.filter((key) => !(key in placeholders));
+  if (unresolved.length > 0) {
+    throw new Error(
+      `MCP config contains unresolvable placeholders: ${unresolved.map((k) => `{{${k}}}`).join(", ")}. Ensure ~/.wix/auth/api-key.json exists (run \`npx @wix/cli login\`).`
+    );
+  }
+  console.log(`[MCP] Resolved ${needed.length} placeholder(s)`);
+  return resolveValue(mcpServers, placeholders);
+}
+
+// src/run-scenario/agents/claude-code/write-mcp.ts
 async function writeMcpToFilesystem(cwd, mcps) {
   if (mcps.length === 0) return;
   const mcpServers = {};
@@ -714,19 +795,20 @@ async function writeMcpToFilesystem(cwd, mcps) {
       mcpServers[key] = value;
     }
   }
+  const resolvedServers = await resolveMcpPlaceholders(mcpServers);
   const content = JSON.stringify(
-    { [import_evalforge_types2.MCP_SERVERS_JSON_KEY]: mcpServers },
+    { [import_evalforge_types2.MCP_SERVERS_JSON_KEY]: resolvedServers },
     null,
     2
   );
-  const filePath = (0, import_path3.join)(cwd, ".mcp.json");
-  await (0, import_promises2.writeFile)(filePath, content, "utf8");
+  const filePath = (0, import_path5.join)(cwd, ".mcp.json");
+  await (0, import_promises4.writeFile)(filePath, content, "utf8");
   console.log(`[MCP] Written to ${filePath}`);
 }
 
 // src/run-scenario/agents/claude-code/write-sub-agents.ts
-var import_promises3 = require("fs/promises");
-var import_path4 = require("path");
+var import_promises5 = require("fs/promises");
+var import_path6 = require("path");
 var AGENTS_DIR = ".claude/agents";
 function toAgentFilename(name, index, nameCount) {
   const base = (name || "").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/^-+|-+$/g, "") || `sub-agent-${index}`;
@@ -736,20 +818,20 @@ function toAgentFilename(name, index, nameCount) {
 }
 async function writeSubAgentsToFilesystem(cwd, subAgents) {
   if (subAgents.length === 0) return;
-  const agentsDir = (0, import_path4.join)(cwd, AGENTS_DIR);
-  await (0, import_promises3.mkdir)(agentsDir, { recursive: true });
+  const agentsDir = (0, import_path6.join)(cwd, AGENTS_DIR);
+  await (0, import_promises5.mkdir)(agentsDir, { recursive: true });
   const nameCount = /* @__PURE__ */ new Map();
   for (const [i, agent] of subAgents.entries()) {
     const filename = toAgentFilename(agent.name, i, nameCount);
-    const filePath = (0, import_path4.join)(agentsDir, `${filename}.md`);
-    await (0, import_promises3.writeFile)(filePath, agent.subAgentMd, "utf8");
+    const filePath = (0, import_path6.join)(agentsDir, `${filename}.md`);
+    await (0, import_promises5.writeFile)(filePath, agent.subAgentMd, "utf8");
   }
   console.log(`[SubAgents] Written to ${agentsDir}`);
 }
 
 // src/run-scenario/agents/claude-code/write-rules.ts
-var import_promises4 = require("fs/promises");
-var import_path5 = require("path");
+var import_promises6 = require("fs/promises");
+var import_path7 = require("path");
 var CURSOR_RULES_DIR = ".cursor/rules";
 function toRuleFilename(name, index, nameCount) {
   const base = (name || "").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/^-+|-+$/g, "") || `rule-${index}`;
@@ -760,13 +842,13 @@ function toRuleFilename(name, index, nameCount) {
 async function appendToFile(filePath, content) {
   let existing = "";
   try {
-    existing = await (0, import_promises4.readFile)(filePath, "utf8");
+    existing = await (0, import_promises6.readFile)(filePath, "utf8");
   } catch {
   }
   const merged = existing ? `${existing.trimEnd()}
 
 ${content}` : content;
-  await (0, import_promises4.writeFile)(filePath, merged, "utf8");
+  await (0, import_promises6.writeFile)(filePath, merged, "utf8");
 }
 async function writeRulesToFilesystem(cwd, rules) {
   if (rules.length === 0) return;
@@ -775,21 +857,21 @@ async function writeRulesToFilesystem(cwd, rules) {
   for (const [i, rule] of rules.entries()) {
     switch (rule.ruleType) {
       case "claude-md": {
-        await appendToFile((0, import_path5.join)(cwd, "CLAUDE.md"), rule.content);
+        await appendToFile((0, import_path7.join)(cwd, "CLAUDE.md"), rule.content);
         break;
       }
       case "agents-md": {
-        await appendToFile((0, import_path5.join)(cwd, "AGENTS.md"), rule.content);
+        await appendToFile((0, import_path7.join)(cwd, "AGENTS.md"), rule.content);
         break;
       }
       case "cursor-rule": {
         if (!hasCursorRules) {
-          await (0, import_promises4.mkdir)((0, import_path5.join)(cwd, CURSOR_RULES_DIR), { recursive: true });
+          await (0, import_promises6.mkdir)((0, import_path7.join)(cwd, CURSOR_RULES_DIR), { recursive: true });
           hasCursorRules = true;
         }
         const filename = toRuleFilename(rule.name, i, nameCount);
-        const filePath = (0, import_path5.join)(cwd, CURSOR_RULES_DIR, `${filename}.md`);
-        await (0, import_promises4.writeFile)(filePath, rule.content, "utf8");
+        const filePath = (0, import_path7.join)(cwd, CURSOR_RULES_DIR, `${filename}.md`);
+        await (0, import_promises6.writeFile)(filePath, rule.content, "utf8");
         break;
       }
     }
@@ -1824,7 +1906,7 @@ defaultRegistry.register(claudeCodeAdapter);
 
 // src/run-scenario/file-diff.ts
 var import_fs2 = require("fs");
-var import_path6 = require("path");
+var import_path8 = require("path");
 
 // ../../node_modules/diff/lib/index.mjs
 function Diff() {
@@ -2000,7 +2082,7 @@ Diff.prototype = {
   tokenize: function tokenize(value) {
     return Array.from(value);
   },
-  join: function join5(chars) {
+  join: function join6(chars) {
     return chars.join("");
   },
   postProcess: function postProcess(changeObjects) {
@@ -2440,8 +2522,8 @@ function snapshotDirectory(dir, baseDir) {
   }
   const entries = (0, import_fs2.readdirSync)(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = (0, import_path6.join)(dir, entry.name);
-    const relativePath = (0, import_path6.relative)(base, fullPath);
+    const fullPath = (0, import_path8.join)(dir, entry.name);
+    const relativePath = (0, import_path8.relative)(base, fullPath);
     if (shouldIgnore(entry.name)) {
       continue;
     }
@@ -2553,14 +2635,17 @@ var import_evalforge_types5 = require("@wix/evalforge-types");
 var DEFAULT_AGENT_COMMAND = import_evalforge_types5.AgentRunCommand.CLAUDE;
 async function runAgentWithContext(config, evalRunId2, scenario, evalData, workDir) {
   const skillsGroupId = evalData.evalRun.skillsGroupId;
+  const agent = evalData.agent ?? void 0;
+  const isSDK = agent?.agentType === import_evalforge_types5.AgentType.SDK;
   if (!skillsGroupId) {
     throw new Error(`Eval run ${evalData.evalRun.id} has no skillsGroupId`);
   }
-  const agent = evalData.codeAgent ?? void 0;
-  const runCommand = agent?.runCommand ?? DEFAULT_AGENT_COMMAND;
-  const adapter = getAdapter(runCommand);
+  const identifier = isSDK ? agent.id : agent?.runCommand ?? DEFAULT_AGENT_COMMAND;
+  const adapter = getAdapter(identifier);
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const beforeSnapshot = workDir ? snapshotDirectory(workDir) : {};
+  const targetId = skillsGroupId ?? agent?.id ?? evalData.evalRun.id;
+  const targetName = evalData.skillsGroupName || agent?.name || "";
   const executionContext = {
     skills: evalData.skills,
     scenario,
@@ -2572,8 +2657,8 @@ async function runAgentWithContext(config, evalRunId2, scenario, evalData, workD
       evalRunId: evalRunId2,
       scenarioId: scenario.id,
       scenarioName: scenario.name,
-      targetId: skillsGroupId,
-      targetName: evalData.skillsGroupName,
+      targetId,
+      targetName,
       tracePushUrl: config.tracePushUrl,
       routeHeader: config.routeHeader,
       authToken: config.authToken
@@ -2590,8 +2675,8 @@ async function runAgentWithContext(config, evalRunId2, scenario, evalData, workD
   const templateFiles = workDir ? extractTemplateFiles(beforeSnapshot, afterSnapshot) : void 0;
   return {
     id: (0, import_crypto2.randomUUID)(),
-    targetId: skillsGroupId,
-    targetName: evalData.skillsGroupName,
+    targetId,
+    targetName,
     scenarioId: scenario.id,
     scenarioName: scenario.name,
     modelConfig: agent?.modelConfig,
@@ -2607,11 +2692,11 @@ async function runAgentWithContext(config, evalRunId2, scenario, evalData, workD
 
 // src/run-scenario/index.ts
 async function runScenario(config, evalRunId2, scenario, evalData, template, resolvedAssertions) {
-  const skillsGroupId = evalData.evalRun.skillsGroupId;
+  const targetId = evalData.evalRun.skillsGroupId ?? evalData.agent?.id ?? evalData.evalRun.id;
   const workDir = await prepareWorkingDirectory(
     config,
     evalRunId2,
-    skillsGroupId,
+    targetId,
     scenario.id,
     template
   );
@@ -2639,7 +2724,8 @@ async function runScenario(config, evalRunId2, scenario, evalData, template, res
     })),
     durationMs: partialResult.duration
   };
-  const { "x-wix-ai-gateway-stream": _stream, ...judgeHeaders } = config.aiGatewayHeaders;
+  const { "x-wix-ai-gateway-stream": _ignored, ...judgeHeaders } = config.aiGatewayHeaders;
+  void _ignored;
   const defaultJudgeModel = import_evalforge_types6.DEFAULT_JUDGE_MODEL;
   const assertionContext = {
     workDir,
@@ -2816,7 +2902,7 @@ async function runEvaluation(projectId2, evalRunId2) {
         scenarioItemCount: evalData.scenarioItems.length,
         scenarios: evalData.scenarioItems.map((s) => s.scenario.name),
         skillsCount: evalData.skills.length,
-        hasCodeAgent: !!evalData.codeAgent,
+        hasAgent: !!evalData.agent,
         timestamp: Date.now()
       })
     );
@@ -2834,14 +2920,14 @@ async function runEvaluation(projectId2, evalRunId2) {
       `[${ExecutionPhase.FETCH_EVAL_RUN}] Failed to fetch evaluation data: ${errorMsg}`
     );
   }
-  const { codeAgent, skills, scenarioItems } = evalData;
+  const { agent, skills, scenarioItems } = evalData;
   state.currentPhase = ExecutionPhase.VALIDATION;
   state.currentContext = {
     projectId: projectId2,
     evalRunId: evalRunId2,
     scenarioCount: scenarioItems.length,
     skillCount: skills.length,
-    hasAgent: !!codeAgent,
+    hasAgent: !!agent,
     agentId: evalData.evalRun.agentId,
     skillsGroupId: evalData.evalRun.skillsGroupId
   };
@@ -2850,9 +2936,9 @@ async function runEvaluation(projectId2, evalRunId2) {
       `[${ExecutionPhase.VALIDATION}] Eval run has no skills: set skillsGroupId and ensure the group has skills. (skillsGroupId: ${evalData.evalRun.skillsGroupId || "not set"})`
     );
   }
-  if (scenarioItems.length > 0 && skills.length > 0 && !codeAgent) {
+  if (scenarioItems.length > 0 && skills.length > 0 && !agent) {
     throw new Error(
-      `[${ExecutionPhase.VALIDATION}] Eval run has no code agent: set agentId for skill-based runs. (agentId: ${evalData.evalRun.agentId || "not set"})`
+      `[${ExecutionPhase.VALIDATION}] Eval run has no agent: set agentId for skill-based runs. (agentId: ${evalData.evalRun.agentId || "not set"})`
     );
   }
   let completedScenarios = 0;
@@ -2866,8 +2952,8 @@ async function runEvaluation(projectId2, evalRunId2) {
       scenarioName: scenario.name,
       skillsGroupId: evalData.evalRun.skillsGroupId,
       skillsGroupName: evalData.skillsGroupName,
-      agentId: codeAgent?.id,
-      agentName: codeAgent?.name,
+      agentId: agent?.id,
+      agentName: agent?.name,
       progress: `${completedScenarios + 1}/${totalScenarios}`
     };
     const skillNames = evalData.skills.map((s) => s.name).join(", ");
@@ -2875,7 +2961,7 @@ async function runEvaluation(projectId2, evalRunId2) {
       "[Evaluator] Running scenario with skills group:",
       evalData.skillsGroupName,
       skillNames ? `(${skillNames})` : "",
-      codeAgent ? `with agent: ${codeAgent.name}` : "",
+      agent ? `with agent: ${agent.name}` : "",
       `(${completedScenarios + 1}/${totalScenarios})`
     );
     try {