@kontextmind/kxm 0.7.17 → 0.7.18

package/plugins/kxm/src/providers/claude-bridge/convert.ts

@@ -0,0 +1,180 @@
+// @ts-nocheck — vendored snapshot; host tsconfig is stricter than upstream.
+import type { ImageContent, Message, TextContent, UserMessage } from "./pi-compat.ts";
+import { PROVIDER_ID } from "./models.ts";
+import { MCP_TOOL_PREFIX, mapPiToolNameToSdk, sanitizeToolId } from "./tools.ts";
+
+export { PROVIDER_ID };
+
+export function messageContentToText(
+  content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  let hasText = false;
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      parts.push(block.text);
+      hasText = true;
+    } else if (block.type !== "text" && block.type !== "image") {
+      parts.push(`[${block.type}]`);
+    }
+  }
+  return hasText ? parts.join("\n") : "";
+}
+
+function toolResultContent(
+  content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): string | Array<Record<string, unknown>> {
+  if (typeof content === "string" || !Array.isArray(content)) return messageContentToText(content) || "";
+  const images = content.filter((b) => b.type === "image" && b.data && b.mimeType);
+  if (!images.length) return messageContentToText(content) || "";
+  const blocks: Array<Record<string, unknown>> = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) blocks.push({ type: "text", text: block.text });
+    else if (block.type === "image" && block.data && block.mimeType) {
+      blocks.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+    } else if (block.type !== "text" && block.type !== "image") {
+      blocks.push({ type: "text", text: `[${block.type}]` });
+    }
+  }
+  return blocks;
+}
+
+export type DroppedContent = {
+  thinking: number;
+  abortedTurns: number;
+  providers: Set<string>;
+  other: Map<string, number>;
+};
+
+export type AnthropicMessage = { role: string; content: unknown };
+
+export function convertPiMessages(
+  messages: Message[],
+  customToolNameToSdk?: Map<string, string>,
+): { anthropicMessages: AnthropicMessage[]; sanitizedIds: Map<string, string>; dropped: DroppedContent } {
+  const anthropicMessages: AnthropicMessage[] = [];
+  const sanitizedIds = new Map<string, string>();
+  const dropped: DroppedContent = { thinking: 0, abortedTurns: 0, providers: new Set(), other: new Map() };
+  let turnResults: { role: "user"; content: Array<Record<string, unknown>> } | null = null;
+  let turnAssistantIdx: number | null = null;
+
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        anthropicMessages.push({ role: "user", content: msg.content || "[empty]" });
+      } else if (Array.isArray(msg.content)) {
+        const parts = [];
+        for (const block of msg.content) {
+          if (block.type === "text" && block.text) parts.push({ type: "text", text: block.text });
+          else if (block.type === "image" && block.data && block.mimeType) {
+            parts.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+          }
+        }
+        anthropicMessages.push({ role: "user", content: parts.length ? parts : "[image]" });
+      } else {
+        anthropicMessages.push({ role: "user", content: "[empty]" });
+      }
+    } else if (msg.role === "assistant") {
+      const content = Array.isArray(msg.content) ? msg.content : [];
+      const blocks = [];
+      for (const block of content) {
+        if (block.type === "text" && block.text) {
+          blocks.push({ type: "text", text: block.text });
+        } else if (block.type === "thinking") {
+          const sig = block.thinkingSignature;
+          if (msg.provider === PROVIDER_ID && sig) {
+            blocks.push({ type: "thinking", thinking: block.thinking ?? "", signature: sig });
+          } else {
+            dropped.thinking++;
+            dropped.providers.add(msg.provider ?? "unknown");
+          }
+        } else if (block.type === "toolCall") {
+          const toolName = mapPiToolNameToSdk(block.name, customToolNameToSdk);
+          blocks.push({
+            type: "tool_use",
+            id: sanitizeToolId(block.id, sanitizedIds),
+            name: toolName,
+            input: block.arguments ?? {},
+          });
+        } else {
+          dropped.other.set(block.type, (dropped.other.get(block.type) ?? 0) + 1);
+        }
+      }
+      if (!content.length) {
+        dropped.abortedTurns++;
+        continue;
+      }
+      if (!blocks.length) blocks.push({ type: "text", text: "[incompatible content omitted]" });
+      turnResults = null;
+      turnAssistantIdx = anthropicMessages.length;
+      anthropicMessages.push({ role: "assistant", content: blocks });
+    } else if (msg.role === "toolResult") {
+      const block = {
+        type: "tool_result",
+        tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds),
+        content: toolResultContent(msg.content),
+        is_error: msg.isError,
+      };
+      if (turnResults) {
+        turnResults.content.push(block);
+      } else {
+        turnResults = { role: "user", content: [block] };
+        anthropicMessages.splice(turnAssistantIdx === null ? anthropicMessages.length : turnAssistantIdx + 1, 0, turnResults);
+      }
+    }
+  }
+
+  return { anthropicMessages, sanitizedIds, dropped };
+}
+
+export function turnStart(messages: Message[]): number {
+  let i = messages.length;
+  while (i > 0 && messages[i - 1].role === "user") i--;
+  return i;
+}
+
+export function extractUserPrompt(messages: Message[]): string | null {
+  const turn = messages.slice(turnStart(messages)) as UserMessage[];
+  if (turn.length === 0) return null;
+  return turn
+    .map((m) => (typeof m.content === "string" ? m.content : messageContentToText(m.content)))
+    .filter((text) => text)
+    .join("\n");
+}
+
+export function extractUserPromptBlocks(
+  messages: Message[],
+): Array<{ type: "text"; text: string } | { type: "image"; source: { type: "base64"; media_type: string; data: string } }> | null {
+  const turn = messages.slice(turnStart(messages)) as UserMessage[];
+  if (turn.length === 0) return null;
+  let hasImage = false;
+  const blocks = [];
+  for (const message of turn) {
+    const content: Array<TextContent | ImageContent> =
+      typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
+    if (!Array.isArray(content)) {
+      throw new Error(
+        `extractUserPromptBlocks: user message content must be a string or block array, got ${typeof content}`,
+      );
+    }
+    for (const block of content) {
+      if (block.type === "text" && block.text) {
+        blocks.push({ type: "text", text: block.text });
+      } else if (block.type === "image") {
+        if (!block.data || !block.mimeType) continue;
+        hasImage = true;
+        blocks.push({
+          type: "image",
+          source: { type: "base64" as const, media_type: block.mimeType, data: block.data },
+        });
+      }
+    }
+  }
+  return hasImage ? blocks : null;
+}
+
+export function alreadySdkToolName(name: string): boolean {
+  return name.toLowerCase().startsWith(MCP_TOOL_PREFIX);
+}

