pi-codebuddy-sdk 0.1.18 → 0.3.0

package/src/models.ts

@@ -0,0 +1,72 @@
+// Dynamic model list from CodeBuddy SDK supportedModels().
+
+import type { ModelInfo } from "@tencent-ai/agent-sdk";
+
+export type PiModel = {
+	id: string;
+	name: string;
+	reasoning: boolean;
+	input: ("text" | "image")[];
+	contextWindow: number;
+	maxTokens: number;
+	thinkingLevelMap?: Record<string, string>;
+	cost: { input: number; output: number; cacheRead: number; cacheWrite: number };
+};
+
+const DEFAULT_CONTEXT = 131_072;
+const DEFAULT_MAX_TOKENS = 8192;
+
+function detectThinking(id: string): boolean {
+	return /claude|gemini|gpt-5|hy3|deepseek|glm/i.test(id);
+}
+
+function detectImages(id: string): boolean {
+	return /claude|gemini|gpt/i.test(id);
+}
+
+function estimateContext(id: string): number {
+	const lower = id.toLowerCase();
+	if (lower.includes("gemini")) return 1_048_576;
+	if (lower.includes("claude") || lower.includes("gpt")) return 200_000;
+	return DEFAULT_CONTEXT;
+}
+
+function estimateMaxTokens(id: string): number {
+	if (id.toLowerCase().includes("gpt")) return 16_384;
+	return DEFAULT_MAX_TOKENS;
+}
+
+export function rawModelsFromSdk(supported: Array<ModelInfo & { id?: string; name?: string }>): PiModel[] {
+	return supported
+		.map((m) => ({ id: m.id ?? m.value, name: m.name ?? m.displayName ?? m.id ?? m.value }))
+		.filter((m) => m.id)
+		.map((m) => ({
+		id: m.id!,
+		name: m.name || m.id!,
+		reasoning: detectThinking(m.id!),
+		input: detectImages(m.id!) ? ["text", "image"] as const : ["text"] as const,
+		contextWindow: estimateContext(m.id!),
+		maxTokens: estimateMaxTokens(m.id!),
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	}));
+}
+
+export const FALLBACK_MODELS: PiModel[] = [
+	{ id: "hy3-preview-agent-ioa", name: "Hunyuan 3 Preview", reasoning: true, input: ["text"], contextWindow: DEFAULT_CONTEXT, maxTokens: DEFAULT_MAX_TOKENS, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } },
+];
+
+export function buildModels(models: PiModel[]): PiModel[] {
+	return models.map((m) => ({
+		...m,
+		cost: m.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	}));
+}
+
+export function codebuddyModelId(model: { id: string }): string {
+	return model.id;
+}
+
+export function resolveModel<T extends { id: string }>(models: T[], input: string): T | undefined {
+	const lower = input.toLowerCase();
+	return models.find((m) => m.id === lower || m.id.toLowerCase().includes(lower));
+}

package/src/query-state.ts

