qlogicagent 0.2.1 → 0.4.0

package/dist/skills/tools/mcp-tool.js

@@ -1,503 +0,0 @@
-// ============================================================
-// MCP Tool — Full Model Context Protocol integration.
-//
-// Matches Claude Code MCP depth:
-// - Complete transport abstraction (stdio/SSE/HTTP/WS/in-process)
-// - Full OAuth flow with PKCE + token lifecycle + step-up auth
-// - Dynamic tool injection/removal (tools/list_changed protocol)
-// - Resource discovery + binary blob persistence
-// - Prompt support (list + get)
-// - Server lifecycle management (add/remove/restart/healthCheck)
-// - Elicitation support (server→user consent requests)
-//
-// Reference: claude-code-haha/src/services/mcp/ (full client SDK)
-//            claude-code-haha/src/tools/MCPTool/MCPTool.ts
-//            claude-code-haha/src/tools/McpAuthTool/McpAuthTool.ts
-//            claude-code-haha/src/tools/ListMcpResourcesTool/
-//            claude-code-haha/src/tools/ReadMcpResourceTool/
-// ============================================================
-import { normalizeNameForMcp } from "./mcp-client-types.js";
-// Re-export name utilities
-export { normalizeNameForMcp, buildMcpToolName, getMcpServerPrefix, parseMcpToolName, isMcpToolName, MCP_CONNECTION_TIMEOUT_MS, MCP_REQUEST_TIMEOUT_MS, MCP_TOOL_CALL_TIMEOUT_MS, MCP_MAX_RECONNECT_ATTEMPTS, MCP_MAX_DESCRIPTION_LENGTH, } from "./mcp-client-types.js";
-// ── Tool Name & Schema ──────────────────────────────────────
-export const MCP_TOOL_NAME = "mcp";
-export const MCP_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: [
-                "list_servers", "list_tools", "call_tool",
-                "list_resources", "read_resource",
-                "list_prompts", "get_prompt",
-                "authenticate", "manage_server",
-            ],
-            description: "MCP action:\n" +
-                "- list_servers: List configured MCP servers, their status and capabilities\n" +
-                "- list_tools: List tools provided by a specific server\n" +
-                "- call_tool: Execute a tool on an MCP server\n" +
-                "- list_resources: List resources from a server (or all servers)\n" +
-                "- read_resource: Read a specific resource by URI\n" +
-                "- list_prompts: List prompts available from a server\n" +
-                "- get_prompt: Get a specific prompt with arguments\n" +
-                "- authenticate: Initiate OAuth authentication with a server\n" +
-                "- manage_server: Add, remove, restart, or check server status",
-        },
-        server: {
-            type: "string",
-            description: "MCP server name. Required for all actions except list_servers.",
-        },
-        toolName: {
-            type: "string",
-            description: "Tool name on the MCP server. Required for call_tool.",
-        },
-        arguments: {
-            type: "object",
-            description: "Arguments for the tool call or prompt. Used with call_tool and get_prompt.",
-        },
-        uri: {
-            type: "string",
-            description: "Resource URI. Required for read_resource.",
-        },
-        promptName: {
-            type: "string",
-            description: "Prompt name. Required for get_prompt.",
-        },
-        manageAction: {
-            type: "string",
-            enum: ["add", "remove", "restart", "health_check", "enable", "disable"],
-            description: "Sub-action for manage_server.",
-        },
-        config: {
-            type: "object",
-            description: "Server configuration. Required for manage_server add.",
-        },
-    },
-    required: ["action"],
-};
-// ── Tool Factory ────────────────────────────────────────────
-export function createMcpTool(deps) {
-    return {
-        name: MCP_TOOL_NAME,
-        label: "MCP",
-        description: "Interact with external MCP (Model Context Protocol) servers. " +
-            "Discover and call tools, read resources, get prompts, manage servers, " +
-            "and handle authentication. MCP servers extend agent capabilities with " +
-            "external integrations (databases, APIs, code analysis, custom tools).\n\n" +
-            "Dynamic tools: When MCP servers are connected, their tools also appear " +
-            "as individual entries in the tool list (prefixed mcp__server__tool) for " +
-            "direct invocation without going through this management tool.",
-        parameters: MCP_TOOL_SCHEMA,
-        shouldDefer: true,
-        execute: async (_toolCallId, params, signal) => {
-            switch (params.action) {
-                // ─── list_servers ─────────────────────────────────
-                case "list_servers": {
-                    const servers = await deps.listServers();
-                    if (servers.length === 0) {
-                        return {
-                            content: [{ type: "text", text: "No MCP servers configured. Use manage_server action to add one." }],
-                            details: { type: "mcp", action: "list_servers", count: 0 },
-                        };
-                    }
-                    const lines = [`MCP Servers (${servers.length}):`, ""];
-                    for (const s of servers) {
-                        const icon = statusIcon(s.status);
-                        lines.push(`${icon} **${s.name}** [${s.transport}] — ${s.status}`);
-                        lines.push(`  Tools: ${s.toolCount} | Resources: ${s.resourceCount} | Prompts: ${s.promptCount}`);
-                        if (s.capabilities) {
-                            const caps = [];
-                            if (s.capabilities.tools?.listChanged)
-                                caps.push("tools/listChanged");
-                            if (s.capabilities.resources?.subscribe)
-                                caps.push("resources/subscribe");
-                            if (s.capabilities.prompts?.listChanged)
-                                caps.push("prompts/listChanged");
-                            if (caps.length > 0)
-                                lines.push(`  Capabilities: ${caps.join(", ")}`);
-                        }
-                        if (s.serverVersion)
-                            lines.push(`  Version: ${s.serverVersion}`);
-                        if (s.error)
-                            lines.push(`  ⚠ Error: ${s.error}`);
-                        lines.push("");
-                    }
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "mcp", action: "list_servers", count: servers.length },
-                    };
-                }
-                // ─── list_tools ───────────────────────────────────
-                case "list_tools": {
-                    if (!params.server) {
-                        return errResult("server is required for list_tools.");
-                    }
-                    const tools = await deps.listTools(params.server);
-                    if (tools.length === 0) {
-                        return {
-                            content: [{ type: "text", text: `No tools available from server "${params.server}".` }],
-                            details: { type: "mcp", action: "list_tools", server: params.server, count: 0 },
-                        };
-                    }
-                    const lines = [`Tools from "${params.server}" (${tools.length}):`, ""];
-                    for (const t of tools) {
-                        const annBadges = formatAnnotations(t.annotations);
-                        lines.push(`- **${t.name}**${annBadges}${t.description ? `: ${t.description}` : ""}`);
-                        if (t.prefixedName)
-                            lines.push(`  Direct call: \`${t.prefixedName}\``);
-                    }
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "mcp", action: "list_tools", server: params.server, count: tools.length },
-                    };
-                }
-                // ─── call_tool ────────────────────────────────────
-                case "call_tool": {
-                    if (!params.server)
-                        return errResult("server is required for call_tool.");
-                    if (!params.toolName)
-                        return errResult("toolName is required for call_tool.");
-                    const result = await deps.callTool(params.server, params.toolName, params.arguments, signal);
-                    if (!result.success || result.isError) {
-                        return {
-                            content: [{ type: "text", text: `MCP tool error (${params.server}/${params.toolName}): ${result.error || result.content || "unknown error"}` }],
-                            details: { type: "mcp", action: "call_tool", server: params.server, toolName: params.toolName, success: false },
-                        };
-                    }
-                    // Handle structured content blocks (images, etc.)
-                    if (result.contentBlocks && result.contentBlocks.length > 0) {
-                        const content = result.contentBlocks.map(block => {
-                            if (block.type === "image" && block.data) {
-                                return { type: "image", data: block.data, mimeType: block.mimeType };
-                            }
-                            return { type: "text", text: block.text || "" };
-                        });
-                        return {
-                            content,
-                            details: { type: "mcp", action: "call_tool", server: params.server, toolName: params.toolName, success: true },
-                        };
-                    }
-                    return {
-                        content: [{ type: "text", text: result.content || "(no output)" }],
-                        details: { type: "mcp", action: "call_tool", server: params.server, toolName: params.toolName, success: true },
-                    };
-                }
-                // ─── list_resources ───────────────────────────────
-                case "list_resources": {
-                    const resources = await deps.listResources(params.server);
-                    if (resources.length === 0) {
-                        return {
-                            content: [{ type: "text", text: params.server ? `No resources from "${params.server}".` : "No MCP resources available." }],
-                            details: { type: "mcp", action: "list_resources", count: 0 },
-                        };
-                    }
-                    const lines = [`MCP Resources (${resources.length}):`, ""];
-                    for (const r of resources) {
-                        lines.push(`- **${r.name}** \`${r.uri}\`${r.mimeType ? ` [${r.mimeType}]` : ""}`);
-                        if (r.description)
-                            lines.push(`  ${r.description}`);
-                        if (r.server)
-                            lines.push(`  Server: ${r.server}`);
-                    }
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "mcp", action: "list_resources", count: resources.length, server: params.server },
-                    };
-                }
-                // ─── read_resource ────────────────────────────────
-                case "read_resource": {
-                    if (!params.server)
-                        return errResult("server is required for read_resource.");
-                    if (!params.uri)
-                        return errResult("uri is required for read_resource.");
-                    const contents = await deps.readResource(params.server, params.uri);
-                    if (contents.length === 0) {
-                        return {
-                            content: [{ type: "text", text: "Resource returned no content." }],
-                            details: { type: "mcp", action: "read_resource", server: params.server, uri: params.uri },
-                        };
-                    }
-                    const resultContent = [];
-                    for (const c of contents) {
-                        if (c.blobSavedTo) {
-                            resultContent.push({ type: "text", text: `[Binary content saved to: ${c.blobSavedTo}${c.blobSize ? ` (${formatBytes(c.blobSize)})` : ""}]` });
-                        }
-                        else if (c.text) {
-                            resultContent.push({ type: "text", text: c.text });
-                        }
-                    }
-                    if (resultContent.length === 0) {
-                        resultContent.push({ type: "text", text: "(empty content)" });
-                    }
-                    return {
-                        content: resultContent,
-                        details: { type: "mcp", action: "read_resource", server: params.server, uri: params.uri },
-                    };
-                }
-                // ─── list_prompts ─────────────────────────────────
-                case "list_prompts": {
-                    if (!params.server)
-                        return errResult("server is required for list_prompts.");
-                    if (!deps.listPrompts) {
-                        return errResult("Prompt listing not supported by the current MCP host.");
-                    }
-                    const prompts = await deps.listPrompts(params.server);
-                    if (prompts.length === 0) {
-                        return {
-                            content: [{ type: "text", text: `No prompts available from "${params.server}".` }],
-                            details: { type: "mcp", action: "list_prompts", server: params.server, count: 0 },
-                        };
-                    }
-                    const lines = [`Prompts from "${params.server}" (${prompts.length}):`, ""];
-                    for (const p of prompts) {
-                        lines.push(`- **${p.name}**${p.description ? `: ${p.description}` : ""}`);
-                        if (p.arguments && p.arguments.length > 0) {
-                            const argDescs = p.arguments.map(a => `${a.name}${a.required ? " (required)" : ""}${a.description ? `: ${a.description}` : ""}`);
-                            lines.push(`  Arguments: ${argDescs.join(", ")}`);
-                        }
-                    }
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "mcp", action: "list_prompts", server: params.server, count: prompts.length },
-                    };
-                }
-                // ─── get_prompt ───────────────────────────────────
-                case "get_prompt": {
-                    if (!params.server)
-                        return errResult("server is required for get_prompt.");
-                    if (!params.promptName)
-                        return errResult("promptName is required for get_prompt.");
-                    if (!deps.getPrompt) {
-                        return errResult("Prompt retrieval not supported by the current MCP host.");
-                    }
-                    const stringArgs = params.arguments
-                        ? Object.fromEntries(Object.entries(params.arguments).map(([k, v]) => [k, String(v)]))
-                        : undefined;
-                    const result = await deps.getPrompt(params.server, params.promptName, stringArgs);
-                    const lines = [];
-                    if (result.description)
-                        lines.push(`> ${result.description}`, "");
-                    for (const msg of result.messages) {
-                        lines.push(`**[${msg.role}]:**`);
-                        if (msg.content.type === "text") {
-                            lines.push(msg.content.text);
-                        }
-                        else if (msg.content.type === "resource") {
-                            lines.push(`[Resource: ${msg.content.resource.uri}]`);
-                            if (msg.content.resource.text)
-                                lines.push(msg.content.resource.text);
-                        }
-                        else if (msg.content.type === "image") {
-                            lines.push("[Image content]");
-                        }
-                        lines.push("");
-                    }
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") || "(empty prompt)" }],
-                        details: { type: "mcp", action: "get_prompt", server: params.server, promptName: params.promptName },
-                    };
-                }
-                // ─── authenticate ─────────────────────────────────
-                case "authenticate": {
-                    if (!params.server)
-                        return errResult("server is required for authenticate.");
-                    const result = await deps.authenticate(params.server);
-                    switch (result.status) {
-                        case "auth_url":
-                            return {
-                                content: [{
-                                        type: "text",
-                                        text: `Authentication required for "${params.server}".\n\n` +
-                                            `Please open this URL in your browser:\n${result.authUrl}\n\n` +
-                                            `${result.message || "Once you complete authentication, the server's tools will become available automatically."}`,
-                                    }],
-                                details: { type: "mcp", action: "authenticate", server: params.server, status: "auth_url" },
-                            };
-                        case "already_authenticated":
-                            return {
-                                content: [{ type: "text", text: `Server "${params.server}" is already authenticated.` }],
-                                details: { type: "mcp", action: "authenticate", server: params.server, status: "already_authenticated" },
-                            };
-                        case "step_up_required":
-                            return {
-                                content: [{
-                                        type: "text",
-                                        text: `Server "${params.server}" requires elevated permissions.\n` +
-                                            `Required scopes: ${result.requiredScopes?.join(", ") || "unknown"}\n\n` +
-                                            (result.authUrl ? `Re-authorize at: ${result.authUrl}` : "Please re-authenticate with elevated permissions."),
-                                    }],
-                                details: { type: "mcp", action: "authenticate", server: params.server, status: "step_up_required" },
-                            };
-                        case "unsupported":
-                            return {
-                                content: [{ type: "text", text: `Authentication not supported for "${params.server}" (${result.message || "uses local transport"}).` }],
-                                details: { type: "mcp", action: "authenticate", server: params.server, status: "unsupported" },
-                            };
-                        default:
-                            return {
-                                content: [{ type: "text", text: `Authentication error for "${params.server}": ${result.message || "unknown error"}` }],
-                                details: { type: "mcp", action: "authenticate", server: params.server, status: "error" },
-                            };
-                    }
-                }
-                // ─── manage_server ────────────────────────────────
-                case "manage_server": {
-                    if (!params.server)
-                        return errResult("server is required for manage_server.");
-                    if (!params.manageAction)
-                        return errResult("manageAction is required for manage_server.");
-                    switch (params.manageAction) {
-                        case "add": {
-                            if (!deps.addServer)
-                                return errResult("Server addition not supported by the current MCP host.");
-                            if (!params.config)
-                                return errResult("config is required for manage_server add.");
-                            const result = await deps.addServer(params.server, params.config);
-                            return manageResultToOutput("add", params.server, result);
-                        }
-                        case "remove": {
-                            if (!deps.removeServer)
-                                return errResult("Server removal not supported by the current MCP host.");
-                            const result = await deps.removeServer(params.server);
-                            return manageResultToOutput("remove", params.server, result);
-                        }
-                        case "restart": {
-                            if (!deps.restartServer)
-                                return errResult("Server restart not supported by the current MCP host.");
-                            const result = await deps.restartServer(params.server);
-                            return manageResultToOutput("restart", params.server, result);
-                        }
-                        case "health_check": {
-                            if (!deps.healthCheck)
-                                return errResult("Health check not supported by the current MCP host.");
-                            const result = await deps.healthCheck(params.server);
-                            return manageResultToOutput("health_check", params.server, result);
-                        }
-                        case "enable":
-                        case "disable": {
-                            if (!deps.setServerEnabled)
-                                return errResult("Server enable/disable not supported by the current MCP host.");
-                            const result = await deps.setServerEnabled(params.server, params.manageAction === "enable");
-                            return manageResultToOutput(params.manageAction, params.server, result);
-                        }
-                        default:
-                            return errResult(`Unknown manageAction: ${params.manageAction}`);
-                    }
-                }
-                default:
-                    return errResult(`Unknown action: "${params.action}".`);
-            }
-        },
-    };
-}
-// ── Helpers ─────────────────────────────────────────────────
-function errResult(message) {
-    return {
-        content: [{ type: "text", text: `Error: ${message}` }],
-        details: { type: "mcp", error: message },
-    };
-}
-function statusIcon(status) {
-    switch (status) {
-        case "connected": return "✅";
-        case "connecting": return "⏳";
-        case "needs-auth": return "🔑";
-        case "failed": return "❌";
-        case "disconnected": return "⚪";
-        case "disabled": return "🚫";
-        default: return "❓";
-    }
-}
-function formatAnnotations(annotations) {
-    if (!annotations)
-        return "";
-    const badges = [];
-    if (annotations.readOnlyHint)
-        badges.push("📖");
-    if (annotations.destructiveHint)
-        badges.push("⚠️");
-    if (annotations.idempotentHint)
-        badges.push("♻️");
-    return badges.length > 0 ? ` ${badges.join("")}` : "";
-}
-function formatBytes(bytes) {
-    if (bytes < 1024)
-        return `${bytes}B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)}KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
-function manageResultToOutput(action, server, result) {
-    const lines = [];
-    lines.push(`${result.success ? "✅" : "❌"} ${action} "${server}": ${result.message}`);
-    if (result.serverState) {
-        lines.push("");
-        lines.push(`  Status: ${result.serverState.status}`);
-        lines.push(`  Tools: ${result.serverState.toolCount} | Resources: ${result.serverState.resourceCount}`);
-    }
-    return {
-        content: [{ type: "text", text: lines.join("\n") }],
-        details: { type: "mcp", action: "manage_server", manageAction: action, server, success: result.success },
-    };
-}
-/**
- * Create a dynamic per-server authentication proxy tool.
- * One instance per unauthenticated MCP server.
- *
- * Tool name follows CC convention: `mcp__<normalizedServer>__authenticate`
- */
-export function createMcpAuthProxy(serverName, deps) {
-    const normalizedName = normalizeNameForMcp(serverName);
-    const toolName = `mcp__${normalizedName}__authenticate`;
-    return {
-        name: toolName,
-        label: `Authenticate ${serverName}`,
-        description: `Initiate OAuth authentication with the "${serverName}" MCP server. ` +
-            `Call this when the server requires authentication before its tools can be used.`,
-        parameters: {
-            type: "object",
-            properties: {},
-        },
-        isReadOnly: true,
-        searchHint: `mcp auth oauth ${serverName} authenticate login`,
-        execute: async (_toolCallId) => {
-            const result = await deps.authenticate(serverName);
-            switch (result.status) {
-                case "auth_url":
-                    // Trigger background reconnect after auth
-                    if (deps.onAuthComplete) {
-                        // Fire-and-forget: host will reconnect in background
-                        deps.onAuthComplete(serverName).catch(() => { });
-                    }
-                    return {
-                        content: [{ type: "text", text: `Please authenticate with "${serverName}" at:\n${result.authUrl}` }],
-                        details: { type: "mcp_auth_proxy", server: serverName, status: "auth_url" },
-                    };
-                case "already_authenticated":
-                    return {
-                        content: [{ type: "text", text: `Server "${serverName}" is already authenticated.` }],
-                        details: { type: "mcp_auth_proxy", server: serverName, status: "already_authenticated" },
-                    };
-                case "step_up_required":
-                    return {
-                        content: [{
-                                type: "text",
-                                text: `Server "${serverName}" requires elevated permissions.\n` +
-                                    (result.authUrl ? `Re-authorize at: ${result.authUrl}` : "Please re-authenticate with elevated permissions."),
-                            }],
-                        details: { type: "mcp_auth_proxy", server: serverName, status: "step_up_required" },
-                    };
-                case "unsupported":
-                    return {
-                        content: [{ type: "text", text: `Server "${serverName}" does not support authentication (local transport).` }],
-                        details: { type: "mcp_auth_proxy", server: serverName, status: "unsupported" },
-                    };
-                default:
-                    return {
-                        content: [{ type: "text", text: `Authentication failed for "${serverName}": ${result.message || "unknown"}` }],
-                        details: { type: "mcp_auth_proxy", server: serverName, status: "error", error: result.message },
-                    };
-            }
-        },
-    };
-}

package/dist/skills/tools/memory-tool.d.ts

@@ -1,74 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const MEMORY_SEARCH_TOOL_NAME: "memory_search";
-export type MemorySource = "memory" | "sessions" | "all";
-export interface MemorySearchToolParams {
-    /** Search query */
-    query: string;
-    /** Source to search in */
-    source?: MemorySource;
-    /** Maximum results to return */
-    maxResults?: number;
-    /** Filter by time range (ISO date string, sessions only) */
-    after?: string;
-    /** Filter by time range (ISO date string, sessions only) */
-    before?: string;
-}
-export declare const MEMORY_SEARCH_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly query: {
-            readonly type: "string";
-            readonly description: "Search query. Supports natural language and keywords.";
-        };
-        readonly source: {
-            readonly type: "string";
-            readonly enum: readonly ["memory", "sessions", "all"];
-            readonly description: string;
-        };
-        readonly maxResults: {
-            readonly type: "number";
-            readonly description: "Maximum results to return (default: 5).";
-        };
-        readonly after: {
-            readonly type: "string";
-            readonly description: "Only return sessions after this date (ISO format). Sessions source only.";
-        };
-        readonly before: {
-            readonly type: "string";
-            readonly description: "Only return sessions before this date (ISO format). Sessions source only.";
-        };
-    };
-    readonly required: readonly ["query"];
-};
-export interface MemoryEntry {
-    content: string;
-    source: "memory" | "session";
-    relevance: number;
-    metadata?: {
-        sessionId?: string;
-        timestamp?: string;
-        summary?: string;
-    };
-}
-export interface MemoryQueryOutput {
-    results: MemoryEntry[];
-    query: string;
-    sources: MemorySource[];
-}
-/**
- * Host-provided memory search backend.
- */
-export interface MemorySearchToolDeps {
-    /**
-     * Search memory/sessions.
-     * The host routes to QMemory vector search, FTS session search, or both.
-     */
-    searchMemory(params: {
-        query: string;
-        source: MemorySource;
-        maxResults: number;
-        after?: string;
-        before?: string;
-    }): Promise<MemoryQueryOutput>;
-}
-export declare function createMemorySearchTool(deps: MemorySearchToolDeps): PortableTool<MemorySearchToolParams>;

package/dist/skills/tools/memory-tool.js

@@ -1,88 +0,0 @@
-// ============================================================
-// Memory Tool — enhanced memory query with multi-source search.
-// Reference: hermes-agent-main/tools/memory_tool.py
-//            hermes-agent-main/tools/session_search_tool.py
-// Category: system
-// ============================================================
-export const MEMORY_SEARCH_TOOL_NAME = "memory_search";
-export const MEMORY_SEARCH_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        query: {
-            type: "string",
-            description: "Search query. Supports natural language and keywords.",
-        },
-        source: {
-            type: "string",
-            enum: ["memory", "sessions", "all"],
-            description: "Where to search:\n" +
-                '- "memory": curated long-term memory (QMemory vector store)\n' +
-                '- "sessions": past conversation history (full-text search)\n' +
-                '- "all": both sources merged (default)',
-        },
-        maxResults: {
-            type: "number",
-            description: "Maximum results to return (default: 5).",
-        },
-        after: {
-            type: "string",
-            description: "Only return sessions after this date (ISO format). Sessions source only.",
-        },
-        before: {
-            type: "string",
-            description: "Only return sessions before this date (ISO format). Sessions source only.",
-        },
-    },
-    required: ["query"],
-};
-const DEFAULT_MAX_RESULTS = 5;
-export function createMemorySearchTool(deps) {
-    return {
-        name: MEMORY_SEARCH_TOOL_NAME,
-        label: "Memory Query",
-        description: "Search your long-term memory and past conversations. " +
-            "Sources: 'memory' (curated knowledge), 'sessions' (conversation history), 'all' (both). " +
-            "Use for recalling previous decisions, finding past code/scripts, or checking what was discussed.",
-        parameters: MEMORY_SEARCH_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            if (!params.query || params.query.trim().length < 2) {
-                return {
-                    content: [{ type: "text", text: "Error: query must be at least 2 characters." }],
-                    details: { type: "memory_query", error: "invalid_query" },
-                };
-            }
-            const source = params.source || "all";
-            const maxResults = Math.min(params.maxResults ?? DEFAULT_MAX_RESULTS, 20);
-            const output = await deps.searchMemory({
-                query: params.query.trim(),
-                source,
-                maxResults,
-                after: params.after,
-                before: params.before,
-            });
-            if (output.results.length === 0) {
-                return {
-                    content: [{ type: "text", text: `No results found for "${params.query}" in ${source} source(s).` }],
-                    details: { type: "memory_query", query: params.query, source, resultCount: 0 },
-                };
-            }
-            const lines = [`Found ${output.results.length} result(s) for "${params.query}":\n`];
-            for (let i = 0; i < output.results.length; i++) {
-                const entry = output.results[i];
-                const srcLabel = entry.source === "memory" ? "📝 Memory" : "💬 Session";
-                const meta = entry.metadata;
-                const timestamp = meta?.timestamp ? ` (${meta.timestamp})` : "";
-                lines.push(`${i + 1}. [${srcLabel}]${timestamp}`);
-                if (meta?.summary) {
-                    lines.push(`   Summary: ${meta.summary}`);
-                }
-                lines.push(`   ${entry.content.slice(0, 300)}${entry.content.length > 300 ? "..." : ""}`);
-                lines.push("");
-            }
-            return {
-                content: [{ type: "text", text: lines.join("\n") }],
-                details: { type: "memory_query", query: params.query, source, resultCount: output.results.length },
-            };
-        },
-    };
-}