bigtool-ts 0.1.0

package/dist/sources/local.js

@@ -0,0 +1,155 @@
+/**
+ * LocalSource module.
+ *
+ * Provides a ToolSource implementation for in-memory StructuredTool instances.
+ *
+ * @module sources/local
+ */
+/**
+ * A tool source backed by local StructuredTool instances.
+ *
+ * LocalSource is the simplest way to add tools to the discovery system.
+ * It wraps an array of StructuredTool instances and exposes them through
+ * the ToolSource interface.
+ *
+ * Tools are stored in memory and returned immediately when requested.
+ * Use {@link withMetadata} to add categories and keywords for better
+ * search matching.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { LocalSource } from '@repo/bigtool-ts';
+ *
+ * const source = new LocalSource([
+ *   calculatorTool,
+ *   weatherTool,
+ *   searchTool,
+ * ]);
+ *
+ * // Register with catalog
+ * await catalog.register(source);
+ * ```
+ *
+ * @example With custom ID
+ * ```typescript
+ * const utilitySource = new LocalSource(utilityTools, 'utilities');
+ * const aiSource = new LocalSource(aiTools, 'ai');
+ *
+ * // Tools will be namespaced: 'utilities:calculator', 'ai:chat'
+ * ```
+ *
+ * @example With enhanced metadata
+ * ```typescript
+ * import { LocalSource, withMetadata } from '@repo/bigtool-ts';
+ *
+ * const tools = [
+ *   withMetadata(createPRTool, {
+ *     categories: ['github', 'git'],
+ *     keywords: ['PR', 'pull request', 'merge'],
+ *   }),
+ *   withMetadata(reviewPRTool, {
+ *     categories: ['github', 'git'],
+ *     keywords: ['review', 'approve', 'comment'],
+ *   }),
+ * ];
+ *
+ * const source = new LocalSource(tools, 'github');
+ * ```
+ */
+export class LocalSource {
+    /**
+     * Unique identifier for this source.
+     *
+     * Used to namespace tool IDs (e.g., 'local:calculator').
+     */
+    id;
+    /** @internal Map of tool name to StructuredTool */
+    tools;
+    /** @internal Cached metadata for all tools */
+    metadata;
+    /**
+     * Creates a new LocalSource.
+     *
+     * @param tools - Array of StructuredTool instances to expose
+     * @param id - Optional source identifier (default: 'local')
+     *
+     * @example
+     * ```typescript
+     * const source = new LocalSource([tool1, tool2]);
+     * const namedSource = new LocalSource([tool1, tool2], 'my-tools');
+     * ```
+     */
+    constructor(tools, id) {
+        this.id = id ?? 'local';
+        this.tools = new Map();
+        this.metadata = [];
+        for (const tool of tools) {
+            this.tools.set(tool.name, tool);
+            this.metadata.push(this.extractMetadata(tool));
+        }
+    }
+    /**
+     * Extracts metadata from a StructuredTool.
+     *
+     * @internal
+     * @param tool - The tool to extract metadata from
+     * @returns Tool metadata for indexing
+     */
+    extractMetadata(tool) {
+        const toolWithMeta = tool;
+        const enhancement = toolWithMeta.__bigtool_metadata ?? toolWithMeta.metadata;
+        // Namespace the tool ID with the source prefix
+        const namespacedId = `${this.id}:${tool.name}`;
+        return {
+            id: namespacedId,
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.schema ? JSON.parse(JSON.stringify(tool.schema)) : undefined,
+            categories: enhancement?.categories,
+            keywords: enhancement?.keywords,
+            source: 'local',
+            sourceId: this.id,
+        };
+    }
+    /**
+     * Get metadata for all tools in this source.
+     *
+     * Returns cached metadata extracted during construction.
+     * This is synchronous internally but returns a Promise for
+     * interface compatibility.
+     *
+     * @returns Promise resolving to array of tool metadata
+     *
+     * @example
+     * ```typescript
+     * const metadata = await source.getMetadata();
+     * console.log(`Found ${metadata.length} tools`);
+     * ```
+     */
+    async getMetadata() {
+        return this.metadata;
+    }
+    /**
+     * Get a tool by its ID.
+     *
+     * Accepts both prefixed IDs (e.g., 'local:calculator') and bare
+     * tool names (e.g., 'calculator'). Returns the tool immediately
+     * from memory.
+     *
+     * @param id - Tool ID or bare name
+     * @returns Promise resolving to the tool, or null if not found
+     *
+     * @example
+     * ```typescript
+     * const tool = await source.getTool('local:calculator');
+     * // or
+     * const tool = await source.getTool('calculator');
+     * ```
+     */
+    async getTool(id) {
+        // Handle both prefixed ID (local:toolName) and bare name (toolName)
+        const bareName = id.startsWith(`${this.id}:`) ? id.slice(this.id.length + 1) : id;
+        return this.tools.get(bareName) ?? null;
+    }
+}
+//# sourceMappingURL=local.js.map