@@ -0,0 +1,80 @@
+// Query state: QueryContext class + context stack.
+//
+// All per-query and per-turn mutable state lives here. Reentrant queries
+// (subagents) push the parent context onto a stack and get a fresh instance.
+// Adding a new field = one property on the class.
+//
+// Extracted from index.ts so tests can import without activating the extension.
+
+import type { AssistantMessage, AssistantMessageEventStream, Model } from "@earendil-works/pi-ai";
+import type { McpResult } from "./extract-tool-results.js";
+
+export interface PendingToolCall {
+	toolName: string;
+	resolve: (result: McpResult) => void;
+}
+
+export class QueryContext {
+	// Query-scoped (fully isolated per query)
+	activeQuery: unknown | null = null;
+	currentPiStream: AssistantMessageEventStream | null = null;
+	latestCursor = 0;
+	pendingToolCalls = new Map<string, PendingToolCall>();
+	pendingResults = new Map<string, McpResult>();
+	turnToolCallIds: string[] = [];
+	nextHandlerIdx = 0;
+	deferredUserMessages: string[] = [];
+
+	// Per-turn (reset together)
+	turnOutput: AssistantMessage | null = null;
+	turnStarted = false;
+	turnSawStreamEvent = false;
+	turnSawToolCall = false;
+
+	get turnBlocks(): Array<any> {
+		if (!this.turnOutput) throw new Error("turnBlocks accessed before resetTurnState");
+		return this.turnOutput.content;
+	}
+
+	resetTurnState(model: Model<any>): void {
+		this.turnOutput = {
+			role: "assistant", content: [],
+			api: model.api, provider: model.provider, model: model.id,
+			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+			stopReason: "stop", timestamp: Date.now(),
+		};
+		this.turnStarted = false;
+		this.turnSawStreamEvent = false;
+		this.turnSawToolCall = false;
+		// turnToolCallIds and nextHandlerIdx are NOT reset — they persist across
+		// tool-result delivery callbacks within the same assistant message.
+	}
+}
+
+let _ctx = new QueryContext();
+const contextStack: QueryContext[] = [];
+
+export function ctx(): QueryContext { return _ctx; }
+
+export function stackDepth(): number { return contextStack.length; }
+
+export function pushContext(): void {
+	if (!_ctx.activeQuery) throw new Error("pushContext() called with no active query");
+	contextStack.push(_ctx);
+	_ctx = new QueryContext();
+}
+
+export function popContext(): void {
+	if (contextStack.length === 0) throw new Error("popContext() called with empty stack");
+	const parent = contextStack[contextStack.length - 1];
+	parent.deferredUserMessages.push(..._ctx.deferredUserMessages);
+	_ctx = contextStack.pop()!;
+}
+
+// Test-only: drop all state so test files can start from a clean module.
+// Not called from production.
+export function resetStack(): void {
+	_ctx = new QueryContext();
+	contextStack.length = 0;
+}

package/src/sdk-gate.ts

@@ -0,0 +1,17 @@
+// Serialize CodeBuddy SDK query() subprocesses — only one CLI at a time.
+
+let chain: Promise<void> = Promise.resolve();
+
+export function withSdkGate<T>(fn: () => Promise<T>): Promise<T> {
+	const run = chain.then(fn);
+	chain = run.then(() => undefined, () => undefined);
+	return run;
+}
+
+export async function drainQuery(q: AsyncIterable<unknown>): Promise<void> {
+	const timer = new Promise<void>((r) => setTimeout(r, 5000));
+	await Promise.race([
+		(async () => { for await (const _ of q) { /* drain */ } })(),
+		timer,
+	]);
+}

package/src/session-verify.ts

@@ -0,0 +1,38 @@
+// Pure session-file integrity check. Returns an array of warning strings;
+// callers decide how to surface them (debug log, piUI, diagDump, etc.).
+// Extracted from index.ts so tests can import without activating the extension.
+
+import { statSync, readFileSync } from "fs";
+
+export function verifyWrittenSession(jsonlPath: string, expectedSessionId: string, expectedRecordCount: number): string[] {
+	const warnings = [];
+	let st;
+	try {
+		st = statSync(jsonlPath);
+	} catch (e) {
+		warnings.push(`file missing after save — path=${jsonlPath} err=${e.message}`);
+		return warnings;
+	}
+	let content;
+	try {
+		content = readFileSync(jsonlPath, "utf8");
+	} catch (e) {
+		warnings.push(`file unreadable — path=${jsonlPath} size=${st.size} err=${e.message}`);
+		return warnings;
+	}
+	const lines = content.split("\n").filter((l) => l.trim().length > 0);
+	if (lines.length !== expectedRecordCount) {
+		warnings.push(`record count mismatch — expected=${expectedRecordCount} actual=${lines.length} path=${jsonlPath} bytes=${content.length}`);
+		return warnings;
+	}
+	try {
+		const firstRec = JSON.parse(lines[0]);
+		const lastRec = JSON.parse(lines[lines.length - 1]);
+		if (firstRec.sessionId !== expectedSessionId || lastRec.sessionId !== expectedSessionId) {
+			warnings.push(`sessionId drift — expected=${expectedSessionId} first=${firstRec.sessionId} last=${lastRec.sessionId}`);
+		}
+	} catch (e) {
+		warnings.push(`malformed JSONL — path=${jsonlPath} err=${e.message}`);
+	}
+	return warnings;
+}

