@axiom-lattice/gateway 2.1.73 → 2.1.75

package/dist/index.mjs

@@ -1747,6 +1747,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
           });
@@ -4592,12 +4593,590 @@ function registerMcpServerConfigRoutes(app2) {
   app2.post("/api/mcp-servers/test-tools", testMcpServerTools);
 }
 
-// src/controllers/users.ts
-import { getStoreLattice as getStoreLattice9 } from "@axiom-lattice/core";
+// src/controllers/eval.ts
+import { getStoreLattice as getStoreLattice10 } from "@axiom-lattice/core";
+import { v4 as uuidv43 } from "uuid";
+
+// src/services/eval-runner.ts
+import { EventEmitter } from "events";
+import { getStoreLattice as getStoreLattice9, modelLatticeManager as modelLatticeManager2 } from "@axiom-lattice/core";
+import { LatticeEvalProject } from "@axiom-lattice/agent-eval";
 import { v4 as uuidv42 } from "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 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 = uuidv42();
+    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 = modelLatticeManager2.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, uuidv42(), {
+        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 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 getStoreLattice9("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 getStoreLattice10("default", "eval").store;
+}
+async function createProject(request, reply) {
+  try {
+    const tenantId = getTenantId10(request);
+    const store = getEvalStore();
+    const id = uuidv43();
+    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, uuidv43(), {
+          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 = uuidv43();
+    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 = uuidv43();
+    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
+import { getStoreLattice as getStoreLattice11 } from "@axiom-lattice/core";
+import { v4 as uuidv44 } from "uuid";
 var UsersController = class {
   constructor() {
-    this.userStore = getStoreLattice9("default", "user").store;
+    this.userStore = getStoreLattice11("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -4610,7 +5189,7 @@ var UsersController = class {
   }
   async createUser(request, reply) {
     const data = request.body;
-    const id = uuidv42();
+    const id = uuidv44();
     const existingUser = await this.userStore.getUserByEmail(data.email);
     if (existingUser) {
       return reply.status(409).send({
@@ -4675,11 +5254,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-import { getStoreLattice as getStoreLattice10 } from "@axiom-lattice/core";
-import { v4 as uuidv43 } from "uuid";
+import { getStoreLattice as getStoreLattice12 } from "@axiom-lattice/core";
+import { v4 as uuidv45 } from "uuid";
 var TenantsController = class {
   constructor() {
-    this.tenantStore = getStoreLattice10("default", "tenant").store;
+    this.tenantStore = getStoreLattice12("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -4688,7 +5267,7 @@ var TenantsController = class {
   }
   async createTenant(request, reply) {
     const data = request.body;
-    const id = uuidv43();
+    const id = uuidv45();
     const tenant = await this.tenantStore.createTenant(id, data);
     return reply.status(201).send({ success: true, data: tenant });
   }
@@ -4743,8 +5322,8 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-import { getStoreLattice as getStoreLattice11 } from "@axiom-lattice/core";
-import { v4 as uuidv44 } from "uuid";
+import { getStoreLattice as getStoreLattice13 } from "@axiom-lattice/core";
+import { v4 as uuidv46 } from "uuid";
 var defaultAuthConfig = {
   autoApproveUsers: true,
   allowTenantRegistration: true,
@@ -4752,9 +5331,9 @@ var defaultAuthConfig = {
 };
 var AuthController = class {
   constructor(config = {}) {
-    this.userStore = getStoreLattice11("default", "user").store;
-    this.tenantStore = getStoreLattice11("default", "tenant").store;
-    this.userTenantLinkStore = getStoreLattice11("default", "userTenantLink").store;
+    this.userStore = getStoreLattice13("default", "user").store;
+    this.tenantStore = getStoreLattice13("default", "tenant").store;
+    this.userTenantLinkStore = getStoreLattice13("default", "userTenantLink").store;
     this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
@@ -4767,7 +5346,7 @@ var AuthController = class {
           error: "User with this email already exists"
         });
       }
-      const userId = uuidv44();
+      const userId = uuidv46();
       const userStatus = this.config.autoApproveUsers ? "active" : "pending";
       const userData = {
         email,
@@ -5122,7 +5701,7 @@ function registerAuthRoutes(app2, config) {
 }
 
 // src/channels/lark/routes.ts
-import { getStoreLattice as getStoreLattice12 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice14 } from "@axiom-lattice/core";
 import {
   ChannelIdentityMappingStore,
   PostgreSQLChannelInstallationStore
@@ -5498,7 +6077,7 @@ function createDefaultLarkDependencies() {
   const installationStore = new PostgreSQLChannelInstallationStore({
     poolConfig: getDatabaseUrl()
   });
-  const threadStore = getStoreLattice12("default", "thread").store;
+  const threadStore = getStoreLattice14("default", "thread").store;
   const mappingStore = new ChannelIdentityMappingStore({
     poolConfig: getDatabaseUrl()
   });
@@ -5579,7 +6158,7 @@ function registerChannelRoutes(app2, dependencies = {}) {
 
 // src/controllers/channel-installations.ts
 import { randomUUID as randomUUID7 } from "crypto";
-function getTenantId10(request) {
+function getTenantId11(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -5597,7 +6176,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();
@@ -5623,7 +6202,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();
@@ -5656,7 +6235,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) {
@@ -5719,7 +6298,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 {
@@ -5765,7 +6344,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();
@@ -5934,6 +6513,7 @@ var registerLatticeRoutes = (app2) => {
     filterSkillsByLicense
   );
   registerSandboxProxyRoutes(app2);
+  registerEvalRoutes(app2);
   registerWorkspaceRoutes(app2);
   registerDatabaseConfigRoutes(app2);
   registerMetricsServerConfigRoutes(app2);
@@ -6308,7 +6888,7 @@ import {
   loggerLatticeManager,
   sandboxLatticeManager as sandboxLatticeManager2,
   sqlDatabaseManager as sqlDatabaseManager2,
-  getStoreLattice as getStoreLattice13,
+  getStoreLattice as getStoreLattice15,
   agentInstanceManager as agentInstanceManager8,
   createSandboxProvider
 } from "@axiom-lattice/core";
@@ -6464,7 +7044,7 @@ var start = async (config) => {
     app.decorate("loggerLattice", loggerLattice);
     registerLatticeRoutes(app);
     try {
-      const storeLattice = getStoreLattice13("default", "database");
+      const storeLattice = getStoreLattice15("default", "database");
       const store = storeLattice.store;
       sqlDatabaseManager2.setConfigStore(store);
       logger.info("Database config store set for SqlDatabaseManager");