package/dist/sources/local.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.js","sourceRoot":"","sources":["../../src/sources/local.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,MAAM,OAAO,WAAW;IACtB;;;;OAIG;IACM,EAAE,CAAS;IAEpB,mDAAmD;IAC3C,KAAK,CAA8B;IAE3C,8CAA8C;IACtC,QAAQ,CAAiB;IAEjC;;;;;;;;;;;OAWG;IACH,YAAY,KAAuB,EAAE,EAAW;QAC9C,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,OAAO,CAAC;QACxB,IAAI,CAAC,KAAK,GAAG,IAAI,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QAEnB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAChC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACK,eAAe,CAAC,IAAoB;QAM1C,MAAM,YAAY,GAAG,IAAyC,CAAC;QAC/D,MAAM,WAAW,GAAG,YAAY,CAAC,kBAAkB,IAAI,YAAY,CAAC,QAAQ,CAAC;QAE7E,+CAA+C;QAC/C,MAAM,YAAY,GAAG,GAAG,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;QAE/C,OAAO;YACL,EAAE,EAAE,YAAY;YAChB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;YAC7E,UAAU,EAAE,WAAW,EAAE,UAAU;YACnC,QAAQ,EAAE,WAAW,EAAE,QAAQ;YAC/B,MAAM,EAAE,OAAO;YACf,QAAQ,EAAE,IAAI,CAAC,EAAE;SAClB,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,WAAW;QACf,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,OAAO,CAAC,EAAU;QACtB,oEAAoE;QACpE,MAAM,QAAQ,GAAG,EAAE,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAClF,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC;IAC1C,CAAC;CACF"}

package/dist/sources/mcp.d.ts

