@yeaft/webchat-agent 0.1.596 → 0.1.597

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.596",
+  "version": "0.1.597",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/llm/adapter.js

@@ -1,9 +1,13 @@
 /**
  * adapter.js — LLM Adapter base class, unified types, and factory
  *
- * Design decision (2026-04-10): Only two adapters needed:
- *   1. AnthropicAdapter — Anthropic Messages API
- *   2. ChatCompletionsAdapter — OpenAI Chat Completions API (covers GPT, DeepSeek, CopilotProxy, etc.)
+ * Design decision (Phase 7, 2026-04-27): Only two adapters remain:
+ *   1. AnthropicAdapter        — Anthropic Messages API
+ *   2. OpenAIResponsesAdapter  — OpenAI Responses API (covers GPT, DeepSeek, CopilotProxy, etc.)
+ *
+ * The legacy ChatCompletionsAdapter (OpenAI Chat Completions API) was deleted in
+ * Phase 7. Configurations using protocol "openai" or alias "chat-completions"
+ * must migrate to "openai-responses" or "anthropic".
  *
  * The engine sees only unified types — it never knows which API is underneath.
  */
@@ -234,8 +238,7 @@ export async function createLLMAdapter(config) {
   }
 
   // ─── Legacy path: single adapter from env vars ────────
-  // Normalize adapter name — accept 'chat-completions' as alias for 'openai'
-  const adapter = config.adapter === 'chat-completions' ? 'openai' : config.adapter;
+  const adapter = config.adapter;
 
   if (adapter === 'anthropic' || (!adapter && config.apiKey)) {
     if (!config.apiKey) {
@@ -248,26 +251,24 @@ export async function createLLMAdapter(config) {
     });
   }
 
-  if (adapter === 'openai' || (!adapter && config.openaiApiKey)) {
-    if (!config.openaiApiKey && !config.apiKey) {
-      throw new Error('OpenAI adapter requires YEAFT_OPENAI_API_KEY (or YEAFT_API_KEY as fallback)');
-    }
-    const { ChatCompletionsAdapter } = await import('./chat-completions.js');
-    return new ChatCompletionsAdapter({
-      apiKey: config.openaiApiKey || config.apiKey,
-      baseUrl: config.baseUrl || 'https://api.openai.com/v1',
-    });
-  }
-
-  if (adapter === 'proxy' || (!adapter && config.proxyUrl)) {
-    const { ChatCompletionsAdapter } = await import('./chat-completions.js');
-    return new ChatCompletionsAdapter({
-      apiKey: 'proxy', // CopilotProxy handles auth
-      baseUrl: `${config.proxyUrl}/v1`,
-    });
+  if (
+    adapter === 'chat-completions' ||
+    adapter === 'openai' ||
+    adapter === 'proxy' ||
+    (!adapter && (config.openaiApiKey || config.proxyUrl))
+  ) {
+    throw new Error(
+      'The chat-completions adapter was removed in Phase 7. ' +
+      'Configure providers via ~/.yeaft/config.json with protocol: "anthropic" ' +
+      'or protocol: "openai-responses" instead of using the legacy ' +
+      '"openai"/"proxy"/"chat-completions" adapter env-var path.'
+    );
   }
 
   throw new Error(
-    'No LLM adapter configured. Set YEAFT_API_KEY (Anthropic), YEAFT_OPENAI_API_KEY (OpenAI), or YEAFT_PROXY_URL (CopilotProxy).',
+    'No LLM adapter configured. Set YEAFT_API_KEY (Anthropic) or configure ' +
+    'providers in ~/.yeaft/config.json. The chat-completions/openai/proxy ' +
+    'env-var paths were removed in Phase 7 — use protocol: "openai-responses" ' +
+    'in a provider entry instead.',
   );
 }

package/unify/llm/router.js

@@ -5,11 +5,14 @@
  *   [{ name, baseUrl, apiKey, protocol?, models[] }, ...]
  *
  * The router resolves model → provider, lazy-creates the right adapter
