@lelemondev/sdk 0.3.0 → 0.4.0

package/README.md

@@ -4,16 +4,15 @@
 [![CI](https://github.com/lelemondev/lelemondev-sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/lelemondev/lelemondev-sdk/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Automatic LLM observability for Node.js. Track your AI agents with zero code changes.
+Automatic LLM observability for Node.js. Wrap your client, everything is traced.
 
 ## Features
 
-- **Automatic Tracing** - Wrap your client, everything is traced
-- **Fire-and-forget** - Never blocks your code
-- **Auto-batching** - Efficient network usage
+- **Automatic Tracing** - Wrap your client, all calls are traced
+- **Zero Config** - Works out of the box
+- **Framework Integrations** - Next.js, Express, Lambda, Hono
 - **Streaming Support** - Full support for streaming responses
 - **Type-safe** - Preserves your client's TypeScript types
-- **Serverless-ready** - Built-in flush for Lambda/Vercel
 
 ## Installation
 
@@ -24,26 +23,120 @@ npm install @lelemondev/sdk
 ## Quick Start
 
 ```typescript
-import { init, observe, flush } from '@lelemondev/sdk';
+import { init, observe } from '@lelemondev/sdk';
 import OpenAI from 'openai';
 
-// 1. Initialize once at app startup
+// 1. Initialize once
 init({ apiKey: process.env.LELEMON_API_KEY });
 
 // 2. Wrap your client
 const openai = observe(new OpenAI());
 
-// 3. Use normally - all calls are traced automatically
+// 3. Use normally - all calls traced automatically
 const response = await openai.chat.completions.create({
   model: 'gpt-4',
   messages: [{ role: 'user', content: 'Hello!' }],
 });
+```
 
-// 4. For serverless: flush before response
-await flush();
+## Framework Integrations
+
+### Next.js App Router
+
+```typescript
+// app/api/chat/route.ts
+import { init, observe } from '@lelemondev/sdk';
+import { withObserve } from '@lelemondev/sdk/next';
+import { after } from 'next/server';
+import OpenAI from 'openai';
+
+init({ apiKey: process.env.LELEMON_API_KEY });
+const openai = observe(new OpenAI());
+
+export const POST = withObserve(
+  async (req) => {
+    const { message } = await req.json();
+    const result = await openai.chat.completions.create({
+      model: 'gpt-4',
+      messages: [{ role: 'user', content: message }],
+    });
+    return Response.json(result.choices[0].message);
+  },
+  { after } // Non-blocking flush (Next.js 15+)
+);
+```
+
+### Express
+
+```typescript
+import express from 'express';
+import { init, observe } from '@lelemondev/sdk';
+import { createMiddleware } from '@lelemondev/sdk/express';
+import OpenAI from 'openai';
+
+init({ apiKey: process.env.LELEMON_API_KEY });
+const openai = observe(new OpenAI());
+
+const app = express();
+app.use(createMiddleware()); // Auto-flush on response finish
+
+app.post('/chat', async (req, res) => {
+  const result = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: [{ role: 'user', content: req.body.message }],
+  });
+  res.json(result.choices[0].message);
+});
+```
+
+### AWS Lambda
+
+```typescript
+import { init, observe } from '@lelemondev/sdk';
+import { withObserve } from '@lelemondev/sdk/lambda';
+import OpenAI from 'openai';
+
+init({ apiKey: process.env.LELEMON_API_KEY });
+const openai = observe(new OpenAI());
+
+export const handler = withObserve(async (event) => {
+  const body = JSON.parse(event.body);
+  const result = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: [{ role: 'user', content: body.message }],
+  });
+  return {
+    statusCode: 200,
+    body: JSON.stringify(result.choices[0].message),
+  };
+});
 ```
 
-That's it! No manual tracing code needed.
+### Hono (Cloudflare Workers, Deno, Bun)
+
+```typescript
+import { Hono } from 'hono';
+import { init, observe } from '@lelemondev/sdk';
+import { createMiddleware } from '@lelemondev/sdk/hono';
+import OpenAI from 'openai';
+
+init({ apiKey: process.env.LELEMON_API_KEY });
+const openai = observe(new OpenAI());
+
+const app = new Hono();
+app.use(createMiddleware()); // Uses waitUntil on Workers
+
+app.post('/chat', async (c) => {
+  const { message } = await c.req.json();
+  const result = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: [{ role: 'user', content: message }],
+  });
+  return c.json(result.choices[0].message);
+});
+
+export default app;
+```
 
 ## Supported Providers
 
@@ -60,69 +153,41 @@ Initialize the SDK. Call once at app startup.
 
 ```typescript
 init({
-  apiKey: 'le_xxx',           // Required (or set LELEMON_API_KEY env var)
+  apiKey: 'le_xxx',           // Required (or LELEMON_API_KEY env var)
   endpoint: 'https://...',    // Optional, custom endpoint
   debug: false,               // Optional, enable debug logs
-  disabled: false,            // Optional, disable all tracing
+  disabled: false,            // Optional, disable tracing
   batchSize: 10,              // Optional, items per batch
   flushIntervalMs: 1000,      // Optional, auto-flush interval
-  requestTimeoutMs: 10000,    // Optional, HTTP request timeout
 });
 ```
 
 ### `observe(client, options?)`
 
-Wrap an LLM client with automatic tracing. Returns the same client type.
+Wrap an LLM client with automatic tracing.
 
 ```typescript
-import Anthropic from '@anthropic-ai/sdk';
-
-const anthropic = observe(new Anthropic(), {
-  sessionId: 'session-123',   // Optional, group related traces
-  userId: 'user-456',         // Optional, identify the user
-  metadata: { source: 'api' }, // Optional, custom metadata
-  tags: ['production'],       // Optional, tags for filtering
-});
-```
-
-### `createObserve(defaultOptions)`
-
-Create a scoped observe function with preset options.
-
-```typescript
-const observeWithSession = createObserve({
+const openai = observe(new OpenAI(), {
   sessionId: 'session-123',
   userId: 'user-456',
+  metadata: { source: 'api' },
+  tags: ['production'],
 });
-
-const openai = observeWithSession(new OpenAI());
-const anthropic = observeWithSession(new Anthropic());
 ```
 
 ### `flush()`
 
-Wait for all pending traces to be sent. Use in serverless environments.
+Manually flush pending traces. Use in serverless without framework integration.
 
 ```typescript
 await flush();
 ```
 
-### `isEnabled()`
-
-Check if tracing is enabled.
-
-```typescript
-if (isEnabled()) {
-  console.log('Tracing is active');
-}
-```
-
-## Streaming Support
+## Streaming
 
 Both OpenAI and Anthropic streaming are fully supported:
 
 ```typescript
-// OpenAI streaming
 const stream = await openai.chat.completions.create({
   model: 'gpt-4',
   messages: [{ role: 'user', content: 'Hello!' }],
@@ -132,64 +197,7 @@ const stream = await openai.chat.completions.create({
 for await (const chunk of stream) {
   process.stdout.write(chunk.choices[0]?.delta?.content || '');
 }
-// Trace is captured automatically when stream completes
-
-// Anthropic streaming
-const stream = anthropic.messages.stream({
-  model: 'claude-3-opus-20240229',
-  max_tokens: 1024,
-  messages: [{ role: 'user', content: 'Hello!' }],
-});
-
-for await (const event of stream) {
-  // Process events
-}
-// Trace is captured automatically
-```
-
-## Serverless Usage
-
-### Vercel (Next.js)
-
-```typescript
-import { waitUntil } from '@vercel/functions';
-import { init, observe, flush } from '@lelemondev/sdk';
-import OpenAI from 'openai';
-
-init({ apiKey: process.env.LELEMON_API_KEY });
-const openai = observe(new OpenAI());
-
-export async function POST(req: Request) {
-  const { message } = await req.json();
-
-  const response = await openai.chat.completions.create({
-    model: 'gpt-4',
-    messages: [{ role: 'user', content: message }],
-  });
-
-  waitUntil(flush());  // Flush after response
-  return Response.json(response.choices[0].message);
-}
-```
-
-### AWS Lambda
-
-```typescript
-import { init, observe, flush } from '@lelemondev/sdk';
-import OpenAI from 'openai';
-
-init({ apiKey: process.env.LELEMON_API_KEY });
-const openai = observe(new OpenAI());
-
-export const handler = async (event) => {
-  const response = await openai.chat.completions.create({
-    model: 'gpt-4',
-    messages: [{ role: 'user', content: event.body }],
-  });
-
-  await flush();  // Always flush before Lambda ends
-  return { statusCode: 200, body: JSON.stringify(response) };
-};
+// Trace captured automatically when stream completes
 ```
 
 ## What Gets Traced
@@ -200,7 +208,7 @@ Each LLM call automatically captures:
 - **Model** - gpt-4, claude-3-opus, etc.
 - **Input** - Messages/prompt (sanitized)
 - **Output** - Response content
-- **Tokens** - Input and output token counts
+- **Tokens** - Input and output counts
 - **Duration** - Request latency in ms
 - **Status** - success or error
 - **Streaming** - Whether streaming was used
@@ -211,14 +219,21 @@ The SDK automatically sanitizes sensitive data:
 
 - API keys and tokens are redacted
 - Large payloads are truncated
-- Errors are captured without stack traces
+- Errors are captured safely
 
 ## Environment Variables
 
 | Variable | Description |
 |----------|-------------|
-| `LELEMON_API_KEY` | Your Lelemon API key (starts with `le_`) |
+| `LELEMON_API_KEY` | Your API key (starts with `le_`) |
 
 ## License
 
 MIT
+
+## Sources
+
+Framework integration patterns based on:
+- [Next.js after() docs](https://nextjs.org/docs/app/api-reference/functions/after)
+- [Vercel waitUntil](https://www.inngest.com/blog/vercel-cloudflare-wait-until)
+- [Langfuse SDK patterns](https://langfuse.com/docs/observability/sdk/typescript/advanced-usage)

package/dist/express-Cmb_A4sI.d.mts

@@ -0,0 +1,47 @@
+/**
+ * Express Integration
+ *
+ * Middleware that automatically flushes traces when response finishes.
+ *
+ * @example
+ * import express from 'express';
+ * import { createMiddleware } from '@lelemondev/sdk/express';
+ *
+ * const app = express();
+ * app.use(createMiddleware());
+ */
+interface ExpressRequest {
+    [key: string]: unknown;
+}
+interface ExpressResponse {
+    on(event: 'finish' | 'close' | 'error', listener: () => void): this;
+    [key: string]: unknown;
+}
+type NextFunction = (error?: unknown) => void;
+type ExpressMiddleware = (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => void;
+/**
+ * Create Express middleware for automatic trace flushing
+ *
+ * Flushes traces when the response finishes (after res.send/res.json).
+ * This is fire-and-forget and doesn't block the response.
+ *
+ * @returns Express middleware function
+ *
+ * @example
+ * // Global middleware
+ * app.use(createMiddleware());
+ *
+ * @example
+ * // Per-route middleware
+ * app.post('/chat', createMiddleware(), async (req, res) => {
+ *   res.json({ ok: true });
+ * });
+ */
+declare function createMiddleware(): ExpressMiddleware;
+
+declare const express_createMiddleware: typeof createMiddleware;
+declare namespace express {
+  export { express_createMiddleware as createMiddleware };
+}
+
+export { createMiddleware as c, express as e };

package/dist/express-Cmb_A4sI.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Express Integration
+ *
+ * Middleware that automatically flushes traces when response finishes.
+ *
+ * @example
+ * import express from 'express';
+ * import { createMiddleware } from '@lelemondev/sdk/express';
+ *
+ * const app = express();
+ * app.use(createMiddleware());
+ */
+interface ExpressRequest {
+    [key: string]: unknown;
+}
+interface ExpressResponse {
+    on(event: 'finish' | 'close' | 'error', listener: () => void): this;
+    [key: string]: unknown;
+}
+type NextFunction = (error?: unknown) => void;
+type ExpressMiddleware = (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => void;
+/**
+ * Create Express middleware for automatic trace flushing
+ *
+ * Flushes traces when the response finishes (after res.send/res.json).
+ * This is fire-and-forget and doesn't block the response.
+ *
+ * @returns Express middleware function
+ *
+ * @example
+ * // Global middleware
+ * app.use(createMiddleware());
+ *
+ * @example
+ * // Per-route middleware
+ * app.post('/chat', createMiddleware(), async (req, res) => {
+ *   res.json({ ok: true });
+ * });
+ */
+declare function createMiddleware(): ExpressMiddleware;
+
+declare const express_createMiddleware: typeof createMiddleware;
+declare namespace express {
+  export { express_createMiddleware as createMiddleware };
+}
+
+export { createMiddleware as c, express as e };

package/dist/express.d.mts

@@ -0,0 +1 @@
+export { c as createMiddleware } from './express-Cmb_A4sI.mjs';

package/dist/express.d.ts

@@ -0,0 +1 @@
+export { c as createMiddleware } from './express-Cmb_A4sI.js';

package/dist/express.js

@@ -0,0 +1,21 @@
+'use strict';
+
+/* @lelemondev/sdk - LLM Observability */
+
+async function flush() {
+}
+
+// src/integrations/express.ts
+function createMiddleware() {
+  return (_req, res, next) => {
+    res.on("finish", () => {
+      flush().catch(() => {
+      });
+    });
+    next();
+  };
+}
+
+exports.createMiddleware = createMiddleware;
+//# sourceMappingURL=express.js.map
+//# sourceMappingURL=express.js.map

package/dist/express.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/config.ts","../src/integrations/express.ts"],"names":[],"mappings":";;;;AAuEA,eAAsB,KAAA,GAAuB;AAI7C;;;ACjBO,SAAS,gBAAA,GAAsC;AACpD,EAAA,OAAO,CAAC,IAAA,EAAM,GAAA,EAAK,IAAA,KAAS;AAE1B,IAAA,GAAA,CAAI,EAAA,CAAG,UAAU,MAAM;AACrB,MAAA,KAAA,EAAM,CAAE,MAAM,MAAM;AAAA,MAEpB,CAAC,CAAA;AAAA,IACH,CAAC,CAAA;AAED,IAAA,IAAA,EAAK;AAAA,EACP,CAAA;AACF","file":"express.js","sourcesContent":["/**\n * Global Configuration\n *\n * Manages SDK configuration and transport instance.\n */\n\nimport type { LelemonConfig } from './types';\nimport { Transport } from './transport';\n\n// ─────────────────────────────────────────────────────────────\n// Global State\n// ─────────────────────────────────────────────────────────────\n\nlet globalConfig: LelemonConfig = {};\nlet globalTransport: Transport | null = null;\nlet initialized = false;\n\n// ─────────────────────────────────────────────────────────────\n// Configuration\n// ─────────────────────────────────────────────────────────────\n\nconst DEFAULT_ENDPOINT = 'https://api.lelemon.dev';\n\n/**\n * Initialize the SDK\n * Call once at app startup\n */\nexport function init(config: LelemonConfig = {}): void {\n  globalConfig = config;\n  globalTransport = createTransport(config);\n  initialized = true;\n}\n\n/**\n * Get current config\n */\nexport function getConfig(): LelemonConfig {\n  return globalConfig;\n}\n\n/**\n * Check if SDK is initialized\n */\nexport function isInitialized(): boolean {\n  return initialized;\n}\n\n/**\n * Check if SDK is enabled\n */\nexport function isEnabled(): boolean {\n  return getTransport().isEnabled();\n}\n\n// ─────────────────────────────────────────────────────────────\n// Transport\n// ─────────────────────────────────────────────────────────────\n\n/**\n * Get or create transport instance\n */\nexport function getTransport(): Transport {\n  if (!globalTransport) {\n    globalTransport = createTransport(globalConfig);\n  }\n  return globalTransport;\n}\n\n/**\n * Flush all pending traces\n */\nexport async function flush(): Promise<void> {\n  if (globalTransport) {\n    await globalTransport.flush();\n  }\n}\n\n/**\n * Create transport instance\n */\nfunction createTransport(config: LelemonConfig): Transport {\n  const apiKey = config.apiKey ?? getEnvVar('LELEMON_API_KEY');\n\n  if (!apiKey && !config.disabled) {\n    console.warn(\n      '[Lelemon] No API key provided. Set apiKey in init() or LELEMON_API_KEY env var. Tracing disabled.'\n    );\n  }\n\n  return new Transport({\n    apiKey: apiKey ?? '',\n    endpoint: config.endpoint ?? DEFAULT_ENDPOINT,\n    debug: config.debug ?? false,\n    disabled: config.disabled ?? !apiKey,\n    batchSize: config.batchSize,\n    flushIntervalMs: config.flushIntervalMs,\n    requestTimeoutMs: config.requestTimeoutMs,\n  });\n}\n\n/**\n * Get environment variable (works in Node and edge)\n */\nfunction getEnvVar(name: string): string | undefined {\n  if (typeof process !== 'undefined' && process.env) {\n    return process.env[name];\n  }\n  return undefined;\n}\n","/**\n * Express Integration\n *\n * Middleware that automatically flushes traces when response finishes.\n *\n * @example\n * import express from 'express';\n * import { createMiddleware } from '@lelemondev/sdk/express';\n *\n * const app = express();\n * app.use(createMiddleware());\n */\n\nimport { flush } from '../core/config';\n\n// ─────────────────────────────────────────────────────────────\n// Types (minimal to avoid requiring express as dependency)\n// ─────────────────────────────────────────────────────────────\n\ninterface ExpressRequest {\n  [key: string]: unknown;\n}\n\ninterface ExpressResponse {\n  on(event: 'finish' | 'close' | 'error', listener: () => void): this;\n  [key: string]: unknown;\n}\n\ntype NextFunction = (error?: unknown) => void;\n\ntype ExpressMiddleware = (\n  req: ExpressRequest,\n  res: ExpressResponse,\n  next: NextFunction\n) => void;\n\n// ─────────────────────────────────────────────────────────────\n// Middleware\n// ─────────────────────────────────────────────────────────────\n\n/**\n * Create Express middleware for automatic trace flushing\n *\n * Flushes traces when the response finishes (after res.send/res.json).\n * This is fire-and-forget and doesn't block the response.\n *\n * @returns Express middleware function\n *\n * @example\n * // Global middleware\n * app.use(createMiddleware());\n *\n * @example\n * // Per-route middleware\n * app.post('/chat', createMiddleware(), async (req, res) => {\n *   res.json({ ok: true });\n * });\n */\nexport function createMiddleware(): ExpressMiddleware {\n  return (_req, res, next) => {\n    // Flush when response is finished (after headers + body sent)\n    res.on('finish', () => {\n      flush().catch(() => {\n        // Silently ignore flush errors - fire and forget\n      });\n    });\n\n    next();\n  };\n}\n"]}

package/dist/express.mjs

@@ -0,0 +1,19 @@
+/* @lelemondev/sdk - LLM Observability */
+
+async function flush() {
+}
+
+// src/integrations/express.ts
+function createMiddleware() {
+  return (_req, res, next) => {
+    res.on("finish", () => {
+      flush().catch(() => {
+      });
+    });
+    next();
+  };
+}
+
+export { createMiddleware };
+//# sourceMappingURL=express.mjs.map
+//# sourceMappingURL=express.mjs.map

package/dist/express.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/config.ts","../src/integrations/express.ts"],"names":[],"mappings":";;AAuEA,eAAsB,KAAA,GAAuB;AAI7C;;;ACjBO,SAAS,gBAAA,GAAsC;AACpD,EAAA,OAAO,CAAC,IAAA,EAAM,GAAA,EAAK,IAAA,KAAS;AAE1B,IAAA,GAAA,CAAI,EAAA,CAAG,UAAU,MAAM;AACrB,MAAA,KAAA,EAAM,CAAE,MAAM,MAAM;AAAA,MAEpB,CAAC,CAAA;AAAA,IACH,CAAC,CAAA;AAED,IAAA,IAAA,EAAK;AAAA,EACP,CAAA;AACF","file":"express.mjs","sourcesContent":["/**\n * Global Configuration\n *\n * Manages SDK configuration and transport instance.\n */\n\nimport type { LelemonConfig } from './types';\nimport { Transport } from './transport';\n\n// ─────────────────────────────────────────────────────────────\n// Global State\n// ─────────────────────────────────────────────────────────────\n\nlet globalConfig: LelemonConfig = {};\nlet globalTransport: Transport | null = null;\nlet initialized = false;\n\n// ─────────────────────────────────────────────────────────────\n// Configuration\n// ─────────────────────────────────────────────────────────────\n\nconst DEFAULT_ENDPOINT = 'https://api.lelemon.dev';\n\n/**\n * Initialize the SDK\n * Call once at app startup\n */\nexport function init(config: LelemonConfig = {}): void {\n  globalConfig = config;\n  globalTransport = createTransport(config);\n  initialized = true;\n}\n\n/**\n * Get current config\n */\nexport function getConfig(): LelemonConfig {\n  return globalConfig;\n}\n\n/**\n * Check if SDK is initialized\n */\nexport function isInitialized(): boolean {\n  return initialized;\n}\n\n/**\n * Check if SDK is enabled\n */\nexport function isEnabled(): boolean {\n  return getTransport().isEnabled();\n}\n\n// ─────────────────────────────────────────────────────────────\n// Transport\n// ─────────────────────────────────────────────────────────────\n\n/**\n * Get or create transport instance\n */\nexport function getTransport(): Transport {\n  if (!globalTransport) {\n    globalTransport = createTransport(globalConfig);\n  }\n  return globalTransport;\n}\n\n/**\n * Flush all pending traces\n */\nexport async function flush(): Promise<void> {\n  if (globalTransport) {\n    await globalTransport.flush();\n  }\n}\n\n/**\n * Create transport instance\n */\nfunction createTransport(config: LelemonConfig): Transport {\n  const apiKey = config.apiKey ?? getEnvVar('LELEMON_API_KEY');\n\n  if (!apiKey && !config.disabled) {\n    console.warn(\n      '[Lelemon] No API key provided. Set apiKey in init() or LELEMON_API_KEY env var. Tracing disabled.'\n    );\n  }\n\n  return new Transport({\n    apiKey: apiKey ?? '',\n    endpoint: config.endpoint ?? DEFAULT_ENDPOINT,\n    debug: config.debug ?? false,\n    disabled: config.disabled ?? !apiKey,\n    batchSize: config.batchSize,\n    flushIntervalMs: config.flushIntervalMs,\n    requestTimeoutMs: config.requestTimeoutMs,\n  });\n}\n\n/**\n * Get environment variable (works in Node and edge)\n */\nfunction getEnvVar(name: string): string | undefined {\n  if (typeof process !== 'undefined' && process.env) {\n    return process.env[name];\n  }\n  return undefined;\n}\n","/**\n * Express Integration\n *\n * Middleware that automatically flushes traces when response finishes.\n *\n * @example\n * import express from 'express';\n * import { createMiddleware } from '@lelemondev/sdk/express';\n *\n * const app = express();\n * app.use(createMiddleware());\n */\n\nimport { flush } from '../core/config';\n\n// ─────────────────────────────────────────────────────────────\n// Types (minimal to avoid requiring express as dependency)\n// ─────────────────────────────────────────────────────────────\n\ninterface ExpressRequest {\n  [key: string]: unknown;\n}\n\ninterface ExpressResponse {\n  on(event: 'finish' | 'close' | 'error', listener: () => void): this;\n  [key: string]: unknown;\n}\n\ntype NextFunction = (error?: unknown) => void;\n\ntype ExpressMiddleware = (\n  req: ExpressRequest,\n  res: ExpressResponse,\n  next: NextFunction\n) => void;\n\n// ─────────────────────────────────────────────────────────────\n// Middleware\n// ─────────────────────────────────────────────────────────────\n\n/**\n * Create Express middleware for automatic trace flushing\n *\n * Flushes traces when the response finishes (after res.send/res.json).\n * This is fire-and-forget and doesn't block the response.\n *\n * @returns Express middleware function\n *\n * @example\n * // Global middleware\n * app.use(createMiddleware());\n *\n * @example\n * // Per-route middleware\n * app.post('/chat', createMiddleware(), async (req, res) => {\n *   res.json({ ok: true });\n * });\n */\nexport function createMiddleware(): ExpressMiddleware {\n  return (_req, res, next) => {\n    // Flush when response is finished (after headers + body sent)\n    res.on('finish', () => {\n      flush().catch(() => {\n        // Silently ignore flush errors - fire and forget\n      });\n    });\n\n    next();\n  };\n}\n"]}

package/dist/hono-ChTmQk_V.d.mts

@@ -0,0 +1,61 @@
+/**
+ * Hono Integration
+ *
+ * Middleware for Hono framework (Cloudflare Workers, Deno, Bun, Node.js).
+ * Uses executionCtx.waitUntil() when available for non-blocking flush.
+ *
+ * @example
+ * import { Hono } from 'hono';
+ * import { createMiddleware } from '@lelemondev/sdk/hono';
+ *
+ * const app = new Hono();
+ * app.use(createMiddleware());
+ */
+interface ExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException(): void;
+}
+interface HonoContext {
+    req: {
+        raw: Request;
+        [key: string]: unknown;
+    };
+    res: Response | undefined;
+    executionCtx?: ExecutionContext;
+    [key: string]: unknown;
+}
+type NextFunction = () => Promise<void>;
+type HonoMiddleware = (c: HonoContext, next: NextFunction) => Promise<void>;
+/**
+ * Create Hono middleware for automatic trace flushing
+ *
+ * On Cloudflare Workers/Deno Deploy: uses executionCtx.waitUntil() for non-blocking flush
+ * On Node.js/Bun: flushes after response (fire-and-forget)
+ *
+ * @returns Hono middleware function
+ *
+ * @example
+ * import { Hono } from 'hono';
+ * import { createMiddleware } from '@lelemondev/sdk/hono';
+ *
+ * const app = new Hono();
+ *
+ * // Global middleware
+ * app.use(createMiddleware());
+ *
+ * app.post('/chat', async (c) => {
+ *   const openai = observe(new OpenAI());
+ *   const result = await openai.chat.completions.create({...});
+ *   return c.json(result);
+ * });
+ *
+ * export default app;
+ */
+declare function createMiddleware(): HonoMiddleware;
+
+declare const hono_createMiddleware: typeof createMiddleware;
+declare namespace hono {
+  export { hono_createMiddleware as createMiddleware };
+}
+
+export { createMiddleware as c, hono as h };

package/dist/hono-ChTmQk_V.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Hono Integration
+ *
+ * Middleware for Hono framework (Cloudflare Workers, Deno, Bun, Node.js).
+ * Uses executionCtx.waitUntil() when available for non-blocking flush.
+ *
+ * @example
+ * import { Hono } from 'hono';
+ * import { createMiddleware } from '@lelemondev/sdk/hono';
+ *
+ * const app = new Hono();
+ * app.use(createMiddleware());
+ */
+interface ExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException(): void;
+}
+interface HonoContext {
+    req: {
+        raw: Request;
+        [key: string]: unknown;
+    };
+    res: Response | undefined;
+    executionCtx?: ExecutionContext;
+    [key: string]: unknown;
+}
+type NextFunction = () => Promise<void>;
+type HonoMiddleware = (c: HonoContext, next: NextFunction) => Promise<void>;
+/**
+ * Create Hono middleware for automatic trace flushing
+ *
+ * On Cloudflare Workers/Deno Deploy: uses executionCtx.waitUntil() for non-blocking flush
+ * On Node.js/Bun: flushes after response (fire-and-forget)
+ *
+ * @returns Hono middleware function
+ *
+ * @example
+ * import { Hono } from 'hono';
+ * import { createMiddleware } from '@lelemondev/sdk/hono';
+ *
+ * const app = new Hono();
+ *
+ * // Global middleware
+ * app.use(createMiddleware());
+ *
+ * app.post('/chat', async (c) => {
+ *   const openai = observe(new OpenAI());
+ *   const result = await openai.chat.completions.create({...});
+ *   return c.json(result);
+ * });
+ *
+ * export default app;
+ */
+declare function createMiddleware(): HonoMiddleware;
+
+declare const hono_createMiddleware: typeof createMiddleware;
+declare namespace hono {
+  export { hono_createMiddleware as createMiddleware };
+}
+
+export { createMiddleware as c, hono as h };

package/dist/hono.d.mts

@@ -0,0 +1 @@
+export { c as createMiddleware } from './hono-ChTmQk_V.mjs';

package/dist/hono.d.ts

@@ -0,0 +1 @@
+export { c as createMiddleware } from './hono-ChTmQk_V.js';

package/dist/hono.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/* @lelemondev/sdk - LLM Observability */
+
+async function flush() {
+}
+
+// src/integrations/hono.ts
+function createMiddleware() {
+  return async (c, next) => {
+    await next();
+    if (c.executionCtx?.waitUntil) {
+      c.executionCtx.waitUntil(flush());
+    } else {
+      flush().catch(() => {
+      });
+    }
+  };
+}
+
+exports.createMiddleware = createMiddleware;
+//# sourceMappingURL=hono.js.map
+//# sourceMappingURL=hono.js.map

package/dist/hono.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/config.ts","../src/integrations/hono.ts"],"names":[],"mappings":";;;;AAuEA,eAAsB,KAAA,GAAuB;AAI7C;;;ACPO,SAAS,gBAAA,GAAmC;AACjD,EAAA,OAAO,OAAO,GAAG,IAAA,KAAS;AACxB,IAAA,MAAM,IAAA,EAAK;AAGX,IAAA,IAAI,CAAA,CAAE,cAAc,SAAA,EAAW;AAC7B,MAAA,CAAA,CAAE,YAAA,CAAa,SAAA,CAAU,KAAA,EAAO,CAAA;AAAA,IAClC,CAAA,MAAO;AAEL,MAAA,KAAA,EAAM,CAAE,MAAM,MAAM;AAAA,MAAC,CAAC,CAAA;AAAA,IACxB;AAAA,EACF,CAAA;AACF","file":"hono.js","sourcesContent":["/**\n * Global Configuration\n *\n * Manages SDK configuration and transport instance.\n */\n\nimport type { LelemonConfig } from './types';\nimport { Transport } from './transport';\n\n// ─────────────────────────────────────────────────────────────\n// Global State\n// ─────────────────────────────────────────────────────────────\n\nlet globalConfig: LelemonConfig = {};\nlet globalTransport: Transport | null = null;\nlet initialized = false;\n\n// ─────────────────────────────────────────────────────────────\n// Configuration\n// ─────────────────────────────────────────────────────────────\n\nconst DEFAULT_ENDPOINT = 'https://api.lelemon.dev';\n\n/**\n * Initialize the SDK\n * Call once at app startup\n */\nexport function init(config: LelemonConfig = {}): void {\n  globalConfig = config;\n  globalTransport = createTransport(config);\n  initialized = true;\n}\n\n/**\n * Get current config\n */\nexport function getConfig(): LelemonConfig {\n  return globalConfig;\n}\n\n/**\n * Check if SDK is initialized\n */\nexport function isInitialized(): boolean {\n  return initialized;\n}\n\n/**\n * Check if SDK is enabled\n */\nexport function isEnabled(): boolean {\n  return getTransport().isEnabled();\n}\n\n// ─────────────────────────────────────────────────────────────\n// Transport\n// ─────────────────────────────────────────────────────────────\n\n/**\n * Get or create transport instance\n */\nexport function getTransport(): Transport {\n  if (!globalTransport) {\n    globalTransport = createTransport(globalConfig);\n  }\n  return globalTransport;\n}\n\n/**\n * Flush all pending traces\n */\nexport async function flush(): Promise<void> {\n  if (globalTransport) {\n    await globalTransport.flush();\n  }\n}\n\n/**\n * Create transport instance\n */\nfunction createTransport(config: LelemonConfig): Transport {\n  const apiKey = config.apiKey ?? getEnvVar('LELEMON_API_KEY');\n\n  if (!apiKey && !config.disabled) {\n    console.warn(\n      '[Lelemon] No API key provided. Set apiKey in init() or LELEMON_API_KEY env var. Tracing disabled.'\n    );\n  }\n\n  return new Transport({\n    apiKey: apiKey ?? '',\n    endpoint: config.endpoint ?? DEFAULT_ENDPOINT,\n    debug: config.debug ?? false,\n    disabled: config.disabled ?? !apiKey,\n    batchSize: config.batchSize,\n    flushIntervalMs: config.flushIntervalMs,\n    requestTimeoutMs: config.requestTimeoutMs,\n  });\n}\n\n/**\n * Get environment variable (works in Node and edge)\n */\nfunction getEnvVar(name: string): string | undefined {\n  if (typeof process !== 'undefined' && process.env) {\n    return process.env[name];\n  }\n  return undefined;\n}\n","/**\n * Hono Integration\n *\n * Middleware for Hono framework (Cloudflare Workers, Deno, Bun, Node.js).\n * Uses executionCtx.waitUntil() when available for non-blocking flush.\n *\n * @example\n * import { Hono } from 'hono';\n * import { createMiddleware } from '@lelemondev/sdk/hono';\n *\n * const app = new Hono();\n * app.use(createMiddleware());\n */\n\nimport { flush } from '../core/config';\n\n// ─────────────────────────────────────────────────────────────\n// Types (minimal to avoid requiring hono as dependency)\n// ─────────────────────────────────────────────────────────────\n\ninterface ExecutionContext {\n  waitUntil(promise: Promise<unknown>): void;\n  passThroughOnException(): void;\n}\n\ninterface HonoContext {\n  req: {\n    raw: Request;\n    [key: string]: unknown;\n  };\n  res: Response | undefined;\n  executionCtx?: ExecutionContext;\n  [key: string]: unknown;\n}\n\ntype NextFunction = () => Promise<void>;\n\ntype HonoMiddleware = (c: HonoContext, next: NextFunction) => Promise<void>;\n\n// ─────────────────────────────────────────────────────────────\n// Middleware\n// ─────────────────────────────────────────────────────────────\n\n/**\n * Create Hono middleware for automatic trace flushing\n *\n * On Cloudflare Workers/Deno Deploy: uses executionCtx.waitUntil() for non-blocking flush\n * On Node.js/Bun: flushes after response (fire-and-forget)\n *\n * @returns Hono middleware function\n *\n * @example\n * import { Hono } from 'hono';\n * import { createMiddleware } from '@lelemondev/sdk/hono';\n *\n * const app = new Hono();\n *\n * // Global middleware\n * app.use(createMiddleware());\n *\n * app.post('/chat', async (c) => {\n *   const openai = observe(new OpenAI());\n *   const result = await openai.chat.completions.create({...});\n *   return c.json(result);\n * });\n *\n * export default app;\n */\nexport function createMiddleware(): HonoMiddleware {\n  return async (c, next) => {\n    await next();\n\n    // Use waitUntil if available (Cloudflare Workers, Deno Deploy)\n    if (c.executionCtx?.waitUntil) {\n      c.executionCtx.waitUntil(flush());\n    } else {\n      // Fire-and-forget for Node.js/Bun\n      flush().catch(() => {});\n    }\n  };\n}\n"]}