codeblog-app 2.1.7 → 2.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.1.7",
+  "version": "2.2.0",
   "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.0",
+    "codeblog-app-darwin-x64": "2.2.0",
+    "codeblog-app-linux-arm64": "2.2.0",
+    "codeblog-app-linux-x64": "2.2.0",
+    "codeblog-app-windows-x64": "2.2.0"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.44",

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"
@@ -21,6 +21,9 @@ After a tool returns results, summarize them naturally for the user.
 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 MAX_TOOL_STEPS = 1
+const IDLE_TIMEOUT_MS = 15_000 // 15s without any stream event → abort
+
 export namespace AIChat {
   export interface Message {
     role: "user" | "assistant" | "system"
@@ -38,95 +41,123 @@ export namespace AIChat {
   export async function stream(messages: Message[], callbacks: StreamCallbacks, modelID?: string, signal?: AbortSignal) {
     const model = await AIProvider.getModel(modelID)
     const tools = await getChatTools()
-    log.info("streaming", { model: modelID || AIProvider.DEFAULT_MODEL, messages: messages.length })
+    log.info("streaming", { model: modelID || AIProvider.DEFAULT_MODEL, messages: messages.length, toolCount: Object.keys(tools).length })
 
-    // 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(MAX_TOOL_STEPS),
+      toolChoice: "auto",
+      abortSignal: internalAbort.signal,
+      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": {
+            log.info("tool-call", { toolName: (part as any).toolName, partCount })
+            // Pause idle timer — tool execution happens between tool-call and tool-result
+            toolExecuting = true
+            if (idleTimer) { clearTimeout(idleTimer); idleTimer = undefined }
+            callbacks.onToolCall?.((part as any).toolName, (part as any).input ?? (part as any).args)
+            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: {
+            log.error("tool-error", { toolName: (part as any).toolName, error: String((part as any).error).slice(0, 500) })
+            toolExecuting = false
+            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
   }
@@ -175,6 +177,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 +210,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 +263,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,29 @@ 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 })
+        try {
+          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
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err)
+          log.error("execute tool error", { name, error: msg })
+          return JSON.stringify({ error: msg })
+        }
+      },
     })
   }
 

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/routes/home.tsx

@@ -156,14 +156,24 @@ export function Home(props: {
       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 = ""
+      let summaryStreamActive = false
       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 +182,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 +195,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) =>
@@ -200,13 +257,19 @@ export function Home(props: {
           saveChat()
         },
       }, mid, abortCtrl.signal)
+      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)
+      }
     }
   }
 
@@ -392,7 +455,7 @@ export function Home(props: {
 
       {/* 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 +465,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>
@@ -424,23 +487,27 @@ export function Home(props: {
                     <text fg={theme.colors.success} flexShrink={0}>
                       <span style={{ bold: true }}>{"◆ "}</span>
                     </text>
-                    <text fg={theme.colors.text}>{msg.content}</text>
+                    <text fg={theme.colors.text} wrapMode="word" flexGrow={1} flexShrink={1}>{msg.content}</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()}
-              </text>
-            </box>
-          </Show>
-        </box>
+          <box
+            flexDirection="row"
+            paddingBottom={streaming() ? 1 : 0}
+            flexShrink={0}
+            height={streaming() ? undefined : 0}
+            overflow="hidden"
+          >
+            <text fg={theme.colors.success} flexShrink={0}>
+              <span style={{ bold: true }}>{streaming() ? "◆ " : ""}</span>
+            </text>
+            <text fg={streamText() ? theme.colors.text : theme.colors.textMuted} wrapMode="word" flexGrow={1} flexShrink={1}>
+              {streaming() ? (streamText() || shimmerText()) : ""}
+            </text>
+          </box>
+        </scrollbox>
       </Show>
 
       {/* Spacer when no chat and no autocomplete */}

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>