@omnicross/core 0.1.0 → 0.1.1

package/dist/completion/url-builder.cjs

@@ -0,0 +1,138 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/completion/url-builder.ts
+var url_builder_exports = {};
+__export(url_builder_exports, {
+  buildAnthropicApiUrl: () => buildAnthropicApiUrl,
+  buildAzureOpenAIApiUrl: () => buildAzureOpenAIApiUrl,
+  buildGeminiApiUrl: () => buildGeminiApiUrl,
+  buildGeminiModelActionUrl: () => buildGeminiModelActionUrl,
+  buildOpenAIApiUrl: () => buildOpenAIApiUrl,
+  buildOpenAIResponseApiUrl: () => buildOpenAIResponseApiUrl,
+  buildProviderApiUrl: () => buildProviderApiUrl,
+  normalizeAzureEndpoint: () => normalizeAzureEndpoint,
+  resolveApiFormat: () => resolveApiFormat,
+  resolveProviderEndpoint: () => resolveProviderEndpoint
+});
+module.exports = __toCommonJS(url_builder_exports);
+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);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAnthropicApiUrl,
+  buildAzureOpenAIApiUrl,
+  buildGeminiApiUrl,
+  buildGeminiModelActionUrl,
+  buildOpenAIApiUrl,
+  buildOpenAIResponseApiUrl,
+  buildProviderApiUrl,
+  normalizeAzureEndpoint,
+  resolveApiFormat,
+  resolveProviderEndpoint
+});

package/dist/completion/url-builder.d.cts

@@ -0,0 +1,87 @@
+import { LLMProvider } from '@omnicross/contracts/llm-config';
+import { A as ApiFormat } from '../types-BScIHmPr.cjs';
+import { resolveProviderEndpoint as resolveProviderEndpoint$1 } from '@omnicross/contracts/endpoint-resolver';
+import '@omnicross/contracts/message-blocks';
+import '@omnicross/contracts/completion-types';
+
+/**
+ * API URL Building Utilities
+ *
+ * Functions for building correct API URLs based on provider format.
+ */
+
+/**
+ * Resolve API format from provider configuration
+ *
+ * Priority:
+ * 1. apiFormat (v3 preferred field)
+ * 2. chatApiFormat (legacy v3 field)
+ * 3. apiType if it's an explicit format (claudecode/anthropic/google)
+ * 4. Default to openai
+ *
+ * Note: This enables implicit routing - the API format determines which
+ * transformer is automatically applied without explicit router configuration.
+ */
+declare function resolveApiFormat(provider: LLMProvider): ApiFormat;
+/**
+ * Build OpenAI Chat Completions API URL
+ * Handles various input formats:
+ * - https://api.openai.com → https://api.openai.com/v1/chat/completions
+ * - https://api.openai.com/v1/chat/completions → unchanged
+ * - https://api.deepseek.com/v1 → https://api.deepseek.com/v1/chat/completions
+ * - https://api.z.ai/api/coding/paas/v4 → https://api.z.ai/api/coding/paas/v4/chat/completions
+ */
+declare function buildOpenAIApiUrl(baseUrl: string): string;
+/**
+ * Build Anthropic Messages API URL
+ * Handles various input formats:
+ * - https://api.anthropic.com → https://api.anthropic.com/v1/messages
+ * - https://api.anthropic.com/v1/messages → unchanged
+ * - https://api.z.ai/api/anthropic → https://api.z.ai/api/anthropic/v1/messages
+ * - https://api.z.ai/api/anthropic/v2 → https://api.z.ai/api/anthropic/v2/messages
+ */
+declare function buildAnthropicApiUrl(baseUrl: string): string;
+/**
+ * Build a Gemini /v1beta/models/{model}:{action} URL with base-URL normalization.
+ * Strips trailing slashes, skips appending /v1beta if the base already has a version path,
+ * and returns the URL as-is if it already contains /models/.
+ */
+declare function buildGeminiModelActionUrl(baseUrl: string, model: string, action: string): string;
+/**
+ * Build Google Gemini API URL
+ * Gemini uses a dynamic URL structure: /v1beta/models/{model}:generateContent or :streamGenerateContent
+ * @param baseUrl - Base URL (e.g., https://generativelanguage.googleapis.com)
+ * @param model - Model name (e.g., gemini-2.0-flash)
+ * @param stream - Whether to use streaming endpoint
+ */
+declare function buildGeminiApiUrl(baseUrl: string, model: string, stream: boolean): string;
+/**
+ * Normalize Azure OpenAI endpoint
+ * Strips trailing /, /openai, /openai/v1 etc.
+ */
+declare function normalizeAzureEndpoint(endpoint: string): string;
+/**
+ * Build Azure OpenAI API URL
+ * Format: {endpoint}/openai/deployments/{deploymentName}/chat/completions?api-version={version}
+ * @param baseUrl - Azure endpoint (e.g., https://my-resource.openai.azure.com)
+ * @param model - Deployment name (used as model in Azure)
+ * @param apiVersion - API version (e.g., 2024-08-01-preview)
+ */
+declare function buildAzureOpenAIApiUrl(baseUrl: string, model: string, apiVersion: string): string;
+/**
+ * Build OpenAI Responses API URL
+ * Format: {baseUrl}/v1/responses
+ */
+declare function buildOpenAIResponseApiUrl(baseUrl: string): string;
+
+declare const resolveProviderEndpoint: typeof resolveProviderEndpoint$1;
+/**
+ * Build API URL based on provider format and options
+ * This is the main entry point for URL building
+ */
+declare function buildProviderApiUrl(provider: LLMProvider, options?: {
+    model?: string;
+    stream?: boolean;
+}): string;
+
+export { buildAnthropicApiUrl, buildAzureOpenAIApiUrl, buildGeminiApiUrl, buildGeminiModelActionUrl, buildOpenAIApiUrl, buildOpenAIResponseApiUrl, buildProviderApiUrl, normalizeAzureEndpoint, resolveApiFormat, resolveProviderEndpoint };

