@tacitai/mcp-server 0.1.1 → 0.2.0

package/dist/tools/search.js

@@ -1,23 +1,20 @@
-"use strict";
 // SPDX-License-Identifier: MIT
 /**
  * tacit_search — hybrid BM25+ANN+RRF search
  * Route: GET /api/v1/search?q=<term>
  * JWT-scoped; workspace resolved by TacitClient.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEARCH_TOOL_DEF = exports.searchInputSchema = void 0;
-exports.buildSearchRequest = buildSearchRequest;
-exports.handleSearch = handleSearch;
-const zod_1 = require("zod");
-const client_js_1 = require("../client.js");
-exports.searchInputSchema = zod_1.z.object({
-    query: zod_1.z.string().min(1).describe('Search query string'),
-    limit: zod_1.z.number().int().positive().optional().describe('Maximum results to return'),
-    source_types: zod_1.z.array(zod_1.z.string()).optional().describe('Filter by source types (e.g. ["artifact","chronicle"])'),
-    entity_types: zod_1.z.array(zod_1.z.string()).optional().describe('Filter by entity types'),
+import { z } from 'zod';
+import { getClient } from '../client.js';
+import { apiErrorResult } from './errors.js';
+export const searchInputSchema = z.object({
+    query: z.string().min(1).describe('Search query string'),
+    limit: z.number().int().positive().optional().describe('Maximum results to return'),
+    source_types: z.array(z.string()).optional().describe('Filter by source types (e.g. ["artifact","chronicle"])'),
+    entity_types: z.array(z.string()).optional().describe('Filter by entity types'),
+    origin: z.string().optional().describe('Optional origin filter (e.g., PYRAMID, LAKE_SYNC, MANUAL) to scope results'),
 });
-exports.SEARCH_TOOL_DEF = {
+export const SEARCH_TOOL_DEF = {
     name: 'tacit_search',
     description: 'Search Tacit knowledge using hybrid BM25+ANN+RRF against /api/v1/search. Returns ranked results from the workspace corpus.',
     inputSchema: {
@@ -27,6 +24,7 @@ exports.SEARCH_TOOL_DEF = {
             limit: { type: 'number', description: 'Maximum results to return' },
             source_types: { type: 'array', items: { type: 'string' }, description: 'Filter by source types' },
             entity_types: { type: 'array', items: { type: 'string' }, description: 'Filter by entity types' },
+            origin: { type: 'string', description: 'Optional origin filter (e.g., PYRAMID, LAKE_SYNC, MANUAL) to scope results' },
         },
         required: ['query'],
     },
@@ -35,10 +33,10 @@ exports.SEARCH_TOOL_DEF = {
  * Build a search request object. Call .execute() to perform the HTTP call.
  * Exported for testability (allows injecting a mock TacitClient).
  */
