@axiom-lattice/gateway 9.0.0 → 10.0.0

package/dist/index.js

@@ -651,6 +651,7 @@ async function saveProjectFile(params) {
     }
     workspaceId = project.workspaceId;
   }
+  if (!workspaceId) throw new Error("Workspace not found");
   const workspace = await workspaceStore.getWorkspaceById(
     params.tenantId,
     workspaceId
@@ -8308,9 +8309,19 @@ var init_openRateLimiter = __esm({
 });
 
 // src/services/open/openMcpServer.ts
-async function buildSessionServer(options) {
+function isStandardSchemaWithJson(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const standard = value["~standard"];
+  return typeof standard === "object" && standard !== null && "jsonSchema" in standard;
+}
+function toStandardSchema(schema2) {
+  if (isStandardSchemaWithJson(schema2)) return schema2;
+  const zodSchema = schema2 instanceof import_zod22.z.ZodType ? schema2 : import_zod22.z.object(schema2);
+  return zodSchema;
+}
+async function createSessionServer(options) {
   const { catalog, invoke, uiResources } = options;
-  const server = new import_mcp.McpServer(OPEN_MCP_SERVER_INFO, {
+  const server = new import_server5.McpServer(OPEN_MCP_SERVER_INFO, {
     capabilities: {
       // The SDK has no `extensions` field; MCP App hosts discover the UI
       // extension through `experimental`.
@@ -8322,7 +8333,7 @@ async function buildSessionServer(options) {
       tool.toolName,
       {
         description: tool.description,
-        inputSchema: tool.schema,
+        inputSchema: toStandardSchema(tool.schema),
         annotations: {
           readOnlyHint: tool.annotations.readOnlyHint,
           destructiveHint: tool.annotations.destructiveHint
@@ -8359,18 +8370,23 @@ async function buildSessionServer(options) {
       }
     );
   }
-  const transport = new import_streamableHttp.StreamableHTTPServerTransport({
+  return { server, tools: catalog };
+}
+async function buildSessionServer(options) {
+  const { server, tools } = await createSessionServer(options);
+  const transport = new import_node.NodeStreamableHTTPServerTransport({
     sessionIdGenerator: void 0,
     enableJsonResponse: true
   });
-  return { server, transport, tools: catalog };
+  return { server, transport, tools };
 }
-var import_mcp, import_streamableHttp, OPEN_MCP_SERVER_INFO;
+var import_node, import_server5, import_zod22, OPEN_MCP_SERVER_INFO;
 var init_openMcpServer = __esm({
   "src/services/open/openMcpServer.ts"() {
     "use strict";
-    import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-    import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    import_node = require("@modelcontextprotocol/node");
+    import_server5 = require("@modelcontextprotocol/server");
+    import_zod22 = require("zod");
     OPEN_MCP_SERVER_INFO = {
       name: "axiom-open",
       version: "0.1.0"
@@ -8380,7 +8396,7 @@ var init_openMcpServer = __esm({
 
 // src/services/open/pluginExposeAdapter.ts
 function schemaOf(tool) {
-  return tool.lc_kwargs?.schema ?? tool.schema ?? import_zod22.z.object({}).passthrough();
+  return tool.lc_kwargs?.schema ?? tool.schema ?? import_zod23.z.object({}).passthrough();
 }
 function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -8482,11 +8498,11 @@ function createPluginProvider(domain, tools, options = {}) {
     }
   };
 }
-var import_zod22;
+var import_zod23;
 var init_pluginExposeAdapter = __esm({
   "src/services/open/pluginExposeAdapter.ts"() {
     "use strict";
-    import_zod22 = require("zod");
+    import_zod23 = require("zod");
     init_openLattice();
   }
 });
@@ -8830,7 +8846,7 @@ function registerOpenRoutes(app2, deps = {}) {
     reply.header(import_protocols45.REPLICA_HEADER, replica);
     reply.raw.setHeader(import_protocols45.REPLICA_HEADER, replica);
   };
-  const buildServerFor = async (context, log2) => {
+  const buildSessionOptions = async (context, log2) => {
     const grants = grantsSource(context);
     const catalog = await openLattice.catalogFor(grants, { tenantId: context.tenantId });
     const globalToolNames = new Set(catalog.map((t2) => t2.toolName));
@@ -8856,7 +8872,7 @@ function registerOpenRoutes(app2, deps = {}) {
       ...collectExposedPluginUiResources(grants),
       ...tenant2.uiResources
     ]);
-    const built = await buildSessionServer({
+    return {
       credential: { credentialId: context.credentialId, kind: context.kind },
       grants,
       catalog: mergedCatalog,
@@ -8963,8 +8979,7 @@ function registerOpenRoutes(app2, deps = {}) {
           );
         }
       }
-    });
-    return built;
+    };
   };
   const handleOpenMcpPost = async (request, reply) => {
     markReplica(reply);
@@ -8972,15 +8987,42 @@ function registerOpenRoutes(app2, deps = {}) {
     if (!context) {
       return reply.status(401).send({ error: "AUTH_FAILED" });
     }
-    const built = await buildServerFor(context, request.log);
-    await built.server.connect(built.transport);
+    const modern = (0, import_server6.createMcpHandler)(
+      async () => (await createSessionServer(
+        await buildSessionOptions(context, request.log)
+      )).server,
+      {
+        legacy: "reject",
+        onerror: (error) => {
+          request.log.warn({ err: error }, "open mcp: handler error");
+        }
+      }
+    );
+    const nodeHandler = (0, import_node2.toNodeHandler)(modern, {
+      onerror: (error) => {
+        request.log.warn({ err: error }, "open mcp: transport error");
+      }
+    });
     reply.hijack();
+    const webRequest = await (0, import_node2.toWebRequest)(request.raw, request.body);
+    if (await (0, import_server6.isLegacyRequest)(webRequest, request.body)) {
+      const built = await buildSessionServer(
+        await buildSessionOptions(context, request.log)
+      );
+      await built.server.connect(built.transport);
+      const close2 = () => {
+        void built.transport.close().catch(() => void 0);
+        void built.server.close().catch(() => void 0);
+      };
+      reply.raw.once("close", close2);
+      await built.transport.handleRequest(request.raw, reply.raw, request.body);
+      return;
+    }
     const close = () => {
-      void built.transport.close().catch(() => void 0);
-      void built.server.close().catch(() => void 0);
+      void modern.close().catch(() => void 0);
     };
     reply.raw.once("close", close);
-    await built.transport.handleRequest(request.raw, reply.raw, request.body);
+    await nodeHandler(request.raw, reply.raw, request.body);
   };
   const methodNotAllowed = async (_request, reply) => {
     reply.header("Allow", "POST");
@@ -8997,7 +9039,7 @@ function registerOpenRoutes(app2, deps = {}) {
   app2.delete("/mcp", methodNotAllowed);
   app2.delete("/mcp/", methodNotAllowed);
 }
-var import_core113, import_protocols45, RPC_ERROR;
+var import_core113, import_protocols45, import_server6, import_node2, RPC_ERROR;
 var init_open = __esm({
   "src/routes/open.ts"() {
     "use strict";
@@ -9007,6 +9049,8 @@ var init_open = __esm({
     init_openAuditService();
     init_openRateLimiter();
     init_openLattice();
+    import_server6 = require("@modelcontextprotocol/server");
+    import_node2 = require("@modelcontextprotocol/node");
     init_openMcpServer();
     init_registerExposedPlugins();
     init_tenantOpenPlugins();
@@ -9231,21 +9275,21 @@ function createOpenSandboxProvider() {
         name: "files_read",
         label: "Read files",
         description: "Read a file from the project sandbox.",
-        schema: { path: import_zod23.z.string().min(1) },
+        schema: { path: import_zod24.z.string().min(1) },
         annotations: { readOnlyHint: true, destructiveHint: false }
       },
       {
         name: "files_list",
         label: "List files",
         description: "List files under a directory in the project sandbox.",
-        schema: { path: import_zod23.z.string(), recursive: import_zod23.z.boolean().optional() },
+        schema: { path: import_zod24.z.string(), recursive: import_zod24.z.boolean().optional() },
         annotations: { readOnlyHint: true, destructiveHint: false }
       },
       {
         name: "files_write",
         label: "Write files",
         description: "Write content to a file in the project sandbox.",
-        schema: { path: import_zod23.z.string().min(1), content: import_zod23.z.string() },
+        schema: { path: import_zod24.z.string().min(1), content: import_zod24.z.string() },
         annotations: { readOnlyHint: false, destructiveHint: true }
       },
       {
@@ -9253,9 +9297,9 @@ function createOpenSandboxProvider() {
         label: "Run shell commands",
         description: "Execute a shell command in the project sandbox. Returns stdout (up to 64KB) and exit code.",
         schema: {
-          command: import_zod23.z.string().min(1),
-          exec_dir: import_zod23.z.string().optional(),
-          timeout: import_zod23.z.number().int().min(1e3).optional()
+          command: import_zod24.z.string().min(1),
+          exec_dir: import_zod24.z.string().optional(),
+          timeout: import_zod24.z.number().int().min(1e3).optional()
         },
         annotations: { readOnlyHint: false, destructiveHint: true }
       }
@@ -9310,11 +9354,11 @@ ${truncated}`
     }
   };
 }
-var import_zod23, import_core117, MAX_OUTPUT_BYTES;
+var import_zod24, import_core117, MAX_OUTPUT_BYTES;
 var init_sandboxProvider = __esm({
   "src/services/open/providers/sandboxProvider.ts"() {
     "use strict";
-    import_zod23 = require("zod");
+    import_zod24 = require("zod");
     import_core117 = require("@axiom-lattice/core");
     MAX_OUTPUT_BYTES = 64e3;
   }
@@ -9623,9 +9667,9 @@ function createKbProvider(collectionService3) {
         label: "Search collections",
         description: "Search a knowledge base collection. Returns matched entries with content, metadata and similarity score.",
         schema: {
-          collection: import_zod24.z.string().min(1),
-          query: import_zod24.z.string().min(1),
-          limit: import_zod24.z.number().int().min(1).max(50).optional()
+          collection: import_zod25.z.string().min(1),
+          query: import_zod25.z.string().min(1),
+          limit: import_zod25.z.number().int().min(1).max(50).optional()
         },
         annotations: { readOnlyHint: true, destructiveHint: false }
       }
@@ -9653,11 +9697,11 @@ function createKbProvider(collectionService3) {
     }
   };
 }
-var import_zod24;
+var import_zod25;
 var init_kbProvider = __esm({
   "src/services/open/providers/kbProvider.ts"() {
     "use strict";
-    import_zod24 = require("zod");
+    import_zod25 = require("zod");
   }
 });
 
@@ -9695,7 +9739,7 @@ function createAgentProvider(deps = {}) {
             toolName: `invoke_${assistantId}`,
             label: name,
             description: `Invoke the "${name}" agent${description ? ` \u2014 ${description}` : ""}. Returns its final reply.`,
-            schema: { message: import_zod25.z.string().min(1) },
+            schema: { message: import_zod26.z.string().min(1) },
             annotations: { readOnlyHint: false, destructiveHint: false }
           };
         })
@@ -9743,11 +9787,11 @@ function createAgentProvider(deps = {}) {
     }
   };
 }
-var import_zod25, import_core121, import_protocols47, STOP_TYPES;
+var import_zod26, import_core121, import_protocols47, STOP_TYPES;
 var init_agentProvider = __esm({
   "src/services/open/providers/agentProvider.ts"() {
     "use strict";
-    import_zod25 = require("zod");
+    import_zod26 = require("zod");
     import_core121 = require("@axiom-lattice/core");
     import_protocols47 = require("@axiom-lattice/protocols");
     STOP_TYPES = [import_protocols47.MessageChunkTypes.MESSAGE_COMPLETED];
@@ -14407,7 +14451,10 @@ function createRunLifecycleHandlers(deps = {}) {
     const tenantId = getTenantId4(request);
     const { assistantId, threadId } = request.params;
     if (!await ownsThread(tenantId, assistantId, threadId)) {
-      return notFound2(reply, THREAD_NOT_FOUND2, "Thread not found");
+      if (!await isNewThread(tenantId, threadId)) {
+        return notFound2(reply, THREAD_NOT_FOUND2, "Thread not found");
+      }
+      return reply.status(200).send({ success: true, data: { runs: [] } });
     }
     const activeOnly = request.query.active === "true" || request.query.active === "1";
     const source = request.query.source;
@@ -23447,11 +23494,11 @@ var createBody = import_zod2.z.object({
   key: import_zod2.z.string().min(1),
   name: import_zod2.z.string().min(1),
   description: import_zod2.z.string().optional(),
-  config: import_zod2.z.record(import_zod2.z.unknown())
+  config: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown())
 });
 var testOrDiscoverBody = import_zod2.z.object({
   key: import_zod2.z.string().optional(),
-  config: import_zod2.z.record(import_zod2.z.unknown()).optional()
+  config: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
 });
 function getTenant(request) {
   const userTenantId = request.user?.tenantId;
@@ -23548,7 +23595,7 @@ function connectionRoutes(fastify2) {
         return reply.status(400).send(err);
       }
       if (err instanceof import_zod2.z.ZodError) {
-        return reply.status(400).send({ error: err.errors });
+        return reply.status(400).send({ error: err.issues });
       }
       return reply.status(500).send({
         ok: false,
@@ -23576,7 +23623,7 @@ function connectionRoutes(fastify2) {
         return reply.status(400).send(err);
       }
       if (err instanceof import_zod2.z.ZodError) {
-        return reply.status(400).send({ error: err.errors });
+        return reply.status(400).send({ error: err.issues });
       }
       return reply.status(500).send({
         error: err instanceof Error ? err.message : String(err)
@@ -23868,13 +23915,17 @@ async function testMcpServerConnection(request, reply) {
     try {
       const testKey = `__test_${key}_${Date.now()}`;
       const connection = (0, import_core49.convertToConnection)(config.config);
-      const { latency } = await import_core49.McpLatticeManager.testConnection(testKey, connection);
+      const { latency, protocolVersion } = await import_core49.McpLatticeManager.testConnection(
+        testKey,
+        connection
+      );
       return {
         success: true,
         message: "Connection test successful",
         data: {
           connected: true,
-          latency
+          latency,
+          ...protocolVersion ? { protocolVersion } : {}
         }
       };
     } catch (error) {
@@ -31535,7 +31586,7 @@ var createSchema = import_zod9.z.object({ name: import_zod9.z.string(), descript
 var updateSchema = createSchema.partial().extend({ expectedUpdatedAt: import_zod9.z.string().optional() });
 var bundleIdSchema = import_zod9.z.string().uuid();
 var bundleParamsSchema = import_zod9.z.object({ bundleId: bundleIdSchema });
-var projectSchema = import_zod9.z.object({ bundleIds: import_zod9.z.array(bundleIdSchema), expectedRevisions: import_zod9.z.record(import_zod9.z.string()).optional() }).strict();
+var projectSchema = import_zod9.z.object({ bundleIds: import_zod9.z.array(bundleIdSchema), expectedRevisions: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.string()).optional() }).strict();
 function tenant(request, authRequired2) {
   const authenticated = request.user?.tenantId;
   const header2 = request.headers["x-tenant-id"];