package/plugins/kxm/src/providers/claude-bridge/index.ts

@@ -0,0 +1,28 @@
+export {
+  CLAUDE_BRIDGE_API,
+  CLAUDE_BRIDGE_MODELS,
+  MODEL_IDS_IN_ORDER,
+  PROVIDER_ID,
+  PROVIDER_NAME,
+  applyLongContext,
+  claudeCodeModelId,
+  registeredClaudeBridgeModels,
+  resolveClaudeCodeRuntimeModel,
+  resolveEffort,
+  resolveModel,
+  REASONING_TO_EFFORT,
+} from "./models.ts";
+export {
+  CLAUDE_BRIDGE_DOUBLE_REGISTRATION_WARNING,
+  CLAUDE_BRIDGE_HOST_PROBE_METHODS,
+  STANDALONE_CLAUDE_BRIDGE_TOOLS,
+  claudeBridgeRegistrationNotice,
+  claudeBridgeStandaloneToolsPresent,
+  registerClaudeBridgeProvider,
+  shouldSkipClaudeBridgeRegistration,
+  type ClaudeBridgeRegistration,
+} from "./register.ts";
+export { consumeQuery, processAssistantMessage, processStreamEvent } from "./stream.ts";
+export { streamClaudeBridge, resetClaudeBridgeSession } from "./provider.ts";
+export { convertPiMessages } from "./convert.ts";
+export { looksLikeClaudeBridgeSecret, redactClaudeBridgeSecrets } from "./redact.ts";

