@hiai-gg/docsmint 1.0.2 → 2.0.2

package/dist/mcp-cli.js

@@ -575,9 +575,6 @@ var RESOURCE_PERMISSIONS = new Set([
   "edit",
   "write"
 ]);
-// ../mcp-server/src/compact.ts
-import { z as z3 } from "zod";
-
 // ../mcp-server/src/output-schemas.ts
 import { z } from "zod";
 var tagSchema = z.looseObject({
@@ -806,7 +803,7 @@ var operationOutputSchemas = {
   permanently_delete_document: deleteAcknowledgmentSchema
 };
 var variant = (operation, result) => z.object({ operation: z.literal(operation), result });
-var toolOutputSchemas = {
+var singleToolOutputSchemas = {
   delete_document: operationOutputSchemas.delete_document,
   delete_folder: operationOutputSchemas.delete_folder,
   delete_category: operationOutputSchemas.delete_category,
@@ -832,6 +829,7 @@ var toolOutputSchemas = {
     variant("update", operationOutputSchemas.update_document)
   ]),
   list_workspace_structure: z.union([
+    variant("workspaces", z.array(z.object({ id: z.string().uuid(), name: z.string(), slug: z.string(), entireWorkspace: z.boolean(), categoryIds: z.array(z.string().uuid()) }))),
     variant("folders", operationOutputSchemas.list_folders),
     variant("categories", operationOutputSchemas.list_categories),
     variant("tags", operationOutputSchemas.list_tags)
@@ -874,9 +872,27 @@ var toolOutputSchemas = {
     variant("tag", tagSchema)
   ])
 };
+var workspaceSchema = z.object({ id: z.string().uuid(), name: z.string(), slug: z.string() });
+var scoped = (data) => z.object({
+  operation: z.string(),
+  scopedResults: z.array(z.object({ workspace: workspaceSchema, categoryId: z.string().uuid().nullable(), data }))
+});
+var scopedSchemas = {
+  find_documents: scoped(singleToolOutputSchemas.find_documents),
+  list_workspace_structure: scoped(singleToolOutputSchemas.list_workspace_structure),
+  list_trash: scoped(singleToolOutputSchemas.list_trash)
+};
+var toolOutputSchemas = {
+  ...singleToolOutputSchemas,
+  find_documents: z.union([...singleToolOutputSchemas.find_documents.options, scopedSchemas.find_documents]),
+  list_workspace_structure: z.union([...singleToolOutputSchemas.list_workspace_structure.options, scopedSchemas.list_workspace_structure]),
+  list_trash: z.union([singleToolOutputSchemas.list_trash, scopedSchemas.list_trash])
+};
+// ../mcp-server/src/compact.ts
+import { z as z4 } from "zod";
 
 // ../mcp-server/src/batch-workspace.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // ../mcp-server/src/client.ts
 var DEFAULT_BASE_URL = "http://localhost:50700";
@@ -970,18 +986,82 @@ var client = new Proxy({}, {
   }
 });
 
+// ../mcp-server/src/client-routing-schema.ts
+import { z as z2 } from "zod";
+function hoistObjectUnionClosure(schema) {
+  const variants = schema.oneOf;
+  if (!Array.isArray(variants) || !variants.every((variant2) => typeof variant2 === "object" && variant2 !== null && variant2.type === "object" && variant2.additionalProperties === false && typeof variant2.properties === "object" && variant2.properties !== null))
+    return schema;
+  const propertyVariants = new Map;
+  for (const variant2 of variants) {
+    for (const [key, property] of Object.entries(variant2.properties)) {
+      const values = propertyVariants.get(key) ?? [];
+      values.push(property);
+      propertyVariants.set(key, values);
+    }
+  }
+  return {
+    ...schema,
+    type: "object",
+    properties: Object.fromEntries([...propertyVariants].map(([key, values]) => [
+      key,
+      values.length === 1 ? values[0] : { anyOf: values }
+    ])),
+    additionalProperties: false,
+    oneOf: variants.map((variant2) => {
+      const { additionalProperties: _closure, ...branch } = variant2;
+      const excluded = [...propertyVariants.keys()].filter((key) => !(key in variant2.properties));
+      return excluded.length === 0 ? branch : {
+        ...branch,
+        allOf: [
+          ...Array.isArray(branch.allOf) ? branch.allOf : [],
+          { not: { anyOf: excluded.map((key) => ({ required: [key] })) } }
+        ]
+      };
+    })
+  };
+}
+function withClientRoutingSchema(schema) {
+  const standard = schema["~standard"];
+  const selector = z2.string().uuid().optional().describe("Workspace UUID from list_workspace_structure(kind=workspaces). Required for ambiguous creates and structure changes; omit to search all granted scopes.");
+  return {
+    "~standard": {
+      ...standard,
+      validate: async (value, options) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+          return standard.validate(value, options);
+        const { workspaceId, ...args } = value;
+        const selected = selector.safeParse(workspaceId);
+        if (!selected.success)
+          return { issues: selected.error.issues };
+        const validated = await standard.validate(args, options);
+        if (validated.issues)
+          return validated;
+        return { value: { ...validated.value, ...selected.data ? { workspaceId: selected.data } : {} } };
+      },
+      jsonSchema: {
+        ...standard.jsonSchema,
+        input: (options) => (() => {
+          const published = hoistObjectUnionClosure(standard.jsonSchema.input(options));
+          return { ...published, properties: { ...published.properties, workspaceId: z2.toJSONSchema(selector) } };
+        })()
+      }
+    }
+  };
+}
+
 // ../mcp-server/src/batch-workspace.ts
-var uuid = z2.string().uuid().describe("UUID of an item visible to the active API key.");
-var documentIds = z2.array(uuid).min(1).max(25).refine((ids) => new Set(ids).size === ids.length, "Document IDs must be unique.").describe("One to 25 distinct document UUIDs, explicitly selected by the user; no search expansion.");
+var uuid = z3.string().uuid().describe("UUID of an item visible to the active API key.");
+var documentIds = z3.array(uuid).min(1).max(25).refine((ids) => new Set(ids).size === ids.length, "Document IDs must be unique.").describe("One to 25 distinct document UUIDs, explicitly selected by the user; no search expansion.");
 var base = { documentIds };
-var batchInput = z2.discriminatedUnion("action", [
-  z2.strictObject({ ...base, action: z2.literal("move").describe("Move each document to the same folder."), folderId: uuid.nullable().describe("Destination folder UUID, or null for no folder.") }),
-  z2.strictObject({ ...base, action: z2.literal("set_category").describe("Set one explicit category on every document."), categoryId: uuid.nullable().describe("Category UUID, or null to clear explicit category.") }),
-  z2.strictObject({ ...base, action: z2.literal("add_tag").describe("Assign one existing tag to every document."), tagId: uuid.describe("Existing tag UUID to assign to each document.") }),
-  z2.strictObject({ ...base, action: z2.literal("remove_tag").describe("Remove one tag assignment from every document."), tagId: uuid.describe("Existing tag UUID to unassign from each document.") }),
-  z2.strictObject({ ...base, action: z2.literal("trash").describe("Move every document to trash without permanent deletion.") }),
-  z2.strictObject({ ...base, action: z2.literal("restore").describe("Restore every selected document from trash.") }),
-  z2.strictObject({ ...base, action: z2.literal("refresh_index").describe("Request explicit indexing retry for every document.") })
+var batchInput = z3.discriminatedUnion("action", [
+  z3.strictObject({ ...base, action: z3.literal("move").describe("Move each document to the same folder."), folderId: uuid.nullable().describe("Destination folder UUID, or null for no folder.") }),
+  z3.strictObject({ ...base, action: z3.literal("set_category").describe("Set one explicit category on every document."), categoryId: uuid.nullable().describe("Category UUID, or null to clear explicit category.") }),
+  z3.strictObject({ ...base, action: z3.literal("add_tag").describe("Assign one existing tag to every document."), tagId: uuid.describe("Existing tag UUID to assign to each document.") }),
+  z3.strictObject({ ...base, action: z3.literal("remove_tag").describe("Remove one tag assignment from every document."), tagId: uuid.describe("Existing tag UUID to unassign from each document.") }),
+  z3.strictObject({ ...base, action: z3.literal("trash").describe("Move every document to trash without permanent deletion.") }),
+  z3.strictObject({ ...base, action: z3.literal("restore").describe("Restore every selected document from trash.") }),
+  z3.strictObject({ ...base, action: z3.literal("refresh_index").describe("Request explicit indexing retry for every document.") })
 ]);
 function required(method, name) {
   if (!method)
@@ -1036,13 +1116,13 @@ function registerBatchAndWorkspaceCapabilities(server, client2, wrap) {
   }
   server.registerTool("batch_documents", {
     description: "Use for multiple explicitly selected documents that need the same action; for one document prefer the matching single-document tool. Accepts 1\u201325 IDs for automation compatibility. Supports move, set_category, add_tag, remove_tag, trash, restore, or refresh_index. Processes sequentially through the existing API with a permission check per document and a per-ID result; partial success is possible. Stops after authentication or rate-limit failure. Never expands a search result or permanently purges documents; version restore is separate.",
-    inputSchema: batchInput,
+    inputSchema: withClientRoutingSchema(batchInput),
     outputSchema: toolOutputSchemas.batch_documents,
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false }
   }, wrap("batch_documents", batch, toolOutputSchemas.batch_documents));
   server.registerTool("get_workspace_item", {
     description: "Read one visible folder, category, or tag by UUID. Folder uses its direct API getter; category and tag lookup uses the complete permission-filtered lists. An absent or out-of-scope ID is reported as not found. Use list_workspace_structure to discover IDs first.",
-    inputSchema: z2.strictObject({ kind: z2.enum(["folder", "category", "tag"]).describe("The workspace resource type to read by ID."), id: uuid }),
+    inputSchema: withClientRoutingSchema(z3.strictObject({ kind: z3.enum(["folder", "category", "tag"]).describe("The workspace resource type to read by ID."), id: uuid })),
     outputSchema: toolOutputSchemas.get_workspace_item,
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, wrap("get_workspace_item", async ({ kind, id }) => {
@@ -1057,10 +1137,10 @@ function registerBatchAndWorkspaceCapabilities(server, client2, wrap) {
 }
 
 // ../mcp-server/src/compact.ts
-var uuid2 = z3.string().uuid().describe("UUID returned by the corresponding list or read operation.");
-var text = z3.string().min(1).describe("Non-empty human-readable name or title.");
-var title = z3.string().min(1).max(500).describe("Document title, from 1 to 500 characters.");
-var content = z3.string().describe("Markdown document content; an empty string clears the content on update.");
+var uuid2 = z4.string().uuid().describe("UUID returned by the corresponding list or read operation.");
+var text = z4.string().min(1).describe("Non-empty human-readable name or title.");
+var title = z4.string().min(1).max(500).describe("Document title, from 1 to 500 characters.");
+var content = z4.string().describe("Markdown document content; an empty string clears the content on update.");
 var read = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var write = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var destructive = { ...write, destructiveHint: true };
@@ -1071,16 +1151,16 @@ function required2(value, name) {
 }
 function registerCompactCapabilities(server, client2, wrap) {
   function register(name, description, inputSchema, annotations, handler) {
-    server.registerTool(name, { description, inputSchema, outputSchema: toolOutputSchemas[name], annotations }, wrap(name, handler, toolOutputSchemas[name]));
+    server.registerTool(name, { description, inputSchema: withClientRoutingSchema(inputSchema), outputSchema: toolOutputSchemas[name], annotations }, wrap(name, handler, toolOutputSchemas[name]));
   }
-  register("find_documents", "Find readable documents in the active scope. Use mode=list for paginated browsing by folder or tag UUID; use mode=search for hybrid text and semantic retrieval with tag names.", z3.discriminatedUnion("mode", [
-    z3.strictObject({ mode: z3.literal("list").describe("Select the list operation explicitly."), folderId: uuid2.optional(), tag: uuid2.optional(), page: z3.number().int().min(1).optional().describe("One-based page number; defaults to the API first page."), limit: z3.number().int().min(1).max(1000).optional().describe("Maximum documents per page, up to 1000.") }),
-    z3.strictObject({ mode: z3.literal("search").describe("Select the search operation explicitly."), query: text.describe("Text to search in the original language."), folder: z3.string().optional().describe("Optional folder UUID filter for search."), tags: z3.array(z3.string()).optional().describe("Optional tag names; all supplied names must match."), limit: z3.number().int().min(1).max(100).optional().describe("Maximum results to return, up to 100.") })
+  register("find_documents", "Find readable documents in the active scope. Use mode=list for paginated browsing by folder or tag UUID; use mode=search for hybrid text and semantic retrieval with tag names.", z4.discriminatedUnion("mode", [
+    z4.strictObject({ mode: z4.literal("list").describe("Select the list operation explicitly."), folderId: uuid2.optional(), tag: uuid2.optional(), page: z4.number().int().min(1).optional().describe("One-based page number; defaults to the API first page."), limit: z4.number().int().min(1).max(1000).optional().describe("Maximum documents per page, up to 1000.") }),
+    z4.strictObject({ mode: z4.literal("search").describe("Select the search operation explicitly."), query: text.describe("Text to search in the original language."), folder: z4.string().optional().describe("Optional folder UUID filter for search."), tags: z4.array(z4.string()).optional().describe("Optional tag names; all supplied names must match."), limit: z4.number().int().min(1).max(100).optional().describe("Maximum results to return, up to 100.") })
   ]), read, async (input) => input.mode === "list" ? { operation: "list", result: await client2.listDocuments(input) } : { operation: "search", result: await client2.search(input) });
-  register("read_document", "Read one document by UUID. Choose detail for content and metadata, markdown for portable export, or versions for saved revisions and snapshots. All views are read-only.", z3.discriminatedUnion("view", [
-    z3.strictObject({ view: z3.literal("detail").describe("Select the detail operation explicitly."), id: uuid2 }),
-    z3.strictObject({ view: z3.literal("markdown").describe("Select the markdown operation explicitly."), id: uuid2 }),
-    z3.strictObject({ view: z3.literal("versions").describe("Select the versions operation explicitly."), id: uuid2, onlySnapshots: z3.boolean().optional().describe("When true, return only named snapshots.") })
+  register("read_document", "Read one document by UUID. Choose detail for content and metadata, markdown for portable export, or versions for saved revisions and snapshots. All views are read-only.", z4.discriminatedUnion("view", [
+    z4.strictObject({ view: z4.literal("detail").describe("Select the detail operation explicitly."), id: uuid2 }),
+    z4.strictObject({ view: z4.literal("markdown").describe("Select the markdown operation explicitly."), id: uuid2 }),
+    z4.strictObject({ view: z4.literal("versions").describe("Select the versions operation explicitly."), id: uuid2, onlySnapshots: z4.boolean().optional().describe("When true, return only named snapshots.") })
   ]), read, async (input) => {
     if (input.view === "detail")
       return { operation: "detail", result: await client2.getDocument(input.id) };
@@ -1088,9 +1168,9 @@ function registerCompactCapabilities(server, client2, wrap) {
       return { operation: "markdown", result: await client2.exportDocument(input.id) };
     return { operation: "versions", result: await client2.getVersionHistory(input.id, input.onlySnapshots) };
   });
-  register("save_document", "Create or update one document. Use action=create for a new document or action=update for an existing one; batch_documents handles the same placement change across multiple existing documents. Creation requires write access; content edits require edit access, and placement changes may require write access. Content or placement changes queue normal indexing.", z3.discriminatedUnion("action", [
-    z3.strictObject({ action: z3.literal("create").describe("Select the create operation explicitly."), title: title.optional(), content: content.optional(), folderId: uuid2.optional(), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category.") }),
-    z3.strictObject({ action: z3.literal("update").describe("Select the update operation explicitly."), id: uuid2, title: title.optional(), content: content.optional(), folderId: uuid2.nullable().optional().describe("Optional folder UUID; null clears the placement on update."), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category.") }).refine((value) => value.title !== undefined || value.content !== undefined || value.folderId !== undefined || value.categoryId !== undefined)
+  register("save_document", "Create or update one document. Use action=create for a new document or action=update for an existing one; batch_documents handles the same placement change across multiple existing documents. Creation requires write access; content edits require edit access, and placement changes may require write access. Content or placement changes queue normal indexing.", z4.discriminatedUnion("action", [
+    z4.strictObject({ action: z4.literal("create").describe("Select the create operation explicitly."), title: title.optional(), content: content.optional(), folderId: uuid2.optional(), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category.") }),
+    z4.strictObject({ action: z4.literal("update").describe("Select the update operation explicitly."), id: uuid2, title: title.optional(), content: content.optional(), folderId: uuid2.nullable().optional().describe("Optional folder UUID; null clears the placement on update."), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category.") }).refine((value) => value.title !== undefined || value.content !== undefined || value.folderId !== undefined || value.categoryId !== undefined)
   ]), destructive, async (input) => {
     if (input.action === "create") {
       const { action: _action2, ...data2 } = input;
@@ -1099,24 +1179,27 @@ function registerCompactCapabilities(server, client2, wrap) {
     const { action: _action, id, ...data } = input;
     return { operation: "update", result: await client2.updateDocument(id, data) };
   });
-  register("delete_document", "Move one document to trash without purging content or versions. Use batch_documents(action=trash) for multiple explicit IDs. Requires write access and an explicit delete request; permanently_delete_document is a separate irreversible action.", z3.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
+  register("delete_document", "Move one document to trash without purging content or versions. Use batch_documents(action=trash) for multiple explicit IDs. Requires write access and an explicit delete request; permanently_delete_document is a separate irreversible action.", z4.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
     await required2(client2.deleteDocument, "delete_document")(id);
     return { id, deleted: true };
   });
-  register("list_workspace_structure", "List visible folders, categories, or tags in the active workspace or category scope. Set kind=folders to inspect root folders or children of parentId.", z3.discriminatedUnion("kind", [
-    z3.strictObject({ kind: z3.literal("folders").describe("Select the folders operation explicitly."), parentId: uuid2.optional() }),
-    z3.strictObject({ kind: z3.literal("categories").describe("Select the categories operation explicitly.") }),
-    z3.strictObject({ kind: z3.literal("tags").describe("Select the tags operation explicitly.") })
+  register("list_workspace_structure", "Discover permitted spaces with kind=workspaces, including empty spaces; use returned workspaceId for scoped operations. List folders, categories, or tags; set kind=folders for root folders or children of parentId. Unselected reads cover all granted scopes when supported by the host.", z4.discriminatedUnion("kind", [
+    z4.strictObject({ kind: z4.literal("workspaces").describe("Discover every workspace granted to this connection, including empty ones.") }),
+    z4.strictObject({ kind: z4.literal("folders").describe("Select the folders operation explicitly."), parentId: uuid2.optional() }),
+    z4.strictObject({ kind: z4.literal("categories").describe("Select the categories operation explicitly.") }),
+    z4.strictObject({ kind: z4.literal("tags").describe("Select the tags operation explicitly.") })
   ]), read, async (input) => {
+    if (input.kind === "workspaces")
+      throw new Error("Workspace routing is not configured");
     if (input.kind === "folders")
       return { operation: "folders", result: await client2.listFolders({ parentId: input.parentId }) };
     if (input.kind === "categories")
       return { operation: "categories", result: await client2.listCategories() };
     return { operation: "tags", result: await client2.listTags() };
   });
-  register("save_folder", "Create or update a folder. action=update can rename or move an existing folder; the API enforces category boundaries and queues affected documents for reindexing.", z3.discriminatedUnion("action", [
-    z3.strictObject({ action: z3.literal("create").describe("Select the create operation explicitly."), name: text.max(255), parentId: uuid2.nullable().optional().describe("Optional parent folder UUID; null selects the root."), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category.") }),
-    z3.strictObject({ action: z3.literal("update").describe("Select the update operation explicitly."), id: uuid2, name: text.max(255).optional(), parentId: uuid2.nullable().optional().describe("Optional parent folder UUID; null selects the root."), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category."), order: z3.number().int().nonnegative().optional().describe("New non-negative display order.") }).refine((value) => value.name !== undefined || value.parentId !== undefined || value.categoryId !== undefined || value.order !== undefined)
+  register("save_folder", "Create or update a folder. action=update can rename or move an existing folder; the API enforces category boundaries and queues affected documents for reindexing.", z4.discriminatedUnion("action", [
+    z4.strictObject({ action: z4.literal("create").describe("Select the create operation explicitly."), name: text.max(255), parentId: uuid2.nullable().optional().describe("Optional parent folder UUID; null selects the root."), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category.") }),
+    z4.strictObject({ action: z4.literal("update").describe("Select the update operation explicitly."), id: uuid2, name: text.max(255).optional(), parentId: uuid2.nullable().optional().describe("Optional parent folder UUID; null selects the root."), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category."), order: z4.number().int().nonnegative().optional().describe("New non-negative display order.") }).refine((value) => value.name !== undefined || value.parentId !== undefined || value.categoryId !== undefined || value.order !== undefined)
   ]), destructive, async (input) => {
     if (input.action === "create") {
       const { action: _action2, ...data2 } = input;
@@ -1125,37 +1208,37 @@ function registerCompactCapabilities(server, client2, wrap) {
     const { action: _action, id, ...data } = input;
     return { operation: "update", result: await required2(client2.updateFolder, "update_folder")(id, data) };
   });
-  register("delete_folder", "Delete a folder while preserving its documents; child folders and documents are detached under the API rules. Requires write access.", z3.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
+  register("delete_folder", "Delete a folder while preserving its documents; child folders and documents are detached under the API rules. Requires write access.", z4.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
     await required2(client2.deleteFolder, "delete_folder")(id);
     return { id, deleted: true };
   });
-  register("save_category", "Create or update a workspace category. Full workspace write access is required; category-scoped credentials cannot manage categories.", z3.discriminatedUnion("action", [
-    z3.strictObject({ action: z3.literal("create").describe("Select the create operation explicitly."), name: text.max(255) }),
-    z3.strictObject({ action: z3.literal("update").describe("Select the update operation explicitly."), id: uuid2, name: text.max(255).optional(), order: z3.number().int().nonnegative().optional().describe("New non-negative display order.") }).refine((value) => value.name !== undefined || value.order !== undefined)
+  register("save_category", "Create or update a workspace category. Full workspace write access is required; category-scoped credentials cannot manage categories.", z4.discriminatedUnion("action", [
+    z4.strictObject({ action: z4.literal("create").describe("Select the create operation explicitly."), name: text.max(255) }),
+    z4.strictObject({ action: z4.literal("update").describe("Select the update operation explicitly."), id: uuid2, name: text.max(255).optional(), order: z4.number().int().nonnegative().optional().describe("New non-negative display order.") }).refine((value) => value.name !== undefined || value.order !== undefined)
   ]), destructive, async (input) => {
     if (input.action === "create")
       return { operation: "create", result: await client2.createCategory({ name: input.name }) };
     const { action: _action, id, ...data } = input;
     return { operation: "update", result: await required2(client2.updateCategory, "update_category")(id, data) };
   });
-  register("delete_category", "Delete a workspace category and detach its documents without deleting them. Requires full workspace write access; category-scoped credentials are denied.", z3.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
+  register("delete_category", "Delete a workspace category and detach its documents without deleting them. Requires full workspace write access; category-scoped credentials are denied.", z4.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
     await required2(client2.deleteCategory, "delete_category")(id);
     return { id, deleted: true };
   });
-  register("save_tag", "Create or update a workspace tag. Full workspace write access is required; renaming or recoloring a tag causes affected documents to be reindexed.", z3.discriminatedUnion("action", [
-    z3.strictObject({ action: z3.literal("create").describe("Select the create operation explicitly."), name: text.max(100), color: z3.string().max(20).optional().describe("Optional tag color, at most 20 characters.") }),
-    z3.strictObject({ action: z3.literal("update").describe("Select the update operation explicitly."), id: uuid2, name: text.max(100).optional(), color: z3.string().max(20).optional().describe("Optional tag color, at most 20 characters.") }).refine((value) => value.name !== undefined || value.color !== undefined)
+  register("save_tag", "Create or update a workspace tag. Full workspace write access is required; renaming or recoloring a tag causes affected documents to be reindexed.", z4.discriminatedUnion("action", [
+    z4.strictObject({ action: z4.literal("create").describe("Select the create operation explicitly."), name: text.max(100), color: z4.string().max(20).optional().describe("Optional tag color, at most 20 characters.") }),
+    z4.strictObject({ action: z4.literal("update").describe("Select the update operation explicitly."), id: uuid2, name: text.max(100).optional(), color: z4.string().max(20).optional().describe("Optional tag color, at most 20 characters.") }).refine((value) => value.name !== undefined || value.color !== undefined)
   ]), destructive, async (input) => {
     if (input.action === "create")
       return { operation: "create", result: await required2(client2.createTag, "create_tag")({ name: input.name, color: input.color }) };
     const { action: _action, id, ...data } = input;
     return { operation: "update", result: await required2(client2.updateTag, "update_tag")(id, data) };
   });
-  register("delete_tag", "Delete a workspace tag and remove its document assignments. Full workspace write access is required; documents themselves remain.", z3.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
+  register("delete_tag", "Delete a workspace tag and remove its document assignments. Full workspace write access is required; documents themselves remain.", z4.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
     await required2(client2.deleteTag, "delete_tag")(id);
     return { id, deleted: true };
   });
-  register("set_document_tag", "Add or remove an existing tag assignment on one document. Use batch_documents for the same tag action across multiple explicit IDs. Requires edit access to each document; action=remove preserves the tag itself.", z3.strictObject({ action: z3.enum(["add", "remove"]).describe("Add or remove exactly one tag assignment."), documentId: uuid2, tagId: uuid2 }), destructive, async ({ action, documentId, tagId }) => {
+  register("set_document_tag", "Add or remove an existing tag assignment on one document. Use batch_documents for the same tag action across multiple explicit IDs. Requires edit access to each document; action=remove preserves the tag itself.", z4.strictObject({ action: z4.enum(["add", "remove"]).describe("Add or remove exactly one tag assignment."), documentId: uuid2, tagId: uuid2 }), destructive, async ({ action, documentId, tagId }) => {
     if (action === "add") {
       await required2(client2.addTagToDocument, "add_tag_to_document")(documentId, tagId);
       return { operation: "add", result: { documentId, tagId, assigned: true } };
@@ -1163,17 +1246,17 @@ function registerCompactCapabilities(server, client2, wrap) {
     await required2(client2.removeTagFromDocument, "remove_tag_from_document")(documentId, tagId);
     return { operation: "remove", result: { documentId, tagId, removed: true } };
   });
-  register("create_snapshot", "Save a named snapshot of an existing document before a planned change. The snapshot can later be restored with restore_document_version.", z3.strictObject({ documentId: uuid2, label: text.max(200).describe("Snapshot label, from 1 to 200 characters."), description: z3.string().max(1000).optional().describe("Optional snapshot note, at most 1000 characters.") }), write, async ({ documentId, label, description }) => client2.createSnapshot(documentId, { label, description }));
-  register("restore_document_version", "Restore content from a version or snapshot listed by read_document(view=versions). This changes current content and queues indexing; it does not restore a trashed document.", z3.strictObject({ documentId: uuid2, versionId: uuid2 }), destructive, async ({ documentId, versionId }) => required2(client2.restoreDocumentVersion, "restore_document_version")(documentId, versionId));
-  register("explore_graph", "Explore graph relations from readable seed documents. mode=neighbors traverses one document without a query; mode=search ranks relations from one or more seed IDs with optional query text.", z3.discriminatedUnion("mode", [
-    z3.strictObject({ mode: z3.literal("neighbors").describe("Select the neighbors operation explicitly."), documentId: uuid2, limit: z3.number().int().min(1).max(100).optional().describe("Maximum results to return, up to 100.") }),
-    z3.strictObject({ mode: z3.literal("search").describe("Select the search operation explicitly."), docIds: z3.array(uuid2).min(1).max(50).describe("One to 50 authorized seed document UUIDs."), query: z3.string().max(2000).optional().describe("Optional graph relevance query, at most 2000 characters."), limit: z3.number().int().min(1).max(100).optional().describe("Maximum results to return, up to 100.") })
+  register("create_snapshot", "Save a named snapshot of an existing document before a planned change. The snapshot can later be restored with restore_document_version.", z4.strictObject({ documentId: uuid2, label: text.max(200).describe("Snapshot label, from 1 to 200 characters."), description: z4.string().max(1000).optional().describe("Optional snapshot note, at most 1000 characters.") }), write, async ({ documentId, label, description }) => client2.createSnapshot(documentId, { label, description }));
+  register("restore_document_version", "Restore content from a version or snapshot listed by read_document(view=versions). This changes current content and queues indexing; it does not restore a trashed document.", z4.strictObject({ documentId: uuid2, versionId: uuid2 }), destructive, async ({ documentId, versionId }) => required2(client2.restoreDocumentVersion, "restore_document_version")(documentId, versionId));
+  register("explore_graph", "Explore graph relations from readable seed documents. mode=neighbors traverses one document without a query; mode=search ranks relations from one or more seed IDs with optional query text.", z4.discriminatedUnion("mode", [
+    z4.strictObject({ mode: z4.literal("neighbors").describe("Select the neighbors operation explicitly."), documentId: uuid2, limit: z4.number().int().min(1).max(100).optional().describe("Maximum results to return, up to 100.") }),
+    z4.strictObject({ mode: z4.literal("search").describe("Select the search operation explicitly."), docIds: z4.array(uuid2).min(1).max(50).describe("One to 50 authorized seed document UUIDs."), query: z4.string().max(2000).optional().describe("Optional graph relevance query, at most 2000 characters."), limit: z4.number().int().min(1).max(100).optional().describe("Maximum results to return, up to 100.") })
   ]), read, async (input) => input.mode === "neighbors" ? { operation: "neighbors", result: await client2.getRelatedDocuments(input.documentId, input.limit) } : { operation: "search", result: await client2.searchGraph(input) });
-  register("get_document_index_status", "Read current indexing and pipeline status for one document without starting work. Use refresh_document_index only when an explicit retry is intended.", z3.strictObject({ documentId: uuid2 }), read, async ({ documentId }) => client2.getDocumentIndexStatus(documentId));
-  register("refresh_document_index", "Queue an explicit asynchronous reindex for one document; use batch_documents(action=refresh_index) for multiple explicit IDs. Routine content and placement changes already schedule indexing; check get_document_index_status first.", z3.strictObject({ documentId: uuid2 }), write, async ({ documentId }) => client2.refreshDocumentIndex(documentId));
-  register("list_trash", "List soft-deleted documents visible to the active workspace or category scope. Requires read access and does not restore or purge anything.", z3.strictObject({}), read, async () => required2(client2.listTrash, "list_trash")());
-  register("restore_trashed_document", "Return one document from trash to the active library; use batch_documents(action=restore) for multiple explicit IDs. This restores the document itself, unlike restore_document_version which changes content.", z3.strictObject({ id: uuid2 }), write, async ({ id }) => required2(client2.restoreTrashedDocument, "restore_trashed_document")(id));
-  register("permanently_delete_document", "Irreversibly purge a document already in trash, including its version history. Use only on an explicit user request after checking list_trash.", z3.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
+  register("get_document_index_status", "Read current indexing and pipeline status for one document without starting work. Use refresh_document_index only when an explicit retry is intended.", z4.strictObject({ documentId: uuid2 }), read, async ({ documentId }) => client2.getDocumentIndexStatus(documentId));
+  register("refresh_document_index", "Queue an explicit asynchronous reindex for one document; use batch_documents(action=refresh_index) for multiple explicit IDs. Routine content and placement changes already schedule indexing; check get_document_index_status first.", z4.strictObject({ documentId: uuid2 }), write, async ({ documentId }) => client2.refreshDocumentIndex(documentId));
+  register("list_trash", "List soft-deleted documents visible to the active workspace or category scope. Requires read access and does not restore or purge anything.", z4.strictObject({}), read, async () => required2(client2.listTrash, "list_trash")());
+  register("restore_trashed_document", "Return one document from trash to the active library; use batch_documents(action=restore) for multiple explicit IDs. This restores the document itself, unlike restore_document_version which changes content.", z4.strictObject({ id: uuid2 }), write, async ({ id }) => required2(client2.restoreTrashedDocument, "restore_trashed_document")(id));
+  register("permanently_delete_document", "Irreversibly purge a document already in trash, including its version history. Use only on an explicit user request after checking list_trash.", z4.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
     await required2(client2.permanentlyDeleteDocument, "permanently_delete_document")(id);
     return { id, deleted: true };
   });
@@ -1181,13 +1264,13 @@ function registerCompactCapabilities(server, client2, wrap) {
 }
 
 // ../mcp-server/src/prompts-resources.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 function registerPromptsAndResources(server, client2) {
   server.registerPrompt("organize_workspace", {
     description: "Plan safe document organization using DocsMint categories and folders.",
-    argsSchema: z4.object({
-      objective: z4.string(),
-      language: z4.string().optional()
+    argsSchema: z5.object({
+      objective: z5.string(),
+      language: z5.string().optional()
     })
   }, ({ objective, language }) => ({
     messages: [
@@ -1202,9 +1285,9 @@ function registerPromptsAndResources(server, client2) {
   }));
   server.registerPrompt("research_workspace", {
     description: "Research a question with hybrid search and GraphRAG while citing DocsMint document IDs.",
-    argsSchema: z4.object({
-      question: z4.string(),
-      language: z4.string().optional()
+    argsSchema: z5.object({
+      question: z5.string(),
+      language: z5.string().optional()
     })
   }, ({ question, language }) => ({
     messages: [
@@ -1258,10 +1341,24 @@ Use find_documents(mode=search) for normal retrieval. Use explore_graph only wit
 }
 
 // ../mcp-server/src/server.ts
-function wrapHandler(name, handler, outputSchema) {
+function wrapHandler(name, handler, outputSchema, workspaceRouting) {
   return async (args) => {
     try {
-      const output = await handler(args);
+      const { workspaceId, ...data } = args;
+      if (workspaceId !== undefined) {
+        if (!workspaceRouting)
+          throw new Error("Workspace routing is not configured");
+        await workspaceRouting.assertSelection(workspaceId);
+      }
+      let output;
+      if (name === "list_workspace_structure" && data.kind === "workspaces") {
+        if (!workspaceRouting)
+          throw new Error("Workspace routing is not configured");
+        const workspaces = await workspaceRouting.listWorkspaces();
+        output = { operation: "workspaces", result: workspaceId ? workspaces.filter((item) => item.id === workspaceId) : workspaces };
+      } else {
+        output = await handler(data);
+      }
       const parsedOutput = outputSchema ? await outputSchema.safeParseAsync(output) : undefined;
       if (parsedOutput && !parsedOutput.success) {
         throw new Error(`Tool '${name}' returned a result outside its published output schema`);
@@ -1295,14 +1392,15 @@ function wrapHandler(name, handler, outputSchema) {
     }
   };
 }
-function registerDocsmintMcpCapabilities(server, client2) {
-  registerCompactCapabilities(server, client2, wrapHandler);
+function registerDocsmintMcpCapabilities(server, client2, workspaceRouting) {
+  const wrap = (name, handler, outputSchema) => wrapHandler(name, handler, outputSchema, workspaceRouting);
+  registerCompactCapabilities(server, client2, wrap);
   registerPromptsAndResources(server, client2);
 }
 function createDocsmintMcpServer(options = {}) {
-  const server = new McpServer({ name: "docsmint", version: "1.0.2" });
+  const server = new McpServer({ name: "docsmint", version: "2.0.2" });
   const client2 = options.docsClient ? createMcpDocsClient(options.docsClient, options.requestContext) : options.client ?? createMcpDocsClient(createDefaultDocsClient(), options.requestContext);
-  registerDocsmintMcpCapabilities(server, client2);
+  registerDocsmintMcpCapabilities(server, client2, options.workspaceRouting);
   return server;
 }
 

package/dist/mcp-server.d.ts

@@ -34,9 +34,23 @@ export interface HiaiDocsClient {
 	exportDocument(id: string): Promise<{ markdown: string; filename?: string }>;
 }
 
+export interface McpWorkspaceDescriptor {
+  id: string;
+  name: string;
+  slug: string;
+  entireWorkspace: boolean;
+  categoryIds: string[];
+}
+export interface McpWorkspaceRouting {
+  listWorkspaces(): Promise<McpWorkspaceDescriptor[]>;
+  assertSelection(workspaceId: string): Promise<void>;
+}
+export declare function createMcpScopedResult(toolName: 'find_documents' | 'list_workspace_structure' | 'list_trash', input: unknown): unknown;
+
 export interface CreateDocsmintMcpServerOptions {
 	docsClient?: DocsClient;
 	requestContext?: DocsRequestContext;
+  workspaceRouting?: McpWorkspaceRouting;
 	/** @deprecated Inject a legacy capability client only for compatibility. */
 	client?: HiaiDocsClient;
 }
@@ -44,6 +58,7 @@ export interface CreateDocsmintMcpServerOptions {
 export declare function registerDocsmintMcpCapabilities(
 	server: McpServer,
 	client: HiaiDocsClient,
+  workspaceRouting?: McpWorkspaceRouting,
 ): void;
 
 export declare function createDocsmintMcpServer(