@tacitai/mcp-server 0.1.1 → 0.2.0

package/dist/tools/recall.d.ts

@@ -3,6 +3,7 @@
  * Route: POST /api/v1/mind/recall
  */
 import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { TacitClient } from '../client.js';
 export declare const recallInputSchema: z.ZodObject<{
     query: z.ZodString;
@@ -61,3 +62,4 @@ export declare function handleRecall(args: unknown): Promise<{
     }>;
     isError?: boolean;
 }>;
+export declare function registerRecallTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;

package/dist/tools/recall.js

@@ -1,21 +1,16 @@
-"use strict";
 // SPDX-License-Identifier: MIT
 /**
  * tacit_recall — Chronicle event recall (hybrid vector)
  * Route: POST /api/v1/mind/recall
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RECALL_TOOL_DEF = exports.recallInputSchema = void 0;
-exports.buildRecallRequest = buildRecallRequest;
-exports.handleRecall = handleRecall;
-const zod_1 = require("zod");
-const client_js_1 = require("../client.js");
-exports.recallInputSchema = zod_1.z.object({
-    query: zod_1.z.string().min(1).describe('Recall query'),
-    portfolio_id: zod_1.z.string().min(1).describe('Portfolio UUID to scope the recall'),
-    limit: zod_1.z.number().int().positive().optional().describe('Maximum events to return'),
+import { z } from 'zod';
+import { getClient, TacitApiError, TokenExpiredError } from '../client.js';
+export const recallInputSchema = z.object({
+    query: z.string().min(1).describe('Recall query'),
+    portfolio_id: z.string().min(1).describe('Portfolio UUID to scope the recall'),
+    limit: z.number().int().positive().optional().describe('Maximum events to return'),
 });
-exports.RECALL_TOOL_DEF = {
+export const RECALL_TOOL_DEF = {
     name: 'tacit_recall',
     description: 'Recall Chronicle events from Tacit workspace via hybrid vector search. Route: POST /api/v1/mind/recall.',
     inputSchema: {
@@ -32,7 +27,7 @@ exports.RECALL_TOOL_DEF = {
  * Build a recall request object. Call .execute() to perform the HTTP call.
  * Exported for testability (allows injecting a mock TacitClient).
  */