@@ -0,0 +1,438 @@
+/**
+ * MCPSource module.
+ *
+ * Provides a ToolSource implementation that connects to an MCP
+ * (Model Context Protocol) server and exposes its tools.
+ *
+ * Supports two patterns:
+ * 1. Pre-connected client: Pass an already-connected MCPClient
+ * 2. Config-based: Pass server config and MCPSource manages the connection
+ *
+ * @module sources/mcp
+ */
+import type { StructuredTool } from "@langchain/core/tools";
+import type { ToolSource, ToolMetadata, EventEmitter } from "../types.js";
+/**
+ * MCP Client interface.
+ *
+ * This is a subset of the @modelcontextprotocol/sdk Client interface.
+ * Using an interface allows MCPSource to work with any compatible
+ * client without a hard dependency on the MCP SDK.
+ *
+ * @example Using with MCP SDK
+ * ```typescript
+ * import { Client } from '@modelcontextprotocol/sdk/client';
+ *
+ * const client = new Client({ name: 'github' });
+ * await client.connect(transport);
+ *
+ * const source = new MCPSource(client);
+ * ```
+ */
+export interface MCPClient {
+    /**
+     * Client name, used as default namespace.
+     *
+     * If not provided, 'mcp' is used.
+     */
+    name?: string;
+    /**
+     * List available tools from the MCP server.
+     *
+     * @returns Promise with array of tool definitions
+     */
+    listTools(): Promise<{
+        tools: Array<{
+            name: string;
+            description?: string;
+            inputSchema?: Record<string, unknown>;
+        }>;
+    }>;
+    /**
+     * Call a tool on the MCP server.
+     *
+     * @param params - Tool call parameters
+     * @returns Promise with tool execution result
+     */
+    callTool(params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }): Promise<{
+        content?: Array<{
+            type: string;
+            text?: string;
+        }>;
+        isError?: boolean;
+    }>;
+}
+/**
+ * Configuration options for MCPSource.
+ *
+ * @example
+ * ```typescript
+ * const options: MCPSourceOptions = {
+ *   namespace: 'github',
+ *   refreshInterval: 60000, // Refresh every minute
+ * };
+ * ```
+ */
+export interface MCPSourceOptions {
+    /**
+     * Namespace for tool IDs.
+     *
+     * Tool IDs are formatted as 'mcp:{namespace}:{toolName}'.
+     *
+     * @default client.name or 'default'
+     */
+    namespace?: string;
+    /**
+     * Refresh interval in milliseconds.
+     *
+     * If set, the source will periodically refresh its tool list
+     * from the MCP server. Set to 0 or omit to disable.
+     *
+     * @default undefined (no auto-refresh)
+     */
+    refreshInterval?: number;
+}
+/**
+ * MCPSource connects to an MCP server and provides its tools.
+ *
+ * Tools are fetched from the MCP server on first access and cached.
+ * Wrapper tools are created lazily that delegate execution back to
+ * the server.
+ *
+ * The source can optionally refresh its tool list periodically to
+ * pick up new tools or changes from the server.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { MCPSource } from '@repo/bigtool-ts';
+ * import { Client } from '@modelcontextprotocol/sdk/client';
+ *
+ * const client = new Client({ name: 'github' });
+ * await client.connect(transport);
+ *
+ * const source = new MCPSource(client);
+ * await catalog.register(source);
+ * ```
+ *
+ * @example With auto-refresh
+ * ```typescript
+ * const source = new MCPSource(client, {
+ *   namespace: 'github',
+ *   refreshInterval: 60000, // Check for new tools every minute
+ * });
+ *
+ * // Listen for refresh events
+ * source.onRefresh.subscribe((metadata) => {
+ *   console.log(`Refreshed: ${metadata.length} tools`);
+ * });
+ * ```
+ */
+export declare class MCPSource implements ToolSource {
+    /**
+     * Unique identifier for this source.
+     *
+     * Format: 'mcp:{namespace}' (e.g., 'mcp:github').
+     */
+    readonly id: string;
+    /** @internal The MCP client */
+    private client;
+    /** @internal Cached tool metadata */
+    private metadata;
+    /** @internal Cache of wrapped tools */
+    private toolCache;
+    /** @internal Timer for periodic refresh */
+    private refreshTimer?;
+    /** @internal Whether initial fetch has completed */
+    private initialized;
+    /**
+     * Event emitter for refresh notifications.
+     *
+     * Subscribe to be notified when the tool list is refreshed
+     * from the MCP server.
+     */
+    readonly onRefresh: EventEmitter<ToolMetadata[]>;
+    /**
+     * Creates a new MCPSource.
+     *
+     * @param client - MCP client instance (must be connected)
+     * @param options - Configuration options
+     *
+     * @example
+     * ```typescript
+     * const source = new MCPSource(client, {
+     *   namespace: 'github',
+     *   refreshInterval: 60000,
+     * });
+     * ```
+     */
+    constructor(client: MCPClient, options?: MCPSourceOptions);
+    /**
+     * Get metadata for all tools from this MCP server.
+     *
+     * Fetches from the server on first call, then returns cached metadata.
+     * Call refresh() to update the metadata from the server.
+     *
+     * @returns Promise resolving to array of tool metadata
+     *
+     * @example
+     * ```typescript
+     * const metadata = await source.getMetadata();
+     * console.log(`MCP server has ${metadata.length} tools`);
+     * ```
+     */
+    getMetadata(): Promise<ToolMetadata[]>;
+    /**
+     * Get a tool by its ID.
+     *
+     * Creates a wrapper tool on first request that delegates execution
+     * to the MCP server. Wrappers are cached for subsequent calls.
+     *
+     * @param id - Tool ID (e.g., 'mcp:github:create_pr' or just 'create_pr')
+     * @returns Promise resolving to the tool wrapper, or null if not found
+     *
+     * @example
+     * ```typescript
+     * const tool = await source.getTool('mcp:github:create_pr');
+     * if (tool) {
+     *   const result = await tool.invoke({ title: 'My PR' });
+     * }
+     * ```
+     */
+    getTool(id: string): Promise<StructuredTool | null>;
+    /**
+     * Refresh the tool list from the MCP server.
+     *
+     * Fetches the current tool list, updates metadata, clears the
+     * tool wrapper cache, and emits an onRefresh event.
+     *
+     * @throws MCPSourceError if the server request fails
+     *
+     * @example
+     * ```typescript
+     * // Manually refresh tools
+     * await source.refresh();
+     *
+     * // Or listen for auto-refresh events
+     * source.onRefresh.subscribe((metadata) => {
+     *   console.log('Tools refreshed:', metadata.length);
+     * });
+     * ```
+     */
+    refresh(): Promise<void>;
+    /**
+     * Create a wrapper tool that delegates execution to the MCP server.
+     */
+    private createToolWrapper;
+    /**
+     * Create a Zod-like schema from MCP input schema.
+     * For simplicity, we create a pass-through schema.
+     */
+    private createSchemaFromParameters;
+    /**
+     * Clean up resources.
+     *
+     * Stops the refresh timer and clears all event subscriptions.
+     * Call this when you're done with the source to prevent memory leaks.
+     *
+     * @example
+     * ```typescript
+     * // When shutting down
+     * source.dispose();
+     * catalog.unregister(source.id);
+     * ```
+     */
+    dispose(): void;
+}
+/**
+ * Error thrown when MCP source operations fail.
+ *
+ * This error indicates a problem with the MCP server connection
+ * or protocol, such as failing to list tools.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await source.refresh();
+ * } catch (error) {
+ *   if (error instanceof MCPSourceError) {
+ *     console.error('MCP server error:', error.message);
+ *   }
+ * }
+ * ```
+ */
+export declare class MCPSourceError extends Error {
+    /**
+     * Creates a new MCPSourceError.
+     *
+     * @param message - Error message
+     * @param options - Error options (e.g., cause)
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when MCP tool execution fails.
+ *
+ * This error indicates a problem executing a specific tool on
+ * the MCP server, such as invalid arguments or server-side errors.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await tool.invoke({ title: '' });
+ * } catch (error) {
+ *   if (error instanceof MCPToolError) {
+ *     console.error('Tool execution failed:', error.message);
+ *   }
+ * }
+ * ```
+ */
+export declare class MCPToolError extends Error {
+    /**
+     * Creates a new MCPToolError.
+     *
+     * @param message - Error message
+     * @param options - Error options (e.g., cause)
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Configuration for connecting to an MCP server via stdio transport.
+ *
+ * Used when the MCP server is a local process that communicates via stdin/stdout.
+ *
+ * @example
+ * ```typescript
+ * const config: MCPStdioConfig = {
+ *   name: 'github',
+ *   transport: 'stdio',
+ *   command: 'npx',
+ *   args: ['-y', '@modelcontextprotocol/server-github'],
+ *   env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN },
+ * };
+ * ```
+ */
+export interface MCPStdioConfig {
+    /** Unique name for this server (used as namespace) */
+    name: string;
+    /** Transport type */
+    transport: "stdio";
+    /** Command to execute (e.g., 'npx', 'node', 'python') */
+    command: string;
+    /** Command arguments */
+    args?: string[];
+    /** Environment variables to pass to the process */
+    env?: Record<string, string | undefined>;
+    /** Working directory for the process */
+    cwd?: string;
+    /** Refresh interval in milliseconds (optional) */
+    refreshInterval?: number;
+}
+/**
+ * Configuration for connecting to an MCP server via SSE transport.
+ *
+ * Used when the MCP server is a remote HTTP server using Server-Sent Events.
+ *
+ * @example
+ * ```typescript
+ * const config: MCPSSEConfig = {
+ *   name: 'remote-tools',
+ *   transport: 'sse',
+ *   url: 'https://mcp.example.com/sse',
+ *   headers: { Authorization: 'Bearer xxx' },
+ * };
+ * ```
+ */
+export interface MCPSSEConfig {
+    /** Unique name for this server (used as namespace) */
+    name: string;
+    /** Transport type */
+    transport: "sse";
+    /** SSE endpoint URL */
+    url: string;
+    /** Optional HTTP headers for authentication */
+    headers?: Record<string, string>;
+    /** Refresh interval in milliseconds (optional) */
+    refreshInterval?: number;
+}
+/**
+ * Configuration for connecting to an MCP server via WebSocket transport.
+ *
+ * @example
+ * ```typescript
+ * const config: MCPWebSocketConfig = {
+ *   name: 'realtime-tools',
+ *   transport: 'websocket',
+ *   url: 'wss://mcp.example.com/ws',
+ * };
+ * ```
+ */
+export interface MCPWebSocketConfig {
+    /** Unique name for this server (used as namespace) */
+    name: string;
+    /** Transport type */
+    transport: "websocket";
+    /** WebSocket endpoint URL */
+    url: string;
+    /** Refresh interval in milliseconds (optional) */
+    refreshInterval?: number;
+}
+/**
+ * Union type for all MCP server configurations.
+ */
+export type MCPServerConfig = MCPStdioConfig | MCPSSEConfig | MCPWebSocketConfig;
+/**
+ * Creates an MCPSource from a server configuration.
+ *
+ * This is the preferred way to create an MCPSource when you don't have
+ * a pre-connected MCP client. The function handles:
+ * - Starting the MCP server process (for stdio transport)
+ * - Connecting to remote servers (for SSE/WebSocket transport)
+ * - Managing the client lifecycle
+ *
+ * @param config - Server configuration
+ * @returns Promise resolving to a configured MCPSource
+ *
+ * @example stdio transport (local server)
+ * ```typescript
+ * import { createMCPSource } from '@repo/bigtool-ts';
+ *
+ * const source = await createMCPSource({
+ *   name: 'github',
+ *   transport: 'stdio',
+ *   command: 'npx',
+ *   args: ['-y', '@modelcontextprotocol/server-github'],
+ *   env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN },
+ * });
+ *
+ * // Use like any ToolSource
+ * await catalog.register(source);
+ * ```
+ *
+ * @example SSE transport (remote server)
+ * ```typescript
+ * const source = await createMCPSource({
+ *   name: 'remote-tools',
+ *   transport: 'sse',
+ *   url: 'https://mcp.example.com/sse',
+ *   headers: { Authorization: `Bearer ${apiKey}` },
+ * });
+ * ```
+ *
+ * @example Multiple servers
+ * ```typescript
+ * const sources = await Promise.all([
+ *   createMCPSource({ name: 'github', transport: 'stdio', command: 'npx', args: ['-y', '@mcp/server-github'] }),
+ *   createMCPSource({ name: 'slack', transport: 'stdio', command: 'npx', args: ['-y', '@mcp/server-slack'] }),
+ *   createMCPSource({ name: 'notion', transport: 'stdio', command: 'npx', args: ['-y', '@mcp/server-notion'] }),
+ * ]);
+ *
+ * for (const source of sources) {
+ *   await catalog.register(source);
+ * }
+ * ```
+ */
+export declare function createMCPSource(config: MCPServerConfig): Promise<MCPSource>;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/sources/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/sources/mcp.ts"],"names":[],"mappings":"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"}