- * (AnthropicAdapter or ChatCompletionsAdapter based on protocol), caches it,
+ * (AnthropicAdapter or OpenAIResponsesAdapter based on protocol), caches it,
  * and forwards stream()/call() to the resolved adapter.
  *
- * protocol defaults to "openai" (Chat Completions API).
- * Set protocol: "anthropic" only for direct Anthropic API connections.
+ * protocol must be one of:
+ *   - "anthropic"        — Anthropic Messages API (required for claude-* models)
+ *   - "openai-responses" — OpenAI Responses API (default for everything else)
+ *
+ * Phase 7 removed the legacy "openai" (Chat Completions) protocol entirely.
  */
 
 import { LLMAdapter } from './adapter.js';
@@ -93,23 +96,25 @@ export class AdapterRouter extends LLMAdapter {
   /**
    * Resolve the effective wire protocol for a (provider, model) pair.
    *
-   * The provider's declared protocol is the default, but Anthropic-style
-   * model IDs (e.g. "claude-opus-4.7") cannot be served by the OpenAI
-   * Responses API even when the provider sits in front of both. Detect
-   * that mismatch and downgrade to chat-completions, which proxies like
-   * GitHub Copilot DO support for Claude models.
+   * Phase 7: only "anthropic" and "openai-responses" are supported. Claude
+   * model IDs require provider.protocol === "anthropic" — there is no
+   * chat-completions fallback any more.
    *
    * @param {object} provider — Provider config
    * @param {string} modelId
-   * @returns {'anthropic' | 'openai-responses' | 'openai'}
+   * @returns {'anthropic' | 'openai-responses'}
    */
   #effectiveProtocol(provider, modelId) {
-    const declared = provider.protocol || 'openai';
-    // Anthropic models — only 'anthropic' or 'openai' (chat-completions) make sense.
-    // Responses API does not support Claude → fall back to chat-completions.
+    const declared = provider.protocol || 'openai-responses';
     if (typeof modelId === 'string' && modelId.startsWith('claude-')) {
-      if (declared === 'openai-responses') return 'openai';
-      return declared; // anthropic / openai both fine
+      if (declared !== 'anthropic') {
+        throw new Error(
+          `Claude models require provider.protocol="anthropic"; ` +
+          `chat-completions fallback removed in Phase 7. ` +
+          `Provider "${provider.name}" declares protocol="${declared}" for model "${modelId}".`
+        );
+      }
+      return 'anthropic';
     }
     return declared;
   }
@@ -131,8 +136,8 @@ export class AdapterRouter extends LLMAdapter {
     }
 
     // Compute the effective protocol per model — a single provider may need
-    // two adapters (e.g. copilot proxy: openai-responses for gpt-5*,
-    // chat-completions for claude-*). Cache key includes the protocol.
+    // two adapters (e.g. mixed config: openai-responses for gpt-5*, anthropic
+    // for claude-*). Cache key includes the protocol.
     const protocol = this.#effectiveProtocol(provider, modelId);
     const cacheKey = `${provider.name}::${protocol}`;
     const cached = this.#adapterCache.get(cacheKey);
@@ -147,19 +152,18 @@ export class AdapterRouter extends LLMAdapter {
         baseUrl: provider.baseUrl,
       });
     } else if (protocol === 'openai-responses') {
-      // OpenAI Responses API (/v1/responses) — next-gen, recommended for GPT-5+
+      // OpenAI Responses API (/v1/responses) — canonical OpenAI-compatible path.
       const { OpenAIResponsesAdapter } = await import('./openai-responses.js');
       adapter = new OpenAIResponsesAdapter({
         apiKey: provider.apiKey,
         baseUrl: provider.baseUrl,
       });
     } else {
-      // Default: openai (Chat Completions API) — covers proxy, OpenAI, DeepSeek, Gemini, etc.
-      const { ChatCompletionsAdapter } = await import('./chat-completions.js');
-      adapter = new ChatCompletionsAdapter({
-        apiKey: provider.apiKey,
-        baseUrl: provider.baseUrl,
-      });
+      throw new Error(
+        `Unsupported protocol "${protocol}" for provider "${provider.name}". ` +
+        `Use protocol: "anthropic" or "openai-responses". ` +
+        `The chat-completions adapter was removed in Phase 7.`
+      );
     }
 
     this.#adapterCache.set(cacheKey, adapter);

