@lelemondev/sdk 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -3,7 +3,7 @@ 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);
 
-// src/transport.ts
+// src/core/transport.ts
 var DEFAULT_BATCH_SIZE = 10;
 var DEFAULT_FLUSH_INTERVAL_MS = 1e3;
 var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
@@ -13,8 +13,6 @@ var Transport = class {
     __publicField(this, "queue", []);
     __publicField(this, "flushPromise", null);
     __publicField(this, "flushTimer", null);
-    __publicField(this, "pendingResolvers", /* @__PURE__ */ new Map());
-    __publicField(this, "idCounter", 0);
     this.config = {
       apiKey: config.apiKey,
       endpoint: config.endpoint,
@@ -32,30 +30,21 @@ var Transport = class {
     return !this.config.disabled && !!this.config.apiKey;
   }
   /**
-   * Enqueue trace creation (returns promise that resolves to trace ID)
+   * Enqueue a trace for sending
+   * Fire-and-forget - never blocks
    */
-  enqueueCreate(data) {
-    if (this.config.disabled) {
-      return Promise.resolve(null);
-    }
-    const tempId = this.generateTempId();
-    return new Promise((resolve) => {
-      this.pendingResolvers.set(tempId, resolve);
-      this.enqueue({ type: "create", tempId, data });
-    });
-  }
-  /**
-   * Enqueue trace completion (fire-and-forget)
-   */
-  enqueueComplete(traceId, data) {
-    if (this.config.disabled || !traceId) {
-      return;
+  enqueue(trace) {
+    if (this.config.disabled) return;
+    this.queue.push(trace);
+    if (this.queue.length >= this.config.batchSize) {
+      this.flush();
+    } else {
+      this.scheduleFlush();
     }
-    this.enqueue({ type: "complete", traceId, data });
   }
   /**
-   * Flush all pending items
-   * Safe to call multiple times (deduplicates)
+   * Flush all pending traces
+   * Safe to call multiple times
    */
   async flush() {
     if (this.flushPromise) {
@@ -73,29 +62,16 @@ var Transport = class {
     return this.flushPromise;
   }
   /**
-   * Get pending item count (for testing/debugging)
+   * Get pending count (for debugging)
    */
   getPendingCount() {
     return this.queue.length;
   }
   // ─────────────────────────────────────────────────────────────
-  // Private methods
+  // Private Methods
   // ─────────────────────────────────────────────────────────────
-  generateTempId() {
-    return `temp_${++this.idCounter}_${Date.now()}`;
-  }
-  enqueue(item) {
-    this.queue.push(item);
-    if (this.queue.length >= this.config.batchSize) {
-      this.flush();
-    } else {
-      this.scheduleFlush();
-    }
-  }
   scheduleFlush() {
-    if (this.flushTimer !== null) {
-      return;
-    }
+    if (this.flushTimer !== null) return;
     this.flushTimer = setTimeout(() => {
       this.flushTimer = null;
       this.flush();
@@ -108,53 +84,12 @@ var Transport = class {
     }
   }
   async sendBatch(items) {
-    const payload = {
-      creates: [],
-      completes: []
-    };
-    for (const item of items) {
-      if (item.type === "create") {
-        payload.creates.push({ tempId: item.tempId, data: item.data });
-      } else {
-        payload.completes.push({ traceId: item.traceId, data: item.data });
-      }
-    }
-    if (payload.creates.length === 0 && payload.completes.length === 0) {
-      return;
-    }
-    this.log("Sending batch", {
-      creates: payload.creates.length,
-      completes: payload.completes.length
-    });
+    if (items.length === 0) return;
+    this.log(`Sending batch of ${items.length} traces`);
     try {
-      const response = await this.request(
-        "POST",
-        "/api/v1/traces/batch",
-        payload
-      );
-      if (response.created) {
-        for (const [tempId, realId] of Object.entries(response.created)) {
-          const resolver = this.pendingResolvers.get(tempId);
-          if (resolver) {
-            resolver(realId);
-            this.pendingResolvers.delete(tempId);
-          }
-        }
-      }
-      if (response.errors?.length && this.config.debug) {
-        console.warn("[Lelemon] Batch errors:", response.errors);
-      }
+      await this.request("POST", "/api/v1/traces/batch", { traces: items });
     } catch (error) {
-      for (const item of items) {
-        if (item.type === "create") {
-          const resolver = this.pendingResolvers.get(item.tempId);
-          if (resolver) {
-            resolver(null);
-            this.pendingResolvers.delete(item.tempId);
-          }
-        }
-      }
-      this.log("Batch failed", error);
+      this.log("Batch send failed", error);
     }
   }
   async request(method, path, body) {
@@ -199,487 +134,755 @@ var Transport = class {
   }
 };
 
-// src/parser.ts
-function isOpenAIFormat(messages) {
-  if (!messages.length) return false;
-  const first = messages[0];
-  return typeof first === "object" && first !== null && "role" in first && ["system", "user", "assistant", "tool"].includes(first.role);
-}
-function isAnthropicFormat(messages) {
-  if (!messages.length) return false;
-  const first = messages[0];
-  return typeof first === "object" && first !== null && "role" in first && ["user", "assistant"].includes(first.role) && (typeof first.content === "string" || Array.isArray(first.content));
-}
-function isGeminiFormat(messages) {
-  if (!messages.length) return false;
-  const first = messages[0];
-  return typeof first === "object" && first !== null && "role" in first && ["user", "model"].includes(first.role) && "parts" in first && Array.isArray(first.parts);
-}
-function parseOpenAI(messages) {
-  const result = {
-    llmCalls: [],
-    toolCalls: [],
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    models: [],
-    provider: "openai"
-  };
-  for (const msg of messages) {
-    if (msg.role === "system") {
-      result.systemPrompt = msg.content ?? void 0;
-    } else if (msg.role === "user" && !result.userInput) {
-      result.userInput = msg.content ?? void 0;
-    } else if (msg.role === "assistant") {
-      const llmCall = {
-        provider: "openai",
-        output: msg.content
-      };
-      if (msg.tool_calls && msg.tool_calls.length > 0) {
-        llmCall.toolCalls = msg.tool_calls.map((tc) => ({
-          name: tc.function.name,
-          input: safeParseJSON(tc.function.arguments)
-        }));
-        for (const tc of msg.tool_calls) {
-          result.toolCalls.push({
-            name: tc.function.name,
-            input: safeParseJSON(tc.function.arguments)
-          });
-        }
-      }
-      result.llmCalls.push(llmCall);
-      if (msg.content) {
-        result.output = msg.content;
-      }
-    } else if (msg.role === "tool") {
-      const lastToolCall = result.toolCalls[result.toolCalls.length - 1];
-      if (lastToolCall) {
-        lastToolCall.output = safeParseJSON(msg.content ?? "");
-      }
-    }
+// src/core/config.ts
+var globalConfig = {};
+var globalTransport = null;
+var DEFAULT_ENDPOINT = "https://api.lelemon.dev";
+function init(config = {}) {
+  globalConfig = config;
+  globalTransport = createTransport(config);
+}
+function getConfig() {
+  return globalConfig;
+}
+function isEnabled() {
+  return getTransport().isEnabled();
+}
+function getTransport() {
+  if (!globalTransport) {
+    globalTransport = createTransport(globalConfig);
   }
-  return result;
+  return globalTransport;
 }
-function parseAnthropic(messages) {
-  const result = {
-    llmCalls: [],
-    toolCalls: [],
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    models: [],
-    provider: "anthropic"
-  };
-  for (const msg of messages) {
-    if (msg.role === "user") {
-      if (!result.userInput) {
-        if (typeof msg.content === "string") {
-          result.userInput = msg.content;
-        } else if (Array.isArray(msg.content)) {
-          const textContent = msg.content.find(
-            (c) => c.type === "text"
-          );
-          if (textContent && "text" in textContent) {
-            result.userInput = textContent.text;
-          }
-        }
-      }
-      if (Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === "tool_result" && block.tool_use_id) {
-            const toolCall = result.toolCalls.find(
-              (tc) => tc.id === block.tool_use_id
-            );
-            if (toolCall) {
-              toolCall.output = block.content;
-            }
-          }
-        }
-      }
-    } else if (msg.role === "assistant") {
-      const llmCall = {
-        provider: "anthropic"
-      };
-      if (typeof msg.content === "string") {
-        llmCall.output = msg.content;
-        result.output = msg.content;
-      } else if (Array.isArray(msg.content)) {
-        const outputs = [];
-        const toolCalls = [];
-        for (const block of msg.content) {
-          if (block.type === "text" && block.text) {
-            outputs.push(block.text);
-          } else if (block.type === "tool_use" && block.name) {
-            const tc = {
-              name: block.name,
-              input: block.input
-            };
-            if (block.id) {
-              tc.id = block.id;
-            }
-            toolCalls.push(tc);
-            result.toolCalls.push(tc);
-          }
-        }
-        if (outputs.length) {
-          llmCall.output = outputs.join("\n");
-          result.output = outputs.join("\n");
-        }
-        if (toolCalls.length) {
-          llmCall.toolCalls = toolCalls;
-        }
-      }
-      result.llmCalls.push(llmCall);
-    }
+async function flush() {
+  if (globalTransport) {
+    await globalTransport.flush();
   }
-  return result;
 }
-function parseGemini(messages) {
-  const result = {
-    llmCalls: [],
-    toolCalls: [],
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    models: [],
-    provider: "gemini"
-  };
-  for (const msg of messages) {
-    if (msg.role === "user") {
-      if (!result.userInput) {
-        const textPart = msg.parts.find((p) => p.text);
-        if (textPart?.text) {
-          result.userInput = textPart.text;
-        }
-      }
-      for (const part of msg.parts) {
-        if (part.functionResponse) {
-          const toolCall = result.toolCalls.find(
-            (tc) => tc.name === part.functionResponse.name
-          );
-          if (toolCall) {
-            toolCall.output = part.functionResponse.response;
-          }
-        }
-      }
-    } else if (msg.role === "model") {
-      const llmCall = {
-        provider: "gemini"
-      };
-      const outputs = [];
-      const toolCalls = [];
-      for (const part of msg.parts) {
-        if (part.text) {
-          outputs.push(part.text);
-        } else if (part.functionCall) {
-          const tc = {
-            name: part.functionCall.name,
-            input: part.functionCall.args
-          };
-          toolCalls.push(tc);
-          result.toolCalls.push(tc);
-        }
-      }
-      if (outputs.length) {
-        llmCall.output = outputs.join("\n");
-        result.output = outputs.join("\n");
-      }
-      if (toolCalls.length) {
-        llmCall.toolCalls = toolCalls;
+function createTransport(config) {
+  const apiKey = config.apiKey ?? getEnvVar("LELEMON_API_KEY");
+  if (!apiKey && !config.disabled) {
+    console.warn(
+      "[Lelemon] No API key provided. Set apiKey in init() or LELEMON_API_KEY env var. Tracing disabled."
+    );
+  }
+  return new Transport({
+    apiKey: apiKey ?? "",
+    endpoint: config.endpoint ?? DEFAULT_ENDPOINT,
+    debug: config.debug ?? false,
+    disabled: config.disabled ?? !apiKey,
+    batchSize: config.batchSize,
+    flushIntervalMs: config.flushIntervalMs,
+    requestTimeoutMs: config.requestTimeoutMs
+  });
+}
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  return void 0;
+}
+
+// src/providers/base.ts
+function safeExtract(fn, fallback) {
+  try {
+    return fn() ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+function getNestedValue(obj, path) {
+  try {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current == null || typeof current !== "object") {
+        return void 0;
       }
-      result.llmCalls.push(llmCall);
+      current = current[part];
     }
+    return current;
+  } catch {
+    return void 0;
   }
-  return result;
 }
-function safeParseJSON(str) {
+function isValidNumber(value) {
+  return typeof value === "number" && !isNaN(value) && isFinite(value);
+}
+
+// src/core/capture.ts
+var globalContext = {};
+function setGlobalContext(options) {
+  globalContext = options;
+}
+function getGlobalContext() {
+  return globalContext;
+}
+function captureTrace(params) {
   try {
-    return JSON.parse(str);
+    const transport = getTransport();
+    if (!transport.isEnabled()) return;
+    const context = getGlobalContext();
+    const request = {
+      provider: params.provider,
+      model: params.model,
+      input: sanitizeInput(params.input),
+      output: sanitizeOutput(params.output),
+      inputTokens: params.inputTokens,
+      outputTokens: params.outputTokens,
+      durationMs: params.durationMs,
+      status: params.status,
+      streaming: params.streaming,
+      sessionId: context.sessionId,
+      userId: context.userId,
+      metadata: { ...context.metadata, ...params.metadata },
+      tags: context.tags
+    };
+    transport.enqueue(request);
   } catch {
-    return str;
   }
 }
-function parseMessages(messages) {
-  if (!messages) {
-    return {
-      llmCalls: [],
-      toolCalls: [],
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      models: [],
-      provider: "unknown"
+function captureError(params) {
+  try {
+    const transport = getTransport();
+    if (!transport.isEnabled()) return;
+    const context = getGlobalContext();
+    const request = {
+      provider: params.provider,
+      model: params.model,
+      input: sanitizeInput(params.input),
+      output: null,
+      inputTokens: 0,
+      outputTokens: 0,
+      durationMs: params.durationMs,
+      status: "error",
+      errorMessage: params.error.message,
+      errorStack: params.error.stack,
+      streaming: params.streaming,
+      sessionId: context.sessionId,
+      userId: context.userId,
+      metadata: { ...context.metadata, ...params.metadata },
+      tags: context.tags
     };
+    transport.enqueue(request);
+  } catch {
   }
-  if (!Array.isArray(messages)) {
-    return {
-      llmCalls: [],
-      toolCalls: [],
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      models: [],
-      provider: "unknown",
-      output: typeof messages === "string" ? messages : JSON.stringify(messages)
-    };
+}
+var MAX_STRING_LENGTH = 1e5;
+var SENSITIVE_KEYS = ["api_key", "apikey", "password", "secret", "token", "authorization"];
+function sanitizeInput(input) {
+  return sanitize(input, 0);
+}
+function sanitizeOutput(output) {
+  return sanitize(output, 0);
+}
+function sanitize(value, depth) {
+  if (depth > 10) return "[max depth exceeded]";
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") {
+    return value.length > MAX_STRING_LENGTH ? value.slice(0, MAX_STRING_LENGTH) + "...[truncated]" : value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitize(item, depth + 1));
+  }
+  if (typeof value === "object") {
+    const sanitized = {};
+    for (const [key, val] of Object.entries(value)) {
+      if (SENSITIVE_KEYS.some((k) => key.toLowerCase().includes(k))) {
+        sanitized[key] = "[REDACTED]";
+      } else {
+        sanitized[key] = sanitize(val, depth + 1);
+      }
+    }
+    return sanitized;
   }
-  if (isGeminiFormat(messages)) {
-    return parseGemini(messages);
-  } else if (isOpenAIFormat(messages)) {
-    return parseOpenAI(messages);
-  } else if (isAnthropicFormat(messages)) {
-    return parseAnthropic(messages);
-  }
-  return {
-    llmCalls: [],
-    toolCalls: [],
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    models: [],
-    provider: "unknown"
+  return String(value);
+}
+
+// src/providers/openai.ts
+var PROVIDER_NAME = "openai";
+function canHandle(client) {
+  if (!client || typeof client !== "object") return false;
+  const constructorName = client.constructor?.name;
+  if (constructorName === "OpenAI") return true;
+  const c = client;
+  return !!(c.chat && c.completions);
+}
+function wrapChatCreate(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 && isAsyncIterable(response)) {
+        return wrapStream(response, request, startTime);
+      }
+      const durationMs = Date.now() - startTime;
+      const extracted = extractChatCompletion(response);
+      captureTrace({
+        provider: PROVIDER_NAME,
+        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
+      });
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      captureError({
+        provider: PROVIDER_NAME,
+        model: request.model || "unknown",
+        input: request.messages,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs,
+        streaming: isStreaming
+      });
+      throw error;
+    }
   };
 }
-function parseResponse(response) {
-  if (!response || typeof response !== "object") {
-    return {};
-  }
-  const res = response;
-  const result = {};
-  if ("model" in res) {
-    result.model = res.model;
-  }
-  if ("modelId" in res) {
-    result.model = res.modelId;
-  }
-  if ("usage" in res && typeof res.usage === "object" && res.usage !== null) {
-    const usage = res.usage;
-    result.inputTokens = usage.prompt_tokens ?? usage.input_tokens;
-    result.outputTokens = usage.completion_tokens ?? usage.output_tokens;
-  }
-  if ("$metadata" in res && "usage" in res) {
-    result.provider = "bedrock";
-  }
-  if ("anthropic_version" in res || "amazon-bedrock-invocationMetrics" in res) {
-    result.provider = "bedrock";
-  }
-  if ("candidates" in res || "promptFeedback" in res) {
-    result.provider = "gemini";
-    if ("usageMetadata" in res && typeof res.usageMetadata === "object" && res.usageMetadata !== null) {
-      const usage = res.usageMetadata;
-      result.inputTokens = usage.promptTokenCount;
-      result.outputTokens = usage.candidatesTokenCount;
+function wrapCompletionCreate(originalFn) {
+  return async function wrappedCompletionCreate(...args) {
+    const startTime = Date.now();
+    const request = args[0] || {};
+    try {
+      const response = await originalFn(...args);
+      const durationMs = Date.now() - startTime;
+      const extracted = extractLegacyCompletion(response);
+      captureTrace({
+        provider: PROVIDER_NAME,
+        model: request.model || extracted.model || "unknown",
+        input: request.prompt,
+        output: extracted.output,
+        inputTokens: extracted.tokens?.inputTokens || 0,
+        outputTokens: extracted.tokens?.outputTokens || 0,
+        durationMs,
+        status: "success",
+        streaming: false
+      });
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      captureError({
+        provider: PROVIDER_NAME,
+        model: request.model || "unknown",
+        input: request.prompt,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs,
+        streaming: false
+      });
+      throw error;
+    }
+  };
+}
+function wrapEmbeddingsCreate(originalFn) {
+  return async function wrappedEmbeddingsCreate(...args) {
+    const startTime = Date.now();
+    const request = args[0] || {};
+    try {
+      const response = await originalFn(...args);
+      const durationMs = Date.now() - startTime;
+      const tokens = extractEmbeddingTokens(response);
+      captureTrace({
+        provider: PROVIDER_NAME,
+        model: request.model || "unknown",
+        input: request.input,
+        output: "[embedding vectors]",
+        inputTokens: tokens?.inputTokens || 0,
+        outputTokens: 0,
+        durationMs,
+        status: "success",
+        streaming: false
+      });
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      captureError({
+        provider: PROVIDER_NAME,
+        model: request.model || "unknown",
+        input: request.input,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs,
+        streaming: false
+      });
+      throw error;
+    }
+  };
+}
+function isAsyncIterable(value) {
+  return value != null && typeof value[Symbol.asyncIterator] === "function";
+}
+async function* wrapStream(stream, request, startTime) {
+  const chunks = [];
+  let tokens = null;
+  let error = null;
+  try {
+    for await (const chunk of stream) {
+      const content = extractStreamChunkContent(chunk);
+      if (content) {
+        chunks.push(content);
+      }
+      const chunkTokens = extractStreamChunkTokens(chunk);
+      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("");
+    if (error) {
+      captureError({
+        provider: PROVIDER_NAME,
+        model: request.model || "unknown",
+        input: request.messages,
+        error,
+        durationMs,
+        streaming: true
+      });
+    } else {
+      captureTrace({
+        provider: PROVIDER_NAME,
+        model: request.model || "unknown",
+        input: request.messages,
+        output,
+        inputTokens: tokens?.inputTokens || 0,
+        outputTokens: tokens?.outputTokens || 0,
+        durationMs,
+        status: "success",
+        streaming: true
+      });
     }
   }
-  if (result.model && !result.provider) {
-    if (result.model.startsWith("gpt") || result.model.startsWith("o1")) {
-      result.provider = "openai";
-    } else if (result.model.startsWith("claude")) {
-      result.provider = "anthropic";
-    } else if (result.model.startsWith("gemini")) {
-      result.provider = "gemini";
-    } else if (result.model.startsWith("anthropic.") || result.model.startsWith("amazon.") || result.model.startsWith("meta.") || result.model.startsWith("cohere.") || result.model.startsWith("mistral.") || result.model.includes(":")) {
-      result.provider = "bedrock";
+}
+function extractChatCompletion(response) {
+  const model = safeExtract(() => getNestedValue(response, "model"), null);
+  const output = safeExtract(
+    () => getNestedValue(response, "choices.0.message.content"),
+    null
+  );
+  const tokens = extractTokens(response);
+  return { model, output, tokens };
+}
+function extractLegacyCompletion(response) {
+  const model = safeExtract(() => getNestedValue(response, "model"), null);
+  const output = safeExtract(
+    () => getNestedValue(response, "choices.0.text"),
+    null
+  );
+  const tokens = extractTokens(response);
+  return { model, output, tokens };
+}
+function extractTokens(response) {
+  try {
+    const usage = getNestedValue(response, "usage");
+    if (!usage || typeof usage !== "object") return null;
+    const u = usage;
+    const promptTokens = u.prompt_tokens;
+    const completionTokens = u.completion_tokens;
+    const totalTokens = u.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
+    };
+  } catch {
+    return null;
   }
-  return result;
 }
-function parseBedrockResponse(body) {
-  if (!body || typeof body !== "object") {
-    return {};
+function extractEmbeddingTokens(response) {
+  try {
+    const usage = getNestedValue(response, "usage");
+    if (!usage || typeof usage !== "object") return null;
+    const u = usage;
+    const promptTokens = u.prompt_tokens;
+    const totalTokens = u.total_tokens;
+    return {
+      inputTokens: isValidNumber(promptTokens) ? promptTokens : 0,
+      outputTokens: 0,
+      totalTokens: isValidNumber(totalTokens) ? totalTokens : 0
+    };
+  } catch {
+    return null;
   }
-  const res = body;
-  const result = { provider: "bedrock" };
-  if ("usage" in res && typeof res.usage === "object" && res.usage !== null) {
-    const usage = res.usage;
-    result.inputTokens = usage.input_tokens;
-    result.outputTokens = usage.output_tokens;
+}
+function extractStreamChunkContent(chunk) {
+  try {
+    return chunk?.choices?.[0]?.delta?.content ?? null;
+  } catch {
+    return null;
   }
-  if ("amazon-bedrock-invocationMetrics" in res) {
-    const metrics = res["amazon-bedrock-invocationMetrics"];
-    if (metrics.inputTokenCount) result.inputTokens = metrics.inputTokenCount;
-    if (metrics.outputTokenCount) result.outputTokens = metrics.outputTokenCount;
+}
+function extractStreamChunkTokens(chunk) {
+  try {
+    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
+    };
+  } catch {
+    return null;
   }
-  return result;
 }
 
-// src/tracer.ts
-var DEFAULT_ENDPOINT = "https://api.lelemon.dev";
-var globalConfig = {};
-var globalTransport = null;
-function init(config = {}) {
-  globalConfig = config;
-  globalTransport = createTransport(config);
+// src/providers/anthropic.ts
+var PROVIDER_NAME2 = "anthropic";
+function canHandle2(client) {
+  if (!client || typeof client !== "object") return false;
+  const constructorName = client.constructor?.name;
+  if (constructorName === "Anthropic") return true;
+  const c = client;
+  return !!(c.messages && typeof c.messages === "object");
 }
-function trace(options) {
-  const transport = getTransport();
-  const debug = globalConfig.debug ?? false;
-  const disabled = globalConfig.disabled ?? !transport.isEnabled();
-  return new Trace(options, transport, debug, disabled);
+function wrapMessagesCreate(originalFn) {
+  return async function wrappedMessagesCreate(...args) {
+    const startTime = Date.now();
+    const request = args[0] || {};
+    const isStreaming = request.stream === true;
+    try {
+      const response = await originalFn(...args);
+      if (isStreaming && isAsyncIterable2(response)) {
+        return wrapStream2(response, request, startTime);
+      }
+      const durationMs = Date.now() - startTime;
+      const extracted = extractMessageResponse(response);
+      captureTrace({
+        provider: PROVIDER_NAME2,
+        model: request.model || extracted.model || "unknown",
+        input: { system: request.system, messages: request.messages },
+        output: extracted.output,
+        inputTokens: extracted.tokens?.inputTokens || 0,
+        outputTokens: extracted.tokens?.outputTokens || 0,
+        durationMs,
+        status: "success",
+        streaming: false
+      });
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      captureError({
+        provider: PROVIDER_NAME2,
+        model: request.model || "unknown",
+        input: { system: request.system, messages: request.messages },
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs,
+        streaming: isStreaming
+      });
+      throw error;
+    }
+  };
 }
-async function flush() {
-  if (globalTransport) {
-    await globalTransport.flush();
-  }
+function wrapMessagesStream(originalFn) {
+  return function wrappedMessagesStream(...args) {
+    const startTime = Date.now();
+    const request = args[0] || {};
+    try {
+      const stream = originalFn(...args);
+      if (stream && typeof stream === "object") {
+        return wrapAnthropicStream(stream, request, startTime);
+      }
+      return stream;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      captureError({
+        provider: PROVIDER_NAME2,
+        model: request.model || "unknown",
+        input: { system: request.system, messages: request.messages },
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs,
+        streaming: true
+      });
+      throw error;
+    }
+  };
 }
-function isEnabled() {
-  return getTransport().isEnabled();
+function isAsyncIterable2(value) {
+  return value != null && typeof value[Symbol.asyncIterator] === "function";
 }
-var Trace = class {
-  constructor(options, transport, debug, disabled) {
-    __publicField(this, "id", null);
-    __publicField(this, "idPromise");
-    __publicField(this, "transport");
-    __publicField(this, "startTime");
-    __publicField(this, "debug");
-    __publicField(this, "disabled");
-    __publicField(this, "completed", false);
-    __publicField(this, "llmCalls", []);
-    this.transport = transport;
-    this.startTime = Date.now();
-    this.debug = debug;
-    this.disabled = disabled;
-    if (disabled) {
-      this.idPromise = Promise.resolve(null);
-    } else {
-      this.idPromise = transport.enqueueCreate({
-        name: options.name,
-        sessionId: options.sessionId,
-        userId: options.userId,
-        input: options.input,
-        metadata: options.metadata,
-        tags: options.tags
-      });
-      this.idPromise.then((id) => {
-        this.id = id;
-      });
+function wrapAnthropicStream(stream, request, startTime) {
+  const originalStream = stream;
+  if (!originalStream[Symbol.asyncIterator]) {
+    return stream;
+  }
+  const chunks = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let model = request.model || "unknown";
+  let captured = false;
+  const wrappedIterator = async function* () {
+    try {
+      for await (const event of originalStream) {
+        if (event.type === "message_start" && event.message) {
+          model = event.message.model || model;
+          if (event.message.usage) {
+            inputTokens = event.message.usage.input_tokens || 0;
+          }
+        }
+        if (event.type === "content_block_delta" && event.delta?.text) {
+          chunks.push(event.delta.text);
+        }
+        if (event.type === "message_delta" && event.usage) {
+          outputTokens = event.usage.output_tokens || 0;
+        }
+        yield event;
+      }
+    } catch (error) {
+      if (!captured) {
+        captured = true;
+        const durationMs = Date.now() - startTime;
+        captureError({
+          provider: PROVIDER_NAME2,
+          model,
+          input: { system: request.system, messages: request.messages },
+          error: error instanceof Error ? error : new Error(String(error)),
+          durationMs,
+          streaming: true
+        });
+      }
+      throw error;
+    } finally {
+      if (!captured) {
+        captured = true;
+        const durationMs = Date.now() - startTime;
+        captureTrace({
+          provider: PROVIDER_NAME2,
+          model,
+          input: { system: request.system, messages: request.messages },
+          output: chunks.join(""),
+          inputTokens,
+          outputTokens,
+          durationMs,
+          status: "success",
+          streaming: true
+        });
+      }
     }
-  }
-  /**
-   * Log an LLM response for token tracking
-   * Optional - use if you want per-call token counts
-   */
-  log(response) {
-    if (this.disabled || this.completed) return this;
-    const parsed = parseResponse(response);
-    if (parsed.model || parsed.inputTokens || parsed.outputTokens) {
-      this.llmCalls.push(parsed);
+  };
+  return new Proxy(stream, {
+    get(target, prop, receiver) {
+      if (prop === Symbol.asyncIterator) {
+        return () => wrappedIterator()[Symbol.asyncIterator]();
+      }
+      return Reflect.get(target, prop, receiver);
     }
-    return this;
-  }
-  /**
-   * Complete trace successfully (fire-and-forget)
-   *
-   * @param messages - Full message history (OpenAI/Anthropic format)
-   */
-  success(messages) {
-    if (this.completed || this.disabled) return;
-    this.completed = true;
-    const durationMs = Date.now() - this.startTime;
-    const parsed = parseMessages(messages);
-    const allLLMCalls = [...this.llmCalls, ...parsed.llmCalls];
-    const { totalInputTokens, totalOutputTokens, models } = this.aggregateCalls(allLLMCalls);
-    this.idPromise.then((id) => {
-      if (!id) return;
-      this.transport.enqueueComplete(id, {
-        status: "completed",
-        output: parsed.output,
-        systemPrompt: parsed.systemPrompt,
-        llmCalls: allLLMCalls,
-        toolCalls: parsed.toolCalls,
-        models,
-        totalInputTokens,
-        totalOutputTokens,
-        durationMs
+  });
+}
+async function* wrapStream2(stream, request, startTime) {
+  const chunks = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let model = request.model || "unknown";
+  let error = null;
+  try {
+    for await (const event of stream) {
+      if (event.type === "message_start" && event.message) {
+        model = event.message.model || model;
+        if (event.message.usage) {
+          inputTokens = event.message.usage.input_tokens || 0;
+        }
+      }
+      if (event.type === "content_block_delta" && event.delta?.text) {
+        chunks.push(event.delta.text);
+      }
+      if (event.type === "message_delta" && event.usage) {
+        outputTokens = event.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_NAME2,
+        model,
+        input: { system: request.system, messages: request.messages },
+        error,
+        durationMs,
+        streaming: true
       });
-    });
-  }
-  /**
-   * Complete trace with error (fire-and-forget)
-   *
-   * @param error - The error that occurred
-   * @param messages - Optional message history up to failure
-   */
-  error(error, messages) {
-    if (this.completed || this.disabled) return;
-    this.completed = true;
-    const durationMs = Date.now() - this.startTime;
-    const parsed = messages ? parseMessages(messages) : null;
-    const errorObj = error instanceof Error ? error : new Error(String(error));
-    const allLLMCalls = parsed ? [...this.llmCalls, ...parsed.llmCalls] : this.llmCalls;
-    const { totalInputTokens, totalOutputTokens, models } = this.aggregateCalls(allLLMCalls);
-    this.idPromise.then((id) => {
-      if (!id) return;
-      this.transport.enqueueComplete(id, {
-        status: "error",
-        errorMessage: errorObj.message,
-        errorStack: errorObj.stack,
-        output: parsed?.output,
-        systemPrompt: parsed?.systemPrompt,
-        llmCalls: allLLMCalls.length > 0 ? allLLMCalls : void 0,
-        toolCalls: parsed?.toolCalls,
-        models: models.length > 0 ? models : void 0,
-        totalInputTokens,
-        totalOutputTokens,
-        durationMs
+    } else {
+      captureTrace({
+        provider: PROVIDER_NAME2,
+        model,
+        input: { system: request.system, messages: request.messages },
+        output: chunks.join(""),
+        inputTokens,
+        outputTokens,
+        durationMs,
+        status: "success",
+        streaming: true
       });
-    });
-  }
-  /**
-   * Get the trace ID (may be null if not yet created or failed)
-   */
-  getId() {
-    return this.id;
-  }
-  /**
-   * Wait for trace ID to be available
-   */
-  async waitForId() {
-    return this.idPromise;
+    }
   }
-  // ─────────────────────────────────────────────────────────────
-  // Private methods
-  // ─────────────────────────────────────────────────────────────
-  aggregateCalls(calls) {
-    let totalInputTokens = 0;
-    let totalOutputTokens = 0;
-    const modelSet = /* @__PURE__ */ new Set();
-    for (const call of calls) {
-      if (call.inputTokens) totalInputTokens += call.inputTokens;
-      if (call.outputTokens) totalOutputTokens += call.outputTokens;
-      if (call.model) modelSet.add(call.model);
+}
+function extractMessageResponse(response) {
+  const model = safeExtract(() => response.model ?? null, null);
+  const output = safeExtract(() => {
+    if (!response.content || !Array.isArray(response.content)) return null;
+    const textBlocks = response.content.filter((block) => block.type === "text" && block.text).map((block) => block.text);
+    return textBlocks.join("") || null;
+  }, null);
+  const tokens = extractTokens2(response);
+  return { model, output, tokens };
+}
+function extractTokens2(response) {
+  try {
+    const usage = response.usage;
+    if (!usage) return null;
+    const inputTokens = usage.input_tokens;
+    const outputTokens = usage.output_tokens;
+    if (!isValidNumber(inputTokens) && !isValidNumber(outputTokens)) {
+      return null;
     }
     return {
-      totalInputTokens,
-      totalOutputTokens,
-      models: Array.from(modelSet)
+      inputTokens: isValidNumber(inputTokens) ? inputTokens : 0,
+      outputTokens: isValidNumber(outputTokens) ? outputTokens : 0,
+      totalTokens: (isValidNumber(inputTokens) ? inputTokens : 0) + (isValidNumber(outputTokens) ? outputTokens : 0)
     };
+  } catch {
+    return null;
   }
-};
-function getTransport() {
-  if (!globalTransport) {
-    globalTransport = createTransport(globalConfig);
-  }
-  return globalTransport;
 }
-function createTransport(config) {
-  const apiKey = config.apiKey ?? getEnvVar("LELEMON_API_KEY");
-  if (!apiKey && !config.disabled) {
-    console.warn(
-      "[Lelemon] No API key provided. Set apiKey in config or LELEMON_API_KEY env var. Tracing disabled."
-    );
+
+// src/observe.ts
+function observe(client, options) {
+  if (options) {
+    setGlobalContext(options);
+  }
+  const config = getConfig();
+  if (config.disabled) {
+    return client;
+  }
+  if (canHandle(client)) {
+    if (config.debug) {
+      console.log("[Lelemon] Wrapping OpenAI client");
+    }
+    return wrapOpenAI(client);
   }
-  return new Transport({
-    apiKey: apiKey ?? "",
-    endpoint: config.endpoint ?? DEFAULT_ENDPOINT,
-    debug: config.debug ?? false,
-    disabled: config.disabled ?? !apiKey,
-    batchSize: config.batchSize,
-    flushIntervalMs: config.flushIntervalMs,
-    requestTimeoutMs: config.requestTimeoutMs
+  if (canHandle2(client)) {
+    if (config.debug) {
+      console.log("[Lelemon] Wrapping Anthropic client");
+    }
+    return wrapAnthropic(client);
+  }
+  console.warn(
+    "[Lelemon] Unknown client type. Tracing not enabled. Supported: OpenAI, Anthropic"
+  );
+  return client;
+}
+function wrapOpenAI(client) {
+  const typed = client;
+  return new Proxy(typed, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "chat" && value && typeof value === "object") {
+        return wrapOpenAIChat(value);
+      }
+      if (prop === "completions" && value && typeof value === "object") {
+        return wrapOpenAICompletions(value);
+      }
+      if (prop === "embeddings" && value && typeof value === "object") {
+        return wrapOpenAIEmbeddings(value);
+      }
+      return value;
+    }
   });
 }
-function getEnvVar(name) {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env[name];
-  }
-  return void 0;
+function wrapOpenAIChat(chat) {
+  return new Proxy(chat, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "completions" && value && typeof value === "object") {
+        return wrapOpenAIChatCompletions(value);
+      }
+      return value;
+    }
+  });
+}
+function wrapOpenAIChatCompletions(completions) {
+  return new Proxy(completions, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "create" && typeof value === "function") {
+        return wrapChatCreate(value.bind(target));
+      }
+      return value;
+    }
+  });
+}
+function wrapOpenAICompletions(completions) {
+  return new Proxy(completions, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "create" && typeof value === "function") {
+        return wrapCompletionCreate(value.bind(target));
+      }
+      return value;
+    }
+  });
+}
+function wrapOpenAIEmbeddings(embeddings) {
+  return new Proxy(embeddings, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "create" && typeof value === "function") {
+        return wrapEmbeddingsCreate(value.bind(target));
+      }
+      return value;
+    }
+  });
+}
+function wrapAnthropic(client) {
+  const typed = client;
+  return new Proxy(typed, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "messages" && value && typeof value === "object") {
+        return wrapAnthropicMessages(value);
+      }
+      return value;
+    }
+  });
+}
+function wrapAnthropicMessages(messages) {
+  return new Proxy(messages, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "create" && typeof value === "function") {
+        return wrapMessagesCreate(value.bind(target));
+      }
+      if (prop === "stream" && typeof value === "function") {
+        return wrapMessagesStream(value.bind(target));
+      }
+      return value;
+    }
+  });
+}
+function createObserve(defaultOptions) {
+  return function scopedObserve(client, options) {
+    return observe(client, { ...defaultOptions, ...options });
+  };
 }
 
-export { Trace, flush, init, isEnabled, parseBedrockResponse, parseMessages, parseResponse, trace };
+export { createObserve, flush, init, isEnabled, observe };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map