@tacitai/mcp-server 0.1.1 → 0.3.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/skills.d.ts

@@ -0,0 +1,9 @@
+/**
+ * tacit_list_skills / tacit_run_skill — MCP skill orchestration (MV-1533 W6)
+ *
+ * GET  /api/v1/internal/skills — list available exec skills
+ * POST /api/v1/converse — invoke a skill by hint (SSE stream)
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TacitClient } from '../client.js';
+export declare function registerSkillTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;

package/dist/tools/skills.js

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+/**
+ * tacit_list_skills / tacit_run_skill — MCP skill orchestration (MV-1533 W6)
+ *
+ * GET  /api/v1/internal/skills — list available exec skills
+ * POST /api/v1/converse — invoke a skill by hint (SSE stream)
+ */
+import { z } from 'zod';
+export function registerSkillTools(server, getClientFn) {
+    // --- tacit_list_skills ---
+    server.tool('tacit_list_skills', 'List available TACIT exec skills with their domains, descriptions, and access levels.', {}, async () => {
+        const client = await getClientFn();
+        try {
+            const data = await client.get('/api/v1/internal/skills');
+            return {
+                content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { content: [{ type: 'text', text: `Error listing skills: ${msg}` }], isError: true };
+        }
+    });
+    // --- tacit_run_skill ---
+    server.tool('tacit_run_skill', 'Run a TACIT exec skill by name. Sends the message through the converse pipeline with skill_hint routing. Returns the skill response, which may include tool calls, structured answers, or approval requests.', {
+        skill_id: z.string().min(1).describe('The skill domain ID (e.g., "pyr-exec", "lake-exec", "kb-exec", "sales-exec", "gm-exec")'),
+        message: z.string().min(1).describe('The natural-language instruction for the skill'),
+        session_id: z.string().optional().describe('Existing converse session UUID to continue; omit for a new session'),
+    }, async (args) => {
+        const client = await getClientFn();
+        // Validate skill_id against the catalog
+        try {
+            const catalog = await client.get('/api/v1/internal/skills');
+            const validDomains = catalog.skills.map((s) => s.domain);
+            if (!validDomains.includes(args.skill_id)) {
+                return {
+                    content: [{ type: 'text', text: `Unknown skill_id "${args.skill_id}". Valid skills: ${validDomains.join(', ')}` }],
+                    isError: true,
+                };
+            }
+        }
+        catch {
+            // Catalog unreachable — proceed anyway, backend will validate
+        }
+        const body = {
+            message: args.message,
+            skill_hint: args.skill_id,
+            channel: 'mcp',
+        };
+        if (args.session_id)
+            body['session_id'] = args.session_id;
+        try {
+            const chunks = [];
+            let sessionId = '';
+            let structuredAnswer = null;
+            let pendingApproval = null;
+            for await (const chunk of client.postSSE('/api/v1/converse', body)) {
+                try {
+                    const parsed = JSON.parse(chunk);
+                    if (parsed.type === 'session_start')
+                        sessionId = parsed.session_id;
+                    else if (parsed.type === 'token')
+                        chunks.push(parsed.delta);
+                    else if (parsed.type === 'structured_answer')
+                        structuredAnswer = parsed.data;
+                    else if (parsed.type === 'pending_approval')
+                        pendingApproval = parsed;
+                    else if (parsed.type === 'tool_call_end') {
+                        if (parsed.result)
+                            chunks.push(typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result));
+                    }
+                }
+                catch {
+                    chunks.push(chunk);
+                }
+            }
+            const text = chunks.join('');
+            const result = {
+                skill_id: args.skill_id,
+                session_id: sessionId,
+                response: text,
+            };
+            if (structuredAnswer)
+                result['structured_answer'] = structuredAnswer;
+            if (pendingApproval) {
+                result['pending_approval'] = pendingApproval;
+                result['instructions'] = 'This operation requires approval. Use tacit_converse with the session_id and confirm_token to approve or reject.';
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { content: [{ type: 'text', text: `Error running skill ${args.skill_id}: ${msg}` }], 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;