@lelemondev/sdk 0.1.0 → 0.2.0

package/dist/index.js

@@ -6,10 +6,26 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/transport.ts
+var DEFAULT_BATCH_SIZE = 10;
+var DEFAULT_FLUSH_INTERVAL_MS = 1e3;
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
 var Transport = class {
   constructor(config) {
     __publicField(this, "config");
-    this.config = config;
+    __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,
+      debug: config.debug,
+      disabled: config.disabled,
+      batchSize: config.batchSize ?? DEFAULT_BATCH_SIZE,
+      flushIntervalMs: config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
+      requestTimeoutMs: config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS
+    };
   }
   /**
    * Check if transport is enabled
@@ -18,53 +34,171 @@ var Transport = class {
     return !this.config.disabled && !!this.config.apiKey;
   }
   /**
-   * Create a new trace
+   * Enqueue trace creation (returns promise that resolves to trace ID)
    */
-  async createTrace(data) {
-    return this.request("POST", "/api/v1/traces", data);
+  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 });
+    });
   }
   /**
-   * Complete a trace (success or error)
+   * Enqueue trace completion (fire-and-forget)
    */
-  async completeTrace(traceId, data) {
-    await this.request("PATCH", `/api/v1/traces/${traceId}`, data);
+  enqueueComplete(traceId, data) {
+    if (this.config.disabled || !traceId) {
+      return;
+    }
+    this.enqueue({ type: "complete", traceId, data });
   }
   /**
-   * Make HTTP request to API
+   * Flush all pending items
+   * Safe to call multiple times (deduplicates)
    */
-  async request(method, path, body) {
-    if (this.config.disabled) {
-      return {};
+  async flush() {
+    if (this.flushPromise) {
+      return this.flushPromise;
     }
-    const url = `${this.config.endpoint}${path}`;
-    if (this.config.debug) {
-      console.log(`[Lelemon] ${method} ${url}`, body);
+    if (this.queue.length === 0) {
+      return;
+    }
+    this.cancelScheduledFlush();
+    const items = this.queue;
+    this.queue = [];
+    this.flushPromise = this.sendBatch(items).finally(() => {
+      this.flushPromise = null;
+    });
+    return this.flushPromise;
+  }
+  /**
+   * Get pending item count (for testing/debugging)
+   */
+  getPendingCount() {
+    return this.queue.length;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // 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;
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.flush();
+    }, this.config.flushIntervalMs);
+  }
+  cancelScheduledFlush() {
+    if (this.flushTimer !== null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  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
+    });
+    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);
+      }
+    } 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);
     }
+  }
+  async request(method, path, body) {
+    const url = `${this.config.endpoint}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+    }, this.config.requestTimeoutMs);
     try {
       const response = await fetch(url, {
         method,
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${this.config.apiKey}`
+          "Authorization": `Bearer ${this.config.apiKey}`
         },
-        body: body ? JSON.stringify(body) : void 0
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
       });
+      clearTimeout(timeoutId);
       if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`Lelemon API error: ${response.status} ${error}`);
+        const errorText = await response.text().catch(() => "Unknown error");
+        throw new Error(`HTTP ${response.status}: ${errorText}`);
       }
       const text = await response.text();
