@miphamai/cli 0.6.6 → 0.6.8

package/package.json

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

package/src/agent/sub-agent.ts

@@ -75,24 +75,97 @@ export class SubAgent {
     const resolvedModel = modelToUse === 'inherit' ? model : modelToUse
 
     const chunks: string[] = []
+    const MAX_TOOL_TURNS = options.maxTurns || 5
+
+    let currentMessages = messages
+    let currentSystemPrompt = systemPrompt
 
     try {
-      for await (const chunk of provider.chat({
-        model: resolvedModel,
-        messages,
-        systemPrompt,
-        tools: toolDefs,
-        maxTokens: 4096,
-      })) {
-        if (chunk.type === 'text' && chunk.content) {
-          chunks.push(chunk.content)
-        }
-        if (chunk.type === 'error') {
-          throw new Error(`Sub-agent execution failed: ${chunk.error}`)
+      for (let turn = 0; turn < MAX_TOOL_TURNS; turn++) {
+        const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
+        let turnText = ''
+
+        for await (const chunk of provider.chat({
+          model: resolvedModel,
+          messages: currentMessages,
+          systemPrompt: currentSystemPrompt,
+          tools: toolDefs,
+          maxTokens: 4096,
+        })) {
+          if (chunk.type === 'text' && chunk.content) {
+            turnText += chunk.content
+          }
+          if (chunk.type === 'tool_use' && chunk.toolUse) {
+            toolUses.push({
+              id: chunk.toolUse.id,
+              name: chunk.toolUse.name,
+              input: chunk.toolUse.input,
+            })
+          }
+          if (chunk.type === 'error') {
+            throw new Error(`Sub-agent execution failed: ${chunk.error}`)
+          }
+          if (chunk.type === 'stop') {
+            break
+          }
         }
-        if (chunk.type === 'stop') {
-          break
+
+        chunks.push(turnText)
+
+        // No tools used — we're done
+        if (toolUses.length === 0) break
+
+        // Execute tools and build follow-up messages
+        currentMessages = [
+          ...currentMessages,
+          {
+            role: 'assistant' as const,
+            content: turnText || 'Executing tools...',
+          },
+        ]
+
+        for (const tu of toolUses) {
+          const tool = this.toolRegistry.get(tu.name)
+          if (!tool) {
+            currentMessages.push({
+              role: 'user' as const,
+              content: `Error: Unknown tool "${tu.name}"`,
+            })
+            continue
+          }
+
+          try {
+            const result = await tool.execute(tu.input, {
+              cwd: process.cwd(),
+              sessionId: 'sub-agent',
+              provider: '',
+              model: resolvedModel,
+            })
+
+            currentMessages.push({
+              role: 'assistant' as const,
+              content: [{ type: 'tool_use' as const, id: tu.id, name: tu.name, input: tu.input }],
+            })
+            currentMessages.push({
+              role: 'user' as const,
+              content: [
+                {
+                  type: 'tool_result' as const,
+                  tool_use_id: tu.id,
+                  content: result.success ? result.content : result.error || result.content,
+                },
+              ],
+            })
+          } catch (err) {
+            currentMessages.push({
+              role: 'user' as const,
+              content: `Tool "${tu.name}" execution error: ${String(err)}`,
+            })
+          }
         }
+
+        // Don't send system prompt on subsequent turns
+        currentSystemPrompt = ''
       }
     } catch (err) {
       if (err instanceof Error && err.message.startsWith('Sub-agent')) {

package/src/agent/types.ts

@@ -36,4 +36,6 @@ export interface SubAgentOptions {
   maxContextMessages?: number
   allowedTools?: string[]
   modelOverride?: string
+  /** Maximum tool-calling turns (default: 5) to prevent infinite loops. */
+  maxTurns?: number
 }

package/src/plugin/plugin-loader.ts

@@ -6,7 +6,8 @@ import type { SkillsLoader } from '../skills/loader'
 import type { HookEngine } from '../core/hooks'
 import type { McpClient } from '../mcp/client'
 import { registerMcpServerTools } from '../mcp/registry'
-import type { McpServerConfig, ToolDefinition, HookDefinition } from '../shared/types'
+import { executeHook } from '../core/hooks-executor'
+import type { McpServerConfig, ToolDefinition, HookConfig, HookEvent } from '../shared/types'
 
 /**
  * Activate all enabled plugins — load their agents, skills, MCP servers, and hooks.
@@ -86,14 +87,24 @@ export function loadPlugins(
     }
 
     // ── Hooks from plugin.json ──
+    // Plugin hooks are HookConfig objects (type + command/url), not HookDefinition
+    // (which requires a handler function). Convert them via executeHook wrapper.
     try {
       const manifestPath = join(plugin.path, 'plugin.json')
       if (existsSync(manifestPath)) {
         const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'))
         if (manifest.hooks && Array.isArray(manifest.hooks)) {
-          for (const hook of manifest.hooks as HookDefinition[]) {
-            if (hook.event) {
-              hookEngine.register(hook)
+          for (const hookCfg of manifest.hooks as HookConfig[]) {
+            if (hookCfg.type && hookCfg) {
+              const event = (hookCfg as unknown as Record<string, unknown>).event as
+                | HookEvent
+                | undefined
+              if (event) {
+                hookEngine.register({
+                  event,
+                  handler: async (ctx) => executeHook(hookCfg, ctx),
+                })
+              }
             }
           }
         }

package/src/tools/computer/computer-use.ts

@@ -35,9 +35,15 @@ export const computerUseTool: ToolDefinition = {
     switch (action) {
       case 'screenshot': {
         const result = await takeScreenshot()
-        return result.success
-          ? { success: true, content: `Screenshot captured: ${result.data!.slice(0, 100)}...` }
-          : { success: false, content: '', error: result.error }
+        if (!result.success) {
+          return { success: false, content: '', error: result.error }
+        }
+        const dataUrl = result.data!
+        const sizeKB = Math.round((dataUrl.length * 0.75) / 1024) // base64 → bytes estimate
+        return {
+          success: true,
+          content: `Screenshot captured (${sizeKB}KB).\n\n${dataUrl}`,
+        }
       }
       case 'launch': {
         const result = launchApp(target)