-function buildSearchRequest(client, input) {
+export function buildSearchRequest(client, input) {
     return {
         async execute() {
-            const { query, limit, source_types, entity_types } = input;
+            const { query, limit, source_types, entity_types, origin } = input;
             try {
                 const params = { q: query };
                 if (limit !== undefined)
@@ -47,6 +45,8 @@ function buildSearchRequest(client, input) {
                     params['source_types'] = source_types.join(',');
                 if (entity_types && entity_types.length > 0)
                     params['entity_types'] = entity_types.join(',');
+                if (origin !== undefined)
+                    params['origin'] = origin;
                 // GET /api/v1/search?q=<term>
                 const result = await client.get('/api/v1/search', params);
                 return {
@@ -54,25 +54,86 @@ function buildSearchRequest(client, input) {
                 };
             }
             catch (err) {
-                return apiErrorResult(err);
+                return apiErrorResult(err, '/api/v1/search');
             }
         },
     };
 }
-async function handleSearch(args) {
-    const parsed = exports.searchInputSchema.safeParse(args);
+export async function handleSearch(args) {
+    const parsed = searchInputSchema.safeParse(args);
     if (!parsed.success) {
         return {
             content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }],
             isError: true,
         };
     }
-    return buildSearchRequest((0, client_js_1.getClient)(), parsed.data).execute();
+    return buildSearchRequest(getClient(), parsed.data).execute();
 }
-function apiErrorResult(err) {
-    if (err instanceof client_js_1.TacitApiError) {
-        return { content: [{ type: 'text', text: `API error ${err.statusCode}: ${err.body}` }], isError: true };
-    }
-    const msg = err instanceof Error ? err.message : String(err);
-    return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+export function registerSearchTools(server, getClientFn) {
+    server.tool('tacit_search', 'Search Tacit knowledge using hybrid BM25+ANN+RRF against /api/v1/search. Returns ranked results from the workspace corpus.', {
+        query: z.string().min(1).describe('Search query string'),
+        limit: z.number().int().positive().optional().describe('Maximum results to return'),
+        source_types: z.array(z.string()).optional().describe('Filter by source types (e.g. ["artifact","chronicle"])'),
+        entity_types: z.array(z.string()).optional().describe('Filter by entity types'),
+        origin: z.string().optional().describe('Optional origin filter (e.g., PYRAMID, LAKE_SYNC, MANUAL) to scope results'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildSearchRequest(client, args).execute();
+    });
+    server.tool('tacit_search_events', 'Search across all event types using hybrid BM25+ANN retrieval.', {
+        q: z.string().describe('Search query text'),
+        limit: z.number().int().optional().describe('Max results'),
+        source_type: z.string().optional().describe('Filter: CHRONICLE_EVENT or SPECIFIER_DOC'),
+        source_types: z.array(z.string()).optional().describe('Multi-type filter'),
+        domain: z.string().optional().describe('Domain context for pre-ANN GIN filtering'),
+        hybrid: z.boolean().optional().describe('Use hybrid BM25+ANN search'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const params = new URLSearchParams();
+            params.set('q', args.q);
+            if (args.limit !== undefined)
+                params.set('limit', String(args.limit));
+            if (args.source_type)
+                params.set('source_type', args.source_type);
+            if (args.source_types?.length)
+                params.set('source_types', args.source_types.join(','));
+            if (args.domain)
+                params.set('domain', args.domain);
+            if (args.hybrid !== undefined)
+                params.set('hybrid', String(args.hybrid));
+            const data = await client.get(`/api/v1/search`, Object.fromEntries(params));
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return apiErrorResult(err, '/api/v1/search');
+        }
+    });
+    server.tool('tacit_entity_search', 'Search for entities by tag.', {
+        tag: z.string().describe('Entity tag to search for'),
+        limit: z.number().int().optional().describe('Max results (default 20, cap 100)'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.get('/api/v1/search/entity', { tag: args.tag, limit: args.limit });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return apiErrorResult(err, '/api/v1/search/entity');
+        }
+    });
+    server.tool('tacit_search_suggest', 'Get search suggestions for a query prefix.', {
+        q: z.string().describe('Search query prefix'),
+        limit: z.number().int().optional().describe('Max results (default 10, cap 20)'),
+        source_types: z.string().optional().describe('Comma-separated source types'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.get('/api/v1/search/suggest', { q: args.q, limit: args.limit, source_types: args.source_types });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return apiErrorResult(err, '/api/v1/search/suggest');
+        }
+    });
 }

package/dist/tools/sharing.d.ts

@@ -0,0 +1,63 @@
+/**
+ * MV-1518b: Guest sharing MCP tools
+ * tacit_shared_list  — list artifacts shared with the guest
+ * tacit_shared_read  — read a specific shared artifact
+ * tacit_shared_search — search across shared artifacts
+ *
+ * All three require a GUEST JWT. Non-guest JWTs get a 403 from the backend.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TacitClient } from '../client.js';
+type ToolResult = {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+};
+export declare const SHARED_LIST_TOOL_DEF: {
+    name: "tacit_shared_list";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+        required: string[];
+    };
+};
+export declare const SHARED_READ_TOOL_DEF: {
+    name: "tacit_shared_read";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            artifact_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const SHARED_SEARCH_TOOL_DEF: {
+    name: "tacit_shared_search";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleSharedList(_args: unknown): Promise<ToolResult>;
+export declare function handleSharedRead(args: unknown): Promise<ToolResult>;
+export declare function handleSharedSearch(args: unknown): Promise<ToolResult>;
+export declare function registerSharingTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;
+export {};

package/dist/tools/sharing.js

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+/**
+ * MV-1518b: Guest sharing MCP tools
+ * tacit_shared_list  — list artifacts shared with the guest
+ * tacit_shared_read  — read a specific shared artifact
+ * tacit_shared_search — search across shared artifacts
+ *
+ * All three require a GUEST JWT. Non-guest JWTs get a 403 from the backend.
+ */
+import { z } from 'zod';
+import { getClient } from '../client.js';
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+export const SHARED_LIST_TOOL_DEF = {
+    name: 'tacit_shared_list',
+    description: 'List artifacts shared with you (guest access). Returns items from /api/v1/shared-with-me using guest-scoped grants.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+};
+export const SHARED_READ_TOOL_DEF = {
+    name: 'tacit_shared_read',
+    description: 'Read a specific shared artifact by ID (guest access). Returns the artifact content if the guest has a grant for it.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            artifact_id: { type: 'string', description: 'UUID of the artifact to read' },
+        },
+        required: ['artifact_id'],
+    },
+};
+export const SHARED_SEARCH_TOOL_DEF = {
+    name: 'tacit_shared_search',
+    description: 'Search across artifacts shared with you (guest access). Queries /api/v1/search scoped to guest-granted artifacts.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query string' },
+            limit: { type: 'number', description: 'Maximum results to return' },
+        },
+        required: ['query'],
+    },
+};
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+export async function handleSharedList(_args) {
+    try {
+        const client = getClient();
+        const resp = await client.get('/api/v1/shared-with-me');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(resp, null, 2) }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `Error listing shared artifacts: ${message}` }],
+            isError: true,
+        };
+    }
+}
+export async function handleSharedRead(args) {
+    try {
+        const client = getClient();
+        const { artifact_id } = args;
+        if (!artifact_id) {
+            return {
+                content: [{ type: 'text', text: 'artifact_id is required' }],
+                isError: true,
+            };
+        }
+        const resp = await client.get(`/api/v1/artifacts/${artifact_id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(resp, null, 2) }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `Error reading shared artifact: ${message}` }],
+            isError: true,
+        };
+    }
+}
+export async function handleSharedSearch(args) {
+    try {
+        const client = getClient();
+        const { query, limit } = args;
+        if (!query) {
+            return {
+                content: [{ type: 'text', text: 'query is required' }],
+                isError: true,
+            };
+        }
+        const params = { q: query };
+        if (limit)
+            params.limit = limit;
+        const resp = await client.get('/api/v1/search', params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(resp, null, 2) }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `Error searching shared artifacts: ${message}` }],
+            isError: true,
+        };
+    }
+}
+export function registerSharingTools(server, getClientFn) {
+    server.tool('tacit_shared_list', 'List artifacts shared with you (guest access).', {}, async () => {
+        const client = await getClientFn();
+        try {
+            const resp = await client.get('/api/v1/shared-with-me');
+            return { content: [{ type: 'text', text: JSON.stringify(resp, null, 2) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { content: [{ type: 'text', text: `Error listing shared artifacts: ${message}` }], isError: true };
+        }
+    });
+    server.tool('tacit_shared_read', 'Read a specific shared artifact by ID (guest access).', {
+        artifact_id: z.string().min(1).describe('UUID of the artifact to read'),
+    }, async (args) => {
+        const client = await getClientFn();
+        try {
+            const resp = await client.get(`/api/v1/artifacts/${args.artifact_id}`);
+            return { content: [{ type: 'text', text: JSON.stringify(resp, null, 2) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { content: [{ type: 'text', text: `Error reading shared artifact: ${message}` }], isError: true };
+        }
+    });
+    server.tool('tacit_shared_search', 'Search across artifacts shared with you (guest access).', {
+        query: z.string().min(1).describe('Search query string'),
+        limit: z.number().int().positive().optional().describe('Maximum results to return'),
+    }, async (args) => {
+        const client = await getClientFn();
+        try {
+            const params = { q: args.query };
+            if (args.limit)
+                params.limit = args.limit;
+            const resp = await client.get('/api/v1/search', params);
+            return { content: [{ type: 'text', text: JSON.stringify(resp, null, 2) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { content: [{ type: 'text', text: `Error searching shared artifacts: ${message}` }], isError: true };
+        }
+    });
+}

package/dist/tools/synthesize.d.ts

@@ -8,19 +8,38 @@
  * stream:true selects the SSE variant and returns aggregated chunks.
  */
 import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { TacitClient } from '../client.js';
 export declare const synthesizeInputSchema: z.ZodObject<{
     query: z.ZodString;
     scope: z.ZodOptional<z.ZodString>;
     stream: z.ZodOptional<z.ZodBoolean>;
+    workspace_id: z.ZodOptional<z.ZodString>;
+    collection_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    program_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    origin: z.ZodOptional<z.ZodString>;
+    synthesis_mode: z.ZodOptional<z.ZodEnum<["burst", "orbit", "crew_compose"]>>;
+    max_turns: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     query: string;
-    stream?: boolean | undefined;
+    workspace_id?: string | undefined;
     scope?: string | undefined;
+    stream?: boolean | undefined;
+    origin?: string | undefined;
+    collection_ids?: string[] | undefined;
+    program_ids?: string[] | undefined;
+    synthesis_mode?: "burst" | "orbit" | "crew_compose" | undefined;
+    max_turns?: number | undefined;
 }, {
     query: string;
-    stream?: boolean | undefined;
+    workspace_id?: string | undefined;
     scope?: string | undefined;
+    stream?: boolean | undefined;
+    origin?: string | undefined;
+    collection_ids?: string[] | undefined;
+    program_ids?: string[] | undefined;
+    synthesis_mode?: "burst" | "orbit" | "crew_compose" | undefined;
+    max_turns?: number | undefined;
 }>;
 export type SynthesizeInput = z.infer<typeof synthesizeInputSchema>;
 export declare const SYNTHESIZE_TOOL_DEF: {
@@ -41,6 +60,38 @@ export declare const SYNTHESIZE_TOOL_DEF: {
                 type: string;
                 description: string;
             };
+            workspace_id: {
+                type: string;
+                description: string;
+            };
+            collection_ids: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            program_ids: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            origin: {
+                type: string;
+                description: string;
+            };
+            synthesis_mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            max_turns: {
+                type: string;
+                minimum: number;
+                description: string;
+            };
         };
         required: string[];
     };
@@ -66,3 +117,4 @@ export declare function handleSynthesize(args: unknown): Promise<{
     }>;
     isError?: boolean;
 }>;
+export declare function registerSynthesizeTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;

package/dist/tools/synthesize.js

@@ -1,4 +1,3 @@
-"use strict";
 // SPDX-License-Identifier: MIT
 /**
  * tacit_synthesize — canonical synthesis tool
@@ -9,18 +8,20 @@
  * Aliases: tacit_ask / tacit_compose route to this same handler.
  * stream:true selects the SSE variant and returns aggregated chunks.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SYNTHESIZE_TOOL_DEF = exports.synthesizeInputSchema = void 0;
-exports.buildSynthesizeRequest = buildSynthesizeRequest;
-exports.handleSynthesize = handleSynthesize;
-const zod_1 = require("zod");
-const client_js_1 = require("../client.js");
-exports.synthesizeInputSchema = zod_1.z.object({
-    query: zod_1.z.string().min(1).describe('Question or synthesis prompt'),
-    scope: zod_1.z.string().optional().describe('Optional scope filter (e.g. portfolio or program id)'),
-    stream: zod_1.z.boolean().optional().describe('If true, use SSE stream variant (/mind/synthesize/stream)'),
+import { z } from 'zod';
+import { getClient, TacitApiError, TokenExpiredError } from '../client.js';
+export const synthesizeInputSchema = z.object({
+    query: z.string().min(1).describe('Question or synthesis prompt'),
+    scope: z.string().optional().describe('Optional scope filter (e.g. portfolio or program id)'),
+    stream: z.boolean().optional().describe('If true, use SSE stream variant (/mind/synthesize/stream)'),
+    workspace_id: z.string().optional().describe('Optional workspace UUID'),
+    collection_ids: z.array(z.string()).optional().describe('Optional collection UUIDs to scope synthesis to'),
+    program_ids: z.array(z.string()).optional().describe('Optional program UUIDs to scope synthesis to'),
+    origin: z.string().optional().describe('Optional origin filter (e.g., PYRAMID, LAKE_SYNC, MANUAL) to scope results'),
+    synthesis_mode: z.enum(['burst', 'orbit', 'crew_compose']).optional().describe('Synthesis mode: burst (fast retrieval), orbit (agentic multi-turn), crew_compose (crew artifact generation). Default: burst.'),
+    max_turns: z.number().int().min(1).optional().describe('Max agentic loop iterations for orbit/crew_compose mode (1-12 for orbit, 1-54 for crew_compose).'),
 });
-exports.SYNTHESIZE_TOOL_DEF = {
+export const SYNTHESIZE_TOOL_DEF = {
     name: 'tacit_synthesize',
     description: 'Synthesize knowledge from the Tacit workspace. ' +
         'stream:false (default) → POST /api/v1/mind/synthesize (JSON). ' +
@@ -31,6 +32,12 @@ exports.SYNTHESIZE_TOOL_DEF = {
             query: { type: 'string', description: 'Question or synthesis prompt' },
             scope: { type: 'string', description: 'Optional scope filter' },
             stream: { type: 'boolean', description: 'Use SSE stream variant if true' },
+            workspace_id: { type: 'string', description: 'Optional workspace UUID' },
+            collection_ids: { type: 'array', items: { type: 'string' }, description: 'Optional collection UUIDs to scope synthesis to' },
+            program_ids: { type: 'array', items: { type: 'string' }, description: 'Optional program UUIDs to scope synthesis to' },
+            origin: { type: 'string', description: 'Optional origin filter (e.g., PYRAMID, LAKE_SYNC, MANUAL) to scope results' },
+            synthesis_mode: { type: 'string', enum: ['burst', 'orbit', 'crew_compose'], description: 'Synthesis mode: burst (fast retrieval), orbit (agentic multi-turn), crew_compose (crew artifact generation). Default: burst.' },
+            max_turns: { type: 'integer', minimum: 1, description: 'Max agentic loop iterations for orbit/crew_compose mode (1-12 for orbit, 1-54 for crew_compose).' },
         },
         required: ['query'],
     },
@@ -39,29 +46,53 @@ exports.SYNTHESIZE_TOOL_DEF = {
  * Build a synthesize request object. Call .execute() to perform the HTTP call.
  * Exported for testability (allows injecting a mock TacitClient).
  */
-function buildSynthesizeRequest(client, input) {
+export function buildSynthesizeRequest(client, input) {
     return {
         async execute() {
-            const { query, scope, stream } = input;
+            const { query, scope, stream, workspace_id, collection_ids, program_ids, origin, synthesis_mode, max_turns } = input;
             const body = { query };
             if (scope)
                 body['scope'] = scope;
+            if (workspace_id)
+                body['workspace_id'] = workspace_id;
+            if (collection_ids)
+                body['collection_ids'] = collection_ids;
+            if (program_ids)
+                body['program_ids'] = program_ids;
+            if (origin)
+                body['origin'] = origin;
+            if (synthesis_mode)
+                body['synthesis_mode'] = synthesis_mode;
+            if (max_turns)
+                body['max_turns'] = max_turns;
             try {
                 if (stream) {
                     // SSE path: POST /api/v1/mind/synthesize/stream
                     const chunks = [];
+                    let structuredAnswer = null;
                     for await (const chunk of client.postSSE('/api/v1/mind/synthesize/stream', body)) {
+                        try {
+                            const parsed = JSON.parse(chunk);
+                            if (parsed.type === 'structured_answer') {
+                                structuredAnswer = parsed.data;
+                                continue;
+                            }
+                        }
+                        catch {
+                            // not JSON — raw text chunk
+                        }
                         chunks.push(chunk);
                     }
-                    if (chunks.length === 0) {
+                    if (chunks.length === 0 && !structuredAnswer) {
                         return {
                             content: [{ type: 'text', text: JSON.stringify({ chunks: 0, text: '' }) }],
                         };
                     }
-                    // Aggregate: return all chunks as content items for D7 chunk counting.
-                    return {
-                        content: chunks.map((c) => ({ type: 'text', text: c })),
-                    };
+                    const contentItems = chunks.map((c) => ({ type: 'text', text: c }));
+                    if (structuredAnswer) {
+                        contentItems.push({ type: 'text', text: JSON.stringify({ structured_answer: structuredAnswer }) });
+                    }
+                    return { content: contentItems };
                 }
                 else {
                     // JSON path: POST /api/v1/mind/synthesize
@@ -72,7 +103,13 @@ function buildSynthesizeRequest(client, input) {
                 }
             }
             catch (err) {
-                if (err instanceof client_js_1.TacitApiError) {
+                if (err instanceof TokenExpiredError) {
+                    return {
+                        content: [{ type: 'text', text: err.message }],
+                        isError: true,
+                    };
+                }
+                if (err instanceof TacitApiError) {
                     return { content: [{ type: 'text', text: `API error ${err.statusCode}: ${err.body}` }], isError: true };
                 }
                 const msg = err instanceof Error ? err.message : String(err);
@@ -81,13 +118,33 @@ function buildSynthesizeRequest(client, input) {
         },
     };
 }
-async function handleSynthesize(args) {
-    const parsed = exports.synthesizeInputSchema.safeParse(args);
+export async function handleSynthesize(args) {
+    const parsed = synthesizeInputSchema.safeParse(args);
     if (!parsed.success) {
         return {
             content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }],
             isError: true,
         };
     }
-    return buildSynthesizeRequest((0, client_js_1.getClient)(), parsed.data).execute();
+    return buildSynthesizeRequest(getClient(), parsed.data).execute();
+}
+const SYNTH_SCHEMA = {
+    query: z.string().min(1).describe('Question or synthesis prompt'),
+    scope: z.string().optional().describe('Optional scope filter (e.g. portfolio or program id)'),
+    stream: z.boolean().optional().describe('If true, use SSE stream variant (/mind/synthesize/stream)'),
+    workspace_id: z.string().optional().describe('Optional workspace UUID'),
+    collection_ids: z.array(z.string()).optional().describe('Optional collection UUIDs to scope synthesis to'),
+    program_ids: z.array(z.string()).optional().describe('Optional program UUIDs to scope synthesis to'),
+    origin: z.string().optional().describe('Optional origin filter (e.g., PYRAMID, LAKE_SYNC, MANUAL) to scope results'),
+    synthesis_mode: z.enum(['burst', 'orbit', 'crew_compose']).optional().describe('Synthesis mode: burst (fast retrieval), orbit (agentic multi-turn), crew_compose (crew artifact generation). Default: burst.'),
+    max_turns: z.number().int().min(1).optional().describe('Max agentic loop iterations for orbit/crew_compose mode (1-12 for orbit, 1-54 for crew_compose).'),
+};
+export function registerSynthesizeTools(server, getClientFn) {
+    const handler = async (args) => {
+        const client = await getClientFn();
+        return buildSynthesizeRequest(client, args).execute();
+    };
+    server.tool('tacit_synthesize', 'Synthesize knowledge from the Tacit workspace. synthesis_mode: burst (default, fast retrieval), orbit (agentic multi-turn), crew_compose (crew artifact generation). stream:false → JSON, stream:true → SSE.', SYNTH_SCHEMA, handler);
+    server.tool('tacit_ask', 'Ask a question against the Tacit workspace. Supports synthesis_mode: burst (default), orbit (agentic), crew_compose.', SYNTH_SCHEMA, handler);
+    server.tool('tacit_compose', 'Compose knowledge from the Tacit workspace. Supports synthesis_mode: burst (default), orbit (agentic), crew_compose.', SYNTH_SCHEMA, handler);
 }