-      if (!text) {
-        return {};
-      }
-      return JSON.parse(text);
+      return text ? JSON.parse(text) : {};
     } catch (error) {
-      if (this.config.debug) {
-        console.error("[Lelemon] Request failed:", error);
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.config.requestTimeoutMs}ms`);
       }
       throw error;
     }
   }
+  log(message, data) {
+    if (this.config.debug) {
+      if (data !== void 0) {
+        console.log(`[Lelemon] ${message}`, data);
+      } else {
+        console.log(`[Lelemon] ${message}`);
+      }
+    }
+  }
 };
 
 // src/parser.ts
@@ -373,176 +507,185 @@ function init(config = {}) {
   globalConfig = config;
   globalTransport = createTransport(config);
 }
-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."
-    );
-  }
-  return new Transport({
-    apiKey: apiKey ?? "",
-    endpoint: config.endpoint ?? DEFAULT_ENDPOINT,
-    debug: config.debug ?? false,
-    disabled: config.disabled ?? !apiKey
-  });
+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 getTransport() {
-  if (!globalTransport) {
-    globalTransport = createTransport(globalConfig);
+async function flush() {
+  if (globalTransport) {
+    await globalTransport.flush();
   }
-  return globalTransport;
 }
-function getEnvVar(name) {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env[name];
-  }
-  return void 0;
+function isEnabled() {
+  return getTransport().isEnabled();
 }
 var Trace = class {
   constructor(options, transport, debug, disabled) {
     __publicField(this, "id", null);
+    __publicField(this, "idPromise");
     __publicField(this, "transport");
-    __publicField(this, "options");
     __publicField(this, "startTime");
-    __publicField(this, "completed", false);
     __publicField(this, "debug");
     __publicField(this, "disabled");
+    __publicField(this, "completed", false);
     __publicField(this, "llmCalls", []);
-    this.options = options;
     this.transport = transport;
     this.startTime = Date.now();
     this.debug = debug;
     this.disabled = disabled;
-  }
-  /**
-   * Initialize trace on server (called internally)
-   */
-  async init() {
-    if (this.disabled) return;
-    try {
-      const result = await this.transport.createTrace({
-        name: this.options.name,
-        sessionId: this.options.sessionId,
-        userId: this.options.userId,
-        input: this.options.input,
-        metadata: this.options.metadata,
-        tags: this.options.tags
+    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;
       });
-      this.id = result.id;
-    } catch (error) {
-      if (this.debug) {
-        console.error("[Lelemon] Failed to create trace:", error);
-      }
     }
   }
   /**
-   * Log an LLM response (optional - for tracking individual calls)
-   * Use this if you want to track tokens per call, not just at the end
+   * 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 this;
   }
   /**
-   * Complete trace successfully
-   * @param messages - The full message history (OpenAI/Anthropic format)
+   * Complete trace successfully (fire-and-forget)
+   *
+   * @param messages - Full message history (OpenAI/Anthropic format)
    */
-  async success(messages) {
-    if (this.completed) return;
+  success(messages) {
+    if (this.completed || this.disabled) return;
     this.completed = true;
-    if (this.disabled || !this.id) return;
     const durationMs = Date.now() - this.startTime;
     const parsed = parseMessages(messages);
     const allLLMCalls = [...this.llmCalls, ...parsed.llmCalls];
-    let totalInputTokens = 0;
-    let totalOutputTokens = 0;
-    const models = /* @__PURE__ */ new Set();
-    for (const call of allLLMCalls) {
-      if (call.inputTokens) totalInputTokens += call.inputTokens;
-      if (call.outputTokens) totalOutputTokens += call.outputTokens;
-      if (call.model) models.add(call.model);
-    }
-    try {
-      await this.transport.completeTrace(this.id, {
+    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: Array.from(models),
+        models,
         totalInputTokens,
         totalOutputTokens,
         durationMs
       });
-    } catch (err) {
-      if (this.debug) {
-        console.error("[Lelemon] Failed to complete trace:", err);
-      }
-    }
+    });
   }
   /**
-   * Complete trace with error
+   * Complete trace with error (fire-and-forget)
+   *
    * @param error - The error that occurred
-   * @param messages - The message history up to the failure (optional)
+   * @param messages - Optional message history up to failure
    */
-  async error(error, messages) {
-    if (this.completed) return;
+  error(error, messages) {
+    if (this.completed || this.disabled) return;
     this.completed = true;
-    if (this.disabled || !this.id) return;
     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
+      });
+    });
+  }
+  /**
+   * 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 models = /* @__PURE__ */ new Set();
-    for (const call of allLLMCalls) {
+    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) models.add(call.model);
+      if (call.model) modelSet.add(call.model);
     }
-    const request = {
-      status: "error",
-      errorMessage: errorObj.message,
-      errorStack: errorObj.stack,
-      durationMs,
+    return {
       totalInputTokens,
       totalOutputTokens,
-      models: Array.from(models)
+      models: Array.from(modelSet)
     };
-    if (parsed) {
-      request.output = parsed.output;
-      request.systemPrompt = parsed.systemPrompt;
-      request.llmCalls = allLLMCalls;
-      request.toolCalls = parsed.toolCalls;
-    }
-    try {
-      await this.transport.completeTrace(this.id, request);
-    } catch (err) {
-      if (this.debug) {
-        console.error("[Lelemon] Failed to complete trace:", err);
-      }
-    }
   }
 };
-function trace(options) {
-  const transport = getTransport();
-  const debug = globalConfig.debug ?? false;
-  const disabled = globalConfig.disabled ?? !transport.isEnabled();
-  const t = new Trace(options, transport, debug, disabled);
-  t.init().catch((err) => {
-    if (debug) {
-      console.error("[Lelemon] Trace init failed:", err);
-    }
+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."
+    );
+  }
+  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
   });
-  return t;
+}
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  return void 0;
 }
 
 exports.Trace = Trace;
+exports.flush = flush;
 exports.init = init;
+exports.isEnabled = isEnabled;
 exports.parseBedrockResponse = parseBedrockResponse;
 exports.parseMessages = parseMessages;
 exports.parseResponse = parseResponse;