@amux.ai/llm-bridge 0.2.0

package/dist/index.cjs

@@ -0,0 +1,909 @@
+'use strict';
+
+// src/adapter/registry.ts
+var AdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  /**
+   * Register an adapter
+   */
+  register(adapter) {
+    if (this.adapters.has(adapter.name)) {
+      throw new Error(`Adapter "${adapter.name}" is already registered`);
+    }
+    this.adapters.set(adapter.name, adapter);
+  }
+  /**
+   * Unregister an adapter
+   */
+  unregister(name) {
+    return this.adapters.delete(name);
+  }
+  /**
+   * Get an adapter by name
+   */
+  get(name) {
+    return this.adapters.get(name);
+  }
+  /**
+   * Check if an adapter is registered
+   */
+  has(name) {
+    return this.adapters.has(name);
+  }
+  /**
+   * List all registered adapters
+   */
+  list() {
+    return Array.from(this.adapters.values()).map(
+      (adapter) => adapter.getInfo()
+    );
+  }
+  /**
+   * Clear all adapters
+   */
+  clear() {
+    this.adapters.clear();
+  }
+};
+var globalRegistry = new AdapterRegistry();
+
+// src/utils/sse-parser.ts
+var SSELineParser = class {
+  buffer = "";
+  /**
+   * Process a chunk of SSE data and extract complete lines
+   * @param chunk - The data chunk to process
+   * @returns Array of complete lines
+   */
+  processChunk(chunk) {
+    this.buffer += chunk;
+    return this.extractLines();
+  }
+  /**
+   * Extract all complete lines from the buffer
+   * Incomplete lines remain in the buffer
+   * @private
+   */
+  extractLines() {
+    const lines = [];
+    let position = 0;
+    while (position < this.buffer.length) {
+      const newlineIndex = this.buffer.indexOf("\n", position);
+      if (newlineIndex === -1) {
+        this.buffer = this.buffer.slice(position);
+        break;
+      }
+      const line = this.buffer.slice(position, newlineIndex);
+      lines.push(line);
+      position = newlineIndex + 1;
+    }
+    if (position >= this.buffer.length) {
+      this.buffer = "";
+    }
+    return lines;
+  }
+  /**
+   * Get any remaining data in the buffer and clear it
+   * Call this when the stream ends to get the last incomplete line
+   */
+  flush() {
+    if (this.buffer.length === 0) {
+      return [];
+    }
+    const lines = this.buffer.split("\n").filter((line) => line.length > 0);
+    this.buffer = "";
+    return lines;
+  }
+  /**
+   * Check if buffer has any remaining data
+   */
+  hasRemaining() {
+    return this.buffer.length > 0;
+  }
+  /**
+   * Clear the buffer
+   */
+  clear() {
+    this.buffer = "";
+  }
+};
+
+// src/errors/index.ts
+var LLMBridgeError = class extends Error {
+  code;
+  retryable;
+  details;
+  constructor(message, code, retryable = false, details) {
+    super(message);
+    this.name = "LLMBridgeError";
+    this.code = code;
+    this.retryable = retryable;
+    this.details = details;
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var APIError = class extends LLMBridgeError {
+  status;
+  provider;
+  data;
+  response;
+  constructor(message, status, provider, data, response) {
+    super(message, "API_ERROR", status >= 500, data);
+    this.name = "APIError";
+    this.status = status;
+    this.provider = provider;
+    this.data = data;
+    this.response = response;
+  }
+};
+var NetworkError = class extends LLMBridgeError {
+  cause;
+  constructor(message, cause) {
+    super(message, "NETWORK_ERROR", true, cause);
+    this.name = "NetworkError";
+    this.cause = cause;
+  }
+};
+var TimeoutError = class extends LLMBridgeError {
+  timeout;
+  constructor(message, timeout) {
+    super(message, "TIMEOUT_ERROR", true, { timeout });
+    this.name = "TimeoutError";
+    this.timeout = timeout;
+  }
+};
+var ValidationError = class extends LLMBridgeError {
+  errors;
+  constructor(message, errors) {
+    super(message, "VALIDATION_ERROR", false, { errors });
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+};
+var AdapterError = class extends LLMBridgeError {
+  adapterName;
+  constructor(message, adapterName, details) {
+    super(message, "ADAPTER_ERROR", false, details);
+    this.name = "AdapterError";
+    this.adapterName = adapterName;
+  }
+};
+var BridgeError = class extends LLMBridgeError {
+  constructor(message, details) {
+    super(message, "BRIDGE_ERROR", false, details);
+    this.name = "BridgeError";
+  }
+};
+
+// src/bridge/http-client.ts
+var HTTPClient = class {
+  defaultHeaders;
+  defaultTimeout;
+  maxRetries;
+  provider;
+  maxResponseSize;
+  constructor(options) {
+    this.defaultHeaders = options?.headers ?? {};
+    this.defaultTimeout = options?.timeout ?? 6e4;
+    this.maxRetries = options?.maxRetries ?? 3;
+    this.provider = options?.provider ?? "unknown";
+    this.maxResponseSize = options?.maxResponseSize ?? 100 * 1024 * 1024;
+  }
+  /**
+   * Determine if a status code should be retried
+   * @private
+   */
+  shouldRetry(status) {
+    const retryableStatuses = [408, 429, 500, 502, 503, 504];
+    return retryableStatuses.includes(status);
+  }
+  /**
+   * Calculate backoff delay with jitter
+   * @private
+   */
+  getBackoffDelay(attempt, retryAfter) {
+    if (retryAfter !== void 0 && retryAfter > 0) {
+      return retryAfter * 1e3;
+    }
+    const baseDelay = Math.pow(2, attempt) * 1e3;
+    const jitter = Math.random() * baseDelay * 0.1;
+    return baseDelay + jitter;
+  }
+  /**
+   * Make an HTTP request with retry logic
+   */
+  async request(options, retries = 0) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+    }, options.timeout ?? this.defaultTimeout);
+    try {
+      const response = await fetch(options.url, {
+        method: options.method,
+        headers: {
+          "Content-Type": "application/json",
+          ...this.defaultHeaders,
+          ...options.headers
+        },
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: options.signal ?? controller.signal
+      });
+      clearTimeout(timeoutId);
+      const contentLength = response.headers.get("content-length");
+      if (contentLength) {
+        const size = parseInt(contentLength, 10);
+        if (size > this.maxResponseSize) {
+          throw new NetworkError(
+            `Response size (${size} bytes) exceeds maximum allowed size (${this.maxResponseSize} bytes)`
+          );
+        }
+      }
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const headers = Object.fromEntries(response.headers.entries());
+        throw new APIError(
+          `HTTP ${response.status}: ${response.statusText}`,
+          response.status,
+          this.provider,
+          errorData,
+          { headers }
+        );
+      }
+      const data = await response.json();
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+        data
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof APIError) {
+        if (this.shouldRetry(error.status) && retries < this.maxRetries) {
+          const retryAfter = error.response?.headers?.["retry-after"];
+          const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : void 0;
+          const delay = this.getBackoffDelay(retries, retryAfterSeconds);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          return this.request(options, retries + 1);
+        }
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        const timeoutError = new TimeoutError(
+          "Request timeout",
+          options.timeout ?? this.defaultTimeout
+        );
+        if (retries < this.maxRetries) {
+          const delay = this.getBackoffDelay(retries);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          return this.request(options, retries + 1);
+        }
+        throw timeoutError;
+      }
+      const networkError = new NetworkError("Network request failed", error);
+      if (retries < this.maxRetries) {
+        const delay = this.getBackoffDelay(retries);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return this.request(options, retries + 1);
+      }
+      throw networkError;
+    }
+  }
+  /**
+   * Make a streaming HTTP request
+   */
+  async *requestStream(options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+    }, options.timeout ?? this.defaultTimeout);
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream",
+        ...this.defaultHeaders,
+        ...options.headers
+      };
+      const response = await fetch(options.url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: options.signal ?? controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const headers2 = Object.fromEntries(response.headers.entries());
+        throw new APIError(
+          `HTTP ${response.status}: ${response.statusText}`,
+          response.status,
+          this.provider,
+          errorData,
+          { headers: headers2 }
+        );
+      }
+      if (!response.body) {
+        throw new NetworkError("Response body is null");
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let totalBytes = 0;
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          totalBytes += value.length;
+          if (totalBytes > this.maxResponseSize) {
+            throw new NetworkError(
+              `Streaming response size (${totalBytes} bytes) exceeds maximum allowed size (${this.maxResponseSize} bytes)`
+            );
+          }
+          const chunk = decoder.decode(value, { stream: true });
+          yield chunk;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof APIError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new TimeoutError(
+          "Request timeout",
+          options.timeout ?? this.defaultTimeout
+        );
+      }
+      if (error instanceof NetworkError) {
+        throw error;
+      }
+      throw new NetworkError("Network request failed", error);
+    }
+  }
+};
+
+// src/bridge/bridge.ts
+var Bridge = class {
+  inboundAdapter;
+  outboundAdapter;
+  config;
+  httpClient;
+  // Lifecycle hooks
+  hooks;
+  // Model mapping configuration
+  targetModel;
+  modelMapper;
+  modelMapping;
+  constructor(options) {
+    this.inboundAdapter = options.inbound;
+    this.outboundAdapter = options.outbound;
+    this.config = options.config;
+    this.hooks = options.hooks;
+    this.targetModel = options.targetModel;
+    this.modelMapper = options.modelMapper;
+    this.modelMapping = options.modelMapping;
+    const authHeaderName = this.config.authHeaderName ?? "Authorization";
+    const authHeaderPrefix = this.config.authHeaderPrefix ?? "Bearer";
+    const authHeaderValue = authHeaderPrefix ? `${authHeaderPrefix} ${this.config.apiKey}` : this.config.apiKey;
+    this.httpClient = new HTTPClient({
+      headers: {
+        [authHeaderName]: authHeaderValue,
+        ...this.config.headers
+      },
+      timeout: this.config.timeout,
+      maxRetries: this.config.maxRetries,
+      provider: this.outboundAdapter.name
+    });
+  }
+  /**
+   * Map model name from inbound to outbound
+   * Priority: targetModel > modelMapper > modelMapping > original model
+   */
+  mapModel(inboundModel) {
+    if (!inboundModel) return void 0;
+    if (this.targetModel) {
+      return this.targetModel;
+    }
+    if (this.modelMapper) {
+      return this.modelMapper(inboundModel);
+    }
+    if (this.modelMapping && this.modelMapping[inboundModel]) {
+      return this.modelMapping[inboundModel];
+    }
+    return inboundModel;
+  }
+  /**
+   * Validate that the IR request features are supported by outbound adapter
+   * @private
+   */
+  validateCapabilities(ir) {
+    const cap = this.outboundAdapter.capabilities;
+    if (ir.tools && ir.tools.length > 0 && !cap.tools) {
+      throw new Error(
+        `Outbound adapter '${this.outboundAdapter.name}' does not support tools`
+      );
+    }
+    if (!cap.vision) {
+      const hasVisionContent = ir.messages.some((msg) => {
+        if (typeof msg.content === "string") return false;
+        return msg.content.some((part) => part.type === "image");
+      });
+      if (hasVisionContent) {
+        throw new Error(
+          `Outbound adapter '${this.outboundAdapter.name}' does not support vision`
+        );
+      }
+    }
+    if (ir.generation?.thinking && !cap.reasoning) {
+      throw new Error(
+        `Outbound adapter '${this.outboundAdapter.name}' does not support reasoning/thinking`
+      );
+    }
+  }
+  /**
+   * Send a chat request
+   */
+  async chat(request) {
+    try {
+      const ir = this.inboundAdapter.inbound.parseRequest(request);
+      if (ir.model) {
+        ir.model = this.mapModel(ir.model);
+      }
+      if (this.hooks?.onRequest) {
+        await this.hooks.onRequest(ir);
+      }
+      if (this.inboundAdapter.validateRequest) {
+        const validation = this.inboundAdapter.validateRequest(ir);
+        if (!validation.valid) {
+          throw new Error(
+            `Invalid request: ${validation.errors?.join(", ") ?? "Unknown error"}`
+          );
+        }
+      }
+      this.validateCapabilities(ir);
+      const providerRequest = this.outboundAdapter.outbound.buildRequest(ir);
+      const baseURL = this.config.baseURL ?? this.getDefaultBaseURL();
+      const endpoint = this.getEndpoint(ir.model);
+      const response = await this.httpClient.request({
+        method: "POST",
+        url: `${baseURL}${endpoint}`,
+        body: providerRequest
+      });
+      const responseIR = this.outboundAdapter.inbound.parseResponse?.(
+        response.data
+      );
+      if (!responseIR) {
+        throw new Error("Outbound adapter does not support response parsing");
+      }
+      if (this.hooks?.onResponse) {
+        await this.hooks.onResponse(responseIR);
+      }
+      const finalResponse = this.inboundAdapter.outbound.buildResponse?.(responseIR);
+      if (!finalResponse) {
+        return responseIR;
+      }
+      return finalResponse;
+    } catch (error) {
+      if (this.hooks?.onError && error instanceof Error) {
+        try {
+          const errorIR = this.outboundAdapter.inbound.parseError?.(error) ?? {
+            message: error.message,
+            code: "UNKNOWN_ERROR",
+            type: "unknown"
+          };
+          await this.hooks.onError(errorIR);
+        } catch (hookError) {
+          console.warn("Error in onError hook:", hookError);
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Send a chat request (raw IR response)
+   * Returns raw IR response for custom processing
+   */
+  async chatRaw(request) {
+    const ir = this.inboundAdapter.inbound.parseRequest(request);
+    if (ir.model) {
+      ir.model = this.mapModel(ir.model);
+    }
+    if (this.inboundAdapter.validateRequest) {
+      const validation = this.inboundAdapter.validateRequest(ir);
+      if (!validation.valid) {
+        throw new Error(
+          `Invalid request: ${validation.errors?.join(", ") ?? "Unknown error"}`
+        );
+      }
+    }
+    const providerRequest = this.outboundAdapter.outbound.buildRequest(ir);
+    const baseURL = this.config.baseURL ?? this.getDefaultBaseURL();
+    const endpoint = this.getEndpoint(ir.model);
+    const response = await this.httpClient.request({
+      method: "POST",
+      url: `${baseURL}${endpoint}`,
+      body: providerRequest
+    });
+    const responseIR = this.outboundAdapter.inbound.parseResponse?.(
+      response.data
+    );
+    if (!responseIR) {
+      throw new Error("Outbound adapter does not support response parsing");
+    }
+    return responseIR;
+  }
+  /**
+   * Send a streaming chat request
+   * Returns SSE events in inbound adapter's format
+   */
+  async *chatStream(request) {
+    const streamBuilder = this.inboundAdapter.outbound.createStreamBuilder?.();
+    if (!streamBuilder) {
+      for await (const event of this.chatStreamRaw(request)) {
+        yield { event: "data", data: event };
+      }
+      return;
+    }
+    for await (const event of this.chatStreamRaw(request)) {
+      const sseEvents = streamBuilder.process(event);
+      for (const sse of sseEvents) {
+        yield sse;
+      }
+    }
+    if (streamBuilder.finalize) {
+      const finalEvents = streamBuilder.finalize();
+      for (const sse of finalEvents) {
+        if (sse.data === "[DONE]") {
+          continue;
+        }
+        yield sse;
+      }
+    }
+  }
+  /**
+   * Send a streaming chat request (raw IR events)
+   * Returns raw IR stream events for custom processing
+   */
+  async *chatStreamRaw(request) {
+    try {
+      const ir = this.inboundAdapter.inbound.parseRequest(request);
+      if (ir.model) {
+        ir.model = this.mapModel(ir.model);
+      }
+      ir.stream = true;
+      if (this.hooks?.onRequest) {
+        await this.hooks.onRequest(ir);
+      }
+      if (!this.outboundAdapter.capabilities.streaming) {
+        throw new Error(
+          `Outbound adapter '${this.outboundAdapter.name}' does not support streaming`
+        );
+      }
+      this.validateCapabilities(ir);
+      const providerRequest = this.outboundAdapter.outbound.buildRequest(ir);
+      const baseURL = this.config.baseURL ?? this.getDefaultBaseURL();
+      const endpoint = this.getEndpoint(ir.model);
+      const streamHandler = this.outboundAdapter.inbound.parseStream;
+      if (!streamHandler) {
+        throw new Error("Outbound adapter does not support streaming");
+      }
+      const sseParser = new SSELineParser();
+      for await (const chunk of this.httpClient.requestStream({
+        method: "POST",
+        url: `${baseURL}${endpoint}`,
+        body: providerRequest
+      })) {
+        const lines = sseParser.processChunk(chunk);
+        for await (const event of this.processSSELines(lines, streamHandler)) {
+          yield event;
+        }
+      }
+      if (sseParser.hasRemaining()) {
+        const lines = sseParser.flush();
+        for await (const event of this.processSSELines(lines, streamHandler)) {
+          yield event;
+        }
+      }
+    } catch (error) {
+      if (this.hooks?.onError && error instanceof Error) {
+        try {
+          const errorIR = this.outboundAdapter.inbound.parseError?.(error) ?? {
+            message: error.message,
+            code: "UNKNOWN_ERROR",
+            type: "unknown"
+          };
+          await this.hooks.onError(errorIR);
+        } catch (hookError) {
+          console.warn("Error in onError hook:", hookError);
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Process SSE lines and yield stream events
+   * @private
+   */
+  async *processSSELines(lines, streamHandler) {
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") continue;
+        try {
+          const parsed = JSON.parse(data);
+          const events = streamHandler(parsed);
+          if (events) {
+            const eventArray = Array.isArray(events) ? events : [events];
+            for (const event of eventArray) {
+              if (this.hooks?.onStreamEvent) {
+                await this.hooks.onStreamEvent(event);
+              }
+              yield event;
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+  }
+  /**
+   * List available models from the provider
+   */
+  async listModels() {
+    const baseURL = this.config.baseURL ?? this.getDefaultBaseURL();
+    const modelsPath = this.getModelsPath();
+    const response = await this.httpClient.request({
+      method: "GET",
+      url: `${baseURL}${modelsPath}`
+    });
+    return response.data;
+  }
+  /**
+   * Check compatibility between adapters
+   */
+  checkCompatibility() {
+    const issues = [];
+    const warnings = [];
+    const inCap = this.inboundAdapter.capabilities;
+    const outCap = this.outboundAdapter.capabilities;
+    if (inCap.tools && !outCap.tools) {
+      issues.push(
+        "Inbound adapter supports tools but outbound adapter does not"
+      );
+    }
+    if (inCap.vision && !outCap.vision) {
+      warnings.push(
+        "Inbound adapter supports vision but outbound adapter does not"
+      );
+    }
+    if (inCap.streaming && !outCap.streaming) {
+      warnings.push(
+        "Inbound adapter supports streaming but outbound adapter does not"
+      );
+    }
+    if (inCap.reasoning && !outCap.reasoning) {
+      warnings.push(
+        "Inbound adapter supports reasoning but outbound adapter does not - reasoning content may be lost"
+      );
+    }
+    return {
+      compatible: issues.length === 0,
+      issues: issues.length > 0 ? issues : void 0,
+      warnings: warnings.length > 0 ? warnings : void 0
+    };
+  }
+  /**
+   * Get adapter information
+   */
+  getAdapters() {
+    return {
+      inbound: {
+        name: this.inboundAdapter.name,
+        version: this.inboundAdapter.version
+      },
+      outbound: {
+        name: this.outboundAdapter.name,
+        version: this.outboundAdapter.version
+      }
+    };
+  }
+  /**
+   * Get default base URL from outbound adapter
+   * Note: config.baseURL is checked before calling this method
+   */
+  getDefaultBaseURL() {
+    const endpoint = this.outboundAdapter.getInfo().endpoint;
+    return endpoint?.baseUrl ?? "";
+  }
+  /**
+   * Get chat endpoint path
+   * Supports dynamic model replacement for endpoints like /v1beta/models/{model}:generateContent
+   * Priority: config.chatPath > adapter.endpoint.chatPath
+   */
+  getEndpoint(model) {
+    const endpoint = this.outboundAdapter.getInfo().endpoint;
+    let chatPath = this.config.chatPath ?? endpoint?.chatPath;
+    if (!chatPath) {
+      throw new Error(
+        `No chatPath configured. Either provide chatPath in config or ensure adapter '${this.outboundAdapter.name}' defines endpoint.chatPath`
+      );
+    }
+    if (model && chatPath.includes("{model}")) {
+      chatPath = chatPath.replace("{model}", model);
+    }
+    return chatPath;
+  }
+  /**
+   * Get models endpoint path
+   * Priority: config.modelsPath > adapter.endpoint.modelsPath
+   */
+  getModelsPath() {
+    const endpoint = this.outboundAdapter.getInfo().endpoint;
+    const modelsPath = this.config.modelsPath ?? endpoint?.modelsPath;
+    if (!modelsPath) {
+      throw new Error(
+        `No modelsPath configured. Either provide modelsPath in config or ensure adapter '${this.outboundAdapter.name}' defines endpoint.modelsPath`
+      );
+    }
+    return modelsPath;
+  }
+};
+
+// src/bridge/factory.ts
+function createBridge(options) {
+  return new Bridge(options);
+}
+
+// src/utils/error-parser.ts
+var STANDARD_ERROR_TYPE_MAP = {
+  invalid_request_error: "validation",
+  authentication_error: "authentication",
+  permission_error: "permission",
+  not_found_error: "not_found",
+  rate_limit_error: "rate_limit",
+  api_error: "api",
+  server_error: "server",
+  insufficient_quota: "rate_limit",
+  // Common in some providers
+  invalid_api_key: "authentication"
+  // Zhipu-specific
+};
+var STANDARD_ERROR_CODE_MAP = {
+  InvalidParameter: "validation",
+  InvalidApiKey: "authentication",
+  AccessDenied: "permission",
+  ModelNotFound: "not_found",
+  Throttling: "rate_limit",
+  InternalError: "server"
+};
+var STANDARD_FINISH_REASON_MAP = {
+  stop: "stop",
+  length: "length",
+  tool_calls: "tool_calls",
+  content_filter: "content_filter",
+  function_call: "tool_calls",
+  // Legacy OpenAI
+  insufficient_system_resource: "error",
+  // DeepSeek-specific
+  sensitive: "content_filter"
+  // Zhipu-specific
+};
+function mapFinishReason(reason, customMappings, defaultReason = "stop") {
+  if (!reason) return defaultReason;
+  const reasonMap = customMappings ? { ...STANDARD_FINISH_REASON_MAP, ...customMappings } : STANDARD_FINISH_REASON_MAP;
+  return reasonMap[reason] ?? defaultReason;
+}
+function mapErrorType(type, code, customTypeMappings, customCodeMappings) {
+  if (code) {
+    const codeMap = customCodeMappings ? { ...STANDARD_ERROR_CODE_MAP, ...customCodeMappings } : STANDARD_ERROR_CODE_MAP;
+    if (codeMap[code]) return codeMap[code];
+  }
+  if (type) {
+    const typeMap = customTypeMappings ? { ...STANDARD_ERROR_TYPE_MAP, ...customTypeMappings } : STANDARD_ERROR_TYPE_MAP;
+    return typeMap[type] ?? "unknown";
+  }
+  return "unknown";
+}
+function parseOpenAICompatibleError(error, customTypeMappings, customCodeMappings) {
+  if (error && typeof error === "object" && "error" in error) {
+    const err = error.error;
+    return {
+      type: mapErrorType(err.type, err.code, customTypeMappings, customCodeMappings),
+      message: err.message,
+      code: err.code,
+      raw: error
+    };
+  }
+  return {
+    type: "unknown",
+    message: String(error),
+    raw: error
+  };
+}
+
+// src/utils/content-helpers.ts
+function contentToString(content) {
+  if (typeof content === "string") {
+    return content || null;
+  }
+  if (!content || content.length === 0) {
+    return null;
+  }
+  return content.filter((part) => part.type === "text").map((part) => part.type === "text" ? part.text : "").join("") || null;
+}
+function isTextOnlyContent(content) {
+  if (typeof content === "string") {
+    return true;
+  }
+  return content.every((part) => part.type === "text");
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string") {
+    return [content];
+  }
+  return content.filter((part) => part.type === "text").map((part) => part.type === "text" ? part.text : "");
+}
+function hasImageContent(content) {
+  if (typeof content === "string") {
+    return false;
+  }
+  return content.some((part) => part.type === "image");
+}
+
+// src/utils/usage-parser.ts
+function parseOpenAIUsage(usage) {
+  if (!usage) return void 0;
+  return {
+    promptTokens: usage.prompt_tokens,
+    completionTokens: usage.completion_tokens,
+    totalTokens: usage.total_tokens,
+    details: usage.completion_tokens_details?.reasoning_tokens || usage.prompt_cache_hit_tokens ? {
+      reasoningTokens: usage.completion_tokens_details?.reasoning_tokens,
+      cachedTokens: usage.prompt_cache_hit_tokens
+    } : void 0
+  };
+}
+function buildOpenAIUsage(usage, includeReasoningTokens = true, includeCacheTokens = false) {
+  if (!usage) return void 0;
+  const result = {
+    prompt_tokens: usage.promptTokens,
+    completion_tokens: usage.completionTokens,
+    total_tokens: usage.totalTokens
+  };
+  if (includeReasoningTokens && usage.details?.reasoningTokens) {
+    result.completion_tokens_details = {
+      reasoning_tokens: usage.details.reasoningTokens
+    };
+  }
+  if (includeCacheTokens && usage.details?.cachedTokens) {
+    result.prompt_cache_hit_tokens = usage.details.cachedTokens;
+  }
+  return result;
+}
+
+exports.APIError = APIError;
+exports.AdapterError = AdapterError;
+exports.AdapterRegistry = AdapterRegistry;
+exports.Bridge = Bridge;
+exports.BridgeError = BridgeError;
+exports.HTTPClient = HTTPClient;
+exports.LLMBridgeError = LLMBridgeError;
+exports.NetworkError = NetworkError;
+exports.SSELineParser = SSELineParser;
+exports.TimeoutError = TimeoutError;
+exports.ValidationError = ValidationError;
+exports.buildOpenAIUsage = buildOpenAIUsage;
+exports.contentToString = contentToString;
+exports.createBridge = createBridge;
+exports.extractTextFromContent = extractTextFromContent;
+exports.globalRegistry = globalRegistry;
+exports.hasImageContent = hasImageContent;
+exports.isTextOnlyContent = isTextOnlyContent;
+exports.mapErrorType = mapErrorType;
+exports.mapFinishReason = mapFinishReason;
+exports.parseOpenAICompatibleError = parseOpenAICompatibleError;
+exports.parseOpenAIUsage = parseOpenAIUsage;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map