@lelemondev/sdk 0.2.1 → 0.4.0

package/README.md

@@ -4,15 +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)
 
-Fire-and-forget LLM observability for Node.js. Track your AI agents with 3 lines of code.
+Automatic LLM observability for Node.js. Wrap your client, everything is traced.
 
 ## Features
 
-- 🔥 **Fire-and-forget** - Never blocks your code
-- 📦 **Auto-batching** - Efficient network usage
-- ⚡ **Zero config** - Works out of the box
-- 🛡️ **Error-safe** - Never crashes your app
-- 🌐 **Serverless-ready** - Built-in flush for Lambda/Vercel
+- **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
 
 ## Installation
 
@@ -23,151 +23,217 @@ npm install @lelemondev/sdk
 ## Quick Start
 
 ```typescript
-import { init, trace, flush } from '@lelemondev/sdk';
+import { init, observe } from '@lelemondev/sdk';
+import OpenAI from 'openai';
 
-// Initialize once at app startup
+// 1. Initialize once
 init({ apiKey: process.env.LELEMON_API_KEY });
 
-// Trace your agent (fire-and-forget, no awaits needed!)
-const t = trace({ input: userMessage });
+// 2. Wrap your client
+const openai = observe(new OpenAI());
 
-try {
-  const result = await myAgent(userMessage);
-  t.success(result.messages);  // Sync, doesn't block
-} catch (error) {
-  t.error(error);              // Sync, doesn't block
-  throw error;
-}
-
-// For serverless: flush before response
-await flush();
+// 3. Use normally - all calls traced automatically
+const response = await openai.chat.completions.create({
+  model: 'gpt-4',
+  messages: [{ role: 'user', content: 'Hello!' }],
+});
 ```
 
-## API Reference
+## Framework Integrations
 
-### `init(config)`
+### Next.js App Router
 
-Initialize the SDK. Call once at app startup.
+```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
-init({
-  apiKey: 'le_xxx',           // Required (or set LELEMON_API_KEY env var)
-  endpoint: 'https://...',    // Optional, custom endpoint
-  debug: false,               // Optional, enable debug logs
-  batchSize: 10,              // Optional, items per batch
-  flushIntervalMs: 1000,      // Optional, auto-flush interval
+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);
 });
 ```
 
-### `trace(options)`
-
-Start a new trace. Returns a `Trace` object.
+### AWS Lambda
 
 ```typescript
-const t = trace({
-  input: userMessage,         // Required, the input to your agent
-  sessionId: 'session-123',   // Optional, group related traces
-  userId: 'user-456',         // Optional, identify the user
-  name: 'chat-agent',         // Optional, name for this trace
-  metadata: { ... },          // Optional, custom metadata
-  tags: ['prod', 'v2'],       // Optional, tags for filtering
+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),
+  };
 });
 ```
 
-### `Trace.success(messages)`
-
-Complete the trace successfully. Fire-and-forget (no await needed).
+### Hono (Cloudflare Workers, Deno, Bun)
 
 ```typescript
-t.success(result.messages);
+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;
 ```
 
-### `Trace.error(error, messages?)`
+## Supported Providers
+
+| Provider | Status | Methods |
+|----------|--------|---------|
+| OpenAI | Supported | `chat.completions.create()`, `completions.create()`, `embeddings.create()` |
+| Anthropic | Supported | `messages.create()`, `messages.stream()` |
+
+## API Reference
+
+### `init(config)`
 
-Complete the trace with an error. Fire-and-forget (no await needed).
+Initialize the SDK. Call once at app startup.
 
 ```typescript
-t.error(error);
-t.error(error, partialMessages);  // Include messages up to failure
+init({
+  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 tracing
+  batchSize: 10,              // Optional, items per batch
+  flushIntervalMs: 1000,      // Optional, auto-flush interval
+});
 ```
 
-### `Trace.log(response)`
+### `observe(client, options?)`
 
-Log an LLM response for token tracking (optional).
+Wrap an LLM client with automatic tracing.
 
 ```typescript
-const response = await openai.chat.completions.create(...);
-t.log(response);  // Extracts model, tokens automatically
+const openai = observe(new OpenAI(), {
+  sessionId: 'session-123',
+  userId: 'user-456',
+  metadata: { source: 'api' },
+  tags: ['production'],
+});
 ```
 
 ### `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();
 ```
 
-## Serverless Usage
+## Streaming
 
-### Vercel (Next.js)
+Both OpenAI and Anthropic streaming are fully supported:
 
 ```typescript
-import { waitUntil } from '@vercel/functions';
-import { trace, flush } from '@lelemondev/sdk';
-
-export async function POST(req: Request) {
-  const t = trace({ input: message });
-
-  try {
-    const result = await myAgent(message);
-    t.success(result);
-    return Response.json(result);
-  } catch (error) {
-    t.error(error);
-    throw error;
-  } finally {
-    waitUntil(flush());  // Flush after response
-  }
+const stream = await openai.chat.completions.create({
+  model: 'gpt-4',
+  messages: [{ role: 'user', content: 'Hello!' }],
+  stream: true,
+});
+
+for await (const chunk of stream) {
+  process.stdout.write(chunk.choices[0]?.delta?.content || '');
 }
+// Trace captured automatically when stream completes
 ```
 
-### AWS Lambda
+## What Gets Traced
 
-```typescript
-import { trace, flush } from '@lelemondev/sdk';
-
-export const handler = async (event) => {
-  const t = trace({ input: event.body });
-
-  try {
-    const result = await myAgent(event.body);
-    t.success(result);
-    return { statusCode: 200, body: JSON.stringify(result) };
-  } catch (error) {
-    t.error(error);
-    throw error;
-  } finally {
-    await flush();  // Always flush before Lambda ends
-  }
-};
-```
+Each LLM call automatically captures:
 
-## Supported Providers
+- **Provider** - openai, anthropic
+- **Model** - gpt-4, claude-3-opus, etc.
+- **Input** - Messages/prompt (sanitized)
+- **Output** - Response content
+- **Tokens** - Input and output counts
+- **Duration** - Request latency in ms
+- **Status** - success or error
+- **Streaming** - Whether streaming was used
+
+## Security
 
-| Provider | Auto-detected |
-|----------|---------------|
-| OpenAI | ✅ |
-| Anthropic | ✅ |
-| Google Gemini | ✅ |
-| AWS Bedrock | ✅ |
+The SDK automatically sanitizes sensitive data:
+
+- API keys and tokens are redacted
+- Large payloads are truncated
+- 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 © [Lelemon](https://lelemon.dev)
+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