bigtool-ts 0.1.0

package/dist/sources/dynamic.d.ts

@@ -0,0 +1,200 @@
+/**
+ * DynamicSource module.
+ *
+ * Provides a ToolSource implementation for lazy-loading tools that
+ * aren't stored in memory.
+ *
+ * @module sources/dynamic
+ */
+import type { StructuredTool } from "@langchain/core/tools";
+import type { ToolSource, ToolMetadata } from "../types.js";
+/**
+ * Configuration options for DynamicSource.
+ *
+ * @example
+ * ```typescript
+ * const options: DynamicSourceOptions = {
+ *   metadata: [
+ *     { id: 'plugin1', name: 'plugin1', description: '...', source: 'dynamic', sourceId: 'dynamic' },
+ *     { id: 'plugin2', name: 'plugin2', description: '...', source: 'dynamic', sourceId: 'dynamic' },
+ *   ],
+ *   loader: async (id) => {
+ *     const module = await import(`./plugins/${id}.js`);
+ *     return module.default;
+ *   },
+ * };
+ * ```
+ */
+export interface DynamicSourceOptions {
+    /**
+     * Pre-known tool metadata.
+     *
+     * This metadata is used for indexing and search. The actual tool
+     * implementations are loaded on-demand via the loader function.
+     */
+    metadata: ToolMetadata[];
+    /**
+     * Function to load a tool by ID.
+     *
+     * Called when the tool is needed for execution. Should return
+     * a StructuredTool instance or throw if loading fails.
+     *
+     * @param id - The bare tool name (without 'dynamic:' prefix)
+     * @returns Promise resolving to the loaded tool
+     */
+    loader: (id: string) => Promise<StructuredTool>;
+}
+/**
+ * DynamicSource provides lazy-loaded tools.
+ *
+ * Metadata is provided upfront for indexing and search, but actual
+ * tool implementations are loaded on-demand via a loader function.
+ *
+ * This is useful for:
+ * - Large tool collections where loading all tools upfront is expensive
+ * - Tools that require dynamic initialization or configuration
+ * - Plugin systems where tools are loaded from external sources
+ * - Code-split modules that shouldn't be loaded until needed
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { DynamicSource } from '@repo/bigtool-ts';
+ *
+ * const source = new DynamicSource({
+ *   metadata: [
+ *     {
+ *       id: 'heavy-tool',
+ *       name: 'heavy-tool',
+ *       description: 'A tool that takes a long time to load',
+ *       source: 'dynamic',
+ *       sourceId: 'dynamic',
+ *     },
+ *   ],
+ *   loader: async (id) => {
+ *     // Only loaded when actually needed
+ *     const { createHeavyTool } = await import('./heavy-tool.js');
+ *     return createHeavyTool();
+ *   },
+ * });
+ *
+ * await catalog.register(source);
+ * ```
+ *
+ * @example Plugin system
+ * ```typescript
+ * // Load plugin manifest
+ * const plugins = await loadPluginManifest();
+ *
+ * const source = new DynamicSource({
+ *   metadata: plugins.map(p => ({
+ *     id: p.name,
+ *     name: p.name,
+ *     description: p.description,
+ *     categories: p.categories,
+ *     source: 'dynamic',
+ *     sourceId: 'dynamic',
+ *   })),
+ *   loader: async (name) => {
+ *     return await loadPlugin(name);
+ *   },
+ * });
+ * ```
+ */
+export declare class DynamicSource implements ToolSource {
+    /**
+     * Unique identifier for this source.
+     *
+     * Always 'dynamic' for DynamicSource instances.
+     */
+    readonly id = "dynamic";
+    /** @internal Cached metadata */
+    private metadata;
+    /** @internal Loader function */
+    private loader;
+    /** @internal Map for fast metadata lookup */
+    private metadataMap;
+    /**
+     * Creates a new DynamicSource.
+     *
+     * @param config - Configuration with metadata and loader function
+     *
+     * @example
+     * ```typescript
+     * const source = new DynamicSource({
+     *   metadata: toolMetadata,
+     *   loader: async (id) => loadTool(id),
+     * });
+     * ```
+     */
+    constructor(config: DynamicSourceOptions);
+    /**
+     * Get metadata for all tools.
+     *
+     * Returns the pre-configured metadata immediately without any
+     * network or async operations. This makes indexing fast.
+     *
+     * @returns Promise resolving to array of tool metadata
+     *
+     * @example
+     * ```typescript
+     * const metadata = await source.getMetadata();
+     * console.log(`${metadata.length} dynamic tools available`);
+     * ```
+     */
+    getMetadata(): Promise<ToolMetadata[]>;
+    /**
+     * Get a tool by its ID.
+     *
+     * Delegates to the loader function provided at construction.
+     * Returns null if the tool ID is not in the metadata.
+     *
+     * @param id - Tool ID ('dynamic:name' or bare 'name')
+     * @returns Promise resolving to the loaded tool, or null if not found
+     * @throws DynamicSourceError if the loader function fails
+     *
+     * @example
+     * ```typescript
+     * const tool = await source.getTool('my-plugin');
+     * if (tool) {
+     *   const result = await tool.invoke(input);
+     * }
+     * ```
+     */
+    getTool(id: string): Promise<StructuredTool | null>;
+    /**
+     * Extract the tool name from an ID.
+     *
+     * @internal
+     * @param id - Full or bare tool ID
+     * @returns Bare tool name
+     */
+    private extractName;
+}
+/**
+ * Error thrown when dynamic tool loading fails.
+ *
+ * This error wraps any error thrown by the loader function,
+ * adding context about which tool failed to load.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const tool = await source.getTool('broken-plugin');
+ * } catch (error) {
+ *   if (error instanceof DynamicSourceError) {
+ *     console.error('Plugin failed to load:', error.message);
+ *     console.error('Original error:', error.cause);
+ *   }
+ * }
+ * ```
+ */
+export declare class DynamicSourceError extends Error {
+    /**
+     * Creates a new DynamicSourceError.
+     *
+     * @param message - Error message with context
+     * @param options - Error options (e.g., cause)
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=dynamic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic.d.ts","sourceRoot":"","sources":["../../src/sources/dynamic.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,QAAQ,EAAE,YAAY,EAAE,CAAC;IAEzB;;;;;;;;OAQG;IACH,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,qBAAa,aAAc,YAAW,UAAU;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,aAAa;IAExB,gCAAgC;IAChC,OAAO,CAAC,QAAQ,CAAiB;IAEjC,gCAAgC;IAChC,OAAO,CAAC,MAAM,CAA0C;IAExD,6CAA6C;IAC7C,OAAO,CAAC,WAAW,CAA4B;IAE/C;;;;;;;;;;;;OAYG;gBACS,MAAM,EAAE,oBAAoB;IAiBxC;;;;;;;;;;;;;OAaG;IACG,WAAW,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAI5C;;;;;;;;;;;;;;;;;OAiBG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAoBzD;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;CAGpB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}

package/dist/sources/dynamic.js

@@ -0,0 +1,194 @@
+/**
+ * DynamicSource module.
+ *
+ * Provides a ToolSource implementation for lazy-loading tools that
+ * aren't stored in memory.
+ *
+ * @module sources/dynamic
+ */
+/**
+ * DynamicSource provides lazy-loaded tools.
+ *
+ * Metadata is provided upfront for indexing and search, but actual
+ * tool implementations are loaded on-demand via a loader function.
+ *
+ * This is useful for:
+ * - Large tool collections where loading all tools upfront is expensive
+ * - Tools that require dynamic initialization or configuration
+ * - Plugin systems where tools are loaded from external sources
+ * - Code-split modules that shouldn't be loaded until needed
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { DynamicSource } from '@repo/bigtool-ts';
+ *
+ * const source = new DynamicSource({
+ *   metadata: [
+ *     {
+ *       id: 'heavy-tool',
+ *       name: 'heavy-tool',
+ *       description: 'A tool that takes a long time to load',
+ *       source: 'dynamic',
+ *       sourceId: 'dynamic',
+ *     },
+ *   ],
+ *   loader: async (id) => {
+ *     // Only loaded when actually needed
+ *     const { createHeavyTool } = await import('./heavy-tool.js');
+ *     return createHeavyTool();
+ *   },
+ * });
+ *
+ * await catalog.register(source);
+ * ```
+ *
+ * @example Plugin system
+ * ```typescript
+ * // Load plugin manifest
+ * const plugins = await loadPluginManifest();
+ *
+ * const source = new DynamicSource({
+ *   metadata: plugins.map(p => ({
+ *     id: p.name,
+ *     name: p.name,
+ *     description: p.description,
+ *     categories: p.categories,
+ *     source: 'dynamic',
+ *     sourceId: 'dynamic',
+ *   })),
+ *   loader: async (name) => {
+ *     return await loadPlugin(name);
+ *   },
+ * });
+ * ```
+ */
+export class DynamicSource {
+    /**
+     * Unique identifier for this source.
+     *
+     * Always 'dynamic' for DynamicSource instances.
+     */
+    id = "dynamic";
+    /** @internal Cached metadata */
+    metadata;
+    /** @internal Loader function */
+    loader;
+    /** @internal Map for fast metadata lookup */
+    metadataMap;
+    /**
+     * Creates a new DynamicSource.
+     *
+     * @param config - Configuration with metadata and loader function
+     *
+     * @example
+     * ```typescript
+     * const source = new DynamicSource({
+     *   metadata: toolMetadata,
+     *   loader: async (id) => loadTool(id),
+     * });
+     * ```
+     */
+    constructor(config) {
+        // Normalize metadata to ensure correct ID format and source
+        this.metadata = config.metadata.map((m) => ({
+            ...m,
+            id: m.id.startsWith("dynamic:") ? m.id : `dynamic:${m.id}`,
+            source: "dynamic",
+            sourceId: this.id,
+        }));
+        // Build lookup map for efficient access
+        this.metadataMap = new Map(this.metadata.map((m) => [this.extractName(m.id), m]));
+        this.loader = config.loader;
+    }
+    /**
+     * Get metadata for all tools.
+     *
+     * Returns the pre-configured metadata immediately without any
+     * network or async operations. This makes indexing fast.
+     *
+     * @returns Promise resolving to array of tool metadata
+     *
+     * @example
+     * ```typescript
+     * const metadata = await source.getMetadata();
+     * console.log(`${metadata.length} dynamic tools available`);
+     * ```
+     */
+    async getMetadata() {
+        return this.metadata;
+    }
+    /**
+     * Get a tool by its ID.
+     *
+     * Delegates to the loader function provided at construction.
+     * Returns null if the tool ID is not in the metadata.
+     *
+     * @param id - Tool ID ('dynamic:name' or bare 'name')
+     * @returns Promise resolving to the loaded tool, or null if not found
+     * @throws DynamicSourceError if the loader function fails
+     *
+     * @example
+     * ```typescript
+     * const tool = await source.getTool('my-plugin');
+     * if (tool) {
+     *   const result = await tool.invoke(input);
+     * }
+     * ```
+     */
+    async getTool(id) {
+        const name = this.extractName(id);
+        // Check if tool exists in our metadata
+        if (!this.metadataMap.has(name)) {
+            return null;
+        }
+        try {
+            return await this.loader(name);
+        }
+        catch (error) {
+            // Re-throw with context
+            const message = error instanceof Error ? error.message : String(error);
+            throw new DynamicSourceError(`Failed to load dynamic tool "${name}": ${message}`, { cause: error });
+        }
+    }
+    /**
+     * Extract the tool name from an ID.
+     *
+     * @internal
+     * @param id - Full or bare tool ID
+     * @returns Bare tool name
+     */
+    extractName(id) {
+        return id.startsWith("dynamic:") ? id.slice(8) : id;
+    }
+}
+/**
+ * Error thrown when dynamic tool loading fails.
+ *
+ * This error wraps any error thrown by the loader function,
+ * adding context about which tool failed to load.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const tool = await source.getTool('broken-plugin');
+ * } catch (error) {
+ *   if (error instanceof DynamicSourceError) {
+ *     console.error('Plugin failed to load:', error.message);
+ *     console.error('Original error:', error.cause);
+ *   }
+ * }
+ * ```
+ */
+export class DynamicSourceError extends Error {
+    /**
+     * Creates a new DynamicSourceError.
+     *
+     * @param message - Error message with context
+     * @param options - Error options (e.g., cause)
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.name = "DynamicSourceError";
+    }
+}
+//# sourceMappingURL=dynamic.js.map

package/dist/sources/dynamic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic.js","sourceRoot":"","sources":["../../src/sources/dynamic.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA2CH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,MAAM,OAAO,aAAa;IACxB;;;;OAIG;IACM,EAAE,GAAG,SAAS,CAAC;IAExB,gCAAgC;IACxB,QAAQ,CAAiB;IAEjC,gCAAgC;IACxB,MAAM,CAA0C;IAExD,6CAA6C;IACrC,WAAW,CAA4B;IAE/C;;;;;;;;;;;;OAYG;IACH,YAAY,MAA4B;QACtC,4DAA4D;QAC5D,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC1C,GAAG,CAAC;YACJ,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,EAAE;YAC1D,MAAM,EAAE,SAAkB;YAC1B,QAAQ,EAAE,IAAI,CAAC,EAAE;SAClB,CAAC,CAAC,CAAC;QAEJ,wCAAwC;QACxC,IAAI,CAAC,WAAW,GAAG,IAAI,GAAG,CACxB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CACtD,CAAC;QAEF,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC9B,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,WAAW;QACf,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,OAAO,CAAC,EAAU;QACtB,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QAElC,uCAAuC;QACvC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,wBAAwB;YACxB,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACvE,MAAM,IAAI,kBAAkB,CAC1B,gCAAgC,IAAI,MAAM,OAAO,EAAE,EACnD,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACK,WAAW,CAAC,EAAU;QAC5B,OAAO,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACtD,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAC3C;;;;;OAKG;IACH,YAAY,OAAe,EAAE,OAAsB;QACjD,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF"}

package/dist/sources/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tool Sources - Different ways to provide tools to bigtool-ts.
+ *
+ * @module sources
+ */
+export { LocalSource } from './local.js';
+export { MCPSource, createMCPSource, MCPSourceError, MCPToolError, type MCPSourceOptions, type MCPClient, type MCPServerConfig, type MCPStdioConfig, type MCPSSEConfig, type MCPWebSocketConfig, } from './mcp.js';
+export { DynamicSource, DynamicSourceError, type DynamicSourceOptions, } from './dynamic.js';
+export { withMetadata } from './with-metadata.js';
+export type { ToolSource, ToolMetadata, ToolEnhancement, EnhancedTool, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sources/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzC,OAAO,EACL,SAAS,EACT,eAAe,EACf,cAAc,EACd,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,kBAAkB,GACxB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,KAAK,oBAAoB,GAC1B,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,YAAY,EACV,UAAU,EACV,YAAY,EACZ,eAAe,EACf,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/sources/index.js

@@ -0,0 +1,14 @@
+/**
+ * Tool Sources - Different ways to provide tools to bigtool-ts.
+ *
+ * @module sources
+ */
+// LocalSource - Wraps in-memory StructuredTool instances
+export { LocalSource } from './local.js';
+// MCPSource - Connects to MCP servers
+export { MCPSource, createMCPSource, MCPSourceError, MCPToolError, } from './mcp.js';
+// DynamicSource - Lazy-loads tools on demand
+export { DynamicSource, DynamicSourceError, } from './dynamic.js';
+// Re-export withMetadata utility for convenience
+export { withMetadata } from './with-metadata.js';
+//# sourceMappingURL=index.js.map

package/dist/sources/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sources/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,yDAAyD;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,sCAAsC;AACtC,OAAO,EACL,SAAS,EACT,eAAe,EACf,cAAc,EACd,YAAY,GAOb,MAAM,UAAU,CAAC;AAElB,6CAA6C;AAC7C,OAAO,EACL,aAAa,EACb,kBAAkB,GAEnB,MAAM,cAAc,CAAC;AAEtB,iDAAiD;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/sources/local.d.ts

@@ -0,0 +1,128 @@
+/**
+ * LocalSource module.
+ *
+ * Provides a ToolSource implementation for in-memory StructuredTool instances.
+ *
+ * @module sources/local
+ */
+import type { StructuredTool } from '@langchain/core/tools';
+import type { ToolSource, ToolMetadata } from '../types.js';
+/**
+ * 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 declare class LocalSource implements ToolSource {
+    /**
+     * Unique identifier for this source.
+     *
+     * Used to namespace tool IDs (e.g., 'local:calculator').
+     */
+    readonly id: string;
+    /** @internal Map of tool name to StructuredTool */
+    private tools;
+    /** @internal Cached metadata for all tools */
+    private 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: StructuredTool[], id?: string);
+    /**
+     * Extracts metadata from a StructuredTool.
+     *
+     * @internal
+     * @param tool - The tool to extract metadata from
+     * @returns Tool metadata for indexing
+     */
+    private extractMetadata;
+    /**
+     * 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`);
+     * ```
+     */
+    getMetadata(): Promise<ToolMetadata[]>;
+    /**
+     * 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');
+     * ```
+     */
+    getTool(id: string): Promise<StructuredTool | null>;
+}
+//# sourceMappingURL=local.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../src/sources/local.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAmB,MAAM,aAAa,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,qBAAa,WAAY,YAAW,UAAU;IAC5C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,mDAAmD;IACnD,OAAO,CAAC,KAAK,CAA8B;IAE3C,8CAA8C;IAC9C,OAAO,CAAC,QAAQ,CAAiB;IAEjC;;;;;;;;;;;OAWG;gBACS,KAAK,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM;IAWhD;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAwBvB;;;;;;;;;;;;;;OAcG;IACG,WAAW,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAI5C;;;;;;;;;;;;;;;;OAgBG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;CAK1D"}