Blame for server/src/providers/commandcode.ts

import type {
  ChatMessage,
  ChatCompletionResponse,
  ChatCompletionChunk,
  ChatToolCall,
  ChatToolDefinition,
} from '@api-gateway/shared/types.js';
import { BaseProvider, providerHttpError, RequestAbortError, type CompletionOptions } from './base.js';
import { contentToString } from '../lib/content.js';

const NPM_VERSION_URL = 'https://registry.npmjs.org/command-code/latest';
const API_BASE = 'https://api.commandcode.ai';
/** Fallback max_tokens when neither the caller nor the catalog specifies one.

 *  Matches the Go reference proxy (proxy.go:92). */
const FALLBACK_MAX_TOKENS = 64000;
/** Default temperature. The Go reference proxy defaults to 0.3, but

 *  the CommandCode API is tuned for 0.7 (matching the Livebench/default

 *  consensus observed across providers). */
const DEFAULT_TEMPERATURE = 0.7;
const STREAM_TIMEOUT_MS = 300000; // 5 min — same as BaseProvider.readSseStream
const VERSION_FALLBACK = '0.18.10'; // upstream's minVersion — safe floor if npm is unreachable
const MIN_SUPPORTED_VERSION = '0.18.10';
/** Hard upper bound the CommandCode /alpha/generate API enforces on

 *  params.max_tokens. Verified live 2026-06-19: values above 200_000 return

 *  400 BAD_REQUEST ("Too big: expected number to be <=200000 at

 *  \"params.max_tokens\""). The catalog's max_output_tokens can be higher

 *  (e.g. 262144 for deepseek-v4-pro, MiniMax-M3) — we clamp to this ceiling

 *  so those models don't permanently 400. This is the maximum possible

 *  output length the upstream allows, not an arbitrary default. */
const API_MAX_TOKENS = 200000;

let cachedVersion: string | undefined;
let versionPromise: Promise<string> | undefined;

/** Fetch the latest command-code npm version, cached for the process lifetime.

 * Mirrors the Go proxy's behavior of sending an up-to-date x-command-code-version. */
async function getCommandCodeVersion(): Promise<string> {
  if (cachedVersion) return cachedVersion;
  if (versionPromise) return versionPromise;

  versionPromise = (async () => {
    try {
      const res = await fetch(NPM_VERSION_URL, { signal: AbortSignal.timeout(5000) });
      if (!res.ok) return VERSION_FALLBACK;
      const pkg = (await res.json()) as { version?: string };
      const v = typeof pkg.version === 'string' ? pkg.version : VERSION_FALLBACK;
      // Always send at least the known-minimum so the upstream doesn't 426 us
      cachedVersion = compareVersions(v, MIN_SUPPORTED_VERSION) < 0 ? MIN_SUPPORTED_VERSION : v;
      return cachedVersion;
    } catch {
      cachedVersion = VERSION_FALLBACK;
      return cachedVersion;
    } finally {
      versionPromise = undefined;
    }
  })();
  return versionPromise;
}

/** Loose semver-ish compare: returns <0 if a<b, 0 if equal, >0 if a>b. */
function compareVersions(a: string, b: string): number {
  const pa = a.split('.').map(p => parseInt(p, 10) || 0);
  const pb = b.split('.').map(p => parseInt(p, 10) || 0);
  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
    const da = pa[i] ?? 0;
    const db = pb[i] ?? 0;
    if (da !== db) return da - db;
  }
  return 0;
}

// ── CommandCode wire types ───────────────────────────────────────────────

interface CCContentBlock {
  type: string;
  text?: string;
  id?: string;
  name?: string;
  input?: unknown;
  toolCallId?: string;
  toolName?: string;
  tool_use_id?: string;
  content?: unknown;
  output?: { type: string; value: string };
}

interface CCStreamEvent {
  type: string;
  text?: string;
  id?: string;
  delta?: string;
  input?: Record<string, unknown>;
  toolCallId?: string;
  toolName?: string;
  finishReason?: string;
  totalUsage?: { inputTokens: number; outputTokens: number };
  // Optional reasoning fields. CommandCode's wrapper surfaces model-side
  // reasoning traces under varying keys depending on the underlying model;
  // we capture any of these so OpenAI-format clients can preserve the trace
  // for multi-turn replay. (#290)
  reasoning?: string;
  reasoningContent?: string;
  reasoning_content?: string;
  thinking?: string | { text?: string; thinking?: string };
  redacted_thinking?: string;
  error?: { message: string; statusCode?: number };
}