package/unify/models.js

@@ -76,7 +76,7 @@ export const MODEL_REGISTRY = new Map([
   // ── OpenAI ─────────────────────────────────────────────────────
   ['gpt-5', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 256000,
     maxOutputTokens: 16384,
@@ -91,25 +91,25 @@ export const MODEL_REGISTRY = new Map([
   // should come from provider config (user-supplied) instead of guesses.
   ['gpt-5-mini', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     displayName: 'GPT-5 Mini',
   }],
   ['gpt-5-nano', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     displayName: 'GPT-5 Nano',
   }],
   ['gpt-5-pro', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     displayName: 'GPT-5 Pro',
   }],
   ['gpt-5.4', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 272000,
     maxOutputTokens: 16384,
@@ -117,7 +117,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['gpt-4.1', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 1047576,
     maxOutputTokens: 32768,
@@ -125,7 +125,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['gpt-4.1-mini', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 1047576,
     maxOutputTokens: 16384,
@@ -133,7 +133,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['gpt-4.1-nano', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 1047576,
     maxOutputTokens: 16384,
@@ -141,7 +141,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['o3', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 200000,
     maxOutputTokens: 100000,
@@ -153,7 +153,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['o4-mini', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 200000,
     maxOutputTokens: 100000,
@@ -166,7 +166,7 @@ export const MODEL_REGISTRY = new Map([
   // ── DeepSeek ───────────────────────────────────────────────────
   ['deepseek-chat', {
     provider: 'deepseek',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.deepseek.com',
     contextWindow: 131072,
     maxOutputTokens: 8192,
@@ -174,7 +174,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['deepseek-reasoner', {
     provider: 'deepseek',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.deepseek.com',
     contextWindow: 131072,
     maxOutputTokens: 8192,
@@ -184,7 +184,7 @@ export const MODEL_REGISTRY = new Map([
   // ── Google (via OpenAI-compatible API) ─────────────────────────
   ['gemini-2.5-pro', {
     provider: 'google',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
     contextWindow: 1048576,
     maxOutputTokens: 65536,
@@ -192,7 +192,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['gemini-2.5-flash', {
     provider: 'google',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
     contextWindow: 1048576,
     maxOutputTokens: 65536,

package/unify/llm/chat-completions.js

@@ -1,501 +0,0 @@
-/**
- * chat-completions.js — OpenAI Chat Completions API adapter
- *
- * Covers ALL OpenAI-compatible backends via baseUrl:
- *   - https://api.openai.com/v1           → OpenAI direct
- *   - https://api.deepseek.com            → DeepSeek
- *   - http://localhost:6628/v1            → CopilotProxy
- *   - Azure, Ollama, LMStudio, etc.
- *
- * Key translation responsibilities:
- *   Request:  UnifiedToolDef → { type: "function", function: { name, description, parameters } }
- *   Response: delta.tool_calls[i].function.arguments (JSON string) → accumulate → JSON.parse → UnifiedToolCall
- *   Result:   UnifiedToolResult → { role: "tool", tool_call_id, content }
- *   Finish:   "tool_calls" → "tool_use", "stop" → "end_turn", "length" → "max_tokens"
- *
- * max_tokens strategy (based on model ID):
- *   OpenAI models (gpt-*, o1*, o3*, o4*) use "max_completion_tokens" (new standard).
- *   All other models (DeepSeek, Gemini, etc.) use "max_tokens" (legacy/compat).
- *   CopilotProxy transparently forwards whatever the client sends.
- *   Callers can override via extraBody to pass any parameter directly.
- */
-
-import {
-  LLMAdapter,
-  LLMRateLimitError,
-  LLMAuthError,
-  LLMContextError,
-  LLMServerError,
-  LLMAbortError,
-  redactRawRequest,
-  capRawRequest,
-  capRawString,
-  RAW_PAYLOAD_CAP_BYTES,
-} from './adapter.js';
-import {
-  normalizeEffort,
-  mapEffortToOpenAIReasoning,
-  getThinkingCapability,
-} from '../models.js';
-
-/**
- * task-327a: feature-flag accessor. Read lazily so tests can flip.
- */
-function thinkingV1Enabled() {
-  return process.env.UNIFY_THINKING_V1 === '1';
-}
-
-/**
- * task-DESIGN-v4: Chat Completions adapter is deprecated in favour of
- * `openai-responses.js` (Responses API) for OpenAI-protocol providers and
- * `anthropic.js` for Anthropic. This warning fires once per process the
- * first time the adapter is instantiated, unless UNIFY_SUPPRESS_DEPRECATION=1.
- * Removal is scheduled for Phase 7 of the multi-VP redesign — see
- * `agent/unify/DESIGN.md` § "Migration Plan".
- */
-let _chatCompletionsDeprecationWarned = false;
-function warnChatCompletionsDeprecated() {
-  if (_chatCompletionsDeprecationWarned) return;
-  if (process.env.UNIFY_SUPPRESS_DEPRECATION === '1') {
-    _chatCompletionsDeprecationWarned = true;
-    return;
-  }
-  _chatCompletionsDeprecationWarned = true;
-  // eslint-disable-next-line no-console
-  console.warn(
-    '[unify] ChatCompletionsAdapter is deprecated. Migrate OpenAI-protocol '
-    + 'providers to the Responses API (set provider.protocol="openai-responses"). '
-    + 'This adapter will be removed in a future release. Set '
-    + 'UNIFY_SUPPRESS_DEPRECATION=1 to silence this warning.'
-  );
-}
-
-/**
- * Check if a model ID is an OpenAI model that supports max_completion_tokens.
- * OpenAI introduced max_completion_tokens with o1 and made it standard for
- * GPT-4.1+, o-series, and GPT-5+. Other OpenAI-compatible APIs (DeepSeek,
- * Gemini, Ollama) still only understand max_tokens.
- *
- * @param {string} model — The model ID (e.g. "gpt-5", "deepseek-chat", "o3")
- * @returns {boolean} true = use max_completion_tokens
- */
-export function useNewMaxTokensParam(model) {
-  if (!model) return false;
-  const m = model.toLowerCase();
-  // GPT-4.1+ and GPT-5+
-  if (m.startsWith('gpt-')) return true;
-  // o-series reasoning models (o1, o3, o4-mini, etc.)
-  if (/^o\d/.test(m)) return true;
-  // Everything else (deepseek-*, gemini-*, claude-*, custom models): legacy
-  return false;
-}
-
-/**
- * ChatCompletionsAdapter — Talks to OpenAI Chat Completions API and compatibles.
- */
-export class ChatCompletionsAdapter extends LLMAdapter {
-  #apiKey;
-  #baseUrl;
-
-  /**
-   * @param {{ apiKey: string, baseUrl: string }} config
-   */
-  constructor({ apiKey, baseUrl }) {
-    super({ apiKey, baseUrl });
-    this.#apiKey = apiKey;
-    this.#baseUrl = baseUrl.replace(/\/+$/, ''); // strip trailing slash
-    warnChatCompletionsDeprecated();
-  }
-
-  /** Expose baseUrl for testing. */
-  get baseUrl() { return this.#baseUrl; }
-
-  /**
-   * Build the max-tokens portion of the request body.
-   * Uses max_completion_tokens for OpenAI models, max_tokens for others.
-   *
-   * @param {string} model
-   * @param {number} maxTokens
-   * @returns {object}
-   */
-  #maxTokensBody(model, maxTokens) {
-    if (useNewMaxTokensParam(model)) {
-      return { max_completion_tokens: maxTokens };
-    }
-    return { max_tokens: maxTokens };
-  }
-
-  /**
-   * Translate UnifiedToolDef[] → Chat Completions tool format.
-   * @param {import('./adapter.js').UnifiedToolDef[]} tools
-   * @returns {object[]|undefined}
-   */
-  #translateTools(tools) {
-    if (!tools || tools.length === 0) return undefined;
-    return tools.map(t => ({
-      type: 'function',
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-      },
-    }));
-  }
-
-  /**
-   * Translate UnifiedMessage[] → Chat Completions message format.
-   * @param {string} system — System prompt
-   * @param {import('./adapter.js').UnifiedMessage[]} messages
-   * @returns {object[]}
-   */
-  #translateMessages(system, messages) {
-    const result = [];
-
-    // System message first
-    if (system) {
-      result.push({ role: 'system', content: system });
-    }
-
-    for (const msg of messages) {
-      if (msg.role === 'system') {
-        result.push({ role: 'system', content: msg.content });
-      } else if (msg.role === 'user') {
-        result.push({ role: 'user', content: msg.content });
-      } else if (msg.role === 'assistant') {
-        const entry = { role: 'assistant' };
-        // Some OpenAI-compatible APIs require `content: null` when tool_calls are present
-        entry.content = msg.content || null;
-        if (msg.toolCalls && msg.toolCalls.length > 0) {
-          entry.tool_calls = msg.toolCalls.map(tc => ({
-            id: tc.id,
-            type: 'function',
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.input),
-            },
-          }));
-        }
-        result.push(entry);
-      } else if (msg.role === 'tool') {
-        result.push({
-          role: 'tool',
-          tool_call_id: msg.toolCallId,
-          content: msg.content,
-        });
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Classify HTTP errors.
-   * @param {number} status
-   * @param {string} body
-   */
-  #classifyError(status, body) {
-    if (status === 401 || status === 403) {
-      return new LLMAuthError(`Auth error: ${body}`, status);
-    }
-    if (status === 429) {
-      return new LLMRateLimitError(`Rate limit: ${body}`, status);
-    }
-    if (status === 529) {
-      return new LLMRateLimitError(`Overloaded: ${body}`, status);
-    }
-    if (status === 413 || body.includes('context_length_exceeded') || body.includes('maximum context length')) {
-      return new LLMContextError(`Context too long: ${body}`);
-    }
-    if (status >= 500) {
-      return new LLMServerError(`Server error: ${body}`, status);
-    }
-    return new Error(`API error ${status}: ${body}`);
-  }
-
-  /**
-   * Map Chat Completions finish_reason → unified stop reason.
-   * @param {string|null} reason
-   * @returns {'end_turn' | 'tool_use' | 'max_tokens'}
-   */
-  #mapFinishReason(reason) {
-    switch (reason) {
-      case 'tool_calls': return 'tool_use';
-      case 'stop': return 'end_turn';
-      case 'length': return 'max_tokens';
-      default: return 'end_turn';
-    }
-  }
-
-  /**
-   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'max', extraBody?: object, signal?: AbortSignal }} params
-   * @returns {AsyncGenerator<import('./adapter.js').StreamEvent>}
-   */
-  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, extraBody, signal, onRawExchange }) {
-    if (signal?.aborted) throw new LLMAbortError();
-
-    const body = {
-      model,
-      messages: this.#translateMessages(system, messages),
-      ...this.#maxTokensBody(model, maxTokens),
-      stream: true,
-      stream_options: { include_usage: true },
-    };
-
-    // task-327a: inject OpenAI reasoning.effort when feature flag on, effort is
-    // valid, and model's registry entry flags openai-reasoning protocol.
-    // 'max' downgrades to 'high' (OpenAI has no 'max' enum). Unknown / unsupported
-    // models silently drop the parameter.
-    const normEffort = normalizeEffort(effort);
-    if (thinkingV1Enabled() && normEffort) {
-      const cap = getThinkingCapability(model);
-      if (cap.supportsThinking && cap.thinkingProtocol === 'openai-reasoning') {
-        const reasoningEffort = mapEffortToOpenAIReasoning(normEffort);
-        if (reasoningEffort) {
-          body.reasoning = { effort: reasoningEffort };
-        }
-      }
-    }
-
-    const translatedTools = this.#translateTools(tools);
-    if (translatedTools) body.tools = translatedTools;
-
-    // extraBody allows callers to pass through any additional/override parameters
-    if (extraBody) Object.assign(body, extraBody);
-
-    const url = `${this.#baseUrl}/chat/completions`;
-    const headers = {
-      'Content-Type': 'application/json',
-      'Authorization': `Bearer ${this.#apiKey}`,
-    };
-
-    // task-344: expose raw request (redacted) for debug panel.
-    // task-344 follow-up (N2): cap body size.
-    const rawRequest = capRawRequest(redactRawRequest({ url, method: 'POST', headers, body }));
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body),
-      signal,
-    });
-
-    if (!response.ok) {
-      const errorBody = await response.text();
-      if (onRawExchange) {
-        try {
-          onRawExchange({
-            rawRequest,
-            rawResponse: {
-              status: response.status,
-              headers: response.headers && typeof response.headers.entries === 'function'
-                ? Object.fromEntries(response.headers.entries())
-                : {},
-              // task-344 follow-up (N2): cap error body.
-              body: capRawString(errorBody),
-            },
-          });
-        } catch { /* ignore */ }
-      }
-      throw this.#classifyError(response.status, errorBody);
-    }
-
-    // Parse SSE stream
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    // task-344: accumulate raw SSE body + headers/status for debug exposure.
-    // task-344 follow-up (N2): cap growth at RAW_PAYLOAD_CAP_BYTES.
-    let rawSseBody = '';
-    let rawSseTotalBytes = 0;
-    let rawSseCapped = false;
-    const responseHeaders = response.headers && typeof response.headers.entries === 'function'
-      ? Object.fromEntries(response.headers.entries())
-      : {};
-    const responseStatus = response.status;
-
-    // Tool call accumulation — Chat Completions sends tool args as fragments
-    // keyed by index within the delta.tool_calls array
-    /** @type {Map<number, { id: string, name: string, arguments: string }>} */
-    const toolCallAccum = new Map();
-
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        const chunkText = decoder.decode(value, { stream: true });
-        buffer += chunkText;
-        // task-344 follow-up (N2): size-capped capture.
-        rawSseTotalBytes += value.byteLength;
-        if (!rawSseCapped) {
-          if (rawSseTotalBytes <= RAW_PAYLOAD_CAP_BYTES) {
-            rawSseBody += chunkText;
-          } else {
-            const remaining = RAW_PAYLOAD_CAP_BYTES - (rawSseTotalBytes - value.byteLength);
-            if (remaining > 0) {
-              rawSseBody += chunkText.slice(0, remaining);
-            }
-            rawSseCapped = true;
-          }
-        }
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-
-        for (const line of lines) {
-          if (!line.startsWith('data: ')) continue;
-          const data = line.slice(6).trim();
-          if (data === '[DONE]') continue;
-
-          let chunk;
-          try {
-            chunk = JSON.parse(data);
-          } catch {
-            continue;
-          }
-
-          // Usage (from stream_options: include_usage)
-          if (chunk.usage) {
-            yield {
-              type: 'usage',
-              inputTokens: chunk.usage.prompt_tokens || 0,
-              outputTokens: chunk.usage.completion_tokens || 0,
-              cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
-              cacheWriteTokens: 0,
-            };
-          }
-
-          const choice = chunk.choices?.[0];
-          if (!choice) continue;
-
-          const delta = choice.delta;
-          if (!delta) continue;
-
-          // Text content
-          if (delta.content) {
-            yield { type: 'text_delta', text: delta.content };
-          }
-
-          // Tool calls (streamed as fragments)
-          if (delta.tool_calls) {
-            for (const tc of delta.tool_calls) {
-              const idx = tc.index;
-              if (!toolCallAccum.has(idx)) {
-                toolCallAccum.set(idx, {
-                  id: tc.id || '',
-                  name: tc.function?.name || '',
-                  arguments: '',
-                });
-              }
-              const accum = toolCallAccum.get(idx);
-              if (tc.id) accum.id = tc.id;
-              if (tc.function?.name) accum.name = tc.function.name;
-              if (tc.function?.arguments) accum.arguments += tc.function.arguments;
-            }
-          }
-
-          // Finish reason
-          if (choice.finish_reason) {
-            // Emit accumulated tool calls before stop
-            for (const [, accum] of toolCallAccum) {
-              let parsedInput = {};
-              try {
-                parsedInput = accum.arguments ? JSON.parse(accum.arguments) : {};
-              } catch {
-                parsedInput = {};
-              }
-              yield {
-                type: 'tool_call',
-                id: accum.id,
-                name: accum.name,
-                input: parsedInput,
-              };
-            }
-            toolCallAccum.clear();
-
-            yield {
-              type: 'stop',
-              stopReason: this.#mapFinishReason(choice.finish_reason),
-            };
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-      // task-344: emit raw exchange after stream completes.
-      if (onRawExchange) {
-        try {
-          // task-344 follow-up (N2): append truncation marker when capped.
-          const finalBody = rawSseCapped
-            ? `${rawSseBody}…[truncated, original ${rawSseTotalBytes} bytes]`
-            : rawSseBody;
-          onRawExchange({
-            rawRequest,
-            rawResponse: {
-              status: responseStatus,
-              headers: responseHeaders,
-              body: finalBody,
-              format: 'sse',
-            },
-          });
-        } catch { /* ignore */ }
-      }
-    }
-  }
-
-  /**
-   * Non-streaming call for side queries.
-   *
-   * task-327c: accepts `effort` for internal scenario-tagged calls
-   * (consolidate/dream/recall/light). Feature-flag + capability guards
-   * mirror stream() exactly; unsupported models silently drop the param.
-   */
-  async call({ model, system, messages, maxTokens = 4096, effort, extraBody, signal }) {
-    if (signal?.aborted) throw new LLMAbortError();
-
-    const body = {
-      model,
-      messages: this.#translateMessages(system, messages),
-      ...this.#maxTokensBody(model, maxTokens),
-    };
-
-    // task-327c: mirror stream()'s reasoning.effort injection for side queries.
-    const normEffort = normalizeEffort(effort);
-    if (thinkingV1Enabled() && normEffort) {
-      const cap = getThinkingCapability(model);
-      if (cap.supportsThinking && cap.thinkingProtocol === 'openai-reasoning') {
-        const reasoningEffort = mapEffortToOpenAIReasoning(normEffort);
-        if (reasoningEffort) {
-          body.reasoning = { effort: reasoningEffort };
-        }
-      }
-    }
-
-    // extraBody allows callers to pass through any additional/override parameters
-    if (extraBody) Object.assign(body, extraBody);
-
-    const response = await fetch(`${this.#baseUrl}/chat/completions`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.#apiKey}`,
-      },
-      body: JSON.stringify(body),
-      signal,
-    });
-
-    if (!response.ok) {
-      const errorBody = await response.text();
-      throw this.#classifyError(response.status, errorBody);
-    }
-
-    const result = await response.json();
-    const text = result.choices?.[0]?.message?.content || '';
-
-    return {
-      text,
-      usage: {
-        inputTokens: result.usage?.prompt_tokens || 0,
-        outputTokens: result.usage?.completion_tokens || 0,
-      },
-    };
-  }
-}