waypoi 0.0.0

package/src/routes/mcp.ts

@@ -0,0 +1,320 @@
+import { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
+import { StoragePaths } from "../storage/files";
+import { appConfig } from "../config";
+import {
+  listMcpServers,
+  getMcpServer,
+  addMcpServer,
+  updateMcpServer,
+  removeMcpServer,
+} from "../mcp/registry";
+import {
+  discoverAllTools,
+  discoverServerTools,
+  discoverBuiltinTools,
+  getBuiltinVirtualServer,
+  getCachedTools,
+  getCachedToolsForServer,
+  executeTool,
+  disconnectServer,
+  isServerConnected,
+  BUILTIN_SERVER_ID,
+} from "../mcp/discovery";
+
+/**
+ * MCP Routes
+ * 
+ * Admin API for managing MCP servers and tools.
+ * 
+ * Endpoints:
+ *   GET    /admin/mcp/servers           - List all MCP servers
+ *   POST   /admin/mcp/servers           - Add a new MCP server
+ *   GET    /admin/mcp/servers/:id       - Get server by ID
+ *   PUT    /admin/mcp/servers/:id       - Update server
+ *   DELETE /admin/mcp/servers/:id       - Remove server
+ *   POST   /admin/mcp/servers/:id/connect    - Connect and discover tools
+ *   POST   /admin/mcp/servers/:id/disconnect - Disconnect from server
+ * 
+ *   GET    /admin/mcp/tools             - List all discovered tools
+ *   POST   /admin/mcp/tools/discover    - Discover tools from all servers
+ *   POST   /admin/mcp/tools/execute     - Execute a tool
+ */
+
+export async function registerMcpRoutes(
+  app: FastifyInstance,
+  paths: StoragePaths
+): Promise<void> {
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Server management
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  app.get("/admin/mcp/servers", async (_req: FastifyRequest, reply: FastifyReply) => {
+    try {
+      const servers = await listMcpServers(paths);
+      const builtin = getBuiltinVirtualServer();
+      return reply.send({
+        object: "list",
+        data: [
+          ...(builtin ? [builtin] : []),
+          ...servers.map((s) => ({
+            ...s,
+            connected: isServerConnected(s.id),
+          })),
+        ],
+      });
+    } catch (error) {
+      app.log.error(error, "Failed to list MCP servers");
+      return reply.status(500).send({
+        error: { message: "Failed to list servers", type: "internal_error" },
+      });
+    }
+  });
+
+  app.post(
+    "/admin/mcp/servers",
+    async (
+      req: FastifyRequest<{ Body: { name: string; url: string; enabled?: boolean } }>,
+      reply: FastifyReply
+    ) => {
+      try {
+        if (!req.body?.name || !req.body?.url) {
+          return reply.status(400).send({
+            error: { message: "name and url are required", type: "invalid_request" },
+          });
+        }
+
+        const server = await addMcpServer(paths, req.body);
+        return reply.status(201).send(server);
+      } catch (error) {
+        if ((error as Error).message.includes("already exists")) {
+          return reply.status(409).send({
+            error: { message: (error as Error).message, type: "conflict" },
+          });
+        }
+        app.log.error(error, "Failed to add MCP server");
+        return reply.status(500).send({
+          error: { message: "Failed to add server", type: "internal_error" },
+        });
+      }
+    }
+  );
+
+  app.get(
+    "/admin/mcp/servers/:id",
+    async (req: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) => {
+      try {
+        if (req.params.id === BUILTIN_SERVER_ID) {
+          const builtin = getBuiltinVirtualServer();
+          if (!builtin) {
+            return reply.status(404).send({
+              error: { message: "Built-in server not yet initialized", type: "not_found" },
+            });
+          }
+          return reply.send({
+            ...builtin,
+            tools: getCachedToolsForServer(BUILTIN_SERVER_ID),
+          });
+        }
+
+        const server = await getMcpServer(paths, req.params.id);
+        if (!server) {
+          return reply.status(404).send({
+            error: { message: "Server not found", type: "not_found" },
+          });
+        }
+        return reply.send({
+          ...server,
+          connected: isServerConnected(server.id),
+          tools: getCachedToolsForServer(server.id),
+        });
+      } catch (error) {
+        app.log.error(error, "Failed to get MCP server");
+        return reply.status(500).send({
+          error: { message: "Failed to get server", type: "internal_error" },
+        });
+      }
+    }
+  );
+
+  app.put(
+    "/admin/mcp/servers/:id",
+    async (
+      req: FastifyRequest<{
+        Params: { id: string };
+        Body: { name?: string; url?: string; enabled?: boolean };
+      }>,
+      reply: FastifyReply
+    ) => {
+      try {
+        const server = await updateMcpServer(paths, req.params.id, req.body || {});
+        if (!server) {
+          return reply.status(404).send({
+            error: { message: "Server not found", type: "not_found" },
+          });
+        }
+        return reply.send(server);
+      } catch (error) {
+        app.log.error(error, "Failed to update MCP server");
+        return reply.status(500).send({
+          error: { message: "Failed to update server", type: "internal_error" },
+        });
+      }
+    }
+  );
+
+  app.delete(
+    "/admin/mcp/servers/:id",
+    async (req: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) => {
+      try {
+        if (req.params.id === BUILTIN_SERVER_ID) {
+          return reply.status(403).send({
+            error: { message: "Cannot delete the built-in waypoi server", type: "forbidden" },
+          });
+        }
+
+        // Disconnect first
+        await disconnectServer(req.params.id);
+
+        const deleted = await removeMcpServer(paths, req.params.id);
+        if (!deleted) {
+          return reply.status(404).send({
+            error: { message: "Server not found", type: "not_found" },
+          });
+        }
+        return reply.status(204).send();
+      } catch (error) {
+        app.log.error(error, "Failed to remove MCP server");
+        return reply.status(500).send({
+          error: { message: "Failed to remove server", type: "internal_error" },
+        });
+      }
+    }
+  );
+
+  app.post(
+    "/admin/mcp/servers/:id/connect",
+    async (req: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) => {
+      try {
+        if (req.params.id === BUILTIN_SERVER_ID) {
+          const port = appConfig.port;
+          const tools = await discoverBuiltinTools(paths, `http://localhost:${port}/mcp`);
+          return reply.send({
+            connected: true,
+            toolCount: tools.length,
+            tools: tools.map((t) => ({ name: t.name, description: t.description })),
+          });
+        }
+
+        const server = await getMcpServer(paths, req.params.id);
+        if (!server) {
+          return reply.status(404).send({
+            error: { message: "Server not found", type: "not_found" },
+          });
+        }
+
+        const tools = await discoverServerTools(paths, server);
+        return reply.send({
+          connected: true,
+          toolCount: tools.length,
+          tools: tools.map((t) => ({ name: t.name, description: t.description })),
+        });
+      } catch (error) {
+        app.log.error(error, "Failed to connect to MCP server");
+        return reply.status(500).send({
+          error: { message: "Failed to connect", type: "connection_error" },
+        });
+      }
+    }
+  );
+
+  app.post(
+    "/admin/mcp/servers/:id/disconnect",
+    async (req: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) => {
+      try {
+        if (req.params.id === BUILTIN_SERVER_ID) {
+          return reply.status(403).send({
+            error: { message: "Cannot disconnect the built-in waypoi server", type: "forbidden" },
+          });
+        }
+        await disconnectServer(req.params.id);
+        return reply.send({ disconnected: true });
+      } catch (error) {
+        app.log.error(error, "Failed to disconnect from MCP server");
+        return reply.status(500).send({
+          error: { message: "Failed to disconnect", type: "internal_error" },
+        });
+      }
+    }
+  );
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Tool management
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  app.get("/admin/mcp/tools", async (_req: FastifyRequest, reply: FastifyReply) => {
+    try {
+      const tools = getCachedTools();
+      return reply.send({
+        object: "list",
+        data: tools,
+      });
+    } catch (error) {
+      app.log.error(error, "Failed to list tools");
+      return reply.status(500).send({
+        error: { message: "Failed to list tools", type: "internal_error" },
+      });
+    }
+  });
+
+  app.post("/admin/mcp/tools/discover", async (_req: FastifyRequest, reply: FastifyReply) => {
+    try {
+      const tools = await discoverAllTools(paths);
+      return reply.send({
+        discovered: tools.length,
+        tools: tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          serverName: t.serverName,
+        })),
+      });
+    } catch (error) {
+      app.log.error(error, "Failed to discover tools");
+      return reply.status(500).send({
+        error: { message: "Failed to discover tools", type: "internal_error" },
+      });
+    }
+  });
+
+  app.post(
+    "/admin/mcp/tools/execute",
+    async (
+      req: FastifyRequest<{ Body: { name: string; arguments: Record<string, unknown> } }>,
+      reply: FastifyReply
+    ) => {
+      try {
+        if (!req.body?.name) {
+          return reply.status(400).send({
+            error: { message: "Tool name is required", type: "invalid_request" },
+          });
+        }
+
+        const result = await executeTool(req.body.name, req.body.arguments ?? {});
+        
+        if (result.isError) {
+          return reply.status(500).send({
+            error: { message: result.content, type: "tool_error" },
+          });
+        }
+
+        return reply.send({
+          result: result.content,
+        });
+      } catch (error) {
+        app.log.error(error, "Failed to execute tool");
+        return reply.status(500).send({
+          error: { message: "Failed to execute tool", type: "internal_error" },
+        });
+      }
+    }
+  );
+}

