@wix/evalforge-evaluator 0.9.0 → 0.10.0

package/build/index.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_evalforge_types3 = require("@wix/evalforge-types");
+var import_evalforge_types4 = require("@wix/evalforge-types");
 
 // src/config.ts
 function loadConfig() {
@@ -6620,6 +6620,67 @@ async function runScenario(config, evalRunId2, scenario, target, template) {
   };
 }
 
+// src/error-reporter.ts
+var import_evalforge_types3 = require("@wix/evalforge-types");
+function formatError(error, phase, context) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      stack: error.stack,
+      errorType: error.constructor.name,
+      phase,
+      context,
+      timestamp
+    };
+  }
+  return {
+    message: String(error),
+    errorType: typeof error,
+    phase,
+    context,
+    timestamp
+  };
+}
+function formatErrorForJobError(details) {
+  const parts = [];
+  if (details.phase) {
+    parts.push(`[Phase: ${details.phase}]`);
+  }
+  if (details.errorType && details.errorType !== "Error") {
+    parts.push(`${details.errorType}: ${details.message}`);
+  } else {
+    parts.push(details.message);
+  }
+  if (details.context && Object.keys(details.context).length > 0) {
+    parts.push(`
+Context: ${JSON.stringify(details.context)}`);
+  }
+  if (details.stack) {
+    const stackLines = details.stack.split("\n").slice(0, 6);
+    parts.push(`
+Stack:
+${stackLines.join("\n")}`);
+  }
+  return parts.join(" ");
+}
+var ExecutionPhase = {
+  CONFIG: "config-loading",
+  API_CLIENT: "api-client-creation",
+  FETCH_EVAL_RUN: "fetch-eval-run",
+  FETCH_SKILLS: "fetch-skills",
+  FETCH_AGENT: "fetch-agent",
+  FETCH_SCENARIOS: "fetch-scenarios",
+  VALIDATION: "validation",
+  PREPARE_WORKSPACE: "prepare-workspace",
+  EXECUTE_SKILL: "execute-skill",
+  EXECUTE_AGENT: "execute-agent",
+  CLAUDE_SDK_IMPORT: "claude-sdk-import",
+  CLAUDE_SDK_EXECUTION: "claude-sdk-execution",
+  ADD_RESULT: "add-result",
+  UPDATE_STATUS: "update-status"
+};
+
 // src/index.ts
 console.error(
   "[EVALUATOR-BOOT] Module loading started",
@@ -6627,13 +6688,22 @@ console.error(
 );
 console.error("[EVALUATOR-BOOT] All static imports successful");
 async function runEvaluation(projectId2, evalRunId2) {
+  const state = {
+    config: null,
+    api: null,
+    currentPhase: ExecutionPhase.CONFIG,
+    currentContext: { projectId: projectId2, evalRunId: evalRunId2 }
+  };
   console.error(
     "[DEBUG-H1] runEvaluation entry",
     JSON.stringify({ projectId: projectId2, evalRunId: evalRunId2, timestamp: Date.now() })
   );
+  state.currentPhase = ExecutionPhase.CONFIG;
+  state.currentContext = { projectId: projectId2, evalRunId: evalRunId2 };
   let config;
   try {
     config = loadConfig();
+    state.config = config;
     console.error(
       "[DEBUG-H1] loadConfig SUCCESS",
       JSON.stringify({
@@ -6649,10 +6719,13 @@ async function runEvaluation(projectId2, evalRunId2) {
       "[DEBUG-H1] loadConfig FAILED",
       JSON.stringify({
         error: configErr instanceof Error ? configErr.message : String(configErr),
+        stack: configErr instanceof Error ? configErr.stack : void 0,
         timestamp: Date.now()
       })
     );
-    throw configErr;
+    throw new Error(
+      `[${ExecutionPhase.CONFIG}] ${configErr instanceof Error ? configErr.message : String(configErr)}`
+    );
   }
   console.log("[Evaluator] Config loaded", {
     serverUrl: config.serverUrl,
@@ -6661,11 +6734,22 @@ async function runEvaluation(projectId2, evalRunId2) {
     hasAiGatewayHeaders: Object.keys(config.aiGatewayHeaders).length > 0,
     hasRouteHeader: !!config.routeHeader
   });
-  const api = createApiClient(config.serverUrl, {
-    apiPrefix: config.apiPrefix,
-    routeHeader: config.routeHeader,
-    authToken: config.authToken
-  });
+  state.currentPhase = ExecutionPhase.API_CLIENT;
+  let api;
+  try {
+    api = createApiClient(config.serverUrl, {
+      apiPrefix: config.apiPrefix,
+      routeHeader: config.routeHeader,
+      authToken: config.authToken
+    });
+    state.api = api;
+  } catch (apiErr) {
+    throw new Error(
+      `[${ExecutionPhase.API_CLIENT}] Failed to create API client: ${apiErr instanceof Error ? apiErr.message : String(apiErr)}`
+    );
+  }
+  state.currentPhase = ExecutionPhase.FETCH_EVAL_RUN;
+  state.currentContext = { projectId: projectId2, evalRunId: evalRunId2, serverUrl: config.serverUrl };
   console.error(
     "[DEBUG-H2] fetchEvaluationData START",
     JSON.stringify({ serverUrl: config.serverUrl, timestamp: Date.now() })
@@ -6684,32 +6768,61 @@ async function runEvaluation(projectId2, evalRunId2) {
       })
     );
   } catch (fetchErr) {
+    const errorMsg = fetchErr instanceof Error ? fetchErr.message : String(fetchErr);
     console.error(
       "[DEBUG-H2] fetchEvaluationData FAILED",
       JSON.stringify({
-        error: fetchErr instanceof Error ? fetchErr.message : String(fetchErr),
+        error: errorMsg,
+        stack: fetchErr instanceof Error ? fetchErr.stack : void 0,
         timestamp: Date.now()
       })
     );
-    throw fetchErr;
+    throw new Error(
+      `[${ExecutionPhase.FETCH_EVAL_RUN}] Failed to fetch evaluation data: ${errorMsg}`
+    );
   }
   const { codeAgent, skills, scenarioItems } = evalData;
+  state.currentPhase = ExecutionPhase.VALIDATION;
+  state.currentContext = {
+    projectId: projectId2,
+    evalRunId: evalRunId2,
+    scenarioCount: scenarioItems.length,
+    skillCount: skills.length,
+    hasAgent: !!codeAgent,
+    agentId: evalData.evalRun.agentId,
+    skillsGroupId: evalData.evalRun.skillsGroupId
+  };
   if (scenarioItems.length > 0 && skills.length === 0) {
     throw new Error(
-      "Eval run has no skills: set skillsGroupId and ensure the group has skills"
+      `[${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) {
     throw new Error(
-      "Eval run has no code agent: set agentId for skill-based runs"
+      `[${ExecutionPhase.VALIDATION}] Eval run has no code agent: set agentId for skill-based runs. (agentId: ${evalData.evalRun.agentId || "not set"})`
     );
   }
+  let completedScenarios = 0;
+  const totalScenarios = scenarioItems.length * skills.length;
   for (const { scenario, template } of scenarioItems) {
     for (const skill of skills) {
+      state.currentPhase = ExecutionPhase.EXECUTE_SKILL;
+      state.currentContext = {
+        projectId: projectId2,
+        evalRunId: evalRunId2,
+        scenarioId: scenario.id,
+        scenarioName: scenario.name,
+        skillId: skill.id,
+        skillName: skill.name,
+        agentId: codeAgent?.id,
+        agentName: codeAgent?.name,
+        progress: `${completedScenarios + 1}/${totalScenarios}`
+      };
       console.log(
         "[Evaluator] Running skill:",
         skill.name,
-        codeAgent ? `with agent: ${codeAgent.name}` : ""
+        codeAgent ? `with agent: ${codeAgent.name}` : "",
+        `(${completedScenarios + 1}/${totalScenarios})`
       );
       try {
         const result = await runScenario(
@@ -6720,17 +6833,48 @@ async function runEvaluation(projectId2, evalRunId2) {
           template
         );
         console.log("[Evaluator] Skill completed, adding result");
+        state.currentPhase = ExecutionPhase.ADD_RESULT;
+        state.currentContext = {
+          ...state.currentContext,
+          resultId: result.id
+        };
         await api.addResult(projectId2, evalRunId2, result);
+        completedScenarios++;
       } catch (err) {
-        console.error("[Evaluator] Failed to run skill:", skill.name, err);
-        throw err;
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        const errorStack = err instanceof Error ? err.stack : void 0;
+        console.error(
+          "[Evaluator] Failed to run skill:",
+          skill.name,
+          "Error:",
+          errorMsg
+        );
+        if (errorStack) {
+          console.error("[Evaluator] Stack trace:", errorStack);
+        }
+        throw new Error(
+          `[${state.currentPhase}] Failed to execute skill "${skill.name}" on scenario "${scenario.name}": ${errorMsg}`
+        );
       }
     }
   }
-  await api.updateEvalRun(projectId2, evalRunId2, {
-    status: import_evalforge_types3.EvalStatus.COMPLETED,
-    completedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
+  state.currentPhase = ExecutionPhase.UPDATE_STATUS;
+  state.currentContext = {
+    projectId: projectId2,
+    evalRunId: evalRunId2,
+    completedScenarios,
+    totalScenarios
+  };
+  try {
+    await api.updateEvalRun(projectId2, evalRunId2, {
+      status: import_evalforge_types4.EvalStatus.COMPLETED,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch (updateErr) {
+    throw new Error(
+      `[${ExecutionPhase.UPDATE_STATUS}] Failed to update eval run status to COMPLETED: ${updateErr instanceof Error ? updateErr.message : String(updateErr)}`
+    );
+  }
 }
 var projectId = process.argv[2];
 var evalRunId = process.argv[3];
@@ -6746,7 +6890,16 @@ runEvaluation(projectId, evalRunId).then(() => {
   console.error("[EVALUATOR-BOOT] runEvaluation completed successfully");
   process.exit(0);
 }).catch(async (err) => {
-  console.error("[EVALUATOR-BOOT] runEvaluation FAILED:", err);
+  const errorDetails = formatError(err, "main-execution", {
+    projectId,
+    evalRunId
+  });
+  const jobError = formatErrorForJobError(errorDetails);
+  console.error("[EVALUATOR-BOOT] runEvaluation FAILED");
+  console.error(
+    "[EVALUATOR-BOOT] Error details:",
+    JSON.stringify(errorDetails, null, 2)
+  );
   try {
     const config = loadConfig();
     const api = createApiClient(config.serverUrl, {
@@ -6755,15 +6908,42 @@ runEvaluation(projectId, evalRunId).then(() => {
       authToken: config.authToken
     });
     await api.updateEvalRun(projectId, evalRunId, {
-      status: import_evalforge_types3.EvalStatus.FAILED,
-      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      status: import_evalforge_types4.EvalStatus.FAILED,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      jobError,
+      jobStatus: "FAILED"
     });
-    console.error("[EVALUATOR-BOOT] Updated eval run status to FAILED");
+    console.error(
+      "[EVALUATOR-BOOT] Updated eval run status to FAILED with error details"
+    );
   } catch (updateErr) {
     console.error(
       "[EVALUATOR-BOOT] Failed to update eval run status:",
-      updateErr
+      updateErr instanceof Error ? updateErr.message : String(updateErr)
     );
+    try {
+      const serverUrl = process.env.EVAL_SERVER_URL;
+      const authToken = process.env.EVAL_AUTH_TOKEN;
+      const routeHeader = process.env.EVAL_ROUTE_HEADER;
+      if (serverUrl) {
+        const api = createApiClient(serverUrl, {
+          routeHeader,
+          authToken
+        });
+        await api.updateEvalRun(projectId, evalRunId, {
+          status: import_evalforge_types4.EvalStatus.FAILED,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          jobError: `Config load failed, then: ${jobError}`,
+          jobStatus: "FAILED"
+        });
+        console.error("[EVALUATOR-BOOT] Fallback: Updated status to FAILED");
+      }
+    } catch (fallbackErr) {
+      console.error(
+        "[EVALUATOR-BOOT] Fallback also failed:",
+        fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)
+      );
+    }
   }
   process.exit(1);
 });