codeblog-app 2.2.6 → 2.3.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.2.6",
+  "version": "2.3.1",
   "description": "CLI client for CodeBlog — the forum where AI writes the posts",
   "type": "module",
   "license": "MIT",
@@ -49,18 +49,20 @@
     "./*": "./src/*.ts"
   },
   "devDependencies": {
+    "@babel/core": "^7.28.4",
     "@tsconfig/bun": "1.0.9",
+    "@types/babel__core": "^7.20.5",
     "@types/bun": "1.3.9",
     "@types/yargs": "17.0.33",
     "drizzle-kit": "1.0.0-beta.12-a5629fb",
     "typescript": "5.8.2"
   },
   "optionalDependencies": {
-    "codeblog-app-darwin-arm64": "2.2.6",
-    "codeblog-app-darwin-x64": "2.2.6",
-    "codeblog-app-linux-arm64": "2.2.6",
-    "codeblog-app-linux-x64": "2.2.6",
-    "codeblog-app-windows-x64": "2.2.6"
+    "codeblog-app-darwin-arm64": "2.3.1",
+    "codeblog-app-darwin-x64": "2.3.1",
+    "codeblog-app-linux-arm64": "2.3.1",
+    "codeblog-app-linux-x64": "2.3.1",
+    "codeblog-app-windows-x64": "2.3.1"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.44",
@@ -71,7 +73,7 @@
     "@opentui/core": "^0.1.79",
     "@opentui/solid": "^0.1.79",
     "ai": "^6.0.86",
-    "codeblog-mcp": "^2.1.5",
+    "codeblog-mcp": "2.2.0",
     "drizzle-orm": "1.0.0-beta.12-a5629fb",
     "fuzzysort": "^3.1.0",
     "hono": "4.10.7",

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

@@ -40,7 +40,7 @@ function makeToolCallStreamResult() {
   }
 }
 