package/src/routes/mcpService.ts

@@ -0,0 +1,114 @@
+import { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
+import { StoragePaths } from "../storage/files";
+import {
+  createMcpService,
+  McpService,
+  McpServiceDependencyOverrides,
+} from "../mcp/service";
+
+let activeMcpService: McpService | null = null;
+
+export async function registerMcpServiceRoutes(
+  app: FastifyInstance,
+  paths: StoragePaths,
+  deps?: McpServiceDependencyOverrides
+): Promise<void> {
+  const mcpService = createMcpService(paths, deps);
+  activeMcpService = mcpService;
+
+  app.route({
+    method: ["GET", "POST", "DELETE"],
+    url: "/mcp",
+    handler: async (req: FastifyRequest, reply: FastifyReply) => {
+      if (!isLocalRequest(req)) {
+        reply.code(403).send({
+          error: {
+            message: "Forbidden: /mcp is restricted to localhost",
+            type: "forbidden",
+          },
+        });
+        return;
+      }
+
+      if (req.method === "GET") {
+        reply.code(405).header("Allow", "POST, DELETE").send("Method Not Allowed");
+        return;
+      }
+
+      await mcpService.handleRequest(req.raw, reply.raw, req.body);
+      reply.hijack();
+    },
+  });
+}
+
+export async function closeMcpServiceRoutes(): Promise<void> {
+  if (!activeMcpService) {
+    return;
+  }
+  await activeMcpService.close();
+  activeMcpService = null;
+}
+
+function isLocalRequest(req: FastifyRequest): boolean {
+  const address = normalizeAddress(req.ip ?? req.socket.remoteAddress);
+  if (address && !isLocalHost(address)) {
+    return false;
+  }
+
+  const hostCandidates = [
+    firstHeaderValue(req.headers.host),
+    firstHeaderValue(req.headers["x-forwarded-host"]),
+    extractHostFromOrigin(firstHeaderValue(req.headers.origin)),
+  ]
+    .map((value) => normalizeHost(value))
+    .filter((value): value is string => Boolean(value));
+
+  return hostCandidates.every((host) => isLocalHost(host));
+}
+
+function firstHeaderValue(header: string | string[] | undefined): string | undefined {
+  if (typeof header === "string") {
+    return header;
+  }
+  if (Array.isArray(header) && header.length > 0) {
+    return header[0];
+  }
+  return undefined;
+}
+
+function extractHostFromOrigin(origin: string | undefined): string | undefined {
+  if (!origin) return undefined;
+  try {
+    const parsed = new URL(origin);
+    return parsed.host;
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizeHost(value: string | undefined): string | null {
+  if (!value) return null;
+  const host = value.split(",")[0].trim().toLowerCase();
+  if (!host) return null;
+  if (host.startsWith("[")) {
+    const end = host.indexOf("]");
+    if (end > -1) {
+      return host.slice(1, end);
+    }
+  }
+  return host.split(":")[0];
+}
+
+function normalizeAddress(value: string | undefined): string | null {
+  if (!value) return null;
+  const trimmed = value.trim().toLowerCase();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("::ffff:")) {
+    return trimmed.replace("::ffff:", "");
+  }
+  return trimmed;
+}
+
+function isLocalHost(host: string): boolean {
+  return host === "localhost" || host === "127.0.0.1" || host === "::1";
+}

package/src/routes/models.ts

@@ -0,0 +1,50 @@
+import { FastifyInstance } from "fastify";
+import { StoragePaths } from "../storage/files";
+import { EndpointType, ModelModality } from "../types";
+import { getAvailableSmartPool, listModelsForApi } from "../providers/modelRegistry";
+
+export async function registerModelsRoutes(app: FastifyInstance, paths: StoragePaths): Promise<void> {
+  app.get("/v1/models", async (req, reply) => {
+    const query = (req.query ?? {}) as { available_only?: string | boolean };
+    const availableOnly = query.available_only === true || query.available_only === "true";
+    const concrete = await listModelsForApi(paths, { availableOnly });
+    const smart = await getAvailableSmartPool(paths);
+    const poolEntries = smart
+      ? [
+          {
+            id: smart.alias,
+            object: "model" as const,
+            owned_by: "waypoi",
+            endpoint_type: inferEndpointType(smart.capabilities.output),
+            capabilities: smart.capabilities,
+            slug: smart.alias,
+            waypoi_pool: {
+              id: smart.id,
+              strategy: smart.strategy,
+              candidateCount: smart.candidateCount,
+              scoreSource: "benchmark.livebench",
+            },
+          },
+        ]
+      : [];
+    const data = [...concrete, ...poolEntries];
+    // Include both `data` and `models` for broader client compatibility.
+    reply.send({ object: "list", data, models: data });
+  });
+}
+
+function inferEndpointType(output: ModelModality[]): EndpointType {
+  if (output.includes("text")) {
+    return "llm";
+  }
+  if (output.includes("embedding")) {
+    return "embedding";
+  }
+  if (output.includes("image")) {
+    return "diffusion";
+  }
+  if (output.includes("audio")) {
+    return "audio";
+  }
+  return "llm";
+}