package/dist/completion/url-builder.d.ts

@@ -0,0 +1,87 @@
+import { LLMProvider } from '@omnicross/contracts/llm-config';
+import { A as ApiFormat } from '../types-BScIHmPr.js';
+import { resolveProviderEndpoint as resolveProviderEndpoint$1 } from '@omnicross/contracts/endpoint-resolver';
+import '@omnicross/contracts/message-blocks';
+import '@omnicross/contracts/completion-types';
+
+/**
+ * API URL Building Utilities
+ *
+ * Functions for building correct API URLs based on provider format.
+ */
+
+/**
+ * Resolve API format from provider configuration
+ *
+ * Priority:
+ * 1. apiFormat (v3 preferred field)
+ * 2. chatApiFormat (legacy v3 field)
+ * 3. apiType if it's an explicit format (claudecode/anthropic/google)
+ * 4. Default to openai
+ *
+ * Note: This enables implicit routing - the API format determines which
+ * transformer is automatically applied without explicit router configuration.
+ */
+declare function resolveApiFormat(provider: LLMProvider): ApiFormat;
+/**
+ * Build OpenAI Chat Completions API URL
+ * Handles various input formats:
+ * - https://api.openai.com → https://api.openai.com/v1/chat/completions
+ * - https://api.openai.com/v1/chat/completions → unchanged
+ * - https://api.deepseek.com/v1 → https://api.deepseek.com/v1/chat/completions
+ * - https://api.z.ai/api/coding/paas/v4 → https://api.z.ai/api/coding/paas/v4/chat/completions
+ */
+declare function buildOpenAIApiUrl(baseUrl: string): string;
+/**
+ * Build Anthropic Messages API URL
+ * Handles various input formats:
+ * - https://api.anthropic.com → https://api.anthropic.com/v1/messages
+ * - https://api.anthropic.com/v1/messages → unchanged
+ * - https://api.z.ai/api/anthropic → https://api.z.ai/api/anthropic/v1/messages
+ * - https://api.z.ai/api/anthropic/v2 → https://api.z.ai/api/anthropic/v2/messages
+ */
+declare function buildAnthropicApiUrl(baseUrl: string): string;
+/**
+ * Build a Gemini /v1beta/models/{model}:{action} URL with base-URL normalization.
+ * Strips trailing slashes, skips appending /v1beta if the base already has a version path,
+ * and returns the URL as-is if it already contains /models/.
+ */
+declare function buildGeminiModelActionUrl(baseUrl: string, model: string, action: string): string;
+/**
+ * Build Google Gemini API URL
+ * Gemini uses a dynamic URL structure: /v1beta/models/{model}:generateContent or :streamGenerateContent
+ * @param baseUrl - Base URL (e.g., https://generativelanguage.googleapis.com)
+ * @param model - Model name (e.g., gemini-2.0-flash)
+ * @param stream - Whether to use streaming endpoint
+ */
+declare function buildGeminiApiUrl(baseUrl: string, model: string, stream: boolean): string;
+/**
+ * Normalize Azure OpenAI endpoint
+ * Strips trailing /, /openai, /openai/v1 etc.
+ */
+declare function normalizeAzureEndpoint(endpoint: string): string;
+/**
+ * Build Azure OpenAI API URL
+ * Format: {endpoint}/openai/deployments/{deploymentName}/chat/completions?api-version={version}
+ * @param baseUrl - Azure endpoint (e.g., https://my-resource.openai.azure.com)
+ * @param model - Deployment name (used as model in Azure)
+ * @param apiVersion - API version (e.g., 2024-08-01-preview)
+ */
+declare function buildAzureOpenAIApiUrl(baseUrl: string, model: string, apiVersion: string): string;
+/**
+ * Build OpenAI Responses API URL
+ * Format: {baseUrl}/v1/responses
+ */
+declare function buildOpenAIResponseApiUrl(baseUrl: string): string;
+
+declare const resolveProviderEndpoint: typeof resolveProviderEndpoint$1;
+/**
+ * Build API URL based on provider format and options
+ * This is the main entry point for URL building
+ */
+declare function buildProviderApiUrl(provider: LLMProvider, options?: {
+    model?: string;
+    stream?: boolean;
+}): string;
+
+export { buildAnthropicApiUrl, buildAzureOpenAIApiUrl, buildGeminiApiUrl, buildGeminiModelActionUrl, buildOpenAIApiUrl, buildOpenAIResponseApiUrl, buildProviderApiUrl, normalizeAzureEndpoint, resolveApiFormat, resolveProviderEndpoint };