package/src/skills.ts

@@ -0,0 +1,73 @@
+// Skills block extraction + MCP naming constants.
+// Extracted from index.ts so tests can import without activating the extension.
+
+import { extractAgentsAppend } from "./agents-md.js";
+
+export const MCP_SERVER_NAME = "custom_tools";
+export const MCP_TOOL_PREFIX = `mcp__${MCP_SERVER_NAME}__`;
+
+const SKILLS_START_MARKER = "The following skills provide specialized instructions for specific tasks.";
+const SKILLS_END_MARKER = "</available_skills>";
+
+// Extract skills block from pi's system prompt for forwarding to CodeBuddy.
+export function extractSkillsBlock(systemPrompt?: string): string | undefined {
+	if (!systemPrompt) return undefined;
+	const startMarker = SKILLS_START_MARKER;
+	const endMarker = SKILLS_END_MARKER;
+	const start = systemPrompt.indexOf(startMarker);
+	if (start === -1) return undefined;
+	const end = systemPrompt.indexOf(endMarker, start);
+	if (end === -1) return undefined;
+	return rewriteSkillsBlock(systemPrompt.slice(start, end + endMarker.length).trim());
+}
+
+export function rewriteSkillsBlock(skillsBlock: string): string {
+	return skillsBlock.replace(
+		"Use the read tool to load a skill's file",
+		`Use the read tool (mcp__${MCP_SERVER_NAME}__read) to load a skill's file`,
+	);
+}
+
+function stripSkillsBlock(systemPrompt: string): string {
+	const start = systemPrompt.indexOf(SKILLS_START_MARKER);
+	if (start === -1) return systemPrompt;
+	const end = systemPrompt.indexOf(SKILLS_END_MARKER, start);
+	if (end === -1) return systemPrompt;
+	return (systemPrompt.slice(0, start) + systemPrompt.slice(end + SKILLS_END_MARKER.length))
+		.replace(/\n{3,}/g, "\n\n")
+		.trim();
+}
+
+function applySkillsRewrite(systemPrompt: string): string {
+	const rewritten = extractSkillsBlock(systemPrompt);
+	if (!rewritten) return systemPrompt;
+	const start = systemPrompt.indexOf(SKILLS_START_MARKER);
+	const end = systemPrompt.indexOf(SKILLS_END_MARKER, start);
+	if (start === -1 || end === -1) return systemPrompt;
+	return systemPrompt.slice(0, start) + rewritten + systemPrompt.slice(end + SKILLS_END_MARKER.length);
+}
+
+/** Pi system prompt as CodeBuddy override (replaces default "CodeBuddy Code" identity). */
+export function buildCodebuddySystemPrompt(
+	piSystemPrompt: string | undefined,
+	options?: { includeAgents?: boolean; includeSkills?: boolean },
+): string | undefined {
+	const parts: string[] = [];
+
+	if (piSystemPrompt) {
+		let prompt = piSystemPrompt;
+		if (options?.includeSkills === false) {
+			prompt = stripSkillsBlock(prompt);
+		} else {
+			prompt = applySkillsRewrite(prompt);
+		}
+		if (prompt) parts.push(prompt);
+	}
+
+	if (options?.includeAgents !== false) {
+		const agents = extractAgentsAppend();
+		if (agents) parts.push(agents);
+	}
+
+	return parts.length > 0 ? parts.join("\n\n") : undefined;
+}

package/src/typebox-to-zod.ts

