@pencil-agent/nano-pencil 1.7.0 → 1.8.0

package/dist/core/mcp/mcp-adapter.js

@@ -4,25 +4,38 @@
  * Adapts MCP tools to work with NanoPencil's tool system.
  */
 import { formatGuidanceMessage, getAPIKeyGuidance } from "./mcp-guidance.js";
+function toSafeToolName(fullName) {
+    const normalized = `mcp_${fullName.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+    if (normalized.length <= 60)
+        return normalized;
+    let hash = 0;
+    for (let i = 0; i < fullName.length; i++) {
+        hash = (hash * 31 + fullName.charCodeAt(i)) | 0;
+    }
+    const suffix = Math.abs(hash).toString(36);
+    return `${normalized.slice(0, 50)}_${suffix}`;
+}
 /**
  * Create a NanoPencil ToolDefinition from an MCP tool definition
  */
 export function createMCPTool(mcpClient, mcpTool) {
-    const toolName = mcpTool.name; // Full name like "filesystem/read"
-    const [serverId] = toolName.split("/");
+    const rawToolName = mcpTool.name; // Full name like "filesystem/read"
+    const toolName = toSafeToolName(rawToolName);
+    const [serverId] = rawToolName.split("/");
     return {
         name: toolName,
-        label: toolName,
-        description: mcpTool.description,
+        label: rawToolName,
+        description: `${mcpTool.description} (MCP: ${rawToolName})`,
         // Use TypeBox Object schema with any properties since MCP tools have dynamic schemas
-        parameters: {
-            type: "object",
-            properties: {},
-            additionalProperties: true,
-        },
+        parameters: mcpTool.inputSchema ??
+            {
+                type: "object",
+                properties: {},
+                additionalProperties: true,
+            },
         async execute(toolCallId, params, signal, onUpdate, ctx) {
             try {
-                const result = await mcpClient.callTool(toolName, params);
+                const result = await mcpClient.callTool(rawToolName, params);
                 if (result.error) {
                     // Check if error is due to missing API key and provide guidance
                     const guidance = getAPIKeyGuidance(serverId);
@@ -79,9 +92,7 @@ export function createMCPTool(mcpClient, mcpTool) {
                     };
                 }
                 return {
-                    content: [
-                        { type: "text", text: `Failed to call MCP tool ${toolName}` },
-                    ],
+                    content: [{ type: "text", text: `Failed to call MCP tool ${rawToolName}` }],
                     details: {
                         error: error instanceof Error ? error.message : String(error),
                     },

package/dist/core/mcp/mcp-client.d.ts

@@ -2,7 +2,7 @@
  * MCP (Model Context Protocol) Client
  *
  * Provides client functionality to connect to MCP servers and call their tools.
- * Supports both stdio and SSE transport types.
+ * Supports stdio transport with JSON-RPC framing.
  */
 export interface MCPServerConfig {
     /** Unique identifier for this server */
@@ -28,7 +28,7 @@ export interface MCPTool {
     /** Tool description */
     description: string;
     /** JSON Schema for input */
-    inputSchema: any;
+    inputSchema: Record<string, unknown>;
     /** Server ID */
     serverId: string;
 }
@@ -50,7 +50,7 @@ export interface MCPToolResult {
  */
 export declare class MCPClient {
     private servers;
-    private serverProcesses;
+    private serverRuntimes;
     private serverTools;
     constructor();
     /**
@@ -73,6 +73,16 @@ export declare class MCPClient {
      * Remove a server
      */
     removeServer(id: string): void;
+    private getRuntime;
+    private attachStdoutParser;
+    private processStdoutBuffer;
+    private handleJsonRpcMessage;
+    private writeFramedMessage;
+    private sendNotification;
+    private sendRequest;
+    private initializeServer;
+    private normalizeToolRecord;
+    private loadToolsForServer;
     /**
      * Start an MCP server (for stdio transport)
      */
@@ -92,7 +102,7 @@ export declare class MCPClient {
     /**
      * Call an MCP tool
      */
-    callTool(toolName: string, args: Record<string, any>): Promise<MCPToolResult>;
+    callTool(toolName: string, args: Record<string, unknown>): Promise<MCPToolResult>;
     /**
      * Call tool via stdio (JSON-RPC)
      */

package/dist/core/mcp/mcp-client.js

@@ -2,7 +2,7 @@
  * MCP (Model Context Protocol) Client
  *
  * Provides client functionality to connect to MCP servers and call their tools.
- * Supports both stdio and SSE transport types.
+ * Supports stdio transport with JSON-RPC framing.
  */
 import { spawn } from "child_process";
 import { existsSync, readFileSync } from "fs";
@@ -14,7 +14,7 @@ import { getAgentDir } from "../../config.js";
  */
 export class MCPClient {
     servers = new Map();
-    serverProcesses = new Map();
+    serverRuntimes = new Map();
     serverTools = new Map();
     constructor() {
         this.loadServersFromConfig();
@@ -67,6 +67,202 @@ export class MCPClient {
         this.serverTools.delete(id);
         this.stopServer(id);
     }
+    getRuntime(serverId) {
+        return this.serverRuntimes.get(serverId);
+    }
+    attachStdoutParser(serverId, runtime) {
+        runtime.process.stdout.on("data", (chunk) => {
+            runtime.buffer = Buffer.concat([runtime.buffer, chunk]);
+            this.processStdoutBuffer(serverId, runtime);
+        });
+        runtime.process.stderr.on("data", (chunk) => {
+            const text = chunk.toString("utf8").trim();
+            if (text.length > 0) {
+                console.error(`[MCP:${serverId}] ${text}`);
+            }
+        });
+        runtime.process.on("exit", (code, signal) => {
+            const message = `MCP server ${serverId} exited (code=${code ?? "null"}, signal=${signal ?? "null"})`;
+            for (const pending of runtime.pendingRequests.values()) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error(message));
+            }
+            runtime.pendingRequests.clear();
+            this.serverRuntimes.delete(serverId);
+        });
+    }
+    processStdoutBuffer(serverId, runtime) {
+        // MCP stdio framing: "Content-Length: N\r\n\r\n<json>"
+        while (runtime.buffer.length > 0) {
+            const headerEnd = runtime.buffer.indexOf("\r\n\r\n");
+            if (headerEnd !== -1) {
+                const headerText = runtime.buffer.slice(0, headerEnd).toString("utf8");
+                const lengthMatch = headerText.match(/content-length:\s*(\d+)/i);
+                if (!lengthMatch) {
+                    runtime.buffer = runtime.buffer.slice(headerEnd + 4);
+                    continue;
+                }
+                const bodyLength = Number(lengthMatch[1]);
+                const totalLength = headerEnd + 4 + bodyLength;
+                if (runtime.buffer.length < totalLength) {
+                    return;
+                }
+                const body = runtime.buffer
+                    .slice(headerEnd + 4, totalLength)
+                    .toString("utf8");
+                runtime.buffer = runtime.buffer.slice(totalLength);
+                this.handleJsonRpcMessage(serverId, body);
+                continue;
+            }
+            // Fallback for line-delimited JSON
+            const lineEnd = runtime.buffer.indexOf("\n");
+            if (lineEnd === -1) {
+                return;
+            }
+            const line = runtime.buffer.slice(0, lineEnd).toString("utf8").trim();
+            runtime.buffer = runtime.buffer.slice(lineEnd + 1);
+            if (line.length > 0) {
+                this.handleJsonRpcMessage(serverId, line);
+            }
+        }
+    }
+    handleJsonRpcMessage(serverId, raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (msg.id === undefined) {
+            // Notification/unsolicited message
+            return;
+        }
+        const id = typeof msg.id === "number" ? msg.id : Number(msg.id);
+        if (!Number.isFinite(id)) {
+            return;
+        }
+        const runtime = this.serverRuntimes.get(serverId);
+        if (!runtime)
+            return;
+        const pending = runtime.pendingRequests.get(id);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        runtime.pendingRequests.delete(id);
+        if (msg.error) {
+            pending.reject(new Error(msg.error.message || `JSON-RPC error ${msg.error.code ?? "unknown"}`));
+            return;
+        }
+        pending.resolve(msg.result);
+    }
+    writeFramedMessage(runtime, message) {
+        const body = JSON.stringify(message);
+        const framed = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+        runtime.process.stdin.write(framed);
+    }
+    sendNotification(serverId, method, params) {
+        const runtime = this.getRuntime(serverId);
+        if (!runtime)
+            return;
+        this.writeFramedMessage(runtime, {
+            jsonrpc: "2.0",
+            method,
+            params: params ?? {},
+        });
+    }
+    async sendRequest(serverId, method, params, timeoutMs = 20_000) {
+        const runtime = this.getRuntime(serverId);
+        if (!runtime) {
+            throw new Error(`Server ${serverId} is not running`);
+        }
+        const id = runtime.nextRequestId++;
+        const payload = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            params: params ?? {},
+        };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                runtime.pendingRequests.delete(id);
+                reject(new Error(`MCP request timed out: ${serverId} ${method} (${timeoutMs}ms)`));
+            }, timeoutMs);
+            runtime.pendingRequests.set(id, {
+                resolve: (value) => resolve(value),
+                reject,
+                timer,
+            });
+            this.writeFramedMessage(runtime, payload);
+        });
+    }
+    async initializeServer(serverId) {
+        // Primary protocol version + fallback for older servers
+        const initPayload = {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "nano-pencil", version: "1.7.0" },
+        };
+        const fallbackPayload = {
+            protocolVersion: "2024-10-07",
+            capabilities: {},
+            clientInfo: { name: "nano-pencil", version: "1.7.0" },
+        };
+        try {
+            await this.sendRequest(serverId, "initialize", initPayload, 20_000);
+        }
+        catch {
+            await this.sendRequest(serverId, "initialize", fallbackPayload, 20_000);
+        }
+        this.sendNotification(serverId, "notifications/initialized");
+    }
+    normalizeToolRecord(serverId, tool) {
+        if (!tool || typeof tool !== "object")
+            return null;
+        const obj = tool;
+        const name = obj.name;
+        const description = obj.description;
+        if (typeof name !== "string" || typeof description !== "string") {
+            return null;
+        }
+        const inputSchema = obj.inputSchema && typeof obj.inputSchema === "object"
+            ? obj.inputSchema
+            : { type: "object", properties: {}, additionalProperties: true };
+        return {
+            name: `${serverId}/${name}`,
+            displayName: typeof obj.title === "string"
+                ? obj.title
+                : typeof obj.displayName === "string"
+                    ? obj.displayName
+                    : undefined,
+            description,
+            inputSchema,
+            serverId,
+        };
+    }
+    async loadToolsForServer(serverId) {
+        const tools = [];
+        let cursor;
+        while (true) {
+            const result = (await this.sendRequest(serverId, "tools/list", cursor ? { cursor } : {}, 20_000));
+            const pageTools = Array.isArray(result.tools) ? result.tools : [];
+            for (const t of pageTools) {
+                const normalized = this.normalizeToolRecord(serverId, t);
+                if (normalized)
+                    tools.push(normalized);
+            }
+            const nextCursor = typeof result.nextCursor === "string"
+                ? result.nextCursor
+                : typeof result.cursor === "string"
+                    ? result.cursor
+                    : undefined;
+            if (!nextCursor || nextCursor === cursor)
+                break;
+            cursor = nextCursor;
+        }
+        this.serverTools.set(serverId, tools);
+        return tools;
+    }
     /**
      * Start an MCP server (for stdio transport)
      */
@@ -80,7 +276,7 @@ export class MCPClient {
             return true;
         }
         // Check if already running
-        if (this.serverProcesses.has(serverId)) {
+        if (this.serverRuntimes.has(serverId)) {
             return true;
         }
         try {
@@ -88,13 +284,21 @@ export class MCPClient {
                 env: { ...process.env, ...server.env },
                 stdio: ["pipe", "pipe", "pipe"],
             });
-            this.serverProcesses.set(serverId, serverProcess);
-            // TODO: Initialize MCP handshake, list tools
-            // For now, we'll mark it as started
+            const runtime = {
+                process: serverProcess,
+                buffer: Buffer.alloc(0),
+                nextRequestId: 1,
+                pendingRequests: new Map(),
+            };
+            this.serverRuntimes.set(serverId, runtime);
+            this.attachStdoutParser(serverId, runtime);
+            await this.initializeServer(serverId);
+            await this.loadToolsForServer(serverId);
             return true;
         }
         catch (error) {
             console.error(`Failed to start MCP server ${serverId}:`, error);
+            this.stopServer(serverId);
             return false;
         }
     }
@@ -102,17 +306,22 @@ export class MCPClient {
      * Stop an MCP server
      */
     stopServer(serverId) {
-        const process = this.serverProcesses.get(serverId);
-        if (process) {
-            process.kill();
-            this.serverProcesses.delete(serverId);
+        const runtime = this.serverRuntimes.get(serverId);
+        if (runtime) {
+            for (const pending of runtime.pendingRequests.values()) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error(`MCP server ${serverId} stopped`));
+            }
+            runtime.pendingRequests.clear();
+            runtime.process.kill();
+            this.serverRuntimes.delete(serverId);
         }
     }
     /**
      * Stop all running servers
      */
     stopAllServers() {
-        for (const serverId of this.serverProcesses.keys()) {
+        for (const serverId of this.serverRuntimes.keys()) {
             this.stopServer(serverId);
         }
     }
@@ -122,12 +331,28 @@ export class MCPClient {
     async listTools(serverId) {
         const tools = [];
         if (serverId) {
+            if (!this.serverTools.has(serverId)) {
+                try {
+                    await this.loadToolsForServer(serverId);
+                }
+                catch {
+                    // keep cache miss as empty list
+                }
+            }
             const serverTools = this.serverTools.get(serverId) || [];
             tools.push(...serverTools);
         }
         else {
-            for (const [_id, serverTools] of this.serverTools) {
-                tools.push(...serverTools);
+            for (const [id] of this.servers.entries()) {
+                if (!this.serverTools.has(id)) {
+                    try {
+                        await this.loadToolsForServer(id);
+                    }
+                    catch {
+                        // skip unavailable servers
+                    }
+                }
+                tools.push(...(this.serverTools.get(id) || []));
             }
         }
         return tools;
@@ -146,7 +371,7 @@ export class MCPClient {
                 error: `Server ${serverId} not found`,
             };
         }
-        // For SSE transport, make HTTP request
+        // For SSE transport, make HTTP request (not implemented in current defaults)
         if (server.transport === "sse") {
             return this.callSSETool(server, toolNameOnly, args);
         }
@@ -157,34 +382,39 @@ export class MCPClient {
      * Call tool via stdio (JSON-RPC)
      */
     async callStdioTool(server, toolName, args) {
-        const process = this.serverProcesses.get(server.id);
-        if (!process) {
+        if (!this.serverRuntimes.has(server.id)) {
             return {
                 content: [{ type: "text", text: `Server ${server.id} is not running` }],
                 error: `Server ${server.id} is not running`,
             };
         }
         try {
-            // Send JSON-RPC request
-            const request = {
-                jsonrpc: "2.0",
-                id: Date.now(),
-                method: "tools/call",
-                params: {
-                    name: toolName,
-                    arguments: args,
-                },
-            };
-            process.stdin.write(JSON.stringify(request) + "\n");
-            // Read response (simplified - in production, use proper message handling)
-            // For now, return a placeholder
+            const result = (await this.sendRequest(server.id, "tools/call", { name: toolName, arguments: args }, 60_000));
+            const isError = result.isError === true;
+            const content = Array.isArray(result.content)
+                ? result.content.map((item) => {
+                    const type = item.type === "image" || item.type === "resource"
+                        ? item.type
+                        : "text";
+                    return {
+                        type: type,
+                        text: typeof item.text === "string"
+                            ? item.text
+                            : typeof item.message === "string"
+                                ? item.message
+                                : undefined,
+                        data: item,
+                    };
+                })
+                : [{ type: "text", text: JSON.stringify(result) }];
             return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Tool ${toolName} called (TODO: implement response handling)`,
-                    },
-                ],
+                content,
+                error: isError
+                    ? content
+                        .map((c) => c.text)
+                        .filter((t) => !!t)
+                        .join("\n") || `MCP tool ${toolName} failed`
+                    : undefined,
             };
         }
         catch (error) {
@@ -200,7 +430,12 @@ export class MCPClient {
     async callSSETool(server, toolName, args) {
         // TODO: Implement SSE tool calls
         return {
-            content: [{ type: "text", text: `SSE tool calls not yet implemented` }],
+            content: [
+                {
+                    type: "text",
+                    text: `SSE transport is not implemented yet for ${server.id}/${toolName}`,
+                },
+            ],
             error: "SSE transport not yet supported",
         };
     }

package/dist/core/mcp-manager.js

@@ -4,6 +4,7 @@
  * Manages MCP client lifecycle and tool integration.
  */
 import { MCPClient } from "./mcp/mcp-client.js";
+import { loadMCPTools } from "./mcp/mcp-adapter.js";
 import { listEnabledMCPServers } from "./mcp/mcp-config.js";
 export class MCPManager {
     client;
@@ -25,8 +26,7 @@ export class MCPManager {
             }
         }
         // Load tools from all servers
-        // TODO: MCP tool integration disabled due to type compatibility issues
-        // this.tools = await loadMCPTools(this.client);
+        this.tools = await loadMCPTools(this.client);
     }
     /**
      * Get all MCP tools as NanoPencil ToolDefinitions

package/dist/core/sdk.js

@@ -234,15 +234,14 @@ export async function createAgentSession(options = {}) {
     }
     // Initialize MCP if enabled (before creating AgentSession)
     let mcpManager;
-    // TODO: MCP tool integration disabled due to type compatibility issues
-    // Will be re-enabled after refactoring tool adapter
-    // const mcpTools: ToolDefinition[] = [];
+    const mcpTools = [];
     if (options.enableMCP) {
         try {
             mcpManager = new MCPManager();
             await mcpManager.initialize();
-            // mcpTools.push(...mcpManager.getTools());
+            mcpTools.push(...mcpManager.getTools());
             time("mcp.initialize");
+            process.once("exit", () => mcpManager?.dispose());
         }
         catch (error) {
             console.warn(`Failed to initialize MCP: ${error}`);
@@ -273,7 +272,7 @@ export async function createAgentSession(options = {}) {
         cwd,
         scopedModels: options.scopedModels,
         resourceLoader,
-        customTools: options.customTools,
+        customTools: [...mcpTools, ...(options.customTools ?? [])],
         modelRegistry,
         initialActiveToolNames,
         extensionRunnerRef,

package/dist/extensions/nanomem/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@pencil-agent/nanomem",
+  "version": "1.0.0",
+  "private": true
+}

package/dist/extensions/nanosoul/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@pencil-agent/nanosoul",
+  "version": "1.0.0",
+  "private": true
+}

package/dist/main.js

@@ -617,6 +617,8 @@ export async function main(args) {
         sessionManager = SessionManager.open(selectedPath);
     }
     const { options: sessionOptions, cliThinkingFromModel } = buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry, settingsManager);
+    // NanoPencil 默认启用 MCP；离线模式下关闭以避免启动阻塞。
+    sessionOptions.enableMCP = APP_NAME === "nanopencil" && !offlineMode;
     sessionOptions.authStorage = authStorage;
     sessionOptions.modelRegistry = modelRegistry;
     sessionOptions.resourceLoader = resourceLoader;

package/dist/modes/interactive/interactive-mode.d.ts

@@ -61,6 +61,7 @@ export declare class InteractiveMode {
     private retryLoader;
     private retryEscapeHandler?;
     private compactionQueuedMessages;
+    private optimisticUserMessages;
     private shutdownRequested;
     private extensionSelector;
     private extensionInput;

package/dist/modes/interactive/interactive-mode.js

@@ -112,6 +112,8 @@ export class InteractiveMode {
     retryEscapeHandler;
     // Messages queued while compaction is running
     compactionQueuedMessages = [];
+    // User messages rendered optimistically before Agent emits message_start
+    optimisticUserMessages = [];
     // Shutdown state
     shutdownRequested = false;
     // Extension UI state
@@ -1710,10 +1712,24 @@ export class InteractiveMode {
             }
             this.editor.addToHistory?.(text);
             this.editor.setText("");
+            if (!text.startsWith("/")) {
+                this.optimisticUserMessages.push(text);
+                this.addMessageToChat({
+                    role: "user",
+                    content: [{ type: "text", text }],
+                    timestamp: Date.now(),
+                });
+                this.ui.requestRender();
+            }
             try {
                 await this.session.prompt(text);
             }
             catch (error) {
+                if (!text.startsWith("/") &&
+                    this.optimisticUserMessages.length > 0 &&
+                    this.optimisticUserMessages[0] === text) {
+                    this.optimisticUserMessages.shift();
+                }
                 const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
                 this.showError(errorMessage);
             }
@@ -1764,6 +1780,15 @@ export class InteractiveMode {
                     this.ui.requestRender();
                 }
                 else if (event.message.role === "user") {
+                    const userText = this.getUserMessageText(event.message);
+                    if (userText &&
+                        this.optimisticUserMessages.length > 0 &&
+                        this.optimisticUserMessages[0] === userText) {
+                        this.optimisticUserMessages.shift();
+                        this.updatePendingMessagesDisplay();
+                        this.ui.requestRender();
+                        break;
+                    }
                     this.addMessageToChat(event.message);
                     this.updatePendingMessagesDisplay();
                     this.ui.requestRender();