codemini-cli 0.5.11 → 0.6.0

package/src/core/chat-runtime.js

@@ -83,11 +83,266 @@ function slugify(input) {
   return base || 'untitled';
 }
 
-function nowStamp() {
-  return new Date().toISOString().replace(/[:.]/g, '-');
-}
-
-function prioritizeByPreferredOrder(items, preferredOrder) {
+function nowStamp() {
+  return new Date().toISOString().replace(/[:.]/g, '-');
+}
+
+function numberFromPath(obj, pathParts) {
+  let current = obj;
+  for (const part of pathParts) {
+    if (!current || typeof current !== 'object') return null;
+    current = current[part];
+  }
+  const value = Number(current);
+  return Number.isFinite(value) ? Math.max(0, value) : null;
+}
+
+function firstFiniteNumber(obj, paths) {
+  for (const pathParts of paths) {
+    const value = numberFromPath(obj, pathParts);
+    if (value != null) return value;
+  }
+  return null;
+}
+
+function sumFiniteNumbers(obj, paths) {
+  let sum = 0;
+  let found = false;
+  for (const pathParts of paths) {
+    const value = numberFromPath(obj, pathParts);
+    if (value != null) {
+      sum += value;
+      found = true;
+    }
+  }
+  return found ? sum : null;
+}
+
+function collectRawUsage(usage) {
+  if (!usage || typeof usage !== 'object') return [];
+  if (Array.isArray(usage.raw)) {
+    return usage.raw
+      .filter((item) => item && typeof item === 'object')
+      .map((item) => ({ ...item }));
+  }
+  return [{ ...usage }];
+}
+
+function normalizeModelUsage(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+  const promptCacheHitTokens = firstFiniteNumber(usage, [
+    ['prompt_cache_hit_tokens'],
+    ['promptCacheHitTokens'],
+    ['cache_hit_tokens'],
+    ['cacheHitTokens']
+  ]);
+  const promptCacheMissTokens = firstFiniteNumber(usage, [
+    ['prompt_cache_miss_tokens'],
+    ['promptCacheMissTokens'],
+    ['cache_miss_tokens'],
+    ['cacheMissTokens']
+  ]);
+  const explicitInputTokens = firstFiniteNumber(usage, [
+    ['prompt_tokens'],
+    ['input_tokens'],
+    ['inputTokens'],
+    ['promptTokens'],
+    ['prompt_token_count'],
+    ['promptTokenCount'],
+    ['input_token_count'],
+    ['inputTokenCount'],
+    ['input_total_tokens'],
+    ['total_input_tokens'],
+    ['usage', 'prompt_tokens'],
+    ['usage', 'input_tokens'],
+    ['usage_metadata', 'prompt_token_count'],
+    ['usage_metadata', 'input_token_count'],
+    ['usageMetadata', 'promptTokenCount'],
+    ['usageMetadata', 'inputTokenCount'],
+    ['token_usage', 'prompt_tokens'],
+    ['token_usage', 'input_tokens'],
+    ['tokenUsage', 'promptTokens'],
+    ['tokenUsage', 'inputTokens'],
+    ['tokens', 'input_tokens'],
+    ['tokens', 'inputTokens'],
+    ['tokens', 'prompt_tokens'],
+    ['tokens', 'promptTokens'],
+    ['billed_units', 'input_tokens'],
+    ['billedUnits', 'inputTokens']
+  ]);
+  const inputTokens = explicitInputTokens ?? (
+    promptCacheHitTokens != null || promptCacheMissTokens != null
+      ? Number(promptCacheHitTokens || 0) + Number(promptCacheMissTokens || 0)
+      : null
+  );
+  const outputTokens = firstFiniteNumber(usage, [
+    ['completion_tokens'],
+    ['output_tokens'],
+    ['outputTokens'],
+    ['completionTokens'],
+    ['completion_token_count'],
+    ['completionTokenCount'],
+    ['output_token_count'],
+    ['outputTokenCount'],
+    ['candidates_token_count'],
+    ['candidatesTokenCount'],
+    ['usage', 'completion_tokens'],
+    ['usage', 'output_tokens'],
+    ['usage_metadata', 'candidates_token_count'],
+    ['usage_metadata', 'output_token_count'],
+    ['usageMetadata', 'candidatesTokenCount'],
+    ['usageMetadata', 'outputTokenCount'],
+    ['token_usage', 'completion_tokens'],
+    ['token_usage', 'output_tokens'],
+    ['tokenUsage', 'completionTokens'],
+    ['tokenUsage', 'outputTokens'],
+    ['tokens', 'output_tokens'],
+    ['tokens', 'outputTokens'],
+    ['tokens', 'completion_tokens'],
+    ['tokens', 'completionTokens'],
+    ['billed_units', 'output_tokens'],
+    ['billedUnits', 'outputTokens']
+  ]);
+  const explicitTotal = firstFiniteNumber(usage, [
+    ['total_tokens'],
+    ['totalTokens'],
+    ['total_token_count'],
+    ['totalTokenCount'],
+    ['usage', 'total_tokens'],
+    ['usage_metadata', 'total_token_count'],
+    ['usageMetadata', 'totalTokenCount'],
+    ['token_usage', 'total_tokens'],
+    ['tokenUsage', 'totalTokens'],
+    ['tokens', 'total_tokens'],
+    ['tokens', 'totalTokens']
+  ]);
+  const cachedInputTokens = firstFiniteNumber(usage, [
+    ['prompt_tokens_details', 'cached_tokens'],
+    ['input_tokens_details', 'cached_tokens'],
+    ['promptTokensDetails', 'cachedTokens'],
+    ['inputTokensDetails', 'cachedTokens'],
+    ['cache_read_input_tokens'],
+    ['cacheReadInputTokens'],
+    ['cache_read_tokens'],
+    ['cacheReadTokens'],
+    ['cached_tokens'],
+    ['cachedTokens'],
+    ['cached_input_tokens'],
+    ['cachedInputTokens'],
+    ['cached_content_token_count'],
+    ['cachedContentTokenCount'],
+    ['usage', 'prompt_tokens_details', 'cached_tokens'],
+    ['usage', 'input_tokens_details', 'cached_tokens'],
+    ['usage_metadata', 'cached_content_token_count'],
+    ['usageMetadata', 'cachedContentTokenCount'],
+    ['token_usage', 'prompt_tokens_details', 'cached_tokens'],
+    ['tokenUsage', 'promptTokensDetails', 'cachedTokens'],
+    ['tokens', 'cached_tokens'],
+    ['tokens', 'cachedTokens'],
+    ['prompt_cache_hit_tokens'],
+    ['promptCacheHitTokens'],
+    ['cache_hit_tokens'],
+    ['cacheHitTokens']
+  ]);
+  const cacheMissInputTokens = firstFiniteNumber(usage, [
+    ['prompt_cache_miss_tokens'],
+    ['promptCacheMissTokens'],
+    ['cache_miss_tokens'],
+    ['cacheMissTokens']
+  ]);
+  const cacheWriteInputTokens = firstFiniteNumber(usage, [
+    ['cache_creation_input_tokens'],
+    ['cacheCreationInputTokens'],
+    ['cache_write_input_tokens'],
+    ['cacheWriteInputTokens'],
+    ['cache_creation_tokens'],
+    ['cacheCreationTokens'],
+    ['usage', 'cache_creation_input_tokens'],
+    ['usage', 'cache_write_input_tokens'],
+    ['token_usage', 'cache_creation_input_tokens'],
+    ['tokenUsage', 'cacheCreationInputTokens']
+  ]) ?? sumFiniteNumbers(usage, [
+    ['cache_creation', 'ephemeral_5m_input_tokens'],
+    ['cache_creation', 'ephemeral_1h_input_tokens'],
+    ['cacheCreation', 'ephemeral5mInputTokens'],
+    ['cacheCreation', 'ephemeral1hInputTokens'],
+    ['usage', 'cache_creation', 'ephemeral_5m_input_tokens'],
+    ['usage', 'cache_creation', 'ephemeral_1h_input_tokens']
+  ]);
+  const reasoningOutputTokens = firstFiniteNumber(usage, [
+    ['completion_tokens_details', 'reasoning_tokens'],
+    ['output_tokens_details', 'reasoning_tokens'],
+    ['completionTokensDetails', 'reasoningTokens'],
+    ['outputTokensDetails', 'reasoningTokens'],
+    ['reasoning_tokens'],
+    ['reasoningTokens'],
+    ['thoughts_token_count'],
+    ['thoughtsTokenCount'],
+    ['usage', 'completion_tokens_details', 'reasoning_tokens'],
+    ['usage_metadata', 'thoughts_token_count'],
+    ['usageMetadata', 'thoughtsTokenCount']
+  ]);
+  const totalTokens = explicitTotal ?? (
+    inputTokens != null || outputTokens != null
+      ? Number(inputTokens || 0) + Number(outputTokens || 0)
+      : null
+  );
+  if (
+    inputTokens == null &&
+    outputTokens == null &&
+    totalTokens == null &&
+    cachedInputTokens == null &&
+    cacheWriteInputTokens == null
+  ) {
+    return null;
+  }
+  return {
+    inputTokens: Math.round(inputTokens || 0),
+    outputTokens: Math.round(outputTokens || 0),
+    totalTokens: Math.round(totalTokens || 0),
+    cachedInputTokens: Math.round(cachedInputTokens || 0),
+    cacheMissInputTokens: Math.round(cacheMissInputTokens || 0),
+    cacheWriteInputTokens: Math.round(cacheWriteInputTokens || 0),
+    reasoningOutputTokens: Math.round(reasoningOutputTokens || 0),
+    requests: 1,
+    raw: collectRawUsage(usage)
+  };
+}
+
+function cloneModelUsage(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+  return {
+    inputTokens: Math.max(0, Math.round(Number(usage.inputTokens || 0))),
+    outputTokens: Math.max(0, Math.round(Number(usage.outputTokens || 0))),
+    totalTokens: Math.max(0, Math.round(Number(usage.totalTokens || 0))),
+    cachedInputTokens: Math.max(0, Math.round(Number(usage.cachedInputTokens || 0))),
+    cacheMissInputTokens: Math.max(0, Math.round(Number(usage.cacheMissInputTokens || 0))),
+    cacheWriteInputTokens: Math.max(0, Math.round(Number(usage.cacheWriteInputTokens || 0))),
+    reasoningOutputTokens: Math.max(0, Math.round(Number(usage.reasoningOutputTokens || 0))),
+    requests: Math.max(0, Math.round(Number(usage.requests || 0))),
+    raw: Array.isArray(usage.raw) ? usage.raw.map((item) => ({ ...item })) : []
+  };
+}
+
+function mergeModelUsage(left, right) {
+  const a = cloneModelUsage(left);
+  const b = cloneModelUsage(right);
+  if (!a) return b;
+  if (!b) return a;
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    totalTokens: a.totalTokens + b.totalTokens,
+    cachedInputTokens: a.cachedInputTokens + b.cachedInputTokens,
+    cacheMissInputTokens: a.cacheMissInputTokens + b.cacheMissInputTokens,
+    cacheWriteInputTokens: a.cacheWriteInputTokens + b.cacheWriteInputTokens,
+    reasoningOutputTokens: a.reasoningOutputTokens + b.reasoningOutputTokens,
+    requests: a.requests + b.requests,
+    raw: [...a.raw, ...b.raw]
+  };
+}
+
+function prioritizeByPreferredOrder(items, preferredOrder) {
   const source = Array.isArray(items) ? items : [];
   const priorities = new Map((Array.isArray(preferredOrder) ? preferredOrder : []).map((value, index) => [value, index]));
   return [...source].sort((left, right) => {
@@ -2885,30 +3140,56 @@ async function askModel({
       session.messages.push(stampedMessage('assistant', ''));
       activeAssistantIndex = session.messages.length - 1;
       if (persistSession) scheduleSessionSave();
-    } else if (event?.type === 'assistant:delta') {
-      if (activeAssistantIndex >= 0 && session.messages[activeAssistantIndex]) {
-        const current = session.messages[activeAssistantIndex];
-        current.content = `${current.content || ''}${event.text || ''}`;
-        current.at = new Date().toISOString();
-        if (persistSession) scheduleSessionSave();
-      }
-    } else if (event?.type === 'assistant:response') {
-      if (activeAssistantIndex >= 0 && session.messages[activeAssistantIndex]) {
-        const current = session.messages[activeAssistantIndex];
-        current.content = event.assistantMessage?.content ?? event.text ?? current.content;
-        if (typeof event.assistantMessage?.reasoning_content === 'string' && event.assistantMessage.reasoning_content) {
-          current.reasoning_content = event.assistantMessage.reasoning_content;
-        }
+    } else if (event?.type === 'assistant:delta') {
+      if (activeAssistantIndex >= 0 && session.messages[activeAssistantIndex]) {
+        const current = session.messages[activeAssistantIndex];
+        current.content = `${current.content || ''}${event.text || ''}`;
+        current.at = new Date().toISOString();
+        if (persistSession) scheduleSessionSave();
+      }
+    } else if (event?.type === 'assistant:reasoning_delta') {
+      if (activeAssistantIndex >= 0 && session.messages[activeAssistantIndex]) {
+        const current = session.messages[activeAssistantIndex];
+        const now = new Date();
+        if (!current.reasoning_started_at) current.reasoning_started_at = now.toISOString();
+        current.reasoning_content = `${current.reasoning_content || ''}${event.text || ''}`;
+        current.reasoning_duration_ms = Math.max(
+          0,
+          now.getTime() - Date.parse(current.reasoning_started_at)
+        );
+        current.at = now.toISOString();
+        if (persistSession) scheduleSessionSave();
+      }
+    } else if (event?.type === 'assistant:response') {
+      const eventUsage = normalizeModelUsage(event.usage || event.assistantMessage?.usage);
+      if (eventUsage) event.usage = eventUsage;
+      if (activeAssistantIndex >= 0 && session.messages[activeAssistantIndex]) {
+        const current = session.messages[activeAssistantIndex];
+        const now = new Date();
+        current.content = event.assistantMessage?.content ?? event.text ?? current.content;
+        if (typeof event.assistantMessage?.reasoning_content === 'string' && event.assistantMessage.reasoning_content) {
+          current.reasoning_content = event.assistantMessage.reasoning_content;
+        }
         if (Array.isArray(event.assistantMessage?.reasoning_details) && event.assistantMessage.reasoning_details.length > 0) {
           current.reasoning_details = event.assistantMessage.reasoning_details;
         }
-        if (Array.isArray(event.assistantMessage?.tool_calls) && event.assistantMessage.tool_calls.length > 0) {
-          current.tool_calls = event.assistantMessage.tool_calls;
-        }
-        current.at = new Date().toISOString();
-        if (persistSession) scheduleSessionSave();
-      } else {
-        const assistantMessage = event.assistantMessage && typeof event.assistantMessage === 'object'
+        if (Array.isArray(event.assistantMessage?.tool_calls) && event.assistantMessage.tool_calls.length > 0) {
+          current.tool_calls = event.assistantMessage.tool_calls;
+        }
+        if (eventUsage) {
+          current.usage = mergeModelUsage(current.usage, eventUsage);
+        }
+        if ((current.reasoning_content || current.reasoning_details) && current.reasoning_started_at) {
+          current.reasoning_ended_at = current.reasoning_ended_at || now.toISOString();
+          current.reasoning_duration_ms = Math.max(
+            Number(current.reasoning_duration_ms || 0),
+            Date.parse(current.reasoning_ended_at) - Date.parse(current.reasoning_started_at)
+          );
+        }
+        current.at = now.toISOString();
+        if (persistSession) scheduleSessionSave();
+      } else {
+        const assistantMessage = event.assistantMessage && typeof event.assistantMessage === 'object'
           ? event.assistantMessage
           : { content: event.text || '' };
         session.messages.push(stampedMessage('assistant', assistantMessage.content || event.text || '', {
@@ -2918,12 +3199,13 @@ async function askModel({
           ...(Array.isArray(assistantMessage.reasoning_details) && assistantMessage.reasoning_details.length > 0
             ? { reasoning_details: assistantMessage.reasoning_details }
             : {}),
-          ...(Array.isArray(assistantMessage.tool_calls) && assistantMessage.tool_calls.length > 0
-            ? { tool_calls: assistantMessage.tool_calls }
-            : {})
-        }));
-        if (persistSession) scheduleSessionSave();
-      }
+          ...(Array.isArray(assistantMessage.tool_calls) && assistantMessage.tool_calls.length > 0
+            ? { tool_calls: assistantMessage.tool_calls }
+            : {}),
+          ...(eventUsage ? { usage: eventUsage } : {})
+        }));
+        if (persistSession) scheduleSessionSave();
+      }
       activeAssistantIndex = -1;
     } else if (event?.type === 'tool:end' || event?.type === 'tool:error' || event?.type === 'tool:blocked') {
       const toolId = String(event.id || '');
@@ -3000,11 +3282,15 @@ async function askModel({
         timeoutMs: config.gateway.timeout_ms || 1800000,
         maxRetries: config.gateway.max_retries ?? 2,
         signal,
-        onTextDelta: (delta) => {
-          startAssistantStream();
-          wrappedAgentEvent({ type: 'assistant:delta', text: delta });
-        },
-        onToolCallDelta: (toolCall) => {
+        onTextDelta: (delta) => {
+          startAssistantStream();
+          wrappedAgentEvent({ type: 'assistant:delta', text: delta });
+        },
+        onReasoningDelta: (delta) => {
+          startAssistantStream();
+          wrappedAgentEvent({ type: 'assistant:reasoning_delta', text: delta });
+        },
+        onToolCallDelta: (toolCall) => {
           startAssistantStream();
           wrappedAgentEvent({ type: 'assistant:tool_call_delta', toolCall });
         }
@@ -3131,7 +3417,7 @@ async function runSubAgentTask({
     }
     if (
       role !== 'summarizer' &&
-      ['assistant:start', 'assistant:delta', 'assistant:response', 'assistant:tool_call_delta'].includes(String(evt?.type || ''))
+      ['assistant:start', 'assistant:delta', 'assistant:reasoning_delta', 'assistant:response', 'assistant:tool_call_delta'].includes(String(evt?.type || ''))
     ) {
       return;
     }
@@ -3171,14 +3457,18 @@ async function runSubAgentTask({
   };
 }
 
-function buildPlanStepTranscript({ stepRecord, stepIndex, totalSteps, messages }) {
-  const toolCardsById = new Map();
-  const toolCards = [];
-  const source = Array.isArray(messages) ? messages : [];
-
-  for (const msg of source) {
-    if (msg?.role === 'assistant' && Array.isArray(msg.tool_calls)) {
-      for (const tc of msg.tool_calls) {
+function buildPlanStepTranscript({ stepRecord, stepIndex, totalSteps, messages }) {
+  const toolCardsById = new Map();
+  const toolCards = [];
+  const source = Array.isArray(messages) ? messages : [];
+  let usage = null;
+
+  for (const msg of source) {
+    if (msg?.role === 'assistant' && msg.usage) {
+      usage = mergeModelUsage(usage, msg.usage);
+    }
+    if (msg?.role === 'assistant' && Array.isArray(msg.tool_calls)) {
+      for (const tc of msg.tool_calls) {
         const id = String(tc?.id || `tool-${toolCards.length + 1}`);
         if (toolCardsById.has(id)) continue;
         const card = {
@@ -3217,11 +3507,12 @@ function buildPlanStepTranscript({ stepRecord, stepIndex, totalSteps, messages }
     total: totalSteps,
     role: stepRecord.role || 'general',
     title: stepRecord.title || '',
-    status: stepRecord.failed ? 'failed' : 'done',
-    summary: stepRecord.failed ? stepRecord.failureReason : trimInline(stepRecord.output || '', 160),
-    segments
-  };
-}
+    status: stepRecord.failed ? 'failed' : 'done',
+    summary: stepRecord.failed ? stepRecord.failureReason : trimInline(stepRecord.output || '', 160),
+    segments,
+    ...(usage ? { usage } : {})
+  };
+}
 
 async function executePlanWithSubAgents({
   planState,

package/src/core/config-store.js

@@ -214,10 +214,11 @@ function getNested(obj, keyPath) {
   return keyPath.split('.').reduce((acc, k) => (acc && k in acc ? acc[k] : undefined), obj);
 }
 
-function parseValue(input) {
-  if (input === 'true') return true;
-  if (input === 'false') return false;
-  if (input === 'null') return null;
+function parseValue(input) {
+  if (typeof input !== 'string') return input;
+  if (input === 'true') return true;
+  if (input === 'false') return false;
+  if (input === 'null') return null;
   if ((input.startsWith('[') && input.endsWith(']')) || (input.startsWith('{') && input.endsWith('}'))) {
     try {
       return JSON.parse(input);

package/src/core/provider/anthropic.js

@@ -403,9 +403,10 @@ export async function createChatCompletionStream({
   model,
   messages,
   temperature = 0.2,
-  tools,
-  onTextDelta,
-  onToolCallDelta,
+  tools,
+  onTextDelta,
+  onReasoningDelta,
+  onToolCallDelta,
   timeoutMs = 1800000,
   maxTokens = 4096,
   signal: externalSignal
@@ -476,12 +477,14 @@ export async function createChatCompletionStream({
       continue;
     }
 
-    if (delta.type === 'thinking_delta') {
-      const current = thinkingBlocksByIndex.get(index) || { type: 'thinking', thinking: '' };
-      current.thinking = `${current.thinking || ''}${String(delta.thinking || '')}`;
-      thinkingBlocksByIndex.set(index, current);
-      continue;
-    }
+    if (delta.type === 'thinking_delta') {
+      const current = thinkingBlocksByIndex.get(index) || { type: 'thinking', thinking: '' };
+      const thinkingDelta = String(delta.thinking || '');
+      current.thinking = `${current.thinking || ''}${thinkingDelta}`;
+      thinkingBlocksByIndex.set(index, current);
+      if (thinkingDelta && onReasoningDelta) onReasoningDelta(thinkingDelta);
+      continue;
+    }
 
     if (delta.type === 'signature_delta') {
       const current = thinkingBlocksByIndex.get(index) || { type: 'thinking', thinking: '' };

package/src/core/provider/openai-compatible.js

@@ -135,17 +135,32 @@ function normalizeToolCallArguments(argumentsText) {
   return '{}';
 }
 
-function normalizeIncomingToolCallArguments(argumentsValue) {
-  if (typeof argumentsValue === 'string') return argumentsValue;
-  if (argumentsValue == null) return '{}';
+function normalizeIncomingToolCallArguments(argumentsValue) {
+  if (typeof argumentsValue === 'string') return argumentsValue;
+  if (argumentsValue == null) return '{}';
   try {
     return JSON.stringify(argumentsValue);
   } catch {
     return '{}';
-  }
-}
-
-function sanitizeGatewayMessages(messages) {
+  }
+}
+
+function extractUsageObject(data) {
+  if (!data || typeof data !== 'object') return null;
+  return data.usage
+    || data.usage_metadata
+    || data.usageMetadata
+    || data.token_usage
+    || data.tokenUsage
+    || data.meta?.tokens
+    || data.meta?.billed_units
+    || data.meta?.billedUnits
+    || data.response?.usage
+    || data.response?.usage_metadata
+    || null;
+}
+
+function sanitizeGatewayMessages(messages) {
   const source = Array.isArray(messages) ? messages : [];
   return source
     .filter((message) => message && typeof message === 'object')
@@ -221,9 +236,10 @@ function buildPayload({ model, temperature, messages, tools, stream = false }) {
     temperature,
     messages: isMiniMaxModel(model) ? sanitizeMiniMaxMessages(sanitizedMessages) : sanitizedMessages
   };
-  if (stream) {
-    payload.stream = true;
-  }
+  if (stream) {
+    payload.stream = true;
+    payload.stream_options = { include_usage: true };
+  }
   if (Array.isArray(tools) && tools.length > 0) {
     payload.tools = tools;
     payload.tool_choice = 'auto';
@@ -365,25 +381,25 @@ export async function createChatCompletion({
   }));
   const normalizedText = String(text || '').trim();
 
-  if (!normalizedText && toolCalls.length === 0) {
-    if (hasTrailingToolContext(messages)) {
-      return {
-        text: '',
-        toolCalls: [],
-        usage: data?.usage || null,
-        incomplete: true
-      };
-    }
-    throw new Error('Gateway returned empty assistant response');
-  }
-
-  return {
-    text,
-    toolCalls,
-    usage: data?.usage || null,
-    assistantMessage: buildAssistantMessage({
-      text,
-      toolCalls,
+  if (!normalizedText && toolCalls.length === 0) {
+    if (hasTrailingToolContext(messages)) {
+      return {
+        text: '',
+        toolCalls: [],
+        usage: extractUsageObject(data),
+        incomplete: true
+      };
+    }
+    throw new Error('Gateway returned empty assistant response');
+  }
+
+  return {
+    text,
+    toolCalls,
+    usage: extractUsageObject(data),
+    assistantMessage: buildAssistantMessage({
+      text,
+      toolCalls,
       content: message.content ?? text,
       reasoningContent
     })
@@ -396,9 +412,10 @@ export async function createChatCompletionStream({
   model,
   messages,
   temperature = 0.2,
-  tools,
-  onTextDelta,
-  onToolCallDelta,
+  tools,
+  onTextDelta,
+  onReasoningDelta,
+  onToolCallDelta,
   timeoutMs = 1800000,
   maxRetries = 2,
   signal: externalSignal
@@ -415,33 +432,46 @@ export async function createChatCompletionStream({
       externalSignal.addEventListener('abort', onAbort, { once: true });
     }
   }
-  const payload = buildPayload({ model, temperature, messages, tools, stream: true });
-  const response = await fetchWithRetry(buildChatCompletionsUrl(baseUrl), {
-    method: 'POST',
-    headers: createHeaders(apiKey),
-    body: JSON.stringify(payload),
-    signal: controller.signal
-  }, { maxRetries });
-  if (!response.ok || !response.body) {
-    const text = await response.text().catch(() => '');
-    throw new Error(`Gateway error ${response.status}: ${text || response.statusText}`);
-  }
+  const url = buildChatCompletionsUrl(baseUrl);
+  const payload = buildPayload({ model, temperature, messages, tools, stream: true });
+  const buildRequest = (bodyPayload) => ({
+    method: 'POST',
+    headers: createHeaders(apiKey),
+    body: JSON.stringify(bodyPayload),
+    signal: controller.signal
+  });
+  let response = await fetchWithRetry(url, buildRequest(payload), { maxRetries });
+  if (!response.ok && payload.stream_options) {
+    const errorText = await response.text().catch(() => '');
+    if (/\b(stream_options|include_usage|unsupported|unknown|unrecognized|forbidden)\b/i.test(errorText)) {
+      const fallbackPayload = { ...payload };
+      delete fallbackPayload.stream_options;
+      response = await fetchWithRetry(url, buildRequest(fallbackPayload), { maxRetries });
+    } else {
+      throw new Error(`Gateway error ${response.status}: ${errorText || response.statusText}`);
+    }
+  }
+  if (!response.ok || !response.body) {
+    const text = await response.text().catch(() => '');
+    throw new Error(`Gateway error ${response.status}: ${text || response.statusText}`);
+  }
   let text = '';
   let reasoningContent = '';
   const toolCallsByIndex = new Map();
   let usage = null;
   let miniMaxStreamState = { rawContent: '', visibleText: '' };
 
-  try {
-    for await (const chunk of iterateSseEvents(response.body)) {
-    usage = chunk?.usage || usage;
+  try {
+    for await (const chunk of iterateSseEvents(response.body)) {
+    usage = extractUsageObject(chunk) || usage;
     const choice0 = chunk?.choices?.[0] || {};
     const delta = choice0?.delta || {};
     const content = delta.content;
-    const reasoningDelta = extractReasoningContent(delta.reasoning_content);
-    if (reasoningDelta) {
-      reasoningContent += reasoningDelta;
-    }
+    const reasoningDelta = extractReasoningContent(delta.reasoning_content);
+    if (reasoningDelta) {
+      reasoningContent += reasoningDelta;
+      if (onReasoningDelta) onReasoningDelta(reasoningDelta);
+    }
     if (isMiniMaxModel(model)) {
       const next = nextMiniMaxVisibleChunk(miniMaxStreamState, content);
       miniMaxStreamState = next.nextState;