@@ -0,0 +1,42 @@
+// TypeBox (JSON Schema) → Zod conversion used by buildMcpServers.
+//
+// Pi tools declare their parameters as TypeBox objects (i.e. JSON Schema at
+// runtime). The Agent SDK's createSdkMcpServer requires Zod — its internal
+// `Z0()` detects Zod via the `~standard` marker or `_def`/`_zod` properties
+// and silently downgrades unrecognized schemas to
+// `{type: "object", properties: {}}`, which leaves the model with no
+// parameter info. This module bridges the two so MCP-exposed pi tools retain
+// their schemas. If this breaks after an SDK update, check whether `Z0()`
+// detection changed or createSdkMcpServer now accepts raw JSON Schema.
+
+import { z } from "zod";
+
+export function jsonSchemaPropertyToZod(prop: Record<string, unknown>): z.ZodTypeAny {
+	let base: z.ZodTypeAny;
+	if (Array.isArray(prop.enum)) base = z.enum(prop.enum as [string, ...string[]]);
+	else switch (prop.type) {
+		case "string": base = z.string(); break;
+		case "number": case "integer": base = z.number(); break;
+		case "boolean": base = z.boolean(); break;
+		case "array": base = prop.items
+			? z.array(jsonSchemaPropertyToZod(prop.items as Record<string, unknown>))
+			: z.array(z.unknown()); break;
+		case "object": base = z.record(z.string(), z.unknown()); break;
+		default: base = z.unknown();
+	}
+	if (typeof prop.description === "string") base = base.describe(prop.description);
+	return base;
+}
+
+export function jsonSchemaToZodShape(schema: unknown): Record<string, z.ZodTypeAny> {
+	const s = schema as Record<string, unknown>;
+	if (!s || s.type !== "object" || !s.properties) return {};
+	const props = s.properties as Record<string, Record<string, unknown>>;
+	const required = new Set(Array.isArray(s.required) ? s.required as string[] : []);
+	const shape: Record<string, z.ZodTypeAny> = {};
+	for (const [key, prop] of Object.entries(props)) {
+		const zodProp = jsonSchemaPropertyToZod(prop);
+		shape[key] = required.has(key) ? zodProp : zodProp.optional();
+	}
+	return shape;
+}

package/src/provider.ts