-function buildRecallRequest(client, input) {
+export function buildRecallRequest(client, input) {
     return {
         async execute() {
             const { query, portfolio_id, limit } = input;
@@ -45,7 +40,13 @@ function buildRecallRequest(client, input) {
                 return { content: [{ type: 'text', text: JSON.stringify(result) }] };
             }
             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);
@@ -54,13 +55,23 @@ function buildRecallRequest(client, input) {
         },
     };
 }
-async function handleRecall(args) {
-    const parsed = exports.recallInputSchema.safeParse(args);
+export async function handleRecall(args) {
+    const parsed = recallInputSchema.safeParse(args);
     if (!parsed.success) {
         return {
             content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }],
             isError: true,
         };
     }
-    return buildRecallRequest((0, client_js_1.getClient)(), parsed.data).execute();
+    return buildRecallRequest(getClient(), parsed.data).execute();
+}
+export function registerRecallTools(server, getClientFn) {
+    server.tool('tacit_recall', 'Recall Chronicle events from Tacit workspace via hybrid vector search. Route: POST /api/v1/mind/recall.', {
+        query: z.string().min(1).describe('Recall query'),
+        portfolio_id: z.string().min(1).describe('Portfolio UUID to scope the recall'),
+        limit: z.number().int().positive().optional().describe('Maximum events to return'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildRecallRequest(client, args).execute();
+    });
 }

package/dist/tools/registry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Compile-time tool classification. Governs which tools may be called over HTTPS.
+ * Partition: 6 stdio_only + 15 admin_only + 2 gate_only + 108 https = 131.
+ */
+export type ToolTransport = 'https' | 'stdio_only' | 'admin_only' | 'gate_only';
+export type ToolClass = 'read' | 'write' | 'admin' | 'dispatch';
+export interface ToolEntry {
+    name: string;
+    toolClass: ToolClass;
+    transport: ToolTransport;
+    fs: boolean;
+}
+export declare const TOOL_REGISTRY: ReadonlyMap<string, ToolEntry>;
+/** Unknown tools are blocked (fail closed). */
+export declare function isBlockedOnHttps(toolName: string): boolean;
+export declare function getBlockedReason(toolName: string): 'stdio_only' | 'admin_only' | 'gate_only' | null;
+export declare function getHttpsEligibleTools(): string[];

package/dist/tools/registry.js

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Compile-time tool classification. Governs which tools may be called over HTTPS.
+ * Partition: 6 stdio_only + 15 admin_only + 2 gate_only + 108 https = 131.
+ */
+const STDIO_ONLY = [
+    'tacit_ingest_file',
+    'tacit_outbox_write',
+    'tacit_outbox_flush',
+    'tacit_outbox_status',
+    'tacit_export_to_git',
+    'tacit_switch_workspace',
+];
+const ADMIN_ONLY = [
+    'tacit_delete_portfolio',
+    'tacit_delete_program',
+    'tacit_delete_value_stream',
+    'tacit_pyramid_delete_dossier',
+    'tacit_lake_register_source',
+    'tacit_lake_deregister_source',
+    'tacit_lake_writeback',
+    'tacit_lake_taxonomy_seed',
+    'tacit_lake_taxonomy_upsert_node',
+    'tacit_lake_apply_structure',
+    'tacit_lake_folder_merge',
+    'tacit_lake_folder_remove',
+    'tacit_lake_delete_catalog_item',
+    'tacit_compose',
+    'tacit_converse',
+];
+const GATE_ONLY = ['tacit_approve_gate', 'tacit_reject_gate'];
+const READ_TOOLS = [
+    'tacit_agent_approvals',
+    'tacit_agent_list',
+    'tacit_agent_thread',
+    'tacit_agent_timeline',
+    'tacit_artifact_get',
+    'tacit_artifact_html_token',
+    'tacit_artifact_list',
+    'tacit_artifact_pdf',
+    'tacit_artifact_versions',
+    'tacit_ask',
+    'tacit_chronicle_events',
+    'tacit_chronicle_graph',
+    'tacit_chronicle_search',
+    'tacit_chronicle_timeline',
+    'tacit_converse_messages',
+    'tacit_converse_sessions',
+    'tacit_crew_history',
+    'tacit_crew_status',
+    'tacit_current_workspace',
+    'tacit_draft_search',
+    'tacit_entity_search',
+    'tacit_get_event',
+    'tacit_get_myself',
+    'tacit_get_person',
+    'tacit_get_value_stream',
+    'tacit_kb_browse_tree',
+    'tacit_kb_freshness',
+    'tacit_kb_get_article',
+    'tacit_kb_list_articles',
+    'tacit_kb_list_categories',
+    'tacit_kb_list_collections',
+    'tacit_lake_browse_catalog',
+    'tacit_lake_catalog_detail',
+    'tacit_lake_folder_list',
+    'tacit_lake_list_proposals',
+    'tacit_lake_list_sources',
+    'tacit_lake_manifest',
+    'tacit_lake_resolve',
+    'tacit_lake_sync_status',
+    'tacit_lake_taxonomy_browse',
+    'tacit_list_annotations',
+    'tacit_list_deliverables',
+    'tacit_list_people',
+    'tacit_list_workspaces',
+    'tacit_outbox_status',
+    'tacit_portfolio_artifacts',
+    'tacit_pyramid_get_dossier',
+    'tacit_pyramid_list_dossiers',
+    'tacit_pyramid_list_portfolios',
+    'tacit_pyramid_list_programs',
+    'tacit_pyramid_list_value_streams',
+    'tacit_recall',
+    'tacit_search',
+    'tacit_search_events',
+    'tacit_search_suggest',
+    'tacit_shared_list',
+    'tacit_shared_read',
+    'tacit_shared_search',
+    'tacit_synthesize',
+    'tacit_web_url',
+];
+const DISPATCH_TOOLS = [
+    'tacit_agent_delegate',
+    'tacit_dispatch_crew',
+    'tacit_kb_pull_source',
+    'tacit_lake_trigger_sync',
+    'tacit_research_launch',
+];
+const WRITE_TOOLS = [
+    'tacit_agent_decide',
+    'tacit_annotate',
+    'tacit_approve_gate',
+    'tacit_artifact_create',
+    'tacit_artifact_delete',
+    'tacit_artifact_publish',
+    'tacit_artifact_revise',
+    'tacit_artifact_update',
+    'tacit_create_event',
+    'tacit_create_person',
+    'tacit_edit_deliverable',
+    'tacit_export_to_git',
+    'tacit_import_artifact',
+    'tacit_ingest_file',
+    'tacit_ingest_url',
+    'tacit_ingest_url_general',
+    'tacit_kb_create_article',
+    'tacit_kb_create_category',
+    'tacit_kb_create_collection',
+    'tacit_kb_delete_collection',
+    'tacit_kb_promote_from_artifact',
+    'tacit_kb_promote_from_catalog',
+    'tacit_kb_register_source',
+    'tacit_kb_update_article',
+    'tacit_kb_update_collection',
+    'tacit_lake_classify',
+    'tacit_lake_classify_subject',
+    'tacit_lake_confirm_proposal',
+    'tacit_lake_folder_add',
+    'tacit_lake_folder_rename',
+    'tacit_lake_ingest',
+    'tacit_lake_propose_structure',
+    'tacit_lake_reclassify',
+    'tacit_lake_reclassify_subjects',
+    'tacit_move',
+    'tacit_outbox_flush',
+    'tacit_outbox_write',
+    'tacit_patch_portfolio',
+    'tacit_patch_program',
+    'tacit_patch_value_stream',
+    'tacit_pyramid_assign_program_to_value_stream',
+    'tacit_pyramid_create_dossier',
+    'tacit_pyramid_create_portfolio',
+    'tacit_pyramid_create_program',
+    'tacit_pyramid_create_value_stream',
+    'tacit_pyramid_update_dossier',
+    'tacit_reject_gate',
+    'tacit_research_place',
+    'tacit_research_prepare',
+    'tacit_share_artifact',
+    'tacit_switch_workspace',
+];
+function build() {
+    const map = new Map();
+    const add = (name, toolClass, transport, fs) => {
+        if (map.has(name))
+            throw new Error(`duplicate tool classification: ${name}`);
+        map.set(name, { name, toolClass, transport, fs });
+    };
+    const exclusive = new Set([...STDIO_ONLY, ...ADMIN_ONLY, ...GATE_ONLY]);
+    const classOf = (name) => {
+        if (DISPATCH_TOOLS.includes(name))
+            return 'dispatch';
+        if (READ_TOOLS.includes(name))
+            return 'read';
+        return 'write';
+    };
+    for (const n of STDIO_ONLY)
+        add(n, classOf(n), 'stdio_only', true);
+    for (const n of ADMIN_ONLY)
+        add(n, 'admin', 'admin_only', false);
+    for (const n of GATE_ONLY)
+        add(n, 'write', 'gate_only', false);
+    for (const n of [...READ_TOOLS, ...DISPATCH_TOOLS, ...WRITE_TOOLS]) {
+        if (!exclusive.has(n))
+            add(n, classOf(n), 'https', false);
+    }
+    if (map.size !== 131)
+        throw new Error(`tool registry expected 131 tools, got ${map.size}`);
+    return map;
+}
+export const TOOL_REGISTRY = build();
+/** Unknown tools are blocked (fail closed). */
+export function isBlockedOnHttps(toolName) {
+    const entry = TOOL_REGISTRY.get(toolName);
+    return !entry || entry.transport !== 'https';
+}
+export function getBlockedReason(toolName) {
+    const entry = TOOL_REGISTRY.get(toolName);
+    if (!entry || entry.transport === 'https')
+        return null;
+    return entry.transport;
+}
+export function getHttpsEligibleTools() {
+    return [...TOOL_REGISTRY.values()].filter((e) => e.transport === 'https').map((e) => e.name);
+}

package/dist/tools/research.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Research tools (MV-1525) — scope discovery + grounded prompt assembly,
+ * pyramid/KB placement with T3 confirmation, and async Gemini launch.
+ *
+ * MV-1138b: principal-scoped task store, TTL eviction, per-principal rate
+ * limits, configurable model, hard timeout for running tasks.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { TacitClient } from '../client.js';
+export interface ContextSource {
+    title: string;
+    excerpt: string;
+    source_id: string;
+    source_type: 'kb' | 'pyramid' | 'lake';
+}
+type TaskStatus = {
+    status: 'running';
+    startedAt: number;
+} | {
+    status: 'completed';
+    content: string;
+    token_usage: unknown;
+    model: string;
+    duration_seconds: number;
+    completedAt: number;
+} | {
+    status: 'failed';
+    error: string;
+    failedAt: number;
+};
+interface PrincipalTaskState {
+    principal: string;
+    task: TaskStatus;
+}
+export declare const _testInternals: {
+    readonly tasks: Map<string, PrincipalTaskState>;
+    readonly dailyLaunches: Map<string, DailyCounter>;
+    evictExpired: typeof evictExpired;
+    resetForTest(): void;
+};
+interface DailyCounter {
+    count: number;
+    resetAt: number;
+}
+declare function evictExpired(): void;
+export declare function registerResearchTools(server: McpServer, getClientFn: () => Promise<TacitClient>, getPrincipalFn?: () => string | null): void;
+export {};