@opengeni/api-router 0.4.0 → 0.5.0

package/src/mcp/documents.ts

@@ -4,11 +4,39 @@ import {
   searchDocuments,
   type DocumentServices,
 } from "@opengeni/documents";
-import type { Database } from "@opengeni/db";
+import {
+  createKnowledgeMemory,
+  listKnowledgeMemories,
+  type Database,
+} from "@opengeni/db";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod/v4";
 
-export function buildDocumentsMcpServer(db: Database, workspaceId: string, documentServices: DocumentServices): McpServer {
+const SearchInputSchema = {
+  query: z.string().min(1),
+  baseIds: z.array(z.string().uuid()).optional(),
+  limit: z.number().int().positive().max(50).optional(),
+  mode: z.enum(["hybrid", "vector", "keyword"]).optional(),
+  sourceKinds: z.array(z.enum(["manual_upload", "meeting_transcript", "repository", "email", "chat", "document", "web", "other"])).optional(),
+  aclTags: z.array(z.string().min(1)).optional(),
+};
+
+const MemoryKindSchema = z.enum(["semantic", "episodic", "procedural", "decision", "preference"]);
+const SourceRefSchema = z.object({
+  kind: z.enum(["document_chunk", "document", "session_event", "memory", "external"]),
+  id: z.string().min(1),
+  uri: z.string().min(1).optional(),
+  title: z.string().min(1).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export function buildDocumentsMcpServer(
+  db: Database,
+  accountId: string,
+  workspaceId: string,
+  documentServices: DocumentServices,
+  options: { createdBySessionId?: string | undefined } = {},
+): McpServer {
   const server = new McpServer({
     name: "opengeni-documents",
     version: "1.0.0",
@@ -22,28 +50,19 @@ export function buildDocumentsMcpServer(db: Database, workspaceId: string, docum
   }));
 
   server.registerTool("search_documents", {
-    description: "Search indexed documents.",
-    inputSchema: {
-      query: z.string(),
-      baseIds: z.array(z.string()).optional(),
-      limit: z.number().optional(),
-    },
-  }, async ({ query, baseIds, limit }) => ({
-    content: [{
-      type: "text",
-      text: JSON.stringify(await searchDocuments(db, {
-        workspaceId,
-        query,
-        ...(baseIds ? { baseIds } : {}),
-        ...(limit ? { limit } : {}),
-      }, documentServices)),
-    }],
-  }));
+    description: "Search indexed documents with hybrid, vector, or keyword retrieval.",
+    inputSchema: SearchInputSchema,
+  }, async (input) => searchContent(db, workspaceId, documentServices, input));
+
+  server.registerTool("knowledge_search", {
+    description: "Search company knowledge sources with optional base, source-kind, ACL, and retrieval-mode filters.",
+    inputSchema: SearchInputSchema,
+  }, async (input) => searchContent(db, workspaceId, documentServices, input));
 
   server.registerTool("fetch_document_chunk", {
     description: "Fetch one indexed document chunk by id.",
     inputSchema: {
-      chunkId: z.string(),
+      chunkId: z.string().uuid(),
     },
   }, async ({ chunkId }) => {
     const found = await getDocumentChunk(db, workspaceId, chunkId);
@@ -53,5 +72,90 @@ export function buildDocumentsMcpServer(db: Database, workspaceId: string, docum
     };
   });
 
+  server.registerTool("knowledge_fetch", {
+    description: "Fetch one knowledge source chunk by id.",
+    inputSchema: {
+      chunkId: z.string().uuid(),
+    },
+  }, async ({ chunkId }) => {
+    const found = await getDocumentChunk(db, workspaceId, chunkId);
+    return {
+      content: [{ type: "text", text: found ? JSON.stringify(found) : `chunk not found: ${chunkId}` }],
+      isError: !found,
+    };
+  });
+
+  server.registerTool("memory_search", {
+    description: "Search approved company memory records.",
+    inputSchema: {
+      query: z.string().min(1).optional(),
+      kind: MemoryKindSchema.optional(),
+      scope: z.string().min(1).optional(),
+      limit: z.number().int().positive().max(100).optional(),
+    },
+  }, async ({ query, kind, scope, limit }) => ({
+    content: [{ type: "text", text: JSON.stringify(await listKnowledgeMemories(db, workspaceId, {
+      ...(query ? { query } : {}),
+      status: "approved",
+      ...(kind ? { kind } : {}),
+      ...(scope ? { scope } : {}),
+      ...(limit ? { limit } : {}),
+    })) }],
+  }));
+
+  server.registerTool("memory_propose", {
+    description: "Propose a company memory record for human review.",
+    inputSchema: {
+      text: z.string().min(1),
+      kind: MemoryKindSchema.optional(),
+      scope: z.string().min(1).optional(),
+      sourceRefs: z.array(SourceRefSchema).optional(),
+      confidence: z.number().min(0).max(1).optional(),
+      metadata: z.record(z.string(), z.unknown()).optional(),
+    },
+  }, async ({ text, kind, scope, sourceRefs, confidence, metadata }) => ({
+    content: [{ type: "text", text: JSON.stringify(await createKnowledgeMemory(db, {
+      accountId,
+      workspaceId,
+      status: "proposed",
+      kind: kind ?? "semantic",
+      scope: scope ?? "workspace",
+      text,
+      sourceRefs: sourceRefs?.map((sourceRef) => ({ ...sourceRef, metadata: sourceRef.metadata ?? {} })) ?? [],
+      confidence: confidence ?? 0.5,
+      metadata: metadata ?? {},
+      createdBySessionId: options.createdBySessionId,
+    })) }],
+  }));
+
   return server;
 }
+
+async function searchContent(
+  db: Database,
+  workspaceId: string,
+  documentServices: DocumentServices,
+  input: {
+    query: string;
+    baseIds?: string[] | undefined;
+    limit?: number | undefined;
+    mode?: "hybrid" | "vector" | "keyword" | undefined;
+    sourceKinds?: Array<"manual_upload" | "meeting_transcript" | "repository" | "email" | "chat" | "document" | "web" | "other"> | undefined;
+    aclTags?: string[] | undefined;
+  },
+) {
+  return {
+    content: [{
+      type: "text" as const,
+      text: JSON.stringify(await searchDocuments(db, {
+        workspaceId,
+        query: input.query,
+        ...(input.baseIds ? { baseIds: input.baseIds } : {}),
+        ...(input.limit ? { limit: input.limit } : {}),
+        ...(input.mode ? { mode: input.mode } : {}),
+        ...(input.sourceKinds ? { sourceKinds: input.sourceKinds } : {}),
+        ...(input.aclTags ? { aclTags: input.aclTags } : {}),
+      }, documentServices)),
+    }],
+  };
+}

package/src/mcp/server.ts

@@ -77,12 +77,14 @@ import {
   type RunOnOp,
 } from "@opengeni/core";
 import { capEventPage, capSessionDetail } from "./session-view";
+import type { ToolspaceMcpSurface } from "./toolspace";
 
 export type McpServerOptions = {
   // Origin of the HTTP request that reached the MCP route; last-resort base
   // for links the server mints (github_connect_link) when neither
   // OPENGENI_PUBLIC_BASE_URL nor the manifest base URL is configured.
   requestOrigin?: string | null;
+  toolspace?: ToolspaceMcpSurface | null;
 };
 
 export function buildOpenGeniMcpServer(deps: ApiRouteDeps, grant: AccessGrant, options: McpServerOptions = {}): McpServer {
@@ -92,6 +94,7 @@ export function buildOpenGeniMcpServer(deps: ApiRouteDeps, grant: AccessGrant, o
   });
   const json = (value: unknown) => ({ content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }] });
   const can = (permission: Permission) => hasPermission(grant.permissions, permission);