/** Normalize the variable-shape reasoning field on CCStreamEvent to a string.

 * CommandCode's wrapper surfaces reasoning traces under varying keys

 * depending on the underlying model (`reasoning`, `text`, `thinking`

 * as object/string, …). This helper flattens any of them. (#290) */
function extractReasoningFromEvent(event: CCStreamEvent): string {
  if (typeof event.reasoning_content === 'string') return event.reasoning_content;
  if (typeof event.reasoningContent === 'string') return event.reasoningContent;
  if (typeof event.reasoning === 'string') return event.reasoning;
  if (typeof event.redacted_thinking === 'string') return event.redacted_thinking;
  if (typeof event.thinking === 'string') return event.thinking;
  if (event.thinking && typeof event.thinking === 'object') {
    const inner = event.thinking.text ?? event.thinking.thinking;
    if (typeof inner === 'string') return inner;
  }
  if (typeof event.text === 'string' && event.type?.toLowerCase().includes('reason')) {
    return event.text;
  }
  return '';
}

interface StreamingToolDelta {
  index: number;
  id?: string;
  type?: 'function';
  function?: { name?: string; arguments?: string };
}

interface StreamingDelta {
  role?: 'assistant';
  content?: string;
  tool_calls?: StreamingToolDelta[];
  reasoning_content?: string;
}

// ── Provider ─────────────────────────────────────────────────────────────

export class CommandCodeProvider extends BaseProvider {
  readonly platform = 'commandcode' as const;
  readonly name = 'CommandCode';
  // baseUrl left undefined — CommandCode has no /v1/models endpoint, so
  // auto-discovery skips this provider.

  async chatCompletion(
    apiKey: string,
    messages: ChatMessage[],
    modelId: string,
    options?: CompletionOptions,
  ): Promise<ChatCompletionResponse> {
    const body = this.buildRequestBody(messages, modelId, options);
    const headers = await this.requestHeaders(apiKey);
    const res = await this.fetchWithTimeout(`${API_BASE}/alpha/generate`, {
      method: 'POST',
      headers,
      body: JSON.stringify(body),
    }, options?.timeoutMs ?? 120000, options?.abortSignal);

    if (!res.ok) {
      const err = await res.text().catch(() => '');
      throw providerHttpError(res, `CommandCode API error ${res.status}: ${err}`);
    }

    return this.collectNonStreamResponse(res, modelId);
  }

  async *streamChatCompletion(
    apiKey: string,
    messages: ChatMessage[],
    modelId: string,
    options?: CompletionOptions,
  ): AsyncGenerator<ChatCompletionChunk> {
    const body = this.buildRequestBody(messages, modelId, options);
    const headers = await this.requestHeaders(apiKey);
    const res = await this.fetchWithTimeout(`${API_BASE}/alpha/generate`, {
      method: 'POST',
      headers,
      body: JSON.stringify(body),
    }, options?.timeoutMs ?? 120000, options?.abortSignal);
    if (!res.ok) {
      const err = await res.text().catch(() => '');
      throw providerHttpError(res, `CommandCode API error ${res.status}: ${err}`);
    }

    yield* this.streamNdjsonResponse(res, modelId, options?.abortSignal);
  }

