codeblog-app 2.1.7 → 2.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.1.7",
+  "version": "2.2.1",
   "description": "CLI client for CodeBlog — the forum where AI writes the posts",
   "type": "module",
   "license": "MIT",
@@ -56,11 +56,11 @@
     "typescript": "5.8.2"
   },
   "optionalDependencies": {
-    "codeblog-app-darwin-arm64": "2.1.7",
-    "codeblog-app-darwin-x64": "2.1.7",
-    "codeblog-app-linux-arm64": "2.1.7",
-    "codeblog-app-linux-x64": "2.1.7",
-    "codeblog-app-windows-x64": "2.1.7"
+    "codeblog-app-darwin-arm64": "2.2.1",
+    "codeblog-app-darwin-x64": "2.2.1",
+    "codeblog-app-linux-arm64": "2.2.1",
+    "codeblog-app-linux-x64": "2.2.1",
+    "codeblog-app-windows-x64": "2.2.1"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.44",
@@ -71,7 +71,7 @@
     "@opentui/core": "^0.1.79",
     "@opentui/solid": "^0.1.79",
     "ai": "^6.0.86",
-    "codeblog-mcp": "^2.1.2",
+    "codeblog-mcp": "^2.1.3",
     "drizzle-orm": "1.0.0-beta.12-a5629fb",
     "fuzzysort": "^3.1.0",
     "hono": "4.10.7",

package/src/ai/__tests__/chat.test.ts

@@ -5,12 +5,17 @@ const mockCallToolJSON = mock((name: string, args: Record<string, unknown>) =>
   Promise.resolve({ ok: true, tool: name }),
 )
 
+const mockListTools = mock(() =>
+  Promise.resolve({ tools: [] }),
+)
+
 mock.module("../../mcp/client", () => ({
   McpBridge: {
     callTool: mock((name: string, args: Record<string, unknown>) =>
       Promise.resolve(JSON.stringify({ ok: true, tool: name })),
     ),
     callToolJSON: mockCallToolJSON,
+    listTools: mockListTools,
     disconnect: mock(() => Promise.resolve()),
   },
 }))
@@ -25,10 +30,23 @@ function makeStreamResult() {
   }
 }
 
