wave-agent-sdk 1.1.5 → 1.3.0

package/dist/managers/mcpManager.js

@@ -1,10 +1,12 @@
 import { promises as fs } from "fs";
 import { join } from "path";
+import { homedir } from "os";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { createMcpToolPlugin, findToolServer } from "../utils/mcpUtils.js";
+import { createMcpToolPlugin, findToolServer, mcpToolFlatName, } from "../utils/mcpUtils.js";
+import { truncateMcpInstructions } from "../utils/mcpInstructions.js";
 import { logger } from "../utils/globalLogger.js";
 /**
  * Expand environment variables in a string value.
@@ -73,9 +75,12 @@ export class McpManager {
         this.servers = new Map();
         this.connections = new Map();
         this.configPath = "";
+        this.userConfigPath = "";
         this.workdir = "";
         this.reconnectTimers = new Map();
         this.reconnectAttempts = new Map();
+        /** Explicit disconnectServer teardowns currently in flight */
+        this.disconnecting = new Set();
         this.callbacks = options.callbacks || {};
         this.mcpServers = options.mcpServers;
     }
@@ -94,6 +99,7 @@ export class McpManager {
      */
     async initialize(workdir, autoConnect = false) {
         this.configPath = join(workdir, ".mcp.json");
+        this.userConfigPath = join(homedir(), ".wave", "mcp.json");
         this.workdir = workdir;
         // Register constructor-provided servers before loading .mcp.json
         if (this.mcpServers) {
@@ -141,22 +147,40 @@ export class McpManager {
             return null;
         }
         try {
-            const configContent = await fs.readFile(this.configPath, "utf-8");
-            const rawConfig = JSON.parse(configContent);
-            const workspaceConfig = resolveMcpConfig(rawConfig, this.envSnapshot);
+            // Load user-level (~/.wave/mcp.json) and project-level (<workdir>/.mcp.json)
+            // configs, then merge with project taking precedence over user-level.
+            const userConfig = await this.readConfigFile(this.userConfigPath);
+            const projectConfig = await this.readConfigFile(this.configPath);
+            // Neither file exists: preserve the original null contract (constructor-
+            // provided servers may still be present in this.config).
+            if (!userConfig && !projectConfig) {
+                return this.config;
+            }
+            const userResolved = userConfig
+                ? resolveMcpConfig(userConfig, this.envSnapshot)
+                : null;
+            const projectResolved = projectConfig
+                ? resolveMcpConfig(projectConfig, this.envSnapshot)
+                : null;
             // Extract original (pre-resolution) URLs for safe display
             const originalUrls = {};
-            for (const [name, serverConfig] of Object.entries(rawConfig.mcpServers)) {
+            for (const [name, serverConfig] of Object.entries({
+                ...(userConfig?.mcpServers || {}),
+                ...(projectConfig?.mcpServers || {}),
+            })) {
                 originalUrls[name] = serverConfig.url;
             }
-            // Merge workspace config with any existing config (e.g., from plugins or constructor)
-            // Constructor-provided servers take precedence, then workspace config, then existing config
+            // Merge: existing config (e.g. plugin servers) -> user -> project -> constructor
             const merged = { mcpServers: {} };
             if (this.config) {
                 Object.assign(merged.mcpServers, this.config.mcpServers);
             }
-            Object.assign(merged.mcpServers, workspaceConfig.mcpServers);
-            // Constructor-provided servers override both for same names
+            if (userResolved) {
+                Object.assign(merged.mcpServers, userResolved.mcpServers);
+            }
+            if (projectResolved) {
+                Object.assign(merged.mcpServers, projectResolved.mcpServers);
+            }
             if (this.mcpServers) {
                 Object.assign(merged.mcpServers, this.mcpServers);
             }
@@ -165,12 +189,27 @@ export class McpManager {
             if (this.config) {
                 for (const [name, config] of Object.entries(this.config.mcpServers)) {
                     const existingServer = this.servers.get(name);
+                    // Determine scope: plugin servers registered with pluginRoot keep
+                    // their plugin scope; user-level names come from ~/.wave/mcp.json.
+                    let scope = existingServer?.scope;
+                    if (!scope) {
+                        if (config.pluginRoot) {
+                            scope = "plugin";
+                        }
+                        else if (userConfig?.mcpServers?.[name]) {
+                            scope = "user";
+                        }
+                        else {
+                            scope = "project";
+                        }
+                    }
                     if (existingServer) {
                         // Update config but preserve status and other runtime info
                         this.servers.set(name, {
                             ...existingServer,
                             config, // Update config in case it changed
                             originalUrl: originalUrls[name] ?? existingServer.originalUrl,
+                            scope,
                         });
                     }
                     else {
@@ -179,6 +218,7 @@ export class McpManager {
                             name,
                             config,
                             originalUrl: originalUrls[name],
+                            scope,
                             status: "disconnected",
                         });
                     }
@@ -189,11 +229,41 @@ export class McpManager {
         catch (error) {
             // Only log error if it's not a "file not found" error
             if (error.code !== "ENOENT") {
-                logger?.error("Failed to load .mcp.json:", error);
+                logger?.error("Failed to load MCP config:", error);
             }
             return null;
         }
     }
+    /**
+     * Read a raw MCP config file, tolerating ENOENT and corrupt JSON.
+     */
+    async readConfigFile(configPath) {
+        if (!configPath)
+            return null;
+        try {
+            const content = await fs.readFile(configPath, "utf-8");
+            return JSON.parse(content);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT")
+                return null;
+            logger?.error("Failed to load .mcp.json:", error);
+            return null;
+        }
+    }
+    /**
+     * The user-level MCP config path (~/.wave/mcp.json).
+     */
+    getUserConfigPath() {
+        return this.userConfigPath;
+    }
+    /**
+     * The project-level MCP config path (<workdir>/.mcp.json).
+     */
+    getProjectConfigPath() {
+        return this.configPath;
+    }
     async saveConfig(config) {
         try {
             await fs.writeFile(this.configPath, JSON.stringify(config, null, 2));
@@ -214,6 +284,38 @@ export class McpManager {
     getServer(name) {
         return this.servers.get(name);
     }
+    /**
+     * The usage notes each usable server described about itself (`initialize`'s
+     * `instructions`), for the announcement appended to the conversation.
+     *
+     * "Usable" is the same predicate `getAllConnectedTools` uses — connected, or
+     * reconnecting with its last-known snapshot retained — so a server's prose is
+     * visible exactly while its tools are. A server that dropped, failed to connect
+     * or went to `error` keeps its snapshot but stops being reported here, which is
+     * what keeps a dead server from still talking to the model.
+     *
+     * `isDenied` receives flattened tool names (`mcp__server__tool`, the shape
+     * permission rules match on); a server whose tools are *all* excluded by rules is
+     * dropped whole, so prose cannot reach the context after the user ruled the
+     * server out. A server exposing no tools at all is still reported: nothing was
+     * excluded, it is simply a server that brings context rather than tools.
+     */
+    getServerInstructions(isDenied) {
+        const result = [];
+        for (const server of this.servers.values()) {
+            const usable = server.status === "connected" || server.status === "reconnecting";
+            const instructions = server.instructions?.trim();
+            if (!usable || !instructions)
+                continue;
+            const tools = server.tools ?? [];
+            if (tools.length > 0 &&
+                tools.every((tool) => isDenied?.(mcpToolFlatName(server.name, tool.name)))) {
+                continue;
+            }
+            result.push({ name: server.name, instructions });
+        }
+        return result;
+    }
     updateServerStatus(name, updates) {
         const server = this.servers.get(name);
         if (server) {
@@ -258,6 +360,7 @@ export class McpManager {
             name,
             config: resolvedConfig,
             originalUrl,
+            scope: resolvedConfig.pluginRoot ? "plugin" : undefined,
             status: "disconnected",
         };
         this.servers.set(name, newServer);
@@ -283,6 +386,55 @@ export class McpManager {
         }
         return removed;
     }
+    /**
+     * Drop every MCP server contributed by a plugin (matched on pluginRoot),
+     * disconnecting each one. Needed instead of re-adding under the same name
+     * because addServer refuses a name that is already registered.
+     * Called by the in-place plugin reload path before re-registering.
+     * @returns the number of servers removed
+     */
+    removeServersForPlugin(pluginRoot) {
+        let removed = 0;
+        for (const [name, server] of Array.from(this.servers.entries())) {
+            if (server.config.pluginRoot !== pluginRoot) {
+                continue;
+            }
+            this.removeServer(name);
+            removed += 1;
+        }
+        if (removed > 0) {
+            logger?.debug(`Removed ${removed} MCP servers for plugin root ${pluginRoot}`);
+        }
+        return removed;
+    }
+    /**
+     * Remove a server from a persisted config file (user or project scope),
+     * then disconnect and drop it from the in-memory registry.
+     * @param scope - "user" removes from ~/.wave/mcp.json; "project" removes from <workdir>/.mcp.json
+     * @param name - The server name
+     * @returns true if the server was found and removed
+     */
+    async removeServerFromConfig(scope, name) {
+        const configPath = scope === "user" ? this.userConfigPath : this.configPath;
+        if (!configPath)
+            return false;
+        const rawConfig = await this.readConfigFile(configPath);
+        if (!rawConfig ||
+            !rawConfig.mcpServers ||
+            !(name in rawConfig.mcpServers)) {
+            return false;
+        }
+        delete rawConfig.mcpServers[name];
+        if (Object.keys(rawConfig.mcpServers).length === 0) {
+            await fs.rm(configPath, { force: true });
+        }
+        else {
+            await fs.writeFile(configPath, JSON.stringify(rawConfig, null, 2));
+        }
+        // Drop from memory (disconnects if connected)
+        this.removeServer(name);
+        return true;
+    }
     // Real MCP connection implementation
     async connectServer(name) {
         const server = this.servers.get(name);
@@ -291,12 +443,20 @@ export class McpManager {
         // Already connected
         if (this.connections.has(name))
             return true;
+        // An explicit disconnectServer teardown is in flight for this server —
+        // don't race it (e.g. an auto-reconnect timer that just fired) by spawning
+        // a fresh process the user asked to stop.
+        if (this.disconnecting.has(name))
+            return false;
         this.updateServerStatus(name, { status: "connecting" });
         try {
             // Create transport - it will manage the process
             let transport;
             let client;
             let tools = [];
+            // Server-level usage notes from `initialize`; part of the connection's
+            // handshake, so it is read once here rather than re-requested later.
+            let instructions;
             const createClient = () => new Client({
                 name: "wave-code",
                 version: "1.0.0",
@@ -316,12 +476,14 @@ export class McpManager {
                 });
                 client = createClient();
                 await client.connect(transport);
+                instructions = truncateMcpInstructions(client.getInstructions());
                 const toolsResponse = await client.listTools();
                 tools =
                     toolsResponse.tools?.map((tool) => ({
                         name: tool.name,
                         description: tool.description,
                         inputSchema: tool.inputSchema,
+                        outputSchema: tool.outputSchema,
                     })) || [];
                 logger?.info(`Connected to MCP server ${name} using Streamable HTTP`);
             }
@@ -337,12 +499,14 @@ export class McpManager {
                 });
                 client = createClient();
                 await client.connect(transport);
+                instructions = truncateMcpInstructions(client.getInstructions());
                 const toolsResponse = await client.listTools();
                 tools =
                     toolsResponse.tools?.map((tool) => ({
                         name: tool.name,
                         description: tool.description,
                         inputSchema: tool.inputSchema,
+                        outputSchema: tool.outputSchema,
                     })) || [];
                 logger?.info(`Connected to MCP server ${name} using SSE`);
             }
@@ -414,12 +578,14 @@ export class McpManager {
                     logger?.debug(`[MCP Server ${name}] Server stderr: ${stderrOutput.trim()}`);
                     stderrOutput = "";
                 }
+                instructions = truncateMcpInstructions(client.getInstructions());
                 const toolsResponse = await client.listTools();
                 tools =
                     toolsResponse.tools?.map((tool) => ({
                         name: tool.name,
                         description: tool.description,
                         inputSchema: tool.inputSchema,
+                        outputSchema: tool.outputSchema,
                     })) || [];
             }
             else if (serverType) {
@@ -454,14 +620,23 @@ export class McpManager {
             };
             transport.onclose = () => {
                 logger?.debug(`MCP Server ${name} transport closed`);
+                // Only the current generation of this server's transport may mutate
+                // state: a stale process 'close' arriving after an auto-reconnect must
+                // not tear down (or schedule a reconnect for) the live connection.
+                const current = this.connections.get(name);
+                if (!current || current.transport !== transport)
+                    return;
                 this.connections.delete(name);
                 this.updateServerStatus(name, {
                     status: "disconnected",
                     tools: [],
                     toolCount: 0,
+                    instructions: undefined,
                 });
-                // Auto-reconnect with exponential backoff (not triggered by explicit disconnect)
-                if (!this.reconnectTimers.has(name)) {
+                // Auto-reconnect with exponential backoff. Skipped while an explicit
+                // disconnectServer teardown is in flight — that close is expected, and
+                // reconnecting would silently undo a user-initiated disconnect.
+                if (!this.disconnecting.has(name) && !this.reconnectTimers.has(name)) {
                     this.scheduleReconnect(name);
                 }
             };
@@ -477,6 +652,7 @@ export class McpManager {
                 tools,
                 toolCount: tools.length,
                 capabilities: ["tools"],
+                instructions,
                 lastConnected: Date.now(),
                 error: undefined,
             });
@@ -540,6 +716,7 @@ export class McpManager {
                     name: tool.name,
                     description: tool.description,
                     inputSchema: tool.inputSchema,
+                    outputSchema: tool.outputSchema,
                 })) || [];
                 logger?.info(`MCP Server ${name} auto-reconnected successfully (attempt ${i + 1})`);
                 this.updateServerStatus(name, {
@@ -570,27 +747,67 @@ export class McpManager {
     async disconnectServer(name) {
         // Cancel any pending reconnect attempts
         this.cancelReconnect(name);
+        const server = this.servers.get(name);
         const connection = this.connections.get(name);
-        if (!connection)
+        // Nothing live to tear down. Still reconcile a stale "connected"-style
+        // status (e.g. after an unobserved crash left no connection entry) so the
+        // UI converges instead of staying wedged on a disconnect action.
+        if (!connection) {
+            if (server && server.status !== "disconnected") {
+                this.updateServerStatus(name, {
+                    status: "disconnected",
+                    tools: [],
+                    toolCount: 0,
+                    instructions: undefined,
+                    error: undefined,
+                });
+            }
+            return false;
+        }
+        // Idempotent: a teardown is already running for this server.
+        if (this.disconnecting.has(name))
             return false;
+        // Mark before closing so transport.onclose knows this is an expected,
+        // user-initiated teardown and must not schedule an auto-reconnect.
+        this.disconnecting.add(name);
         try {
             // Close client connection and transport
             await connection.client.close();
             await connection.transport.close();
-            // Remove connection
-            this.connections.delete(name);
+            // Remove connection (transport.onclose may already have done so)
+            if (this.connections.get(name) === connection) {
+                this.connections.delete(name);
+            }
             // updateServerStatus will trigger the callback
             this.updateServerStatus(name, {
                 status: "disconnected",
                 tools: [],
                 toolCount: 0,
+                instructions: undefined,
+                error: undefined,
             });
             return true;
         }
         catch (error) {
             logger?.error(`Error disconnecting from MCP server ${name}:`, error);
+            // Never leave the server reporting connected after a failed teardown:
+            // drop the connection and push a terminal state so the caller/UI gets a
+            // definitive outcome instead of an endless "disconnecting" spinner.
+            if (this.connections.get(name) === connection) {
+                this.connections.delete(name);
+            }
+            this.updateServerStatus(name, {
+                status: "disconnected",
+                tools: [],
+                toolCount: 0,
+                instructions: undefined,
+                error: error instanceof Error ? error.message : String(error),
+            });
             return false;
         }
+        finally {
+            this.disconnecting.delete(name);
+        }
     }
     // Get all tools from connected servers.
     // "reconnecting" servers retain their last-known tool snapshot so that
@@ -675,9 +892,17 @@ export class McpManager {
                 : images.length > 0
                     ? `Tool returned ${images.length} image(s).`
                     : "No content";
+            // The sandbox's value, decided from the text parts rather than from
+            // `textContentStr`: that one carries display placeholders ("No content"),
+            // and a script has to be able to tell "the tool said nothing" (`null`) from
+            // "the tool said 'No content'". Same rule the catalog renders return types
+            // from: structured, else text, else null.
+            const text = textContent.join("\n");
+            const output = result.structuredContent ?? (text === "" ? null : text);
             return {
                 success: true,
                 content: textContentStr,
+                output,
                 images: images.length > 0 ? images : undefined,
                 serverName,
             };
@@ -721,6 +946,31 @@ export class McpManager {
     getMcpToolsConfig() {
         return this.getMcpToolPlugins().map((tool) => tool.config);
     }
+    /**
+     * Declared output schema per flattened tool name, for the Exec catalog's return
+     * types.
+     *
+     * A separate accessor because `getMcpToolsConfig()` cannot carry it: an OpenAI
+     * function declaration has room for `parameters` and nothing else, so the schema
+     * a server declared for its *output* has no field to travel in. Correlated with
+     * the same `findToolServer` lookup `getMcpToolPlugins` uses and keyed with the
+     * same `mcpToolFlatName`, so the two agree on which server owns a tool.
+     *
+     * Servers that declare no output schema are simply absent, which renders as
+     * `Promise<unknown>`: honest about the call returning *something* of unspecified
+     * shape.
+     */
+    getMcpToolOutputSchemas() {
+        const schemas = new Map();
+        const servers = this.getAllServers();
+        for (const tool of this.getAllConnectedTools()) {
+            const server = findToolServer(tool.name, servers);
+            if (server && tool.outputSchema) {
+                schemas.set(mcpToolFlatName(server.name, tool.name), tool.outputSchema);
+            }
+        }
+        return schemas;
+    }
     /**
      * Execute an MCP tool by name (registry version)
      */

package/dist/managers/messageManager.d.ts

@@ -1,8 +1,9 @@
 import { UserMessageParams, type AgentToolBlockUpdateParams, type ToolBlockUpdateCallbackParams, type AddNotificationMessageParams } from "../utils/messageOperations.js";
-import type { Message, Usage } from "../types/index.js";
+import type { Message, Usage, InvokedSkillRecord } from "../types/index.js";
 import { SessionData } from "../services/session.js";
 import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
 import type { MemoryRule } from "../types/memoryRule.js";
+import { type NestedMemoryFile } from "../utils/nestedMemory.js";
 import { Container } from "../utils/container.js";
 export interface MessageManagerCallbacks {
     onSessionIdChange?: (sessionId: string) => void;
@@ -24,9 +25,6 @@ export interface MessageManagerCallbacks {
     onErrorBlockAdded?: (error: string) => void;
     onCompactBlockAdded?: (content: string) => void;
     onCompactionStateChange?: (isCompacting: boolean) => void;
-    onAddBangMessage?: (command: string, messageId: string) => void;
-    onUpdateBangMessage?: (command: string, output: string, messageId: string) => void;
-    onCompleteBangMessage?: (command: string, exitCode: number, messageId: string, output?: string) => void;
     onInfoBlockAdded?: (content: string) => void;
     onShowRewind?: () => void;
     onFileHistoryBlockAdded?: (snapshots: import("../types/reversion.js").FileSnapshot[]) => void;
@@ -47,6 +45,13 @@ export declare class MessageManager {
     private container;
     private sessionId;
     private messages;
+    /** Full display message stream for the UI. Mirrors `messages` (context) on
+     * every normal change; the two diverge only around compaction, where
+     * `messages` is replaced by [compact, ...last API rounds] for the API
+     * context while `displayMessages` keeps the full history and appends the
+     * compact block (aligned with Claude Code desktop/VS Code: compaction
+     * folds the API context but leaves the UI transcript intact). */
+    private displayMessages;
     private latestTotalTokens;
     private workdir;
     private encodedWorkdir;
@@ -55,19 +60,38 @@ export declare class MessageManager {
     private savedMessageCount;
     private pendingFileReadTriggers;
     private loadedRuleIds;
+    private pendingNestedMemoryTriggers;
+    private loadedNestedMemoryPaths;
     private recentFileReads;
     private invokedSkills;
     private sessionType;
     private subagentType?;
     private _usages;
+    /**
+     * This session's user-set title, as last known to this process (set on
+     * rename, or recovered from the transcript on resume). It is the fallback
+     * `reAppendSessionMetadata` writes back at EOF once the `custom-title` entry
+     * has been pushed out of the listing's tail window — at which point the file
+     * itself can no longer answer "what was this session called".
+     */
+    private customTitle?;
     constructor(container: Container, options: MessageManagerOptions);
     private get memoryRuleManager();
     private get memoryService();
     getSessionId(): string;
     getRootSessionId(): string;
     getMessages(): Message[];
+    /** Full UI display message stream (includes pre-compaction history). */
+    getDisplayMessages(): Message[];
     getUsages(): Usage[];
     getLatestTotalTokens(): number;
+    /**
+     * Re-point this manager at another working directory (in-session session
+     * switch). The encoded workdir and the transcript path are both derived from
+     * it, so they must move together with it: otherwise the next append would
+     * create a second copy of the same session file under the old project dir.
+     */
+    setWorkdir(workdir: string): void;
     getWorkdir(): string;
     /**
      * Process pending file read triggers: match against conditional rules,
@@ -105,17 +129,42 @@ export declare class MessageManager {
      * conditional memory rules before the next AI call.
      */
     triggerFileRead(filePath: string): void;
+    /**
+     * Record an absolute path whose read may pull in a nested memory file
+     * (`AGENTS.md` in one of its ancestor directories). Separate from
+     * `triggerFileRead`: rule matching needs workdir-relative paths, the nested
+     * walk needs absolute ones.
+     */
+    triggerNestedMemory(filePath: string): void;
+    /**
+     * Resolve nested memory files for the paths read since the last call,
+     * outermost first. Clears the pending set; dedup is session-scoped via
+     * `loadedNestedMemoryPaths`.
+     */
+    collectNestedMemoryFiles(): Promise<NestedMemoryFile[]>;
     /**
      * Check if a file has been read (for read-before-edit enforcement).
      * Uses recentFileReads Map populated from Read tool execution.
      */
     hasFileBeenRead(filePath: string): boolean;
-    setMessages(messages: Message[]): void;
+    setMessages(messages: Message[], opts?: {
+        keepDisplay?: boolean;
+    }): void;
     /**
      * Save current session
      */
     saveSession(): Promise<void>;
     setlatestTotalTokens(latestTotalTokens: number): void;
+    getCustomTitle(): string | undefined;
+    setCustomTitle(customTitle: string | undefined): void;
+    /**
+     * Re-append the session's metadata entries at EOF, so they stay inside the
+     * tail window the session list reads. Called at the sparse points where the
+     * transcript is about to be read back by another process (exit, compaction,
+     * resume, rewind); doing it per save would cost a tail read plus a line on
+     * every message.
+     */
+    reAppendSessionMetadata(): Promise<void>;
     /**
      * Clear messages
      */
@@ -145,15 +194,6 @@ export declare class MessageManager {
      */
     compactMessagesAndUpdateSession(compactedContent: string, usage?: Usage): Promise<void>;
     addFileHistoryBlock(snapshots: import("../types/reversion.js").FileSnapshot[]): void;
-    addBangMessage(command: string): void;
-    updateBangMessage(command: string, output: string): void;
-    completeBangMessage(command: string, exitCode: number, output?: string): void;
-    /**
-     * Find the message ID of the most recent message containing a bang block
-     * for the given command. Bang callbacks do not carry a block ID, so the
-     * message is located by matching the command against bang blocks.
-     */
-    private findBangMessageId;
     addNotificationMessage(params: Omit<AddNotificationMessageParams, "messages">): void;
     /**
      * Rebuild usage array from messages containing usage metadata
@@ -215,7 +255,9 @@ export declare class MessageManager {
      */
     truncateHistory(index: number, reversionManager?: import("./reversionManager.js").ReversionManager): Promise<void>;
     /**
-     * Rewrite the session file with the current messages.
+     * Drop everything past the first `keepMessageCount` messages from the
+     * session file. The rewrite is a filter over the file's own lines, so the
+     * metadata header, the user-set title and any other reserved entry survive.
      */
     private rewriteSessionFile;
     /**
@@ -243,11 +285,11 @@ export declare class MessageManager {
      */
     private extractSkillInvocationsFromMessage;
     /**
-     * Get recently invoked skill names, sorted by timestamp (newest first).
+     * Get recently invoked skills, sorted by timestamp (newest first).
      * @param maxSkills - Maximum number of skills to return
-     * @returns Array of skill names sorted by recency
+     * @returns Invoked skill records sorted by recency
      */
-    getInvokedSkillNames(maxSkills?: number): string[];
+    getInvokedSkills(maxSkills?: number): InvokedSkillRecord[];
     /**
      * Clear all invoked skills (e.g., after compaction).
      */