package/dist/completion/url-builder.js

@@ -0,0 +1,104 @@
+// src/completion/url-builder.ts
+import { resolveProviderEndpoint as resolveProviderEndpointShared } from "@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 = resolveProviderEndpointShared;
+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);
+  }
+}
+export {
+  buildAnthropicApiUrl,
+  buildAzureOpenAIApiUrl,
+  buildGeminiApiUrl,
+  buildGeminiModelActionUrl,
+  buildOpenAIApiUrl,
+  buildOpenAIResponseApiUrl,
+  buildProviderApiUrl,
+  normalizeAzureEndpoint,
+  resolveApiFormat,
+  resolveProviderEndpoint
+};

package/dist/completion.d.cts

@@ -1,17 +1,158 @@
-export { a as ApiFormat, B as BuiltinToolExecutor, C as CompletionOptions, b as CompletionResult, c as CompletionService, N as NATIVE_SEARCH_TOOL_NAMES, d as NativeSearchAugmentation, e as NativeSearchDetectionResult, f as NativeSearchProvider, g as NativeSearchUserConfig, S as SimpleChatGeminiMessage, h as SimpleChatGeminiPart, i as StreamCallbacks, j as StreamEvent, k as StreamEventType, l as StreamSender, V as VisionFallbackProvider, m as addOpenRouterProviderToRequest, n as applyAugmentation, o as attachStreamEventBuffer, p as buildAnthropicApiUrl, q as buildAzureOpenAIApiUrl, r as buildGeminiApiUrl, s as buildNativeSearchAugmentation, t as buildOpenAIApiUrl, u as buildOpenAIResponseApiUrl, v as buildProviderApiUrl, w as convertMessageToAnthropic, x as convertMessageToGemini, y as convertMessageToOpenAI, z as detectNativeSearch, D as emitStreamEvent, E as getBuiltinSearchTools, F as getOpenRouterProviderConfig, H as getProviderHeaders, I as normalizeAzureEndpoint, J as registerStreamEventBuffer, K as releaseStreamEventBuffer, L as resolveApiFormat, P as resolveProviderEndpoint } from './index-DXazdTzZ.cjs';
+export { A as ApiFormat, C as CompletionOptions, a as CompletionResult, N as NATIVE_SEARCH_TOOL_NAMES, b as NativeSearchAugmentation, c as NativeSearchDetectionResult, d as NativeSearchProvider, e as NativeSearchUserConfig, S as StreamCallbacks } from './types-BScIHmPr.cjs';
+export { C as CompletionService, V as VisionFallbackProvider } from './CompletionService-DtOF_War.cjs';
+export { buildAnthropicApiUrl, buildAzureOpenAIApiUrl, buildGeminiApiUrl, buildOpenAIApiUrl, buildOpenAIResponseApiUrl, buildProviderApiUrl, normalizeAzureEndpoint, resolveApiFormat, resolveProviderEndpoint } from './completion/url-builder.cjs';
+import { LLMProvider, OpenRouterProviderRouting } from '@omnicross/contracts/llm-config';
+import { SimpleChatMessage, AnthropicMessage, OpenAIMessage } from '@omnicross/contracts/completion-types';
+export { B as BuiltinToolExecutor, g as getBuiltinSearchTools } from './BuiltinToolExecutor-CS2WpXhM.cjs';
+export { applyAugmentation, buildNativeSearchAugmentation, detectNativeSearch } from './completion/NativeSearchInjector.cjs';
 import '@omnicross/contracts/message-blocks';
