@miphamai/cli 0.6.2 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/core/engine.ts

@@ -140,6 +140,7 @@ export class QueryEngine {
     const toolDefs = this.getToolDefinitions()
 
     let assistantContent = ''
+    let reasoningContent = ''
     const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
 
     // Stream model response
@@ -162,6 +163,10 @@ export class QueryEngine {
           assistantContent += chunk.content
         }
 
+        if (chunk.reasoning_content) {
+          reasoningContent += chunk.reasoning_content
+        }
+
         if (chunk.type === 'tool_use' && chunk.toolUse) {
           toolUses.push({
             id: chunk.toolUse.id,
@@ -172,16 +177,26 @@ export class QueryEngine {
 
         if (chunk.type === 'stop') {
           // Add assistant response to context
-          if (assistantContent) {
-            this.context.addMessage({ role: 'assistant', content: assistantContent })
+          if (assistantContent || reasoningContent) {
+            const msg: import('../shared/types').Message = {
+              role: 'assistant',
+              content: assistantContent || '',
+            }
+            if (reasoningContent) msg.reasoning_content = reasoningContent
+            this.context.addMessage(msg)
           }
         }
       }
     } catch (err) {
       if (isAbortError(err)) {
         // User interrupted — keep partial content, stop gracefully
-        if (assistantContent) {
-          this.context.addMessage({ role: 'assistant', content: assistantContent })
+        if (assistantContent || reasoningContent) {
+          const msg: import('../shared/types').Message = {
+            role: 'assistant',
+            content: assistantContent || '',
+          }
+          if (reasoningContent) msg.reasoning_content = reasoningContent
+          this.context.addMessage(msg)
         }
         yield { type: 'stop' }
         return
@@ -259,6 +274,7 @@ export class QueryEngine {
       const messages = this.context.getMessages()
 
       let assistantContent = ''
+      let reasoningContent = ''
       const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
 
       try {
@@ -274,6 +290,10 @@ export class QueryEngine {
           if (chunk.type === 'error') return
           if (chunk.type === 'text' && chunk.content) assistantContent += chunk.content
 
+          if (chunk.reasoning_content) {
+            reasoningContent += chunk.reasoning_content
+          }
+
           if (chunk.type === 'tool_use' && chunk.toolUse) {
             toolUses.push({
               id: chunk.toolUse.id,
@@ -284,8 +304,13 @@ export class QueryEngine {
         }
       } catch (err) {
         if (isAbortError(err)) {
-          if (assistantContent) {
-            this.context.addMessage({ role: 'assistant', content: assistantContent })
+          if (assistantContent || reasoningContent) {
+            const msg: import('../shared/types').Message = {
+              role: 'assistant',
+              content: assistantContent || '',
+            }
+            if (reasoningContent) msg.reasoning_content = reasoningContent
+            this.context.addMessage(msg)
           }
           yield { type: 'stop' }
           return
@@ -294,8 +319,13 @@ export class QueryEngine {
         return
       }
 
-      if (assistantContent) {
-        this.context.addMessage({ role: 'assistant', content: assistantContent })
+      if (assistantContent || reasoningContent) {
+        const msg: import('../shared/types').Message = {
+          role: 'assistant',
+          content: assistantContent || '',
+        }
+        if (reasoningContent) msg.reasoning_content = reasoningContent
+        this.context.addMessage(msg)
       }
 
       // No more tool calls — fire Stop hook and potentially continue
@@ -401,6 +431,27 @@ export class QueryEngine {
     return this.tools
   }
 
+  /** Register a tool dynamically (used by MCP auto-registration). */
+  registerTool(tool: ToolDefinition): void {
+    if (this.tools.has(tool.name)) {
+      process.stderr.write(`[mcp] Tool collision: "${tool.name}" already registered. Skipping.\n`)
+      return
+    }
+    this.tools.set(tool.name, tool)
+  }
+
+  /** Remove a dynamically registered tool by name. */
+  unregisterTool(name: string): void {
+    this.tools.delete(name)
+  }
+
+  /** Register multiple tools at once. */
+  registerTools(tools: ToolDefinition[]): void {
+    for (const tool of tools) {
+      this.tools.set(tool.name, tool)
+    }
+  }
+
   switchProvider(providerId: string, modelId?: string): void {
     this.registry.switchProvider(providerId, modelId)
   }

package/src/index.tsx

@@ -11,6 +11,7 @@ import { SkillsLoader } from './skills/loader'
 import { PluginManager } from './plugin/plugin-manager'
 import { createToolRegistry } from './tools'
 import { McpClient } from './mcp/client'
+import { registerMcpServerTools } from './mcp/registry'
 import { HookEngine } from './core/hooks'
 import { ArtifactServer } from './artifacts/server'
 import { ARTIFACTS_DIR, ARTIFACT_PORT, MIPHAM_DIR } from './shared/constants'
@@ -50,17 +51,6 @@ export async function runApp(options: RunOptions): Promise<void> {
   // Load configuration
   const config = loadConfig()
 
-  // Connect MCP servers (fire-and-forget — do not block startup)
-  const mcpServers = config.skills?.mcpServers ?? []
-  if (mcpServers.length > 0) {
-    const mcp = McpClient.getInstance()
-    for (const server of mcpServers) {
-      mcp.connect(server).catch((err) => {
-        process.stderr.write(`[mcp] Failed to connect "${server.name}": ${String(err)}\n`)
-      })
-    }
-  }
-
   // Bootstrap providers
   const defaultProvider = options.provider || config.defaultProvider
   const defaultModel = options.model || config.defaultModel
@@ -97,9 +87,34 @@ export async function runApp(options: RunOptions): Promise<void> {
     context.setSystemPrompt(instructions.buildSystemPrompt())
   }
 
-  // Create tool registry with all 16 tools
+  // Create tool registry with all built-in tools
   const tools = createToolRegistry()
 
+  // Connect MCP servers and register their tools into the tool registry.
+  // Uses Promise.allSettled for parallel connection — failures are non-fatal.
+  const mcpServers = config.skills?.mcpServers ?? []
+  if (mcpServers.length > 0) {
+    const mcp = McpClient.getInstance()
+    const results = await Promise.allSettled(
+      mcpServers.map(async (server) => {
+        await mcp.connect(server)
+        const count = registerMcpServerTools(server.name, tools)
+        if (count > 0) {
+          process.stderr.write(`[mcp] "${server.name}": registered ${count} tools\n`)
+        }
+      }),
+    )
+    // Log failures (non-fatal — app starts without that server's tools)
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i]!
+      if (result.status === 'rejected') {
+        process.stderr.write(
+          `[mcp] Failed to connect "${mcpServers[i]!.name}": ${String(result.reason)}\n`,
+        )
+      }
+    }
+  }
+
   // Initialize hook engine — register skill-defined hooks
   const hookEngine = new HookEngine()
   for (const skill of skillsLoader.list()) {

package/src/mcp/registry.ts

@@ -0,0 +1,142 @@
+/**
+ * MCP Tool Registry — converts MCP server tools into main ToolDefinitions
+ * and registers them into the central tool registry.
+ *
+ * Naming convention: mcp__<sanitizedServerName>__<sanitizedToolName>
+ * Example: server "chrome-devtools-mcp" tool "click" → "mcp__chrome_devtools_mcp__click"
+ */
+
+import type { ToolDefinition as McpToolDefinition, ToolCallResult } from './types'
+import type { ToolDefinition, ToolResult, ToolContext } from '../shared/types'
+import { McpClient } from './client'
+
+const MCP_TOOL_PREFIX = 'mcp__'
+const MAX_NAME_LENGTH = 128
+
+/**
+ * Sanitize a name for use in a tool identifier.
+ * Lowercases and replaces non-alphanumeric characters (except hyphens) with underscores.
+ */
+function sanitizeName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '')
+}
+
+/**
+ * Build a namespaced MCP tool name.
+ * Format: mcp__<sanitizedServerName>__<sanitizedToolName>
+ */
+function buildToolName(serverName: string, toolName: string): string {
+  const base = `${MCP_TOOL_PREFIX}${sanitizeName(serverName)}__${sanitizeName(toolName)}`
+  if (base.length <= MAX_NAME_LENGTH) return base
+  const prefix = `${MCP_TOOL_PREFIX}${sanitizeName(serverName)}__`
+  const maxToolLen = MAX_NAME_LENGTH - prefix.length
+  return prefix + sanitizeName(toolName).slice(0, maxToolLen)
+}
+
+/**
+ * Convert an MCP server ToolDefinition into the main ToolDefinition format
+ * that can be registered in the central tool registry.
+ */
+export function convertMcpTool(serverName: string, mcpTool: McpToolDefinition): ToolDefinition {
+  const toolName = buildToolName(serverName, mcpTool.name)
+
+  // Build parameters schema — pass through MCP inputSchema as-is
+  const parameters: Record<string, unknown> = {
+    type: 'object',
+    properties: (mcpTool.inputSchema.properties as Record<string, unknown>) ?? {},
+  }
+  if (mcpTool.inputSchema.required) {
+    parameters.required = mcpTool.inputSchema.required
+  }
+
+  return {
+    name: toolName,
+    description: `[MCP:${serverName}] ${mcpTool.description || mcpTool.name}`,
+    category: 'system',
+    permission: 'ask',
+    parameters,
+    async execute(params: Record<string, unknown>, _ctx: ToolContext): Promise<ToolResult> {
+      const client = McpClient.getInstance()
+
+      const conn = client.getConnection(serverName)
+      if (!conn || conn.status !== 'connected') {
+        return {
+          success: false,
+          content: '',
+          error: `MCP server "${serverName}" is not connected (status: ${conn?.status || 'unknown'}). The server may have crashed or been disconnected.`,
+        }
+      }
+
+      const result: ToolCallResult = await client.callTool(serverName, mcpTool.name, params)
+
+      const text = result.content
+        .map((c) => {
+          if (c.type === 'text' && c.text) return c.text
+          if (c.type === 'image') return `[Image: ${c.mimeType || 'unknown'}]`
+          return JSON.stringify(c)
+        })
+        .join('\n')
+
+      return {
+        success: !result.isError,
+        content: text || '(empty result)',
+        error: result.isError ? text : undefined,
+      }
+    },
+  }
+}
+
+/**
+ * Register all tools from a connected MCP server into the tool registry.
+ * Returns the number of tools registered.
+ */
+export function registerMcpServerTools(
+  serverName: string,
+  toolsMap: Map<string, ToolDefinition>,
+): number {
+  const client = McpClient.getInstance()
+  const mcpTools = client.getTools(serverName)
+  let registered = 0
+
+  for (const mcpTool of mcpTools) {
+    try {
+      const tool = convertMcpTool(serverName, mcpTool)
+
+      if (toolsMap.has(tool.name)) {
+        process.stderr.write(
+          `[mcp] Tool collision: "${tool.name}" (from server "${serverName}") conflicts with existing tool. Skipping.\n`,
+        )
+        continue
+      }
+
+      toolsMap.set(tool.name, tool)
+      registered++
+    } catch (err) {
+      process.stderr.write(
+        `[mcp] Failed to register tool "${mcpTool.name}" from server "${serverName}": ${String(err)}\n`,
+      )
+    }
+  }
+
+  return registered
+}
+
+/**
+ * Unregister all tools previously registered from a specific MCP server.
+ * Tools are identified by the mcp__<serverName>__ prefix.
+ */
+export function unregisterMcpServerTools(
+  serverName: string,
+  toolsMap: Map<string, ToolDefinition>,
+): void {
+  const prefix = `${MCP_TOOL_PREFIX}${sanitizeName(serverName)}__`
+  for (const name of toolsMap.keys()) {
+    if (name.startsWith(prefix)) {
+      toolsMap.delete(name)
+    }
+  }
+}

package/src/providers/openai-compat.ts

@@ -44,8 +44,9 @@ export class OpenAICompatProvider implements ProviderInstance {
     const decoder = new TextDecoder()
     let buffer = ''
 
-    // Track incremental tool calls across streaming deltas
+    // Track incremental tool calls and reasoning content across streaming deltas
     const pendingToolCalls = new Map<number, { id: string; name: string; arguments: string }>()
+    let reasoningContent = ''
 
     while (true) {
       const { done, value } = await reader.read()
@@ -72,7 +73,7 @@ export class OpenAICompatProvider implements ProviderInstance {
               },
             }
           }
-          yield { type: 'stop' }
+          yield { type: 'stop', reasoning_content: reasoningContent }
           return
         }
 
@@ -104,6 +105,10 @@ export class OpenAICompatProvider implements ProviderInstance {
             yield { type: 'text', content: delta.content }
           }
 
+          if (delta?.reasoning_content) {
+            reasoningContent += delta.reasoning_content
+          }
+
           if (choice.finish_reason === 'tool_calls') {
             // Emit fully accumulated tool calls
             for (const [, tc] of pendingToolCalls) {
@@ -121,7 +126,7 @@ export class OpenAICompatProvider implements ProviderInstance {
           }
 
           if (choice.finish_reason === 'stop') {
-            yield { type: 'stop' }
+            yield { type: 'stop', reasoning_content: reasoningContent }
           }
         } catch {
           // skip unparseable chunks
@@ -129,7 +134,7 @@ export class OpenAICompatProvider implements ProviderInstance {
       }
     }
 
-    yield { type: 'stop' }
+    yield { type: 'stop', reasoning_content: reasoningContent }
   }
 
   async listModels(): Promise<ModelInfo[]> {
@@ -174,7 +179,7 @@ export class OpenAICompatProvider implements ProviderInstance {
           next.content.some((b) => b.type === 'tool_use')
         ) {
           const toolUses = next.content.filter((b) => b.type === 'tool_use')
-          result.push({
+          const combinedMsg: Record<string, unknown> = {
             role: 'assistant',
             content: msg.content,
             tool_calls: toolUses.map((tu) => ({
@@ -185,12 +190,20 @@ export class OpenAICompatProvider implements ProviderInstance {
                 arguments: JSON.stringify(tu.input),
               },
             })),
-          })
+          }
+          if (msg.reasoning_content) {
+            combinedMsg.reasoning_content = msg.reasoning_content
+          }
+          result.push(combinedMsg)
           i++ // skip the next message (consumed)
           continue
         }
 
-        result.push({ role: msg.role, content: msg.content })
+        const standaloneMsg: Record<string, unknown> = { role: msg.role, content: msg.content }
+        if (msg.role === 'assistant' && msg.reasoning_content) {
+          standaloneMsg.reasoning_content = msg.reasoning_content
+        }
+        result.push(standaloneMsg)
         continue
       }
 
@@ -207,7 +220,7 @@ export class OpenAICompatProvider implements ProviderInstance {
             .map((b) => (b.type === 'text' ? b.text : ''))
             .join('') || null
 
-        result.push({
+        const toolUseMsg: Record<string, unknown> = {
           role: 'assistant',
           content: textContent,
           tool_calls: toolUses.map((tu) => ({
@@ -218,7 +231,11 @@ export class OpenAICompatProvider implements ProviderInstance {
               arguments: JSON.stringify(tu.input),
             },
           })),
-        })
+        }
+        if (msg.reasoning_content) {
+          toolUseMsg.reasoning_content = msg.reasoning_content
+        }
+        result.push(toolUseMsg)
         continue
       }
 

package/src/shared/types.ts

@@ -46,6 +46,8 @@ export type ContentBlock = TextContent | ImageContent | ToolUseContent | ToolRes
 export interface Message {
   role: 'system' | 'user' | 'assistant'
   content: string | ContentBlock[]
+  /** DeepSeek reasoning tokens — must be passed back to the API in multi-turn conversations. */
+  reasoning_content?: string
 }
 
 // ── Tool Types ──
@@ -105,6 +107,8 @@ export interface StreamChunk {
   toolUse?: ToolUseContent
   tool_use_id?: string
   error?: string
+  /** DeepSeek reasoning tokens accumulated during this stream. */
+  reasoning_content?: string
 }
 
 // ── Config Types ──