@tacitai/mcp-server 0.1.1 → 0.3.0

package/dist/tools/lake.d.ts

@@ -0,0 +1,932 @@
+/**
+ * Lake tools — CLI wrappers for data lake source, sync, proposal,
+ * classification, catalog, taxonomy, and subject-classification operations
+ * on the Axum REST API.
+ *
+ * Routes (Axum, all under /api/v1/org/lake):
+ *   POST   /onboard
+ *   GET    /sources
+ *   DELETE /sources/:id
+ *   GET    /status
+ *   POST   /sync
+ *   GET    /proposals
+ *   POST   /proposals/confirm
+ *   POST   /classify
+ *   POST   /catalog/:id/reclassify
+ *   POST   /writeback
+ *   GET    /catalog
+ *   GET    /catalog/:id
+ *   DELETE /catalog/:id
+ *   POST   /ingest
+ *   GET    /taxonomy
+ *   POST   /taxonomy/seed
+ *   POST   /taxonomy/nodes
+ *   POST   /catalog/:id/subject
+ *   POST   /catalog/subject/bulk
+ */
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TacitClient } from '../client.js';
+export interface ToolRequest {
+    execute(): Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+        isError?: boolean;
+    }>;
+}
+export declare const registerSourceInputSchema: z.ZodObject<{
+    source: z.ZodString;
+    kind: z.ZodOptional<z.ZodString>;
+    sync_mode: z.ZodOptional<z.ZodString>;
+    interval: z.ZodOptional<z.ZodNumber>;
+    write_back: z.ZodOptional<z.ZodBoolean>;
+    write_back_path: z.ZodOptional<z.ZodString>;
+    default_kb_collection: z.ZodOptional<z.ZodString>;
+    webhook_secret: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    kind?: string | undefined;
+    sync_mode?: string | undefined;
+    interval?: number | undefined;
+    write_back?: boolean | undefined;
+    write_back_path?: string | undefined;
+    default_kb_collection?: string | undefined;
+    webhook_secret?: string | undefined;
+}, {
+    source: string;
+    kind?: string | undefined;
+    sync_mode?: string | undefined;
+    interval?: number | undefined;
+    write_back?: boolean | undefined;
+    write_back_path?: string | undefined;
+    default_kb_collection?: string | undefined;
+    webhook_secret?: string | undefined;
+}>;
+export type RegisterSourceInput = z.infer<typeof registerSourceInputSchema>;
+export declare const REGISTER_SOURCE_TOOL_DEF: {
+    name: "tacit_lake_register_source";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            source: {
+                type: string;
+                description: string;
+            };
+            kind: {
+                type: string;
+                description: string;
+            };
+            sync_mode: {
+                type: string;
+                description: string;
+            };
+            interval: {
+                type: string;
+                description: string;
+            };
+            write_back: {
+                type: string;
+                description: string;
+            };
+            write_back_path: {
+                type: string;
+                description: string;
+            };
+            default_kb_collection: {
+                type: string;
+                description: string;
+            };
+            webhook_secret: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildRegisterSourceRequest(client: TacitClient, input: RegisterSourceInput): ToolRequest;
+export declare function handleRegisterSource(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const listSourcesInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type ListSourcesInput = z.infer<typeof listSourcesInputSchema>;
+export declare const LIST_SOURCES_TOOL_DEF: {
+    name: "tacit_lake_list_sources";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+        required: string[];
+    };
+};
+export declare function buildListSourcesRequest(client: TacitClient, _input: ListSourcesInput): ToolRequest;
+export declare function handleListSources(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const deregisterSourceInputSchema: z.ZodObject<{
+    source_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source_id: string;
+}, {
+    source_id: string;
+}>;
+export type DeregisterSourceInput = z.infer<typeof deregisterSourceInputSchema>;
+export declare const DEREGISTER_SOURCE_TOOL_DEF: {
+    name: "tacit_lake_deregister_source";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            source_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildDeregisterSourceRequest(client: TacitClient, input: DeregisterSourceInput): ToolRequest;
+export declare function handleDeregisterSource(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const syncStatusInputSchema: z.ZodObject<{
+    source_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    source_id?: string | undefined;
+}, {
+    source_id?: string | undefined;
+}>;
+export type SyncStatusInput = z.infer<typeof syncStatusInputSchema>;
+export declare const SYNC_STATUS_TOOL_DEF: {
+    name: "tacit_lake_sync_status";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            source_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildSyncStatusRequest(client: TacitClient, input: SyncStatusInput): ToolRequest;
+export declare function handleSyncStatus(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const triggerSyncInputSchema: z.ZodObject<{
+    source_id: z.ZodString;
+    confirm_deletions: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    source_id: string;
+    confirm_deletions?: boolean | undefined;
+}, {
+    source_id: string;
+    confirm_deletions?: boolean | undefined;
+}>;
+export type TriggerSyncInput = z.infer<typeof triggerSyncInputSchema>;
+export declare const TRIGGER_SYNC_TOOL_DEF: {
+    name: "tacit_lake_trigger_sync";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            source_id: {
+                type: string;
+                description: string;
+            };
+            confirm_deletions: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildTriggerSyncRequest(client: TacitClient, input: TriggerSyncInput): ToolRequest;
+export declare function handleTriggerSync(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const listProposalsInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type ListProposalsInput = z.infer<typeof listProposalsInputSchema>;
+export declare const LIST_PROPOSALS_TOOL_DEF: {
+    name: "tacit_lake_list_proposals";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+        required: string[];
+    };
+};
+export declare function buildListProposalsRequest(client: TacitClient, _input: ListProposalsInput): ToolRequest;
+export declare function handleListProposals(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const confirmProposalInputSchema: z.ZodObject<{
+    proposal_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    proposal_id: string;
+}, {
+    proposal_id: string;
+}>;
+export type ConfirmProposalInput = z.infer<typeof confirmProposalInputSchema>;
+export declare const CONFIRM_PROPOSAL_TOOL_DEF: {
+    name: "tacit_lake_confirm_proposal";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            proposal_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildConfirmProposalRequest(client: TacitClient, input: ConfirmProposalInput): ToolRequest;
+export declare function handleConfirmProposal(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const classifyInputSchema: z.ZodObject<{
+    source_uri: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    source_uri: string;
+    content?: string | undefined;
+}, {
+    source_uri: string;
+    content?: string | undefined;
+}>;
+export type ClassifyInput = z.infer<typeof classifyInputSchema>;
+export declare const CLASSIFY_TOOL_DEF: {
+    name: "tacit_lake_classify";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            source_uri: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildClassifyRequest(client: TacitClient, input: ClassifyInput): ToolRequest;
+export declare function handleClassify(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const reclassifyInputSchema: z.ZodObject<{
+    catalog_id: z.ZodString;
+    proposed_portfolio: z.ZodOptional<z.ZodString>;
+    proposed_program: z.ZodOptional<z.ZodString>;
+    proposed_domain_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    catalog_id: string;
+    proposed_portfolio?: string | undefined;
+    proposed_program?: string | undefined;
+    proposed_domain_id?: string | undefined;
+}, {
+    catalog_id: string;
+    proposed_portfolio?: string | undefined;
+    proposed_program?: string | undefined;
+    proposed_domain_id?: string | undefined;
+}>;
+export type ReclassifyInput = z.infer<typeof reclassifyInputSchema>;
+export declare const RECLASSIFY_TOOL_DEF: {
+    name: "tacit_lake_reclassify";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            catalog_id: {
+                type: string;
+                description: string;
+            };
+            proposed_portfolio: {
+                type: string;
+                description: string;
+            };
+            proposed_program: {
+                type: string;
+                description: string;
+            };
+            proposed_domain_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildReclassifyRequest(client: TacitClient, input: ReclassifyInput): ToolRequest;
+export declare function handleReclassify(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const writebackInputSchema: z.ZodObject<{
+    source_id: z.ZodString;
+    artifact_id: z.ZodString;
+    target_folder: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    frontmatter: z.ZodOptional<z.ZodObject<{
+        subject: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        supersedes: z.ZodOptional<z.ZodString>;
+        sensitivity: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status?: string | undefined;
+        title?: string | undefined;
+        subject?: string | undefined;
+        supersedes?: string | undefined;
+        sensitivity?: string | undefined;
+    }, {
+        status?: string | undefined;
+        title?: string | undefined;
+        subject?: string | undefined;
+        supersedes?: string | undefined;
+        sensitivity?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    artifact_id: string;
+    source_id: string;
+    slug?: string | undefined;
+    target_folder?: string | undefined;
+    frontmatter?: {
+        status?: string | undefined;
+        title?: string | undefined;
+        subject?: string | undefined;
+        supersedes?: string | undefined;
+        sensitivity?: string | undefined;
+    } | undefined;
+}, {
+    artifact_id: string;
+    source_id: string;
+    slug?: string | undefined;
+    target_folder?: string | undefined;
+    frontmatter?: {
+        status?: string | undefined;
+        title?: string | undefined;
+        subject?: string | undefined;
+        supersedes?: string | undefined;
+        sensitivity?: string | undefined;
+    } | undefined;
+}>;
+export type WritebackInput = z.infer<typeof writebackInputSchema>;
+export declare const WRITEBACK_TOOL_DEF: {
+    name: "tacit_lake_writeback";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            source_id: {
+                type: string;
+                description: string;
+            };
+            artifact_id: {
+                type: string;
+                description: string;
+            };
+            target_folder: {
+                type: string;
+                description: string;
+            };
+            slug: {
+                type: string;
+                description: string;
+            };
+            frontmatter: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildWritebackRequest(client: TacitClient, input: WritebackInput): ToolRequest;
+export declare function handleWriteback(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const browseCatalogInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    origin: z.ZodOptional<z.ZodString>;
+    catalog_status: z.ZodOptional<z.ZodString>;
+    content_type: z.ZodOptional<z.ZodString>;
+    source_id: z.ZodOptional<z.ZodString>;
+    q: z.ZodOptional<z.ZodString>;
+    subject_id: z.ZodOptional<z.ZodString>;
+    subject_needs_review: z.ZodOptional<z.ZodBoolean>;
+    subject_layer: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    origin?: string | undefined;
+    q?: string | undefined;
+    offset?: number | undefined;
+    source_id?: string | undefined;
+    catalog_status?: string | undefined;
+    content_type?: string | undefined;
+    subject_id?: string | undefined;
+    subject_needs_review?: boolean | undefined;
+    subject_layer?: string | undefined;
+}, {
+    limit?: number | undefined;
+    origin?: string | undefined;
+    q?: string | undefined;
+    offset?: number | undefined;
+    source_id?: string | undefined;
+    catalog_status?: string | undefined;
+    content_type?: string | undefined;
+    subject_id?: string | undefined;
+    subject_needs_review?: boolean | undefined;
+    subject_layer?: string | undefined;
+}>;
+export type BrowseCatalogInput = z.infer<typeof browseCatalogInputSchema>;
+export declare const BROWSE_CATALOG_TOOL_DEF: {
+    name: "tacit_lake_browse_catalog";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            limit: {
+                type: string;
+                description: string;
+            };
+            offset: {
+                type: string;
+                description: string;
+            };
+            origin: {
+                type: string;
+                description: string;
+            };
+            catalog_status: {
+                type: string;
+                description: string;
+            };
+            content_type: {
+                type: string;
+                description: string;
+            };
+            source_id: {
+                type: string;
+                description: string;
+            };
+            q: {
+                type: string;
+                description: string;
+            };
+            subject_id: {
+                type: string;
+                description: string;
+            };
+            subject_needs_review: {
+                type: string;
+                description: string;
+            };
+            subject_layer: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildBrowseCatalogRequest(client: TacitClient, input: BrowseCatalogInput): ToolRequest;
+export declare function handleBrowseCatalog(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const catalogDetailInputSchema: z.ZodObject<{
+    catalog_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    catalog_id: string;
+}, {
+    catalog_id: string;
+}>;
+export type CatalogDetailInput = z.infer<typeof catalogDetailInputSchema>;
+export declare const CATALOG_DETAIL_TOOL_DEF: {
+    name: "tacit_lake_catalog_detail";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            catalog_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildCatalogDetailRequest(client: TacitClient, input: CatalogDetailInput): ToolRequest;
+export declare function handleCatalogDetail(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const deleteCatalogItemInputSchema: z.ZodObject<{
+    catalog_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    catalog_id: string;
+}, {
+    catalog_id: string;
+}>;
+export type DeleteCatalogItemInput = z.infer<typeof deleteCatalogItemInputSchema>;
+export declare const DELETE_CATALOG_ITEM_TOOL_DEF: {
+    name: "tacit_lake_delete_catalog_item";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            catalog_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildDeleteCatalogItemRequest(client: TacitClient, input: DeleteCatalogItemInput): ToolRequest;
+export declare function handleDeleteCatalogItem(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const ingestInputSchema: z.ZodObject<{
+    source_uri: z.ZodString;
+    content: z.ZodString;
+    content_type: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    source_uri: string;
+    content_type?: string | undefined;
+}, {
+    content: string;
+    source_uri: string;
+    content_type?: string | undefined;
+}>;
+export type IngestInput = z.infer<typeof ingestInputSchema>;
+export declare const INGEST_TOOL_DEF: {
+    name: "tacit_lake_ingest";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            source_uri: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            content_type: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildIngestRequest(client: TacitClient, input: IngestInput): ToolRequest;
+export declare function handleIngest(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const taxonomyBrowseInputSchema: z.ZodObject<{
+    layer: z.ZodOptional<z.ZodString>;
+    parent_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    layer?: string | undefined;
+    parent_id?: string | undefined;
+}, {
+    layer?: string | undefined;
+    parent_id?: string | undefined;
+}>;
+export type TaxonomyBrowseInput = z.infer<typeof taxonomyBrowseInputSchema>;
+export declare const TAXONOMY_BROWSE_TOOL_DEF: {
+    name: "tacit_lake_taxonomy_browse";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            layer: {
+                type: string;
+                description: string;
+            };
+            parent_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildTaxonomyBrowseRequest(client: TacitClient, input: TaxonomyBrowseInput): ToolRequest;
+export declare function handleTaxonomyBrowse(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const taxonomySeedInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type TaxonomySeedInput = z.infer<typeof taxonomySeedInputSchema>;
+export declare const TAXONOMY_SEED_TOOL_DEF: {
+    name: "tacit_lake_taxonomy_seed";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+        required: string[];
+    };
+};
+export declare function buildTaxonomySeedRequest(client: TacitClient, _input: TaxonomySeedInput): ToolRequest;
+export declare function handleTaxonomySeed(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const taxonomyUpsertNodeInputSchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    layer: z.ZodEnum<["COMPANY", "DOMAIN", "DIMENSION"]>;
+    parent_id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    slug: string;
+    layer: "COMPANY" | "DOMAIN" | "DIMENSION";
+    description?: string | undefined;
+    parent_id?: string | undefined;
+    aliases?: string[] | undefined;
+}, {
+    name: string;
+    slug: string;
+    layer: "COMPANY" | "DOMAIN" | "DIMENSION";
+    description?: string | undefined;
+    parent_id?: string | undefined;
+    aliases?: string[] | undefined;
+}>;
+export type TaxonomyUpsertNodeInput = z.infer<typeof taxonomyUpsertNodeInputSchema>;
+export declare const TAXONOMY_UPSERT_NODE_TOOL_DEF: {
+    name: "tacit_lake_taxonomy_upsert_node";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            slug: {
+                type: string;
+                description: string;
+            };
+            name: {
+                type: string;
+                description: string;
+            };
+            layer: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            parent_id: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            aliases: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildTaxonomyUpsertNodeRequest(client: TacitClient, input: TaxonomyUpsertNodeInput): ToolRequest;
+export declare function handleTaxonomyUpsertNode(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const classifySubjectInputSchema: z.ZodObject<{
+    catalog_id: z.ZodString;
+    subject_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    catalog_id: string;
+    subject_id: string;
+}, {
+    catalog_id: string;
+    subject_id: string;
+}>;
+export type ClassifySubjectInput = z.infer<typeof classifySubjectInputSchema>;
+export declare const CLASSIFY_SUBJECT_TOOL_DEF: {
+    name: "tacit_lake_classify_subject";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            catalog_id: {
+                type: string;
+                description: string;
+            };
+            subject_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildClassifySubjectRequest(client: TacitClient, input: ClassifySubjectInput): ToolRequest;
+export declare function handleClassifySubject(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const reclassifySubjectsInputSchema: z.ZodObject<{
+    subject_id: z.ZodString;
+    catalog_ids: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    subject_id: string;
+    catalog_ids: string[];
+}, {
+    subject_id: string;
+    catalog_ids: string[];
+}>;
+export type ReclassifySubjectsInput = z.infer<typeof reclassifySubjectsInputSchema>;
+export declare const RECLASSIFY_SUBJECTS_TOOL_DEF: {
+    name: "tacit_lake_reclassify_subjects";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            subject_id: {
+                type: string;
+                description: string;
+            };
+            catalog_ids: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildReclassifySubjectsRequest(client: TacitClient, input: ReclassifySubjectsInput): ToolRequest;
+export declare function handleReclassifySubjects(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const resolveInputSchema: z.ZodObject<{
+    doc_id: z.ZodOptional<z.ZodString>;
+    sha256: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    sha256?: string | undefined;
+    path?: string | undefined;
+    doc_id?: string | undefined;
+}, {
+    sha256?: string | undefined;
+    path?: string | undefined;
+    doc_id?: string | undefined;
+}>;
+export type ResolveInput = z.infer<typeof resolveInputSchema>;
+export declare const RESOLVE_TOOL_DEF: {
+    name: "tacit_lake_resolve";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            doc_id: {
+                type: string;
+                description: string;
+            };
+            sha256: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildResolveRequest(client: TacitClient, input: ResolveInput): ToolRequest;
+export declare function handleResolve(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const manifestInputSchema: z.ZodObject<{
+    source_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source_id: string;
+}, {
+    source_id: string;
+}>;
+export type ManifestInput = z.infer<typeof manifestInputSchema>;
+export declare const MANIFEST_TOOL_DEF: {
+    name: "tacit_lake_manifest";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            source_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function buildManifestRequest(client: TacitClient, input: ManifestInput): ToolRequest;
+export declare function handleManifest(args: unknown): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare function registerLakeTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;