@omnicross/core 0.1.0 → 0.1.1

package/dist/completion/CompletionService.cjs

@@ -0,0 +1,3487 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/completion/CompletionService.ts
+var CompletionService_exports = {};
+__export(CompletionService_exports, {
+  CompletionService: () => CompletionService
+});
+module.exports = __toCommonJS(CompletionService_exports);
+
+// src/completion/url-builder.ts
+var import_endpoint_resolver = require("@omnicross/contracts/endpoint-resolver");
+function resolveApiFormat(provider) {
+  if (provider.apiFormat) {
+    return provider.apiFormat;
+  }
+  if (provider.chatApiFormat) {
+    return provider.chatApiFormat;
+  }
+  if (provider.apiType === "claudecode" || provider.apiType === "anthropic") {
+    return "anthropic";
+  }
+  if (provider.apiType === "google") {
+    return "google";
+  }
+  return "openai";
+}
+function buildOpenAIApiUrl(baseUrl) {
+  const url = baseUrl.replace(/\/+$/, "");
+  if (url.endsWith("/chat/completions")) {
+    return url;
+  }
+  if (/\/v\d+$/.test(url)) {
+    return url + "/chat/completions";
+  }
+  if (url.includes("/chat/completions")) {
+    return url;
+  }
+  return url + "/v1/chat/completions";
+}
+function buildAnthropicApiUrl(baseUrl) {
+  const url = baseUrl.replace(/\/+$/, "");
+  if (url.endsWith("/messages")) {
+    return url;
+  }
+  if (url.includes("/messages")) {
+    return url;
+  }
+  if (/\/v\d+$/.test(url)) {
+    return url + "/messages";
+  }
+  return url + "/v1/messages";
+}
+function buildGeminiModelActionUrl(baseUrl, model, action) {
+  let url = baseUrl.replace(/\/+$/, "");
+  if (url.includes("/models/")) {
+    return url;
+  }
+  if (!/\/v\d+(?:beta)?(?:$|\/)/.test(url)) {
+    url += "/v1beta";
+  }
+  return `${url}/models/${model}:${action}`;
+}
+function buildGeminiApiUrl(baseUrl, model, stream) {
+  const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+  return buildGeminiModelActionUrl(baseUrl, model, action);
+}
+function normalizeAzureEndpoint(endpoint) {
+  return endpoint.replace(/\/+$/, "").replace(/\/openai(\/v\d+)?$/, "");
+}
+function buildAzureOpenAIApiUrl(baseUrl, model, apiVersion) {
+  const endpoint = normalizeAzureEndpoint(baseUrl);
+  return `${endpoint}/openai/deployments/${model}/chat/completions?api-version=${apiVersion}`;
+}
+function buildOpenAIResponseApiUrl(baseUrl) {
+  const url = baseUrl.replace(/\/+$/, "");
+  if (url.endsWith("/responses")) {
+    return url;
+  }
+  if (/\/v\d+$/.test(url)) {
+    return url + "/responses";
+  }
+  return url + "/v1/responses";
+}
+var resolveProviderEndpoint = import_endpoint_resolver.resolveProviderEndpoint;
+function buildProviderApiUrl(provider, options = {}) {
+  const format = resolveApiFormat(provider);
+  const { baseUrl } = resolveProviderEndpoint(provider);
+  switch (format) {
+    case "anthropic":
+      return buildAnthropicApiUrl(baseUrl);
+    case "google":
+      return buildGeminiApiUrl(baseUrl, options.model || "", options.stream || false);
+    case "azure-openai":
+      return buildAzureOpenAIApiUrl(baseUrl, options.model || "", provider.apiVersion || "2024-08-01-preview");
+    case "openai-response":
+      return buildOpenAIResponseApiUrl(baseUrl);
+    case "openai":
+    default:
+      return buildOpenAIApiUrl(baseUrl);
+  }
+}
+
+// src/openrouter.ts
+function isOpenRouterProvider(provider) {
+  const baseUrl = (provider.api_base_url || "").toLowerCase();
+  return baseUrl.includes("openrouter.ai");
+}
+var OPENROUTER_APP_HEADERS = {
+  "HTTP-Referer": "https://omnicross.dev",
+  "X-Title": "omnicross"
+};
+
+// src/completion/header-builder.ts
+function getProviderHeaders(provider, apiKey) {
+  const format = resolveApiFormat(provider);
+  let headers;
+  switch (format) {
+    case "anthropic":
+      headers = {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2025-01-10"
+        // Required for extended thinking feature
+      };
+      break;
+    case "google":
+      headers = {
+        "Content-Type": "application/json",
+        "x-goog-api-key": apiKey
+      };
+      break;
+    case "azure-openai":
+      headers = {
+        "Content-Type": "application/json",
+        "api-key": apiKey
+      };
+      break;
+    case "openai":
+    case "openai-response":
+    default:
+      headers = {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      };
+      break;
+  }
+  if (isOpenRouterProvider(provider)) {
+    return { ...headers, ...OPENROUTER_APP_HEADERS };
+  }
+  return headers;
+}
+
+// src/completion/message-converter.ts
+var OPENROUTER_AUDIO_FORMAT_MAP = {
+  "audio/wav": "wav",
+  "audio/x-wav": "wav",
+  "audio/wave": "wav",
+  "audio/mpeg": "mp3",
+  "audio/mp3": "mp3",
+  "audio/aiff": "aiff",
+  "audio/x-aiff": "aiff",
+  "audio/aac": "aac",
+  "audio/ogg": "ogg",
+  "audio/flac": "flac",
+  "audio/x-flac": "flac",
+  "audio/mp4": "m4a",
+  "audio/m4a": "m4a",
+  "audio/x-m4a": "m4a",
+  "audio/L16": "pcm16",
+  "audio/L24": "pcm24"
+};
+var MAX_INLINE_VIDEO_BYTES = 25 * 1024 * 1024;
+function decodeDataUrl(url) {
+  const match = url.match(/^data:([^;]+);base64,(.+)$/);
+  if (!match) return null;
+  return { mimeType: match[1], data: match[2] };
+}
+function looksLikeRemoteUrl(url) {
+  return /^https?:\/\//i.test(url);
+}
+function resolveAudioFormat(mimeType, sourceUrl) {
+  const candidate = (mimeType || "").toLowerCase();
+  const mapped = OPENROUTER_AUDIO_FORMAT_MAP[candidate];
+  if (mapped) return mapped;
+  const decoded = decodeDataUrl(sourceUrl);
+  if (decoded) {
+    const mappedFromUrl = OPENROUTER_AUDIO_FORMAT_MAP[decoded.mimeType.toLowerCase()];
+    if (mappedFromUrl) return mappedFromUrl;
+  }
+  throw new Error(
+    `Unsupported audio format for OpenAI/OpenRouter chat input: ${mimeType || "unknown"}. Supported: wav, mp3, aiff, aac, ogg, flac, m4a, pcm16, pcm24.`
+  );
+}
+function convertMessageToOpenAI(msg) {
+  const role = msg.role;
+  const hasImages = msg.images && msg.images.length > 0;
+  const hasAudios = msg.audios && msg.audios.length > 0;
+  const hasVideos = msg.videos && msg.videos.length > 0;
+  if (!hasImages && !hasAudios && !hasVideos) {
+    return { role, content: msg.content };
+  }
+  const content = [];
+  if (msg.content) {
+    content.push({ type: "text", text: msg.content });
+  }
+  if (msg.images) {
+    for (const img of msg.images) {
+      content.push({
+        type: "image_url",
+        image_url: { url: img.url }
+      });
+    }
+  }
+  if (msg.audios) {
+    for (const audio of msg.audios) {
+      const decoded = decodeDataUrl(audio.url);
+      if (decoded) {
+        const format = resolveAudioFormat(decoded.mimeType, audio.url);
+        content.push({ type: "input_audio", input_audio: { data: decoded.data, format } });
+      } else if (audio.mimeType) {
+        content.push({ type: "audio_url", audio_url: { url: audio.url, format: audio.mimeType } });
+      } else {
+        content.push({ type: "audio_url", audio_url: { url: audio.url } });
+      }
+    }
+  }
+  if (msg.videos) {
+    for (const video of msg.videos) {
+      if (looksLikeRemoteUrl(video.url)) {
+        content.push({ type: "video_url", video_url: { url: video.url } });
+        continue;
+      }
+      const decoded = decodeDataUrl(video.url);
+      if (decoded) {
+        const sizeBytes = Math.floor(decoded.data.length * 3 / 4);
+        if (sizeBytes > MAX_INLINE_VIDEO_BYTES) {
+          const sizeMb = (sizeBytes / 1024 / 1024).toFixed(1);
+          throw new Error(
+            `Video too large for inline upload: ${sizeMb} MB exceeds the 25 MB cap. Use a publicly accessible HTTPS URL instead.`
+          );
+        }
+        content.push({ type: "video_url", video_url: { url: video.url } });
+      } else {
+        content.push({ type: "video_url", video_url: { url: video.url } });
+      }
+    }
+  }
+  return { role, content };
+}
+function convertMessageToAnthropic(msg) {
+  const role = msg.role === "system" ? "user" : msg.role;
+  const hasImages = msg.images && msg.images.length > 0;
+  const hasAudios = msg.audios && msg.audios.length > 0;
+  if (!hasImages && !hasAudios) {
+    return { role, content: msg.content };
+  }
+  const content = [];
+  if (msg.content) {
+    content.push({ type: "text", text: msg.content });
+  }
+  if (msg.images) {
+    for (const img of msg.images) {
+      let base64Data = img.url;
+      let mediaType = img.mimeType || "image/jpeg";
+      if (img.url.startsWith("data:")) {
+        const match = img.url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          mediaType = match[1];
+          base64Data = match[2];
+        }
+      }
+      content.push({
+        type: "image",
+        source: { type: "base64", media_type: mediaType, data: base64Data }
+      });
+    }
+  }
+  if (msg.audios) {
+    for (const audio of msg.audios) {
+      let base64Data = audio.url;
+      let mediaType = audio.mimeType || "audio/wav";
+      if (audio.url.startsWith("data:")) {
+        const match = audio.url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          mediaType = match[1];
+          base64Data = match[2];
+        }
+      }
+      content.push({
+        type: "audio",
+        source: { type: "base64", media_type: mediaType, data: base64Data }
+      });
+    }
+  }
+  return { role, content };
+}
+function convertMessageToGemini(msg) {
+  const role = msg.role === "assistant" ? "model" : msg.role;
+  const parts = [];
+  if (msg.content) {
+    parts.push({ text: msg.content });
+  }
+  if (msg.images && msg.images.length > 0) {
+    for (const img of msg.images) {
+      let base64Data = img.url;
+      let mimeType = img.mimeType || "image/jpeg";
+      if (img.url.startsWith("data:")) {
+        const match = img.url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          mimeType = match[1];
+          base64Data = match[2];
+        }
+      }
+      parts.push({ inlineData: { mimeType, data: base64Data } });
+    }
+  }
+  if (msg.audios && msg.audios.length > 0) {
+    for (const audio of msg.audios) {
+      let base64Data = audio.url;
+      let mimeType = audio.mimeType || "audio/wav";
+      if (audio.url.startsWith("data:")) {
+        const match = audio.url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          mimeType = match[1];
+          base64Data = match[2];
+        }
+      }
+      parts.push({ inlineData: { mimeType, data: base64Data } });
+    }
+  }
+  return { role, parts };
+}
+
+// src/completion/openrouter-utils.ts
+function getOpenRouterProviderConfig(provider, modelId) {
+  if (!isOpenRouterProvider(provider)) {
+    return void 0;
+  }
+  const modelConfig = provider.modelConfigs?.find((m) => m.id === modelId);
+  return modelConfig?.openRouterProvider;
+}
+function addOpenRouterProviderToRequest(requestBody, provider, modelId) {
+  const providerRouting = getOpenRouterProviderConfig(provider, modelId);
+  if (!providerRouting) {
+    return requestBody;
+  }
+  const hasConfig = Object.values(providerRouting).some(
+    (v) => v !== void 0 && v !== null && (Array.isArray(v) ? v.length > 0 : true)
+  );
+  if (!hasConfig) {
+    return requestBody;
+  }
+  return {
+    ...requestBody,
+    provider: providerRouting
+  };
+}
+
+// src/completion/native-search-types.ts
+var NATIVE_SEARCH_TOOL_NAMES = [
+  "web_search",
+  "web_search_20250305",
+  "web_search_20260209",
+  "google_search",
+  "googleSearchRetrieval"
+];
+
+// src/completion/NativeSearchInjector.ts
+function applyAugmentation(requestBody, augmentation) {
+  if (augmentation.additionalTools?.length) {
+    const existing = requestBody.tools ?? [];
+    requestBody.tools = [...existing, ...augmentation.additionalTools];
+  }
+  if (augmentation.bodyFields) {
+    Object.assign(requestBody, augmentation.bodyFields);
+  }
+  return requestBody;
+}
+
+// src/completion/DirectApiHandler.ts
+var import_thinking_config2 = require("@omnicross/contracts/thinking-config");
+
+// src/sse-parser.ts
+var DEBUG_SSE = true;
+function debugSSE(prefix, ...args) {
+  if (DEBUG_SSE) {
+    console.log(`[SSE-Parser] ${prefix}`, ...args);
+  }
+}
+function createSSEParser(format, callbacks) {
+  const state = {
+    buffer: "",
+    content: "",
+    reasoning: "",
+    usage: void 0,
+    isDone: false,
+    streamStartTime: void 0,
+    firstTokenTime: void 0,
+    streamEndTime: void 0,
+    blocks: [],
+    currentBlockIndex: -1,
+    currentBlockType: "",
+    inputJsonBuffer: "",
+    audios: [],
+    videos: []
+  };
+  function parseOpenAIEvent(data) {
+    if (data === "[DONE]") {
+      debugSSE("OpenAI [DONE] received, content length:", state.content.length);
+      state.isDone = true;
+      callbacks.onDone?.();
+      return;
+    }
+    try {
+      const json = JSON.parse(data);
+      callbacks.onRawEvent?.({ data: json, raw: data });
+      const delta = json.choices?.[0]?.delta;
+      const finishReason = json.choices?.[0]?.finish_reason;
+      if (finishReason) {
+        debugSSE("OpenAI finish_reason:", finishReason, "content length so far:", state.content.length);
+      }
+      if (delta?.content) {
+        if (!state.firstTokenTime) {
+          state.firstTokenTime = Date.now();
+        }
+        state.content += delta.content;
+        callbacks.onDelta?.(delta.content);
+      }
+      if (delta?.reasoning_content) {
+        state.reasoning += delta.reasoning_content;
+        callbacks.onReasoning?.(delta.reasoning_content);
+      }
+      if (delta?.audio) {
+        const audioData = delta.audio;
+        if (audioData.data) {
+          const mimeType = audioData.format ? `audio/${audioData.format}` : "audio/wav";
+          const audio = {
+            url: audioData.data.startsWith("data:") ? audioData.data : `data:${mimeType};base64,${audioData.data}`,
+            mimeType
+          };
+          state.audios.push(audio);
+          callbacks.onAudio?.(audio);
+        }
+      }
+      if (json.usage) {
+        debugSSE("OpenAI usage received:", JSON.stringify(json.usage));
+        debugSSE("OpenAI final chunk full data:", JSON.stringify(json));
+        state.usage = {
+          promptTokens: json.usage.prompt_tokens || 0,
+          completionTokens: json.usage.completion_tokens || 0,
+          totalTokens: json.usage.total_tokens || 0
+        };
+        callbacks.onUsage?.(state.usage);
+      }
+      if (finishReason === "stop" || finishReason === "end_turn" || finishReason === "length") {
+        debugSSE("OpenAI stream marked done due to finish_reason:", finishReason);
+      }
+    } catch {
+    }
+  }
+  function parseAnthropicEvent(data) {
+    try {
+      const json = JSON.parse(data);
+      callbacks.onRawEvent?.({ type: json.type, data: json, raw: data });
+      if (json.type === "content_block_start") {
+        const contentBlock = json.content_block;
+        const blockIndex = json.index ?? -1;
+        if (contentBlock?.type === "thinking") {
+          debugSSE("THINKING BLOCK STARTED!");
+        }
+        if (contentBlock?.type === "server_tool_use") {
+          state.currentBlockIndex = blockIndex;
+          state.currentBlockType = "server_tool_use";
+          state.inputJsonBuffer = "";
+          const toolUseBlock = {
+            id: contentBlock.id || `block_${Date.now()}`,
+            type: "tool_use",
+            toolId: contentBlock.id || "",
+            toolName: contentBlock.name || "web_search",
+            input: contentBlock.input || {},
+            status: "running"
+          };
+          state.blocks.push(toolUseBlock);
+          callbacks.onBlock?.(toolUseBlock);
+        }
+        if (contentBlock?.type === "web_search_tool_result") {
+          state.currentBlockIndex = blockIndex;
+          state.currentBlockType = "web_search_tool_result";
+          const searchResults = contentBlock.content;
+          let output = "";
+          if (Array.isArray(searchResults)) {
+            output = searchResults.filter((r) => r.type === "web_search_result").map(
+              (r) => `**${r.title || "Untitled"}**
+${r.url || ""}
+${r.encrypted_content ? "(encrypted)" : r.page_content || r.snippet || ""}`
+            ).join("\n\n");
+          }
+          const lastToolUse = [...state.blocks].reverse().find(
+            (b) => b.type === "tool_use"
+          );
+          const toolResultBlock = {
+            id: `result_${Date.now()}`,
+            type: "tool_result",
+            toolId: lastToolUse?.toolId || "",
+            toolName: lastToolUse?.toolName || "web_search",
+            output: output || "(no results)"
+          };
+          state.blocks.push(toolResultBlock);
+          callbacks.onBlock?.(toolResultBlock);
+          if (lastToolUse) {
+            lastToolUse.status = "completed";
+            callbacks.onBlock?.(lastToolUse);
+          }
+        }
+      }
+      if (json.type === "content_block_delta") {
+        const delta = json.delta;
+        if (delta?.type === "text_delta" && delta?.text) {
+          if (!state.firstTokenTime) {
+            state.firstTokenTime = Date.now();
+          }
+          state.content += delta.text;
+          callbacks.onDelta?.(delta.text);
+        }
+        if (delta?.type === "thinking_delta" && delta?.thinking) {
+          state.reasoning += delta.thinking;
+          callbacks.onReasoning?.(delta.thinking);
+        }
+        if (delta?.type === "input_json_delta" && delta?.partial_json) {
+          state.inputJsonBuffer += delta.partial_json;
+        }
+      }
+      if (json.type === "content_block_stop") {
+        if (state.currentBlockType === "server_tool_use" && state.inputJsonBuffer) {
+          const lastToolUse = [...state.blocks].reverse().find(
+            (b) => b.type === "tool_use"
+          );
+          if (lastToolUse) {
+            try {
+              lastToolUse.input = JSON.parse(state.inputJsonBuffer);
+            } catch {
+              lastToolUse.input = { raw: state.inputJsonBuffer };
+            }
+            callbacks.onBlock?.(lastToolUse);
+          }
+        }
+        state.currentBlockIndex = -1;
+        state.currentBlockType = "";
+        state.inputJsonBuffer = "";
+      }
+      if (json.type === "message_delta" && json.usage) {
+        state.usage = {
+          promptTokens: json.usage.input_tokens || 0,
+          completionTokens: json.usage.output_tokens || 0,
+          totalTokens: (json.usage.input_tokens || 0) + (json.usage.output_tokens || 0)
+        };
+        callbacks.onUsage?.(state.usage);
+      }
+      if (json.type === "message_stop") {
+        state.isDone = true;
+        callbacks.onDone?.();
+      }
+      if (json.type === "error") {
+        callbacks.onError?.(json.error?.message || "Unknown error");
+      }
+    } catch {
+    }
+  }
+  function parseGeminiEvent(data) {
+    try {
+      const json = JSON.parse(data);
+      callbacks.onRawEvent?.({ data: json, raw: data });
+      const candidates = json.candidates;
+      if (candidates && candidates.length > 0) {
+        const candidate = candidates[0];
+        const content = candidate.content;
+        if (content?.parts) {
+          for (const part of content.parts) {
+            if (part.thought === true && part.text) {
+              state.reasoning += part.text;
+              callbacks.onReasoning?.(part.text);
+            } else if (part.text) {
+              if (!state.firstTokenTime) {
+                state.firstTokenTime = Date.now();
+              }
+              state.content += part.text;
+              callbacks.onDelta?.(part.text);
+            }
+          }
+        }
+        const finishReason = candidate.finishReason;
+        if (finishReason === "STOP" || finishReason === "MAX_TOKENS" || finishReason === "SAFETY") {
+          debugSSE("Gemini finish reason:", finishReason);
+        }
+      }
+      const usage = json.usageMetadata;
+      if (usage) {
+        state.usage = {
+          promptTokens: usage.promptTokenCount || 0,
+          completionTokens: usage.candidatesTokenCount || 0,
+          totalTokens: usage.totalTokenCount || 0
+        };
+        callbacks.onUsage?.(state.usage);
+        debugSSE("Gemini usage:", state.usage);
+      }
+      if (json.error) {
+        callbacks.onError?.(json.error.message || "Gemini API error");
+      }
+    } catch {
+    }
+  }
+  function parseOpenAIResponseEvent(data) {
+    try {
+      const json = JSON.parse(data);
+      callbacks.onRawEvent?.({ type: json.type, data: json, raw: data });
+      switch (json.type) {
+        case "response.output_text.delta":
+          if (json.delta) {
+            if (!state.firstTokenTime) {
+              state.firstTokenTime = Date.now();
+            }
+            state.content += json.delta;
+            callbacks.onDelta?.(json.delta);
+          }
+          break;
+        case "response.reasoning_summary_text.delta":
+          if (json.delta) {
+            state.reasoning += json.delta;
+            callbacks.onReasoning?.(json.delta);
+          }
+          break;
+        case "response.completed": {
+          const response = json.response;
+          if (response?.usage) {
+            state.usage = {
+              promptTokens: response.usage.input_tokens || 0,
+              completionTokens: response.usage.output_tokens || 0,
+              totalTokens: (response.usage.input_tokens || 0) + (response.usage.output_tokens || 0)
+            };
+            callbacks.onUsage?.(state.usage);
+          }
+          state.isDone = true;
+          callbacks.onDone?.();
+          break;
+        }
+        case "error":
+          callbacks.onError?.(json.error?.message || json.message || "Unknown error");
+          break;
+        // Informational events — no-op
+        // response.created, response.in_progress, response.output_item.added,
+        // response.content_part.added, response.output_text.done,
+        // response.content_part.done, response.output_item.done, etc.
+        default:
+          break;
+      }
+    } catch {
+    }
+  }
+  function processEventBlock(eventBlock) {
+    const lines = eventBlock.split("\n");
+    const dataLines = [];
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        dataLines.push(line.slice(6));
+      } else if (line.trim() !== "" && !line.startsWith(":")) {
+      }
+    }
+    if (dataLines.length > 0) {
+      const data = dataLines.join("\n");
+      if (format === "openai") {
+        parseOpenAIEvent(data);
+      } else if (format === "gemini") {
+        parseGeminiEvent(data);
+      } else if (format === "openai-response") {
+        parseOpenAIResponseEvent(data);
+      } else {
+        parseAnthropicEvent(data);
+      }
+    }
+  }
+  return {
+    /**
+     * Push a chunk of data to the parser
+     * @param chunk - Raw SSE chunk from response stream
+     */
+    push(chunk) {
+      if (state.isDone) return;
+      if (!state.streamStartTime) {
+        state.streamStartTime = Date.now();
+      }
+      state.buffer += chunk;
+      const events = state.buffer.split("\n\n");
+      state.buffer = events.pop() || "";
+      for (const eventBlock of events) {
+        processEventBlock(eventBlock);
+        if (state.isDone) break;
+      }
+    },
+    /**
+     * Flush any remaining data in the buffer
+     */
+    flush() {
+      debugSSE("flush() called, buffer length:", state.buffer.length, "isDone:", state.isDone);
+      if (state.buffer.trim()) {
+        debugSSE("flush() processing remaining buffer:", state.buffer.substring(0, 200));
+        processEventBlock(state.buffer);
+        state.buffer = "";
+      }
+      state.streamEndTime = Date.now();
+      if (!state.isDone) {
+        debugSSE("flush() marking stream as done, final content length:", state.content.length);
+        state.isDone = true;
+        callbacks.onDone?.();
+      }
+    },
+    /**
+     * Get accumulated results
+     */
+    getResult() {
+      let metrics;
+      if (state.usage && state.firstTokenTime && state.streamEndTime) {
+        const timeCompletionMs = state.streamEndTime - state.firstTokenTime;
+        const timeFirstTokenMs = state.streamStartTime ? state.firstTokenTime - state.streamStartTime : void 0;
+        metrics = {
+          completionTokens: state.usage.completionTokens,
+          timeCompletionMs: timeCompletionMs > 0 ? timeCompletionMs : 1,
+          // Ensure at least 1ms
+          timeFirstTokenMs
+        };
+      }
+      if (state.reasoning) {
+        const thinkingBlock = {
+          id: `thinking_${Date.now()}`,
+          type: "thinking",
+          content: state.reasoning
+        };
+        state.blocks.unshift(thinkingBlock);
+      }
+      return {
+        content: state.content,
+        reasoning: state.reasoning,
+        usage: state.usage,
+        metrics,
+        blocks: state.blocks,
+        audios: state.audios,
+        videos: state.videos
+      };
+    },
+    /**
+     * Check if stream is complete
+     */
+    isDone() {
+      return state.isDone;
+    },
+    /**
+     * Reset parser state for reuse
+     */
+    reset() {
+      state.buffer = "";
+      state.content = "";
+      state.reasoning = "";
+      state.usage = void 0;
+      state.isDone = false;
+      state.streamStartTime = void 0;
+      state.firstTokenTime = void 0;
+      state.streamEndTime = void 0;
+      state.blocks = [];
+      state.currentBlockIndex = -1;
+      state.currentBlockType = "";
+      state.inputJsonBuffer = "";
+      state.audios = [];
+      state.videos = [];
+    }
+  };
+}
+async function streamSSEResponse(response, format, callbacks) {
+  debugSSE("streamSSEResponse started, format:", format);
+  const reader = response.body?.getReader();
+  if (!reader) {
+    callbacks.onError?.("No response body");
+    return { content: "", reasoning: "", blocks: [], audios: [], videos: [] };
+  }
+  const decoder = new TextDecoder();
+  const parser = createSSEParser(format, callbacks);
+  let chunkCount = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        debugSSE("Reader done signal received after", chunkCount, "chunks");
+        break;
+      }
+      const chunk = decoder.decode(value, { stream: true });
+      chunkCount++;
+      parser.push(chunk);
+      if (parser.isDone()) {
+        debugSSE("Parser isDone after", chunkCount, "chunks");
+        break;
+      }
+    }
+    parser.flush();
+    const result = parser.getResult();
+    debugSSE("streamSSEResponse complete, content length:", result.content.length, "completionTokens:", result.usage?.completionTokens, "usage:", result.usage);
+    return result;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/provider-proxy/ProviderProxy.ts
+var import_node_http = __toESM(require("http"), 1);
+
+// src/provider-proxy/providerProxyRouteMap.ts
+var import_node_crypto = require("crypto");
+var DEFAULT_ROUTE_IDLE_MS = 10 * 60 * 1e3;
+
+// src/pipeline/resolveProviderChain.ts
+async function resolveProviderChain(llmConfig, providerId, model) {
+  const cachedChain = await llmConfig.resolveTransformerChain(providerId, model);
+  const mainTransformer = await llmConfig.getMainTransformer(providerId);
+  const chain = {
+    providerTransformers: [...cachedChain.providerTransformers],
+    modelTransformers: [...cachedChain.modelTransformers]
+  };
+  if (mainTransformer) {
+    const alreadyInChain = chain.providerTransformers.some(
+      (t) => t.name === mainTransformer.name
+    );
+    if (!alreadyInChain) {
+      chain.providerTransformers.unshift(mainTransformer);
+    }
+  }
+  const hasTransformers = chain.providerTransformers.length > 0 || chain.modelTransformers.length > 0;
+  return { chain, mainTransformer, hasTransformers };
+}
+
+// src/transformer/anthropicBetaInject.ts
+var import_extended_context = require("@omnicross/contracts/extended-context");
+var EXTENDED_CONTEXT_BETA = "context-1m-2025-08-07";
+var ANTHROPIC_BETA_HEADER = "anthropic-beta";
+function injectExtendedContextBeta(headers, model, useExtendedContext) {
+  if (!useExtendedContext) return;
+  if (!(0, import_extended_context.isExtendedContextCapable)(model)) return;
+  let existingValue = "";
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === ANTHROPIC_BETA_HEADER) {
+      const v = headers[key];
+      if (typeof v === "string") existingValue = v;
+      if (key !== ANTHROPIC_BETA_HEADER) delete headers[key];
+    }
+  }
+  const parts = existingValue.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (!parts.includes(EXTENDED_CONTEXT_BETA)) {
+    parts.push(EXTENDED_CONTEXT_BETA);
+  }
+  headers[ANTHROPIC_BETA_HEADER] = parts.join(",");
+}
+
+// src/pipeline/executeProviderCall.ts
+async function executeProviderCall(ctx) {
+  const {
+    executor,
+    request,
+    provider,
+    chain,
+    endpointTransformer,
+    extendedContext,
+    resolveUrl,
+    buildHeaders,
+    prepareBody,
+    fetchFn,
+    runResponseChain = false,
+    responseChainRequest
+  } = ctx;
+  const { requestBody, config } = await executor.executeRequestChain(
+    request,
+    provider,
+    chain,
+    { endpointTransformer, extendedContext }
+  );
+  const finalBody = prepareBody ? await prepareBody(requestBody, config) : requestBody;
+  const url = resolveUrl(config);
+  const headers = buildHeaders(config);
+  const fetched = await fetchFn(url, headers, finalBody);
+  let response = fetched;
+  if (runResponseChain) {
+    response = await executor.executeResponseChain(
+      // Preserve the EXACT first arg each site passed: proxy → requestBody,
+      // unified ingresses → their pre-transform request. The caller supplies
+      // it via `responseChainRequest`; fall back to `requestBody` (the proxy
+      // shape) so the contract is never silently `undefined`.
+      responseChainRequest ?? requestBody,
+      fetched,
+      provider,
+      chain,
+      { endpointTransformer }
+    );
+  }
+  return { response, requestBody, finalBody, config, url, headers };
+}
+
+// src/transformer/TransformerChainExecutor.ts
+var defaultLogger = {
+  debug: (msg, ...args) => console.debug(`[ChainExecutor] ${msg}`, ...args),
+  info: (msg, ...args) => console.info(`[ChainExecutor] ${msg}`, ...args),
+  warn: (msg, ...args) => console.warn(`[ChainExecutor] ${msg}`, ...args),
+  error: (msg, ...args) => console.error(`[ChainExecutor] ${msg}`, ...args)
+};
+var TransformerChainExecutor = class {
+  logger;
+  constructor(logger) {
+    this.logger = logger ?? defaultLogger;
+  }
+  /**
+   * Execute the request transformation chain
+   *
+   * @param request - Original request body
+   * @param provider - LLM provider configuration
+   * @param chain - Resolved transformer chain
+   * @param options - Execution options
+   * @returns Transformed request result
+   */
+  async executeRequestChain(request, provider, chain, options = {}) {
+    const { endpointTransformer, headers, extendedContext } = options;
+    const context = {
+      logger: this.logger,
+      providerName: provider.name
+    };
+    let requestBody = request;
+    let config = {};
+    let bypass = false;
+    bypass = this.shouldBypassTransformers(
+      chain,
+      endpointTransformer,
+      requestBody
+    );
+    if (bypass) {
+      if (headers) {
+        const cleanHeaders = this.cleanHeaders(headers);
+        config.headers = cleanHeaders;
+      }
+      this.logger.debug("Bypass mode enabled - skipping transformations");
+    }
+    if (!bypass && endpointTransformer?.transformRequestOut) {
+      this.logger.debug("Executing transformRequestOut");
+      try {
+        const transformOut = await endpointTransformer.transformRequestOut(requestBody, context);
+        if (transformOut && typeof transformOut === "object") {
+          if ("body" in transformOut) {
+            requestBody = transformOut.body;
+            config = transformOut.config ?? {};
+          } else {
+            requestBody = transformOut;
+          }
+        }
+      } catch (error) {
+        this.logger.error(`transformRequestOut error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    if (!bypass && chain.providerTransformers.length > 0) {
+      this.logger.debug(`Executing ${chain.providerTransformers.length} provider transformers`);
+      for (const transformer of chain.providerTransformers) {
+        if (transformer.transformRequestIn) {
+          try {
+            const transformIn = await transformer.transformRequestIn(
+              requestBody,
+              provider,
+              context
+            );
+            if (transformIn && typeof transformIn === "object") {
+              if ("body" in transformIn) {
+                requestBody = transformIn.body;
+                config = { ...config, ...transformIn.config };
+              } else {
+                requestBody = transformIn;
+              }
+            }
+          } catch (error) {
+            this.logger.error(
+              `Provider transformer ${transformer.name} error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (!bypass && chain.modelTransformers.length > 0) {
+      this.logger.debug(`Executing ${chain.modelTransformers.length} model transformers`);
+      for (const transformer of chain.modelTransformers) {
+        if (transformer.transformRequestIn) {
+          try {
+            const result = await transformer.transformRequestIn(
+              requestBody,
+              provider,
+              context
+            );
+            requestBody = result;
+          } catch (error) {
+            this.logger.error(
+              `Model transformer ${transformer.name} error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (extendedContext?.enabled) {
+      if (!config.headers || typeof config.headers !== "object") {
+        config.headers = {};
+      }
+      injectExtendedContextBeta(
+        config.headers,
+        extendedContext.model,
+        true
+      );
+    }
+    return { requestBody, config, bypass };
+  }
+  /**
+   * Execute the response transformation chain
+   *
+   * @param request - Original request (for context)
+   * @param response - Response from provider
+   * @param provider - LLM provider configuration
+   * @param chain - Resolved transformer chain
+   * @param options - Execution options
+   * @returns Transformed response
+   */
+  async executeResponseChain(request, response, provider, chain, options = {}) {
+    const { endpointTransformer } = options;
+    const context = {
+      logger: this.logger,
+      providerName: provider.name
+    };
+    let finalResponse = response;
+    const bypass = this.shouldBypassTransformers(chain, endpointTransformer, request);
+    if (bypass) {
+      this.logger.debug("Bypass mode - skipping response transformations");
+      return finalResponse;
+    }
+    if (chain.modelTransformers.length > 0) {
+      const reversedModelTransformers = [...chain.modelTransformers].reverse();
+      this.logger.debug(
+        `Executing ${reversedModelTransformers.length} model response transformers (reversed)`
+      );
+      for (const transformer of reversedModelTransformers) {
+        if (transformer.transformResponseOut) {
+          try {
+            finalResponse = await transformer.transformResponseOut(finalResponse, context);
+          } catch (error) {
+            this.logger.error(
+              `Model transformer ${transformer.name} response error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (chain.providerTransformers.length > 0) {
+      const reversedProviderTransformers = [...chain.providerTransformers].reverse();
+      this.logger.debug(
+        `Executing ${reversedProviderTransformers.length} provider response transformers (reversed)`
+      );
+      for (const transformer of reversedProviderTransformers) {
+        if (transformer.transformResponseOut) {
+          try {
+            finalResponse = await transformer.transformResponseOut(finalResponse, context);
+          } catch (error) {
+            this.logger.error(
+              `Provider transformer ${transformer.name} response error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (endpointTransformer?.transformResponseIn) {
+      this.logger.debug("Executing transformResponseIn");
+      try {
+        finalResponse = await endpointTransformer.transformResponseIn(finalResponse, context);
+      } catch (error) {
+        this.logger.error(`transformResponseIn error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    return finalResponse;
+  }
+  /**
+   * Execute authentication handler if available
+   *
+   * @param request - Request body
+   * @param provider - LLM provider
+   * @param endpointTransformer - Endpoint transformer with auth handler
+   * @param context - Transformer context
+   * @returns Auth result with potentially modified request and config
+   */
+  async executeAuth(request, provider, endpointTransformer, context) {
+    let requestBody = request;
+    let config = {};
+    if (endpointTransformer?.auth) {
+      this.logger.debug("Executing auth handler");
+      try {
+        const auth = await endpointTransformer.auth(requestBody, provider, context);
+        if (auth && typeof auth === "object") {
+          if ("body" in auth) {
+            requestBody = auth.body;
+            const authConfig = auth.config;
+            if (authConfig) {
+              const headers = { ...config.headers ?? {}, ...authConfig.headers ?? {} };
+              delete headers["host"];
+              config = { ...config, ...authConfig, headers };
+            }
+          } else {
+            requestBody = auth;
+          }
+        }
+      } catch (error) {
+        this.logger.error(`Auth handler error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    return { requestBody, config };
+  }
+  /**
+   * Check if transformers should be bypassed (optimization)
+   *
+   * Bypass is enabled when:
+   * - Provider has only one transformer that matches the endpoint transformer
+   * - Model has no specific transformers or only the same endpoint transformer
+   */
+  shouldBypassTransformers(chain, endpointTransformer, _request) {
+    if (!endpointTransformer?.name) {
+      return false;
+    }
+    const providerHasOnlyEndpoint = chain.providerTransformers.length === 1 && chain.providerTransformers[0]?.name === endpointTransformer.name;
+    const modelHasNoTransformers = chain.modelTransformers.length === 0;
+    const modelHasOnlyEndpoint = chain.modelTransformers.length === 1 && chain.modelTransformers[0]?.name === endpointTransformer.name;
+    return providerHasOnlyEndpoint && (modelHasNoTransformers || modelHasOnlyEndpoint);
+  }
+  /**
+   * Clean headers for pass-through
+   */
+  cleanHeaders(headers) {
+    const result = {};
+    if (headers instanceof Headers) {
+      headers.forEach((value, key) => {
+        if (key.toLowerCase() !== "content-length") {
+          result[key] = value;
+        }
+      });
+    } else {
+      for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() !== "content-length") {
+          result[key] = value;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get error message from unknown error
+   */
+  getErrorMessage(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
+};
+
+// src/transformer/transformers/ReasoningTransformer.ts
+var import_thinking_config = require("@omnicross/contracts/thinking-config");
+
+// src/outbound-api/OutboundApiServer.ts
+var import_node_http2 = __toESM(require("http"), 1);
+var import_node_os = require("os");
+
+// src/outbound-api/outboundApiRouter.ts
+var import_node_stream = require("stream");
+
+// src/outbound-api/outboundApiKeyAuth.ts
+var import_node_crypto2 = require("crypto");
+
+// src/outbound-api/roleDetection.ts
+var import_canonical_models = require("@omnicross/contracts/canonical-models");
+
+// src/outbound-api/subscriptionSupport.ts
+var SUBSCRIPTION_PROVIDER_IDS = [
+  "claude",
+  "codex",
+  "gemini",
+  "opencodego"
+];
+var SUBSCRIPTION_ID_SET = new Set(SUBSCRIPTION_PROVIDER_IDS);
+
+// src/api-converter/shared.ts
+function convertOpenAITool(tool) {
+  return {
+    name: tool.function.name,
+    description: tool.function.description,
+    input_schema: tool.function.parameters
+  };
+}
+function mapAnthropicStopReason(stopReason) {
+  switch (stopReason) {
+    case "end_turn":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "tool_calls";
+    case "stop_sequence":
+      return "stop";
+    default:
+      return "stop";
+  }
+}
+
+// src/api-converter/anthropic-to-openai.ts
+function convertAnthropicToOpenAI(response) {
+  const content = [];
+  const toolCalls = [];
+  let reasoningContent = "";
+  for (const block of response.content) {
+    if (block.type === "text") {
+      content.push(block.text);
+    } else if (block.type === "tool_use") {
+      toolCalls.push({
+        id: block.id,
+        type: "function",
+        function: {
+          name: block.name,
+          arguments: JSON.stringify(block.input)
+        }
+      });
+    } else if (block.type === "thinking") {
+      reasoningContent += block.thinking;
+    }
+  }
+  const finishReason = mapAnthropicStopReason(response.stop_reason);
+  const result = {
+    id: response.id,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: response.model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: content.join("\n") || null,
+          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+        },
+        finish_reason: finishReason
+      }
+    ],
+    usage: {
+      prompt_tokens: response.usage.input_tokens,
+      completion_tokens: response.usage.output_tokens,
+      total_tokens: response.usage.input_tokens + response.usage.output_tokens
+    }
+  };
+  if (reasoningContent) {
+    result.reasoning_content = reasoningContent;
+  }
+  return result;
+}
+
+// src/api-converter/openai-to-anthropic.ts
+function convertOpenAIToAnthropic(request, config) {
+  const messages = [];
+  let system;
+  for (const msg of request.messages) {
+    if (msg.role === "system") {
+      if (typeof msg.content === "string") {
+        system = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        system = msg.content.filter((p) => p.type === "text").map((p) => ({ type: "text", text: p.text || "" }));
+      }
+      continue;
+    }
+    if (msg.role === "tool" && msg.tool_call_id) {
+      const toolResult = {
+        type: "tool_result",
+        tool_use_id: msg.tool_call_id,
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+      };
+      const lastMsg = messages[messages.length - 1];
+      if (lastMsg && lastMsg.role === "user" && Array.isArray(lastMsg.content)) {
+        lastMsg.content.push(toolResult);
+      } else {
+        messages.push({ role: "user", content: [toolResult] });
+      }
+      continue;
+    }
+    if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+      const content = [];
+      if (msg.content) {
+        if (typeof msg.content === "string") {
+          content.push({ type: "text", text: msg.content });
+        } else if (Array.isArray(msg.content)) {
+          for (const part of msg.content) {
+            if (part.type === "text" && part.text) {
+              content.push({ type: "text", text: part.text });
+            }
+          }
+        }
+      }
+      for (const tc of msg.tool_calls) {
+        content.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input: JSON.parse(tc.function.arguments || "{}")
+        });
+      }
+      messages.push({ role: "assistant", content });
+      continue;
+    }
+    if (msg.role === "user" || msg.role === "assistant") {
+      const content = convertOpenAIMessageContent(msg);
+      messages.push({ role: msg.role, content });
+    }
+  }
+  let model = request.model;
+  if (config.modelMapping && config.modelMapping[model]) {
+    model = config.modelMapping[model];
+  } else if (!model.startsWith("claude")) {
+    model = config.defaultModel;
+  }
+  const result = {
+    model,
+    // Anthropic requires max_tokens; use high default (16384) if not explicitly set
+    // This prevents output truncation for long responses
+    max_tokens: request.max_tokens || 16384,
+    messages,
+    stream: request.stream
+  };
+  if (system) {
+    result.system = system;
+  }
+  if (request.tools && request.tools.length > 0) {
+    result.tools = request.tools.map(convertOpenAITool);
+    if (request.tool_choice) {
+      if (request.tool_choice === "auto") {
+        result.tool_choice = { type: "auto" };
+      } else if (request.tool_choice === "required") {
+        result.tool_choice = { type: "any" };
+      } else if (typeof request.tool_choice === "object") {
+        result.tool_choice = {
+          type: "tool",
+          name: request.tool_choice.function.name
+        };
+      }
+    }
+  }
+  return result;
+}
+function convertOpenAIMessageContent(msg) {
+  if (typeof msg.content === "string") {
+    return msg.content;
+  }
+  if (!msg.content || !Array.isArray(msg.content)) {
+    return "";
+  }
+  const parts = [];
+  for (const part of msg.content) {
+    if (part.type === "text" && part.text) {
+      parts.push({ type: "text", text: part.text });
+    } else if (part.type === "image_url" && part.image_url) {
+      const url = part.image_url.url;
+      if (url.startsWith("data:")) {
+        const match = url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          parts.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: match[1],
+              data: match[2]
+            }
+          });
+        }
+      } else {
+        parts.push({
+          type: "image",
+          source: { type: "url", url }
+        });
+      }
+    }
+  }
+  return parts.length > 0 ? parts : "";
+}
+
+// src/completion/DirectApiHandler.ts
+async function callOpenAICompletion(provider, apiKey, options, logger) {
+  const request = {
+    model: options.model,
+    messages: options.messages.map((m) => convertMessageToOpenAI(m)),
+    // Only set max_tokens if explicitly provided, otherwise let API use its default
+    ...options.maxTokens ? { max_tokens: options.maxTokens } : {},
+    temperature: options.temperature,
+    stream: false
+    // For now, non-streaming only
+  };
+  if (options.thinkLevel && options.thinkLevel !== "none") {
+    const effort = (0, import_thinking_config2.getOpenAIReasoningEffort)(options.thinkLevel);
+    if (effort) {
+      request.reasoning_effort = effort;
+    }
+  }
+  const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: false });
+  const headers = getProviderHeaders(provider, apiKey);
+  logger.info("Calling OpenAI completion API", { url: apiUrl, model: options.model });
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(request)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    return {
+      success: false,
+      error: `API error (${response.status}): ${errorText}`
+    };
+  }
+  const data = await response.json();
+  const choice = data.choices[0];
+  return {
+    success: true,
+    message: {
+      id: `msg_${Date.now()}`,
+      role: "assistant",
+      content: choice.message.content || "",
+      timestamp: Date.now(),
+      thinking: data.reasoning_content ? { content: data.reasoning_content } : void 0
+    },
+    usage: {
+      promptTokens: data.usage.prompt_tokens,
+      completionTokens: data.usage.completion_tokens,
+      totalTokens: data.usage.total_tokens
+    }
+  };
+}
+async function callAnthropicCompletion(provider, apiKey, options, logger) {
+  const hasImages = options.messages.some((m) => m.images && m.images.length > 0);
+  if (hasImages) {
+    const systemMessages = options.messages.filter((m) => m.role === "system");
+    const nonSystemMessages = options.messages.filter((m) => m.role !== "system");
+    const anthropicRequest2 = {
+      model: options.model,
+      max_tokens: options.maxTokens || 16384,
+      temperature: options.temperature,
+      ...systemMessages.length > 0 ? { system: systemMessages.map((m) => m.content).join("\n\n") } : {},
+      messages: nonSystemMessages.map((m) => convertMessageToAnthropic(m)),
+      stream: false
+    };
+    const apiUrl2 = buildProviderApiUrl(provider, { model: options.model, stream: false });
+    const headers2 = getProviderHeaders(provider, apiKey);
+    logger.info("Calling Anthropic completion API with images", { url: apiUrl2, model: options.model });
+    const response2 = await fetch(apiUrl2, {
+      method: "POST",
+      headers: headers2,
+      body: JSON.stringify(anthropicRequest2)
+    });
+    if (!response2.ok) {
+      const errorText = await response2.text();
+      return {
+        success: false,
+        error: `API error (${response2.status}): ${errorText}`
+      };
+    }
+    const anthropicResponse2 = await response2.json();
+    const openaiResponse2 = convertAnthropicToOpenAI(anthropicResponse2);
+    const choice2 = openaiResponse2.choices[0];
+    return {
+      success: true,
+      message: {
+        id: `assistant-${Date.now()}`,
+        role: "assistant",
+        content: choice2.message?.content || "",
+        timestamp: Date.now()
+      },
+      usage: openaiResponse2.usage ? {
+        promptTokens: openaiResponse2.usage.prompt_tokens,
+        completionTokens: openaiResponse2.usage.completion_tokens,
+        totalTokens: openaiResponse2.usage.total_tokens
+      } : void 0
+    };
+  }
+  const openaiRequest = {
+    model: options.model,
+    messages: options.messages.map((m) => ({
+      role: m.role,
+      content: m.content
+    })),
+    // Anthropic requires max_tokens; use 16384 default if not explicitly set
+    max_tokens: options.maxTokens || 16384,
+    temperature: options.temperature,
+    stream: false
+  };
+  const config = {
+    defaultModel: options.model
+  };
+  const anthropicRequest = convertOpenAIToAnthropic(openaiRequest, config);
+  const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: false });
+  const headers = getProviderHeaders(provider, apiKey);
+  logger.info("Calling Anthropic completion API", { url: apiUrl, model: options.model });
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(anthropicRequest)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    return {
+      success: false,
+      error: `API error (${response.status}): ${errorText}`
+    };
+  }
+  const anthropicResponse = await response.json();
+  const openaiResponse = convertAnthropicToOpenAI(anthropicResponse);
+  const choice = openaiResponse.choices[0];
+  return {
+    success: true,
+    message: {
+      id: `msg_${Date.now()}`,
+      role: "assistant",
+      content: choice.message.content || "",
+      timestamp: Date.now(),
+      thinking: openaiResponse.reasoning_content ? { content: openaiResponse.reasoning_content } : void 0
+    },
+    usage: {
+      promptTokens: openaiResponse.usage.prompt_tokens,
+      completionTokens: openaiResponse.usage.completion_tokens,
+      totalTokens: openaiResponse.usage.total_tokens
+    }
+  };
+}
+async function callGeminiCompletion(provider, apiKey, options, logger) {
+  const contents = [];
+  let systemInstruction;
+  for (const msg of options.messages) {
+    if (msg.role === "system") {
+      systemInstruction = { parts: [{ text: msg.content }] };
+    } else {
+      contents.push(convertMessageToGemini(msg));
+    }
+  }
+  const request = {
+    contents,
+    generationConfig: {
+      ...options.maxTokens ? { maxOutputTokens: options.maxTokens } : {},
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+    }
+  };
+  if (systemInstruction) {
+    request.systemInstruction = systemInstruction;
+  }
+  const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: false });
+  const headers = getProviderHeaders(provider, apiKey);
+  logger.info("Calling Gemini completion API", { url: apiUrl, model: options.model });
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(request)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    return {
+      success: false,
+      error: `API error (${response.status}): ${errorText}`
+    };
+  }
+  const data = await response.json();
+  const candidates = data.candidates;
+  if (!candidates || candidates.length === 0) {
+    return {
+      success: false,
+      error: "No candidates in response"
+    };
+  }
+  const candidate = candidates[0];
+  const content = candidate.content;
+  let textContent = "";
+  if (content?.parts) {
+    for (const part of content.parts) {
+      if (part.text) {
+        textContent += part.text;
+      }
+    }
+  }
+  const usage = data.usageMetadata;
+  return {
+    success: true,
+    message: {
+      id: `msg_${Date.now()}`,
+      role: "assistant",
+      content: textContent,
+      timestamp: Date.now()
+    },
+    usage: usage ? {
+      promptTokens: usage.promptTokenCount || 0,
+      completionTokens: usage.candidatesTokenCount || 0,
+      totalTokens: usage.totalTokenCount || 0
+    } : void 0
+  };
+}
+async function callOpenAIResponseCompletion(provider, apiKey, options, logger) {
+  const input = [];
+  for (const msg of options.messages) {
+    if (msg.role === "system") {
+      input.push({ role: "developer", content: msg.content });
+    } else {
+      input.push({ role: msg.role, content: msg.content });
+    }
+  }
+  const request = {
+    model: options.model,
+    input,
+    stream: false,
+    ...options.maxTokens ? { max_output_tokens: options.maxTokens } : {},
+    ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+  };
+  if (options.thinkLevel && options.thinkLevel !== "none") {
+    const effort = (0, import_thinking_config2.getOpenAIReasoningEffort)(options.thinkLevel);
+    if (effort) {
+      request.reasoning = { effort, summary: "auto" };
+    }
+  }
+  const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: false });
+  const headers = getProviderHeaders(provider, apiKey);
+  logger.info("Calling OpenAI Response API", { url: apiUrl, model: options.model });
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(request)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    return {
+      success: false,
+      error: `API error (${response.status}): ${errorText}`
+    };
+  }
+  const data = await response.json();
+  let textContent = "";
+  const output = data.output;
+  if (output) {
+    for (const item of output) {
+      if (item.type === "message") {
+        const content = item.content;
+        if (content) {
+          for (const part of content) {
+            if (part.type === "output_text" && typeof part.text === "string") {
+              textContent += part.text;
+            }
+          }
+        }
+      }
+    }
+  }
+  const usage = data.usage;
+  return {
+    success: true,
+    message: {
+      id: `msg_${Date.now()}`,
+      role: "assistant",
+      content: textContent,
+      timestamp: Date.now()
+    },
+    usage: usage ? {
+      promptTokens: usage.input_tokens || 0,
+      completionTokens: usage.output_tokens || 0,
+      totalTokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
+    } : void 0
+  };
+}
+
+// src/completion/StreamHandler.ts
+var import_thinking_config3 = require("@omnicross/contracts/thinking-config");
+async function streamOpenAICompletion(provider, apiKey, options, messageId, callbacks, logger) {
+  const request = {
+    model: options.model,
+    messages: options.messages.map((m) => convertMessageToOpenAI(m)),
+    // Only set max_tokens if explicitly provided, otherwise let API use its default
+    ...options.maxTokens ? { max_tokens: options.maxTokens } : {},
+    temperature: options.temperature,
+    stream: true
+  };
+  if (options.thinkLevel && options.thinkLevel !== "none") {
+    const effort = (0, import_thinking_config3.getOpenAIReasoningEffort)(options.thinkLevel);
+    if (effort) {
+      request.reasoning_effort = effort;
+    }
+  }
+  const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: true });
+  const headers = getProviderHeaders(provider, apiKey);
+  if (options.nativeSearchAugmentation) {
+    applyAugmentation(request, options.nativeSearchAugmentation);
+  }
+  logger.info("Streaming OpenAI completion request", {
+    url: apiUrl,
+    providerId: options.providerId,
+    model: options.model,
+    maxTokens: options.maxTokens,
+    max_tokens_in_request: request.max_tokens,
+    temperature: options.temperature,
+    messagesCount: options.messages.length,
+    hasNativeSearchAugmentation: !!options.nativeSearchAugmentation
+  });
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(request)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    callbacks.onError?.(`API error (${response.status}): ${errorText}`);
+    return;
+  }
+  const result = await streamSSEResponse(response, "openai", {
+    onDelta: callbacks.onDelta,
+    onReasoning: callbacks.onReasoning,
+    onAudio: callbacks.onAudio,
+    onVideo: callbacks.onVideo,
+    onError: callbacks.onError
+  });
+  callbacks.onDone?.(
+    {
+      id: messageId,
+      role: "assistant",
+      content: result.content,
+      timestamp: Date.now(),
+      thinking: result.reasoning ? { content: result.reasoning } : void 0,
+      audios: result.audios.length > 0 ? result.audios : void 0,
+      videos: result.videos.length > 0 ? result.videos : void 0
+    },
+    result.usage,
+    result.metrics
+  );
+}
+async function streamAnthropicCompletion(provider, apiKey, options, messageId, callbacks, logger) {
+  const hasImages = options.messages.some((m) => m.images && m.images.length > 0);
+  const MAX_TOKENS_FOR_THINKING = 16384;
+  let effectiveMaxTokens = options.maxTokens || 16384;
+  const thinkingMaxTokens = options.thinkLevel && options.thinkLevel !== "none" ? Math.min(effectiveMaxTokens, MAX_TOKENS_FOR_THINKING) : effectiveMaxTokens;
+  const thinkingConfig = options.thinkLevel && options.thinkLevel !== "none" ? (0, import_thinking_config3.buildAnthropicThinking)(options.model, options.thinkLevel, thinkingMaxTokens) : void 0;
+  if (thinkingConfig) {
+    effectiveMaxTokens = thinkingMaxTokens;
+  }
+  logger.debug("Anthropic thinking configuration", {
+    thinkLevel: options.thinkLevel,
+    thinkingConfig,
+    effectiveMaxTokens
+  });
+  let anthropicRequest;
+  if (hasImages) {
+    const systemMessages = options.messages.filter((m) => m.role === "system");
+    const nonSystemMessages = options.messages.filter((m) => m.role !== "system");
+    anthropicRequest = {
+      model: options.model,
+      max_tokens: effectiveMaxTokens,
+      // Omit temperature when thinking is enabled (Anthropic will use default temperature=1)
+      ...thinkingConfig ? {} : { temperature: options.temperature },
+      ...systemMessages.length > 0 ? { system: systemMessages.map((m) => m.content).join("\n\n") } : {},
+      messages: nonSystemMessages.map((m) => convertMessageToAnthropic(m)),
+      stream: true,
+      ...thinkingConfig ? { thinking: thinkingConfig } : {}
+    };
+  } else {
+    const config = {
+      defaultModel: options.model
+    };
+    const openaiRequest = {
+      model: options.model,
+      messages: options.messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      // Anthropic requires max_tokens; use adjusted value
+      max_tokens: effectiveMaxTokens,
+      // Omit temperature when thinking is enabled (Anthropic will use default temperature=1)
+      temperature: thinkingConfig ? void 0 : options.temperature,
+      stream: true
+    };
+    anthropicRequest = convertOpenAIToAnthropic(openaiRequest, config);
+    if (thinkingConfig) {
+      anthropicRequest.thinking = thinkingConfig;
+      delete anthropicRequest.temperature;
+    }
+  }
+  const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: true });
+  const headers = getProviderHeaders(provider, apiKey);
+  if (options.nativeSearchAugmentation) {
+    applyAugmentation(anthropicRequest, options.nativeSearchAugmentation);
+  }
+  logger.info("Streaming Anthropic completion request", {
+    url: apiUrl,
+    model: anthropicRequest.model,
+    messagesCount: anthropicRequest.messages?.length,
+    max_tokens: anthropicRequest.max_tokens,
+    temperature: anthropicRequest.temperature,
+    stream: anthropicRequest.stream,
+    hasImages,
+    hasThinking: !!anthropicRequest.thinking,
+    hasNativeSearchAugmentation: !!options.nativeSearchAugmentation
+  });
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(anthropicRequest)
+  });
+  logger.debug("Anthropic response status", { status: response.status });
+  if (!response.ok) {
+    const errorText = await response.text();
+    logger.error("Anthropic API error", void 0, { status: response.status, errorText });
+    callbacks.onError?.(`API error (${response.status}): ${errorText}`);
+    return;
+  }
+  const result = await streamSSEResponse(response, "anthropic", {
+    onDelta: callbacks.onDelta,
+    onReasoning: callbacks.onReasoning,
+    onError: callbacks.onError,
+    onBlock: callbacks.onBlock
+  });
+  logger.info("Anthropic stream complete", {
+    contentLength: result.content.length,
+    reasoningLength: result.reasoning?.length || 0,
+    blocksCount: result.blocks.length
+  });
+  callbacks.onDone?.(
+    {
+      id: messageId,
+      role: "assistant",
+      content: result.content,
+      timestamp: Date.now(),
+      thinking: result.reasoning ? { content: result.reasoning } : void 0,
+      blocks: result.blocks.length > 0 ? result.blocks : void 0
+    },
+    result.usage,
+    result.metrics
+  );
+}
+async function streamGeminiCompletion(provider, apiKey, options, messageId, callbacks, logger) {
+  const contents = [];
+  let systemInstruction;
+  for (const msg of options.messages) {
+    if (msg.role === "system") {
+      systemInstruction = { parts: [{ text: msg.content }] };
+    } else {
+      contents.push(convertMessageToGemini(msg));
+    }
+  }
+  const request = {
+    contents,
+    generationConfig: {
+      ...options.maxTokens ? { maxOutputTokens: options.maxTokens } : {},
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+    }
+  };
+  if (systemInstruction) {
+    request.systemInstruction = systemInstruction;
+  }
+  const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: true });
+  const headers = getProviderHeaders(provider, apiKey);
+  if (options.nativeSearchAugmentation) {
+    applyAugmentation(request, options.nativeSearchAugmentation);
+  }
+  logger.info("Streaming Gemini completion request", {
+    url: apiUrl,
+    model: options.model,
+    contentsCount: contents.length,
+    hasSystemInstruction: !!systemInstruction,
+    maxOutputTokens: options.maxTokens,
+    temperature: options.temperature,
+    hasNativeSearchAugmentation: !!options.nativeSearchAugmentation
+  });
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(request)
+  });
+  logger.debug("Gemini response status", { status: response.status });
+  if (!response.ok) {
+    const errorText = await response.text();
+    logger.error("Gemini API error", void 0, { status: response.status, errorText });
+    callbacks.onError?.(`API error (${response.status}): ${errorText}`);
+    return;
+  }
+  const result = await streamSSEResponse(response, "gemini", {
+    onDelta: callbacks.onDelta,
+    onReasoning: callbacks.onReasoning,
+    onError: callbacks.onError
+  });
+  logger.info("Gemini stream complete", { contentLength: result.content.length });
+  callbacks.onDone?.(
+    {
+      id: messageId,
+      role: "assistant",
+      content: result.content,
+      timestamp: Date.now(),
+      thinking: result.reasoning ? { content: result.reasoning } : void 0
+    },
+    result.usage,
+    result.metrics
+  );
+}
+async function streamOpenAIResponseCompletion(provider, apiKey, options, messageId, callbacks, logger) {
+  const input = [];
+  for (const msg of options.messages) {
+    if (msg.role === "system") {
+      input.push({ role: "developer", content: msg.content });
+    } else {
+      input.push({ role: msg.role, content: msg.content });
+    }
+  }
+  const request = {
+    model: options.model,
+    input,
+    stream: true,
+    ...options.maxTokens ? { max_output_tokens: options.maxTokens } : {},
+    ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+  };
+  if (options.thinkLevel && options.thinkLevel !== "none") {
+    const effort = (0, import_thinking_config3.getOpenAIReasoningEffort)(options.thinkLevel);
+    if (effort) {
+      request.reasoning = { effort, summary: "auto" };
+    }
+  }
+  const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: true });
+  const headers = getProviderHeaders(provider, apiKey);
+  logger.info("Streaming OpenAI Response API request", {
+    url: apiUrl,
+    providerId: options.providerId,
+    model: options.model,
+    maxOutputTokens: options.maxTokens,
+    temperature: options.temperature,
+    inputCount: input.length,
+    reasoning: request.reasoning
+  });
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(request)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    callbacks.onError?.(`API error (${response.status}): ${errorText}`);
+    return;
+  }
+  const result = await streamSSEResponse(response, "openai-response", {
+    onDelta: callbacks.onDelta,
+    onReasoning: callbacks.onReasoning,
+    onError: callbacks.onError
+  });
+  logger.info("OpenAI Response API stream complete", { contentLength: result.content.length });
+  callbacks.onDone?.(
+    {
+      id: messageId,
+      role: "assistant",
+      content: result.content,
+      timestamp: Date.now(),
+      thinking: result.reasoning ? { content: result.reasoning } : void 0
+    },
+    result.usage,
+    result.metrics
+  );
+}
+
+// src/completion/ThinkingResolver.ts
+var import_thinking_config4 = require("@omnicross/contracts/thinking-config");
+async function resolveEffectiveMaxTokens(llmConfig, getProvider, logger, providerId, modelId, sessionMaxTokens) {
+  if (sessionMaxTokens !== void 0 && sessionMaxTokens > 0) {
+    logger.debug("Using session maxTokens", { sessionMaxTokens });
+    return sessionMaxTokens;
+  }
+  try {
+    const globalParams = await llmConfig.getGlobalModelParameters();
+    if (globalParams?.maxTokens?.enabled && globalParams.maxTokens.value > 0) {
+      logger.debug("Using global maxTokens", { maxTokens: globalParams.maxTokens.value });
+      return globalParams.maxTokens.value;
+    }
+  } catch (err) {
+    logger.warn("Failed to get global params", err instanceof Error ? err : void 0);
+  }
+  const MAX_TOKENS_CAP = 131072;
+  const provider = await getProvider(providerId);
+  if (provider) {
+    const modelConfig = provider.modelConfigs?.find((m) => m.id === modelId);
+    if (modelConfig?.maxTokens && modelConfig.maxTokens > 0) {
+      const cappedMaxTokens = Math.min(modelConfig.maxTokens, MAX_TOKENS_CAP);
+      logger.debug("Using model config maxTokens", {
+        maxTokens: modelConfig.maxTokens,
+        cappedMaxTokens
+      });
+      return cappedMaxTokens;
+    }
+    if (provider.modelGroups) {
+      for (const group of provider.modelGroups) {
+        const model = group.models?.find((m) => m.id === modelId);
+        if (model?.maxTokens && model.maxTokens > 0) {
+          const cappedMaxTokens = Math.min(model.maxTokens, MAX_TOKENS_CAP);
+          logger.debug("Using modelGroup model maxTokens", {
+            maxTokens: model.maxTokens,
+            cappedMaxTokens
+          });
+          return cappedMaxTokens;
+        }
+      }
+    }
+  }
+  try {
+    const discoveredMaxTokens = await llmConfig.getDiscoveredModelMaxTokens(providerId, modelId);
+    if (discoveredMaxTokens && discoveredMaxTokens > 0) {
+      const cappedMaxTokens = Math.min(discoveredMaxTokens, MAX_TOKENS_CAP);
+      logger.debug("Using discovered model maxTokens", {
+        discoveredMaxTokens,
+        cappedMaxTokens
+      });
+      return cappedMaxTokens;
+    }
+  } catch (err) {
+    logger.warn("Failed to get discovered model maxTokens", err instanceof Error ? err : void 0);
+  }
+  logger.debug("No maxTokens configured, returning undefined");
+  return void 0;
+}
+async function getRequiredMaxTokens(llmConfig, getProvider, logger, providerId, modelId, sessionMaxTokens) {
+  const resolved = await resolveEffectiveMaxTokens(llmConfig, getProvider, logger, providerId, modelId, sessionMaxTokens);
+  if (resolved !== void 0) {
+    return resolved;
+  }
+  logger.debug("Using default maxTokens", { defaultMaxTokens: import_thinking_config4.DEFAULT_MAX_TOKENS });
+  return import_thinking_config4.DEFAULT_MAX_TOKENS;
+}
+async function resolveThinkingBudget(getProvider, logger, providerId, modelId, maxTokens, thinkLevel) {
+  if (thinkLevel === "none" || !(0, import_thinking_config4.isReasoningModel)(modelId)) {
+    return {
+      adjustedMaxTokens: maxTokens,
+      thinkingBudget: void 0,
+      thinkingConfig: void 0
+    };
+  }
+  const thinkingBudget = (0, import_thinking_config4.calculateThinkingBudget)(modelId, thinkLevel, maxTokens);
+  const provider = await getProvider(providerId);
+  const providerName = provider?.name?.toLowerCase() || "";
+  const apiFormat = provider ? resolveApiFormat(provider) : "openai";
+  if (apiFormat === "anthropic" || providerName === "anthropic" || providerName.includes("claude")) {
+    const thinkingConfig = (0, import_thinking_config4.buildAnthropicThinking)(modelId, thinkLevel, maxTokens);
+    const adjustedMaxTokens = (0, import_thinking_config4.getClaudeMaxTokens)(maxTokens, thinkingBudget) || maxTokens;
+    logger.debug("Claude model thinking budget", {
+      thinkingBudget,
+      adjustedMaxTokens
+    });
+    return {
+      adjustedMaxTokens,
+      thinkingBudget,
+      thinkingConfig
+    };
+  }
+  logger.debug("Non-Claude model thinking budget", { thinkingBudget });
+  return {
+    adjustedMaxTokens: maxTokens,
+    thinkingBudget,
+    thinkingConfig: thinkingBudget ? { type: "enabled", budget_tokens: thinkingBudget } : void 0
+  };
+}
+
+// src/completion/ToolExecutor.ts
+function logToolFormat(tools, logger) {
+  if (!Array.isArray(tools) || tools.length === 0) {
+    logger.warn("No tools provided");
+    return;
+  }
+  const firstTool = tools[0];
+  if ("function" in firstTool) {
+    const openaiTools = tools;
+    logger.info("Tools configured (OpenAI format)", {
+      count: openaiTools.length,
+      tools: openaiTools.map((t) => t.function.name),
+      firstTool: {
+        name: firstTool.function.name,
+        description: firstTool.function.description?.slice(0, 100),
+        parameters: firstTool.function.parameters
+      }
+    });
+  } else if ("input_schema" in firstTool) {
+    const anthropicTools = tools;
+    logger.info("Tools configured (Anthropic format)", {
+      count: anthropicTools.length,
+      tools: anthropicTools.map((t) => t.name),
+      firstTool: {
+        name: firstTool.name,
+        description: firstTool.description?.slice(0, 100),
+        input_schema: firstTool.input_schema
+      }
+    });
+  } else if ("functionDeclarations" in firstTool) {
+    const geminiTools = tools;
+    const allDeclarations = geminiTools.flatMap((t) => t.functionDeclarations);
+    logger.info("Tools configured (Gemini format)", {
+      count: allDeclarations.length,
+      tools: allDeclarations.map((t) => t.name),
+      firstTool: {
+        name: allDeclarations[0]?.name,
+        description: allDeclarations[0]?.description?.slice(0, 100),
+        parameters: allDeclarations[0]?.parameters
+      }
+    });
+  }
+}
+function buildToolRequest(apiFormat, conversationMessages, actualModel, options, provider) {
+  let requestBody;
+  let url;
+  if (apiFormat === "google") {
+    const contents = [];
+    for (const msg of conversationMessages) {
+      if (msg.role !== "system") {
+        contents.push({
+          role: msg.role === "assistant" ? "model" : "user",
+          parts: [{ text: msg.content }]
+        });
+      }
+    }
+    requestBody = {
+      contents,
+      tools: options.tools
+    };
+    url = buildProviderApiUrl(provider, { model: actualModel, stream: true });
+  } else if (apiFormat === "anthropic") {
+    requestBody = {
+      model: actualModel,
+      messages: conversationMessages.filter((m) => m.role !== "system").map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      max_tokens: options.maxTokens || 4096,
+      temperature: options.temperature ?? 0.7,
+      stream: true,
+      tools: options.tools
+    };
+    const systemMsg = conversationMessages.find((m) => m.role === "system");
+    if (systemMsg) {
+      requestBody.system = systemMsg.content;
+    }
+    url = buildProviderApiUrl(provider, { model: actualModel, stream: true });
+  } else {
+    requestBody = {
+      model: actualModel,
+      messages: conversationMessages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      max_tokens: options.maxTokens || 4096,
+      temperature: options.temperature ?? 0.7,
+      stream: true,
+      tools: options.tools
+    };
+    url = buildProviderApiUrl(provider, { model: actualModel, stream: true });
+  }
+  return { requestBody, url };
+}
+function extractDeltaContent(rawJson, apiFormat) {
+  const json = rawJson;
+  if (apiFormat === "google") {
+    const parts = json.candidates?.[0]?.content?.parts || [];
+    let text = "";
+    for (const part of parts) {
+      if (part.thought === true) continue;
+      if (part.text) text += part.text;
+    }
+    return text;
+  } else if (apiFormat === "anthropic") {
+    return json.delta?.text || "";
+  } else {
+    return json.choices?.[0]?.delta?.content || "";
+  }
+}
+function extractDeltaReasoning(rawJson, apiFormat) {
+  const json = rawJson;
+  if (apiFormat === "google") {
+    const parts = json.candidates?.[0]?.content?.parts || [];
+    let reasoning = "";
+    for (const part of parts) {
+      if (part.thought === true && part.text) reasoning += part.text;
+    }
+    return reasoning;
+  } else if (apiFormat === "anthropic") {
+    return "";
+  } else {
+    const delta = json.choices?.[0]?.delta;
+    return (delta?.thinking?.content || "") + (delta?.reasoning_content || "");
+  }
+}
+function extractToolCalls(rawJson, apiFormat, toolCalls, callbacks, logger, pendingOpenAIToolCalls) {
+  const json = rawJson;
+  if (apiFormat === "google") {
+    const parts = json.candidates?.[0]?.content?.parts || [];
+    for (const part of parts) {
+      if (part.functionCall) {
+        logger.info("Function call detected", { functionCall: part.functionCall });
+        const toolCall = {
+          id: `call_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+          name: part.functionCall.name,
+          args: part.functionCall.args || {}
+        };
+        toolCalls.push(toolCall);
+        callbacks.onToolCall?.(toolCall);
+        logger.info("Tool called", { toolName: toolCall.name });
+      }
+    }
+  } else if (apiFormat !== "anthropic") {
+    const delta = json.choices?.[0]?.delta;
+    if (delta?.tool_calls && pendingOpenAIToolCalls) {
+      for (const tc of delta.tool_calls) {
+        const index = tc.index ?? 0;
+        let pending = pendingOpenAIToolCalls.get(index);
+        if (!pending) {
+          pending = { id: "", name: "", arguments: "" };
+          pendingOpenAIToolCalls.set(index, pending);
+        }
+        if (tc.id) pending.id = tc.id;
+        if (tc.function?.name) pending.name += tc.function.name;
+        if (tc.function?.arguments) pending.arguments += tc.function.arguments;
+      }
+    }
+  }
+}
+function finalizeOpenAIToolCalls(pendingOpenAIToolCalls, toolCalls, callbacks, logger) {
+  for (const [, pending] of pendingOpenAIToolCalls) {
+    if (pending.name) {
+      try {
+        const toolCall = {
+          id: pending.id || `tool_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+          name: pending.name,
+          args: JSON.parse(pending.arguments || "{}")
+        };
+        toolCalls.push(toolCall);
+        callbacks.onToolCall?.(toolCall);
+        logger.info("Tool called (OpenAI)", { toolName: toolCall.name, args: toolCall.args });
+      } catch (e) {
+        logger.error("Failed to parse OpenAI tool call arguments", e instanceof Error ? e : void 0, {
+          name: pending.name,
+          arguments: pending.arguments
+        });
+      }
+    }
+  }
+}
+function parseStreamChunk(rawJson, apiFormat, callbacks, logger) {
+  const json = rawJson;
+  if (apiFormat === "google") {
+    const candidate = json.candidates?.[0];
+    if (!candidate) {
+      logger.warn("No candidate found in Gemini response");
+      return;
+    }
+    const parts = candidate.content?.parts || [];
+    for (const part of parts) {
+      if (part.thought === true && part.text) {
+        callbacks.onReasoning?.(part.text);
+        continue;
+      } else if (part.thoughtSignature && !part.thought) {
+        logger.debug("Gemini returned thoughtSignature without thought content");
+      }
+      if (part.text) {
+        callbacks.onDelta?.(part.text);
+      }
+    }
+  } else if (apiFormat === "anthropic") {
+    const delta = json.delta;
+    if (delta?.text) {
+      callbacks.onDelta?.(delta.text);
+    }
+  } else {
+    const delta = json.choices?.[0]?.delta;
+    if (delta?.content) {
+      callbacks.onDelta?.(delta.content);
+    }
+    if (delta?.thinking?.content) {
+      callbacks.onReasoning?.(delta.thinking.content);
+    }
+    if (delta?.reasoning_content) {
+      callbacks.onReasoning?.(delta.reasoning_content);
+    }
+  }
+}
+function buildIterationBlocks(iteration, content, reasoning, blocks, callbacks) {
+  const blockIdPrefix = `block_${iteration}_${Date.now()}`;
+  if (reasoning && reasoning.trim()) {
+    const thinkingBlock = {
+      id: `${blockIdPrefix}_thinking`,
+      type: "thinking",
+      content: reasoning
+    };
+    blocks.push(thinkingBlock);
+    callbacks.onBlock?.(thinkingBlock);
+  }
+  if (content && content.trim()) {
+    const textBlock = {
+      id: `${blockIdPrefix}_text`,
+      type: "text",
+      content
+    };
+    blocks.push(textBlock);
+    callbacks.onBlock?.(textBlock);
+  }
+}
+async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbacks, logger, builtinExecutor) {
+  const toolResults = [];
+  for (const toolCall of toolCalls) {
+    const toolUseBlock = {
+      id: `${toolCall.id}_use`,
+      type: "tool_use",
+      toolId: toolCall.id,
+      toolName: toolCall.name,
+      input: toolCall.args,
+      status: "running"
+    };
+    blocks.push(toolUseBlock);
+    callbacks.onBlock?.(toolUseBlock);
+    try {
+      logger.info("Executing tool", { toolName: toolCall.name });
+      const mcpTool = mcpTools.find((t) => t.id === toolCall.name);
+      if (!mcpTool) {
+        logger.error("Tool not found", void 0, { toolName: toolCall.name });
+        continue;
+      }
+      logger.debug("Tool info", {
+        serverId: mcpTool.serverId,
+        toolName: mcpTool.name,
+        args: toolCall.args
+      });
+      const mappedArgs = mapToolArguments(toolCall.args, mcpTool, logger);
+      let result;
+      if (mcpTool.serverId === "builtin" && builtinExecutor) {
+        result = await builtinExecutor.execute(mcpTool.name, mappedArgs);
+      } else if (mcpService) {
+        result = await mcpService.callTool(mcpTool.serverId, mcpTool.name, mappedArgs, toolCall.id);
+      } else {
+        result = { isError: true, content: [{ type: "text", text: "MCP service not available" }] };
+      }
+      logger.info("Tool result received", { result });
+      callbacks.onToolResult?.(toolCall.id, result);
+      const resultText = result.content?.[0]?.text || JSON.stringify(result);
+      const toolResultBlock = {
+        id: `${toolCall.id}_result`,
+        type: "tool_result",
+        toolId: toolCall.id,
+        toolName: toolCall.name,
+        output: resultText,
+        isError: result.isError
+      };
+      blocks.push(toolResultBlock);
+      callbacks.onBlock?.(toolResultBlock);
+      const toolUseBlockRef = blocks.find((b) => b.id === `${toolCall.id}_use`);
+      if (toolUseBlockRef && toolUseBlockRef.type === "tool_use") {
+        toolUseBlockRef.status = result.isError ? "error" : "completed";
+        callbacks.onBlock?.({ ...toolUseBlockRef });
+      }
+      toolResults.push({ toolCall, result });
+    } catch (error) {
+      logger.error("Tool execution error", error instanceof Error ? error : void 0);
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      const errorResult = {
+        isError: true,
+        content: [{ type: "text", text: `Error: ${errorMessage}` }]
+      };
+      callbacks.onToolResult?.(toolCall.id, errorResult);
+      const errorToolResultBlock = {
+        id: `${toolCall.id}_result`,
+        type: "tool_result",
+        toolId: toolCall.id,
+        toolName: toolCall.name,
+        error: errorMessage,
+        isError: true
+      };
+      blocks.push(errorToolResultBlock);
+      callbacks.onBlock?.(errorToolResultBlock);
+      const errorToolUseBlockRef = blocks.find((b) => b.id === `${toolCall.id}_use`);
+      if (errorToolUseBlockRef && errorToolUseBlockRef.type === "tool_use") {
+        errorToolUseBlockRef.status = "error";
+        callbacks.onBlock?.({ ...errorToolUseBlockRef });
+      }
+      toolResults.push({ toolCall, result: errorResult });
+    }
+  }
+  return toolResults;
+}
+function mapToolArguments(args, mcpTool, logger) {
+  const mappedArgs = { ...args };
+  const toolSchema = mcpTool.inputSchema;
+  if (toolSchema?.properties) {
+    const expectedParams = Object.keys(toolSchema.properties);
+    const paramMappings = {
+      "search_query": ["query", "q", "searchQuery", "search"],
+      "content": ["text", "body", "message"],
+      "file_path": ["path", "filePath", "file"],
+      "url": ["link", "uri"]
+    };
+    for (const expectedParam of expectedParams) {
+      if (!(expectedParam in mappedArgs)) {
+        const aliases = paramMappings[expectedParam];
+        if (aliases) {
+          for (const alias of aliases) {
+            if (alias in mappedArgs) {
+              logger.info("Mapping parameter", { from: alias, to: expectedParam });
+              mappedArgs[expectedParam] = mappedArgs[alias];
+              delete mappedArgs[alias];
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  return mappedArgs;
+}
+
+// src/completion/ToolHandler.ts
+async function streamWithTools(options, callbacks, mcpService, llmConfig, getProvider, resolveApiKey, logger, builtinExecutor) {
+  try {
+    const routedInfo = await llmConfig.resolveRoutedModel(
+      options.providerId,
+      options.model
+    );
+    const actualProviderId = routedInfo?.actualProviderId || options.providerId;
+    const actualModel = routedInfo?.actualModelId || options.model;
+    const provider = await getProvider(actualProviderId);
+    if (!provider) {
+      callbacks.onError?.(`Provider not found: ${actualProviderId}`);
+      return;
+    }
+    if (!provider.enabled) {
+      callbacks.onError?.(`Provider is disabled: ${provider.name}`);
+      return;
+    }
+    const { apiKey: effectiveKey } = resolveProviderEndpoint(provider);
+    const apiKey = resolveApiKey(effectiveKey);
+    if (!apiKey) {
+      callbacks.onError?.("API key not configured");
+      return;
+    }
+    const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    callbacks.onStart?.(messageId);
+    const globalParams = await llmConfig.getGlobalModelParameters();
+    const MAX_ITERATIONS = globalParams.toolMaxTurns ?? 100;
+    let iteration = 0;
+    const conversationMessages = [...options.messages];
+    let finalContent = "";
+    let finalReasoning = "";
+    let finalUsageTokens;
+    const blocks = [];
+    logger.info("Sending request to LLM with tools", {
+      model: actualModel,
+      providerId: actualProviderId,
+      messagesCount: options.messages.length
+    });
+    logToolFormat(options.tools, logger);
+    const apiFormat = resolveApiFormat(provider);
+    logger.info("API format determined", { apiFormat });
+    while (iteration < MAX_ITERATIONS) {
+      iteration++;
+      logger.info("Agentic loop iteration", {
+        iteration,
+        maxIterations: MAX_ITERATIONS,
+        messagesCount: conversationMessages.length
+      });
+      const { requestBody, url } = buildToolRequest(
+        apiFormat,
+        conversationMessages,
+        actualModel,
+        options,
+        provider
+      );
+      if (options.nativeSearchAugmentation) {
+        applyAugmentation(requestBody, options.nativeSearchAugmentation);
+      }
+      const headers = getProviderHeaders(provider, apiKey);
+      logger.info("Sending tool call request", {
+        url,
+        headers,
+        requestBody
+      });
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        callbacks.onError?.(`API error (${response.status}): ${errorText}`);
+        return;
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        callbacks.onError?.("No response body");
+        return;
+      }
+      const decoder = new TextDecoder();
+      let content = "";
+      let reasoning = "";
+      const toolCalls = [];
+      const pendingOpenAIToolCalls = /* @__PURE__ */ new Map();
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const chunk = decoder.decode(value, { stream: true });
+          logger.debug("Received raw chunk", { chunkLength: chunk.length });
+          buffer += chunk;
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine) continue;
+            logger.debug("Processing line", { linePreview: trimmedLine.substring(0, 200) });
+            if (trimmedLine.startsWith("data: ")) {
+              const data = trimmedLine.slice(6);
+              if (data === "[DONE]") {
+                logger.debug("Stream done");
+                continue;
+              }
+              try {
+                const json = JSON.parse(data);
+                logger.debug("Parsed JSON", { json });
+                if (json.error) {
+                  logger.error("API Error", void 0, { error: json.error });
+                  callbacks.onError?.(`API Error: ${json.error.message || JSON.stringify(json.error)}`);
+                  return;
+                }
+                parseStreamChunk(json, apiFormat, callbacks, logger);
+                content = content + extractDeltaContent(json, apiFormat);
+                reasoning = reasoning + extractDeltaReasoning(json, apiFormat);
+                extractToolCalls(json, apiFormat, toolCalls, callbacks, logger, pendingOpenAIToolCalls);
+                if (apiFormat !== "google" && apiFormat !== "anthropic" && json.usage) {
+                  finalUsageTokens = {
+                    promptTokens: json.usage.prompt_tokens || 0,
+                    completionTokens: json.usage.completion_tokens || 0,
+                    totalTokens: json.usage.total_tokens || 0
+                  };
+                }
+              } catch (_e) {
+              }
+            }
+          }
+        }
+        if (apiFormat !== "google" && apiFormat !== "anthropic") {
+          finalizeOpenAIToolCalls(pendingOpenAIToolCalls, toolCalls, callbacks, logger);
+          pendingOpenAIToolCalls.clear();
+        }
+        finalContent = content;
+        finalReasoning = reasoning;
+        buildIterationBlocks(iteration, content, reasoning, blocks, callbacks);
+        const executableToolCalls = toolCalls.filter(
+          (tc) => !NATIVE_SEARCH_TOOL_NAMES.includes(tc.name)
+        );
+        logger.info("Tool execution check", {
+          toolCallsLength: toolCalls.length,
+          executableToolCallsLength: executableToolCalls.length,
+          hasMcpTools: !!options.mcpTools,
+          mcpToolsLength: options.mcpTools?.length,
+          hasMcpService: !!mcpService
+        });
+        if (executableToolCalls.length > 0 && options.mcpTools && (mcpService || builtinExecutor)) {
+          logger.info("Executing tool calls", { count: executableToolCalls.length });
+          conversationMessages.push({
+            id: `assistant_${iteration}`,
+            role: "assistant",
+            content: content || "Calling tools...",
+            timestamp: Date.now()
+          });
+          const toolResults = await executeToolCalls(
+            executableToolCalls,
+            options.mcpTools,
+            mcpService,
+            blocks,
+            callbacks,
+            logger,
+            builtinExecutor
+          );
+          const toolResultsText = toolResults.map(({ toolCall, result }) => {
+            const resultText = typeof result === "string" ? result : result.content?.[0]?.text || JSON.stringify(result);
+            return `Tool ${toolCall.name} result:
+${resultText}`;
+          }).join("\n\n");
+          conversationMessages.push({
+            id: `tool_results_${iteration}`,
+            role: "user",
+            content: toolResultsText,
+            timestamp: Date.now()
+          });
+          logger.info("Continuing to next iteration with tool results");
+          continue;
+        } else {
+          logger.info("No tool calls, finishing");
+          break;
+        }
+      } catch (streamError) {
+        logger.error("Stream processing error", streamError instanceof Error ? streamError : void 0);
+        callbacks.onError?.(`Stream error: ${streamError instanceof Error ? streamError.message : "Unknown error"}`);
+        return;
+      }
+    }
+    logger.info("Sending final callback", { blocksCount: blocks.length });
+    callbacks.onDone?.({
+      id: messageId,
+      role: "assistant",
+      content: finalContent,
+      timestamp: Date.now(),
+      thinking: finalReasoning ? { content: finalReasoning } : void 0,
+      blocks: blocks.length > 0 ? blocks : void 0
+    }, finalUsageTokens);
+  } catch (error) {
+    logger.error("Error in streamWithTools", error instanceof Error ? error : void 0);
+    const message = error instanceof Error ? error.message : "Unknown error";
+    callbacks.onError?.(message);
+  }
+}
+
+// src/completion/TransformerHandler.ts
+function readUsageFromOpenAIResponse(usage) {
+  if (!usage) return null;
+  const promptTokens = Number(usage.prompt_tokens) || 0;
+  const completionTokens = Number(usage.completion_tokens) || 0;
+  const promptDetails = usage.prompt_tokens_details ?? {};
+  const cachedTokens = Number(promptDetails.cached_tokens) || Number(usage.cache_read_input_tokens) || 0;
+  const cacheCreation = Number(usage.cache_creation_input_tokens) || 0;
+  const inputTokens = Math.max(0, promptTokens - cachedTokens - cacheCreation);
+  const reasoningDetails = usage.completion_tokens_details ?? usage.output_tokens_details ?? {};
+  const reasoningTokens = Number(reasoningDetails.reasoning_tokens) || 0;
+  return {
+    inputTokens,
+    outputTokens: completionTokens,
+    cacheReadTokens: cachedTokens,
+    cacheCreationTokens: cacheCreation,
+    reasoningTokens
+  };
+}
+var sharedExecutor = null;
+function getSharedExecutor2() {
+  if (!sharedExecutor) {
+    sharedExecutor = new TransformerChainExecutor();
+  }
+  return sharedExecutor;
+}
+async function resolveChainWithMain(llmConfig, providerId, model) {
+  return resolveProviderChain(llmConfig, providerId, model);
+}
+async function completeWithTransformers(options, llmConfig, getProvider, resolveApiKey, completeFallback, logger, recording) {
+  try {
+    const routedInfo = await llmConfig.resolveRoutedModel(
+      options.providerId,
+      options.model
+    );
+    const actualProviderId = routedInfo?.actualProviderId || options.providerId;
+    const actualModel = routedInfo?.actualModelId || options.model;
+    const provider = await getProvider(actualProviderId);
+    if (!provider) {
+      return { success: false, error: `Provider not found: ${actualProviderId}` };
+    }
+    if (!provider.enabled) {
+      return { success: false, error: `Provider is disabled: ${provider.name}` };
+    }
+    const { apiKey: effectiveKey } = resolveProviderEndpoint(provider);
+    const apiKey = resolveApiKey(effectiveKey);
+    if (!apiKey) {
+      return { success: false, error: "API key not configured" };
+    }
+    const { chain, hasTransformers } = await resolveChainWithMain(
+      llmConfig,
+      actualProviderId,
+      actualModel
+    );
+    if (!hasTransformers) {
+      return completeFallback(options);
+    }
+    const unifiedRequest = {
+      model: actualModel,
+      messages: options.messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      max_tokens: options.maxTokens || 4096,
+      temperature: options.temperature,
+      stream: options.stream ?? false
+    };
+    const transformerProvider = {
+      name: provider.name,
+      baseUrl: provider.api_base_url,
+      apiKey,
+      models: provider.models || []
+    };
+    const executor = getSharedExecutor2();
+    const { response } = await executeProviderCall({
+      executor,
+      request: unifiedRequest,
+      provider: transformerProvider,
+      chain,
+      endpointTransformer: void 0,
+      extendedContext: options.useExtendedContext ? { enabled: true, model: actualModel } : void 0,
+      resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : buildProviderApiUrl(provider, { model: actualModel, stream: false }),
+      buildHeaders: (config) => ({
+        ...getProviderHeaders(provider, apiKey),
+        ...config.headers,
+        ...isOpenRouterProvider(provider) ? OPENROUTER_APP_HEADERS : {}
+      }),
+      // Add OpenRouter provider routing config if applicable
+      prepareBody: (requestBody) => addOpenRouterProviderToRequest(
+        requestBody,
+        provider,
+        actualModel
+      ),
+      fetchFn: (url, headers, body) => {
+        logger.info("Calling completion with transformers", { url });
+        return fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body)
+        });
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      return {
+        success: false,
+        error: `API error (${response.status}): ${errorText}`
+      };
+    }
+    const transformedResponse = await executor.executeResponseChain(
+      unifiedRequest,
+      response,
+      transformerProvider,
+      chain,
+      { endpointTransformer: void 0 }
+    );
+    const data = await transformedResponse.json();
+    const choice = data.choices?.[0];
+    if (!choice) {
+      return { success: false, error: "No choices in response" };
+    }
+    const rawToolCalls = choice.message?.tool_calls;
+    const toolCalls = rawToolCalls?.map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      args: typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments
+    }));
+    const tapped = readUsageFromOpenAIResponse(data.usage);
+    if (recording?.recorder && tapped) {
+      recording.recorder.record({
+        messageId: options.messageId ?? null,
+        parentMessageId: options.parentMessageId ?? null,
+        sessionId: options.sessionId ?? null,
+        providerId: actualProviderId,
+        model: actualModel,
+        apiKeyId: recording.apiKeyId ?? null,
+        engineOrigin: "completion",
+        usage: tapped,
+        rawUsage: data.usage
+      });
+    }
+    return {
+      success: true,
+      message: {
+        id: `msg_${Date.now()}`,
+        role: "assistant",
+        content: choice.message?.content || "",
+        timestamp: Date.now(),
+        thinking: data.reasoning_content || choice.message?.thinking?.content ? { content: data.reasoning_content || choice.message?.thinking?.content || "", signature: choice.message?.thinking?.signature } : void 0,
+        toolCalls
+      },
+      usage: data.usage ? {
+        promptTokens: data.usage.prompt_tokens || 0,
+        completionTokens: data.usage.completion_tokens || 0,
+        totalTokens: data.usage.total_tokens || 0
+      } : void 0,
+      finishReason: choice.finish_reason
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, error: message };
+  }
+}
+async function completeStreamWithTransformers(options, callbacks, llmConfig, getProvider, resolveApiKey, completeStreamFallback, logger, recording) {
+  try {
+    const routedInfo = await llmConfig.resolveRoutedModel(
+      options.providerId,
+      options.model
+    );
+    const actualProviderId = routedInfo?.actualProviderId || options.providerId;
+    const actualModel = routedInfo?.actualModelId || options.model;
+    const provider = await getProvider(actualProviderId);
+    if (!provider) {
+      callbacks.onError?.(`Provider not found: ${actualProviderId}`);
+      return;
+    }
+    if (!provider.enabled) {
+      callbacks.onError?.(`Provider is disabled: ${provider.name}`);
+      return;
+    }
+    const { apiKey: effectiveKey } = resolveProviderEndpoint(provider);
+    const apiKey = resolveApiKey(effectiveKey);
+    if (!apiKey) {
+      callbacks.onError?.("API key not configured");
+      return;
+    }
+    const { chain, hasTransformers } = await resolveChainWithMain(
+      llmConfig,
+      actualProviderId,
+      actualModel
+    );
+    if (!hasTransformers) {
+      return completeStreamFallback(options, callbacks);
+    }
+    const messageId = `msg_${Date.now()}`;
+    callbacks.onStart?.(messageId);
+    const unifiedRequest = {
+      model: actualModel,
+      messages: options.messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      max_tokens: options.maxTokens || 4096,
+      temperature: options.temperature,
+      stream: true
+    };
+    const transformerProvider = {
+      name: provider.name,
+      baseUrl: provider.api_base_url,
+      apiKey,
+      models: provider.models || []
+    };
+    const executor = getSharedExecutor2();
+    const { response } = await executeProviderCall({
+      executor,
+      request: unifiedRequest,
+      provider: transformerProvider,
+      chain,
+      endpointTransformer: void 0,
+      extendedContext: options.useExtendedContext ? { enabled: true, model: actualModel } : void 0,
+      resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : buildProviderApiUrl(provider, { model: actualModel, stream: true }),
+      buildHeaders: (config) => ({
+        ...getProviderHeaders(provider, apiKey),
+        ...config.headers,
+        ...isOpenRouterProvider(provider) ? OPENROUTER_APP_HEADERS : {}
+      }),
+      // Add OpenRouter provider routing config if applicable
+      prepareBody: (requestBody) => addOpenRouterProviderToRequest(
+        requestBody,
+        provider,
+        actualModel
+      ),
+      fetchFn: (url, headers, body) => {
+        logger.info("Streaming completion with transformers", { url });
+        return fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body)
+        });
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      callbacks.onError?.(`API error (${response.status}): ${errorText}`);
+      return;
+    }
+    const transformedResponse = await executor.executeResponseChain(
+      unifiedRequest,
+      response,
+      transformerProvider,
+      chain,
+      { endpointTransformer: void 0 }
+    );
+    const reader = transformedResponse.body?.getReader();
+    if (!reader) {
+      callbacks.onError?.("No response body");
+      return;
+    }
+    const decoder = new TextDecoder();
+    let content = "";
+    let reasoning = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        const lines = chunk.split("\n").filter((line) => line.trim() !== "");
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") continue;
+            try {
+              const json = JSON.parse(data);
+              const delta = json.choices?.[0]?.delta;
+              if (delta?.content) {
+                content += delta.content;
+                callbacks.onDelta?.(delta.content);
+              }
+              if (delta?.thinking?.content) {
+                reasoning += delta.thinking.content;
+                callbacks.onReasoning?.(delta.thinking.content);
+              }
+              if (delta?.reasoning_content) {
+                reasoning += delta.reasoning_content;
+                callbacks.onReasoning?.(delta.reasoning_content);
+              }
+              if (json.usage) {
+                const tapped = readUsageFromOpenAIResponse(json.usage);
+                if (recording?.recorder && tapped) {
+                  recording.recorder.record({
+                    messageId: options.messageId ?? null,
+                    parentMessageId: options.parentMessageId ?? null,
+                    sessionId: options.sessionId ?? null,
+                    providerId: actualProviderId,
+                    model: actualModel,
+                    apiKeyId: recording.apiKeyId ?? null,
+                    engineOrigin: "completion",
+                    usage: tapped,
+                    rawUsage: json.usage
+                  });
+                }
+                callbacks.onDone?.(
+                  {
+                    id: messageId,
+                    role: "assistant",
+                    content,
+                    timestamp: Date.now(),
+                    thinking: reasoning ? { content: reasoning } : void 0
+                  },
+                  {
+                    promptTokens: json.usage.prompt_tokens || 0,
+                    completionTokens: json.usage.completion_tokens || 0,
+                    totalTokens: json.usage.total_tokens || 0
+                  }
+                );
+                return;
+              }
+            } catch (_e) {
+            }
+          }
+        }
+      }
+      callbacks.onDone?.({
+        id: messageId,
+        role: "assistant",
+        content,
+        timestamp: Date.now(),
+        thinking: reasoning ? { content: reasoning } : void 0
+      });
+    } finally {
+      reader.releaseLock();
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    callbacks.onError?.(message);
+  }
+}
+
+// src/completion/CompletionService.ts
+var CompletionService = class {
+  constructor(paths, llmConfig, logger) {
+    this.paths = paths;
+    this.llmConfig = llmConfig;
+    this.logger = logger;
+  }
+  paths;
+  llmConfig;
+  logger;
+  apiKeyPool = null;
+  usageRecorder = null;
+  usageEventSink = null;
+  visionFallbackProvider = null;
+  /**
+   * Set the API key pool service for multi-key load balancing.
+   * When set, keys are resolved via the pool instead of directly from the provider.
+   */
+  setApiKeyPool(pool) {
+    this.apiKeyPool = pool;
+  }
+  /**
+   * Set the usage recorder so completion paths can persist token/cost stats.
+   * Optional — when unset, all calls succeed but nothing is recorded.
+   */
+  setUsageRecorder(recorder) {
+    this.usageRecorder = recorder;
+  }
+  /**
+   * Set the usage-event sink so completion paths can push live usage events
+   * (context-meter, aggregate recorder) into the in-process hub. Injected DOWN
+   * at bootstrap with `getUsageEventHub()` immediately after construction, so
+   * emission is unconditional in production. Optional — when unset (unit-test
+   * constructors), the emit calls no-op, identical to `usageRecorder`.
+   */
+  setUsageEventSink(sink) {
+    this.usageEventSink = sink;
+  }
+  /**
+   * Set the vision-fallback provider used by `applyVisionFallback` to describe
+   * images for non-vision models. Injected DOWN by the host at bootstrap
+   * (the host's impl is built on top of CompletionService).
+   * Optional — when unset, `applyVisionFallback` strips images instead.
+   */
+  setVisionFallbackProvider(provider) {
+    this.visionFallbackProvider = provider;
+  }
+  /**
+   * Get provider by ID
+   * Delegates to the `ProviderConfigSource` which maintains its own in-memory cache.
+   */
+  async getProvider(providerId) {
+    return this.llmConfig.getProvider(providerId);
+  }
+  /**
+   * Send a completion request
+   */
+  async complete(options) {
+    try {
+      const routedInfo = await this.llmConfig.resolveRoutedModel(
+        options.providerId,
+        options.model
+      );
+      const actualProviderId = routedInfo?.actualProviderId || options.providerId;
+      const actualModel = routedInfo?.actualModelId || options.model;
+      const provider = await this.getProvider(actualProviderId);
+      if (!provider) {
+        return { success: false, error: `Provider not found: ${actualProviderId}` };
+      }
+      if (!provider.enabled) {
+        return { success: false, error: `Provider is disabled: ${provider.name}` };
+      }
+      const apiKey = await this.resolveApiKeyForRequest(provider, actualProviderId, options.sessionId);
+      if (!apiKey) {
+        return { success: false, error: "API key not configured" };
+      }
+      const apiFormat = resolveApiFormat(provider);
+      this.logger.info("Using API format for completion", { apiFormat, providerId: actualProviderId });
+      const resolvedOptions = { ...options, model: actualModel };
+      let result = await this.callDirectHandler(apiFormat, provider, apiKey, resolvedOptions);
+      if (!result.success && result.error && this.apiKeyPool && options.sessionId) {
+        const status = this.extractHttpStatus(result.error);
+        if (status && (status === 429 || status === 529 || status === 401 || status === 403)) {
+          const newKey = await this.apiKeyPool.reportError(actualProviderId, options.sessionId, status);
+          if (newKey) {
+            this.logger.info("Retrying completion with new API key", {
+              providerId: actualProviderId,
+              statusCode: status
+            });
+            result = await this.callDirectHandler(apiFormat, provider, newKey, resolvedOptions);
+          }
+        }
+      }
+      if (result.success && this.apiKeyPool && options.sessionId) {
+        this.apiKeyPool.reportSuccess(options.sessionId);
+      }
+      if (result.success && result.usage && options.sessionId) {
+        this.usageEventSink?.emit({
+          sessionId: options.sessionId,
+          modelId: actualModel,
+          usage: result.usage,
+          engineOrigin: "completion"
+        });
+      }
+      return result;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Send a streaming completion request
+   */
+  async completeStream(options, callbacks) {
+    try {
+      await this.applyVisionFallback(options);
+      this.logger.info("Starting stream completion", {
+        providerId: options.providerId,
+        model: options.model,
+        messagesCount: options.messages.length
+      });
+      const routedInfo = await this.llmConfig.resolveRoutedModel(
+        options.providerId,
+        options.model
+      );
+      this.logger.debug("Resolved routed model", { routedInfo });
+      const actualProviderId = routedInfo?.actualProviderId || options.providerId;
+      const actualModel = routedInfo?.actualModelId || options.model;
+      this.logger.debug("Resolved provider and model", { actualProviderId, actualModel });
+      const provider = await this.getProvider(actualProviderId);
+      this.logger.debug("Retrieved provider", provider ? {
+        id: provider.id,
+        name: provider.name,
+        apiType: provider.apiType,
+        apiFormat: provider.apiFormat,
+        api_base_url: provider.api_base_url,
+        enabled: provider.enabled
+      } : { error: "Provider not found" });
+      if (!provider) {
+        callbacks.onError?.(`Provider not found: ${actualProviderId}`);
+        return;
+      }
+      if (!provider.enabled) {
+        callbacks.onError?.(`Provider is disabled: ${provider.name}`);
+        return;
+      }
+      const apiKey = await this.resolveApiKeyForRequest(provider, actualProviderId, options.sessionId);
+      if (!apiKey) {
+        callbacks.onError?.("API key not configured");
+        return;
+      }
+      const apiFormat = resolveApiFormat(provider);
+      this.logger.info("Using API format for stream", { apiFormat });
+      const messageId = `msg_${Date.now()}`;
+      callbacks.onStart?.(messageId);
+      const resolvedOptions = { ...options, model: actualModel };
+      if (options.sessionId) {
+        const sid = options.sessionId;
+        const userOnDone = callbacks.onDone;
+        callbacks = {
+          ...callbacks,
+          onDone: (message, usage, metrics) => {
+            if (usage) {
+              this.usageEventSink?.emit({
+                sessionId: sid,
+                modelId: actualModel,
+                usage,
+                engineOrigin: "completion"
+              });
+            }
+            userOnDone?.(message, usage, metrics);
+          }
+        };
+      }
+      if (this.apiKeyPool && options.sessionId) {
+        const retryState = { error: null };
+        const interceptCallbacks = {
+          ...callbacks,
+          onStart: void 0,
+          // already called above
+          onError: (error) => {
+            const status = this.extractHttpStatus(error);
+            if (status && (status === 429 || status === 529 || status === 401 || status === 403)) {
+              retryState.error = { status, message: error };
+              return;
+            }
+            callbacks.onError?.(error);
+          },
+          onDone: (message, usage, metrics) => {
+            this.apiKeyPool.reportSuccess(options.sessionId);
+            callbacks.onDone?.(message, usage, metrics);
+          }
+        };
+        await this.callStreamHandler(apiFormat, provider, apiKey, resolvedOptions, messageId, interceptCallbacks);
+        if (retryState.error) {
+          const newKey = await this.apiKeyPool.reportError(
+            actualProviderId,
+            options.sessionId,
+            retryState.error.status
+          );
+          if (newKey) {
+            this.logger.info("Retrying stream with new API key", {
+              providerId: actualProviderId,
+              statusCode: retryState.error.status
+            });
+            await this.callStreamHandler(apiFormat, provider, newKey, resolvedOptions, messageId, {
+              ...callbacks,
+              onStart: void 0
+              // don't fire onStart again
+            });
+          } else {
+            callbacks.onError?.(retryState.error.message);
+          }
+        }
+      } else {
+        await this.callStreamHandler(apiFormat, provider, apiKey, resolvedOptions, messageId, {
+          ...callbacks,
+          onStart: void 0
+          // already called above
+        });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      this.logger.error("Stream completion error", error instanceof Error ? error : void 0, { message });
+      callbacks.onError?.(message);
+    }
+  }
+  /**
+   * Get available models for a provider
+   */
+  async getAvailableModels(providerId) {
+    const provider = await this.getProvider(providerId);
+    if (!provider) return [];
+    return provider.models || [];
+  }
+  /**
+   * Test provider connection with a specific model.
+   * Sends "Hello" and returns the AI response, duration, etc.
+   */
+  async testModel(providerId, modelId) {
+    try {
+      const provider = await this.getProvider(providerId);
+      if (!provider) {
+        return { success: false, message: "Provider not found", model: modelId };
+      }
+      const apiKey = this.resolveApiKey(provider.api_key);
+      if (!apiKey) {
+        return { success: false, message: "API key not configured", model: modelId };
+      }
+      const testMessages = [
+        { id: "test", role: "user", content: "Hello", timestamp: Date.now() }
+      ];
+      const startTime = Date.now();
+      const result = await this.complete({
+        providerId,
+        model: modelId,
+        messages: testMessages,
+        maxTokens: 100
+      });
+      const durationMs = Date.now() - startTime;
+      if (result.success) {
+        return {
+          success: true,
+          message: "Connection successful",
+          response: result.message?.content || "",
+          model: modelId,
+          durationMs
+        };
+      } else {
+        return {
+          success: false,
+          message: result.error || "Unknown error",
+          model: modelId,
+          durationMs
+        };
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return { success: false, message, model: modelId };
+    }
+  }
+  /**
+   * Check if any messages contain images and the model lacks vision capability.
+   * If so, use the auxiliary vision model to describe images as text and remove
+   * the image attachments from the messages.
+   *
+   * Mutates options.messages in-place.
+   */
+  async applyVisionFallback(options) {
+    const hasImages = options.messages.some((m) => m.images && m.images.length > 0);
+    if (!hasImages) return;
+    const hasVision = await this.llmConfig.hasVisionCapability(options.providerId, options.model);
+    if (hasVision) return;
+    const { vision: effectiveVisionModel } = await this.llmConfig.resolveEffectiveModels();
+    if (!effectiveVisionModel || !this.visionFallbackProvider) {
+      this.logger.info("Messages contain images but no vision auxiliary model configured; stripping images");
+      for (const msg of options.messages) {
+        if (msg.images && msg.images.length > 0) {
+          msg.images = void 0;
+        }
+      }
+      return;
+    }
+    this.logger.info("Model lacks vision capability, using auxiliary vision model for image descriptions", {
+      providerId: options.providerId,
+      model: options.model
+    });
+    const visionService = this.visionFallbackProvider;
+    for (const msg of options.messages) {
+      if (msg.images && msg.images.length > 0) {
+        const imageDataUrls = msg.images.map((img) => ({ data: img.url }));
+        const description = await visionService.describeImages(imageDataUrls, msg.content, effectiveVisionModel);
+        if (description && description !== "[Image description unavailable]") {
+          msg.content = `${msg.content}
+
+[Image Description]
+${description}`;
+        }
+        msg.images = void 0;
+      }
+    }
+  }
+  /**
+   * Resolve API key for a request with priority:
+   * 1. Coding Plan override (if enabled)
+   * 2. API key pool (session-affinity weighted round-robin)
+   * 3. Legacy single key from provider config
+   */
+  async resolveApiKeyForRequest(provider, providerId, sessionId) {
+    if (provider.codingPlan?.enabled && provider.codingPlan.apiKey) {
+      return this.resolveApiKey(provider.codingPlan.apiKey);
+    }
+    if (this.apiKeyPool) {
+      const poolKey = sessionId ? await this.apiKeyPool.getKeyForSession(providerId, sessionId) : await this.apiKeyPool.getKey(providerId);
+      if (poolKey) return poolKey;
+    }
+    const { apiKey: effectiveKey } = resolveProviderEndpoint(provider);
+    return this.resolveApiKey(effectiveKey);
+  }
+  // ==========================================================================
+  // Handler dispatch helpers
+  // ==========================================================================
+  /**
+   * Extract HTTP status code from error messages like "API error (429): ..."
+   */
+  extractHttpStatus(error) {
+    const match = error.match(/\((\d{3})\):/);
+    return match ? parseInt(match[1], 10) : null;
+  }
+  /**
+   * Dispatch a non-streaming completion to the appropriate handler.
+   */
+  async callDirectHandler(apiFormat, provider, apiKey, options) {
+    switch (apiFormat) {
+      case "anthropic":
+        return callAnthropicCompletion(provider, apiKey, options, this.logger);
+      case "google":
+        return callGeminiCompletion(provider, apiKey, options, this.logger);
+      case "openai-response":
+        return callOpenAIResponseCompletion(provider, apiKey, options, this.logger);
+      case "azure-openai":
+      case "openai":
+      default:
+        return callOpenAICompletion(provider, apiKey, options, this.logger);
+    }
+  }
+  /**
+   * Dispatch a streaming completion to the appropriate handler.
+   */
+  async callStreamHandler(apiFormat, provider, apiKey, options, messageId, callbacks) {
+    switch (apiFormat) {
+      case "openai-response":
+        await streamOpenAIResponseCompletion(provider, apiKey, options, messageId, callbacks, this.logger);
+        return;
+      case "anthropic":
+        await streamAnthropicCompletion(provider, apiKey, options, messageId, callbacks, this.logger);
+        return;
+      case "google":
+        await streamGeminiCompletion(provider, apiKey, options, messageId, callbacks, this.logger);
+        return;
+      case "azure-openai":
+      case "openai":
+      default:
+        await streamOpenAICompletion(provider, apiKey, options, messageId, callbacks, this.logger);
+        return;
+    }
+  }
+  /**
+   * Resolve API key (handle environment variable references)
+   */
+  resolveApiKey(apiKey) {
+    if (!apiKey) return "";
+    if (apiKey.startsWith("$")) {
+      const envVar = apiKey.slice(1);
+      return process.env[envVar] || "";
+    }
+    return apiKey;
+  }
+  /**
+   * Resolve effective max_tokens value with priority:
+   * 1. Session settings (if provided)
+   * 2. Global model parameters (if enabled)
+   * 3. Model's maxTokens from provider config
+   * 4. Discovered models cache (from API)
+   * 5. undefined - let API use its default
+   */
+  async resolveEffectiveMaxTokens(providerId, modelId, sessionMaxTokens) {
+    return resolveEffectiveMaxTokens(
+      this.llmConfig,
+      this.getProvider.bind(this),
+      this.logger,
+      providerId,
+      modelId,
+      sessionMaxTokens
+    );
+  }
+  /**
+   * Get required max_tokens for providers that need it (e.g., Anthropic)
+   * Falls back to DEFAULT_MAX_TOKENS if no value is configured
+   */
+  async getRequiredMaxTokens(providerId, modelId, sessionMaxTokens) {
+    return getRequiredMaxTokens(
+      this.llmConfig,
+      this.getProvider.bind(this),
+      this.logger,
+      providerId,
+      modelId,
+      sessionMaxTokens
+    );
+  }
+  /**
+   * Calculate thinking budget and adjust max_tokens for the provider
+   */
+  async resolveThinkingBudget(providerId, modelId, maxTokens, thinkLevel) {
+    return resolveThinkingBudget(
+      this.getProvider.bind(this),
+      this.logger,
+      providerId,
+      modelId,
+      maxTokens,
+      thinkLevel
+    );
+  }
+  // --------------------------------------------------------------------------
+  // Transformer Chain Completion
+  // --------------------------------------------------------------------------
+  /**
+   * Send a completion request using transformer chain
+   */
+  async completeWithTransformers(options) {
+    return completeWithTransformers(
+      options,
+      this.llmConfig,
+      this.getProvider.bind(this),
+      this.resolveApiKey.bind(this),
+      this.complete.bind(this),
+      this.logger,
+      this.usageRecorder ? { recorder: this.usageRecorder } : void 0
+    );
+  }
+  /**
+   * Send a streaming completion request using transformer chain
+   */
+  async completeStreamWithTransformers(options, callbacks) {
+    return completeStreamWithTransformers(
+      options,
+      callbacks,
+      this.llmConfig,
+      this.getProvider.bind(this),
+      this.resolveApiKey.bind(this),
+      this.completeStream.bind(this),
+      this.logger,
+      this.usageRecorder ? { recorder: this.usageRecorder } : void 0
+    );
+  }
+  // --------------------------------------------------------------------------
+  // Tool-based Completion
+  // --------------------------------------------------------------------------
+  /**
+   * Stream completion with MCP tools support (direct API call)
+   * Implements agentic loop: calls LLM -> executes tools -> calls LLM again until done
+   */
+  async streamWithTools(options, callbacks, mcpService, builtinExecutor) {
+    return streamWithTools(
+      options,
+      callbacks,
+      mcpService,
+      this.llmConfig,
+      this.getProvider.bind(this),
+      this.resolveApiKey.bind(this),
+      this.logger,
+      builtinExecutor
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompletionService
+});