-import '@omnicross/contracts/completion-types';
-import '@omnicross/contracts/llm-config';
 import './usage-event-sink-BX7FE1NL.cjs';
 import './ApiKeyPoolService-BmMkau07.cjs';
-import './types-DZIQbgp0.cjs';
+import './ports/provider-config-source.cjs';
+import './transformer/types.cjs';
+import './transformer/TransformerService.cjs';
+import './provider-proxy/types.cjs';
 import 'node:http';
 import '@omnicross/contracts/subscription-types';
 import '@omnicross/contracts/usage-types';
-import './SubscriptionAuthSource-Cr4fVEYY.cjs';
+import './pipeline/AuthSource.cjs';
+import './pipeline/SubscriptionAuthSource.cjs';
 import './pipeline/SubscriptionAuthStrategy.cjs';
-import './transformer/types.cjs';
-import './transformer/TransformerService.cjs';
+import './ports/web-search-backend.cjs';
 import '@omnicross/contracts/websearch-types';
 import '@omnicross/contracts/mcp-types';
 import '@omnicross/contracts/endpoint-resolver';
+
+/**
+ * StreamEventBuffer — per-streamId event queue for streamed completion delivery.
+ *
+ * Closes the subscribe-vs-emit race between a producer that starts the LLM call
+ * asynchronously and a consumer that only attaches its listener after awaiting a
+ * reply. Events emitted before `attach(streamId)` is called are queued and
+ * replayed in order on attach.
+ */
+/**
+ * Minimal structural sender — the subset of an Electron `WebContents` (or any
+ * IPC channel) this buffer actually uses. Kept LOCAL so core has zero electron
+ * dependency; the host passes any object satisfying this shape.
+ */
+interface StreamSender {
+    isDestroyed(): boolean;
+    send(channel: string, payload: StreamEvent): void;
+}
+type StreamEventType = 'start' | 'delta' | 'reasoning' | 'tool_call' | 'tool_result' | 'tool_use' | 'block' | 'search_start' | 'search_result' | 'done' | 'error' | 'abort';
+interface StreamEvent {
+    type: StreamEventType;
+    [key: string]: unknown;
+}
+/**
+ * Register a new stream. Called by the engine / handler immediately after the
+ * `streamId` is created, before any `emit`. Idempotent re-registration replaces
+ * the sender (covers the rare case of the engine retrying with the same id).
+ */
+declare function register(streamId: string, sender: StreamSender): void;
+/**
+ * Emit an event for `streamId`. Forwards directly if the client has attached;
+ * otherwise queues until `attach` is called. Bounded at QUEUE_CAP — overflow
+ * evicts the oldest non-terminal event.
+ */
+declare function emit(streamId: string, event: StreamEvent): void;
+/**
+ * The client announced readiness via the `completion:stream:subscribe` IPC. Drains
+ * the queue synchronously to the bound sender, then flips to direct-forward mode.
+ * Returns the number of events drained for diagnostic purposes.
+ */
+declare function attach(streamId: string): {
+    ok: boolean;
+    drained: number;
+};
+/**
+ * Mark a stream finished. If the client has already attached, release
+ * synchronously. Otherwise defer one tick so a late `subscribe` arriving on the
+ * heels of the `done`/`error` event still drains the queue before cleanup.
+ */
+declare function release(streamId: string): void;
+
+/**
+ * Request Header Building Utilities
+ *
+ * Functions for building correct request headers based on provider format.
+ */
+
+/**
+ * Get request headers based on provider format
+ */
+declare function getProviderHeaders(provider: LLMProvider, apiKey: string): Record<string, string>;
+
+/**
+ * Message Format Conversion Utilities
+ *
+ * Functions for converting SimpleChatMessage to different API formats.
+ */
+
+/**
+ * Convert SimpleChatMessage to OpenAI-compatible format (covers OpenAI, OpenRouter,
+ * and other OpenAI-compatible providers — DO NOT call from Anthropic / Gemini paths,
+ * which have their own converters above).
+ *
+ * - Text only: { role, content: string }
+ * - With media: { role, content: [{ type: "text" | "image_url" | "input_audio" | "video_url", ... }] }
+ *
+ * Audio is emitted as `input_audio` with base64 + format (the standard OpenAI / OpenRouter
+ * shape). Video is emitted as `video_url`: HTTPS URLs pass through; local data is sent as a
+ * `data:<mime>;base64,...` URL with a 25 MB cap before the request is even built.
+ */
+declare function convertMessageToOpenAI(msg: SimpleChatMessage): OpenAIMessage;
+/**
+ * Convert SimpleChatMessage to Anthropic format (with vision support)
+ * Anthropic format:
+ * - Text only: { role, content: string }
+ * - With images: { role, content: [{ type: "text", text: "..." }, { type: "image", source: { type: "base64", media_type: "...", data: "..." } }] }
+ */
+declare function convertMessageToAnthropic(msg: SimpleChatMessage): AnthropicMessage;
+/**
+ * Minimal Gemini part shape for the simple-chat DIRECT path (text + inline
+ * media only), serialized with the official REST JSON casing
+ * (`inlineData` / `mimeType`).
+ *
+ * NOT the same wire model as the transformer pipeline's full `GeminiPart`
+ * union in `transformer/transformers/utils/gemini.util.ts` (function calls /
+ * file data, snake_case alias keys). The two paths intentionally serialize
+ * differently — do not merge them blindly.
+ */
+interface SimpleChatGeminiPart {
+    text?: string;
+    inlineData?: {
+        mimeType: string;
+        data: string;
+    };
+}
+/** Gemini message for the simple-chat direct path. */
+interface SimpleChatGeminiMessage {
+    role: string;
+    parts: SimpleChatGeminiPart[];
+}
+/**
+ * Convert SimpleChatMessage to Gemini format (with vision support)
+ * Gemini format:
+ * - { role: "user"|"model", parts: [{ text: "..." }, { inlineData: { mimeType: "...", data: "..." } }] }
+ */
+declare function convertMessageToGemini(msg: SimpleChatMessage): SimpleChatGeminiMessage;
+
+/**
+ * OpenRouter Provider Utilities
+ *
+ * Functions for handling OpenRouter-specific configuration and routing.
+ */
+
+/**
+ * Get OpenRouter provider routing config from model configuration
+ * Returns the provider routing config if the provider is OpenRouter and model has config
+ */
+declare function getOpenRouterProviderConfig(provider: LLMProvider, modelId: string): OpenRouterProviderRouting | undefined;
+/**
+ * Add OpenRouter provider routing to request body if applicable
+ */
+declare function addOpenRouterProviderToRequest(requestBody: Record<string, unknown>, provider: LLMProvider, modelId: string): Record<string, unknown>;
+
+export { type SimpleChatGeminiMessage, type SimpleChatGeminiPart, type StreamEvent, type StreamEventType, type StreamSender, addOpenRouterProviderToRequest, attach as attachStreamEventBuffer, convertMessageToAnthropic, convertMessageToGemini, convertMessageToOpenAI, emit as emitStreamEvent, getOpenRouterProviderConfig, getProviderHeaders, register as registerStreamEventBuffer, release as releaseStreamEventBuffer };