@aria-cli/tools 1.0.10 → 1.0.12

package/dist-cjs/registry/registry.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Tool Registry - Manages tool registration and discovery
+ */
+import type { Tool, ToolCategory, ToolContext, ToolResult, ToolMiddleware, RegisterOptions, ToolInfo, Logger } from "../types.js";
+import type { ToolItem } from "@aria-cli/types";
+import { MCPClient } from "../mcp/client.js";
+import type { MCPServerConfig } from "../mcp/types.js";
+export declare function validateToolInput(input: unknown, schema: Record<string, unknown>, path?: string): string | null;
+/**
+ * Memoria-like interface for tool discovery
+ */
+interface MemoriaLike {
+    recallTools(options: {
+        query: string;
+        limit?: number;
+        offset?: number;
+        minConfidence?: number;
+        matchAll?: boolean;
+        updateAccessStats?: boolean;
+    }): Promise<ToolItem[]>;
+    rememberTool(tool: {
+        name: string;
+        description: string;
+    } & Record<string, unknown>): Promise<string>;
+}
+export declare class ToolRegistry {
+    private tools;
+    private middleware;
+    private mcpClient?;
+    private logger;
+    constructor(options?: {
+        logger?: Logger;
+    });
+    /**
+     * Register a middleware to wrap tool execution.
+     * Middlewares are applied in registration order (first registered = outermost).
+     */
+    use(mw: ToolMiddleware): void;
+    /**
+     * Register a tool
+     * @throws Error if tool already registered and override not set
+     */
+    register(tool: Tool, options?: RegisterOptions): void;
+    /**
+     * Get a tool by name
+     */
+    get(name: string): Tool | undefined;
+    /**
+     * Check if a tool is registered
+     */
+    has(name: string): boolean;
+    /**
+     * List all tools, optionally filtered by category
+     */
+    list(category?: ToolCategory): Tool[];
+    /**
+     * Unregister a tool
+     * @returns true if tool was removed, false if not found
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get count of registered tools
+     */
+    get size(): number;
+    /**
+     * Clear all registered tools
+     */
+    clear(): void;
+    /**
+     * Get all registered tools
+     */
+    getAll(): Tool[];
+    /**
+     * Execute a tool by name with input validation.
+     *
+     * Validates `input` against the tool's JSON Schema `parameters` before
+     * delegating to the tool's handler. Returns a structured error result
+     * for unknown tools or validation failures instead of throwing.
+     *
+     * Tools without a `parameters` schema (or with a non-object schema)
+     * skip validation and pass input directly to the handler.
+     */
+    execute(name: string, input: unknown, context: ToolContext): Promise<ToolResult>;
+    /**
+     * Convert a Tool to ToolInfo for system prompt
+     */
+    private toolToInfo;
+    /**
+     * Get tool info for all tools (for system prompt)
+     */
+    getToolInfos(): ToolInfo[];
+    /**
+     * Search for tools by name or description
+     */
+    search(query: string): Tool[];
+    /**
+     * Discover and load tools from Memoria knowledge base
+     *
+     * @param memoria - Memoria instance to query
+     * @returns Number of tools discovered and loaded
+     */
+    discoverFromMemoria(memoria: MemoriaLike): Promise<number>;
+    /**
+     * Save a tool definition to Memoria
+     *
+     * @param name - Name of the tool to save
+     * @param memoria - Memoria instance to save to
+     */
+    saveToMemoria(name: string, memoria: MemoriaLike): Promise<void>;
+    /**
+     * Create an executor for a tool loaded from Memoria.
+     *
+     * Supports template execution only (no eval, no arbitrary code):
+     *
+     * **Response template**: If `toolDef.responseTemplate` is a string,
+     *    `{{key}}` placeholders are replaced with values from the input object.
+     *
+     * Input is validated against the full declared JSON Schema before interpolation.
+     */
+    private createMemoriaToolExecutor;
+    /**
+     * Connect to MCP servers and register their tools
+     */
+    connectMCP(configs: MCPServerConfig[]): Promise<{
+        tools: number;
+        resources: number;
+        prompts: number;
+    }>;
+    /**
+     * Refresh tools from a specific MCP server
+     */
+    private refreshMCPTools;
+    /**
+     * Disconnect from all MCP servers
+     */
+    disconnectMCP(): Promise<void>;
+    /**
+     * Get the MCP client for direct resource/prompt access
+     */
+    getMCPClient(): MCPClient | undefined;
+    /**
+     * Dispose of the registry, cleaning up all MCP connections.
+     *
+     * Shuts down every MCP server connection and clears all registered tools.
+     * Safe to call multiple times (idempotent).
+     */
+    dispose(): Promise<void>;
+    /**
+     * Async disposable support for `await using registry = new ToolRegistry()`.
+     *
+     * Delegates to dispose() so that ToolRegistry works with the Explicit
+     * Resource Management proposal (using/await using).
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export {};