@axiom-lattice/gateway 2.1.73 → 2.1.74

package/dist/index.js

@@ -1772,6 +1772,7 @@ async function getDefinitionsFromAssistants(tenantId) {
           results.push({
             assistantId: a.id,
             assistantName: a.name,
+            description: a.description,
             topologyEdges: mw.config.edges,
             totalEdges: mw.config.edges.length
           });
@@ -4606,12 +4607,590 @@ function registerMcpServerConfigRoutes(app2) {
   app2.post("/api/mcp-servers/test-tools", testMcpServerTools);
 }
 
-// src/controllers/users.ts
+// src/controllers/eval.ts
+var import_core24 = require("@axiom-lattice/core");
+var import_uuid4 = require("uuid");
+
+// src/services/eval-runner.ts
+var import_events = require("events");
 var import_core23 = require("@axiom-lattice/core");
+var import_agent_eval = require("@axiom-lattice/agent-eval");
 var import_uuid3 = require("uuid");
+function mapLogs(logs) {
+  return logs.map((l) => ({
+    timestamp: l.ts,
+    level: l.level,
+    message: l.message,
+    data: l.data
+  }));
+}
+var EvalRunner = class {
+  constructor() {
+    this.runs = /* @__PURE__ */ new Map();
+    this.eventEmitter = new import_events.EventEmitter();
+  }
+  getEventEmitter() {
+    return this.eventEmitter;
+  }
+  async startRun(tenantId, projectId) {
+    const store = this.getEvalStore();
+    const project = await store.getProjectById(tenantId, projectId);
+    if (!project) throw new Error("Project not found");
+    const existingRuns = await store.getRunsByTenant(tenantId, { projectId, status: "running" });
+    if (existingRuns.length > 0) {
+      throw new Error("A run is already in progress for this project");
+    }
+    const suites = await store.getSuitesByProject(tenantId, projectId);
+    const evalSuites = [];
+    let totalCases = 0;
+    for (const suite of suites) {
+      const cases = await store.getCasesBySuite(tenantId, suite.id);
+      totalCases += cases.length;
+      evalSuites.push({
+        suiteName: suite.name,
+        cases: cases.map((c) => ({
+          caseId: c.id,
+          input: { message: c.inputMessage, files: c.inputFiles },
+          steps: c.steps,
+          output: { type: c.outputType },
+          eval: {
+            content_assertion: c.contentAssertion,
+            eval_rubrics: c.rubrics?.map((r) => ({
+              dimension: r.name,
+              weight: r.weight,
+              description: r.description
+            }))
+          }
+        }))
+      });
+    }
+    const runId = (0, import_uuid3.v4)();
+    const concurrency = project.concurrency || 3;
+    await store.createRun(tenantId, projectId, runId, { totalCases, concurrency });
+    const judgeCfg = project.judgeModelConfig;
+    const hasModelKey = Boolean(judgeCfg.modelKey);
+    const hasApiKey = Boolean(judgeCfg.apiKeyEnvName || judgeCfg.apiKey);
+    const hasCredentials = hasApiKey;
+    let judgeModelConfig = {};
+    if (hasModelKey) {
+      judgeModelConfig = { modelKey: judgeCfg.modelKey };
+    } else if (!hasCredentials) {
+      const firstModel = import_core23.modelLatticeManager.getAllLattices()[0];
+      if (firstModel) {
+        judgeModelConfig = { modelKey: firstModel.key };
+      } else {
+        judgeModelConfig = { model: judgeCfg };
+      }
+    } else {
+      judgeModelConfig = { model: judgeCfg };
+    }
+    const projectConfig = {
+      projectName: project.name,
+      version: project.version,
+      description: project.description,
+      suites: evalSuites,
+      judge_agent_config: judgeModelConfig,
+      lattice_server_config: {
+        base_url: project.targetServerConfig.base_url || "",
+        api_key: project.targetServerConfig.api_key || "",
+        tenant_id: tenantId
+      },
+      concurrency
+    };
+    const abortController = new AbortController();
+    const stats = { passed: 0, failed: 0, totalScore: 0 };
+    const onCaseComplete = async (result, suiteName) => {
+      const passed = result.result?.pass ?? false;
+      const score = result.result?.final_score ?? 0;
+      if (passed) stats.passed++;
+      else stats.failed++;
+      stats.totalScore += score;
+      const completedCount = stats.passed + stats.failed;
+      await store.createRunResult(tenantId, runId, (0, import_uuid3.v4)(), {
+        suiteName,
+        caseId: result.caseId,
+        pass: passed,
+        score,
+        summary: result.result?.summary,
+        dimensionResults: result.result?.dimension_results?.map((d) => ({
+          name: d.name,
+          score: d.score,
+          reason: d.reason
+        })),
+        durationMs: result.duration_ms,
+        messages: result.messages,
+        logs: mapLogs(result.logs),
+        error: result.error
+      });
+      const avgScore = completedCount > 0 ? stats.totalScore / completedCount : 0;
+      await store.updateRunStatus(tenantId, runId, {
+        passedCases: stats.passed,
+        failedCases: stats.failed,
+        avgScore
+      });
+      this.eventEmitter.emit(`run:${runId}`, {
+        type: "progress",
+        runId,
+        data: { suiteName, caseId: result.caseId, pass: passed, score, completed: completedCount, total: totalCases }
+      });
+    };
+    const runPromise = (async () => {
+      try {
+        const evalProject = new import_agent_eval.LatticeEvalProject(projectConfig, onCaseComplete);
+        const { report } = await evalProject.runAllSuitesBatch(concurrency);
+        const completedCount = stats.passed + stats.failed;
+        await store.updateRunStatus(tenantId, runId, {
+          status: "completed",
+          completedAt: /* @__PURE__ */ new Date(),
+          passedCases: stats.passed,
+          failedCases: stats.failed,
+          avgScore: completedCount > 0 ? stats.totalScore / completedCount : 0
+        });
+        this.eventEmitter.emit(`run:${runId}`, {
+          type: "completed",
+          runId,
+          data: { passed: stats.passed, failed: stats.failed, avgScore: completedCount > 0 ? stats.totalScore / completedCount : 0 }
+        });
+        return { report };
+      } catch (err) {
+        const errorMsg = err.message;
+        await store.updateRunStatus(tenantId, runId, {
+          status: "failed",
+          error: errorMsg,
+          completedAt: /* @__PURE__ */ new Date()
+        });
+        this.eventEmitter.emit(`run:${runId}`, {
+          type: "error",
+          runId,
+          data: { message: errorMsg }
+        });
+        throw err;
+      } finally {
+        this.runs.delete(runId);
+      }
+    })();
+    this.runs.set(runId, { runId, projectId, tenantId, abortController, promise: runPromise });
+    runPromise.catch(() => {
+    });
+    return runId;
+  }
+  async abortRun(runId) {
+    const ctx = this.runs.get(runId);
+    if (!ctx) return false;
+    ctx.abortController.abort();
+    const store = this.getEvalStore();
+    await store.updateRunStatus(ctx.tenantId, runId, { status: "aborted", completedAt: /* @__PURE__ */ new Date() });
+    return true;
+  }
+  isRunning(runId) {
+    return this.runs.has(runId);
+  }
+  getEvalStore() {
+    return (0, import_core23.getStoreLattice)("default", "eval").store;
+  }
+};
+var evalRunner = new EvalRunner();
+
+// src/controllers/eval.ts
+function getTenantId10(request) {
+  const userTenantId = request.user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+  return request.headers["x-tenant-id"] || "default";
+}
+function getEvalStore() {
+  return (0, import_core24.getStoreLattice)("default", "eval").store;
+}
+async function createProject(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const id = (0, import_uuid4.v4)();
+    const data = request.body;
+    const project = await store.createProject(tenantId, id, {
+      name: data.name,
+      description: data.description,
+      version: data.version,
+      judgeModelConfig: data.judgeModelConfig ?? {},
+      targetServerConfig: data.targetServerConfig ?? {},
+      concurrency: data.concurrency ?? 1,
+      reportConfig: data.reportConfig
+    });
+    return reply.status(201).send({
+      success: true,
+      message: "Successfully created project",
+      data: project
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to create project";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+async function listProjects(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    let projects = await store.getProjectsByTenant(tenantId);
+    if (projects.length === 0) {
+      try {
+        const { modelLatticeManager: modelLatticeManager3 } = await import("@axiom-lattice/core");
+        const models = modelLatticeManager3.getAllLattices();
+        const first = models[0];
+        const judgeModel = first ? { modelKey: first.key } : { provider: "openai", model: "gpt-4" };
+        const host = request.hostname || "localhost";
+        const baseUrl = `http://${host}:${process.env.PORT || 4001}`;
+        await store.createProject(tenantId, (0, import_uuid4.v4)(), {
+          name: "Default",
+          description: "Built-in project for testing eval against this server",
+          judgeModelConfig: judgeModel,
+          targetServerConfig: { base_url: baseUrl, api_key: "" },
+          concurrency: 3
+        });
+        projects = await store.getProjectsByTenant(tenantId);
+      } catch {
+      }
+    }
+    return {
+      success: true,
+      message: "Ok",
+      data: { records: projects, total: projects.length }
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to list projects";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+async function getProject(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const { pid } = request.params;
+    const project = await store.getProjectById(tenantId, pid);
+    if (!project) {
+      return reply.status(404).send({ success: false, message: "Project not found" });
+    }
+    const suites = await store.getSuitesByProject(tenantId, pid);
+    return {
+      success: true,
+      message: "Ok",
+      data: { project, suites }
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to get project";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+async function updateProject(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const { pid } = request.params;
+    const existing = await store.getProjectById(tenantId, pid);
+    if (!existing) {
+      return reply.status(404).send({ success: false, message: "Project not found" });
+    }
+    const updated = await store.updateProject(tenantId, pid, request.body);
+    return {
+      success: true,
+      message: "Successfully updated project",
+      data: updated
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to update project";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+async function deleteProject(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const { pid } = request.params;
+    const existing = await store.getProjectById(tenantId, pid);
+    if (!existing) {
+      return reply.status(404).send({ success: false, message: "Project not found" });
+    }
+    const deleted = await store.deleteProject(tenantId, pid);
+    if (!deleted) {
+      return reply.status(500).send({ success: false, message: "Failed to delete project" });
+    }
+    return { success: true, message: "Successfully deleted project" };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to delete project";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+async function createSuite(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const { pid } = request.params;
+    const project = await store.getProjectById(tenantId, pid);
+    if (!project) {
+      return reply.status(404).send({ success: false, message: "Project not found" });
+    }
+    const id = (0, import_uuid4.v4)();
+    const data = request.body;
+    const suite = await store.createSuite(tenantId, pid, id, { name: data.name });
+    return reply.status(201).send({
+      success: true,
+      message: "Successfully created suite",
+      data: suite
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to create suite";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+async function updateSuite(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const { sid } = request.params;
+    const existing = await store.getSuiteById(tenantId, sid);
+    if (!existing) {
+      return reply.status(404).send({ success: false, message: "Suite not found" });
+    }
+    const updated = await store.updateSuite(tenantId, sid, request.body);
+    return {
+      success: true,
+      message: "Successfully updated suite",
+      data: updated
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to update suite";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+async function deleteSuite(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const { sid } = request.params;
+    const existing = await store.getSuiteById(tenantId, sid);
+    if (!existing) {
+      return reply.status(404).send({ success: false, message: "Suite not found" });
+    }
+    const deleted = await store.deleteSuite(tenantId, sid);
+    if (!deleted) {
+      return reply.status(500).send({ success: false, message: "Failed to delete suite" });
+    }
+    return { success: true, message: "Successfully deleted suite" };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to delete suite";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+async function createCase(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const { sid } = request.params;
+    const suite = await store.getSuiteById(tenantId, sid);
+    if (!suite) {
+      return reply.status(404).send({ success: false, message: "Suite not found" });
+    }
+    const id = (0, import_uuid4.v4)();
+    const data = request.body;
+    const created = await store.createCase(tenantId, sid, id, {
+      inputMessage: data.inputMessage,
+      inputFiles: data.inputFiles,
+      steps: data.steps ?? [],
+      outputType: data.outputType ?? "message_content",
+      contentAssertion: data.contentAssertion ?? "",
+      rubrics: data.rubrics
+    });
+    return reply.status(201).send({
+      success: true,
+      message: "Successfully created case",
+      data: created
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to create case";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+async function listCasesForSuite(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const { sid } = request.params;
+    const cases = await store.getCasesBySuite(tenantId, sid);
+    return {
+      success: true,
+      message: "Ok",
+      data: { records: cases, total: cases.length }
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to list cases";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+async function updateCase(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const { cid } = request.params;
+    const existing = await store.getCaseById(tenantId, cid);
+    if (!existing) {
+      return reply.status(404).send({ success: false, message: "Case not found" });
+    }
+    const updated = await store.updateCase(tenantId, cid, request.body);
+    return {
+      success: true,
+      message: "Successfully updated case",
+      data: updated
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to update case";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+async function deleteCase(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const { cid } = request.params;
+    const existing = await store.getCaseById(tenantId, cid);
+    if (!existing) {
+      return reply.status(404).send({ success: false, message: "Case not found" });
+    }
+    const deleted = await store.deleteCase(tenantId, cid);
+    if (!deleted) {
+      return reply.status(500).send({ success: false, message: "Failed to delete case" });
+    }
+    return { success: true, message: "Successfully deleted case" };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to delete case";
+    return reply.status(500).send({ success: false, message });
+  }
+}
+function registerEvalRoutes(app2) {
+  app2.post("/api/eval/projects", createProject);
+  app2.get("/api/eval/projects", listProjects);
+  app2.get("/api/eval/projects/:pid", getProject);
+  app2.put("/api/eval/projects/:pid", updateProject);
+  app2.delete("/api/eval/projects/:pid", deleteProject);
+  app2.post("/api/eval/projects/:pid/suites", createSuite);
+  app2.put("/api/eval/projects/:pid/suites/:sid", updateSuite);
+  app2.delete("/api/eval/projects/:pid/suites/:sid", deleteSuite);
+  app2.post("/api/eval/projects/:pid/suites/:sid/cases", createCase);
+  app2.get("/api/eval/projects/:pid/suites/:sid/cases", listCasesForSuite);
+  app2.put("/api/eval/projects/:pid/suites/:sid/cases/:cid", updateCase);
+  app2.delete("/api/eval/projects/:pid/suites/:sid/cases/:cid", deleteCase);
+  app2.post("/api/eval/projects/:pid/runs", async (request, reply) => {
+    try {
+      const tenantId = getTenantId10(request);
+      const { pid } = request.params;
+      const runId = await evalRunner.startRun(tenantId, pid);
+      reply.status(202).send({ success: true, message: "Run started", data: { run_id: runId } });
+    } catch (err) {
+      const msg = err.message;
+      const code = msg === "Project not found" ? 404 : msg.includes("already in progress") ? 409 : 500;
+      reply.status(code).send({ success: false, message: msg });
+    }
+  });
+  app2.get("/api/eval/runs", async (request, reply) => {
+    try {
+      const tenantId = getTenantId10(request);
+      const query = request.query;
+      const runs = await getEvalStore().getRunsByTenant(tenantId, { projectId: query.project_id, status: query.status });
+      reply.send({ success: true, message: "Ok", data: { records: runs, total: runs.length } });
+    } catch (err) {
+      reply.status(500).send({ success: false, message: err.message });
+    }
+  });
+  app2.get("/api/eval/runs/:rid", async (request, reply) => {
+    try {
+      const tenantId = getTenantId10(request);
+      const { rid } = request.params;
+      const run = await getEvalStore().getRunById(tenantId, rid);
+      if (!run) return reply.status(404).send({ success: false, message: "Run not found" });
+      const results = await getEvalStore().getResultsByRun(tenantId, rid);
+      reply.send({ success: true, message: "Ok", data: { ...run, results } });
+    } catch (err) {
+      reply.status(500).send({ success: false, message: err.message });
+    }
+  });
+  app2.get("/api/eval/runs/:rid/stream", async (request, reply) => {
+    reply.hijack();
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    });
+    const { rid } = request.params;
+    const emitter = evalRunner.getEventEmitter();
+    const eventKey = `run:${rid}`;
+    if (!evalRunner.isRunning(rid)) {
+      const tenantId = getTenantId10(request);
+      const run = await getEvalStore().getRunById(tenantId, rid);
+      if (run) {
+        const eventType = run.status === "completed" ? "completed" : "error";
+        reply.raw.write(`event: ${eventType}
+data: ${JSON.stringify({ passed: run.passedCases, failed: run.failedCases, avgScore: run.avgScore })}
+
+`);
+      }
+      reply.raw.end();
+      return;
+    }
+    const handler = (event) => {
+      reply.raw.write(`event: ${event.type}
+data: ${JSON.stringify(event.data)}
+
+`);
+      if (event.type === "completed" || event.type === "error") {
+        emitter.off(eventKey, handler);
+        reply.raw.end();
+      }
+    };
+    emitter.on(eventKey, handler);
+    request.raw.on("close", () => {
+      emitter.off(eventKey, handler);
+    });
+  });
+  app2.post("/api/eval/runs/:rid/abort", async (request, reply) => {
+    try {
+      const { rid } = request.params;
+      const aborted = await evalRunner.abortRun(rid);
+      if (!aborted) return reply.status(404).send({ success: false, message: "Run not found or not running" });
+      reply.send({ success: true, message: "Run aborted" });
+    } catch (err) {
+      reply.status(500).send({ success: false, message: err.message });
+    }
+  });
+  app2.delete("/api/eval/runs/:rid", async (request, reply) => {
+    try {
+      const tenantId = getTenantId10(request);
+      const { rid } = request.params;
+      const deleted = await getEvalStore().deleteRun(tenantId, rid);
+      if (!deleted) return reply.status(404).send({ success: false, message: "Run not found" });
+      reply.send({ success: true, message: "Run deleted" });
+    } catch (err) {
+      reply.status(500).send({ success: false, message: err.message });
+    }
+  });
+  app2.get("/api/eval/reports/projects/:pid", async (request, reply) => {
+    try {
+      const tenantId = getTenantId10(request);
+      const { pid } = request.params;
+      const report = await getEvalStore().getProjectReport(tenantId, pid);
+      if (!report) return reply.status(404).send({ success: false, message: "Project not found" });
+      reply.send({ success: true, message: "Ok", data: report });
+    } catch (err) {
+      reply.status(500).send({ success: false, message: err.message });
+    }
+  });
+}
+
+// src/controllers/users.ts
+var import_core25 = require("@axiom-lattice/core");
+var import_uuid5 = require("uuid");
 var UsersController = class {
   constructor() {
-    this.userStore = (0, import_core23.getStoreLattice)("default", "user").store;
+    this.userStore = (0, import_core25.getStoreLattice)("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -4624,7 +5203,7 @@ var UsersController = class {
   }
   async createUser(request, reply) {
     const data = request.body;
-    const id = (0, import_uuid3.v4)();
+    const id = (0, import_uuid5.v4)();
     const existingUser = await this.userStore.getUserByEmail(data.email);
     if (existingUser) {
       return reply.status(409).send({
@@ -4689,11 +5268,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-var import_core24 = require("@axiom-lattice/core");
-var import_uuid4 = require("uuid");
+var import_core26 = require("@axiom-lattice/core");
+var import_uuid6 = require("uuid");
 var TenantsController = class {
   constructor() {
-    this.tenantStore = (0, import_core24.getStoreLattice)("default", "tenant").store;
+    this.tenantStore = (0, import_core26.getStoreLattice)("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -4702,7 +5281,7 @@ var TenantsController = class {
   }
   async createTenant(request, reply) {
     const data = request.body;
-    const id = (0, import_uuid4.v4)();
+    const id = (0, import_uuid6.v4)();
     const tenant = await this.tenantStore.createTenant(id, data);
     return reply.status(201).send({ success: true, data: tenant });
   }
@@ -4757,8 +5336,8 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-var import_core25 = require("@axiom-lattice/core");
-var import_uuid5 = require("uuid");
+var import_core27 = require("@axiom-lattice/core");
+var import_uuid7 = require("uuid");
 var defaultAuthConfig = {
   autoApproveUsers: true,
   allowTenantRegistration: true,
@@ -4766,9 +5345,9 @@ var defaultAuthConfig = {
 };
 var AuthController = class {
   constructor(config = {}) {
-    this.userStore = (0, import_core25.getStoreLattice)("default", "user").store;
-    this.tenantStore = (0, import_core25.getStoreLattice)("default", "tenant").store;
-    this.userTenantLinkStore = (0, import_core25.getStoreLattice)("default", "userTenantLink").store;
+    this.userStore = (0, import_core27.getStoreLattice)("default", "user").store;
+    this.tenantStore = (0, import_core27.getStoreLattice)("default", "tenant").store;
+    this.userTenantLinkStore = (0, import_core27.getStoreLattice)("default", "userTenantLink").store;
     this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
@@ -4781,7 +5360,7 @@ var AuthController = class {
           error: "User with this email already exists"
         });
       }
-      const userId = (0, import_uuid5.v4)();
+      const userId = (0, import_uuid7.v4)();
       const userStatus = this.config.autoApproveUsers ? "active" : "pending";
       const userData = {
         email,
@@ -5136,7 +5715,7 @@ function registerAuthRoutes(app2, config) {
 }
 
 // src/channels/lark/routes.ts
-var import_core27 = require("@axiom-lattice/core");
+var import_core29 = require("@axiom-lattice/core");
 var import_pg_stores = require("@axiom-lattice/pg-stores");
 
 // src/channels/lark/parser.ts
@@ -5384,7 +5963,7 @@ function resolveSubjectType(mappingMode, chatType) {
 }
 
 // src/channels/lark/runner.ts
-var import_core26 = require("@axiom-lattice/core");
+var import_core28 = require("@axiom-lattice/core");
 var import_protocols5 = require("@axiom-lattice/protocols");
 
 // src/channels/lark/aggregator.ts
@@ -5397,7 +5976,7 @@ function aggregateLarkReply(messageId, chunks) {
 
 // src/channels/lark/runner.ts
 async function runAgentAndCollectLarkReply(input) {
-  const agent = import_core26.agentInstanceManager.getAgent({
+  const agent = import_core28.agentInstanceManager.getAgent({
     tenant_id: input.tenantId,
     assistant_id: input.assistantId,
     thread_id: input.threadId,
@@ -5509,7 +6088,7 @@ function createDefaultLarkDependencies() {
   const installationStore = new import_pg_stores.PostgreSQLChannelInstallationStore({
     poolConfig: getDatabaseUrl()
   });
-  const threadStore = (0, import_core27.getStoreLattice)("default", "thread").store;
+  const threadStore = (0, import_core29.getStoreLattice)("default", "thread").store;
   const mappingStore = new import_pg_stores.ChannelIdentityMappingStore({
     poolConfig: getDatabaseUrl()
   });
@@ -5590,7 +6169,7 @@ function registerChannelRoutes(app2, dependencies = {}) {
 
 // src/controllers/channel-installations.ts
 var import_crypto8 = require("crypto");
-function getTenantId10(request) {
+function getTenantId11(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -5608,7 +6187,7 @@ async function getInstallationStore() {
   });
 }
 async function getChannelInstallationList(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { channel } = request.query;
   try {
     const store = await getInstallationStore();
@@ -5634,7 +6213,7 @@ async function getChannelInstallationList(request, reply) {
   }
 }
 async function getChannelInstallation(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { installationId } = request.params;
   try {
     const store = await getInstallationStore();
@@ -5667,7 +6246,7 @@ async function getChannelInstallation(request, reply) {
   }
 }
 async function createChannelInstallation(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const body = request.body;
   try {
     if (!body.channel) {
@@ -5730,7 +6309,7 @@ async function createChannelInstallation(request, reply) {
   }
 }
 async function updateChannelInstallation(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { installationId } = request.params;
   const body = request.body;
   try {
@@ -5776,7 +6355,7 @@ async function updateChannelInstallation(request, reply) {
   }
 }
 async function deleteChannelInstallation(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { installationId } = request.params;
   try {
     const store = await getInstallationStore();
@@ -5945,6 +6524,7 @@ var registerLatticeRoutes = (app2) => {
     filterSkillsByLicense
   );
   registerSandboxProxyRoutes(app2);
+  registerEvalRoutes(app2);
   registerWorkspaceRoutes(app2);
   registerDatabaseConfigRoutes(app2);
   registerMetricsServerConfigRoutes(app2);
@@ -6055,7 +6635,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core28 = require("@axiom-lattice/core");
+var import_core30 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -6073,18 +6653,18 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
     console.log(
       `\u5F00\u59CB\u5904\u7406\u4EFB\u52A1 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
     );
-    const agent = import_core28.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
-    await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core28.QueueMode.STEER);
+    const agent = import_core30.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
+    await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core30.QueueMode.STEER);
     if (callback_event) {
       agent.subscribeOnce("message:completed", (evt) => {
-        import_core28.eventBus.publish(callback_event, {
+        import_core30.eventBus.publish(callback_event, {
           success: true,
           state: evt.state,
           config: { assistant_id, thread_id, tenant_id }
         });
         if (main_thread_id && main_tenant_id) {
           try {
-            const mainAgent = import_core28.agentInstanceManager.getAgent({
+            const mainAgent = import_core30.agentInstanceManager.getAgent({
               assistant_id: main_assistant_id ?? assistant_id,
               thread_id: main_thread_id,
               tenant_id: main_tenant_id
@@ -6112,7 +6692,7 @@ ${summary}`
         }
       });
       agent.subscribeOnce("message:interrupted", (evt) => {
-        import_core28.eventBus.publish(callback_event, {
+        import_core30.eventBus.publish(callback_event, {
           success: true,
           state: evt.state,
           config: { assistant_id, thread_id, tenant_id }
@@ -6136,7 +6716,7 @@ ${summary}`
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core28.eventBus.publish(callback_event, {
+      import_core30.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         config: { assistant_id, thread_id, tenant_id }
@@ -6174,7 +6754,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core28.eventBus.subscribe(import_core28.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core30.eventBus.subscribe(import_core30.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
     this.startPollingQueue();
     console.log("Agent\u4EFB\u52A1\u6D88\u8D39\u8005\u5DF2\u542F\u52A8\u5E76\u76D1\u542C\u4EFB\u52A1\u4E8B\u4EF6\u548C\u961F\u5217");
   }
@@ -6293,7 +6873,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
     handleAgentTask(taskRequest).catch((error) => {
       console.error("\u5904\u7406Agent\u4EFB\u52A1\u65F6\u53D1\u751F\u672A\u6355\u83B7\u7684\u9519\u8BEF:", error);
       if (taskRequest.callback_event) {
-        import_core28.eventBus.publish(taskRequest.callback_event, {
+        import_core30.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
           config: {
@@ -6313,7 +6893,7 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core29 = require("@axiom-lattice/core");
+var import_core31 = require("@axiom-lattice/core");
 var import_protocols6 = require("@axiom-lattice/protocols");
 var import_meta = {};
 process.on("unhandledRejection", (reason, promise) => {
@@ -6329,11 +6909,11 @@ var DEFAULT_LOGGER_CONFIG = {
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core29.loggerLatticeManager.hasLattice("default")) {
-    import_core29.loggerLatticeManager.removeLattice("default");
+  if (import_core31.loggerLatticeManager.hasLattice("default")) {
+    import_core31.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core29.registerLoggerLattice)("default", config);
-  return (0, import_core29.getLoggerLattice)("default");
+  (0, import_core31.registerLoggerLattice)("default", config);
+  return (0, import_core31.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -6436,7 +7016,7 @@ app.setErrorHandler((error, request, reply) => {
 });
 function getConfiguredSandboxProvider() {
   const sandboxProviderType = process.env.SANDBOX_PROVIDER_TYPE || "microsandbox-remote";
-  return (0, import_core29.createSandboxProvider)({
+  return (0, import_core31.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -6465,15 +7045,15 @@ var start = async (config) => {
     app.decorate("loggerLattice", loggerLattice);
     registerLatticeRoutes(app);
     try {
-      const storeLattice = (0, import_core29.getStoreLattice)("default", "database");
+      const storeLattice = (0, import_core31.getStoreLattice)("default", "database");
       const store = storeLattice.store;
-      import_core29.sqlDatabaseManager.setConfigStore(store);
+      import_core31.sqlDatabaseManager.setConfigStore(store);
       logger.info("Database config store set for SqlDatabaseManager");
     } catch (error) {
       logger.warn("Failed to set database config store: " + (error instanceof Error ? error.message : String(error)));
     }
-    if (!import_core29.sandboxLatticeManager.hasLattice("default")) {
-      import_core29.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+    if (!import_core31.sandboxLatticeManager.hasLattice("default")) {
+      import_core31.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
       logger.info("Registered sandbox manager from env configuration");
     }
     const target_port = config?.port || Number(process.env.PORT) || 4001;
@@ -6494,7 +7074,7 @@ var start = async (config) => {
     }
     try {
       logger.info("Starting agent instance recovery...");
-      const restoreStats = await import_core29.agentInstanceManager.restore();
+      const restoreStats = await import_core31.agentInstanceManager.restore();
       logger.info(`Agent recovery complete: ${restoreStats.restored} threads restored, ${restoreStats.errors} errors`);
     } catch (error) {
       logger.error("Agent recovery failed", { error });