+function makeToolCallStreamResult() {
+  return {
+    fullStream: (async function* () {
+      yield { type: "tool-call", toolName: "scan_sessions", args: { limit: 5 } }
+      yield { type: "tool-result", toolName: "scan_sessions", result: { sessions: [] } }
+      yield { type: "text-delta", textDelta: "Done scanning." }
+    })(),
+  }
+}
+
+let streamFactory = () => makeStreamResult()
+
 mock.module("ai", () => ({
-  streamText: () => makeStreamResult(),
-  ModelMessage: class {},
+  streamText: () => streamFactory(),
+  stepCountIs: (n: number) => ({ type: "step-count", count: n }),
   tool: (config: any) => config,
+  jsonSchema: (schema: any) => schema,
 }))
 
 mock.module("../provider", () => ({
@@ -43,6 +61,7 @@ const { AIChat } = await import("../chat")
 describe("AIChat", () => {
   beforeEach(() => {
     mockCallToolJSON.mockClear()
+    streamFactory = () => makeStreamResult()
   })
 
   // ---------------------------------------------------------------------------
@@ -99,6 +118,56 @@ describe("AIChat", () => {
     // Should not throw — system messages are filtered
   })
 
+  // ---------------------------------------------------------------------------
+  // stream() with tool calls
+  // ---------------------------------------------------------------------------
+
+  test("stream dispatches onToolCall and onToolResult callbacks", async () => {
+    streamFactory = () => makeToolCallStreamResult()
+
+    const toolCalls: Array<{ name: string; args: unknown }> = []
+    const toolResults: Array<{ name: string; result: unknown }> = []
+    const tokens: string[] = []
+
+    await AIChat.stream(
+      [{ role: "user", content: "scan my sessions" }],
+      {
+        onToken: (t) => tokens.push(t),
+        onToolCall: (name, args) => toolCalls.push({ name, args }),
+        onToolResult: (name, result) => toolResults.push({ name, result }),
+        onFinish: () => {},
+      },
+    )
+
+    expect(toolCalls).toEqual([{ name: "scan_sessions", args: { limit: 5 } }])
+    expect(toolResults).toEqual([{ name: "scan_sessions", result: { sessions: [] } }])
+    expect(tokens).toEqual(["Done scanning."])
+  })
+
+  // ---------------------------------------------------------------------------
+  // stream() error handling
+  // ---------------------------------------------------------------------------
+
+  test("stream calls onError when error event is received", async () => {
+    streamFactory = () => ({
+      fullStream: (async function* () {
+        yield { type: "error", error: new Error("test error") }
+      })(),
+    })
+
+    const errors: Error[] = []
+    await AIChat.stream(
+      [{ role: "user", content: "test" }],
+      {
+        onError: (err) => errors.push(err),
+        onFinish: () => {},
+      },
+    )
+
+    expect(errors).toHaveLength(1)
+    expect(errors[0]!.message).toBe("test error")
+  })
+
   // ---------------------------------------------------------------------------
   // generate()
   // ---------------------------------------------------------------------------

package/src/ai/__tests__/provider.test.ts

@@ -143,13 +143,27 @@ describe("AIProvider", () => {
   // available
   // ---------------------------------------------------------------------------
 
-  test("available returns all builtin models with hasKey status", async () => {
+  test("available returns at least builtin models with hasKey status", async () => {
     const models = await AIProvider.available()
-    expect(models).toHaveLength(7)
+    expect(models.length).toBeGreaterThanOrEqual(7)
     for (const entry of models) {
       expect(entry.model).toBeDefined()
       expect(typeof entry.hasKey).toBe("boolean")
     }
+    // The first 7 should always be builtins
+    const builtinCount = models.filter((m) => AIProvider.BUILTIN_MODELS[m.model.id]).length
+    expect(builtinCount).toBe(7)
+  })
+
+  test("available includes openai-compatible remote models when configured", async () => {
+    // With a valid key and base URL from config, remote models should be fetched.
+    // This test verifies that available() attempts to include openai-compatible models.
+    // Use localhost to ensure fast failure (connection refused) instead of DNS timeout.
+    process.env.OPENAI_COMPATIBLE_API_KEY = "sk-test"
+    process.env.OPENAI_COMPATIBLE_BASE_URL = "http://127.0.0.1:1"
+    const models = await AIProvider.available()
+    // Should still return at least builtins even if remote fetch fails
+    expect(models.length).toBeGreaterThanOrEqual(7)
   })
 
   // ---------------------------------------------------------------------------

package/src/ai/__tests__/tools.test.ts

@@ -1,23 +1,55 @@
-import { describe, test, expect } from "bun:test"
-import { getChatTools, TOOL_LABELS, clearChatToolsCache } from "../tools"
+import { describe, test, expect, mock } from "bun:test"
 
-describe("AI Tools (dynamic MCP discovery)", () => {
-  // These tests require a running MCP server subprocess.
-  // getChatTools() connects to codeblog-mcp via stdio and calls listTools().
+// Mock MCP bridge so tests don't need a running MCP server
+const MOCK_MCP_TOOLS = [
+  {
+    name: "scan_sessions",
+    description: "Scan IDE sessions for coding activity",
+    inputSchema: { type: "object", properties: { limit: { type: "number" } } },
+  },
+  {
+    name: "my_dashboard",
+    description: "Show the user dashboard with stats",
+    inputSchema: {},
+  },
+  {
+    name: "browse_posts",
+    description: "Browse posts on the forum with filters",
+    inputSchema: { type: "object", properties: { page: { type: "number" }, tag: { type: "string" } } },
+  },
+]
+
+mock.module("../../mcp/client", () => ({
+  McpBridge: {
+    listTools: mock(() => Promise.resolve({ tools: MOCK_MCP_TOOLS })),
+    callToolJSON: mock((name: string) => Promise.resolve({ ok: true, tool: name })),
+  },
+}))
+
+mock.module("ai", () => ({
+  tool: (config: any) => config,
+  jsonSchema: (schema: any) => schema,
+}))
+
+const { getChatTools, TOOL_LABELS, clearChatToolsCache } = await import("../tools")
 
+describe("AI Tools (dynamic MCP discovery)", () => {
   let chatTools: Record<string, any>
 
   test("getChatTools() discovers tools from MCP server", async () => {
     clearChatToolsCache()
     chatTools = await getChatTools()
     const names = Object.keys(chatTools)
-    expect(names.length).toBeGreaterThanOrEqual(20)
+    expect(names.length).toBe(MOCK_MCP_TOOLS.length)
+    expect(names).toContain("scan_sessions")
+    expect(names).toContain("my_dashboard")
+    expect(names).toContain("browse_posts")
   })
 
-  test("each tool has parameters and execute", () => {
+  test("each tool has inputSchema and execute", () => {
     for (const [name, t] of Object.entries(chatTools)) {
       const tool = t as any
-      expect(tool.parameters).toBeDefined()
+      expect(tool.inputSchema).toBeDefined()
       expect(tool.execute).toBeDefined()
       expect(typeof tool.execute).toBe("function")
     }
@@ -32,6 +64,13 @@ describe("AI Tools (dynamic MCP discovery)", () => {
     }
   })
 
+  test("normalizeToolSchema adds type:object to empty schemas", async () => {
+    // my_dashboard has empty inputSchema {} — should be normalized
+    const dashboard = chatTools["my_dashboard"] as any
+    expect(dashboard.inputSchema.type).toBe("object")
+    expect(dashboard.inputSchema.properties).toEqual({})
+  })
+
   // ---------------------------------------------------------------------------
   // TOOL_LABELS tests (static fallback map)
   // ---------------------------------------------------------------------------

package/src/ai/chat.ts

@@ -1,4 +1,4 @@
-import { streamText, type ModelMessage } from "ai"
+import { streamText, stepCountIs } from "ai"
 import { AIProvider } from "./provider"
 import { getChatTools } from "./tools"
 import { Log } from "../util/log"
@@ -18,9 +18,17 @@ You help developers with everything on the platform:
 You have 20+ tools. Use them whenever the user's request matches. Chain multiple tools if needed.
 After a tool returns results, summarize them naturally for the user.
 
+CRITICAL: When using tools, ALWAYS use the EXACT data returned by previous tool calls.
+- If scan_sessions returns a path like "/Users/zhaoyifei/...", use that EXACT path
+- NEVER modify, guess, or infer file paths — use them exactly as returned
+- If a tool call fails with "file not found", the path is wrong — check the scan results again
+
 Write casually like a dev talking to another dev. Be specific, opinionated, and genuine.
 Use code examples when relevant. Think Juejin / HN / Linux.do vibes — not a conference paper.`
 
+const IDLE_TIMEOUT_MS = 15_000 // 15s without any stream event → abort
+const DEFAULT_MAX_STEPS = 10 // Allow AI to retry tools up to 10 steps (each tool call + result = 1 step)
+
 export namespace AIChat {
   export interface Message {
     role: "user" | "assistant" | "system"
@@ -35,98 +43,144 @@ export namespace AIChat {
     onToolResult?: (name: string, result: unknown) => void
   }
 
-  export async function stream(messages: Message[], callbacks: StreamCallbacks, modelID?: string, signal?: AbortSignal) {
+  export interface StreamOptions {
+    maxSteps?: number
+  }
+
+  export async function stream(
+    messages: Message[],
+    callbacks: StreamCallbacks,
+    modelID?: string,
+    signal?: AbortSignal,
+    options?: StreamOptions
+  ) {
     const model = await AIProvider.getModel(modelID)
     const tools = await getChatTools()
-    log.info("streaming", { model: modelID || AIProvider.DEFAULT_MODEL, messages: messages.length })
+    const maxSteps = options?.maxSteps ?? DEFAULT_MAX_STEPS
+    log.info("streaming", { model: modelID || AIProvider.DEFAULT_MODEL, messages: messages.length, toolCount: Object.keys(tools).length, maxSteps })
 
-    // Build history: only user/assistant text (tool context is added per-step below)
-    const history: ModelMessage[] = messages
+    const history = messages
       .filter((m) => m.role === "user" || m.role === "assistant")
       .map((m) => ({ role: m.role as "user" | "assistant", content: m.content }))
     let full = ""
 
-    for (let step = 0; step < 5; step++) {
-      if (signal?.aborted) break
-
-      const result = streamText({
-        model,
-        system: SYSTEM_PROMPT,
-        messages: history,
-        tools,
-        maxSteps: 1,
-        abortSignal: signal,
-      } as any)
-
-      const calls: Array<{ id: string; name: string; input: unknown; output: unknown }> = []
-
-      try {
-        log.info("starting fullStream iteration")
-        for await (const part of (result as any).fullStream) {
-          log.info("stream part", { type: part.type })
-          if (signal?.aborted) break
-          switch (part.type) {
-            case "text-delta": {
-              const delta = part.text ?? part.textDelta ?? ""
-              if (delta) { full += delta; callbacks.onToken?.(delta) }
-              break
-            }
-            case "tool-call": {
-              const input = part.input ?? part.args
-              callbacks.onToolCall?.(part.toolName, input)
-              calls.push({ id: part.toolCallId, name: part.toolName, input, output: undefined })
-              break
-            }
-            case "tool-result": {
-              const output = part.output ?? part.result ?? {}
-              const name = part.toolName
-              callbacks.onToolResult?.(name, output)
-              const match = calls.find((c: any) => c.id === part.toolCallId && c.output === undefined)
-              if (match) match.output = output
-              break
-            }
-            case "error": {
-              const msg = part.error instanceof Error ? part.error.message : String(part.error)
-              log.error("stream part error", { error: msg })
-              callbacks.onError?.(part.error instanceof Error ? part.error : new Error(msg))
-              break
-            }
+    // Create an internal AbortController that we can trigger on idle timeout
+    const internalAbort = new AbortController()
+    const onExternalAbort = () => {
+      log.info("external abort signal received")
+      internalAbort.abort()
+    }
+    signal?.addEventListener("abort", onExternalAbort)
+
+    const result = streamText({
+      model,
+      system: SYSTEM_PROMPT,
+      messages: history,
+      tools,
+      stopWhen: stepCountIs(maxSteps),
+      toolChoice: "auto",
+      abortSignal: internalAbort.signal,
+      experimental_toolCallStreaming: false, // Disable streaming tool calls to avoid incomplete arguments bug
+      onStepFinish: (stepResult) => {
+        log.info("onStepFinish", {
+          stepNumber: stepResult.stepNumber,
+          finishReason: stepResult.finishReason,
+          textLength: stepResult.text?.length ?? 0,
+          toolCallsCount: stepResult.toolCalls?.length ?? 0,
+          toolResultsCount: stepResult.toolResults?.length ?? 0,
+        })
+      },
+    })
+
+    let partCount = 0
+    let toolExecuting = false
+    try {
+      // Idle timeout: if no stream events arrive for IDLE_TIMEOUT_MS, abort.
+      // Paused during tool execution (tools can take longer than 15s).
+      let idleTimer: ReturnType<typeof setTimeout> | undefined
+      const resetIdle = () => {
+        if (idleTimer) clearTimeout(idleTimer)
+        if (toolExecuting) return // Don't start timer while tool is running
+        idleTimer = setTimeout(() => {
+          log.info("IDLE TIMEOUT FIRED", { partCount, fullLength: full.length })
+          internalAbort.abort()
+        }, IDLE_TIMEOUT_MS)
+      }
+      resetIdle()
+
+      for await (const part of result.fullStream) {
+        partCount++
+        if (internalAbort.signal.aborted) {
+          log.info("abort detected in loop, breaking", { partCount })
+          break
+        }
+        resetIdle()
+
+        switch (part.type) {
+          case "text-delta": {
+            const delta = (part as any).text ?? (part as any).textDelta ?? ""
+            if (delta) { full += delta; callbacks.onToken?.(delta) }
+            break
+          }
+          case "tool-call": {
+            const toolName = (part as any).toolName
+            const toolArgs = (part as any).args ?? (part as any).input ?? {}
+            log.info("tool-call", { toolName, args: toolArgs, partCount })
+            // Pause idle timer — tool execution happens between tool-call and tool-result
+            toolExecuting = true
+            if (idleTimer) { clearTimeout(idleTimer); idleTimer = undefined }
+            callbacks.onToolCall?.(toolName, toolArgs)
+            break
+          }
+          case "tool-result": {
+            log.info("tool-result", { toolName: (part as any).toolName, partCount })
+            toolExecuting = false
+            callbacks.onToolResult?.((part as any).toolName, (part as any).output ?? (part as any).result ?? {})
+            break
+          }
+          case "tool-error" as any: {
+            const errorMsg = String((part as any).error).slice(0, 500)
+            log.error("tool-error", { toolName: (part as any).toolName, error: errorMsg })
+            toolExecuting = false
+            // Abort the stream on tool error to prevent infinite retry loops
+            log.info("aborting stream due to tool error")
+            internalAbort.abort()
+            break
           }
+          case "error": {
+            const msg = (part as any).error instanceof Error ? (part as any).error.message : String((part as any).error)
+            log.error("stream part error", { error: msg })
+            callbacks.onError?.((part as any).error instanceof Error ? (part as any).error : new Error(msg))
+            break
+          }
+          default:
+            break
         }
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err))
-        log.error("stream error", { error: error.message })
+      }
+
+      if (idleTimer) clearTimeout(idleTimer)
+      log.info("for-await loop exited normally", { partCount, fullLength: full.length })
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err))
+      log.info("catch block entered", { name: error.name, message: error.message.slice(0, 200), partCount })
+      // Don't treat abort as a real error
+      if (error.name !== "AbortError") {
+        log.error("stream error (non-abort)", { error: error.message })
         if (callbacks.onError) callbacks.onError(error)
         else throw error
-        return full
+      } else {
+        log.info("AbortError caught — treating as normal completion")
       }
-
-      if (calls.length === 0) break
-
-      // AI SDK v6 ModelMessage format
-      history.push({
-        role: "assistant",
-        content: calls.map((c) => ({
-          type: "tool-call" as const,
-          toolCallId: c.id,
-          toolName: c.name,
-          input: c.input,
-        })),
-      } as ModelMessage)
-
-      history.push({
-        role: "tool",
-        content: calls.map((c) => ({
-          type: "tool-result" as const,
-          toolCallId: c.id,
-          toolName: c.name,
-          output: { type: "json" as const, value: c.output ?? {} },
-        })),
-      } as ModelMessage)
-
-      log.info("tool step done", { step, tools: calls.map((c) => c.name) })
+      // On abort or error, still call onFinish so UI cleans up
+      log.info("calling onFinish from catch", { fullLength: full.length })
+      callbacks.onFinish?.(full || "(No response)")
+      return full
+    } finally {
+      log.info("finally block", { partCount, fullLength: full.length })
+      signal?.removeEventListener("abort", onExternalAbort)
     }
 
+    log.info("calling onFinish from normal path", { fullLength: full.length })
     callbacks.onFinish?.(full || "(No response)")
     return full
   }

package/src/ai/provider.ts

@@ -115,7 +115,9 @@ export namespace AIProvider {
     }
     const compatKey = await getApiKey("openai-compatible")
     if (compatKey) {
-      result["openai-compatible"] = { name: "OpenAI Compatible", models: [], hasKey: true }
+      const compatBase = await getBaseUrl("openai-compatible")
+      const remoteModels = compatBase ? await fetchRemoteModels(compatBase, compatKey) : []
+      result["openai-compatible"] = { name: "OpenAI Compatible", models: remoteModels, hasKey: true }
     }
     return result
   }
@@ -161,7 +163,20 @@ export namespace AIProvider {
   }
 
   function getLanguageModel(providerID: string, modelID: string, apiKey: string, npm?: string, baseURL?: string): LanguageModel {
-    const pkg = npm || PROVIDER_NPM[providerID] || "@ai-sdk/openai-compatible"
+    // Auto-detect Anthropic models and use @ai-sdk/anthropic instead of openai-compatible
+    // This fixes streaming tool call argument parsing issues with openai-compatible provider
+    let pkg = npm || PROVIDER_NPM[providerID]
+
+    // Force Anthropic SDK for Claude models, even if provider is openai-compatible
+    if (modelID.startsWith("claude-") && pkg === "@ai-sdk/openai-compatible") {
+      pkg = "@ai-sdk/anthropic"
+      log.info("auto-detected Claude model, switching from openai-compatible to @ai-sdk/anthropic", { model: modelID })
+    }
+
+    if (!pkg) {
+      pkg = "@ai-sdk/openai-compatible"
+    }
+
     const cacheKey = `${providerID}:${pkg}:${apiKey.slice(0, 8)}`
 
     log.info("loading model", { provider: providerID, model: modelID, pkg })
@@ -175,6 +190,26 @@ export namespace AIProvider {
         const clean = baseURL.replace(/\/+$/, "")
         opts.baseURL = clean.endsWith("/v1") ? clean : `${clean}/v1`
       }
+      // For openai-compatible providers, normalize request body for broader compatibility
+      if (pkg === "@ai-sdk/openai-compatible") {
+        opts.transformRequestBody = (body: Record<string, any>) => {
+          // Remove parallel_tool_calls — many proxies/providers don't support it
+          delete body.parallel_tool_calls
+
+          // Ensure all tool schemas have type: "object" (required by DeepSeek/Qwen/etc.)
+          if (Array.isArray(body.tools)) {
+            for (const t of body.tools) {
+              const params = t?.function?.parameters
+              if (params && !params.type) {
+                params.type = "object"
+                if (!params.properties) params.properties = {}
+              }
+            }
+          }
+
+          return body
+        }
+      }
       sdk = createFn(opts)
       sdkCache.set(cacheKey, sdk)
     }
@@ -188,6 +223,22 @@ export namespace AIProvider {
     return (sdk as any)(modelID)
   }
 
+  async function fetchRemoteModels(base: string, key: string): Promise<string[]> {
+    try {
+      const clean = base.replace(/\/+$/, "")
+      const url = clean.endsWith("/v1") ? `${clean}/models` : `${clean}/v1/models`
+      const r = await fetch(url, {
+        headers: { Authorization: `Bearer ${key}` },
+        signal: AbortSignal.timeout(8000),
+      })
+      if (!r.ok) return []
+      const data = await r.json() as { data?: Array<{ id: string }> }
+      return data.data?.map((m) => m.id) ?? []
+    } catch {
+      return []
+    }
+  }
+
   function noKeyError(providerID: string): Error {
     const envKeys = PROVIDER_ENV[providerID] || []
     const envHint = envKeys[0] || `${providerID.toUpperCase().replace(/-/g, "_")}_API_KEY`
@@ -225,6 +276,19 @@ export namespace AIProvider {
       const apiKey = await getApiKey(model.providerID)
       result.push({ model, hasKey: !!apiKey })
     }
+    // Include remote models from openai-compatible provider
+    const compatKey = await getApiKey("openai-compatible")
+    const compatBase = await getBaseUrl("openai-compatible")
+    if (compatKey && compatBase) {
+      const remoteModels = await fetchRemoteModels(compatBase, compatKey)
+      for (const id of remoteModels) {
+        if (BUILTIN_MODELS[id]) continue
+        result.push({
+          model: { id, providerID: "openai-compatible", name: id, contextWindow: 0, outputTokens: 0 },
+          hasKey: true,
+        })
+      }
+    }
     return result
   }
 

package/src/ai/tools.ts

@@ -53,6 +53,18 @@ function clean(obj: Record<string, unknown>): Record<string, unknown> {
   return result
 }
 
+// ---------------------------------------------------------------------------
+// Schema normalization: ensure all JSON schemas are valid tool input schemas.
+// Some MCP tools have empty inputSchema ({}) which produces schemas without
+// "type": "object", causing providers like DeepSeek/Qwen to reject them.
+// ---------------------------------------------------------------------------
+function normalizeToolSchema(schema: Record<string, unknown>): Record<string, unknown> {
+  const normalized = { ...schema }
+  if (!normalized.type) normalized.type = "object"
+  if (normalized.type === "object" && !normalized.properties) normalized.properties = {}
+  return normalized
+}
+
 // ---------------------------------------------------------------------------
 // Dynamic tool discovery from MCP server
 // ---------------------------------------------------------------------------
@@ -72,12 +84,23 @@ export async function getChatTools(): Promise<Record<string, any>> {
 
   for (const t of mcpTools) {
     const name = t.name
-    const schema = t.inputSchema as Record<string, unknown>
+    const rawSchema = (t.inputSchema ?? {}) as Record<string, unknown>
 
-    tools[name] = (tool as any)({
+    tools[name] = tool({
       description: t.description || name,
-      parameters: jsonSchema(schema),
-      execute: async (args: any) => mcp(name, clean(args)),
+      inputSchema: jsonSchema(normalizeToolSchema(rawSchema)),
+      execute: async (args: any) => {
+        log.info("execute tool", { name, args })
+        const result = await mcp(name, clean(args))
+        const resultStr = typeof result === "string" ? result : JSON.stringify(result)
+        log.info("execute tool result", { name, resultType: typeof result, resultLength: resultStr.length, resultPreview: resultStr.slice(0, 300) })
+        // Truncate very large tool results to avoid overwhelming the LLM context
+        if (resultStr.length > 8000) {
+          log.info("truncating large tool result", { name, originalLength: resultStr.length })
+          return resultStr.slice(0, 8000) + "\n...(truncated)"
+        }
+        return resultStr
+      },
     })
   }
 

package/src/cli/__tests__/commands.test.ts

@@ -74,7 +74,7 @@ describe("CLI Commands", () => {
     test("handler calls codeblog_status when --status flag", async () => {
       mockCallTool.mockImplementationOnce(() => Promise.resolve("Status: OK"))
       await (ScanCommand.handler as any)({ status: true, limit: 20 })
-      expect(mockCallTool).toHaveBeenCalledWith("codeblog_status")
+      expect(mockCallTool).toHaveBeenCalledWith("codeblog_status", {})
     })
 
     test("handler passes source when provided", async () => {

package/src/tui/app.tsx

@@ -44,6 +44,7 @@ function App() {
   const renderer = useRenderer()
   const [loggedIn, setLoggedIn] = createSignal(false)
   const [username, setUsername] = createSignal("")
+  const [activeAgent, setActiveAgent] = createSignal("")
   const [hasAI, setHasAI] = createSignal(false)
   const [aiProvider, setAiProvider] = createSignal("")
   const [modelName, setModelName] = createSignal("")
@@ -78,6 +79,15 @@ function App() {
       }
     } catch {}
 
+    // Get active agent
+    try {
+      const { Config } = await import("../config")
+      const cfg = await Config.load()
+      if (cfg.activeAgent) {
+        setActiveAgent(cfg.activeAgent)
+      }
+    } catch {}
+
     await refreshAI()
   })
 
@@ -103,6 +113,7 @@ function App() {
           <Home
             loggedIn={loggedIn()}
             username={username()}
+            activeAgent={activeAgent()}
             hasAI={hasAI()}
             aiProvider={aiProvider()}
             modelName={modelName()}
@@ -144,34 +155,9 @@ function App() {
         </Match>
       </Switch>
 
-      {/* Status bar — like OpenCode */}
+      {/* Status bar — only version */}
       <box paddingLeft={2} paddingRight={2} flexShrink={0} flexDirection="row" gap={2}>
-        <text fg={theme.colors.textMuted}>{process.cwd()}</text>
         <box flexGrow={1} />
-        <Show when={hasAI()}>
-          <text fg={theme.colors.text}>
-            <span style={{ fg: theme.colors.success }}>● </span>
-            {modelName()}
-          </text>
-        </Show>
-        <Show when={!hasAI()}>
-          <text fg={theme.colors.text}>
-            <span style={{ fg: theme.colors.error }}>○ </span>
-            no AI <span style={{ fg: theme.colors.textMuted }}>/ai</span>
-          </text>
-        </Show>
-        <Show when={loggedIn()}>
-          <text fg={theme.colors.text}>
-            <span style={{ fg: theme.colors.success }}>● </span>
-            {username() || "logged in"}
-          </text>
-        </Show>
-        <Show when={!loggedIn()}>
-          <text fg={theme.colors.text}>
-            <span style={{ fg: theme.colors.error }}>○ </span>
-            <span style={{ fg: theme.colors.textMuted }}>/login</span>
-          </text>
-        </Show>
         <text fg={theme.colors.textMuted}>v{VERSION}</text>
       </box>
     </box>

package/src/tui/routes/home.tsx

@@ -1,13 +1,40 @@
 import { createSignal, createMemo, createEffect, onCleanup, Show, For } from "solid-js"
 import { useKeyboard, usePaste } from "@opentui/solid"
+import { SyntaxStyle, type ThemeTokenStyle } from "@opentui/core"
 import { useRoute } from "../context/route"
 import { useExit } from "../context/exit"
-import { useTheme } from "../context/theme"
+import { useTheme, type ThemeColors } from "../context/theme"
 import { createCommands, LOGO, TIPS, TIPS_NO_AI } from "../commands"
 import { TOOL_LABELS } from "../../ai/tools"
 import { mask, saveProvider } from "../../ai/configure"
 import { ChatHistory } from "../../storage/chat"
 
+function buildMarkdownSyntaxRules(colors: ThemeColors): ThemeTokenStyle[] {
+  return [
+    { scope: ["default"], style: { foreground: colors.text } },
+    { scope: ["spell", "nospell"], style: { foreground: colors.text } },
+    { scope: ["conceal"], style: { foreground: colors.textMuted } },
+    { scope: ["markup.heading", "markup.heading.1", "markup.heading.2", "markup.heading.3", "markup.heading.4", "markup.heading.5", "markup.heading.6"], style: { foreground: colors.primary, bold: true } },
+    { scope: ["markup.bold", "markup.strong"], style: { foreground: colors.text, bold: true } },
+    { scope: ["markup.italic"], style: { foreground: colors.text, italic: true } },
+    { scope: ["markup.list"], style: { foreground: colors.text } },
+    { scope: ["markup.quote"], style: { foreground: colors.textMuted, italic: true } },
+    { scope: ["markup.raw", "markup.raw.block", "markup.raw.inline"], style: { foreground: colors.accent } },
+    { scope: ["markup.link", "markup.link.url"], style: { foreground: colors.primary, underline: true } },
+    { scope: ["markup.link.label"], style: { foreground: colors.primary, underline: true } },
+    { scope: ["label"], style: { foreground: colors.primary } },
+    { scope: ["comment"], style: { foreground: colors.textMuted, italic: true } },
+    { scope: ["string", "symbol"], style: { foreground: colors.success } },
+    { scope: ["number", "boolean"], style: { foreground: colors.accent } },
+    { scope: ["keyword"], style: { foreground: colors.primary, italic: true } },
+    { scope: ["keyword.function", "function.method", "function", "constructor", "variable.member"], style: { foreground: colors.primary } },
+    { scope: ["variable", "variable.parameter", "property", "parameter"], style: { foreground: colors.text } },
+    { scope: ["type", "module", "class"], style: { foreground: colors.warning } },
+    { scope: ["operator", "keyword.operator", "punctuation.delimiter"], style: { foreground: colors.textMuted } },
+    { scope: ["punctuation", "punctuation.bracket"], style: { foreground: colors.textMuted } },
+  ]
+}
+
 interface ChatMsg {
   role: "user" | "assistant" | "tool"
   content: string
@@ -18,6 +45,7 @@ interface ChatMsg {
 export function Home(props: {
   loggedIn: boolean
   username: string
+  activeAgent: string
   hasAI: boolean
   aiProvider: string
   modelName: string
@@ -40,6 +68,7 @@ export function Home(props: {
   let escCooldown = 0
   let sessionId = ""
   const chatting = createMemo(() => messages().length > 0 || streaming())
+  const syntaxStyle = createMemo(() => SyntaxStyle.fromTheme(buildMarkdownSyntaxRules(theme.colors)))
 
   function ensureSession() {
     if (!sessionId) {
@@ -151,19 +180,29 @@ export function Home(props: {
     setStreaming(true)
     setStreamText("")
     setMessage("")
+    let summaryStreamActive = false
 
     try {
       const { AIChat } = await import("../../ai/chat")
       const { Config } = await import("../../config")
       const { AIProvider } = await import("../../ai/provider")
+      const { Log } = await import("../../util/log")
+      const sendLog = Log.create({ service: "home-send" })
       const cfg = await Config.load()
       const mid = cfg.model || AIProvider.DEFAULT_MODEL
       const allMsgs = [...prev, userMsg].filter((m) => m.role !== "tool").map((m) => ({ role: m.role as "user" | "assistant", content: m.content }))
       let full = ""
+      let hasToolCalls = false
+      let lastToolName = ""
+      let lastToolResult = ""
       abortCtrl = new AbortController()
+      sendLog.info("calling AIChat.stream", { model: mid, msgCount: allMsgs.length })
       await AIChat.stream(allMsgs, {
         onToken: (token) => { full += token; setStreamText(full) },
         onToolCall: (name) => {
+          hasToolCalls = true
+          lastToolName = name
+          sendLog.info("onToolCall", { name })
           // Save any accumulated text as assistant message before tool
           if (full.trim()) {
             setMessages((p) => [...p, { role: "assistant", content: full.trim() }])
@@ -172,7 +211,12 @@ export function Home(props: {
           }
           setMessages((p) => [...p, { role: "tool", content: TOOL_LABELS[name] || name, toolName: name, toolStatus: "running" }])
         },
-        onToolResult: (name) => {
+        onToolResult: (name, result) => {
+          sendLog.info("onToolResult", { name })
+          try {
+            const str = typeof result === "string" ? result : JSON.stringify(result)
+            lastToolResult = str.slice(0, 6000)
+          } catch { lastToolResult = "" }
           setMessages((p) => p.map((m) =>
             m.role === "tool" && m.toolName === name && m.toolStatus === "running"
               ? { ...m, toolStatus: "done" as const }
@@ -180,13 +224,55 @@ export function Home(props: {
           ))
         },
         onFinish: () => {
+          sendLog.info("onFinish", { fullLength: full.length, hasToolCalls, hasToolResult: !!lastToolResult })
           if (full.trim()) {
             setMessages((p) => [...p, { role: "assistant", content: full.trim() }])
+            setStreamText(""); setStreaming(false)
+            saveChat()
+          } else if (hasToolCalls && lastToolResult) {
+            // Tool executed but model didn't summarize — send a follow-up request
+            // to have the model produce a natural-language summary
+            sendLog.info("auto-summarizing tool result", { tool: lastToolName })
+            full = ""
+            setStreamText("")
+            const summaryMsgs = [
+              ...allMsgs,
+              { role: "assistant" as const, content: `I used the ${lastToolName} tool. Here are the results:\n${lastToolResult}` },
+              { role: "user" as const, content: "Please summarize these results in a helpful, natural way." },
+            ]
+            // NOTE: intentionally not awaited — the outer await resolves here,
+            // but streaming state is managed by the inner callbacks.
+            // The finally block must NOT reset streaming in this path.
+            summaryStreamActive = true
+            AIChat.stream(summaryMsgs, {
+              onToken: (token) => { full += token; setStreamText(full) },
+              onFinish: () => {
+                if (full.trim()) {
+                  setMessages((p) => [...p, { role: "assistant", content: full.trim() }])
+                } else {
+                  setMessages((p) => [...p, { role: "assistant", content: "(Tool executed — model did not respond)" }])
+                }
+                setStreamText(""); setStreaming(false)
+                saveChat()
+              },
+              onError: (err) => {
+                sendLog.info("summary stream error", { message: err.message })
+                setMessages((p) => [...p, { role: "assistant", content: `Tool result received but summary failed: ${err.message}` }])
+                setStreamText(""); setStreaming(false)
+                saveChat()
+              },
+            }, mid, abortCtrl?.signal)
+          } else if (hasToolCalls) {
+            setMessages((p) => [...p, { role: "assistant", content: "(Tool executed — no response from model)" }])
+            setStreamText(""); setStreaming(false)
+            saveChat()
+          } else {
+            setStreamText(""); setStreaming(false)
+            saveChat()
           }
-          setStreamText(""); setStreaming(false)
-          saveChat()
         },
         onError: (err) => {
+          sendLog.info("onError", { message: err.message })
           setMessages((p) => {
             // Mark any running tools as error
             const updated = p.map((m) =>
@@ -199,14 +285,20 @@ export function Home(props: {
           setStreamText(""); setStreaming(false)
           saveChat()
         },
-      }, mid, abortCtrl.signal)
+      }, mid, abortCtrl.signal, { maxSteps: 10 })
+      sendLog.info("AIChat.stream returned normally")
       abortCtrl = undefined
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err)
+      // Can't use sendLog here because it might not be in scope
       setMessages((p) => [...p, { role: "assistant", content: `Error: ${msg}` }])
-      setStreamText("")
-      setStreaming(false)
       saveChat()
+    } finally {
+      // Clean up streaming state — but NOT if a summary stream is still running
+      if (!summaryStreamActive) {
+        setStreamText("")
+        setStreaming(false)
+      }
     }
   }
 
@@ -371,28 +463,42 @@ export function Home(props: {
           ))}
           <box height={1} />
           <text fg={theme.colors.textMuted}>The AI-powered coding forum</text>
-        </box>
-        <Show when={!props.loggedIn || !props.hasAI}>
-          <box flexShrink={0} flexDirection="column" paddingTop={1} alignItems="center">
+
+          {/* Status info below logo */}
+          <box height={1} />
+          <box flexDirection="column" alignItems="center" gap={0}>
             <box flexDirection="row" gap={1}>
-              <text fg={props.hasAI ? theme.colors.success : theme.colors.warning}>{props.hasAI ? "✓" : "●"}</text>
-              <text fg={props.hasAI ? theme.colors.textMuted : theme.colors.text}>
-                {props.hasAI ? `AI: ${props.modelName}` : "Type /ai to configure AI"}
+              <text fg={props.hasAI ? theme.colors.success : theme.colors.warning}>
+                {props.hasAI ? "●" : "○"}
+              </text>
+              <text fg={theme.colors.text}>
+                {props.hasAI ? props.modelName : "No AI"}
               </text>
+              <Show when={!props.hasAI}>
+                <text fg={theme.colors.textMuted}> — type /ai</text>
+              </Show>
             </box>
             <box flexDirection="row" gap={1}>
-              <text fg={props.loggedIn ? theme.colors.success : theme.colors.warning}>{props.loggedIn ? "✓" : "●"}</text>
-              <text fg={props.loggedIn ? theme.colors.textMuted : theme.colors.text}>
-                {props.loggedIn ? `Logged in as ${props.username}` : "Type /login to sign in"}
+              <text fg={props.loggedIn ? theme.colors.success : theme.colors.warning}>
+                {props.loggedIn ? "●" : "○"}
+              </text>
+              <text fg={theme.colors.text}>
+                {props.loggedIn ? props.username : "Not logged in"}
               </text>
+              <Show when={props.loggedIn && props.activeAgent}>
+                <text fg={theme.colors.textMuted}> / {props.activeAgent}</text>
+              </Show>
+              <Show when={!props.loggedIn}>
+                <text fg={theme.colors.textMuted}> — type /login</text>
+              </Show>
             </box>
           </box>
-        </Show>
+        </box>
       </Show>
 
       {/* When chatting: messages fill the space */}
       <Show when={chatting()}>
-        <box flexDirection="column" flexGrow={1} paddingTop={1} overflow="scroll">
+        <scrollbox flexGrow={1} paddingTop={1} stickyScroll={true} stickyStart="bottom">
           <For each={messages()}>
             {(msg) => (
               <box flexShrink={0}>
@@ -402,7 +508,7 @@ export function Home(props: {
                     <text fg={theme.colors.primary} flexShrink={0}>
                       <span style={{ bold: true }}>{"❯ "}</span>
                     </text>
-                    <text fg={theme.colors.text}>
+                    <text fg={theme.colors.text} wrapMode="word" flexGrow={1} flexShrink={1}>
                       <span style={{ bold: true }}>{msg.content}</span>
                     </text>
                   </box>
@@ -420,27 +526,44 @@ export function Home(props: {
                 </Show>
                 {/* Assistant message — ◆ prefix */}
                 <Show when={msg.role === "assistant"}>
-                  <box flexDirection="row" paddingBottom={1}>
-                    <text fg={theme.colors.success} flexShrink={0}>
-                      <span style={{ bold: true }}>{"◆ "}</span>
-                    </text>
-                    <text fg={theme.colors.text}>{msg.content}</text>
+                  <box paddingBottom={1} flexShrink={0}>
+                    <code
+                      filetype="markdown"
+                      drawUnstyledText={false}
+                      syntaxStyle={syntaxStyle()}
+                      content={msg.content}
+                      conceal={true}
+                      fg={theme.colors.text}
+                    />
                   </box>
                 </Show>
               </box>
             )}
           </For>
-          <Show when={streaming()}>
-            <box flexDirection="row" paddingBottom={1} flexShrink={0}>
-              <text fg={theme.colors.success} flexShrink={0}>
-                <span style={{ bold: true }}>{"◆ "}</span>
-              </text>
-              <text fg={streamText() ? theme.colors.text : theme.colors.textMuted}>
-                {streamText() || shimmerText()}
+          <box
+            flexShrink={0}
+            paddingBottom={streaming() ? 1 : 0}
+            height={streaming() ? undefined : 0}
+            overflow="hidden"
+          >
+            <Show when={streaming() && streamText()}>
+              <code
+                filetype="markdown"
+                drawUnstyledText={false}
+                streaming={true}
+                syntaxStyle={syntaxStyle()}
+                content={streamText()}
+                conceal={true}
+                fg={theme.colors.text}
+              />
+            </Show>
+            <Show when={streaming() && !streamText()}>
+              <text fg={theme.colors.textMuted} wrapMode="word">
+                {"◆ " + shimmerText()}
               </text>
-            </box>
-          </Show>
-        </box>
+            </Show>
+          </box>
+        </scrollbox>
       </Show>
 
       {/* Spacer when no chat and no autocomplete */}
@@ -508,11 +631,11 @@ export function Home(props: {
                 <text fg={theme.colors.textMuted}>{tipPool()[tipIdx % tipPool().length]}</text>
               </box>
             </Show>
-            {/* Input line */}
+            {/* Input line with blinking cursor */}
             <box flexDirection="row">
               <text fg={theme.colors.primary}><span style={{ bold: true }}>{"❯ "}</span></text>
               <text fg={theme.colors.input}>{input()}</text>
-              <text fg={theme.colors.cursor}>{"█"}</text>
+              <text fg={theme.colors.cursor} style={{ bold: true }}>{"█"}</text>
             </box>
           </box>
         </Show>

package/src/tui/routes/model.tsx

@@ -54,7 +54,8 @@ export function ModelPicker(props: { onDone: (model?: string) => void }) {
       }))
       if (items.length > 0) {
         setModels(items)
-        const curIdx = items.findIndex((m) => m.id === (cfg.model || AIProvider.DEFAULT_MODEL))
+        const modelId = cfg.model || AIProvider.DEFAULT_MODEL
+        const curIdx = items.findIndex((m) => m.id === modelId || `${m.provider}/${m.id}` === modelId)
         if (curIdx >= 0) setIdx(curIdx)
         setStatus(`${items.length} models loaded`)
       } else {
@@ -123,9 +124,11 @@ export function ModelPicker(props: { onDone: (model?: string) => void }) {
 
   async function save(id: string) {
     try {
+      const item = filtered().find((m) => m.id === id)
+      const saveId = item && item.provider === "openai-compatible" ? `openai-compatible/${id}` : id
       const { Config } = await import("../../config")
-      await Config.save({ model: id })
-      props.onDone(id)
+      await Config.save({ model: saveId })
+      props.onDone(saveId)
     } catch {
       props.onDone()
     }
@@ -187,7 +190,7 @@ export function ModelPicker(props: { onDone: (model?: string) => void }) {
                     <text fg={selected() ? "#ffffff" : theme.colors.textMuted}>
                       {" " + m.provider}
                     </text>
-                    {m.id === current() ? (
+                    {(m.id === current() || `${m.provider}/${m.id}` === current()) ? (
                       <text fg={selected() ? "#ffffff" : theme.colors.success}>{" ← current"}</text>
                     ) : null}
                   </box>