-let streamFactory = () => makeStreamResult()
+let streamFactory: () => { fullStream: AsyncGenerator<any, void, unknown> } = () => makeStreamResult()
 
 mock.module("ai", () => ({
   streamText: () => streamFactory(),
@@ -52,6 +52,15 @@ mock.module("ai", () => ({
 mock.module("../provider", () => ({
   AIProvider: {
     getModel: mock(() => Promise.resolve({ id: "test-model" })),
+    resolveModelCompat: mock(() => Promise.resolve({
+      providerID: "openai-compatible",
+      modelID: "test-model",
+      api: "openai-compatible",
+      compatProfile: "openai-compatible",
+      cacheKey: "openai-compatible:openai-compatible",
+      stripParallelToolCalls: true,
+      normalizeToolSchema: true,
+    })),
     DEFAULT_MODEL: "test-model",
   },
 }))
@@ -69,7 +78,7 @@ describe("AIChat", () => {
   // ---------------------------------------------------------------------------
 
   test("Message type accepts user, assistant, system roles", () => {
-    const messages: AIChat.Message[] = [
+    const messages = [
       { role: "user", content: "hello" },
       { role: "assistant", content: "hi" },
       { role: "system", content: "you are a bot" },

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

@@ -0,0 +1,46 @@
+import { describe, test, expect } from "bun:test"
+import { patchRequestByCompat, resolveCompat } from "../types"
+
+describe("AI Compat", () => {
+  test("resolveCompat uses openai-compatible preset by default", () => {
+    const compat = resolveCompat({
+      providerID: "openai-compatible",
+      modelID: "deepseek-chat",
+    })
+    expect(compat.api).toBe("openai-compatible")
+    expect(compat.stripParallelToolCalls).toBe(true)
+    expect(compat.normalizeToolSchema).toBe(true)
+  })
+
+  test("resolveCompat honors provider config override", () => {
+    const compat = resolveCompat({
+      providerID: "openai-compatible",
+      modelID: "claude-sonnet-4-20250514",
+      providerConfig: { api_key: "x", api: "anthropic", compat_profile: "anthropic" },
+    })
+    expect(compat.api).toBe("anthropic")
+    expect(compat.compatProfile).toBe("anthropic")
+    expect(compat.stripParallelToolCalls).toBe(false)
+  })
+
+  test("patchRequestByCompat removes parallel_tool_calls and fixes schema", () => {
+    const compat = resolveCompat({
+      providerID: "openai-compatible",
+      modelID: "qwen3-coder",
+    })
+    const body = {
+      parallel_tool_calls: true,
+      tools: [
+        {
+          function: {
+            parameters: {},
+          },
+        },
+      ],
+    }
+    const patched = patchRequestByCompat(compat, body)
+    expect(patched.parallel_tool_calls).toBeUndefined()
+    expect(patched.tools[0]!.function.parameters.type).toBe("object")
+    expect(patched.tools[0]!.function.parameters.properties).toEqual({})
+  })
+})

package/src/ai/__tests__/home.ai-stream.integration.test.ts

@@ -0,0 +1,77 @@
+import { describe, test, expect, mock } from "bun:test"
+import { resolveAssistantContent } from "../../tui/ai-stream"
+
+const streamTextMock = mock(() => ({
+  fullStream: (async function* () {
+    yield { type: "tool-call", toolName: "scan_sessions", args: { limit: 1 } }
+    yield { type: "tool-result", toolName: "scan_sessions", result: { sessions: [{ id: "s1" }] } }
+  })(),
+}))
+
+mock.module("ai", () => ({
+  streamText: streamTextMock,
+  stepCountIs: (n: number) => ({ type: "step-count", count: n }),
+  tool: (config: any) => config,
+  jsonSchema: (schema: any) => schema,
+}))
+
+mock.module("../../mcp/client", () => ({
+  McpBridge: {
+    listTools: mock(async () => ({ tools: [] })),
+    callToolJSON: mock(async () => ({})),
+  },
+}))
+
+mock.module("../provider", () => ({
+  AIProvider: {
+    getModel: mock(async () => ({ id: "test-model" })),
+    resolveModelCompat: mock(async () => ({
+      providerID: "openai-compatible",
+      modelID: "test-model",
+      api: "openai-compatible",
+      compatProfile: "openai-compatible",
+      cacheKey: "openai-compatible:openai-compatible",
+      stripParallelToolCalls: true,
+      normalizeToolSchema: true,
+    })),
+    DEFAULT_MODEL: "test-model",
+  },
+}))
+
+const { AIChat } = await import("../chat")
+
+describe("home ai stream integration (equivalent)", () => {
+  test("tool-only run stays single-stream and produces structured fallback content", async () => {
+    let finishText = ""
+    await AIChat.stream(
+      [{ role: "user", content: "scan now" }],
+      {
+        onFinish: (text) => { finishText = text },
+      },
+    )
+
+    expect(streamTextMock).toHaveBeenCalledTimes(1)
+    expect(finishText).toBe("(No response)")
+
+    const content = resolveAssistantContent({
+      finalText: "",
+      aborted: false,
+      abortByUser: false,
+      hasToolCalls: true,
+      toolResults: [{ name: "scan_sessions", result: "{\"sessions\":[{\"id\":\"s1\"}]}" }],
+    })
+    expect(content).toContain("Tool execution completed:")
+    expect(content).toContain("scan_sessions")
+  })
+
+  test("abort state is rendered consistently", () => {
+    const content = resolveAssistantContent({
+      finalText: "partial answer",
+      aborted: true,
+      abortByUser: true,
+      hasToolCalls: false,
+      toolResults: [],
+    })
+    expect(content).toContain("(interrupted)")
+  })
+})

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

@@ -0,0 +1,61 @@
+import { describe, test, expect, beforeEach } from "bun:test"
+import { routeModel } from "../provider-registry"
+
+describe("provider-registry", () => {
+  beforeEach(() => {
+    delete process.env.ANTHROPIC_API_KEY
+    delete process.env.OPENAI_API_KEY
+    delete process.env.GOOGLE_GENERATIVE_AI_API_KEY
+    delete process.env.OPENAI_COMPATIBLE_API_KEY
+  })
+
+  test("routes explicit provider/model first", async () => {
+    const route = await routeModel("openai/gpt-4o", {
+      api_url: "https://codeblog.ai",
+      providers: {
+        openai: { api_key: "sk-openai" },
+      },
+    })
+    expect(route.providerID).toBe("openai")
+    expect(route.modelID).toBe("gpt-4o")
+  })
+
+  test("routes by default_provider for unknown model", async () => {
+    const route = await routeModel("deepseek-chat", {
+      api_url: "https://codeblog.ai",
+      default_provider: "openai-compatible",
+      providers: {
+        "openai-compatible": {
+          api_key: "sk-compat",
+          base_url: "https://api.deepseek.com",
+          api: "openai-compatible",
+          compat_profile: "openai-compatible",
+        },
+      },
+    })
+    expect(route.providerID).toBe("openai-compatible")
+    expect(route.modelID).toBe("deepseek-chat")
+  })
+
+  test("unknown model throws deterministic actionable error", async () => {
+    await expect(routeModel("unknown-model-x", {
+      api_url: "https://codeblog.ai",
+      providers: {
+        openai: { api_key: "sk-openai" },
+      },
+    })).rejects.toThrow('Unknown model "unknown-model-x"')
+  })
+
+  test("multi-provider routing is deterministic by prefix", async () => {
+    const route = await routeModel("gpt-4o-mini", {
+      api_url: "https://codeblog.ai",
+      default_provider: "openai-compatible",
+      providers: {
+        openai: { api_key: "sk-openai" },
+        "openai-compatible": { api_key: "sk-compat", base_url: "https://api.deepseek.com" },
+      },
+    })
+    expect(route.providerID).toBe("openai")
+    expect(route.modelID).toBe("gpt-4o-mini")
+  })
+})

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

@@ -1,26 +1,56 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test"
-import { AIProvider } from "../provider"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { describe, test, expect, beforeAll, beforeEach, afterEach, afterAll } from "bun:test"
+import { Config } from "../../config"
 
 describe("AIProvider", () => {
   const originalEnv = { ...process.env }
-
-  beforeEach(() => {
-    // Clean up env vars before each test
-    delete process.env.ANTHROPIC_API_KEY
-    delete process.env.ANTHROPIC_AUTH_TOKEN
-    delete process.env.OPENAI_API_KEY
-    delete process.env.GOOGLE_GENERATIVE_AI_API_KEY
-    delete process.env.GOOGLE_API_KEY
-    delete process.env.OPENAI_COMPATIBLE_API_KEY
-    delete process.env.ANTHROPIC_BASE_URL
-    delete process.env.OPENAI_BASE_URL
-    delete process.env.OPENAI_API_BASE
-    delete process.env.GOOGLE_API_BASE_URL
-    delete process.env.OPENAI_COMPATIBLE_BASE_URL
+  const testHome = path.join(os.tmpdir(), `codeblog-provider-test-${process.pid}-${Date.now()}`)
+  const configFile = path.join(testHome, ".config", "codeblog", "config.json")
+  const xdgData = path.join(testHome, ".local", "share")
+  const xdgCache = path.join(testHome, ".cache")
+  const xdgConfig = path.join(testHome, ".config")
+  const xdgState = path.join(testHome, ".local", "state")
+  const envKeys = [
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "OPENAI_API_KEY",
+    "GOOGLE_GENERATIVE_AI_API_KEY",
+    "GOOGLE_API_KEY",
+    "OPENAI_COMPATIBLE_API_KEY",
+    "ANTHROPIC_BASE_URL",
+    "OPENAI_BASE_URL",
+    "OPENAI_API_BASE",
+    "GOOGLE_API_BASE_URL",
+    "OPENAI_COMPATIBLE_BASE_URL",
+  ]
+  let AIProvider: (typeof import("../provider"))["AIProvider"]
+
+  beforeAll(async () => {
+    process.env.CODEBLOG_TEST_HOME = testHome
+    process.env.XDG_DATA_HOME = xdgData
+    process.env.XDG_CACHE_HOME = xdgCache
+    process.env.XDG_CONFIG_HOME = xdgConfig
+    process.env.XDG_STATE_HOME = xdgState
+    process.env.CODEBLOG_AI_PROVIDER_REGISTRY_V2 = "0"
+    await fs.mkdir(path.dirname(configFile), { recursive: true })
+    await fs.writeFile(configFile, "{}\n")
+    ;({ AIProvider } = await import("../provider"))
+  })
+
+  beforeEach(async () => {
+    process.env.CODEBLOG_TEST_HOME = testHome
+    process.env.XDG_DATA_HOME = xdgData
+    process.env.XDG_CACHE_HOME = xdgCache
+    process.env.XDG_CONFIG_HOME = xdgConfig
+    process.env.XDG_STATE_HOME = xdgState
+    process.env.CODEBLOG_AI_PROVIDER_REGISTRY_V2 = "0"
+    for (const key of envKeys) delete process.env[key]
+    await fs.writeFile(configFile, "{}\n")
   })
 
   afterEach(() => {
-    // Restore original env
     for (const key of Object.keys(process.env)) {
       if (!(key in originalEnv)) delete process.env[key]
     }
@@ -29,6 +59,10 @@ describe("AIProvider", () => {
     }
   })
 
+  afterAll(async () => {
+    await fs.rm(testHome, { recursive: true, force: true })
+  })
+
   // ---------------------------------------------------------------------------
   // BUILTIN_MODELS
   // ---------------------------------------------------------------------------
@@ -171,7 +205,13 @@ describe("AIProvider", () => {
   // ---------------------------------------------------------------------------
 
   test("getModel throws when no API key for builtin model", async () => {
-    expect(AIProvider.getModel("gpt-4o")).rejects.toThrow("No API key for openai")
+    const load = Config.load
+    Config.load = async () => ({ api_url: "https://codeblog.ai" })
+    try {
+      await expect(AIProvider.getModel("gpt-4o")).rejects.toThrow("No API key for openai")
+    } finally {
+      Config.load = load
+    }
   })
 
   test("getModel falls back to provider with base_url for unknown model", async () => {

package/src/ai/__tests__/stream-events.test.ts

@@ -0,0 +1,152 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test"
+
+const mockListTools = mock(async () => ({ tools: [] }))
+
+mock.module("../../mcp/client", () => ({
+  McpBridge: {
+    listTools: mockListTools,
+    callToolJSON: mock(async () => ({})),
+  },
+}))
+
+let streamFactory: () => { fullStream: AsyncGenerator<any, void, unknown> } = () => ({
+  fullStream: (async function* () {
+    yield { type: "text-delta", textDelta: "hello" }
+  })(),
+})
+
+mock.module("ai", () => ({
+  streamText: () => streamFactory(),
+  stepCountIs: (n: number) => ({ type: "step-count", count: n }),
+  tool: (config: any) => config,
+  jsonSchema: (schema: any) => schema,
+}))
+
+mock.module("../provider", () => ({
+  AIProvider: {
+    getModel: mock(async () => ({ id: "test-model" })),
+    resolveModelCompat: mock(async () => ({
+      providerID: "openai-compatible",
+      modelID: "test-model",
+      api: "openai-compatible",
+      compatProfile: "openai-compatible",
+      cacheKey: "openai-compatible:openai-compatible",
+      stripParallelToolCalls: true,
+      normalizeToolSchema: true,
+    })),
+    DEFAULT_MODEL: "test-model",
+  },
+}))
+
+const { AIChat } = await import("../chat")
+
+describe("stream events", () => {
+  beforeEach(() => {
+    mockListTools.mockClear()
+  })
+
+  test("emits ordered run-start -> deltas -> run-finish sequence", async () => {
+    streamFactory = () => ({
+      fullStream: (async function* () {
+        yield { type: "text-delta", textDelta: "Hello " }
+        yield { type: "text-delta", textDelta: "World" }
+      })(),
+    })
+
+    const events: any[] = []
+    for await (const event of AIChat.streamEvents([{ role: "user", content: "hi" }])) {
+      events.push(event)
+    }
+
+    expect(events.map((e: any) => e.type)).toEqual(["run-start", "text-delta", "text-delta", "run-finish"])
+    expect(events.every((e: any) => e.runId === events[0]!.runId)).toBe(true)
+    expect(events.map((e: any) => e.seq)).toEqual([1, 2, 3, 4])
+  })
+
+  test("tool-start and tool-result are paired", async () => {
+    streamFactory = () => ({
+      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" }
+      })(),
+    })
+
+    const starts: string[] = []
+    const results: string[] = []
+    const ids: Array<{ start?: string; result?: string }> = []
+    for await (const event of AIChat.streamEvents([{ role: "user", content: "scan" }])) {
+      if (event.type === "tool-start") {
+        starts.push(event.name)
+        ids.push({ start: event.callID })
+      }
+      if (event.type === "tool-result") {
+        results.push(event.name)
+        ids[0] = { ...ids[0], result: event.callID }
+      }
+    }
+
+    expect(starts).toEqual(["scan_sessions"])
+    expect(results).toEqual(["scan_sessions"])
+    expect(ids[0]?.start).toBe(ids[0]?.result)
+  })
+
+  test("abort keeps lifecycle consistent and marks run-finish.aborted", async () => {
+    streamFactory = () => ({
+      fullStream: (async function* () {
+        yield { type: "text-delta", textDelta: "partial" }
+        await Bun.sleep(40)
+        yield { type: "text-delta", textDelta: " late" }
+      })(),
+    })
+
+    const ctrl = new AbortController()
+    let seenFinish = false
+    for await (const event of AIChat.streamEvents([{ role: "user", content: "stop test" }], undefined, ctrl.signal)) {
+      if (event.type === "text-delta") ctrl.abort()
+      if (event.type === "run-finish") {
+        seenFinish = true
+        expect(event.aborted).toBe(true)
+      }
+    }
+
+    expect(seenFinish).toBe(true)
+  })
+
+  test("error part is surfaced and lifecycle still finishes", async () => {
+    streamFactory = () => ({
+      fullStream: (async function* () {
+        yield { type: "error", error: new Error("boom") }
+      })(),
+    })
+
+    const types: string[] = []
+    for await (const event of AIChat.streamEvents([{ role: "user", content: "error path" }])) {
+      types.push(event.type)
+      if (event.type === "error") expect(event.error.message).toBe("boom")
+    }
+
+    expect(types).toContain("error")
+    expect(types[types.length - 1]).toBe("run-finish")
+  })
+
+  test("tool timeout emits error and still reaches run-finish", async () => {
+    streamFactory = () => ({
+      fullStream: (async function* () {
+        yield { type: "tool-call", toolName: "scan_sessions", args: { limit: 1 } }
+        await Bun.sleep(40)
+      })(),
+    })
+
+    const seen: string[] = []
+    for await (const event of AIChat.streamEvents([{ role: "user", content: "scan" }], undefined, undefined, {
+      toolTimeoutMs: 15,
+      idleTimeoutMs: 1000,
+    })) {
+      seen.push(event.type)
+    }
+
+    expect(seen).toContain("error")
+    expect(seen[seen.length - 1]).toBe("run-finish")
+  })
+})