@lelemondev/sdk 0.3.0 → 0.5.0

package/dist/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-/* @lelemon/sdk - LLM Observability */
+/* @lelemondev/sdk - LLM Observability */
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -311,7 +311,7 @@ function canHandle(client) {
   const constructorName = client.constructor?.name;
   if (constructorName === "OpenAI") return true;
   const c = client;
-  return !!(c.chat && c.completions);
+  return !!(c.chat && c.completions) || !!c.responses;
 }
 function wrapChatCreate(originalFn) {
   return async function wrappedChatCreate(...args) {
@@ -351,6 +351,45 @@ function wrapChatCreate(originalFn) {
     }
   };
 }
+function wrapResponsesCreate(originalFn) {
+  return async function wrappedResponsesCreate(...args) {
+    const startTime = Date.now();
+    const request = args[0] || {};
+    const isStreaming = request.stream === true;
+    try {
+      const response = await originalFn(...args);
+      if (isStreaming && isAsyncIterable(response)) {
+        return wrapResponsesStream(response, request, startTime);
+      }
+      const durationMs = Date.now() - startTime;
+      const extracted = extractResponsesResult(response);
+      captureTrace({
+        provider: PROVIDER_NAME,
+        model: request.model || "unknown",
+        input: { instructions: request.instructions, input: request.input },
+        output: extracted.output,
+        inputTokens: extracted.inputTokens,
+        outputTokens: extracted.outputTokens,
+        durationMs,
+        status: "success",
+        streaming: false,
+        metadata: extracted.metadata
+      });
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      captureError({
+        provider: PROVIDER_NAME,
+        model: request.model || "unknown",
+        input: { instructions: request.instructions, input: request.input },
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs,
+        streaming: isStreaming
+      });
+      throw error;
+    }
+  };
+}
 function wrapCompletionCreate(originalFn) {
   return async function wrappedCompletionCreate(...args) {
     const startTime = Date.now();
@@ -542,6 +581,85 @@ function extractStreamChunkTokens(chunk) {
     return null;
   }
 }
+function extractResponsesResult(response) {
+  let output = response.output_text || null;
+  if (!output && response.output && Array.isArray(response.output)) {
+    const textItems = response.output.filter((item) => {
+      const i = item;
+      return i.type === "message" || i.type === "text";
+    }).map((item) => {
+      const i = item;
+      if (i.type === "message" && i.content) {
+        const content = i.content;
+        return content.filter((c) => c.type === "text" || c.type === "output_text").map((c) => c.text || "").join("");
+      }
+      return i.text || "";
+    });
+    output = textItems.join("");
+  }
+  const usage = response.usage || {};
+  const inputTokens = isValidNumber(usage.input_tokens) ? usage.input_tokens : 0;
+  const outputTokens = isValidNumber(usage.output_tokens) ? usage.output_tokens : 0;
+  const metadata = {};
+  if (response.id) {
+    metadata.responseId = response.id;
+  }
+  return {
+    output,
+    inputTokens,
+    outputTokens,
+    metadata: Object.keys(metadata).length > 0 ? metadata : {}
+  };
+}
+async function* wrapResponsesStream(stream, request, startTime) {
+  const chunks = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let error = null;
+  try {
+    for await (const event of stream) {
+      const e = event;
+      if (e.type === "response.output_text.delta" && e.delta) {
+        chunks.push(e.delta);
+      }
+      if (e.type === "response.done" && e.response) {
+        const resp = e.response;
+        if (resp.usage) {
+          inputTokens = resp.usage.input_tokens || 0;
+          outputTokens = resp.usage.output_tokens || 0;
+        }
+      }
+      yield event;
+    }
+  } catch (err) {
+    error = err instanceof Error ? err : new Error(String(err));
+    throw err;
+  } finally {
+    const durationMs = Date.now() - startTime;
+    if (error) {
+      captureError({
+        provider: PROVIDER_NAME,
+        model: request.model || "unknown",
+        input: { instructions: request.instructions, input: request.input },
+        error,
+        durationMs,
+        streaming: true
+      });
+    } else {
+      captureTrace({
+        provider: PROVIDER_NAME,
+        model: request.model || "unknown",
+        input: { instructions: request.instructions, input: request.input },
+        output: chunks.join(""),
+        inputTokens,
+        outputTokens,
+        durationMs,
+        status: "success",
+        streaming: true
+      });
+    }
+  }
+}
 
 // src/providers/anthropic.ts
 var PROVIDER_NAME2 = "anthropic";
@@ -765,6 +883,802 @@ function extractTokens2(response) {
   }
 }
 