package/plugins/kxm/src/providers/claude-bridge/mcp-server.ts

@@ -0,0 +1,59 @@
+// @ts-nocheck — vendored snapshot; host tsconfig is stricter than upstream.
+// In-process MCP server that exposes pi tools to Claude Code.
+// From pi-claude-bridge 0.7.0. Not a user-facing MCP product.
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import type { McpResult } from "./tools.ts";
+
+const TOOL_USE_ID_META = "claudecode/toolUseId";
+
+export interface McpToolDef {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+  handler: (toolCallId: string) => Promise<McpResult>;
+}
+
+export function assertObjectSchema(tool: McpToolDef): void {
+  const schema = tool.inputSchema as Record<string, unknown> | undefined;
+  if (!schema || schema.type !== "object") {
+    throw new Error(`${tool.name}: MCP tool parameters must be an object schema, got ${JSON.stringify(schema)}`);
+  }
+}
+
+export function createToolServer(name: string, tools: McpToolDef[]) {
+  const server = new McpServer({ name, version: "1.0.0" }, { capabilities: { tools: {} } });
+  const byName = new Map(tools.map((tool) => [tool.name, tool]));
+  for (const tool of tools) assertObjectSchema(tool);
+
+  server.server.setRequestHandler(ListToolsRequestSchema, () => ({
+    tools: tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema as Record<string, unknown>,
+    })),
+  }));
+
+  server.server.setRequestHandler(CallToolRequestSchema, async (request) => dispatchToolCall(byName, request));
+
+  return { type: "sdk" as const, name, instance: server };
+}
+
+export async function dispatchToolCall(
+  byName: Map<string, McpToolDef>,
+  request: { params: { name: string; _meta?: Record<string, unknown> } },
+) {
+  const tool = byName.get(request.params.name);
+  if (!tool) throw new Error(`Unknown tool: ${request.params.name}`);
+  const toolCallId = request.params._meta?.[TOOL_USE_ID_META];
+  if (typeof toolCallId !== "string") {
+    throw new Error(
+      `${tool.name}: tools/call is missing _meta["${TOOL_USE_ID_META}"] — cannot pair the result with its tool call`,
+    );
+  }
+  const { content, isError } = await tool.handler(toolCallId);
+  return { content, isError };
+}
+
+export { TOOL_USE_ID_META };

package/plugins/kxm/src/providers/claude-bridge/models.ts

