pi-codebuddy-sdk 0.1.13 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-codebuddy-sdk",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "CodeBuddy Agent SDK provider for Pi — native tool execution, 29+ models, thinking controls, session pool",
   "author": "slahser",
   "license": "MIT",

package/src/index.ts

@@ -1,97 +1,101 @@
-import type { ExtensionAPI, ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+/**
+ * pi-codebuddy-sdk — CodeBuddy Agent SDK as a Pi provider.
+ *
+ * Architecture follows pi-claude-bridge:
+ * - Stateless: one sdk.query() per Pi turn
+ * - No Pi systemPrompt forwarding — CodeBuddy uses its own default
+ * - No MCP tool bridge — CodeBuddy SDK tools are used natively
+ * - Only the latest user message is forwarded (Pi manages conversation)
+ *
+ * Two files: index.ts (registration + model discovery), provider.ts (streaming).
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ProviderApi, SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
+import { streamCodebuddy } from "./provider.js";
 
-// ponytail: hardcoded patterns for capability detection since supportedModels() returns
-// only {id, name} without capability metadata.
-const THINKING_PATTERNS = [/claude/i, /gemini/i, /gpt-5/i];
-const IMAGE_PATTERNS = [/claude/i, /gemini/i, /gpt/i];
-// ponytail: rough context window estimates by model family
-const CONTEXT_ESTIMATES: Record<string, [number, number]> = {
-  // [contextWindow, maxTokens]
-  claude: [200000, 8192],
-  gemini: [1048576, 8192],
-  gpt: [200000, 16384],
-  deepseek: [131072, 8192],
-  glm: [131072, 8192],
-  minimax: [131072, 8192],
-  kimi: [131072, 8192],
-  hy: [131072, 8192], // Hunyuan
-};
+// ── provider registration ──
 
-function detectCapabilities(modelId: string) {
-  const reasoning = THINKING_PATTERNS.some((p) => p.test(modelId));
-  const hasImage = IMAGE_PATTERNS.some((p) => p.test(modelId));
-
-  // Match family for context window estimate
-  const family = Object.keys(CONTEXT_ESTIMATES).find((k) =>
-    modelId.toLowerCase().startsWith(k),
-  );
-  const [contextWindow, maxTokens] = family
-    ? CONTEXT_ESTIMATES[family]
-    : [128000, 8192];
-
-  return {
-    reasoning,
-    input: (hasImage ? ["text", "image"] : ["text"]) as ("text" | "image")[],
-    contextWindow,
-    maxTokens,
-  };
-}
+export default function activate(api: ExtensionAPI) {
+  api.registerProvider("codebuddy", {
+    name: "CodeBuddy",
+    baseUrl: "codebuddy-local",
+    apiKey: "codebuddy-local-auth",
+    api: "codebuddy-sdk",
+    models: [],
+    streamSimple: streamCodebuddy,
+  });
 
-async function discoverModels(): Promise<ProviderModelConfig[]> {
-  try {
-    const sdk = await import("@tencent-ai/agent-sdk");
-    const q = sdk.query({
-      prompt: "",
-      options: {
-        permissionMode: "bypassPermissions",
-        maxTurns: 0,
-      },
-    });
-    const models = await Promise.race([
-      q.supportedModels(),
-      new Promise<never>((_, reject) =>
-        setTimeout(() => reject(new Error("CodeBuddy model discovery timed out after 15s")), 15000),
-      ),
-    ]);
-    if (models && models.length > 0) {
-      return models.map((m) => {
-        const caps = detectCapabilities(m.id);
-        return {
-          id: m.id,
-          name: m.name || m.id,
-          reasoning: caps.reasoning,
-          input: caps.input,
-          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-          contextWindow: caps.contextWindow,
-          maxTokens: caps.maxTokens,
-        };
+  // Lazy model discovery at startup
+  queueMicrotask(async () => {
+    try {
+      const models = await discoverModels();
+      api.registerProvider("codebuddy", {
+        name: "CodeBuddy",
+        baseUrl: "codebuddy-local",
+        apiKey: "codebuddy-local-auth",
+        api: "codebuddy-sdk",
+        models,
+        streamSimple: streamCodebuddy,
       });
+    } catch {
+      // Model discovery failed — provider registered with empty models,
+      // user can still try manually.
     }
-  } catch (e) {
-    // Discovery failed — SDK not installed, CLI missing, or network issue.
-    // Fall back to hardcoded minimal list so Pi can still show a provider.
-    console.warn(
-      `[pi-codebuddy-sdk] Model discovery failed: ${e instanceof Error ? e.message : String(e)}. Using ${3} fallback models.`,
-    );
-  }
+  });
+}
 
-  // ponytail: fallback model list when discovery fails
-  return [
-    { id: "hy3-preview-agent-ioa", name: "Hunyuan 3 Preview", reasoning: false, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 128000, maxTokens: 8192 },
-    { id: "claude-sonnet-4.6", name: "Claude Sonnet 4.6", reasoning: true, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 200000, maxTokens: 8192 },
-    { id: "deepseek-v4-pro-ioa", name: "DeepSeek V4 Pro", reasoning: false, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 128000, maxTokens: 8192 },
-  ];
+// ── model discovery ──
+
+let _sdk: typeof import("@tencent-ai/agent-sdk") | undefined;
+async function getSdk() {
+  if (!_sdk) _sdk = await import("@tencent-ai/agent-sdk");
+  return _sdk;
 }
 
-export default async function (pi: ExtensionAPI) {
-  const models = await discoverModels();
+export async function discoverModels(): Promise<ProviderApi["models"]> {
+  const sdk = await getSdk();
+  const q = sdk.query({ prompt: " ", options: { maxTurns: 0 } });
+  const supported = await q.supportedModels();
+  await q.interrupt();
 
-  pi.registerProvider("codebuddy", {
-    name: "CodeBuddy",
-    baseUrl: "https://codebuddy.ai",
-    apiKey: "codebuddy-local",
-    api: "codebuddy-sdk",
-    models,
-    streamSimple: (await import("./provider.js")).streamCodebuddy,
+  const models = supported.map((m) => {
+    const caps = detectCapabilities(m.id);
+    return {
+      id: m.id,
+      name: m.name || m.id,
+      api: "codebuddy-sdk" as const,
+      provider: "codebuddy" as const,
+      reasoning: caps.reasoning,
+      input: caps.input,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: caps.contextWindow,
+      maxTokens: caps.maxTokens,
+    };
   });
+
+  return models;
+}
+
+// ── capability detection (pattern-based, like pi-claude-bridge) ──
+
+const THINKING_PATTERNS = [/claude/i, /gemini/i, /gpt-5/i];
+const IMAGE_PATTERNS = [/claude/i, /gemini/i, /gpt/i];
+const CONTEXT_ESTIMATES: Record<string, { window: number; maxTokens: number }> = {
+  claude: { window: 200000, maxTokens: 8192 },
+  gemini: { window: 1048576, maxTokens: 8192 },
+  gpt: { window: 200000, maxTokens: 16384 },
+  deepseek: { window: 131072, maxTokens: 8192 },
+  glm: { window: 131072, maxTokens: 8192 },
+  minimax: { window: 131072, maxTokens: 8192 },
+  kimi: { window: 131072, maxTokens: 8192 },
+  hy: { window: 131072, maxTokens: 8192 },
+};
+
+function detectCapabilities(id: string) {
+  const reasoning = THINKING_PATTERNS.some((p) => p.test(id));
+  const supportsImages = IMAGE_PATTERNS.some((p) => p.test(id));
+  const input = supportsImages ? (["text", "image"] as const) : (["text"] as const);
+  const family = Object.keys(CONTEXT_ESTIMATES).find((k) => id.toLowerCase().includes(k));
+  const est = family ? CONTEXT_ESTIMATES[family] : { window: 131072, maxTokens: 8192 };
+  return { reasoning, input, contextWindow: est.window, maxTokens: est.maxTokens };
 }

package/src/provider-debug.patch

@@ -0,0 +1 @@
+# Temporary: add debug logging to extractUserMessage

package/src/provider.ts

@@ -1,15 +1,13 @@
 /**
- * CodeBuddy Provider — stateless, lightweight.
+ * Provider entry point — pi-claude-bridge pattern.
  *
- * Uses sdk.query() (one-shot) — no context building, no session pool,
- * no tool boundary. Pi manages conversation, CodeBuddy is just a model backend.
- *
- * Architecture follows pi-openai-compatible / pi-anthropic pattern:
- * extract latest user message → send to SDK → stream events back to Pi.
+ * For each Pi turn:
+ * 1. Extract the latest user message (strip context-mode injection)
+ * 2. Call sdk.query() — stateless, CodeBuddy uses its own system prompt
+ * 3. Stream events back to Pi (text, thinking, toolcalls)
  */
 import {
   createAssistantMessageEventStream,
-  type Api,
   type AssistantMessage,
   type AssistantMessageEventStream,
   type Context,
@@ -20,21 +18,20 @@ import {
   type ToolCall,
 } from "@earendil-works/pi-ai/compat";
 import type {
+  Effort,
   Message as CbMessage,
   ThinkingConfig,
-  Effort,
-  RawMessageStreamEvent,
 } from "@tencent-ai/agent-sdk";
 
 type CodebuddySdk = typeof import("@tencent-ai/agent-sdk");
 
-async function loadCodebuddySdk(): Promise<CodebuddySdk> {
+async function loadSdk(): Promise<CodebuddySdk> {
   return import("@tencent-ai/agent-sdk");
 }
 
 // ── helpers ──
 
-function makePartial(model: Model<Api>): AssistantMessage {
+function makePartial(model: Model<any>): AssistantMessage {
   return {
     role: "assistant",
     content: [],
@@ -47,143 +44,149 @@ function makePartial(model: Model<Api>): AssistantMessage {
   };
 }
 
-function makeErrorPartial(model: Model<Api>, error: unknown): AssistantMessage {
+function makeErrorPartial(model: Model<any>, error: unknown): AssistantMessage {
   return {
     ...makePartial(model),
     stopReason: "error",
-    errorMessage: `CodeBuddy SDK error: ${error instanceof Error ? error.message : String(error)}`,
+    errorMessage: error instanceof Error ? error.message : String(error),
   };
 }
 
-function extractUsageUpdate(msg: CbMessage): Partial<AssistantMessage> | null {
-  if (msg.type === "result" && msg.usage) {
-    return {
-      usage: {
-        input: msg.usage.input_tokens ?? 0,
-        output: msg.usage.output_tokens ?? 0,
-        cacheRead: msg.usage.cache_read_input_tokens ?? 0,
-        cacheWrite: msg.usage.cache_creation_input_tokens ?? 0,
-        totalTokens: (msg.usage.input_tokens ?? 0) + (msg.usage.output_tokens ?? 0) + (msg.usage.cache_read_input_tokens ?? 0) + (msg.usage.cache_creation_input_tokens ?? 0),
-        cost: {
-          input: 0,
-          output: 0,
-          cacheRead: 0,
-          cacheWrite: 0,
-          total: msg.total_cost_usd ?? 0,
-        },
-      },
-    };
-  }
-  return null;
-}
+// ── extract user message ──
 
-// ── extract latest user message ──
-
-function extractLatestUserText(context: Context): string {
-  const messages = context.messages;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === "user") {
-      let raw = extractRawContent((messages[i] as any).content);
-      if (!raw) continue;
-      // Strip context-mode session state injection prepended to user messages.
-      // Pi's context-mode adds its hierarchy/state before the actual user input.
-      raw = stripContextModeInjection(raw);
-      if (raw) return raw;
-    }
+/**
+ * Extract the latest user message from Pi Context.
+ * Strips context-mode session state injection.
+ *
+ * Like pi-claude-bridge's extractUserPrompt() but with context-mode defense.
+ */
+function extractUserMessage(context: Context): string {
+  const msgs = context.messages;
+
+  // Pi injects context-mode state as the LAST user message (after the real one).
+  // Search from the end, skip obvious context-mode injections.
+  for (let i = msgs.length - 1; i >= 0; i--) {
+    if (msgs[i].role !== "user") continue;
+    const raw = contentToText((msgs[i] as any).content);
+    if (!raw) continue;
+
+    // Skip messages that are entirely context-mode injection
+    if (isContextModeInjection(raw)) continue;
+
+    return stripPiInjection(raw);
   }
   return "Continue.";
 }
 
-function extractRawContent(content: unknown): string {
+/** Detect if a user message is a Pi context-mode state injection (not a real message). */
+function isContextModeInjection(text: string): boolean {
+  const t = text.trim();
+  if (t.startsWith("context-mode active.")) return true;
+  if (t.includes("<session_state") || t.includes("<session_mode")) return true;
+  if (t.startsWith("<summary>") && t.includes("</summary>")) return true;
+  return false;
+}
+
+function contentToText(content: unknown): string {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
   return content
     .filter((c: any) => c?.type === "text")
-    .map((c: any) => c.text)
+    .map((c: any) => c.text as string)
     .join("\n");
 }
 
 /**
- * Pi context-mode prepends its session state to user messages.
- * Strip it to keep CodeBuddy from treating it as conversation content.
+ * Strip context-mode session state that Pi prepends to user messages.
  *
- * Injected format:
+ * Pi injects several formats:
  *   context-mode active. Hierarchy: ...
- *   <session_state source="compaction">
- *   <session_mode>investigate</session_mode>
- *   </session_state>
- *   [actual user message]
+ *   <session_state source="compaction"> ... </session_state>
+ *   <summary>Compacted: ...</summary>
+ *
+ * Strip all of them, keep only the actual user message.
  */
-function stripContextModeInjection(text: string): string {
-  // Find the end of context-mode injection
-  // Pattern: </session_state> followed by newlines then actual message
+function stripPiInjection(text: string): string {
+  // Fast path
+  if (!text.includes("context-mode") && !text.includes("<session_state") && !text.includes("<summary>")) {
+    return text;
+  }
+
+  // 1. Remove <summary> blocks (compaction summaries contain context-mode state)
+  text = text.replace(/<summary>[\s\S]*?<\/summary>\s*/g, "");
+
+  // 2. Remove <session_state> block and everything between "context-mode" and </session_state>
   const sessionEnd = text.lastIndexOf("</session_state>");
   if (sessionEnd >= 0) {
     const after = text.slice(sessionEnd + "</session_state>".length).trimStart();
-    if (after) return after;
+    if (after) {
+      text = after;
+    } else {
+      // All content was in the session_state block
+      const before = text.slice(0, text.indexOf("<session_state")).trim();
+      if (before) text = before;
+    }
   }
 
-  // Fallback: look for "context-mode active" header and take everything after it + session_state
-  const cmStart = text.indexOf("context-mode active.");
-  if (cmStart >= 0) {
-    // Find first blank line after </session_state> or end of XML
-    const afterSession = afterSessionState(text);
-    if (afterSession) return afterSession;
+  // 3. Remove "context-mode active." line and everything after until a blank line
+  //    Pattern: "context-mode active. ... Hierarchy: ..." followed by blank line, then real message
+  const cmRe = /context-mode active\.[\s\S]*?\n\s*\n([\s\S]*)$/;
+  const cmMatch = text.match(cmRe);
+  if (cmMatch?.[1]?.trim()) {
+    text = cmMatch[1].trim();
   }
 
-  return text;
-}
-
-function afterSessionState(text: string): string | null {
-  // Try to find the actual user message after context-mode XML injection
-  const patterns = [
-    /context-mode active\.[\s\S]*?<\/session_state>\s*\n+([\s\S]+)$/,
-    /<session_state[\s\S]*?<\/session_state>\s*\n+([\s\S]+)$/,
-  ];
-  for (const re of patterns) {
-    const m = text.match(re);
-    if (m?.[1]?.trim()) return m[1].trim();
+  // 4. If "context-mode" is still the only content, return empty
+  if (text.trim() === "context-mode active." || text.trim().startsWith("context-mode active.")) {
+    const afterCm = text.replace(/context-mode active\.[\s\S]*/, "").trim();
+    if (afterCm) text = afterCm;
   }
-  return null;
+
+  return text.trim() || text;
 }
 
-// ── thinking config mapping ──
+// ── thinking config ──
 
-const DEFAULT_THINKING_BUDGETS: Record<string, number> = {
-  minimal: 1600,
-  low: 4000,
-  medium: 0,
-  high: 0,
-  xhigh: 32000,
+const THINKING_BUDGETS: Record<string, number> = {
+  minimal: 1600, low: 4000, medium: 0, high: 0, xhigh: 32000,
 };
-
-const DEFAULT_EFFORT: Record<string, Effort | undefined> = {
-  minimal: 'low',
-  low: 'low',
-  medium: 'medium',
-  high: 'high',
-  xhigh: 'xhigh',
+const EFFORT_MAP: Record<string, Effort | undefined> = {
+  minimal: "low", low: "low", medium: "medium", high: "high", xhigh: "xhigh",
 };
 
-function buildThinkingConfig(
-  reasoning: string | undefined,
-  thinkingBudgets?: SimpleStreamOptions["thinkingBudgets"],
-): { thinking?: ThinkingConfig; effort?: Effort } {
+function buildThinking(reasoning?: SimpleStreamOptions["reasoning"], budgets?: SimpleStreamOptions["thinkingBudgets"]): { thinking?: ThinkingConfig; effort?: Effort } {
   if (!reasoning) return {};
   if (reasoning === "off") return { thinking: { type: "disabled" } };
-
-  const budget = thinkingBudgets?.[reasoning as keyof typeof thinkingBudgets]
-    ?? DEFAULT_THINKING_BUDGETS[reasoning] ?? 0;
-  const effort = DEFAULT_EFFORT[reasoning];
-
+  const budget = budgets?.[reasoning as keyof typeof budgets] ?? THINKING_BUDGETS[reasoning] ?? 0;
+  const effort = EFFORT_MAP[reasoning];
   if (budget > 0) return { thinking: { type: "enabled", budgetTokens: budget }, effort };
   return { thinking: { type: "adaptive" }, effort };
 }
 
-// ── main provider ──
+// ── usage extraction ──
+
+function extractUsage(msg: CbMessage): Partial<AssistantMessage> | null {
+  if (msg.type !== "result" || !msg.usage) return null;
+  return {
+    usage: {
+      input: msg.usage.input_tokens ?? 0,
+      output: msg.usage.output_tokens ?? 0,
+      cacheRead: msg.usage.cache_read_input_tokens ?? 0,
+      cacheWrite: msg.usage.cache_creation_input_tokens ?? 0,
+      totalTokens:
+        (msg.usage.input_tokens ?? 0) +
+        (msg.usage.output_tokens ?? 0) +
+        (msg.usage.cache_read_input_tokens ?? 0) +
+        (msg.usage.cache_creation_input_tokens ?? 0),
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: msg.total_cost_usd ?? 0 },
+    },
+  };
+}
+
+// ── main ──
 
 export function streamCodebuddy(
-  model: Model<Api>,
+  model: Model<any>,
   context: Context,
   options?: SimpleStreamOptions,
 ): AssistantMessageEventStream {
@@ -194,13 +197,10 @@ export function streamCodebuddy(
     try {
       stream.push({ type: "start", partial });
 
-      const sdk = await loadCodebuddySdk();
-      const userText = extractLatestUserText(context);
+      const sdk = await loadSdk();
+      const userText = extractUserMessage(context);
 
-      const { thinking, effort } = buildThinkingConfig(
-        options?.reasoning,
-        options?.thinkingBudgets,
-      );
+      const { thinking, effort } = buildThinking(options?.reasoning, options?.thinkingBudgets);
 
       const q = sdk.query({
         prompt: userText,
@@ -214,7 +214,7 @@ export function streamCodebuddy(
         },
       });
 
-      // ── abort handling ──
+      // ── abort ──
       let aborted = false;
       const onAbort = async () => {
         if (aborted) return;
@@ -225,86 +225,74 @@ export function streamCodebuddy(
       };
       if (options?.signal) {
         options.signal.addEventListener("abort", onAbort, { once: true });
-        if (options.signal.aborted) {
-          await onAbort();
-          return;
-        }
+        if (options.signal.aborted) { await onAbort(); return; }
       }
 
-      // ── per-index block tracking ──
-      type BlockKind = 'text' | 'thinking' | 'tool_use' | 'redacted_thinking';
+      // ── per-block tracking (for stream_event delta accumulation) ──
+      type BlockKind = "text" | "thinking" | "tool_use" | "redacted_thinking";
       const blockKind = new Map<number, BlockKind>();
       const blockAccum = new Map<number, string>();
       const blockMeta = new Map<number, { id: string; name: string; signature?: string }>();
 
       let hasStreamEvents = false;
 
-      function onBlockStart(idx: number, kind: BlockKind, initText: string, meta?: { id: string; name: string; signature?: string }) {
+      function onStart(idx: number, kind: BlockKind, init: string, meta?: { id: string; name: string; signature?: string }) {
         blockKind.set(idx, kind);
-        blockAccum.set(idx, initText);
+        blockAccum.set(idx, init);
         if (meta) blockMeta.set(idx, meta);
 
-        if (kind === 'redacted_thinking') {
-          const tc: ThinkingContent = { type: 'thinking', thinking: '[redacted]', redacted: true, thinkingSignature: meta?.signature };
+        if (kind === "redacted_thinking") {
+          const tc: ThinkingContent = { type: "thinking", thinking: "[redacted]", redacted: true, thinkingSignature: meta?.signature };
           partial.content = [...partial.content, tc];
-          stream.push({ type: 'thinking_start', contentIndex: idx, partial });
-          stream.push({ type: 'thinking_end', contentIndex: idx, content: '[redacted]', partial });
-        } else if (kind === 'thinking') {
-          const tc: ThinkingContent = { type: 'thinking', thinking: initText, thinkingSignature: meta?.signature };
+          stream.push({ type: "thinking_start", contentIndex: idx, partial });
+          stream.push({ type: "thinking_end", contentIndex: idx, content: "[redacted]", partial });
+        } else if (kind === "thinking") {
+          const tc: ThinkingContent = { type: "thinking", thinking: init, thinkingSignature: meta?.signature };
           partial.content = [...partial.content, tc];
-          stream.push({ type: 'thinking_start', contentIndex: idx, partial });
-        } else if (kind === 'text') {
-          const tb: TextContent = { type: 'text', text: initText };
-          partial.content = [...partial.content, tb];
-          stream.push({ type: 'text_start', contentIndex: idx, partial });
-        } else if (kind === 'tool_use' && meta) {
-          const toolCall: ToolCall = { type: 'toolCall', id: meta.id, name: meta.name, arguments: {} };
-          partial.content = [...partial.content, toolCall];
-          stream.push({ type: 'toolcall_start', contentIndex: idx, partial });
+          stream.push({ type: "thinking_start", contentIndex: idx, partial });
+        } else if (kind === "text") {
+          partial.content = [...partial.content, { type: "text", text: init }];
+          stream.push({ type: "text_start", contentIndex: idx, partial });
+        } else if (kind === "tool_use" && meta) {
+          partial.content = [...partial.content, { type: "toolCall", id: meta.id, name: meta.name, arguments: {} }];
+          stream.push({ type: "toolcall_start", contentIndex: idx, partial });
         }
       }
 
-      function onBlockDelta(idx: number, deltaType: string, deltaValue: string) {
+      function onDelta(idx: number, deltaType: string, value: string) {
         const kind = blockKind.get(idx);
         if (!kind) return;
 
-        if (deltaType === 'text_delta' && kind === 'text') {
-          const newText = (blockAccum.get(idx) || '') + deltaValue;
-          blockAccum.set(idx, newText);
+        if (deltaType === "text_delta" && kind === "text") {
+          const next = (blockAccum.get(idx) || "") + value;
+          blockAccum.set(idx, next);
           const blocks = [...partial.content];
-          blocks[idx] = { type: 'text', text: newText };
+          blocks[idx] = { type: "text", text: next };
           partial.content = blocks;
-          stream.push({ type: 'text_delta', contentIndex: idx, delta: deltaValue, partial });
-        } else if (deltaType === 'thinking_delta' && kind === 'thinking') {
-          const newThinking = (blockAccum.get(idx) || '') + deltaValue;
-          blockAccum.set(idx, newThinking);
+          stream.push({ type: "text_delta", contentIndex: idx, delta: value, partial });
+        } else if (deltaType === "thinking_delta" && kind === "thinking") {
+          const next = (blockAccum.get(idx) || "") + value;
+          blockAccum.set(idx, next);
           const blocks = [...partial.content];
-          blocks[idx] = { type: 'thinking', thinking: newThinking, thinkingSignature: blockMeta.get(idx)?.signature };
+          blocks[idx] = { type: "thinking", thinking: next, thinkingSignature: blockMeta.get(idx)?.signature };
           partial.content = blocks;
-          stream.push({ type: 'thinking_delta', contentIndex: idx, delta: deltaValue, partial });
-        } else if (deltaType === 'input_json_delta' && kind === 'tool_use') {
-          const newJson = (blockAccum.get(idx) || '') + deltaValue;
-          blockAccum.set(idx, newJson);
+          stream.push({ type: "thinking_delta", contentIndex: idx, delta: value, partial });
+        } else if (deltaType === "input_json_delta" && kind === "tool_use") {
+          const json = (blockAccum.get(idx) || "") + value;
+          blockAccum.set(idx, json);
           const blocks = [...partial.content];
-          try {
-            blocks[idx] = { ...blocks[idx], arguments: JSON.parse(newJson) };
-          } catch { /* partial JSON */ }
+          try { blocks[idx] = { ...blocks[idx], arguments: JSON.parse(json) }; } catch { /* partial */ }
           partial.content = blocks;
-          stream.push({ type: 'toolcall_delta', contentIndex: idx, delta: deltaValue, partial } as any);
+          stream.push({ type: "toolcall_delta", contentIndex: idx, delta: value, partial } as any);
         }
       }
 
-      function onBlockStop(idx: number) {
+      function onStop(idx: number) {
         const kind = blockKind.get(idx);
-        const accum = blockAccum.get(idx) || '';
-        if (kind === 'text') {
-          stream.push({ type: 'text_end', contentIndex: idx, content: accum, partial });
-        } else if (kind === 'thinking') {
-          stream.push({ type: 'thinking_end', contentIndex: idx, content: accum, partial });
-        } else if (kind === 'tool_use') {
-          const toolCall = partial.content[idx] as ToolCall;
-          stream.push({ type: 'toolcall_end', contentIndex: idx, toolCall, partial });
-        }
+        const accum = blockAccum.get(idx) || "";
+        if (kind === "text") stream.push({ type: "text_end", contentIndex: idx, content: accum, partial });
+        else if (kind === "thinking") stream.push({ type: "thinking_end", contentIndex: idx, content: accum, partial });
+        else if (kind === "tool_use") stream.push({ type: "toolcall_end", contentIndex: idx, toolCall: partial.content[idx] as ToolCall, partial });
       }
 
       // ── iterate ──
@@ -316,29 +304,24 @@ export function streamCodebuddy(
           continue;
         }
 
+        // Token-level streaming via stream_event (preferred)
         if (msg.type === "stream_event") {
           hasStreamEvents = true;
           const evt = msg.event;
 
           if (evt.type === "content_block_start") {
-            const block = evt.content_block;
-            if (block.type === "text") {
-              onBlockStart(evt.index, 'text', block.text || '');
-            } else if (block.type === "thinking") {
-              onBlockStart(evt.index, 'thinking', block.thinking || '', { id: '', name: '', signature: block.signature });
-            } else if (block.type === "redacted_thinking") {
-              onBlockStart(evt.index, 'redacted_thinking', '[redacted]', { id: '', name: '', signature: block.data });
-            } else if (block.type === "tool_use") {
-              const initJson = JSON.stringify(block.input || {});
-              onBlockStart(evt.index, 'tool_use', initJson, { id: block.id, name: block.name });
-            }
+            const b = evt.content_block;
+            if (b.type === "text") onStart(evt.index, "text", b.text || "");
+            else if (b.type === "thinking") onStart(evt.index, "thinking", b.thinking || "", { id: "", name: "", signature: b.signature });
+            else if (b.type === "redacted_thinking") onStart(evt.index, "redacted_thinking", "[redacted]", { id: "", name: "", signature: b.data });
+            else if (b.type === "tool_use") onStart(evt.index, "tool_use", JSON.stringify(b.input || {}), { id: b.id, name: b.name });
           } else if (evt.type === "content_block_delta") {
             const d = evt.delta;
-            if (d.type === 'text_delta') onBlockDelta(evt.index, 'text_delta', d.text);
-            else if (d.type === 'thinking_delta') onBlockDelta(evt.index, 'thinking_delta', d.thinking);
-            else if (d.type === 'input_json_delta') onBlockDelta(evt.index, 'input_json_delta', d.partial_json);
+            if (d.type === "text_delta") onDelta(evt.index, "text_delta", d.text);
+            else if (d.type === "thinking_delta") onDelta(evt.index, "thinking_delta", d.thinking);
+            else if (d.type === "input_json_delta") onDelta(evt.index, "input_json_delta", d.partial_json);
           } else if (evt.type === "content_block_stop") {
-            onBlockStop(evt.index);
+            onStop(evt.index);
           }
           continue;
         }
@@ -348,25 +331,16 @@ export function streamCodebuddy(
           let ci = 0;
           for (const block of msg.message.content) {
             const idx = ci++;
-            if (block.type === "thinking") {
-              onBlockStart(idx, 'thinking', block.thinking);
-              onBlockStop(idx);
-            } else if (block.type === "redacted_thinking") {
-              onBlockStart(idx, 'redacted_thinking', '[redacted]', { id: '', name: '', signature: block.data });
-            } else if (block.type === "text") {
-              onBlockStart(idx, 'text', block.text);
-              onBlockStop(idx);
-            } else if (block.type === "tool_use") {
-              const initJson = JSON.stringify(block.input ?? {});
-              onBlockStart(idx, 'tool_use', initJson, { id: block.id, name: block.name });
-              onBlockStop(idx);
-            }
+            if (block.type === "thinking") { onStart(idx, "thinking", block.thinking); onStop(idx); }
+            else if (block.type === "redacted_thinking") onStart(idx, "redacted_thinking", "[redacted]", { id: "", name: "", signature: block.data });
+            else if (block.type === "text") { onStart(idx, "text", block.text); onStop(idx); }
+            else if (block.type === "tool_use") { onStart(idx, "tool_use", JSON.stringify(block.input ?? {}), { id: block.id, name: block.name }); onStop(idx); }
           }
         }
 
         if (msg.type === "result") {
-          const usageUpdate = extractUsageUpdate(msg);
-          if (usageUpdate) Object.assign(partial, usageUpdate);
+          const u = extractUsage(msg);
+          if (u) Object.assign(partial, u);
 
           if (msg.subtype === "success") {
             partial.stopReason = "stop";
@@ -380,8 +354,7 @@ export function streamCodebuddy(
         }
       }
     } catch (error) {
-      const errPartial = makeErrorPartial(model, error);
-      stream.push({ type: "error", reason: "error", error: errPartial });
+      stream.push({ type: "error", reason: "error", error: makeErrorPartial(model, error) });
     }
   });