  async validateKey(apiKey: string): Promise<boolean> {
    try {
      const headers = await this.requestHeaders(apiKey);
      const res = await this.fetchWithTimeout(`${API_BASE}/alpha/generate`, {
        method: 'POST',
        headers,
        body: JSON.stringify({
          config: this.defaultConfig(),
          memory: '',
          taste: '',
          skills: '',
          params: { model: 'deepseek/deepseek-v4-flash', messages: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }], system: '', max_tokens: 1, temperature: 0.7, stream: true, tools: [] },
          threadId: crypto.randomUUID(),
        }),
      }, 15000);
      return res.ok || res.status >= 500;
    } catch {
      return true;
    }
  }

  // ── Request building ───────────────────────────────────────────────────

  private buildRequestBody(
    messages: ChatMessage[],
    modelId: string,
    options?: CompletionOptions,
  ): Record<string, unknown> {
    const system = this.buildSystemText(messages);
    const ccMessages = this.convertMessages(messages);
    const tools = this.convertTools(options?.tools);
    const temperature = options?.temperature ?? DEFAULT_TEMPERATURE;
    // The CommandCode API rejects max_tokens > 200_000 with 400. The catalog
    // stores per-model max_output_tokens which can exceed this (e.g. 262144 for
    // deepseek-v4-pro), and callers may also ask for more than the upstream
    // accepts. Clamp to the API ceiling so every model can serve at least up
    const maxTokens = Math.min(options?.max_tokens ?? FALLBACK_MAX_TOKENS, API_MAX_TOKENS);
    return {
      config: this.defaultConfig(),
      memory: '',
      taste: '',
      skills: '',
      params: {
        model: modelId,
        messages: ccMessages,
        tools,
        system,
        max_tokens: maxTokens,
        temperature,
        stream: true,
        // Pass thinking signals through to the underlying provider. The
        // CommandCode wrapper reaches model-specific APIs that recognize
        // `reasoning_effort`; the richer `thinking` object is forwarded
        // verbatim too so the wrapper can pick what it understands. (#290)
        ...(options?.reasoning_effort ? { reasoning_effort: options.reasoning_effort } : {}),
        ...(options?.thinking ? { thinking: options.thinking } : {}),
      },
      threadId: crypto.randomUUID(),
    };
  }

  private defaultConfig(): Record<string, unknown> {
    return {
      workingDir: '.',
      date: new Date().toISOString().slice(0, 10),
      environment: 'cli',
      structure: [],
      isGitRepo: false,
      currentBranch: '',
      mainBranch: 'main',
      gitStatus: '',
      recentCommits: [],
    };
  }

  private async requestHeaders(apiKey: string): Promise<Record<string, string>> {
    const version = await getCommandCodeVersion();
    return {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
      'x-command-code-version': version,
      'x-cli-environment': 'production',
      'Accept': 'text/event-stream',
    };
  }

  // ── Message translation ────────────────────────────────────────────────

  private buildSystemText(messages: ChatMessage[]): string {
    let system = '';
    for (const m of messages) {
      if (m.role === 'system') {
        if (system.length > 0) system += '\n';
        system += this.blockText(m.content);
      }
    }
    return system;
  }

  private convertMessages(messages: ChatMessage[]): Array<{ role: string; content: CCContentBlock[] }> {
    const toolNames = new Map<string, string>();
    for (const m of messages) {
      if (m.role === 'assistant' && 'tool_calls' in m) {
        const calls = (m as { tool_calls?: ChatToolCall[] }).tool_calls;
        if (calls) {
          for (const tc of calls) {
            if (tc.id && tc.function?.name) toolNames.set(tc.id, tc.function.name);
          }
        }
      }
    }

    const out: Array<{ role: string; content: CCContentBlock[] }> = [];
    for (const m of messages) {
      if (m.role === 'system') continue;

      if (m.role === 'tool') {
        const toolMsg = m as ChatMessage & { tool_call_id: string };
        const name = (m as { name?: string }).name || toolNames.get(toolMsg.tool_call_id) || 'unknown';
        const val = this.blockText(m.content);
        out.push({
          role: 'tool',
          content: [{ type: 'tool-result', toolCallId: toolMsg.tool_call_id, toolName: name, output: { type: val.startsWith('Error:') ? 'error-text' : 'text', value: val } }],
        });
        continue;
      }

      if (m.role === 'assistant' && 'tool_calls' in m) {
        const a = m as ChatMessage & { tool_calls?: ChatToolCall[] };
        const blocks: CCContentBlock[] = this.contentToBlocks(m.content);
        const added = new Set(blocks.filter(b => b.type === 'tool-call' && b.toolCallId).map(b => b.toolCallId!));

        for (const tc of a.tool_calls ?? []) {
          if (added.has(tc.id)) continue;
          blocks.push({ type: 'tool-call', toolCallId: tc.id, toolName: tc.function?.name, input: this.safeParseJson(tc.function?.arguments) });
          added.add(tc.id);
        }
        out.push({ role: 'assistant', content: blocks });
        continue;
      }

      out.push({ role: m.role, content: this.contentToBlocks(m.content) });
    }
    return out;
  }
  /** Extract the text value from an individual content block object, mirroring

   *  the Go proxy's `contentPartToString()` in convert.go. Key difference from

   *  lib/content.ts's `contentToString`: that function operates on a whole

   *  message (string | null | array), NOT on single block objects — a bare

   *  `{type:'text',text:'Hello'}` returns '' from it, silently dropping user

   *  content. This helper handles single blocks directly. */
  private blockText(block: unknown): string {
    if (block === null || block === undefined) return '';
    if (typeof block === 'string') return block;
    if (Array.isArray(block)) {
      return block.map(b => this.blockText(b)).join('');
    }
    if (typeof block === 'object') {
      const b = block as Record<string, unknown>;
      // Common text-carrying keys — same order as Go reference
      for (const key of ['text', 'content', 'output_text', 'input_text', 'refusal', 'thinking', 'redacted_thinking']) {
        if (typeof b[key] === 'string') return b[key] as string;
      }
      // Image blocks → descriptive string
      const iu = b['image_url'];
      if (iu && typeof iu === 'object' && typeof (iu as Record<string,unknown>)['url'] === 'string') {
        return `[Image URL: ${(iu as Record<string,unknown>)['url']}]`;
      }
      if (typeof iu === 'string') return `[Image URL: ${iu}]`;
      // Fallback: stringify the block
      try { return JSON.stringify(b); } catch { return String(b); }
    }
    return String(block);
  }


  /** Convert an OpenAI content value to CommandCode content blocks.

   *  Matches the Go reference proxy's `parseContent()` in convert.go — every

   *  block type the Go proxy preserves is preserved here so conversation

   *  history is never silently truncated. */
  private contentToBlocks(content: unknown, _toolNames?: Map<string, string>): CCContentBlock[] {
    if (content === null || content === undefined) return [];
    if (typeof content === 'string') {
      return content.length > 0 ? [{ type: 'text', text: content }] : [];
    }
    if (Array.isArray(content)) {
      return content
        .map((c): CCContentBlock | null => {
          if (typeof c === 'string') return { type: 'text', text: c };
          const b = c as Record<string, unknown>;
          const typ = typeof b.type === 'string' ? b.type : '';

          // ── text-like blocks (Go: text, input_text, output_text, refusal,
          //     thinking, redacted_thinking, reasoning, document, search_result) ──
          if (typ === 'text' || typ === 'input_text' || typ === 'output_text' ||
              typ === 'refusal' || typ === 'thinking' || typ === 'redacted_thinking' ||
              typ === 'reasoning' || typ === 'document' || typ === 'search_result') {
            return { type: 'text', text: this.blockText(b) };
          }

          // ── image-like blocks (Go: image_url, input_image, image → stringified text) ──
          if (typ === 'image_url' || typ === 'input_image' || typ === 'image') {
            return { type: 'text', text: this.blockText(b) };
          }

          // ── tool-call blocks (Go: tool_use, tool-call) ──
          if (typ === 'tool_use' || typ === 'tool-call' || b.tool_use_id) {
            const id = (typeof b.id === 'string' ? b.id : '') ||
                       (typeof b.toolCallId === 'string' ? b.toolCallId : '') ||
                       (typeof b.tool_use_id === 'string' ? b.tool_use_id : '');
            const name = (typeof b.name === 'string' ? b.name : '') ||
                         (typeof b.toolName === 'string' ? b.toolName : '');
            const input = b.input ?? b.arguments;
            const block: CCContentBlock = { type: 'tool-call', input };
            if (id) block.toolCallId = id;
            if (name) block.toolName = name;
            return block;
          }

          // ── tool-result blocks (Go: tool_result, tool-result) ──
          if (typ === 'tool_result' || typ === 'tool-result') {
            const toolUseId = (typeof b.tool_use_id === 'string' ? b.tool_use_id : '') ||
                              (typeof b.toolCallId === 'string' ? b.toolCallId : '');
            const toolName = typeof b.toolName === 'string' ? b.toolName : '';
            const contentVal = this.blockText(b.content ?? b.output);
            const outputType = contentVal.startsWith('Error:') ? 'error-text' : 'text';
            const block: CCContentBlock = {
              type: 'tool-result',
              output: { type: outputType, value: contentVal },
            };
            if (toolUseId) block.toolCallId = toolUseId;
            if (toolName) block.toolName = toolName;
            return block;
          }

          // ── fallthrough: unknown types become text ──
          return { type: 'text', text: this.blockText(b) };
        })
        .filter((b): b is CCContentBlock => b !== null);
    }
    return [];
  }

  private convertTools(tools?: ChatToolDefinition[]): Record<string, unknown>[] {
    if (!tools || tools.length === 0) return [];
    return tools
      .filter(t => t.type === 'function' && t.function?.name)
      .map(t => {
        const out: Record<string, unknown> = {
          name: t.function.name,
          input_schema: t.function.parameters ?? { type: 'object', properties: {} },
        };
        if (t.function.description) out.description = t.function.description;
        return out;
      });
  }

  private async collectNonStreamResponse(res: Response, modelId: string): Promise<ChatCompletionResponse> {
    const events = await this.readNdjsonEvents(res);
    let content = '';
    let reasoning = '';
    const toolCalls: ChatToolCall[] = [];
    const toolCallBySlot: Record<string, number> = {};
    let inputTokens = 0;
    let outputTokens = 0;

    for (const event of events) {
      switch (event.type) {
        case 'text-delta':
          content += event.text ?? '';
          break;
        case 'reasoning-delta':
        case 'reasoning-deltas':
        case 'reasoning': {
          const r = extractReasoningFromEvent(event);
          if (r) reasoning = reasoning ? `${reasoning}\n${r}` : r;
          break;
        }
        case 'tool-use':
          toolCallBySlot[event.toolCallId!] = toolCalls.length;
          toolCalls.push({ id: event.toolCallId!, type: 'function', function: { name: event.toolName ?? '', arguments: '' } });
          break;
        case 'tool-delta':
          if (toolCalls.length > 0) toolCalls[toolCalls.length - 1].function.arguments += event.text ?? '';
          break;
        case 'tool-input-start':
          toolCallBySlot[event.id!] = toolCalls.length;
          toolCalls.push({ id: event.id!, type: 'function', function: { name: event.toolName ?? '', arguments: '' } });
          break;
        case 'tool-input-delta':
          if (event.id && toolCallBySlot[event.id] !== undefined) {
            toolCalls[toolCallBySlot[event.id]].function.arguments += event.delta ?? '';
          }
          break;
        case 'tool-call': {
          const args = event.input ? JSON.stringify(event.input) : '';
          const idx = event.toolCallId ? toolCallBySlot[event.toolCallId] : undefined;
          if (idx !== undefined) {
            if (event.toolName) toolCalls[idx].function.name = event.toolName;
            if (args) toolCalls[idx].function.arguments = args;
          } else {
            toolCalls.push({ id: event.toolCallId!, type: 'function', function: { name: event.toolName ?? '', arguments: args } });
          }
          break;
        }
        case 'finish':
          if (event.totalUsage) {
            inputTokens = event.totalUsage.inputTokens;
            outputTokens = event.totalUsage.outputTokens;
          }
          break;
      }
    }

    const hasToolCalls = toolCalls.length > 0;
    const finishReason = hasToolCalls ? 'tool_calls' : 'stop';
    const msg: { role: string; content: string | null; tool_calls?: ChatToolCall[]; reasoning_content?: string } = {
      role: 'assistant',
      content: hasToolCalls ? null : content,
    };
    if (hasToolCalls) msg.tool_calls = toolCalls;
    if (reasoning.length > 0) msg.reasoning_content = reasoning;

    return {
      id: this.makeId(),
      object: 'chat.completion',
      created: Math.floor(Date.now() / 1000),
      model: modelId,
      choices: [{ index: 0, message: msg as ChatCompletionResponse['choices'][0]['message'], finish_reason: finishReason }],
      usage: {
        prompt_tokens: inputTokens,
        completion_tokens: outputTokens,
        total_tokens: inputTokens + outputTokens,
      },
    };
  }

  // ── Streaming ──────────────────────────────────────────────────────────

  private async *streamNdjsonResponse(res: Response, modelId: string, abortSignal?: AbortSignal): AsyncGenerator<ChatCompletionChunk> {
    const id = this.makeId();
    const created = Math.floor(Date.now() / 1000);
    let sentRole = false;
    let toolCallIndex = 0;
    const toolCallSlot: Record<string, number> = {};
    const reader = res.body?.getReader();
    if (!reader) throw new Error('No response body');
    const decoder = new TextDecoder();
    let buf = '';

    // Client disconnect must interrupt a stalled/slow CommandCode stream
    // immediately rather than waiting for the inactivity timer. (#292)
    if (abortSignal?.aborted) throw new RequestAbortError();
    let aborted = false;
    const onAbort = () => { aborted = true; };
    if (abortSignal) abortSignal.addEventListener('abort', onAbort, { once: true });

    try {
      while (true) {
        if (aborted) throw new RequestAbortError();
        let timer: ReturnType<typeof setTimeout> | undefined;
        const result = await Promise.race([
          reader.read(),
          new Promise<never>((_, reject) => {
            timer = setTimeout(() => reject(new Error('CommandCode stream stalled')), STREAM_TIMEOUT_MS);
          }),
          // A client abort rejects the pending read first. (#292)
          ...(abortSignal ? [new Promise<never>((_, reject) => {
            abortSignal.addEventListener('abort', () => reject(new RequestAbortError()), { once: true });
          })] : []),
        ]).finally(() => clearTimeout(timer));

        const { done, value } = result;
        if (done) {
          buf += decoder.decode();
          yield* this.flushStreamBuffer(buf, id, created, modelId, () => sentRole, (v) => { sentRole = v; }, toolCallSlot, () => toolCallIndex, (v) => { toolCallIndex = v; });
          break;
        }

        buf += decoder.decode(value, { stream: true });
        const lines = buf.split('\n');
        buf = lines.pop() ?? '';

        for (const line of lines) {
          const chunk = this.processStreamLine(line, id, created, modelId, () => sentRole, (v) => { sentRole = v; }, toolCallSlot, () => toolCallIndex, (v) => { toolCallIndex = v; });
          if (chunk) yield chunk;
        }
      }
    } finally {
      if (abortSignal) abortSignal.removeEventListener('abort', onAbort);
      reader.cancel().catch(() => {});
    }
  }

  private *flushStreamBuffer(
    buf: string,
    id: string, created: number, modelId: string,
    getRole: () => boolean, setRole: (v: boolean) => void,
    toolCallSlot: Record<string, number>,
    getIdx: () => number, setIdx: (v: number) => void,
  ): Generator<ChatCompletionChunk> {
    for (const line of buf.split('\n')) {
      const chunk = this.processStreamLine(line, id, created, modelId, getRole, setRole, toolCallSlot, getIdx, setIdx);
      if (chunk) yield chunk;
    }
  }

  private processStreamLine(
    line: string,
    id: string, created: number, modelId: string,
    getRole: () => boolean, setRole: (v: boolean) => void,
    toolCallSlot: Record<string, number>,
    getIdx: () => number, setIdx: (v: number) => void,
  ): ChatCompletionChunk | null {
    const trimmed = line.trim();
    if (!trimmed) return null;
    const event = this.safeParseJson(trimmed) as CCStreamEvent | null;
    if (!event || !event.type) return null;
    switch (event.type) {
      case 'text-delta': {
        const delta: StreamingDelta = { content: event.text };
        if (!getRole()) { delta.role = 'assistant'; setRole(true); }
        return this.buildChunk(id, created, modelId, delta, null);
      }
      case 'reasoning-delta':
      case 'reasoning-deltas':
      case 'reasoning':
      case 'thinking-delta': {
        const text = extractReasoningFromEvent(event);
        if (text.length === 0) return null;
        const delta: StreamingDelta = { reasoning_content: text };
        if (!getRole()) { delta.role = 'assistant'; setRole(true); }
        return this.buildChunk(id, created, modelId, delta, null);
      }
      case 'tool-use': {
        const idx = getIdx();
        toolCallSlot[event.toolCallId!] = idx;
        const tc: StreamingToolDelta = { index: idx, id: event.toolCallId!, type: 'function', function: { name: event.toolName } };
        const delta: StreamingDelta = { tool_calls: [tc] };
        if (!getRole()) { delta.role = 'assistant'; setRole(true); }
        return this.buildChunk(id, created, modelId, delta, null);
      }
      case 'tool-delta': {
        const prevIdx = getIdx() - 1;
        const delta: StreamingDelta = { tool_calls: [{ index: prevIdx, function: { arguments: event.text } }] };
        return this.buildChunk(id, created, modelId, delta, null);
      }
      case 'tool-input-start': {
        if (toolCallSlot[event.id!] === undefined) {
          const idx = getIdx();
          toolCallSlot[event.id!] = idx;
          setIdx(idx + 1);
        }
        const idx = toolCallSlot[event.id!];
        const tc: StreamingToolDelta = { index: idx, id: event.id!, type: 'function', function: { name: event.toolName } };
        const delta: StreamingDelta = { tool_calls: [tc] };
        if (!getRole()) { delta.role = 'assistant'; setRole(true); }
        return this.buildChunk(id, created, modelId, delta, null);
      }
      case 'tool-input-delta': {
        const idx = toolCallSlot[event.id!] ?? getIdx();
        const delta: StreamingDelta = { tool_calls: [{ index: idx, function: { arguments: event.delta } }] };
        return this.buildChunk(id, created, modelId, delta, null);
      }
      case 'tool-call': {
        if (!event.toolCallId) return null;
        if (toolCallSlot[event.toolCallId] !== undefined) return null;
        const idx = getIdx();
        toolCallSlot[event.toolCallId] = idx;
        setIdx(idx + 1);
        const args = event.input ? JSON.stringify(event.input) : '';
        const tc: StreamingToolDelta = { index: idx, id: event.toolCallId, type: 'function', function: { name: event.toolName, arguments: args } };
        const delta: StreamingDelta = { tool_calls: [tc] };
        if (!getRole()) { delta.role = 'assistant'; setRole(true); }
        return this.buildChunk(id, created, modelId, delta, null);
      }
      case 'finish': {
        const reason = this.mapFinishReason(event.finishReason);
        return {
          id, object: 'chat.completion.chunk', created, model: modelId,
          choices: [{ index: 0, delta: {}, finish_reason: reason }],
          usage: event.totalUsage ? {
            prompt_tokens: event.totalUsage.inputTokens,
            completion_tokens: event.totalUsage.outputTokens,
            total_tokens: event.totalUsage.inputTokens + event.totalUsage.outputTokens,
          } : undefined,
        };
      }
      default:
        return null;
    }
  }

  private buildChunk(
    id: string, created: number, modelId: string,
    delta: StreamingDelta, finishReason: string | null,
  ): ChatCompletionChunk {
    return {
      id, object: 'chat.completion.chunk', created, model: modelId,
      choices: [{ index: 0, delta: delta as unknown as ChatCompletionChunk['choices'][0]['delta'], finish_reason: finishReason }],
    } satisfies ChatCompletionChunk;
  }

  private mapFinishReason(reason?: string): string {
    if (reason === 'tool_calls' || reason === 'tool-calls') return 'tool_calls';
    if (reason === 'length' || reason === 'max_tokens') return 'length';
    if (reason === 'content_filter' || reason === 'content-filter') return 'content_filter';
    return 'stop';
  }

  private async readNdjsonEvents(res: Response): Promise<CCStreamEvent[]> {
    const text = await res.text();
    const events: CCStreamEvent[] = [];
    for (const line of text.split('\n')) {
      const trimmed = line.trim();
      if (!trimmed) continue;
      const parsed = this.safeParseJson(trimmed);
      if (parsed && typeof parsed === 'object' && 'type' in parsed) {
        events.push(parsed as CCStreamEvent);
      }
    }
    return events;
  }

  private safeParseJson(raw: string): unknown {
    try { return JSON.parse(raw); } catch { return null; }
  }
}