+// src/providers/bedrock.ts
+var PROVIDER_NAME3 = "bedrock";
+function canHandle3(client) {
+  if (!client || typeof client !== "object") return false;
+  const constructorName = client.constructor?.name;
+  if (constructorName === "BedrockRuntimeClient") return true;
+  const c = client;
+  if (typeof c.send !== "function") return false;
+  if (!c.config || typeof c.config !== "object") return false;
+  return "region" in c.config;
+}
+function wrap(client) {
+  const bedrockClient = client;
+  return new Proxy(bedrockClient, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "send" && typeof value === "function") {
+        return wrapSend(value.bind(target));
+      }
+      return value;
+    }
+  });
+}
+function wrapSend(originalSend) {
+  return async function tracedSend(command) {
+    const commandName = command.constructor?.name || "";
+    switch (commandName) {
+      case "ConverseCommand":
+        return handleConverse(originalSend, command);
+      case "ConverseStreamCommand":
+        return handleConverseStream(originalSend, command);
+      case "InvokeModelCommand":
+        return handleInvokeModel(originalSend, command);
+      case "InvokeModelWithResponseStreamCommand":
+        return handleInvokeModelStream(originalSend, command);
+      default:
+        return originalSend(command);
+    }
+  };
+}
+async function handleConverse(send, command) {
+  const startTime = Date.now();
+  const input = command.input;
+  try {
+    const response = await send(command);
+    const durationMs = Date.now() - startTime;
+    const extracted = extractConverseOutput(response);
+    captureTrace({
+      provider: PROVIDER_NAME3,
+      model: input.modelId || "unknown",
+      input: { system: input.system, messages: input.messages },
+      output: extracted.output,
+      inputTokens: extracted.inputTokens,
+      outputTokens: extracted.outputTokens,
+      durationMs,
+      status: "success",
+      streaming: false,
+      metadata: {
+        stopReason: response.stopReason,
+        hasToolUse: extracted.hasToolUse,
+        cacheReadTokens: extracted.cacheReadTokens,
+        cacheWriteTokens: extracted.cacheWriteTokens,
+        latencyMs: response.metrics?.latencyMs
+      }
+    });
+    return response;
+  } catch (error) {
+    captureError({
+      provider: PROVIDER_NAME3,
+      model: input.modelId || "unknown",
+      input: { system: input.system, messages: input.messages },
+      error: error instanceof Error ? error : new Error(String(error)),
+      durationMs: Date.now() - startTime,
+      streaming: false
+    });
+    throw error;
+  }
+}
+async function handleConverseStream(send, command) {
+  const startTime = Date.now();
+  const input = command.input;
+  try {
+    const response = await send(command);
+    if (response.stream) {
+      return {
+        ...response,
+        stream: wrapConverseStream(response.stream, input, startTime)
+      };
+    }
+    return response;
+  } catch (error) {
+    captureError({
+      provider: PROVIDER_NAME3,
+      model: input.modelId || "unknown",
+      input: { system: input.system, messages: input.messages },
+      error: error instanceof Error ? error : new Error(String(error)),
+      durationMs: Date.now() - startTime,
+      streaming: true
+    });
+    throw error;
+  }
+}
+async function* wrapConverseStream(stream, input, startTime) {
+  const chunks = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let error = null;
+  try {
+    for await (const event of stream) {
+      if (event.contentBlockDelta?.delta?.text) {
+        chunks.push(event.contentBlockDelta.delta.text);
+      }
+      if (event.metadata?.usage) {
+        inputTokens = event.metadata.usage.inputTokens || 0;
+        outputTokens = event.metadata.usage.outputTokens || 0;
+      }
+      yield event;
+    }
+  } catch (err) {
+    error = err instanceof Error ? err : new Error(String(err));
+    throw err;
+  } finally {
+    const durationMs = Date.now() - startTime;
+    if (error) {
+      captureError({
+        provider: PROVIDER_NAME3,
+        model: input.modelId || "unknown",
+        input: { system: input.system, messages: input.messages },
+        error,
+        durationMs,
+        streaming: true
+      });
+    } else {
+      captureTrace({
+        provider: PROVIDER_NAME3,
+        model: input.modelId || "unknown",
+        input: { system: input.system, messages: input.messages },
+        output: chunks.join(""),
+        inputTokens,
+        outputTokens,
+        durationMs,
+        status: "success",
+        streaming: true
+      });
+    }
+  }
+}
+async function handleInvokeModel(send, command) {
+  const startTime = Date.now();
+  const input = command.input;
+  try {
+    const response = await send(command);
+    const durationMs = Date.now() - startTime;
+    const parsed = parseInvokeModelBody(response.body);
+    captureTrace({
+      provider: PROVIDER_NAME3,
+      model: input.modelId || "unknown",
+      input: parseRequestBody(input.body),
+      output: parsed.output,
+      inputTokens: parsed.inputTokens,
+      outputTokens: parsed.outputTokens,
+      durationMs,
+      status: "success",
+      streaming: false
+    });
+    return response;
+  } catch (error) {
+    captureError({
+      provider: PROVIDER_NAME3,
+      model: input.modelId || "unknown",
+      input: parseRequestBody(input.body),
+      error: error instanceof Error ? error : new Error(String(error)),
+      durationMs: Date.now() - startTime,
+      streaming: false
+    });
+    throw error;
+  }
+}
+async function handleInvokeModelStream(send, command) {
+  const startTime = Date.now();
+  const input = command.input;
+  try {
+    const response = await send(command);
+    if (response.body) {
+      return {
+        ...response,
+        body: wrapInvokeModelStream(response.body, input, startTime)
+      };
+    }
+    return response;
+  } catch (error) {
+    captureError({
+      provider: PROVIDER_NAME3,
+      model: input.modelId || "unknown",
+      input: parseRequestBody(input.body),
+      error: error instanceof Error ? error : new Error(String(error)),
+      durationMs: Date.now() - startTime,
+      streaming: true
+    });
+    throw error;
+  }
+}
+async function* wrapInvokeModelStream(stream, input, startTime) {
+  const chunks = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let error = null;
+  try {
+    for await (const event of stream) {
+      if (event.chunk?.bytes) {
+        const parsed = tryParseStreamChunk(event.chunk.bytes);
+        if (parsed) {
+          if (parsed.text) chunks.push(parsed.text);
+          if (parsed.inputTokens) inputTokens = parsed.inputTokens;
+          if (parsed.outputTokens) outputTokens = parsed.outputTokens;
+        }
+      }
+      yield event;
+    }
+  } catch (err) {
+    error = err instanceof Error ? err : new Error(String(err));
+    throw err;
+  } finally {
+    const durationMs = Date.now() - startTime;
+    if (error) {
+      captureError({
+        provider: PROVIDER_NAME3,
+        model: input.modelId || "unknown",
+        input: parseRequestBody(input.body),
+        error,
+        durationMs,
+        streaming: true
+      });
+    } else {
+      captureTrace({
+        provider: PROVIDER_NAME3,
+        model: input.modelId || "unknown",
+        input: parseRequestBody(input.body),
+        output: chunks.join(""),
+        inputTokens,
+        outputTokens,
+        durationMs,
+        status: "success",
+        streaming: true
+      });
+    }
+  }
+}
+function extractConverseOutput(response) {
+  const content = response.output?.message?.content;
+  const hasToolUse = Array.isArray(content) && content.some((c) => c.toolUse);
+  const output = safeExtract(() => {
+    if (!Array.isArray(content)) return null;
+    if (hasToolUse) {
+      return content;
+    }
+    return content.map((c) => c.text || "").join("");
+  }, null);
+  const usage = response.usage || {};
+  return {
+    output,
+    inputTokens: isValidNumber(usage.inputTokens) ? usage.inputTokens : 0,
+    outputTokens: isValidNumber(usage.outputTokens) ? usage.outputTokens : 0,
+    cacheReadTokens: isValidNumber(usage.cacheReadInputTokens) ? usage.cacheReadInputTokens : 0,
+    cacheWriteTokens: isValidNumber(usage.cacheWriteInputTokens) ? usage.cacheWriteInputTokens : 0,
+    hasToolUse
+  };
+}
+function parseInvokeModelBody(body) {
+  try {
+    const text = new TextDecoder().decode(body);
+    const parsed = JSON.parse(text);
+    if (parsed.content && Array.isArray(parsed.content)) {
+      const output = parsed.content.filter((c) => c.type === "text").map((c) => c.text || "").join("");
+      return {
+        output,
+        inputTokens: parsed.usage?.input_tokens || 0,
+        outputTokens: parsed.usage?.output_tokens || 0
+      };
+    }
+    if (parsed.results) {
+      return {
+        output: parsed.results[0]?.outputText || parsed.results,
+        inputTokens: parsed.inputTextTokenCount || 0,
+        outputTokens: parsed.results[0]?.tokenCount || 0
+      };
+    }
+    if (parsed.generation) {
+      return {
+        output: parsed.generation,
+        inputTokens: parsed.prompt_token_count || 0,
+        outputTokens: parsed.generation_token_count || 0
+      };
+    }
+    return { output: parsed, inputTokens: 0, outputTokens: 0 };
+  } catch {
+    return { output: null, inputTokens: 0, outputTokens: 0 };
+  }
+}
+function parseRequestBody(body) {
+  try {
+    const text = typeof body === "string" ? body : new TextDecoder().decode(body);
+    return JSON.parse(text);
+  } catch {
+    return body;
+  }
+}
+function tryParseStreamChunk(bytes) {
+  try {
+    const text = new TextDecoder().decode(bytes);
+    const parsed = JSON.parse(text);
+    if (parsed.type === "content_block_delta" && parsed.delta?.text) {
+      return { text: parsed.delta.text };
+    }
+    if (parsed.type === "message_delta" && parsed.usage) {
+      return { outputTokens: parsed.usage.output_tokens };
+    }
+    if (parsed.type === "message_start" && parsed.message?.usage) {
+      return { inputTokens: parsed.message.usage.input_tokens };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/providers/gemini.ts
+var PROVIDER_NAME4 = "gemini";
+function canHandle4(client) {
+  if (!client || typeof client !== "object") return false;
+  const constructorName = client.constructor?.name;
+  if (constructorName === "GoogleGenerativeAI") return true;
+  if (constructorName === "GoogleGenAI") return true;
+  const c = client;
+  if (typeof c.getGenerativeModel === "function") return true;
+  if (c.models && typeof c.models.generate === "function") {
+    return true;
+  }
+  return false;
+}
+function wrap2(client) {
+  const geminiClient = client;
+  return new Proxy(geminiClient, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "getGenerativeModel" && typeof value === "function") {
+        return wrapGetGenerativeModel(value.bind(target));
+      }
+      return value;
+    }
+  });
+}
+function wrapGetGenerativeModel(originalFn) {
+  return function wrappedGetGenerativeModel(config) {
+    const model = originalFn(config);
+    return wrapGenerativeModel(model, config.model);
+  };
+}
+function wrapGenerativeModel(model, modelName) {
+  return new Proxy(model, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "generateContent" && typeof value === "function") {
+        return wrapGenerateContent(value.bind(target), modelName);
+      }
+      if (prop === "generateContentStream" && typeof value === "function") {
+        return wrapGenerateContentStream(value.bind(target), modelName);
+      }
+      if (prop === "startChat" && typeof value === "function") {
+        return wrapStartChat(value.bind(target), modelName);
+      }
+      return value;
+    }
+  });
+}
+function wrapGenerateContent(originalFn, modelName) {
+  return async function wrappedGenerateContent(request) {
+    const startTime = Date.now();
+    const input = extractInput(request);
+    try {
+      const result = await originalFn(request);
+      const durationMs = Date.now() - startTime;
+      const extracted = extractGenerateContentResult(result);
+      captureTrace({
+        provider: PROVIDER_NAME4,
+        model: modelName,
+        input,
+        output: extracted.output,
+        inputTokens: extracted.inputTokens,
+        outputTokens: extracted.outputTokens,
+        durationMs,
+        status: "success",
+        streaming: false,
+        metadata: extracted.metadata
+      });
+      return result;
+    } catch (error) {
+      captureError({
+        provider: PROVIDER_NAME4,
+        model: modelName,
+        input,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime,
+        streaming: false
+      });
+      throw error;
+    }
+  };
+}
+function wrapGenerateContentStream(originalFn, modelName) {
+  return async function wrappedGenerateContentStream(request) {
+    const startTime = Date.now();
+    const input = extractInput(request);
+    try {
+      const result = await originalFn(request);
+      const wrappedStream = wrapStream3(result.stream, modelName, input, startTime);
+      return {
+        ...result,
+        stream: wrappedStream
+      };
+    } catch (error) {
+      captureError({
+        provider: PROVIDER_NAME4,
+        model: modelName,
+        input,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime,
+        streaming: true
+      });
+      throw error;
+    }
+  };
+}
+async function* wrapStream3(stream, modelName, input, startTime) {
+  const chunks = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cachedTokens = 0;
+  let thoughtsTokens = 0;
+  let error = null;
+  try {
+    for await (const chunk of stream) {
+      try {
+        const text = chunk.text();
+        if (text) {
+          chunks.push(text);
+        }
+      } catch {
+      }
+      if (chunk.usageMetadata) {
+        inputTokens = chunk.usageMetadata.promptTokenCount || 0;
+        outputTokens = chunk.usageMetadata.candidatesTokenCount || 0;
+        cachedTokens = chunk.usageMetadata.cachedContentTokenCount || 0;
+        thoughtsTokens = chunk.usageMetadata.thoughtsTokenCount || 0;
+      }
+      yield chunk;
+    }
+  } catch (err) {
+    error = err instanceof Error ? err : new Error(String(err));
+    throw err;
+  } finally {
+    const durationMs = Date.now() - startTime;
+    if (error) {
+      captureError({
+        provider: PROVIDER_NAME4,
+        model: modelName,
+        input,
+        error,
+        durationMs,
+        streaming: true
+      });
+    } else {
+      captureTrace({
+        provider: PROVIDER_NAME4,
+        model: modelName,
+        input,
+        output: chunks.join(""),
+        inputTokens,
+        outputTokens,
+        durationMs,
+        status: "success",
+        streaming: true,
+        metadata: {
+          cachedTokens: cachedTokens > 0 ? cachedTokens : void 0,
+          thoughtsTokens: thoughtsTokens > 0 ? thoughtsTokens : void 0
+        }
+      });
+    }
+  }
+}
+function wrapStartChat(originalFn, modelName) {
+  return function wrappedStartChat(config) {
+    const chat = originalFn(config);
+    return wrapChatSession(chat, modelName);
+  };
+}
+function wrapChatSession(chat, modelName) {
+  return new Proxy(chat, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "sendMessage" && typeof value === "function") {
+        return wrapSendMessage(value.bind(target), modelName);
+      }
+      if (prop === "sendMessageStream" && typeof value === "function") {
+        return wrapSendMessageStream(value.bind(target), modelName);
+      }
+      return value;
+    }
+  });
+}
+function wrapSendMessage(originalFn, modelName) {
+  return async function wrappedSendMessage(request) {
+    const startTime = Date.now();
+    const input = typeof request === "string" ? request : request;
+    try {
+      const result = await originalFn(request);
+      const durationMs = Date.now() - startTime;
+      const extracted = extractGenerateContentResult(result);
+      captureTrace({
+        provider: PROVIDER_NAME4,
+        model: modelName,
+        input,
+        output: extracted.output,
+        inputTokens: extracted.inputTokens,
+        outputTokens: extracted.outputTokens,
+        durationMs,
+        status: "success",
+        streaming: false,
+        metadata: extracted.metadata
+      });
+      return result;
+    } catch (error) {
+      captureError({
+        provider: PROVIDER_NAME4,
+        model: modelName,
+        input,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime,
+        streaming: false
+      });
+      throw error;
+    }
+  };
+}
+function wrapSendMessageStream(originalFn, modelName) {
+  return async function wrappedSendMessageStream(request) {
+    const startTime = Date.now();
+    const input = typeof request === "string" ? request : request;
+    try {
+      const result = await originalFn(request);
+      const wrappedStream = wrapStream3(result.stream, modelName, input, startTime);
+      return {
+        ...result,
+        stream: wrappedStream
+      };
+    } catch (error) {
+      captureError({
+        provider: PROVIDER_NAME4,
+        model: modelName,
+        input,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime,
+        streaming: true
+      });
+      throw error;
+    }
+  };
+}
+function extractInput(request) {
+  if (typeof request === "string") {
+    return request;
+  }
+  if (request.contents) {
+    return request.contents;
+  }
+  return request;
+}
+function extractGenerateContentResult(result) {
+  const response = result.response;
+  let output = null;
+  try {
+    output = response.text();
+  } catch {
+    output = safeExtract(() => {
+      const content = response.candidates?.[0]?.content;
+      if (content?.parts) {
+        return content.parts;
+      }
+      return null;
+    }, null);
+  }
+  const usage = response.usageMetadata;
+  const inputTokens = isValidNumber(usage?.promptTokenCount) ? usage.promptTokenCount : 0;
+  const outputTokens = isValidNumber(usage?.candidatesTokenCount) ? usage.candidatesTokenCount : 0;
+  const metadata = {};
+  if (usage?.cachedContentTokenCount && usage.cachedContentTokenCount > 0) {
+    metadata.cachedTokens = usage.cachedContentTokenCount;
+  }
+  if (usage?.thoughtsTokenCount && usage.thoughtsTokenCount > 0) {
+    metadata.thoughtsTokens = usage.thoughtsTokenCount;
+  }
+  const finishReason = response.candidates?.[0]?.finishReason;
+  if (finishReason) {
+    metadata.finishReason = finishReason;
+  }
+  return {
+    output,
+    inputTokens,
+    outputTokens,
+    metadata: Object.keys(metadata).length > 0 ? metadata : {}
+  };
+}
+
+// src/providers/openrouter.ts
+var OPENROUTER_BASE_URL = "openrouter.ai";
+var PROVIDER_NAME5 = "openrouter";
+function canHandle5(client) {
+  if (!client || typeof client !== "object") return false;
+  const c = client;
+  if (!c.chat?.completions?.create) return false;
+  const baseURL = c.baseURL || "";
+  return baseURL.includes(OPENROUTER_BASE_URL);
+}
+function wrap3(client) {
+  const openrouterClient = client;
+  return new Proxy(openrouterClient, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "chat" && value && typeof value === "object") {
+        return wrapChatNamespace(value);
+      }
+      return value;
+    }
+  });
+}
+function wrapChatNamespace(chat) {
+  if (!chat) return chat;
+  return new Proxy(chat, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "completions" && value && typeof value === "object") {
+        return wrapChatCompletions(value);
+      }
+      return value;
+    }
+  });
+}
+function wrapChatCompletions(completions) {
+  return new Proxy(completions, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "create" && typeof value === "function") {
+        return wrapChatCreate2(value.bind(target));
+      }
+      return value;
+    }
+  });
+}
+function wrapChatCreate2(originalFn) {
+  return async function wrappedChatCreate(...args) {
+    const startTime = Date.now();
+    const request = args[0] || {};
+    const isStreaming = request.stream === true;
+    try {
+      const response = await originalFn(...args);
+      if (isStreaming && isAsyncIterable3(response)) {
+        return wrapStream4(response, request, startTime);
+      }
+      const durationMs = Date.now() - startTime;
+      const extracted = extractChatCompletion2(response);
+      captureTrace({
+        provider: PROVIDER_NAME5,
+        model: request.model || extracted.model || "unknown",
+        input: request.messages,
+        output: extracted.output,
+        inputTokens: extracted.tokens?.inputTokens || 0,
+        outputTokens: extracted.tokens?.outputTokens || 0,
+        durationMs,
+        status: "success",
+        streaming: false,
+        metadata: extracted.metadata
+      });
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      captureError({
+        provider: PROVIDER_NAME5,
+        model: request.model || "unknown",
+        input: request.messages,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs,
+        streaming: isStreaming
+      });
+      throw error;
+    }
+  };
+}
+function isAsyncIterable3(value) {
+  return value != null && typeof value[Symbol.asyncIterator] === "function";
+}
+async function* wrapStream4(stream, request, startTime) {
+  const chunks = [];
+  let tokens = null;
+  let generationId = null;
+  let error = null;
+  try {
+    for await (const chunk of stream) {
+      const c = chunk;
+      if (!generationId && c.id) {
+        generationId = c.id;
+      }
+      const content = c.choices?.[0]?.delta?.content;
+      if (content) {
+        chunks.push(content);
+      }
+      const chunkTokens = extractStreamChunkTokens2(c);
+      if (chunkTokens) {
+        tokens = chunkTokens;
+      }
+      yield chunk;
+    }
+  } catch (err) {
+    error = err instanceof Error ? err : new Error(String(err));
+    throw err;
+  } finally {
+    const durationMs = Date.now() - startTime;
+    const output = chunks.join("");
+    const metadata = {};
+    if (generationId) {
+      metadata.generationId = generationId;
+    }
+    if (error) {
+      captureError({
+        provider: PROVIDER_NAME5,
+        model: request.model || "unknown",
+        input: request.messages,
+        error,
+        durationMs,
+        streaming: true
+      });
+    } else {
+      captureTrace({
+        provider: PROVIDER_NAME5,
+        model: request.model || "unknown",
+        input: request.messages,
+        output,
+        inputTokens: tokens?.inputTokens || 0,
+        outputTokens: tokens?.outputTokens || 0,
+        durationMs,
+        status: "success",
+        streaming: true,
+        metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+      });
+    }
+  }
+}
+function extractChatCompletion2(response) {
+  const model = response.model || null;
+  const output = response.choices?.[0]?.message?.content || null;
+  const tokens = extractTokens3(response);
+  const metadata = {};
+  if (response.id) {
+    metadata.generationId = response.id;
+  }
+  return {
+    model,
+    output,
+    tokens,
+    metadata: Object.keys(metadata).length > 0 ? metadata : {}
+  };
+}
+function extractTokens3(response) {
+  const usage = response.usage;
+  if (!usage) return null;
+  const promptTokens = usage.prompt_tokens;
+  const completionTokens = usage.completion_tokens;
+  const totalTokens = usage.total_tokens;
+  if (!isValidNumber(promptTokens) && !isValidNumber(completionTokens)) {
+    return null;
+  }
+  return {
+    inputTokens: isValidNumber(promptTokens) ? promptTokens : 0,
+    outputTokens: isValidNumber(completionTokens) ? completionTokens : 0,
+    totalTokens: isValidNumber(totalTokens) ? totalTokens : 0
+  };
+}
+function extractStreamChunkTokens2(chunk) {
+  const usage = chunk.usage;
+  if (!usage) return null;
+  return {
+    inputTokens: isValidNumber(usage.prompt_tokens) ? usage.prompt_tokens : 0,
+    outputTokens: isValidNumber(usage.completion_tokens) ? usage.completion_tokens : 0,
+    totalTokens: 0
+  };
+}
+
 // src/observe.ts
 function observe(client, options) {
   if (options) {
@@ -774,6 +1688,12 @@ function observe(client, options) {
   if (config.disabled) {
     return client;
   }
+  if (canHandle5(client)) {
+    if (config.debug) {
+      console.log("[Lelemon] Wrapping OpenRouter client");
+    }
+    return wrap3(client);
+  }
   if (canHandle(client)) {
     if (config.debug) {
       console.log("[Lelemon] Wrapping OpenAI client");
@@ -786,8 +1706,20 @@ function observe(client, options) {
     }
     return wrapAnthropic(client);
   }
+  if (canHandle3(client)) {
+    if (config.debug) {
+      console.log("[Lelemon] Wrapping Bedrock client");
+    }
+    return wrap(client);
+  }
+  if (canHandle4(client)) {
+    if (config.debug) {
+      console.log("[Lelemon] Wrapping Gemini client");
+    }
+    return wrap2(client);
+  }
   console.warn(
-    "[Lelemon] Unknown client type. Tracing not enabled. Supported: OpenAI, Anthropic"
+    "[Lelemon] Unknown client type. Tracing not enabled. Supported: OpenAI, OpenRouter, Anthropic, Bedrock, Gemini"
   );
   return client;
 }
@@ -799,6 +1731,9 @@ function wrapOpenAI(client) {
       if (prop === "chat" && value && typeof value === "object") {
         return wrapOpenAIChat(value);
       }
+      if (prop === "responses" && value && typeof value === "object") {
+        return wrapOpenAIResponses(value);
+      }
       if (prop === "completions" && value && typeof value === "object") {
         return wrapOpenAICompletions(value);
       }
@@ -831,6 +1766,17 @@ function wrapOpenAIChatCompletions(completions) {
     }
   });
 }
+function wrapOpenAIResponses(responses) {
+  return new Proxy(responses, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "create" && typeof value === "function") {
+        return wrapResponsesCreate(value.bind(target));
+      }
+      return value;
+    }
+  });
+}
 function wrapOpenAICompletions(completions) {
   return new Proxy(completions, {
     get(target, prop, receiver) {