+  const toolspaceMode = options.toolspace != null;
 
   // Session-scoped tools key off the worker-asserted sessionId claim (signed
   // into the delegated token by the worker, never agent-controlled).
@@ -99,7 +102,7 @@ export function buildOpenGeniMcpServer(deps: ApiRouteDeps, grant: AccessGrant, o
   // set_session_title names the agent's OWN session — pure session metadata,
   // not a goal operation — so it is available on every session, gated only on
   // the signed sessionId (NOT goals:manage, and NOT on a goal existing).
-  if (sessionId !== null) {
+  if (sessionId !== null && (!toolspaceMode || can("sessions:control"))) {
     server.registerTool("set_session_title", {
       description: "Set this session's display title to a concise 3-7 word summary. Call once early to name the session; calling again replaces it unless a human has manually set the title.",
       inputSchema: { title: z4.string().min(1).max(200) },
@@ -119,7 +122,7 @@ export function buildOpenGeniMcpServer(deps: ApiRouteDeps, grant: AccessGrant, o
   // so they register only when the grant carries the worker-signed sessionId claim
   // (never agent-controlled). Gated on the selfhosted feature flag: the active
   // pointer + swap are only meaningful when bring-your-own-compute is enabled.
-  if (sessionId !== null && deps.settings.sandboxSelfhostedEnabled) {
+  if (!toolspaceMode && sessionId !== null && deps.settings.sandboxSelfhostedEnabled) {
     registerFleetTools(server, deps, grant, sessionId, json);
   }
 
@@ -144,6 +147,7 @@ export function buildOpenGeniMcpServer(deps: ApiRouteDeps, grant: AccessGrant, o
     }
   }
 
+  if (!toolspaceMode || can("files:read")) {
   server.registerTool("files_get_download_url", {
     description: "Create a short-lived download URL for a ready file asset.",
     inputSchema: { fileId: z4.string().uuid() },
@@ -174,7 +178,9 @@ export function buildOpenGeniMcpServer(deps: ApiRouteDeps, grant: AccessGrant, o
       },
     });
   });
+  }
 
+  if (!toolspaceMode || can("github:use")) {
   server.registerTool("github_repositories_list", {
     description: "List GitHub App repositories available as scheduled task repository resources. Use the returned resource object in scheduled task agentConfig.resources.",
     inputSchema: { limit: z4.number().int().positive().optional() },
@@ -191,7 +197,9 @@ export function buildOpenGeniMcpServer(deps: ApiRouteDeps, grant: AccessGrant, o
       throw error;
     }
   });
+  }
 
+  if (!toolspaceMode || can("connections:read")) {
   server.registerTool("social_connections_list", {
     description: "List connected social media accounts available to social media analysis packs.",
     inputSchema: { limit: z4.number().int().positive().optional() },
@@ -266,6 +274,9 @@ export function buildOpenGeniMcpServer(deps: ApiRouteDeps, grant: AccessGrant, o
     });
   });
 
+  }
+
+  if (!toolspaceMode || can("scheduled_tasks:manage") || can("scheduled_tasks:run")) {
   server.registerTool("scheduled_tasks_list", {
     description: "List scheduled tasks.",
     inputSchema: { limit: z4.number().int().positive().optional() },
@@ -379,9 +390,33 @@ export function buildOpenGeniMcpServer(deps: ApiRouteDeps, grant: AccessGrant, o
     inputSchema: { taskId: z4.string().uuid(), limit: z4.number().int().positive().optional() },
   }, async ({ taskId, limit }) => json({ runs: await listScheduledTaskRuns(deps.db, grant.workspaceId, taskId, limit ?? 100) }));
 
+  }
+
+  registerToolspaceProxyTools(server, options.toolspace ?? null);
+
   return server;
 }
 
+function registerToolspaceProxyTools(server: McpServer, surface: ToolspaceMcpSurface | null): void {
+  if (!surface) {
+    return;
+  }
+  for (const tool of surface.tools) {
+    server.registerTool(tool.name, {
+      ...(tool.description ? { description: tool.description } : {}),
+      inputSchema: z4.object({}).passthrough(),
+      _meta: {
+        opengeni: {
+          origin: "toolspace",
+          subjectId: surface.subjectId,
+          sessionId: surface.sessionId,
+          ...(tool.inputSchema ? { inputSchema: tool.inputSchema } : {}),
+        },
+      },
+    }, async (args) => await tool.call(args));
+  }
+}
+
 function registerGoalTools(
   server: McpServer,
   deps: ApiRouteDeps,