@@ -1,289 +0,0 @@
-/**
- * Provider entry point — pi-claude-bridge pattern.
- *
- * For each Pi turn:
- * 1. Extract the latest user message
- * 2. Call sdk.query() — stateless, CodeBuddy uses its own system prompt
- * 3. Stream events back to Pi (text, thinking, toolcalls)
- */
-import {
-  createAssistantMessageEventStream,
-  type AssistantMessage,
-  type AssistantMessageEventStream,
-  type Context,
-  type Model,
-  type SimpleStreamOptions,
-  type TextContent,
-  type ThinkingContent,
-  type ToolCall,
-} from "@earendil-works/pi-ai/compat";
-import type {
-  Effort,
-  Message as CbMessage,
-  ThinkingConfig,
-} from "@tencent-ai/agent-sdk";
-
-type CodebuddySdk = typeof import("@tencent-ai/agent-sdk");
-
-async function loadSdk(): Promise<CodebuddySdk> {
-  return import("@tencent-ai/agent-sdk");
-}
-
-// ── helpers ──
-
-function makePartial(model: Model<any>): AssistantMessage {
-  return {
-    role: "assistant",
-    content: [],
-    api: model.api,
-    provider: model.provider,
-    model: model.id,
-    usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
-    stopReason: "stop",
-    timestamp: Date.now(),
-  };
-}
-
-function makeErrorPartial(model: Model<any>, error: unknown): AssistantMessage {
-  return {
-    ...makePartial(model),
-    stopReason: "error",
-    errorMessage: error instanceof Error ? error.message : String(error),
-  };
-}
-
-// ── extract user message ──
-
-function extractUserMessage(context: Context): string {
-  const msgs = context.messages;
-  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) return raw.trim();
-  }
-  return "Continue.";
-}
-
-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 as string)
-    .join("\n");
-}
-
-// ── thinking config ──
-
-const THINKING_BUDGETS: Record<string, number> = {
-  minimal: 1600, low: 4000, medium: 0, high: 0, xhigh: 32000,
-};
-const EFFORT_MAP: Record<string, Effort | undefined> = {
-  minimal: "low", low: "low", medium: "medium", high: "high", xhigh: "xhigh",
-};
-
-function buildThinking(reasoning?: SimpleStreamOptions["reasoning"], budgets?: SimpleStreamOptions["thinkingBudgets"]): { thinking?: ThinkingConfig; effort?: Effort } {
-  if (!reasoning) return {};
-  if (reasoning === "off") return { thinking: { type: "disabled" } };
-  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 };
-}
-
-// ── 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<any>,
-  context: Context,
-  options?: SimpleStreamOptions,
-): AssistantMessageEventStream {
-  const stream = createAssistantMessageEventStream();
-  const partial = makePartial(model);
-
-  queueMicrotask(async () => {
-    try {
-      stream.push({ type: "start", partial });
-
-      const sdk = await loadSdk();
-      const userText = extractUserMessage(context);
-
-      const { thinking, effort } = buildThinking(options?.reasoning, options?.thinkingBudgets);
-
-      const q = sdk.query({
-        prompt: userText,
-        options: {
-          model: model.id,
-          permissionMode: "bypassPermissions",
-          maxTurns: 100,
-          thinking,
-          effort,
-          includePartialMessages: true,
-        },
-      });
-
-      // ── abort ──
-      let aborted = false;
-      const onAbort = async () => {
-        if (aborted) return;
-        aborted = true;
-        try { await q.interrupt(); } catch { /* best-effort */ }
-        partial.stopReason = "aborted";
-        stream.push({ type: "error", reason: "aborted", error: partial });
-      };
-      if (options?.signal) {
-        options.signal.addEventListener("abort", onAbort, { once: true });
-        if (options.signal.aborted) { await onAbort(); return; }
-      }
-
-      // ── per-block tracking ──
-      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 onStart(idx: number, kind: BlockKind, init: string, meta?: { id: string; name: string; signature?: string }) {
-        blockKind.set(idx, kind);
-        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 };
-          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: init, thinkingSignature: meta?.signature };
-          partial.content = [...partial.content, tc];
-          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 onDelta(idx: number, deltaType: string, value: string) {
-        const kind = blockKind.get(idx);
-        if (!kind) return;
-
-        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: next };
-          partial.content = blocks;
-          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: next, thinkingSignature: blockMeta.get(idx)?.signature };
-          partial.content = blocks;
-          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(json) }; } catch { /* partial */ }
-          partial.content = blocks;
-          stream.push({ type: "toolcall_delta", contentIndex: idx, delta: value, partial } as any);
-        }
-      }
-
-      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") stream.push({ type: "toolcall_end", contentIndex: idx, toolCall: partial.content[idx] as ToolCall, partial });
-      }
-
-      // ── iterate ──
-      for await (const msg of q) {
-        if (aborted) return;
-
-        if (msg.type === "system") {
-          if (msg.model) partial.responseModel = msg.model;
-          continue;
-        }
-
-        if (msg.type === "stream_event") {
-          hasStreamEvents = true;
-          const evt = msg.event;
-
-          if (evt.type === "content_block_start") {
-            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") 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") {
-            onStop(evt.index);
-          }
-          continue;
-        }
-
-        // Fallback: full assistant messages (when model doesn't support streaming)
-        if (msg.type === "assistant" && !hasStreamEvents) {
-          let ci = 0;
-          for (const block of msg.message.content) {
-            const idx = ci++;
-            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 u = extractUsage(msg);
-          if (u) Object.assign(partial, u);
-
-          if (msg.subtype === "success") {
-            partial.stopReason = "stop";
-            stream.push({ type: "done", reason: "stop", message: { ...partial } });
-          } else {
-            partial.stopReason = "error";
-            partial.errorMessage = msg.errors?.join("; ") ?? `CodeBuddy error: ${msg.subtype}`;
-            stream.push({ type: "error", reason: "error", error: { ...partial } });
-          }
-          break;
-        }
-      }
-    } catch (error) {
-      stream.push({ type: "error", reason: "error", error: makeErrorPartial(model, error) });
-    }
-  });
-
-  return stream;
-}