@axiom-lattice/gateway 2.1.106 → 2.1.108

package/dist/index.mjs

@@ -1,3 +1,6 @@
+import {
+  registerMcpServerConfigRoutes
+} from "./chunk-K4XELOSO.mjs";
 import {
   Logger,
   getQrCode,
@@ -196,6 +199,21 @@ async function deleteAssistant(request, reply) {
     });
   }
   eventBus.publish("assistant:deleted", { id, tenantId });
+  const userId = getUserId(request);
+  if (userId) {
+    try {
+      const linkStore = getStoreLattice("default", "userTenantLink").store;
+      const link = await linkStore.getLink(userId, tenantId);
+      const meta = link?.metadata || {};
+      if (meta.personalAssistantId === id) {
+        delete meta.personalAssistantId;
+        delete meta.personalProjectId;
+        delete meta.personalWorkspaceId;
+        await linkStore.updateLink(userId, tenantId, { metadata: meta });
+      }
+    } catch {
+    }
+  }
   return {
     success: true,
     message: "Successfully deleted assistant"
@@ -278,7 +296,7 @@ var createRun = async (request, reply) => {
           command,
           custom_run_config: mergedConfig
         }, mode);
-        const stream = agent.chunkStream(result.messageId, [MessageChunkTypes.MESSAGE_COMPLETED]);
+        const stream = agent.chunkStream(result.messageId, [MessageChunkTypes.MESSAGE_COMPLETED, MessageChunkTypes.INTERRUPT, MessageChunkTypes.MESSAGE_FAILED]);
         for await (const chunk of stream) {
           const success = reply.raw.write(`data: ${JSON.stringify(chunk)}
 
@@ -1548,6 +1566,442 @@ async function filterSkillsByLicense(request, reply) {
   }
 }
 
+// src/services/collection_service.ts
+import { v4 as uuidv4 } from "uuid";
+import { Document } from "@langchain/core/documents";
+import {
+  collectionLatticeManager,
+  embeddingsLatticeManager,
+  getOrCreateCollectionVectorStore,
+  getCollectionEntryCount,
+  listCollectionEntries,
+  removeCollectionVectorStore
+} from "@axiom-lattice/core";
+function getTenantId5(request) {
+  return request.user?.tenantId || request.headers["x-tenant-id"] || "default";
+}
+var CollectionService = class {
+  // ─── Collection CRUD ──────────────────────────────────────────
+  async getAllCollections(request) {
+    const tenantId = getTenantId5(request);
+    const collections = await collectionLatticeManager.getAllCollections(tenantId);
+    for (const c of collections) {
+      try {
+        c._entryCount = await getCollectionEntryCount(c.name, c.embeddingKey, c.tenantId);
+      } catch {
+        c._entryCount = 0;
+      }
+    }
+    return collections;
+  }
+  async getCollectionByName(request, name) {
+    const tenantId = getTenantId5(request);
+    return collectionLatticeManager.getCollection(tenantId, name);
+  }
+  async createCollection(request, data) {
+    const tenantId = getTenantId5(request);
+    const collection = await collectionLatticeManager.registerCollection(tenantId, data);
+    try {
+      await getOrCreateCollectionVectorStore(data.name, data.embeddingKey, tenantId);
+    } catch (err) {
+      console.warn(`[CollectionService] Failed to init vector store for ${data.name}:`, err);
+    }
+    return collection;
+  }
+  async updateCollection(request, name, updates) {
+    const tenantId = getTenantId5(request);
+    return collectionLatticeManager.updateCollection(tenantId, name, updates);
+  }
+  async deleteCollection(request, name) {
+    const tenantId = getTenantId5(request);
+    await removeCollectionVectorStore(name, tenantId);
+    return collectionLatticeManager.removeCollection(tenantId, name);
+  }
+  // ─── Entry CRUD ───────────────────────────────────────────────
+  async getEntries(request, collectionName) {
+    const collection = await this.getCollectionByName(request, collectionName);
+    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+    const docs = await listCollectionEntries(collectionName, collection.embeddingKey, collection.tenantId);
+    return docs.map((doc) => ({
+      id: doc.metadata._id || "",
+      content: doc.pageContent,
+      metadata: Object.fromEntries(
+        Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
+      )
+    }));
+  }
+  async createEntry(request, collectionName, data) {
+    const collection = await this.getCollectionByName(request, collectionName);
+    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+    const vectorStore = await getOrCreateCollectionVectorStore(
+      collectionName,
+      collection.embeddingKey,
+      collection.tenantId
+    );
+    const entryId = uuidv4();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const doc = new Document({
+      pageContent: data.content,
+      metadata: {
+        _id: entryId,
+        _created_at: now,
+        _updated_at: now,
+        ...data.metadata || {}
+      }
+    });
+    await vectorStore.addDocuments([doc]);
+    return { id: entryId, content: data.content, metadata: data.metadata || {} };
+  }
+  async getEntry(request, collectionName, entryId) {
+    const collection = await this.getCollectionByName(request, collectionName);
+    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+    const docs = await listCollectionEntries(collectionName, collection.embeddingKey, collection.tenantId);
+    const doc = docs.find((d) => d.metadata._id === entryId);
+    if (!doc) return null;
+    return {
+      id: entryId,
+      content: doc.pageContent,
+      metadata: Object.fromEntries(
+        Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
+      )
+    };
+  }
+  async updateEntry(request, collectionName, entryId, data) {
+    const existing = await this.getEntry(request, collectionName, entryId);
+    if (!existing) return null;
+    const collection = await this.getCollectionByName(request, collectionName);
+    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+    const vectorStore = await getOrCreateCollectionVectorStore(
+      collectionName,
+      collection.embeddingKey,
+      collection.tenantId
+    );
+    try {
+      await vectorStore.delete({ filter: { _id: entryId } });
+    } catch {
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const mergedMetadata = { ...existing.metadata, ...data.metadata || {} };
+    const doc = new Document({
+      pageContent: data.content ?? existing.content,
+      metadata: { _id: entryId, _created_at: now, _updated_at: now, ...mergedMetadata }
+    });
+    await vectorStore.addDocuments([doc]);
+    return { id: entryId, content: data.content ?? existing.content, metadata: mergedMetadata };
+  }
+  async deleteEntry(request, collectionName, entryId) {
+    const collection = await this.getCollectionByName(request, collectionName);
+    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+    const vectorStore = await getOrCreateCollectionVectorStore(
+      collectionName,
+      collection.embeddingKey,
+      collection.tenantId
+    );
+    try {
+      await vectorStore.delete({ filter: { _id: entryId } });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async searchEntries(request, collectionName, params) {
+    const collection = await this.getCollectionByName(request, collectionName);
+    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+    const vectorStore = await getOrCreateCollectionVectorStore(
+      collectionName,
+      collection.embeddingKey,
+      collection.tenantId
+    );
+    let embeddings;
+    try {
+      embeddings = embeddingsLatticeManager.getEmbeddingsClient(collection.embeddingKey);
+    } catch {
+      embeddings = embeddingsLatticeManager.getEmbeddingsClient("default");
+    }
+    const queryVector = await embeddings.embedQuery(params.query);
+    const results = await vectorStore.similaritySearchVectorWithScore(
+      queryVector,
+      params.top_k || 5,
+      params.filter
+    );
+    return results.map(([doc, score]) => ({
+      id: doc.metadata._id || uuidv4(),
+      content: doc.pageContent,
+      metadata: Object.fromEntries(
+        Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
+      ),
+      score
+    }));
+  }
+};
+
+// src/controllers/collections.ts
+var collectionService = new CollectionService();
+function serializeCollection(collection) {
+  return {
+    id: collection.id,
+    name: collection.name,
+    label: collection.label,
+    embeddingKey: collection.embeddingKey,
+    schema: collection.schema,
+    entryCount: collection._entryCount ?? 0,
+    createdAt: collection.createdAt instanceof Date ? collection.createdAt.toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: collection.updatedAt instanceof Date ? collection.updatedAt.toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function getCollectionList(request, reply) {
+  try {
+    const collections = await collectionService.getAllCollections(request);
+    return {
+      success: true,
+      message: "Successfully retrieved collection list",
+      data: {
+        records: collections.map(serializeCollection),
+        total: collections.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve collections: ${error.message}`,
+      data: { records: [], total: 0 }
+    });
+  }
+}
+async function getCollection(request, reply) {
+  try {
+    const { name } = request.params;
+    const collection = await collectionService.getCollectionByName(request, name);
+    if (!collection) {
+      return reply.status(404).send({ success: false, message: "Collection not found" });
+    }
+    return {
+      success: true,
+      message: "Successfully retrieved collection",
+      data: serializeCollection(collection)
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve collection: ${error.message}`
+    });
+  }
+}
+async function createCollection(request, reply) {
+  try {
+    const data = request.body;
+    if (!data.name) {
+      return reply.status(400).send({ success: false, message: "name is required" });
+    }
+    if (!data.label) {
+      return reply.status(400).send({ success: false, message: "label is required" });
+    }
+    if (!data.embeddingKey) {
+      return reply.status(400).send({ success: false, message: "embeddingKey is required" });
+    }
+    const collection = await collectionService.createCollection(request, data);
+    return reply.status(201).send({
+      success: true,
+      message: "Successfully created collection",
+      data: serializeCollection(collection)
+    });
+  } catch (error) {
+    if (error.message?.includes("already exists")) {
+      return reply.status(409).send({ success: false, message: error.message });
+    }
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to create collection: ${error.message}`
+    });
+  }
+}
+async function updateCollection(request, reply) {
+  try {
+    const { name } = request.params;
+    const updates = request.body;
+    const collection = await collectionService.updateCollection(
+      request,
+      name,
+      updates
+    );
+    if (!collection) {
+      return reply.status(404).send({ success: false, message: "Collection not found" });
+    }
+    return {
+      success: true,
+      message: "Successfully updated collection",
+      data: serializeCollection(collection)
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to update collection: ${error.message}`
+    });
+  }
+}
+async function deleteCollection(request, reply) {
+  try {
+    const { name } = request.params;
+    const result = await collectionService.deleteCollection(request, name);
+    if (!result) {
+      return reply.status(404).send({ success: false, message: "Collection not found" });
+    }
+    return { success: true, message: "Successfully deleted collection" };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to delete collection: ${error.message}`
+    });
+  }
+}
+
+// src/controllers/embeddings.ts
+import { embeddingsLatticeManager as embeddingsLatticeManager2 } from "@axiom-lattice/core";
+async function listEmbeddings(_request, _reply) {
+  try {
+    const info = embeddingsLatticeManager2.getAllEmbeddingsInfo();
+    return {
+      success: true,
+      message: "Successfully retrieved embedding models",
+      data: { records: info, total: info.length }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to retrieve embeddings: ${error.message}`,
+      data: { records: [], total: 0 }
+    };
+  }
+}
+
+// src/controllers/entries.ts
+var collectionService2 = new CollectionService();
+async function listEntries(request, reply) {
+  try {
+    const { name } = request.params;
+    const entries = await collectionService2.getEntries(request, name);
+    return {
+      success: true,
+      message: "Successfully retrieved entries",
+      data: { records: entries, total: entries.length }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve entries: ${error.message}`,
+      data: { records: [], total: 0 }
+    });
+  }
+}
+async function createEntry(request, reply) {
+  try {
+    const { name } = request.params;
+    const data = request.body;
+    if (!data.content) {
+      return reply.status(400).send({ success: false, message: "content is required" });
+    }
+    const entry = await collectionService2.createEntry(request, name, data);
+    return reply.status(201).send({
+      success: true,
+      message: "Successfully created entry",
+      data: entry
+    });
+  } catch (error) {
+    if (error.message?.includes("not found")) {
+      return reply.status(404).send({ success: false, message: error.message });
+    }
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to create entry: ${error.message}`
+    });
+  }
+}
+async function getEntry(request, reply) {
+  try {
+    const { name, id } = request.params;
+    const entry = await collectionService2.getEntry(request, name, id);
+    if (!entry) {
+      return reply.status(404).send({ success: false, message: "Entry not found" });
+    }
+    return {
+      success: true,
+      message: "Successfully retrieved entry",
+      data: entry
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve entry: ${error.message}`
+    });
+  }
+}
+async function updateEntry(request, reply) {
+  try {
+    const { name, id } = request.params;
+    const data = request.body;
+    const entry = await collectionService2.updateEntry(request, name, id, data);
+    if (!entry) {
+      return reply.status(404).send({ success: false, message: "Entry not found" });
+    }
+    return {
+      success: true,
+      message: "Successfully updated entry",
+      data: entry
+    };
+  } catch (error) {
+    if (error.message?.includes("not found")) {
+      return reply.status(404).send({ success: false, message: error.message });
+    }
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to update entry: ${error.message}`
+    });
+  }
+}
+async function deleteEntry(request, reply) {
+  try {
+    const { name, id } = request.params;
+    const result = await collectionService2.deleteEntry(request, name, id);
+    if (!result) {
+      return reply.status(404).send({ success: false, message: "Entry not found" });
+    }
+    return { success: true, message: "Successfully deleted entry" };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to delete entry: ${error.message}`
+    });
+  }
+}
+async function searchEntries(request, reply) {
+  try {
+    const { name } = request.params;
+    const { query, filter, top_k } = request.body;
+    if (!query) {
+      return reply.status(400).send({ success: false, message: "query is required" });
+    }
+    const entries = await collectionService2.searchEntries(request, name, {
+      query,
+      filter,
+      top_k
+    });
+    return {
+      success: true,
+      message: "Search completed",
+      data: { records: entries, total: entries.length }
+    };
+  } catch (error) {
+    if (error.message?.includes("not found")) {
+      return reply.status(404).send({ success: false, message: error.message });
+    }
+    return reply.status(500).send({
+      success: false,
+      message: `Search failed: ${error.message}`,
+      data: { records: [], total: 0 }
+    });
+  }
+}
+
 // src/controllers/tools.ts
 import { toolLatticeManager } from "@axiom-lattice/core";
 function serializeSchema(schema) {
@@ -1635,11 +2089,11 @@ import {
   getStoreLattice as getStoreLattice3,
   metricsServerManager
 } from "@axiom-lattice/core";
-function getTenantId5(request) {
+function getTenantId6(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function executeDataQuery(request, reply) {
-  const tenantId = getTenantId5(request);
+  const tenantId = getTenantId6(request);
   const body = request.body;
   try {
     if (!body.serverKey && !body.datasourceId) {
@@ -1696,14 +2150,16 @@ async function executeDataQuery(request, reply) {
         message: "datasourceId is required"
       };
     }
-    if (!metricsServerManager.hasServer(tenantId, body.serverKey)) {
+    let client;
+    try {
+      client = await metricsServerManager.getClient(tenantId, body.serverKey);
+    } catch {
       reply.code(400);
       return {
         success: false,
         message: `Metrics server not registered: ${body.serverKey}. Please register the server first.`
       };
     }
-    const client = await metricsServerManager.getClient(tenantId, body.serverKey);
     if (isSemanticQuery) {
       return await executeSemanticQuery(client, body, reply);
     } else {
@@ -1773,7 +2229,7 @@ async function executeSqlQuery(client, body, reply) {
 // src/controllers/workflow-tracking.ts
 import { getStoreLattice as getStoreLattice4, agentInstanceManager as agentInstanceManager4, ThreadStatus as ThreadStatus2 } from "@axiom-lattice/core";
 import { MessageChunkTypes as MessageChunkTypes2 } from "@axiom-lattice/protocols";
-function getTenantId6(request) {
+function getTenantId7(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) return userTenantId;
   return request.headers["x-tenant-id"] || "default";
@@ -1814,7 +2270,7 @@ async function getDefinitionsFromAssistants(tenantId) {
   }
 }
 async function getAllWorkflowDefinitions(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   try {
     const configDefs = await getDefinitionsFromAssistants(tenantId);
     if (configDefs.length === 0) {
@@ -1859,7 +2315,7 @@ async function getAllWorkflowDefinitions(request, reply) {
   }
 }
 async function getAllWorkflowRuns(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { assistantId, status } = request.query;
   try {
     const store = getTrackingStore();
@@ -1911,7 +2367,7 @@ async function getAllWorkflowRuns(request, reply) {
   }
 }
 async function getInboxItems(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   try {
     const store = getTrackingStore();
     if (!store) {
@@ -2002,7 +2458,7 @@ async function getInboxItems(request, reply) {
 }
 async function getWorkflowDefinitions(request, reply) {
   const { assistantId } = request.params;
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   try {
     const store = getTrackingStore();
     if (!store) {
@@ -2033,7 +2489,7 @@ async function getWorkflowDefinitions(request, reply) {
 }
 async function getWorkflowRuns(request, reply) {
   const { threadId } = request.params;
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   try {
     const store = getTrackingStore();
     if (!store) {
@@ -2069,7 +2525,7 @@ async function getWorkflowRun(request, reply) {
 }
 async function deleteWorkflowRun(request, reply) {
   const { runId } = request.params;
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   try {
     const store = getTrackingStore();
     if (!store) {
@@ -2152,7 +2608,7 @@ async function getRunTasks(request, reply) {
 }
 async function replyInboxTask(request, reply) {
   const { runId, answers } = request.body;
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   try {
     const store = getTrackingStore();
     if (!store) {
@@ -2233,7 +2689,7 @@ import { randomUUID as randomUUID3 } from "crypto";
 function getWorkspaceId2(request) {
   return request.headers["x-workspace-id"] || "default";
 }
-function getTenantId7(request) {
+function getTenantId8(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) return userTenantId;
   return request.headers["x-tenant-id"] || "default";
@@ -2260,7 +2716,7 @@ async function updateLinkMeta(userId, tenantId, meta) {
   await getLinkStore().updateLink(userId, tenantId, { metadata: meta });
 }
 async function createPersonalAssistant(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const userId = getUserId3(request);
   const { name, personality } = request.body;
   if (!name || !personality) {
@@ -2296,7 +2752,7 @@ async function createPersonalAssistant(request, reply) {
   });
 }
 async function getPersonalAssistant(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const userId = getUserId3(request);
   const store = getAssistantStore();
   const assistant = await store.getByOwner(tenantId, userId);
@@ -2313,7 +2769,7 @@ async function getPersonalAssistant(request, reply) {
   };
 }
 async function deletePersonalAssistant(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const userId = getUserId3(request);
   const store = getAssistantStore();
   const assistant = await store.getByOwner(tenantId, userId);
@@ -2350,7 +2806,7 @@ async function deletePersonalAssistant(request, reply) {
 
 // src/controllers/tasks.ts
 import { getStoreLattice as getStoreLattice6 } from "@axiom-lattice/core";
-function getTenantId8(request) {
+function getTenantId9(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) return userTenantId;
   return request.headers["x-tenant-id"] || "default";
@@ -2365,7 +2821,7 @@ function getStore() {
 }
 async function listTasks(request, reply) {
   try {
-    const tenantId = getTenantId8(request);
+    const tenantId = getTenantId9(request);
     const userId = getUserId4(request);
     const query = request.query;
     const store = getStore();
@@ -2386,7 +2842,7 @@ async function listTasks(request, reply) {
 }
 async function getTask(request, reply) {
   try {
-    const tenantId = getTenantId8(request);
+    const tenantId = getTenantId9(request);
     const userId = getUserId4(request);
     const { id } = request.params;
     const store = getStore();
@@ -2404,7 +2860,7 @@ async function getTask(request, reply) {
 }
 async function createTask(request, reply) {
   try {
-    const tenantId = getTenantId8(request);
+    const tenantId = getTenantId9(request);
     const userId = getUserId4(request);
     const body = request.body;
     if (!body.title) {
@@ -2424,7 +2880,7 @@ async function createTask(request, reply) {
 }
 async function updateTask(request, reply) {
   try {
-    const tenantId = getTenantId8(request);
+    const tenantId = getTenantId9(request);
     const userId = getUserId4(request);
     const { id } = request.params;
     const store = getStore();
@@ -2446,7 +2902,7 @@ async function updateTask(request, reply) {
 }
 async function deleteTask(request, reply) {
   try {
-    const tenantId = getTenantId8(request);
+    const tenantId = getTenantId9(request);
     const userId = getUserId4(request);
     const { id } = request.params;
     const store = getStore();
@@ -2468,7 +2924,7 @@ async function deleteTask(request, reply) {
 }
 async function completeTask(request, reply) {
   try {
-    const tenantId = getTenantId8(request);
+    const tenantId = getTenantId9(request);
     const userId = getUserId4(request);
     const { id } = request.params;
     const store = getStore();
@@ -3159,7 +3615,7 @@ import * as path from "path";
 import { getStoreLattice as getStoreLattice7 } from "@axiom-lattice/core";
 import { SandboxFilesystem, FilesystemBackend } from "@axiom-lattice/core";
 import { getSandBoxManager as getSandBoxManager3 } from "@axiom-lattice/core";
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv42 } from "uuid";
 var WorkspaceController = class {
   constructor() {
     this.workspaceStore = getStoreLattice7("default", "workspace").store;
@@ -3185,7 +3641,7 @@ var WorkspaceController = class {
   async createWorkspace(request, reply) {
     const tenantId = this.getTenantId(request);
     const data = request.body;
-    const id = uuidv4();
+    const id = uuidv42();
     const workspace = await this.workspaceStore.createWorkspace(
       tenantId,
       id,
@@ -3245,7 +3701,7 @@ var WorkspaceController = class {
     const tenantId = this.getTenantId(request);
     const { workspaceId } = request.params;
     const data = request.body;
-    const id = uuidv4();
+    const id = uuidv42();
     const project = await this.projectStore.createProject(
       tenantId,
       workspaceId,
@@ -3683,7 +4139,7 @@ import {
   sqlDatabaseManager
 } from "@axiom-lattice/core";
 import { randomUUID as randomUUID4 } from "crypto";
-function getTenantId9(request) {
+function getTenantId10(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -3691,7 +4147,7 @@ function getTenantId9(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getDatabaseConfigList(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId10(request);
   try {
     const storeLattice = getStoreLattice8("default", "database");
     const store = storeLattice.store;
@@ -3721,7 +4177,7 @@ async function getDatabaseConfigList(request, reply) {
   }
 }
 async function getDatabaseConfig(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId10(request);
   const { key } = request.params;
   try {
     const storeLattice = getStoreLattice8("default", "database");
@@ -3747,7 +4203,7 @@ async function getDatabaseConfig(request, reply) {
   }
 }
 async function createDatabaseConfig(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId10(request);
   const body = request.body;
   try {
     const storeLattice = getStoreLattice8("default", "database");
@@ -3782,7 +4238,7 @@ async function createDatabaseConfig(request, reply) {
   }
 }
 async function updateDatabaseConfig(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId10(request);
   const { key } = request.params;
   const updates = request.body;
   try {
@@ -3824,7 +4280,7 @@ async function updateDatabaseConfig(request, reply) {
   }
 }
 async function deleteDatabaseConfig(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId10(request);
   const { keyOrId } = request.params;
   try {
     const storeLattice = getStoreLattice8("default", "database");
@@ -3873,7 +4329,7 @@ async function deleteDatabaseConfig(request, reply) {
   }
 }
 async function testDatabaseConnection(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId10(request);
   const { key } = request.params;
   try {
     const storeLattice = getStoreLattice8("default", "database");
@@ -3966,7 +4422,7 @@ import {
   SemanticMetricsClient as SemanticMetricsClient2
 } from "@axiom-lattice/core";
 import { randomUUID as randomUUID5 } from "crypto";
-function getTenantId10(request) {
+function getTenantId11(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -3974,7 +4430,7 @@ function getTenantId10(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getMetricsServerConfigList(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   try {
     const storeLattice = getStoreLattice9("default", "metrics");
     const store = storeLattice.store;
@@ -4000,7 +4456,7 @@ async function getMetricsServerConfigList(request, reply) {
   }
 }
 async function getMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
     const storeLattice = getStoreLattice9("default", "metrics");
@@ -4026,7 +4482,7 @@ async function getMetricsServerConfig(request, reply) {
   }
 }
 async function createMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const body = request.body;
   try {
     const storeLattice = getStoreLattice9("default", "metrics");
@@ -4077,7 +4533,7 @@ async function createMetricsServerConfig(request, reply) {
   }
 }
 async function updateMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   const updates = request.body;
   try {
@@ -4128,7 +4584,7 @@ async function updateMetricsServerConfig(request, reply) {
   }
 }
 async function deleteMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { keyOrId } = request.params;
   try {
     const storeLattice = getStoreLattice9("default", "metrics");
@@ -4175,7 +4631,7 @@ async function deleteMetricsServerConfig(request, reply) {
   }
 }
 async function testMetricsServerConnection(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
     const storeLattice = getStoreLattice9("default", "metrics");
@@ -4226,7 +4682,7 @@ async function testMetricsServerConnection(request, reply) {
   }
 }
 async function listAvailableMetrics(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
     const storeLattice = getStoreLattice9("default", "metrics");
@@ -4264,7 +4720,7 @@ async function listAvailableMetrics(request, reply) {
   }
 }
 async function queryMetricsData(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   const { metricName, startTime, endTime, step, labels } = request.body;
   try {
@@ -4312,7 +4768,7 @@ async function queryMetricsData(request, reply) {
   }
 }
 async function getDataSources(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
     const storeLattice = getStoreLattice9("default", "metrics");
@@ -4353,7 +4809,7 @@ async function getDataSources(request, reply) {
   }
 }
 async function getDatasourceMetrics(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key, datasourceId } = request.params;
   try {
     const storeLattice = getStoreLattice9("default", "metrics");
@@ -4390,7 +4846,7 @@ async function getDatasourceMetrics(request, reply) {
   }
 }
 async function querySemanticMetrics(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   const body = request.body;
   try {
@@ -4546,448 +5002,15 @@ function registerMetricsServerConfigRoutes(app2) {
   app2.post("/api/metrics-configs/test-datasources/:datasourceId/meta", testDatasourceMetrics);
 }
 
-// src/controllers/mcp-configs.ts
-import {
-  getStoreLattice as getStoreLattice10,
-  mcpManager,
-  toolLatticeManager as toolLatticeManager2
-} from "@axiom-lattice/core";
-import { randomUUID as randomUUID6 } from "crypto";
-function getTenantId11(request) {
-  const userTenantId = request.user?.tenantId;
-  if (userTenantId) {
-    return userTenantId;
-  }
-  return request.headers["x-tenant-id"] || "default";
-}
-async function getMcpServerConfigList(request, reply) {
-  const tenantId = getTenantId11(request);
-  try {
-    const storeLattice = getStoreLattice10("default", "mcp");
-    const store = storeLattice.store;
-    const configs = await store.getAllConfigs(tenantId);
-    return {
-      success: true,
-      message: "MCP server configurations retrieved successfully",
-      data: {
-        records: configs,
-        total: configs.length
-      }
-    };
-  } catch (error) {
-    console.error("Failed to get MCP server configs:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve MCP server configurations",
-      data: {
-        records: [],
-        total: 0
-      }
-    };
-  }
-}
-async function getMcpServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
-  const { key } = request.params;
-  try {
-    const storeLattice = getStoreLattice10("default", "mcp");
-    const store = storeLattice.store;
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      return {
-        success: false,
-        message: "MCP server configuration not found"
-      };
-    }
-    return {
-      success: true,
-      message: "MCP server configuration retrieved successfully",
-      data: config
-    };
-  } catch (error) {
-    console.error("Failed to get MCP server config:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve MCP server configuration"
-    };
-  }
-}
-async function createMcpServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
-  const body = request.body;
-  try {
-    const storeLattice = getStoreLattice10("default", "mcp");
-    const store = storeLattice.store;
-    const existing = await store.getConfigByKey(tenantId, body.key);
-    if (existing) {
-      reply.code(409);
-      return {
-        success: false,
-        message: "MCP server configuration with this key already exists"
-      };
-    }
-    const id = body.id || randomUUID6();
-    const config = await store.createConfig(tenantId, id, body);
-    try {
-      await connectAndRegisterTools(config);
-      await store.updateConfig(tenantId, id, { status: "connected" });
-      config.status = "connected";
-    } catch (error) {
-      console.warn("Failed to auto-connect MCP server:", error);
-      await store.updateConfig(tenantId, id, { status: "error" });
-      config.status = "error";
-    }
-    reply.code(201);
-    return {
-      success: true,
-      message: "MCP server configuration created successfully",
-      data: config
-    };
-  } catch (error) {
-    console.error("Failed to create MCP server config:", error);
-    return {
-      success: false,
-      message: "Failed to create MCP server configuration"
-    };
-  }
-}
-async function updateMcpServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
-  const { key } = request.params;
-  const updates = request.body;
-  try {
-    const storeLattice = getStoreLattice10("default", "mcp");
-    const store = storeLattice.store;
-    const existing = await store.getConfigByKey(tenantId, key);
-    if (!existing) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "MCP server configuration not found"
-      };
-    }
-    const shouldReconnect = updates.config !== void 0;
-    const updated = await store.updateConfig(tenantId, existing.id, updates);
-    if (!updated) {
-      return {
-        success: false,
-        message: "Failed to update MCP server configuration"
-      };
-    }
-    if (shouldReconnect) {
-      try {
-        if (mcpManager.hasServer(key)) {
-          await mcpManager.removeServer(key);
-        }
-        await connectAndRegisterTools(updated);
-        await store.updateConfig(tenantId, existing.id, { status: "connected" });
-        updated.status = "connected";
-      } catch (error) {
-        console.warn("Failed to reconnect MCP server:", error);
-        await store.updateConfig(tenantId, existing.id, { status: "error" });
-        updated.status = "error";
-      }
-    }
-    return {
-      success: true,
-      message: "MCP server configuration updated successfully",
-      data: updated
-    };
-  } catch (error) {
-    console.error("Failed to update MCP server config:", error);
-    return {
-      success: false,
-      message: "Failed to update MCP server configuration"
-    };
-  }
-}
-async function deleteMcpServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
-  const { keyOrId } = request.params;
-  try {
-    const storeLattice = getStoreLattice10("default", "mcp");
-    const store = storeLattice.store;
-    let config = await store.getConfigByKey(tenantId, keyOrId);
-    let configKey = keyOrId;
-    if (!config) {
-      config = await store.getConfigById(tenantId, keyOrId);
-      if (config) {
-        configKey = config.key;
-      }
-    }
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "MCP server configuration not found"
-      };
-    }
-    try {
-      if (mcpManager.hasServer(configKey)) {
-        await mcpManager.removeServer(configKey);
-      }
-    } catch (error) {
-      console.warn("Failed to remove from MCP manager:", error);
-    }
-    const deleted = await store.deleteConfig(tenantId, config.id);
-    if (!deleted) {
-      return {
-        success: false,
-        message: "Failed to delete MCP server configuration"
-      };
-    }
-    return {
-      success: true,
-      message: "MCP server configuration deleted successfully"
-    };
-  } catch (error) {
-    console.error("Failed to delete MCP server config:", error);
-    return {
-      success: false,
-      message: "Failed to delete MCP server configuration"
-    };
-  }
-}
-async function testMcpServerConnection(request, reply) {
-  const tenantId = getTenantId11(request);
-  const { key } = request.params;
-  try {
-    const storeLattice = getStoreLattice10("default", "mcp");
-    const store = storeLattice.store;
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "MCP server configuration not found"
-      };
-    }
-    const startTime = Date.now();
-    try {
-      const testKey = `__test_${key}_${Date.now()}`;
-      const connection = convertToConnection(config.config);
-      mcpManager.addServer(testKey, connection);
-      await mcpManager.connect();
-      const tools = await mcpManager.getAllTools();
-      const latency = Date.now() - startTime;
-      await mcpManager.removeServer(testKey);
-      return {
-        success: true,
-        message: "Connection test successful",
-        data: {
-          connected: true,
-          latency
-        }
-      };
-    } catch (error) {
-      return {
-        success: true,
-        message: "Connection test failed",
-        data: {
-          connected: false,
-          error: error instanceof Error ? error.message : "Unknown error"
-        }
-      };
-    }
-  } catch (error) {
-    console.error("Failed to test MCP server connection:", error);
-    return {
-      success: false,
-      message: "Failed to test MCP server connection",
-      data: {
-        connected: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      }
-    };
-  }
-}
-async function listMcpServerTools(request, reply) {
-  const tenantId = getTenantId11(request);
-  const { key } = request.params;
-  try {
-    const storeLattice = getStoreLattice10("default", "mcp");
-    const store = storeLattice.store;
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "MCP server configuration not found"
-      };
-    }
-    if (!mcpManager.hasServer(key)) {
-      await connectAndRegisterTools(config);
-    }
-    const tools = await mcpManager.getAllTools();
-    return {
-      success: true,
-      message: "Tools retrieved successfully",
-      data: {
-        tools
-      }
-    };
-  } catch (error) {
-    console.error("Failed to list MCP tools:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve tools"
-    };
-  }
-}
-async function connectMcpServer(request, reply) {
-  const tenantId = getTenantId11(request);
-  const { key } = request.params;
-  try {
-    const storeLattice = getStoreLattice10("default", "mcp");
-    const store = storeLattice.store;
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "MCP server configuration not found"
-      };
-    }
-    await connectAndRegisterTools(config);
-    const updated = await store.updateConfig(tenantId, config.id, {
-      status: "connected"
-    });
-    return {
-      success: true,
-      message: "MCP server connected successfully",
-      data: updated || config
-    };
-  } catch (error) {
-    console.error("Failed to connect MCP server:", error);
-    const storeLattice = getStoreLattice10("default", "mcp");
-    const store = storeLattice.store;
-    const config = await store.getConfigByKey(tenantId, key);
-    if (config) {
-      await store.updateConfig(tenantId, config.id, { status: "error" });
-    }
-    return {
-      success: false,
-      message: `Failed to connect MCP server: ${error instanceof Error ? error.message : "Unknown error"}`
-    };
-  }
-}
-async function disconnectMcpServer(request, reply) {
-  const tenantId = getTenantId11(request);
-  const { key } = request.params;
-  try {
-    const storeLattice = getStoreLattice10("default", "mcp");
-    const store = storeLattice.store;
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "MCP server configuration not found"
-      };
-    }
-    if (mcpManager.hasServer(key)) {
-      await mcpManager.removeServer(key);
-    }
-    const updated = await store.updateConfig(tenantId, config.id, {
-      status: "disconnected"
-    });
-    return {
-      success: true,
-      message: "MCP server disconnected successfully",
-      data: updated || config
-    };
-  } catch (error) {
-    console.error("Failed to disconnect MCP server:", error);
-    return {
-      success: false,
-      message: "Failed to disconnect MCP server"
-    };
-  }
-}
-async function testMcpServerTools(request, reply) {
-  const body = request.body;
-  try {
-    if (!body.config) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "config is required"
-      };
-    }
-    const testKey = `__test_${Date.now()}`;
-    const connection = convertToConnection(body.config);
-    mcpManager.addServer(testKey, connection);
-    await mcpManager.connect();
-    const tools = await mcpManager.getAllTools();
-    await mcpManager.removeServer(testKey);
-    return {
-      success: true,
-      message: "Tools retrieved successfully",
-      data: {
-        tools
-      }
-    };
-  } catch (error) {
-    console.error("Failed to test MCP server tools:", error);
-    return {
-      success: false,
-      message: `Failed to retrieve tools: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-function convertToConnection(config) {
-  const baseConfig = {
-    env: config.env
-  };
-  if (config.transport === "stdio") {
-    return {
-      ...baseConfig,
-      transport: "stdio",
-      command: config.command,
-      args: config.args || []
-    };
-  } else {
-    return {
-      ...baseConfig,
-      transport: config.transport === "streamable_http" ? "http" : config.transport,
-      url: config.url
-    };
-  }
-}
-async function connectAndRegisterTools(config) {
-  const connection = convertToConnection(config.config);
-  mcpManager.addServer(config.key, connection);
-  await mcpManager.connect();
-  const allTools = await mcpManager.getAllTools();
-  const selectedTools = allTools.filter(
-    (tool) => config.selectedTools.includes(tool.name)
-  );
-  for (const tool of selectedTools) {
-    toolLatticeManager2.registerExistingTool(tool.name, tool);
-  }
-}
-function registerMcpServerConfigRoutes(app2) {
-  app2.get("/api/mcp-servers", getMcpServerConfigList);
-  app2.get("/api/mcp-servers/:key", getMcpServerConfig);
-  app2.post("/api/mcp-servers", createMcpServerConfig);
-  app2.put("/api/mcp-servers/:key", updateMcpServerConfig);
-  app2.delete("/api/mcp-servers/:keyOrId", deleteMcpServerConfig);
-  app2.post("/api/mcp-servers/:key/test", testMcpServerConnection);
-  app2.get("/api/mcp-servers/:key/tools", listMcpServerTools);
-  app2.post("/api/mcp-servers/:key/connect", connectMcpServer);
-  app2.post("/api/mcp-servers/:key/disconnect", disconnectMcpServer);
-  app2.post("/api/mcp-servers/test-tools", testMcpServerTools);
-}
-
 // src/controllers/eval.ts
-import { getStoreLattice as getStoreLattice12 } from "@axiom-lattice/core";
-import { v4 as uuidv43 } from "uuid";
+import { getStoreLattice as getStoreLattice11 } from "@axiom-lattice/core";
+import { v4 as uuidv44 } from "uuid";
 
 // src/services/eval-runner.ts
 import { EventEmitter } from "events";
-import { getStoreLattice as getStoreLattice11, modelLatticeManager as modelLatticeManager2 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice10, modelLatticeManager as modelLatticeManager2 } from "@axiom-lattice/core";
 import { LatticeEvalProject } from "@axiom-lattice/agent-eval";
-import { v4 as uuidv42 } from "uuid";
+import { v4 as uuidv43 } from "uuid";
 function mapLogs(logs) {
   return logs.map((l) => ({
     timestamp: l.ts,
@@ -5036,7 +5059,7 @@ var EvalRunner = class {
         }))
       });
     }
-    const runId = uuidv42();
+    const runId = uuidv43();
     const concurrency = project.concurrency || 3;
     await store.createRun(tenantId, projectId, runId, { totalCases, concurrency });
     const judgeCfg = project.judgeModelConfig;
@@ -5078,7 +5101,7 @@ var EvalRunner = class {
       else stats.failed++;
       stats.totalScore += score;
       const completedCount = stats.passed + stats.failed;
-      await store.createRunResult(tenantId, runId, uuidv42(), {
+      await store.createRunResult(tenantId, runId, uuidv43(), {
         suiteName,
         caseId: result.caseId,
         pass: passed,
@@ -5158,7 +5181,7 @@ var EvalRunner = class {
     return this.runs.has(runId);
   }
   getEvalStore() {
-    return getStoreLattice11("default", "eval").store;
+    return getStoreLattice10("default", "eval").store;
   }
 };
 var evalRunner = new EvalRunner();
@@ -5172,13 +5195,13 @@ function getTenantId12(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 function getEvalStore() {
-  return getStoreLattice12("default", "eval").store;
+  return getStoreLattice11("default", "eval").store;
 }
 async function createProject(request, reply) {
   try {
     const tenantId = getTenantId12(request);
     const store = getEvalStore();
-    const id = uuidv43();
+    const id = uuidv44();
     const data = request.body;
     const project = await store.createProject(tenantId, id, {
       name: data.name,
@@ -5212,7 +5235,7 @@ async function listProjects(request, reply) {
         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(), {
+        await store.createProject(tenantId, uuidv44(), {
           name: "Default",
           description: "Built-in project for testing eval against this server",
           judgeModelConfig: judgeModel,
@@ -5301,7 +5324,7 @@ async function createSuite(request, reply) {
     if (!project) {
       return reply.status(404).send({ success: false, message: "Project not found" });
     }
-    const id = uuidv43();
+    const id = uuidv44();
     const data = request.body;
     const suite = await store.createSuite(tenantId, pid, id, { name: data.name });
     return reply.status(201).send({
@@ -5362,7 +5385,7 @@ async function createCase(request, reply) {
     if (!suite) {
       return reply.status(404).send({ success: false, message: "Suite not found" });
     }
-    const id = uuidv43();
+    const id = uuidv44();
     const data = request.body;
     const created = await store.createCase(tenantId, sid, id, {
       inputMessage: data.inputMessage,
@@ -5558,11 +5581,11 @@ data: ${JSON.stringify(event.data)}
 }
 
 // src/controllers/users.ts
-import { getStoreLattice as getStoreLattice13 } from "@axiom-lattice/core";
-import { v4 as uuidv44 } from "uuid";
+import { getStoreLattice as getStoreLattice12 } from "@axiom-lattice/core";
+import { v4 as uuidv45 } from "uuid";
 var UsersController = class {
   constructor() {
-    this.userStore = getStoreLattice13("default", "user").store;
+    this.userStore = getStoreLattice12("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -5575,7 +5598,7 @@ var UsersController = class {
   }
   async createUser(request, reply) {
     const data = request.body;
-    const id = uuidv44();
+    const id = uuidv45();
     const existingUser = await this.userStore.getUserByEmail(data.email);
     if (existingUser) {
       return reply.status(409).send({
@@ -5640,11 +5663,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-import { getStoreLattice as getStoreLattice14 } from "@axiom-lattice/core";
-import { v4 as uuidv45 } from "uuid";
+import { getStoreLattice as getStoreLattice13 } from "@axiom-lattice/core";
+import { v4 as uuidv46 } from "uuid";
 var TenantsController = class {
   constructor() {
-    this.tenantStore = getStoreLattice14("default", "tenant").store;
+    this.tenantStore = getStoreLattice13("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -5653,7 +5676,7 @@ var TenantsController = class {
   }
   async createTenant(request, reply) {
     const data = request.body;
-    const id = uuidv45();
+    const id = uuidv46();
     const tenant = await this.tenantStore.createTenant(id, data);
     return reply.status(201).send({ success: true, data: tenant });
   }
@@ -5708,8 +5731,8 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-import { getStoreLattice as getStoreLattice15 } from "@axiom-lattice/core";
-import { v4 as uuidv46 } from "uuid";
+import { getStoreLattice as getStoreLattice14 } from "@axiom-lattice/core";
+import { v4 as uuidv47 } from "uuid";
 var defaultAuthConfig = {
   autoApproveUsers: true,
   allowTenantRegistration: true,
@@ -5717,9 +5740,9 @@ var defaultAuthConfig = {
 };
 var AuthController = class {
   constructor(config = {}) {
-    this.userStore = getStoreLattice15("default", "user").store;
-    this.tenantStore = getStoreLattice15("default", "tenant").store;
-    this.userTenantLinkStore = getStoreLattice15("default", "userTenantLink").store;
+    this.userStore = getStoreLattice14("default", "user").store;
+    this.tenantStore = getStoreLattice14("default", "tenant").store;
+    this.userTenantLinkStore = getStoreLattice14("default", "userTenantLink").store;
     this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
@@ -5732,7 +5755,7 @@ var AuthController = class {
           error: "User with this email already exists"
         });
       }
-      const userId = uuidv46();
+      const userId = uuidv47();
       const userStatus = this.config.autoApproveUsers ? "active" : "pending";
       const userData = {
         email,
@@ -5875,6 +5898,18 @@ var AuthController = class {
       const token = await this.generateToken(userId, tenantId);
       const link = await this.userTenantLinkStore.getLink(userId, tenantId);
       const linkMeta = link?.metadata || {};
+      let personalAssistant = null;
+      if (linkMeta.personalAssistantId) {
+        const assistantStore = getStoreLattice14("default", "assistant").store;
+        const exists = await assistantStore.hasAssistant(tenantId, linkMeta.personalAssistantId);
+        if (exists) {
+          personalAssistant = {
+            assistantId: linkMeta.personalAssistantId,
+            projectId: linkMeta.personalProjectId || "default",
+            workspaceId: linkMeta.personalWorkspaceId || "default"
+          };
+        }
+      }
       return {
         success: true,
         data: {
@@ -5884,11 +5919,7 @@ var AuthController = class {
             status: tenant.status
           },
           token,
-          personalAssistant: linkMeta.personalAssistantId ? {
-            assistantId: linkMeta.personalAssistantId,
-            projectId: linkMeta.personalProjectId || "default",
-            workspaceId: linkMeta.personalWorkspaceId || "default"
-          } : null
+          personalAssistant
         }
       };
     } catch (error) {
@@ -6416,7 +6447,7 @@ function registerChannelRoutes(app2, dependencies) {
 }
 
 // src/controllers/channel-installations.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var _adapterRegistry;
 var _router;
 function setChannelControllerDeps(deps) {
@@ -6431,8 +6462,8 @@ function getTenantId13(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getInstallationStore() {
-  const { getStoreLattice: getStoreLattice18 } = await import("@axiom-lattice/core");
-  const store = getStoreLattice18("default", "channelInstallation").store;
+  const { getStoreLattice: getStoreLattice17 } = await import("@axiom-lattice/core");
+  const store = getStoreLattice17("default", "channelInstallation").store;
   if (store) return store;
   const { PostgreSQLChannelInstallationStore } = await import("@axiom-lattice/pg-stores");
   const databaseUrl = process.env.DATABASE_URL;
@@ -6538,7 +6569,7 @@ async function createChannelInstallation(request, reply) {
       }
     }
     const store = await getInstallationStore();
-    const installationId = body.id || randomUUID7();
+    const installationId = body.id || randomUUID6();
     const installation = await store.createInstallation(
       tenantId,
       installationId,
@@ -7202,6 +7233,18 @@ var registerLatticeRoutes = (app2, channelDeps) => {
     "/api/skills/filter/license",
     filterSkillsByLicense
   );
+  app2.get("/api/collections", getCollectionList);
+  app2.get("/api/collections/:name", getCollection);
+  app2.post("/api/collections", createCollection);
+  app2.put("/api/collections/:name", updateCollection);
+  app2.delete("/api/collections/:name", deleteCollection);
+  app2.get("/api/embeddings", listEmbeddings);
+  app2.get("/api/collections/:name/entries", listEntries);
+  app2.post("/api/collections/:name/entries", createEntry);
+  app2.get("/api/collections/:name/entries/:id", getEntry);
+  app2.put("/api/collections/:name/entries/:id", updateEntry);
+  app2.delete("/api/collections/:name/entries/:id", deleteEntry);
+  app2.post("/api/collections/:name/search", searchEntries);
   registerSandboxProxyRoutes(app2);
   registerEvalRoutes(app2);
   registerWorkspaceRoutes(app2);
@@ -7317,10 +7360,10 @@ function registerResourceRoutes(app2, controller) {
 
 // src/router/MessageRouter.ts
 import {
-  getStoreLattice as getStoreLattice16,
+  getStoreLattice as getStoreLattice15,
   agentInstanceManager as agentInstanceManager6
 } from "@axiom-lattice/core";
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 var BindingNotFoundError = class extends Error {
   constructor(message) {
     super(message);
@@ -7480,7 +7523,7 @@ var MessageRouter = class {
             channel: message.channel,
             adapterChannel: adapter.channel
           }, "Thread resolved by adapter strategy");
-          const threadStore = getStoreLattice16("default", "thread").store;
+          const threadStore = getStoreLattice15("default", "thread").store;
           try {
             await threadStore.createThread(
               tenantId,
@@ -7517,8 +7560,8 @@ var MessageRouter = class {
           }
         }
         if (!threadId) {
-          const threadStore = getStoreLattice16("default", "thread").store;
-          const newThreadId = randomUUID8();
+          const threadStore = getStoreLattice15("default", "thread").store;
+          const newThreadId = randomUUID7();
           console.log({
             event: "dispatch:thread:create",
             agentId,
@@ -8123,10 +8166,11 @@ import {
   getLoggerLattice,
   loggerLatticeManager,
   sandboxLatticeManager as sandboxLatticeManager2,
-  getStoreLattice as getStoreLattice17,
+  getStoreLattice as getStoreLattice16,
   agentInstanceManager as agentInstanceManager8,
   createSandboxProvider,
-  TokenCache
+  TokenCache,
+  mcpManager
 } from "@axiom-lattice/core";
 import {
   LoggerType
@@ -8187,7 +8231,7 @@ app.addHook("preHandler", async (request, reply) => {
   if (PUBLIC_ROUTES.some((r) => request.url === r)) return;
   if (request.url.startsWith("/s/")) return;
   const urlPath = request.url.split("?")[0];
-  if (urlPath.includes("/viewfile") || urlPath.includes("/downloadfile")) return;
+  if (urlPath.includes("/viewfile") || urlPath.includes("/downloadfile") || urlPath.includes("/uploadfile")) return;
   return reply.status(401).send({
     success: false,
     error: "Unauthorized - Missing or invalid token"
@@ -8274,6 +8318,41 @@ function getConfiguredSandboxProvider() {
     daytonaVolumeName: process.env.DAYTONA_VOLUME_NAME
   });
 }
+async function restoreMcpConnections() {
+  try {
+    const storeLattice = getStoreLattice16("default", "mcp");
+    const store = storeLattice.store;
+    if (!store) {
+      logger4.info("MCP store not configured, skipping connection restoration");
+      return;
+    }
+    const configs = await store.getAllConfigs("default");
+    const connectedConfigs = configs.filter((c) => c.status === "connected");
+    if (connectedConfigs.length === 0) return;
+    logger4.info(`Restoring ${connectedConfigs.length} MCP server connections...`);
+    const { convertToConnection } = await import("./mcp-configs-SHRMQHIL.mjs");
+    for (const config of connectedConfigs) {
+      try {
+        const connection = convertToConnection(config.config);
+        mcpManager.addServer(config.key, connection);
+      } catch (err) {
+        logger4.warn(`Failed to prepare MCP server "${config.key}" for restoration`, { error: err });
+      }
+    }
+    await mcpManager.connect();
+    for (const config of connectedConfigs) {
+      try {
+        await mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
+        logger4.info(`MCP server "${config.key}" restored with ${config.selectedTools.length} tools`);
+      } catch (err) {
+        logger4.warn(`Failed to register tools for MCP server "${config.key}"`, { error: err });
+      }
+    }
+    logger4.info(`MCP connection restoration complete: ${connectedConfigs.length} servers`);
+  } catch (err) {
+    logger4.error("MCP connection restoration failed", { error: err });
+  }
+}
 var start = async (config) => {
   try {
     if (config?.loggerConfig) {
@@ -8322,7 +8401,7 @@ var start = async (config) => {
       });
     }
     try {
-      const menuStore = getStoreLattice17("default", "menu").store;
+      const menuStore = getStoreLattice16("default", "menu").store;
       setMenuRegistry(menuStore);
       logger4.info("Menu registry initialized");
     } catch {
@@ -8336,8 +8415,8 @@ var start = async (config) => {
       logger4.info("Registered sandbox manager from env configuration");
     }
     try {
-      const { ResourceController } = await import("./resources-HEVGN3JM.mjs");
-      const sharedResourceStore = getStoreLattice17("default", "sharedResource").store;
+      const { ResourceController } = await import("./resources-P4XF764M.mjs");
+      const sharedResourceStore = getStoreLattice16("default", "sharedResource").store;
       const cache = new TokenCache();
       const resourceController = new ResourceController({
         store: sharedResourceStore,
@@ -8386,6 +8465,9 @@ var start = async (config) => {
     }).catch((error) => {
       logger4.error("Agent recovery failed", { error });
     });
+    restoreMcpConnections().catch((error) => {
+      logger4.error("MCP connection restoration failed", { error });
+    });
   } catch (err) {
     logger4.error("Server start failed", { error: err });
     process.exit(1);