@@ -0,0 +1,166 @@
+// Canonical selection + display order for the model picker.
+// Extracted from pi-claude-bridge 0.7.0; catalog is static (no pi-ai getModels).
+
+import type { Model, ProviderModelConfig, ThinkingLevel, ThinkingLevelMap } from "./pi-compat.ts";
+
+export const PROVIDER_ID = "claude-bridge";
+export const PROVIDER_NAME = "Claude Bridge";
+export const CLAUDE_BRIDGE_API = "claude-bridge";
+
+export const MODEL_IDS_IN_ORDER = [
+  "claude-fable-5-1",
+  "claude-fable-5",
+  "claude-opus-5",
+  "claude-opus-4-8",
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  "claude-sonnet-5",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5",
+] as const;
+
+export type ClaudeBridgeModelId = (typeof MODEL_IDS_IN_ORDER)[number];
+
+const DISPLAY_NAMES: Record<ClaudeBridgeModelId, string> = {
+  "claude-fable-5-1": "Claude Fable 5.1",
+  "claude-fable-5": "Claude Fable 5",
+  "claude-opus-5": "Claude Opus 5",
+  "claude-opus-4-8": "Claude Opus 4.8",
+  "claude-opus-4-7": "Claude Opus 4.7",
+  "claude-opus-4-6": "Claude Opus 4.6",
+  "claude-sonnet-5": "Claude Sonnet 5",
+  "claude-sonnet-4-6": "Claude Sonnet 4.6",
+  "claude-haiku-4-5": "Claude Haiku 4.5",
+};
+
+/** Per-model effort overrides (pi-ai 0.72+ shipped these for later Opus). */
+const THINKING_LEVEL_MAPS: Partial<Record<ClaudeBridgeModelId, ThinkingLevelMap>> = {
+  "claude-opus-4-8": { xhigh: "xhigh", max: "max" },
+  "claude-opus-4-7": { xhigh: "xhigh", max: "max" },
+  "claude-opus-5": { xhigh: "xhigh", max: "max" },
+};
+
+export type LongContextSettings = {
+  plan: "pro" | "max";
+  longContextExtraUsage: boolean;
+};
+
+export type ClaudeCodeRuntimeModel = {
+  cliModelId: string;
+  contextWindow: number;
+};
+
+const TWO_HUNDRED_K_CONTEXT = 200_000;
+const ONE_M_CONTEXT = 1_000_000;
+
+export const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } as const;
+
+export const DEFAULT_LONG_CONTEXT: LongContextSettings = {
+  plan: "pro",
+  longContextExtraUsage: false,
+};
+
+/** Pi reasoning levels → Claude Agent SDK effort levels. */
+export const REASONING_TO_EFFORT: Record<string, string> = {
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "max",
+};
+
+export function resolveEffort(
+  reasoning: ThinkingLevel | undefined,
+  thinkingLevelMap?: ThinkingLevelMap,
+): string | undefined {
+  if (!reasoning) return undefined;
+  const mapped = thinkingLevelMap?.[reasoning];
+  if (typeof mapped === "string") return mapped;
+  return REASONING_TO_EFFORT[reasoning];
+}
+
+export function resolveClaudeCodeRuntimeModel(
+  modelId: string,
+  settings: LongContextSettings,
+): ClaudeCodeRuntimeModel {
+  switch (modelId) {
+    case "claude-opus-5":
+      return { cliModelId: "claude-opus-5[1m]", contextWindow: ONE_M_CONTEXT };
+    case "claude-opus-4-8":
+      return { cliModelId: "claude-opus-4-8[1m]", contextWindow: ONE_M_CONTEXT };
+    case "claude-opus-4-7":
+      return { cliModelId: "claude-opus-4-7", contextWindow: ONE_M_CONTEXT };
+    case "claude-opus-4-6": {
+      const useOneM = settings.plan === "max" || settings.longContextExtraUsage;
+      return {
+        cliModelId: useOneM ? "claude-opus-4-6[1m]" : "claude-opus-4-6",
+        contextWindow: useOneM ? ONE_M_CONTEXT : TWO_HUNDRED_K_CONTEXT,
+      };
+    }
+    case "claude-fable-5-1":
+      return { cliModelId: "claude-fable-5-1[1m]", contextWindow: ONE_M_CONTEXT };
+    case "claude-fable-5":
+      return { cliModelId: "claude-fable-5[1m]", contextWindow: ONE_M_CONTEXT };
+    case "claude-sonnet-5":
+      return { cliModelId: "claude-sonnet-5[1m]", contextWindow: ONE_M_CONTEXT };
+    case "claude-sonnet-4-6":
+      return {
+        cliModelId: settings.longContextExtraUsage ? "claude-sonnet-4-6[1m]" : "claude-sonnet-4-6",
+        contextWindow: settings.longContextExtraUsage ? ONE_M_CONTEXT : TWO_HUNDRED_K_CONTEXT,
+      };
+    case "claude-haiku-4-5":
+      return { cliModelId: "claude-haiku-4-5", contextWindow: TWO_HUNDRED_K_CONTEXT };
+    default:
+      return { cliModelId: modelId, contextWindow: TWO_HUNDRED_K_CONTEXT };
+  }
+}
+
+export function claudeCodeModelId(model: { id: string }, settings: LongContextSettings): string {
+  return resolveClaudeCodeRuntimeModel(model.id, settings).cliModelId;
+}
+
+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.includes(lower));
+}
+
+export function applyLongContext<T extends { id: string; name: string; contextWindow?: number | null }>(
+  models: T[],
+  settings: LongContextSettings,
+): T[] {
+  return models.map((m) => {
+    const { contextWindow } = resolveClaudeCodeRuntimeModel(m.id, settings);
+    const name =
+      contextWindow > TWO_HUNDRED_K_CONTEXT && !/\b1M\b/i.test(m.name) ? `${m.name} 1M` : m.name;
+    return contextWindow === m.contextWindow && name === m.name ? m : { ...m, contextWindow, name };
+  });
+}
+
+function staticModel(id: ClaudeBridgeModelId): ProviderModelConfig {
+  const runtime = resolveClaudeCodeRuntimeModel(id, DEFAULT_LONG_CONTEXT);
+  const name = DISPLAY_NAMES[id];
+  const thinkingLevelMap = THINKING_LEVEL_MAPS[id];
+  return {
+    id,
+    name: runtime.contextWindow > TWO_HUNDRED_K_CONTEXT && !/\b1M\b/i.test(name) ? `${name} 1M` : name,
+    reasoning: true,
+    input: ["text", "image"],
+    cost: { ...ZERO_COST },
+    contextWindow: runtime.contextWindow,
+    maxTokens: 32_000,
+    ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
+  };
+}
+
+export const CLAUDE_BRIDGE_MODELS: ProviderModelConfig[] = MODEL_IDS_IN_ORDER.map(staticModel);
+
+export function registeredClaudeBridgeModels(
+  settings: LongContextSettings = DEFAULT_LONG_CONTEXT,
+): Model[] {
+  return applyLongContext(CLAUDE_BRIDGE_MODELS, settings).map((model) => ({
+    ...model,
+    api: CLAUDE_BRIDGE_API,
+    provider: PROVIDER_ID,
+    baseUrl: PROVIDER_ID,
+  }));
+}

