@tacitai/mcp-server 0.1.1 → 0.2.0

package/dist/tools/research.js

@@ -0,0 +1,575 @@
+// SPDX-License-Identifier: MIT
+/**
+ * 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 { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { apiErrorResult } from './errors.js';
+function ok(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+function fail(message) {
+    return { content: [{ type: 'text', text: message }], isError: true };
+}
+function asRecords(value, ...keys) {
+    if (Array.isArray(value))
+        return value;
+    if (value && typeof value === 'object') {
+        for (const k of keys) {
+            const v = value[k];
+            if (Array.isArray(v))
+                return v;
+        }
+    }
+    return [];
+}
+function str(v) {
+    return typeof v === 'string' ? v : v == null ? '' : String(v);
+}
+function excerptOf(r) {
+    const raw = str(r['excerpt'] ?? r['snippet'] ?? r['summary'] ?? r['description'] ?? r['content']);
+    return raw.length > 400 ? `${raw.slice(0, 400)}...` : raw;
+}
+function toSource(r, type) {
+    return {
+        title: str(r['title'] ?? r['name'] ?? r['file_name'] ?? r['path']) || '(untitled)',
+        excerpt: excerptOf(r),
+        source_id: str(r['id'] ?? r['source_id'] ?? r['article_id'] ?? r['entity_id']),
+        source_type: type,
+    };
+}
+const VERIFICATION_DIRECTIVE = `IMPORTANT: The following company knowledge is provided as research leads to verify,
+not facts to repeat. Before citing any company-sourced information in your report,
+verify it by calling the relevant TACIT MCP tool (tacit_search, tacit_kb_get_article, etc.).
+Verified facts should be cited from the tool response. Do not state unverified company
+information as fact.`;
+function buildGroundedPrompt(topic, sources) {
+    const leads = sources.length
+        ? sources
+            .map((s, i) => `${i + 1}. [${s.source_type}:${s.source_id}] ${s.title}${s.excerpt ? ` — ${s.excerpt}` : ''}`)
+            .join('\n')
+        : '(no company context found for the selected scope)';
+    return [
+        `# Research Topic\n${topic}`,
+        VERIFICATION_DIRECTIVE,
+        `## Research leads to verify\n${leads}`,
+    ].join('\n\n');
+}
+function envInt(key, fallback) {
+    const v = Number.parseInt(process.env[key] ?? '', 10);
+    return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+const MAX_TASKS = envInt('MCP_RESEARCH_MAX_TASKS', 500);
+const MAX_CONCURRENT = envInt('MCP_RESEARCH_MAX_CONCURRENT', 3);
+const DAILY_CAP = envInt('MCP_RESEARCH_DAILY_CAP', 50);
+const COMPLETED_TTL_MS = 60 * 60 * 1000; // 1 hour
+const RUNNING_HARD_TIMEOUT_MS = 2 * 60 * 60 * 1000; // 2 hours
+export const _testInternals = {
+    get tasks() { return tasks; },
+    get dailyLaunches() { return dailyLaunches; },
+    evictExpired,
+    resetForTest() {
+        tasks.clear();
+        dailyLaunches.clear();
+    },
+};
+const tasks = new Map();
+const dailyLaunches = new Map();
+function midnightUtc() {
+    const now = new Date();
+    const tomorrow = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1));
+    return tomorrow.getTime();
+}
+function getDailyCount(principal) {
+    const entry = dailyLaunches.get(principal);
+    if (!entry)
+        return 0;
+    if (Date.now() >= entry.resetAt) {
+        dailyLaunches.delete(principal);
+        return 0;
+    }
+    return entry.count;
+}
+function incrementDailyCount(principal) {
+    const entry = dailyLaunches.get(principal);
+    if (!entry || Date.now() >= entry.resetAt) {
+        dailyLaunches.set(principal, { count: 1, resetAt: midnightUtc() });
+    }
+    else {
+        entry.count += 1;
+    }
+}
+function countRunning(principal) {
+    let count = 0;
+    for (const entry of tasks.values()) {
+        if (entry.principal === principal && entry.task.status === 'running')
+            count++;
+    }
+    return count;
+}
+function evictExpired() {
+    const now = Date.now();
+    for (const [id, entry] of tasks) {
+        const t = entry.task;
+        if (t.status === 'running' && now - t.startedAt > RUNNING_HARD_TIMEOUT_MS) {
+            tasks.set(id, {
+                principal: entry.principal,
+                task: { status: 'failed', error: 'task timed out (exceeded 2 hour limit)', failedAt: now },
+            });
+        }
+        else if (t.status === 'completed' && now - t.completedAt > COMPLETED_TTL_MS) {
+            tasks.delete(id);
+        }
+        else if (t.status === 'failed' && now - t.failedAt > COMPLETED_TTL_MS) {
+            tasks.delete(id);
+        }
+    }
+}
+function evictForCapacity() {
+    evictExpired();
+    if (tasks.size < MAX_TASKS)
+        return true;
+    // Evict oldest completed/failed first
+    let oldestId = null;
+    let oldestTime = Infinity;
+    for (const [id, entry] of tasks) {
+        const t = entry.task;
+        if (t.status === 'completed' && t.completedAt < oldestTime) {
+            oldestTime = t.completedAt;
+            oldestId = id;
+        }
+        else if (t.status === 'failed' && t.failedAt < oldestTime) {
+            oldestTime = t.failedAt;
+            oldestId = id;
+        }
+    }
+    if (oldestId) {
+        tasks.delete(oldestId);
+        return true;
+    }
+    return tasks.size < MAX_TASKS;
+}
+// Periodic cleanup every 60s
+let _cleanupInterval = null;
+function ensureCleanupInterval() {
+    if (_cleanupInterval)
+        return;
+    _cleanupInterval = setInterval(evictExpired, 60_000);
+    if (_cleanupInterval && typeof _cleanupInterval === 'object' && 'unref' in _cleanupInterval) {
+        _cleanupInterval.unref();
+    }
+}
+function resolveModel(override) {
+    return override ?? process.env['MCP_RESEARCH_MODEL'] ?? 'deep-research-max-preview-04-2026';
+}
+function isDeepResearchModel(model) {
+    return model.includes('deep-research');
+}
+async function runGemini(taskId, principal, apiKey, model, prompt) {
+    const startedAt = Date.now();
+    try {
+        const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'x-goog-api-key': apiKey },
+            body: JSON.stringify({ contents: [{ parts: [{ text: prompt }] }] }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            tasks.set(taskId, {
+                principal,
+                task: { status: 'failed', error: `Gemini API error ${res.status}: ${body.slice(0, 500)}`, failedAt: Date.now() },
+            });
+            return;
+        }
+        const data = (await res.json());
+        const content = (data.candidates?.[0]?.content?.parts ?? []).map((p) => p.text ?? '').join('');
+        tasks.set(taskId, {
+            principal,
+            task: {
+                status: 'completed',
+                content,
+                token_usage: data.usageMetadata ?? null,
+                model,
+                duration_seconds: Math.round((Date.now() - startedAt) / 100) / 10,
+                completedAt: Date.now(),
+            },
+        });
+    }
+    catch (err) {
+        tasks.set(taskId, {
+            principal,
+            task: { status: 'failed', error: err instanceof Error ? err.message : String(err), failedAt: Date.now() },
+        });
+    }
+}
+const DEEP_RESEARCH_POLL_INTERVAL_MS = 5_000;
+const DEEP_RESEARCH_MAX_POLL_MS = 30 * 60 * 1000;
+const DEEP_RESEARCH_MAX_POLL_FAILURES = 3;
+const DEEP_RESEARCH_FETCH_TIMEOUT_MS = 30_000;
+const DEEP_RESEARCH_CONTINUABLE = new Set(['in_progress', 'queued', 'pending']);
+function safeErrorString(err) {
+    if (typeof err === 'string')
+        return err;
+    if (err instanceof Error)
+        return err.message;
+    try {
+        return JSON.stringify(err);
+    }
+    catch {
+        return String(err);
+    }
+}
+async function runDeepResearch(taskId, principal, apiKey, agent, prompt) {
+    const startedAt = Date.now();
+    try {
+        const startRes = await fetch('https://generativelanguage.googleapis.com/v1beta/interactions', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'x-goog-api-key': apiKey },
+            body: JSON.stringify({ input: prompt, agent, background: true }),
+            signal: AbortSignal.timeout(DEEP_RESEARCH_FETCH_TIMEOUT_MS),
+        });
+        if (!startRes.ok) {
+            const body = await startRes.text().catch(() => '');
+            tasks.set(taskId, {
+                principal,
+                task: { status: 'failed', error: `Deep Research API error ${startRes.status}: ${body.slice(0, 500)}`, failedAt: Date.now() },
+            });
+            return;
+        }
+        const startData = (await startRes.json());
+        const interactionId = startData.id;
+        if (!interactionId) {
+            tasks.set(taskId, {
+                principal,
+                task: { status: 'failed', error: 'Deep Research API returned no interaction ID', failedAt: Date.now() },
+            });
+            return;
+        }
+        const deadline = startedAt + DEEP_RESEARCH_MAX_POLL_MS;
+        let consecutiveFailures = 0;
+        while (Date.now() < deadline) {
+            await new Promise(resolve => setTimeout(resolve, DEEP_RESEARCH_POLL_INTERVAL_MS));
+            let pollRes;
+            try {
+                pollRes = await fetch(`https://generativelanguage.googleapis.com/v1beta/interactions/${encodeURIComponent(interactionId)}`, {
+                    headers: { 'x-goog-api-key': apiKey },
+                    signal: AbortSignal.timeout(DEEP_RESEARCH_FETCH_TIMEOUT_MS),
+                });
+            }
+            catch (fetchErr) {
+                consecutiveFailures++;
+                if (consecutiveFailures >= DEEP_RESEARCH_MAX_POLL_FAILURES) {
+                    tasks.set(taskId, {
+                        principal,
+                        task: { status: 'failed', error: `Deep Research poll failed ${consecutiveFailures} times: ${safeErrorString(fetchErr)}`, failedAt: Date.now() },
+                    });
+                    return;
+                }
+                continue;
+            }
+            if (!pollRes.ok) {
+                consecutiveFailures++;
+                if (consecutiveFailures >= DEEP_RESEARCH_MAX_POLL_FAILURES) {
+                    const body = await pollRes.text().catch(() => '');
+                    tasks.set(taskId, {
+                        principal,
+                        task: { status: 'failed', error: `Deep Research poll error ${pollRes.status} (${consecutiveFailures} consecutive): ${body.slice(0, 500)}`, failedAt: Date.now() },
+                    });
+                    return;
+                }
+                continue;
+            }
+            consecutiveFailures = 0;
+            const pollData = (await pollRes.json());
+            if (pollData.status === 'failed') {
+                tasks.set(taskId, {
+                    principal,
+                    task: { status: 'failed', error: safeErrorString(pollData.error) || 'Deep Research task failed', failedAt: Date.now() },
+                });
+                return;
+            }
+            if (pollData.status === 'completed') {
+                const steps = pollData.steps ?? [];
+                const content = steps
+                    .flatMap(s => s.content ?? [])
+                    .filter(p => p.type === 'text')
+                    .map(p => p.text ?? '')
+                    .join('');
+                if (!content) {
+                    tasks.set(taskId, {
+                        principal,
+                        task: { status: 'failed', error: 'Deep Research completed but returned no text content', failedAt: Date.now() },
+                    });
+                    return;
+                }
+                tasks.set(taskId, {
+                    principal,
+                    task: {
+                        status: 'completed',
+                        content,
+                        token_usage: null,
+                        model: agent,
+                        duration_seconds: Math.round((Date.now() - startedAt) / 100) / 10,
+                        completedAt: Date.now(),
+                    },
+                });
+                return;
+            }
+            if (!DEEP_RESEARCH_CONTINUABLE.has(pollData.status ?? '')) {
+                tasks.set(taskId, {
+                    principal,
+                    task: { status: 'failed', error: `Deep Research returned unexpected status: ${pollData.status}`, failedAt: Date.now() },
+                });
+                return;
+            }
+        }
+        tasks.set(taskId, {
+            principal,
+            task: { status: 'failed', error: 'Deep Research task timed out (exceeded 30 min polling limit)', failedAt: Date.now() },
+        });
+    }
+    catch (err) {
+        tasks.set(taskId, {
+            principal,
+            task: { status: 'failed', error: safeErrorString(err), failedAt: Date.now() },
+        });
+    }
+}
+// ─── Registration ────────────────────────────────────────────────────────────
+export function registerResearchTools(server, getClientFn, getPrincipalFn) {
+    ensureCleanupInterval();
+    // tacit_research_prepare
+    server.tool('tacit_research_prepare', 'Prepare a grounded research prompt. Without scope params, returns available scopes (collections, programs, portfolios) to choose from. With scope params, gathers KB/pyramid/lake context and returns a prompt that treats company knowledge as leads to verify.', {
+        topic: z.string().describe('Research topic'),
+        collection_ids: z.array(z.string()).optional().describe('KB collection IDs to scope'),
+        program_ids: z.array(z.string()).optional().describe('Pyramid program IDs to scope'),
+        portfolio_ids: z.array(z.string()).optional().describe('Pyramid portfolio IDs to scope'),
+    }, async (args) => {
+        const { topic } = args;
+        const collection_ids = args.collection_ids ?? [];
+        const program_ids = args.program_ids ?? [];
+        const portfolio_ids = args.portfolio_ids ?? [];
+        const hasScope = collection_ids.length + program_ids.length + portfolio_ids.length > 0;
+        try {
+            const client = await getClientFn();
+            if (!hasScope) {
+                const [colRes, portRes, progRes] = await Promise.allSettled([
+                    client.get('/api/v1/kb/collections'),
+                    client.get('/api/v1/portfolios'),
+                    client.get('/api/v1/programs'),
+                ]);
+                return ok({
+                    requires_scope: true,
+                    available_scopes: {
+                        collections: colRes.status === 'fulfilled' ? asRecords(colRes.value, 'collections', 'items') : [],
+                        portfolios: portRes.status === 'fulfilled' ? asRecords(portRes.value, 'portfolios', 'items') : [],
+                        programs: progRes.status === 'fulfilled' ? asRecords(progRes.value, 'programs', 'items') : [],
+                    },
+                });
+            }
+            const sources = [];
+            try {
+                const searchRes = await client.post('/api/v1/search', { query: topic });
+                for (const r of asRecords(searchRes, 'results', 'items')) {
+                    sources.push(toSource(r, 'kb'));
+                }
+            }
+            catch { /* search endpoint unavailable — continue without it */ }
+            for (const id of collection_ids) {
+                try {
+                    const articles = await client.get(`/api/v1/kb/collections/${encodeURIComponent(id)}/articles`);
+                    for (const r of asRecords(articles, 'articles', 'items'))
+                        sources.push(toSource(r, 'kb'));
+                }
+                catch { /* collection unavailable */ }
+            }
+            for (const id of portfolio_ids) {
+                try {
+                    const programs = await client.get(`/api/v1/portfolios/${encodeURIComponent(id)}/programs`);
+                    for (const r of asRecords(programs, 'programs', 'items'))
+                        sources.push(toSource(r, 'pyramid'));
+                }
+                catch { /* portfolio unavailable */ }
+            }
+            try {
+                const lake = await client.get('/api/v1/org/lake/catalog');
+                for (const r of asRecords(lake, 'items', 'catalog', 'entries'))
+                    sources.push(toSource(r, 'lake'));
+            }
+            catch { /* lake endpoint unavailable */ }
+            return ok({
+                prompt: buildGroundedPrompt(topic, sources),
+                context_sources: sources,
+                metadata: { topic, scope_used: { collection_ids, program_ids, portfolio_ids } },
+            });
+        }
+        catch (err) {
+            return apiErrorResult(err, 'tacit_research_prepare');
+        }
+    });
+    // tacit_research_place
+    server.tool('tacit_research_place', 'Place a research report. No pyramid_target: lists available targets. content + pyramid_target: creates a DRAFT artifact and asks for confirmation. artifact_id + confirm_promote=true (T3): promotes to KB and links into the pyramid.', {
+        content: z.string().optional().describe('Research content (HTML)'),
+        title: z.string().optional().describe('Artifact title'),
+        pyramid_target: z
+            .object({
+            portfolio_id: z.string(),
+            program_id: z.string(),
+            dossier_id: z.string().optional(),
+        })
+            .optional()
+            .describe('Target placement in the pyramid'),
+        artifact_id: z.string().optional().describe('Existing artifact ID for confirmation'),
+        confirm_promote: z.boolean().optional().describe('Confirm KB promotion (T3)'),
+    }, async (args) => {
+        const { content, title, pyramid_target: target, artifact_id, confirm_promote } = args;
+        try {
+            const client = await getClientFn();
+            if (!target) {
+                const [portRes, progRes] = await Promise.allSettled([
+                    client.get('/api/v1/portfolios'),
+                    client.get('/api/v1/programs'),
+                ]);
+                return ok({
+                    requires_placement: true,
+                    available_targets: {
+                        portfolios: portRes.status === 'fulfilled' ? asRecords(portRes.value, 'portfolios', 'items') : [],
+                        programs: progRes.status === 'fulfilled' ? asRecords(progRes.value, 'programs', 'items') : [],
+                    },
+                });
+            }
+            if (artifact_id && confirm_promote === true) {
+                let kbArticleId;
+                let pyramidMoved = false;
+                const placements = [];
+                try {
+                    const kbArticle = await client.post('/api/v1/kb/promote-from-artifact', { artifact_id });
+                    kbArticleId = str(kbArticle['article_id'] ?? kbArticle['id']) || undefined;
+                }
+                catch { /* KB promote not available */ }
+                try {
+                    const moved = await client.post('/api/v1/move', {
+                        artifact_id,
+                        placement: { pyramid: { portfolio_id: target.portfolio_id, program_id: target.program_id } },
+                    });
+                    placements.push(moved);
+                    pyramidMoved = true;
+                }
+                catch { /* move endpoint not available */ }
+                if (target.dossier_id) {
+                    try {
+                        const dossierPath = `/api/v1/dossiers/${encodeURIComponent(target.dossier_id)}`;
+                        const dossier = await client.get(dossierPath);
+                        const existing = Array.isArray(dossier['document_ids']) ? dossier['document_ids'] : [];
+                        const documentIds = existing.includes(artifact_id) ? existing : [...existing, artifact_id];
+                        const updated = await client.put(dossierPath, { ...dossier, document_ids: documentIds });
+                        placements.push(updated);
+                    }
+                    catch { /* dossier link not available */ }
+                }
+                return ok({
+                    artifact_id,
+                    kb_article_id: kbArticleId ?? null,
+                    pyramid_path: {
+                        portfolio_id: target.portfolio_id,
+                        program_id: target.program_id,
+                        dossier_id: target.dossier_id,
+                    },
+                    pyramid_moved: pyramidMoved,
+                    placements,
+                });
+            }
+            if (content) {
+                const created = await client.post('/api/v1/artifacts', {
+                    title: title ?? 'Research Report',
+                    content,
+                    domain: 'research',
+                    output_format: 'DOCUMENT',
+                    portfolio_id: target.portfolio_id,
+                    artifact_kind: 'research_report',
+                });
+                return ok({
+                    artifact_id: created['artifact_id'] ?? created['id'],
+                    requires_confirmation: true,
+                    pending_operations: ['kb_promote', 'pyramid_link'],
+                    status: 'DRAFT',
+                });
+            }
+            return fail('Provide content (to create a DRAFT) or artifact_id with confirm_promote=true (to confirm placement).');
+        }
+        catch (err) {
+            return apiErrorResult(err, 'tacit_research_place');
+        }
+    });
+    // tacit_research_launch
+    server.tool('tacit_research_launch', 'Launch a research run asynchronously (returns task_id), or poll an existing run with task_id. Requires GEMINI_API_KEY. Default: Deep Research (Interactions API, deep-research-max-preview-04-2026). Pass a regular gemini model name to use generateContent instead. Model configurable via MCP_RESEARCH_MODEL env var.', {
+        prompt: z.string().optional().describe('Research prompt'),
+        model: z.string().optional().describe('Model or agent ID (default: deep-research-max-preview-04-2026; pass a gemini-* model to use generateContent instead)'),
+        output_format: z.string().optional().describe('Output format (default: text)'),
+        task_id: z.string().optional().describe('Task ID to check status'),
+    }, async (args) => {
+        const { prompt, model, output_format, task_id } = args;
+        const principal = getPrincipalFn?.() ?? 'anonymous';
+        if (task_id) {
+            evictExpired();
+            const entry = tasks.get(task_id);
+            if (!entry)
+                return fail(`Unknown task_id: ${task_id}`);
+            if (entry.principal !== principal) {
+                return fail(`Access denied: task belongs to a different principal`);
+            }
+            const t = entry.task;
+            if (t.status === 'running') {
+                if (Date.now() - t.startedAt > RUNNING_HARD_TIMEOUT_MS) {
+                    const failedTask = { status: 'failed', error: 'task timed out (exceeded 2 hour limit)', failedAt: Date.now() };
+                    tasks.set(task_id, { principal: entry.principal, task: failedTask });
+                    return ok({ error: failedTask.error, status: 'failed' });
+                }
+                return ok({ task_id, status: 'running' });
+            }
+            if (t.status === 'failed')
+                return ok({ error: t.error, status: 'failed' });
+            return ok({
+                content: t.content,
+                token_usage: t.token_usage,
+                model: t.model,
+                duration_seconds: t.duration_seconds,
+                status: 'completed',
+            });
+        }
+        if (!prompt)
+            return fail('Provide prompt to start a research run, or task_id to check status.');
+        const apiKey = process.env['GEMINI_API_KEY'];
+        if (!apiKey) {
+            return fail('GEMINI_API_KEY is not set in the MCP server environment. Set it and restart the server to use tacit_research_launch.');
+        }
+        // Per-principal concurrent limit
+        if (countRunning(principal) >= MAX_CONCURRENT) {
+            return fail(`Concurrent research limit reached (${MAX_CONCURRENT} running). Wait for existing tasks to complete.`);
+        }
+        // Per-principal daily cap
+        if (getDailyCount(principal) >= DAILY_CAP) {
+            return fail(`Daily research launch limit reached (${DAILY_CAP}). Try again tomorrow.`);
+        }
+        // Task store capacity
+        if (!evictForCapacity()) {
+            return fail('Task store is full. Wait for existing tasks to complete or expire.');
+        }
+        const newId = randomUUID();
+        const resolvedModel = resolveModel(model);
+        const finalPrompt = output_format && output_format !== 'text' ? `${prompt}\n\nOutput format: ${output_format}` : prompt;
+        tasks.set(newId, { principal, task: { status: 'running', startedAt: Date.now() } });
+        incrementDailyCount(principal);
+        if (isDeepResearchModel(resolvedModel)) {
+            void runDeepResearch(newId, principal, apiKey, resolvedModel, finalPrompt);
+        }
+        else {
+            void runGemini(newId, principal, apiKey, resolvedModel, finalPrompt);
+        }
+        return ok({ task_id: newId, status: 'running' });
+    });
+}

package/dist/tools/search.d.ts

@@ -4,22 +4,26 @@
  * JWT-scoped; workspace resolved by TacitClient.
  */
 import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { TacitClient } from '../client.js';
 export declare const searchInputSchema: z.ZodObject<{
     query: z.ZodString;
     limit: z.ZodOptional<z.ZodNumber>;
     source_types: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     entity_types: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    origin: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     query: string;
     limit?: number | undefined;
     source_types?: string[] | undefined;
     entity_types?: string[] | undefined;
+    origin?: string | undefined;
 }, {
     query: string;
     limit?: number | undefined;
     source_types?: string[] | undefined;
     entity_types?: string[] | undefined;
+    origin?: string | undefined;
 }>;
 export type SearchInput = z.infer<typeof searchInputSchema>;
 export declare const SEARCH_TOOL_DEF: {
@@ -50,6 +54,10 @@ export declare const SEARCH_TOOL_DEF: {
                 };
                 description: string;
             };
+            origin: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
     };
@@ -75,3 +83,4 @@ export declare function handleSearch(args: unknown): Promise<{
     }>;
     isError?: boolean;
 }>;
+export declare function registerSearchTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;