package/plugins/kxm/src/providers/claude-bridge/pi-compat.ts

@@ -0,0 +1,215 @@
+/**
+ * Structural Pi stream types used by the vendored claude-bridge provider.
+ * No @earendil-works/pi-ai import (nested copy is forbidden).
+ */
+
+export type Api = string;
+export type ProviderId = string;
+export type ThinkingLevel = "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ModelThinkingLevel = "off" | ThinkingLevel;
+export type ThinkingLevelMap = Partial<Record<ModelThinkingLevel, string | null>>;
+
+export type ModelCostRates = {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+};
+
+export type ModelCost = ModelCostRates;
+
+export type ProviderModelConfig = {
+  id: string;
+  name: string;
+  api?: Api;
+  baseUrl?: string;
+  reasoning: boolean;
+  thinkingLevelMap?: ThinkingLevelMap;
+  input: Array<"text" | "image">;
+  cost: ModelCost;
+  contextWindow: number;
+  maxTokens: number;
+};
+
+export type Model<TApi extends Api = Api> = ProviderModelConfig & {
+  api: TApi;
+  provider: ProviderId;
+  baseUrl: string;
+};
+
+export type TextContent = {
+  type: "text";
+  text: string;
+  textSignature?: string;
+};
+
+export type ThinkingContent = {
+  type: "thinking";
+  thinking: string;
+  thinkingSignature?: string;
+  redacted?: boolean;
+};
+
+export type ImageContent = {
+  type: "image";
+  data: string;
+  mimeType: string;
+};
+
+export type ToolCall = {
+  type: "toolCall";
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+  thoughtSignature?: string;
+};
+
+export type Usage = {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  reasoning?: number;
+  totalTokens: number;
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+  };
+};
+
+export type StopReason = "pending" | "stop" | "length" | "toolUse" | "error" | "aborted" | "deferred";
+
+export type UserMessage = {
+  role: "user";
+  content: string | Array<TextContent | ImageContent>;
+  timestamp: number;
+};
+
+export type AssistantMessage = {
+  role: "assistant";
+  content: Array<TextContent | ThinkingContent | ToolCall>;
+  api: Api;
+  provider: ProviderId;
+  model: string;
+  usage: Usage;
+  stopReason: StopReason;
+  errorMessage?: string;
+  timestamp: number;
+};
+
+export type ToolResultMessage = {
+  role: "toolResult";
+  toolCallId: string;
+  toolName?: string;
+  content: string | Array<TextContent | ImageContent>;
+  isError?: boolean;
+  timestamp?: number;
+};
+
+export type Message = UserMessage | AssistantMessage | ToolResultMessage;
+
+export type Tool = {
+  name: string;
+  description: string;
+  parameters: unknown;
+};
+
+export type Context = {
+  systemPrompt?: string;
+  messages: Message[];
+  tools?: Tool[];
+};
+
+export type AssistantMessageEvent =
+  | { type: "start"; partial: AssistantMessage }
+  | { type: "text_start"; contentIndex: number; partial: AssistantMessage }
+  | { type: "text_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
+  | { type: "text_end"; contentIndex: number; content: string; partial: AssistantMessage }
+  | { type: "thinking_start"; contentIndex: number; partial: AssistantMessage }
+  | { type: "thinking_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
+  | { type: "thinking_end"; contentIndex: number; content: string; partial: AssistantMessage }
+  | { type: "toolcall_start"; contentIndex: number; partial: AssistantMessage }
+  | { type: "toolcall_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
+  | { type: "toolcall_end"; contentIndex: number; toolCall: ToolCall; partial: AssistantMessage }
+  | { type: "done"; reason: StopReason; message: AssistantMessage }
+  | { type: "error"; reason: StopReason; error: AssistantMessage };
+
+export class AssistantMessageEventStream {
+  queue: AssistantMessageEvent[] = [];
+  waiting: Array<(result: { value?: AssistantMessageEvent; done: boolean }) => void> = [];
+  done = false;
+  finalResultPromise: Promise<AssistantMessage>;
+  private resolveFinalResult!: (message: AssistantMessage) => void;
+
+  constructor() {
+    this.finalResultPromise = new Promise((resolve) => {
+      this.resolveFinalResult = resolve;
+    });
+  }
+
+  push(event: AssistantMessageEvent): void {
+    if (this.done) return;
+    if (event.type === "done") {
+      this.done = true;
+      this.resolveFinalResult(event.message);
+    } else if (event.type === "error") {
+      this.done = true;
+      this.resolveFinalResult(event.error);
+    }
+    const waiter = this.waiting.shift();
+    if (waiter) waiter({ value: event, done: false });
+    else this.queue.push(event);
+  }
+
+  end(result?: AssistantMessage): void {
+    this.done = true;
+    if (result !== undefined) this.resolveFinalResult(result);
+    while (this.waiting.length > 0) {
+      this.waiting.shift()?.({ done: true });
+    }
+  }
+
+  async *[Symbol.asyncIterator](): AsyncGenerator<AssistantMessageEvent> {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift()!;
+      } else if (this.done) {
+        return;
+      } else {
+        const next = await new Promise<{ value?: AssistantMessageEvent; done: boolean }>((resolve) => {
+          this.waiting.push(resolve);
+        });
+        if (next.done) return;
+        if (next.value) yield next.value;
+      }
+    }
+  }
+
+  result(): Promise<AssistantMessage> {
+    return this.finalResultPromise;
+  }
+}
+
+export function createAssistantMessageEventStream(): AssistantMessageEventStream {
+  return new AssistantMessageEventStream();
+}
+
+export function emptyUsage(): Usage {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  };
+}
+
+export type SimpleStreamOptions = {
+  signal?: AbortSignal;
+  cwd?: string;
+  reasoning?: ThinkingLevel;
+};