evlog 2.11.1 → 2.12.0

package/README.md

@@ -518,7 +518,7 @@ See the full [nestjs example](https://github.com/HugoRCD/evlog/tree/main/example
 Use the `log` API on the client side for structured browser logging:
 
 ```typescript
-import { log } from 'evlog/browser'
+import { log } from 'evlog/client'
 
 log.info('checkout', 'User initiated checkout')
 log.error({ action: 'payment', error: 'validation_failed' })
@@ -556,6 +556,8 @@ When enabled:
 3. `evlog:drain` hook is called with `source: 'client'`
 4. External services receive the log
 
+For a **framework-agnostic** batched HTTP drain (e.g. vanilla JS or custom endpoints), use `createHttpLogDrain` from [`evlog/http`](https://www.evlog.dev/adapters/http). The legacy import path `evlog/browser` is deprecated and will be removed in the next major release.
+
 ## Structured Errors
 
 Errors should tell you **what** happened, **why**, and **how to fix it**.
@@ -1154,7 +1156,7 @@ try {
 | **Hono** | `app.use(evlog())` with `import { evlog } from 'evlog/hono'` ([example](./examples/hono)) |
 | **Fastify** | `app.register(evlog)` with `import { evlog } from 'evlog/fastify'` ([example](./examples/fastify)) |
 | **Elysia** | `.use(evlog())` with `import { evlog } from 'evlog/elysia'` ([example](./examples/elysia)) |
-| **Cloudflare Workers** | Manual setup with `import { initLogger, createRequestLogger } from 'evlog'` ([example](./examples/workers)) |
+| **Cloudflare Workers** | Manual setup with `import { initWorkersLogger, createWorkersLogger } from 'evlog/workers'` ([example](./examples/workers)) |
 | **Custom** | Build your own with `import { createMiddlewareLogger } from 'evlog/toolkit'` ([guide](https://evlog.dev/frameworks/custom-integration)) |
 | **Analog** | Nitro v2 module setup |
 | **Vinxi** | Nitro v2 module setup |

package/dist/{_drain-YH8ERc5l.mjs → _drain-CmCtsuF6.mjs}

@@ -20,4 +20,4 @@ function defineDrain(options) {
 //#endregion
 export { defineDrain as t };
 
-//# sourceMappingURL=_drain-YH8ERc5l.mjs.map
+//# sourceMappingURL=_drain-CmCtsuF6.mjs.map

package/dist/{_drain-YH8ERc5l.mjs.map → _drain-CmCtsuF6.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"_drain-YH8ERc5l.mjs","names":[],"sources":["../src/adapters/_drain.ts"],"sourcesContent":["import type { DrainContext, WideEvent } from '../types'\n\nexport interface DrainOptions<TConfig> {\n  name: string\n  resolve: () => TConfig | null | Promise<TConfig | null>\n  send: (events: WideEvent[], config: TConfig) => Promise<void>\n}\n\n/**\n * Build a drain callback for `evlog:drain` (or `initLogger({ drain })`).\n * The returned function is async so `resolve` can load Nitro runtime config; hosts typically attach\n * the resulting promise to `waitUntil` so the HTTP response is not blocked (see Nitro plugin).\n */\nexport function defineDrain<TConfig>(options: DrainOptions<TConfig>): (ctx: DrainContext | DrainContext[]) => Promise<void> {\n  return async (ctx: DrainContext | DrainContext[]) => {\n    const contexts = Array.isArray(ctx) ? ctx : [ctx]\n    if (contexts.length === 0) return\n\n    const config = await options.resolve()\n    if (!config) return\n\n    try {\n      await options.send(contexts.map(c => c.event), config)\n    } catch (error) {\n      console.error(`[evlog/${options.name}] Failed to send events:`, error)\n    }\n  }\n}\n"],"mappings":";;;;;;AAaA,SAAgB,YAAqB,SAAuF;AAC1H,QAAO,OAAO,QAAuC;EACnD,MAAM,WAAW,MAAM,QAAQ,IAAI,GAAG,MAAM,CAAC,IAAI;AACjD,MAAI,SAAS,WAAW,EAAG;EAE3B,MAAM,SAAS,MAAM,QAAQ,SAAS;AACtC,MAAI,CAAC,OAAQ;AAEb,MAAI;AACF,SAAM,QAAQ,KAAK,SAAS,KAAI,MAAK,EAAE,MAAM,EAAE,OAAO;WAC/C,OAAO;AACd,WAAQ,MAAM,UAAU,QAAQ,KAAK,2BAA2B,MAAM"}
+{"version":3,"file":"_drain-CmCtsuF6.mjs","names":[],"sources":["../src/adapters/_drain.ts"],"sourcesContent":["import type { DrainContext, WideEvent } from '../types'\n\nexport interface DrainOptions<TConfig> {\n  name: string\n  resolve: () => TConfig | null | Promise<TConfig | null>\n  send: (events: WideEvent[], config: TConfig) => Promise<void>\n}\n\n/**\n * Build a drain callback for `evlog:drain` (or `initLogger({ drain })`).\n * The returned function is async so `resolve` can load Nitro runtime config; hosts typically attach\n * the resulting promise to `waitUntil` so the HTTP response is not blocked (see Nitro plugin).\n */\nexport function defineDrain<TConfig>(options: DrainOptions<TConfig>): (ctx: DrainContext | DrainContext[]) => Promise<void> {\n  return async (ctx: DrainContext | DrainContext[]) => {\n    const contexts = Array.isArray(ctx) ? ctx : [ctx]\n    if (contexts.length === 0) return\n\n    const config = await options.resolve()\n    if (!config) return\n\n    try {\n      await options.send(contexts.map(c => c.event), config)\n    } catch (error) {\n      console.error(`[evlog/${options.name}] Failed to send events:`, error)\n    }\n  }\n}\n"],"mappings":";;;;;;AAaA,SAAgB,YAAqB,SAAuF;AAC1H,QAAO,OAAO,QAAuC;EACnD,MAAM,WAAW,MAAM,QAAQ,IAAI,GAAG,MAAM,CAAC,IAAI;AACjD,MAAI,SAAS,WAAW,EAAG;EAE3B,MAAM,SAAS,MAAM,QAAQ,SAAS;AACtC,MAAI,CAAC,OAAQ;AAEb,MAAI;AACF,SAAM,QAAQ,KAAK,SAAS,KAAI,MAAK,EAAE,MAAM,EAAE,OAAO;WAC/C,OAAO;AACd,WAAQ,MAAM,UAAU,QAAQ,KAAK,2BAA2B,MAAM"}

package/dist/{_http-C_2wbJw3.mjs → _http-CHSsrWDJ.mjs}

@@ -1,4 +1,4 @@
-import { t as getNitroRuntimeConfigRecord } from "./nitroConfigBridge-fidbf-Y_.mjs";
+import { t as getNitroRuntimeConfigRecord } from "./nitroConfigBridge-C37lXaNm.mjs";
 //#region src/adapters/_config.ts
 /**
 * Adapter runtime-config reads go through `getNitroRuntimeConfigRecord` in
@@ -68,4 +68,4 @@ async function httpPost({ url, headers, body, timeout, label, retries = 2 }) {
 //#endregion
 export { resolveAdapterConfig as n, httpPost as t };
 
-//# sourceMappingURL=_http-C_2wbJw3.mjs.map
+//# sourceMappingURL=_http-CHSsrWDJ.mjs.map

package/dist/{_http-C_2wbJw3.mjs.map → _http-CHSsrWDJ.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"_http-C_2wbJw3.mjs","names":[],"sources":["../src/adapters/_config.ts","../src/adapters/_http.ts"],"sourcesContent":["import { getNitroRuntimeConfigRecord } from '../shared/nitroConfigBridge'\n\n/**\n * Adapter runtime-config reads go through `getNitroRuntimeConfigRecord` in\n * `shared/nitroConfigBridge.ts` (documented there — Workers-safe dynamic imports).\n *\n * Drain handlers remain non-blocking when the host provides `waitUntil`.\n */\n\nexport function getRuntimeConfig(): Promise<Record<string, any> | undefined> {\n  return getNitroRuntimeConfigRecord()\n}\n\nexport interface ConfigField<T> {\n  key: keyof T & string\n  env?: string[]\n}\n\nexport async function resolveAdapterConfig<T>(\n  namespace: string,\n  fields: ConfigField<T>[],\n  overrides?: Partial<T>,\n): Promise<Partial<T>> {\n  const runtimeConfig = await getRuntimeConfig()\n  const evlogNs = runtimeConfig?.evlog?.[namespace]\n  const rootNs = runtimeConfig?.[namespace]\n\n  const config: Record<string, unknown> = {}\n\n  for (const { key, env } of fields) {\n    config[key] =\n      overrides?.[key]\n      ?? evlogNs?.[key]\n      ?? rootNs?.[key]\n      ?? resolveEnv(env)\n  }\n\n  return config as Partial<T>\n}\n\nfunction resolveEnv(envKeys?: string[]): string | undefined {\n  if (!envKeys) return undefined\n  for (const key of envKeys) {\n    const val = process.env[key]\n    if (val) return val\n  }\n  return undefined\n}\n","export interface HttpPostOptions {\n  url: string\n  headers: Record<string, string>\n  body: string\n  timeout: number\n  label: string\n  retries?: number\n}\n\nfunction isRetryable(error: unknown): boolean {\n  if (error instanceof DOMException && error.name === 'AbortError') return true\n  if (error instanceof TypeError) return true\n  if (error instanceof Error) {\n    const match = error.message.match(/API error: (\\d+)/)\n    if (match) return Number.parseInt(match[1]) >= 500\n  }\n  return false\n}\n\nexport async function httpPost({ url, headers, body, timeout, label, retries = 2 }: HttpPostOptions): Promise<void> {\n  const normalizedRetries = Number.isFinite(retries) && retries >= 0 ? Math.floor(retries) : 2\n\n  let lastError: Error | undefined\n\n  for (let attempt = 0; attempt <= normalizedRetries; attempt++) {\n    const controller = new AbortController()\n    const timeoutId = setTimeout(() => controller.abort(), timeout)\n\n    try {\n      const response = await fetch(url, {\n        method: 'POST',\n        headers,\n        body,\n        signal: controller.signal,\n      })\n\n      if (!response.ok) {\n        const text = await response.text().catch(() => 'Unknown error')\n        const safeText = text.length > 200 ? `${text.slice(0, 200)}...[truncated]` : text\n        throw new Error(`${label} API error: ${response.status} ${response.statusText} - ${safeText}`)\n      }\n\n      clearTimeout(timeoutId)\n      return\n    } catch (error) {\n      clearTimeout(timeoutId)\n\n      if (error instanceof DOMException && error.name === 'AbortError') {\n        lastError = new Error(`${label} request timed out after ${timeout}ms`)\n      } else {\n        lastError = error as Error\n      }\n\n      if (!isRetryable(error) || attempt === normalizedRetries) {\n        throw lastError\n      }\n\n      await new Promise<void>(r => setTimeout(r, 200 * 2 ** attempt))\n    }\n  }\n\n  throw lastError!\n}\n"],"mappings":";;;;;;;;AASA,SAAgB,mBAA6D;AAC3E,QAAO,6BAA6B;;AAQtC,eAAsB,qBACpB,WACA,QACA,WACqB;CACrB,MAAM,gBAAgB,MAAM,kBAAkB;CAC9C,MAAM,UAAU,eAAe,QAAQ;CACvC,MAAM,SAAS,gBAAgB;CAE/B,MAAM,SAAkC,EAAE;AAE1C,MAAK,MAAM,EAAE,KAAK,SAAS,OACzB,QAAO,OACL,YAAY,QACT,UAAU,QACV,SAAS,QACT,WAAW,IAAI;AAGtB,QAAO;;AAGT,SAAS,WAAW,SAAwC;AAC1D,KAAI,CAAC,QAAS,QAAO,KAAA;AACrB,MAAK,MAAM,OAAO,SAAS;EACzB,MAAM,MAAM,QAAQ,IAAI;AACxB,MAAI,IAAK,QAAO;;;;;ACnCpB,SAAS,YAAY,OAAyB;AAC5C,KAAI,iBAAiB,gBAAgB,MAAM,SAAS,aAAc,QAAO;AACzE,KAAI,iBAAiB,UAAW,QAAO;AACvC,KAAI,iBAAiB,OAAO;EAC1B,MAAM,QAAQ,MAAM,QAAQ,MAAM,mBAAmB;AACrD,MAAI,MAAO,QAAO,OAAO,SAAS,MAAM,GAAG,IAAI;;AAEjD,QAAO;;AAGT,eAAsB,SAAS,EAAE,KAAK,SAAS,MAAM,SAAS,OAAO,UAAU,KAAqC;CAClH,MAAM,oBAAoB,OAAO,SAAS,QAAQ,IAAI,WAAW,IAAI,KAAK,MAAM,QAAQ,GAAG;CAE3F,IAAI;AAEJ,MAAK,IAAI,UAAU,GAAG,WAAW,mBAAmB,WAAW;EAC7D,MAAM,aAAa,IAAI,iBAAiB;EACxC,MAAM,YAAY,iBAAiB,WAAW,OAAO,EAAE,QAAQ;AAE/D,MAAI;GACF,MAAM,WAAW,MAAM,MAAM,KAAK;IAChC,QAAQ;IACR;IACA;IACA,QAAQ,WAAW;IACpB,CAAC;AAEF,OAAI,CAAC,SAAS,IAAI;IAChB,MAAM,OAAO,MAAM,SAAS,MAAM,CAAC,YAAY,gBAAgB;IAC/D,MAAM,WAAW,KAAK,SAAS,MAAM,GAAG,KAAK,MAAM,GAAG,IAAI,CAAC,kBAAkB;AAC7E,UAAM,IAAI,MAAM,GAAG,MAAM,cAAc,SAAS,OAAO,GAAG,SAAS,WAAW,KAAK,WAAW;;AAGhG,gBAAa,UAAU;AACvB;WACO,OAAO;AACd,gBAAa,UAAU;AAEvB,OAAI,iBAAiB,gBAAgB,MAAM,SAAS,aAClD,6BAAY,IAAI,MAAM,GAAG,MAAM,2BAA2B,QAAQ,IAAI;OAEtE,aAAY;AAGd,OAAI,CAAC,YAAY,MAAM,IAAI,YAAY,kBACrC,OAAM;AAGR,SAAM,IAAI,SAAc,MAAK,WAAW,GAAG,MAAM,KAAK,QAAQ,CAAC;;;AAInE,OAAM"}
+{"version":3,"file":"_http-CHSsrWDJ.mjs","names":[],"sources":["../src/adapters/_config.ts","../src/adapters/_http.ts"],"sourcesContent":["import { getNitroRuntimeConfigRecord } from '../shared/nitroConfigBridge'\n\n/**\n * Adapter runtime-config reads go through `getNitroRuntimeConfigRecord` in\n * `shared/nitroConfigBridge.ts` (documented there — Workers-safe dynamic imports).\n *\n * Drain handlers remain non-blocking when the host provides `waitUntil`.\n */\n\nexport function getRuntimeConfig(): Promise<Record<string, any> | undefined> {\n  return getNitroRuntimeConfigRecord()\n}\n\nexport interface ConfigField<T> {\n  key: keyof T & string\n  env?: string[]\n}\n\nexport async function resolveAdapterConfig<T>(\n  namespace: string,\n  fields: ConfigField<T>[],\n  overrides?: Partial<T>,\n): Promise<Partial<T>> {\n  const runtimeConfig = await getRuntimeConfig()\n  const evlogNs = runtimeConfig?.evlog?.[namespace]\n  const rootNs = runtimeConfig?.[namespace]\n\n  const config: Record<string, unknown> = {}\n\n  for (const { key, env } of fields) {\n    config[key] =\n      overrides?.[key]\n      ?? evlogNs?.[key]\n      ?? rootNs?.[key]\n      ?? resolveEnv(env)\n  }\n\n  return config as Partial<T>\n}\n\nfunction resolveEnv(envKeys?: string[]): string | undefined {\n  if (!envKeys) return undefined\n  for (const key of envKeys) {\n    const val = process.env[key]\n    if (val) return val\n  }\n  return undefined\n}\n","export interface HttpPostOptions {\n  url: string\n  headers: Record<string, string>\n  body: string\n  timeout: number\n  label: string\n  retries?: number\n}\n\nfunction isRetryable(error: unknown): boolean {\n  if (error instanceof DOMException && error.name === 'AbortError') return true\n  if (error instanceof TypeError) return true\n  if (error instanceof Error) {\n    const match = error.message.match(/API error: (\\d+)/)\n    if (match) return Number.parseInt(match[1]) >= 500\n  }\n  return false\n}\n\nexport async function httpPost({ url, headers, body, timeout, label, retries = 2 }: HttpPostOptions): Promise<void> {\n  const normalizedRetries = Number.isFinite(retries) && retries >= 0 ? Math.floor(retries) : 2\n\n  let lastError: Error | undefined\n\n  for (let attempt = 0; attempt <= normalizedRetries; attempt++) {\n    const controller = new AbortController()\n    const timeoutId = setTimeout(() => controller.abort(), timeout)\n\n    try {\n      const response = await fetch(url, {\n        method: 'POST',\n        headers,\n        body,\n        signal: controller.signal,\n      })\n\n      if (!response.ok) {\n        const text = await response.text().catch(() => 'Unknown error')\n        const safeText = text.length > 200 ? `${text.slice(0, 200)}...[truncated]` : text\n        throw new Error(`${label} API error: ${response.status} ${response.statusText} - ${safeText}`)\n      }\n\n      clearTimeout(timeoutId)\n      return\n    } catch (error) {\n      clearTimeout(timeoutId)\n\n      if (error instanceof DOMException && error.name === 'AbortError') {\n        lastError = new Error(`${label} request timed out after ${timeout}ms`)\n      } else {\n        lastError = error as Error\n      }\n\n      if (!isRetryable(error) || attempt === normalizedRetries) {\n        throw lastError\n      }\n\n      await new Promise<void>(r => setTimeout(r, 200 * 2 ** attempt))\n    }\n  }\n\n  throw lastError!\n}\n"],"mappings":";;;;;;;;AASA,SAAgB,mBAA6D;AAC3E,QAAO,6BAA6B;;AAQtC,eAAsB,qBACpB,WACA,QACA,WACqB;CACrB,MAAM,gBAAgB,MAAM,kBAAkB;CAC9C,MAAM,UAAU,eAAe,QAAQ;CACvC,MAAM,SAAS,gBAAgB;CAE/B,MAAM,SAAkC,EAAE;AAE1C,MAAK,MAAM,EAAE,KAAK,SAAS,OACzB,QAAO,OACL,YAAY,QACT,UAAU,QACV,SAAS,QACT,WAAW,IAAI;AAGtB,QAAO;;AAGT,SAAS,WAAW,SAAwC;AAC1D,KAAI,CAAC,QAAS,QAAO,KAAA;AACrB,MAAK,MAAM,OAAO,SAAS;EACzB,MAAM,MAAM,QAAQ,IAAI;AACxB,MAAI,IAAK,QAAO;;;;;ACnCpB,SAAS,YAAY,OAAyB;AAC5C,KAAI,iBAAiB,gBAAgB,MAAM,SAAS,aAAc,QAAO;AACzE,KAAI,iBAAiB,UAAW,QAAO;AACvC,KAAI,iBAAiB,OAAO;EAC1B,MAAM,QAAQ,MAAM,QAAQ,MAAM,mBAAmB;AACrD,MAAI,MAAO,QAAO,OAAO,SAAS,MAAM,GAAG,IAAI;;AAEjD,QAAO;;AAGT,eAAsB,SAAS,EAAE,KAAK,SAAS,MAAM,SAAS,OAAO,UAAU,KAAqC;CAClH,MAAM,oBAAoB,OAAO,SAAS,QAAQ,IAAI,WAAW,IAAI,KAAK,MAAM,QAAQ,GAAG;CAE3F,IAAI;AAEJ,MAAK,IAAI,UAAU,GAAG,WAAW,mBAAmB,WAAW;EAC7D,MAAM,aAAa,IAAI,iBAAiB;EACxC,MAAM,YAAY,iBAAiB,WAAW,OAAO,EAAE,QAAQ;AAE/D,MAAI;GACF,MAAM,WAAW,MAAM,MAAM,KAAK;IAChC,QAAQ;IACR;IACA;IACA,QAAQ,WAAW;IACpB,CAAC;AAEF,OAAI,CAAC,SAAS,IAAI;IAChB,MAAM,OAAO,MAAM,SAAS,MAAM,CAAC,YAAY,gBAAgB;IAC/D,MAAM,WAAW,KAAK,SAAS,MAAM,GAAG,KAAK,MAAM,GAAG,IAAI,CAAC,kBAAkB;AAC7E,UAAM,IAAI,MAAM,GAAG,MAAM,cAAc,SAAS,OAAO,GAAG,SAAS,WAAW,KAAK,WAAW;;AAGhG,gBAAa,UAAU;AACvB;WACO,OAAO;AACd,gBAAa,UAAU;AAEvB,OAAI,iBAAiB,gBAAgB,MAAM,SAAS,aAClD,6BAAY,IAAI,MAAM,GAAG,MAAM,2BAA2B,QAAQ,IAAI;OAEtE,aAAY;AAGd,OAAI,CAAC,YAAY,MAAM,IAAI,YAAY,kBACrC,OAAM;AAGR,SAAM,IAAI,SAAc,MAAK,WAAW,GAAG,MAAM,KAAK,QAAQ,CAAC;;;AAInE,OAAM"}

package/dist/{_severity-BZhz3f9e.mjs → _severity-CQijvfhU.mjs}

@@ -14,4 +14,4 @@ const OTEL_SEVERITY_TEXT = {
 //#endregion
 export { OTEL_SEVERITY_TEXT as n, OTEL_SEVERITY_NUMBER as t };
 
-//# sourceMappingURL=_severity-BZhz3f9e.mjs.map
+//# sourceMappingURL=_severity-CQijvfhU.mjs.map

package/dist/{_severity-BZhz3f9e.mjs.map → _severity-CQijvfhU.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"_severity-BZhz3f9e.mjs","names":[],"sources":["../src/adapters/_severity.ts"],"sourcesContent":["import type { LogLevel } from '../types'\n\nexport const OTEL_SEVERITY_NUMBER: Record<LogLevel, number> = {\n  debug: 5,\n  info: 9,\n  warn: 13,\n  error: 17,\n}\n\nexport const OTEL_SEVERITY_TEXT: Record<LogLevel, string> = {\n  debug: 'DEBUG',\n  info: 'INFO',\n  warn: 'WARN',\n  error: 'ERROR',\n}\n"],"mappings":";AAEA,MAAa,uBAAiD;CAC5D,OAAO;CACP,MAAM;CACN,MAAM;CACN,OAAO;CACR;AAED,MAAa,qBAA+C;CAC1D,OAAO;CACP,MAAM;CACN,MAAM;CACN,OAAO;CACR"}
+{"version":3,"file":"_severity-CQijvfhU.mjs","names":[],"sources":["../src/adapters/_severity.ts"],"sourcesContent":["import type { LogLevel } from '../types'\n\nexport const OTEL_SEVERITY_NUMBER: Record<LogLevel, number> = {\n  debug: 5,\n  info: 9,\n  warn: 13,\n  error: 17,\n}\n\nexport const OTEL_SEVERITY_TEXT: Record<LogLevel, string> = {\n  debug: 'DEBUG',\n  info: 'INFO',\n  warn: 'WARN',\n  error: 'ERROR',\n}\n"],"mappings":";AAEA,MAAa,uBAAiD;CAC5D,OAAO;CACP,MAAM;CACN,MAAM;CACN,OAAO;CACR;AAED,MAAa,qBAA+C;CAC1D,OAAO;CACP,MAAM;CACN,MAAM;CACN,OAAO;CACR"}

package/dist/adapters/axiom.d.mts

@@ -1,4 +1,4 @@
-import { T as WideEvent, r as DrainContext } from "../types-v_JkG_D7.mjs";
+import { E as WideEvent, r as DrainContext } from "../types-D5OwxZCw.mjs";
 //#region src/adapters/axiom.d.ts
 interface BaseAxiomConfig {
   /** Axiom dataset name */

package/dist/adapters/axiom.mjs

@@ -1,5 +1,5 @@
-import { n as resolveAdapterConfig, t as httpPost } from "../_http-C_2wbJw3.mjs";
-import { t as defineDrain } from "../_drain-YH8ERc5l.mjs";
+import { n as resolveAdapterConfig, t as httpPost } from "../_http-CHSsrWDJ.mjs";
+import { t as defineDrain } from "../_drain-CmCtsuF6.mjs";
 //#region src/adapters/axiom.ts
 const AXIOM_FIELDS = [
 	{

package/dist/adapters/better-stack.d.mts

@@ -1,4 +1,4 @@
-import { T as WideEvent, r as DrainContext } from "../types-v_JkG_D7.mjs";
+import { E as WideEvent, r as DrainContext } from "../types-D5OwxZCw.mjs";
 //#region src/adapters/better-stack.d.ts
 interface BetterStackConfig {
   /** Better Stack source token */

package/dist/adapters/better-stack.mjs

@@ -1,5 +1,5 @@
-import { n as resolveAdapterConfig, t as httpPost } from "../_http-C_2wbJw3.mjs";
-import { t as defineDrain } from "../_drain-YH8ERc5l.mjs";
+import { n as resolveAdapterConfig, t as httpPost } from "../_http-CHSsrWDJ.mjs";
+import { t as defineDrain } from "../_drain-CmCtsuF6.mjs";
 //#region src/adapters/better-stack.ts
 const BETTER_STACK_FIELDS = [
 	{

package/dist/adapters/datadog.d.mts

@@ -1,4 +1,4 @@
-import { T as WideEvent, r as DrainContext } from "../types-v_JkG_D7.mjs";
+import { E as WideEvent, r as DrainContext } from "../types-D5OwxZCw.mjs";
 //#region src/adapters/datadog.d.ts
 interface DatadogConfig {
   /** Datadog API key with Logs intake permission */

package/dist/adapters/datadog.mjs

@@ -1,5 +1,5 @@
-import { n as resolveAdapterConfig, t as httpPost } from "../_http-C_2wbJw3.mjs";
-import { t as defineDrain } from "../_drain-YH8ERc5l.mjs";
+import { n as resolveAdapterConfig, t as httpPost } from "../_http-CHSsrWDJ.mjs";
+import { t as defineDrain } from "../_drain-CmCtsuF6.mjs";
 //#region src/adapters/datadog.ts
 const DATADOG_FIELDS = [
 	{

package/dist/adapters/fs.d.mts

@@ -1,4 +1,4 @@
-import { T as WideEvent, r as DrainContext } from "../types-v_JkG_D7.mjs";
+import { E as WideEvent, r as DrainContext } from "../types-D5OwxZCw.mjs";
 //#region src/adapters/fs.d.ts
 interface FsConfig {
   /** Directory for log files */

package/dist/adapters/fs.mjs

@@ -1,4 +1,4 @@
-import { t as defineDrain } from "../_drain-YH8ERc5l.mjs";
+import { t as defineDrain } from "../_drain-CmCtsuF6.mjs";
 import { join, sep } from "node:path";
 import { appendFile, mkdir, readdir, stat, unlink, writeFile } from "node:fs/promises";
 //#region src/adapters/fs.ts

package/dist/adapters/hyperdx.d.mts

@@ -1,4 +1,4 @@
-import { T as WideEvent, r as DrainContext } from "../types-v_JkG_D7.mjs";
+import { E as WideEvent, r as DrainContext } from "../types-D5OwxZCw.mjs";
 import { OTLPConfig } from "./otlp.mjs";
 
 //#region src/adapters/hyperdx.d.ts

package/dist/adapters/hyperdx.mjs

@@ -1,5 +1,5 @@
-import { n as resolveAdapterConfig } from "../_http-C_2wbJw3.mjs";
-import { t as defineDrain } from "../_drain-YH8ERc5l.mjs";
+import { n as resolveAdapterConfig } from "../_http-CHSsrWDJ.mjs";
+import { t as defineDrain } from "../_drain-CmCtsuF6.mjs";
 import { sendBatchToOTLP } from "./otlp.mjs";
 //#region src/adapters/hyperdx.ts
 /**

package/dist/adapters/otlp.d.mts

@@ -1,4 +1,4 @@
-import { T as WideEvent, r as DrainContext } from "../types-v_JkG_D7.mjs";
+import { E as WideEvent, r as DrainContext } from "../types-D5OwxZCw.mjs";
 //#region src/adapters/otlp.d.ts
 interface OTLPConfig {
   /** OTLP HTTP endpoint (e.g., http://localhost:4318) */

package/dist/adapters/otlp.mjs

@@ -1,6 +1,6 @@
-import { n as resolveAdapterConfig, t as httpPost } from "../_http-C_2wbJw3.mjs";
-import { t as defineDrain } from "../_drain-YH8ERc5l.mjs";
-import { n as OTEL_SEVERITY_TEXT, t as OTEL_SEVERITY_NUMBER } from "../_severity-BZhz3f9e.mjs";
+import { n as resolveAdapterConfig, t as httpPost } from "../_http-CHSsrWDJ.mjs";
+import { t as defineDrain } from "../_drain-CmCtsuF6.mjs";
+import { n as OTEL_SEVERITY_TEXT, t as OTEL_SEVERITY_NUMBER } from "../_severity-CQijvfhU.mjs";
 //#region src/adapters/otlp.ts
 const OTLP_FIELDS = [
 	{

package/dist/adapters/posthog.d.mts

@@ -1,4 +1,4 @@
-import { T as WideEvent, r as DrainContext } from "../types-v_JkG_D7.mjs";
+import { E as WideEvent, r as DrainContext } from "../types-D5OwxZCw.mjs";
 //#region src/adapters/posthog.d.ts
 interface PostHogConfig {
   /** PostHog project API key */

package/dist/adapters/posthog.mjs

@@ -1,5 +1,5 @@
-import { n as resolveAdapterConfig, t as httpPost } from "../_http-C_2wbJw3.mjs";
-import { t as defineDrain } from "../_drain-YH8ERc5l.mjs";
+import { n as resolveAdapterConfig, t as httpPost } from "../_http-CHSsrWDJ.mjs";
+import { t as defineDrain } from "../_drain-CmCtsuF6.mjs";
 import { sendBatchToOTLP } from "./otlp.mjs";
 //#region src/adapters/posthog.ts
 const POSTHOG_FIELDS = [

package/dist/adapters/sentry.d.mts

@@ -1,4 +1,4 @@
-import { T as WideEvent, r as DrainContext } from "../types-v_JkG_D7.mjs";
+import { E as WideEvent, r as DrainContext } from "../types-D5OwxZCw.mjs";
 //#region src/adapters/sentry.d.ts
 interface SentryConfig {
   /** Sentry DSN */

package/dist/adapters/sentry.mjs

@@ -1,6 +1,6 @@
-import { n as resolveAdapterConfig, t as httpPost } from "../_http-C_2wbJw3.mjs";
-import { t as defineDrain } from "../_drain-YH8ERc5l.mjs";
-import { t as OTEL_SEVERITY_NUMBER } from "../_severity-BZhz3f9e.mjs";
+import { n as resolveAdapterConfig, t as httpPost } from "../_http-CHSsrWDJ.mjs";
+import { t as defineDrain } from "../_drain-CmCtsuF6.mjs";
+import { t as OTEL_SEVERITY_NUMBER } from "../_severity-CQijvfhU.mjs";
 //#region src/adapters/sentry.ts
 const SENTRY_FIELDS = [
 	{

package/dist/ai/index.d.mts

@@ -1,5 +1,5 @@
-import { g as RequestLogger } from "../types-v_JkG_D7.mjs";
-import { GatewayModelId } from "ai";
+import { _ as RequestLogger } from "../types-D5OwxZCw.mjs";
+import { GatewayModelId, TelemetryIntegration } from "ai";
 import { LanguageModelV3, LanguageModelV3Middleware } from "@ai-sdk/provider";
 
 //#region src/ai/index.d.ts
@@ -19,6 +19,13 @@ interface ToolInputsOptions {
    */
   transform?: (input: unknown, toolName: string) => unknown;
 }
+/**
+ * Pricing entry for a single model: cost per 1 million tokens in dollars.
+ */
+interface ModelCost {
+  input: number;
+  output: number;
+}
 /**
  * Options for `createAILogger` and `createAIMiddleware`.
  */
@@ -32,6 +39,24 @@ interface AILoggerOptions {
    * @default false
    */
   toolInputs?: boolean | ToolInputsOptions;
+  /**
+   * Pricing map for estimating request cost.
+   * Keys are model IDs (e.g. `'claude-sonnet-4.6'`, `'gpt-4o'`), values are
+   * `{ input, output }` in dollars per 1M tokens.
+   *
+   * When provided, the wide event includes `ai.estimatedCost` (in dollars).
+   *
+   * @example
+   * ```ts
+   * const ai = createAILogger(log, {
+   *   cost: {
+   *     'claude-sonnet-4.6': { input: 3, output: 15 },
+   *     'gpt-4o': { input: 2.5, output: 10 },
+   *   },
+   * })
+   * ```
+   */
+  cost?: Record<string, ModelCost>;
 }
 /**
  * Per-step token usage breakdown for multi-step agent runs.
@@ -42,6 +67,24 @@ interface AIStepUsage {
   outputTokens: number;
   toolCalls?: string[];
 }
+/**
+ * Tool execution detail captured via `TelemetryIntegration`.
+ */
+interface AIToolExecution {
+  name: string;
+  durationMs: number;
+  success: boolean;
+  error?: string;
+}
+/**
+ * Embedding metadata captured via `captureEmbed`.
+ */
+interface AIEmbeddingData {
+  model?: string;
+  tokens: number;
+  dimensions?: number;
+  count?: number;
+}
 /**
  * Shape of the `ai` field written to the wide event.
  */
@@ -68,12 +111,16 @@ interface AIEventData {
   msToFinish?: number;
   tokensPerSecond?: number;
   error?: string;
+  tools?: AIToolExecution[];
+  totalDurationMs?: number;
+  embedding?: AIEmbeddingData;
+  estimatedCost?: number;
 }
 interface AILogger {
   /**
    * Wrap a language model with evlog middleware.
-   * All `generateText`, `streamText`, `generateObject`, and `streamObject` calls
-   * using the wrapped model are captured automatically into the wide event.
+   * All `generateText` and `streamText` calls using the wrapped model
+   * are captured automatically into the wide event.
    *
    * Accepts a `LanguageModelV3` object or a model string (e.g. `'anthropic/claude-sonnet-4.6'`).
    * Strings are resolved via the AI SDK gateway.
@@ -100,13 +147,34 @@ interface AILogger {
    * ```ts
    * const { embedding, usage } = await embed({ model: embeddingModel, value: query })
    * ai.captureEmbed({ usage })
+   *
+   * // With model info (v2)
+   * ai.captureEmbed({ usage, model: 'text-embedding-3-small', dimensions: 1536 })
+   *
+   * // After embedMany
+   * ai.captureEmbed({ usage, count: texts.length })
    * ```
    */
   captureEmbed: (result: {
     usage: {
       tokens: number;
     };
+    model?: string;
+    dimensions?: number;
+    count?: number;
   }) => void;
+  /**
+   * Internal accumulator state exposed for `createEvlogIntegration` to share.
+   * @internal
+   */
+  _state: AccumulatorState;
+}
+interface UsageAccumulator {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  reasoningTokens: number;
 }
 /**
  * Create the evlog AI middleware that captures AI SDK data into a wide event.
@@ -160,6 +228,77 @@ declare function createAIMiddleware(log: RequestLogger, options?: AILoggerOption
  * ```
  */
 declare function createAILogger(log: RequestLogger, options?: AILoggerOptions): AILogger;
+interface AccumulatorState {
+  calls: number;
+  steps: number;
+  usage: UsageAccumulator;
+  models: string[];
+  lastProvider: string | undefined;
+  allToolCalls: string[];
+  allToolCallInputs: Array<{
+    name: string;
+    input: unknown;
+  }>;
+  stepsUsage: AIStepUsage[];
+  lastFinishReason: string | undefined;
+  lastMsToFirstChunk: number | undefined;
+  lastMsToFinish: number | undefined;
+  lastError: string | undefined;
+  lastResponseId: string | undefined;
+  toolInputs: boolean;
+  toolInputsOptions: ToolInputsOptions | undefined;
+  toolExecutions: AIToolExecution[];
+  generationStartTime: number | undefined;
+  totalDurationMs: number | undefined;
+  embedding: AIEmbeddingData | undefined;
+  costMap: Record<string, ModelCost> | undefined;
+  /** @internal Logger reference for integration flush */
+  _log?: RequestLogger;
+}
+/**
+ * Create an AI SDK `TelemetryIntegration` that captures tool execution
+ * timing, errors, and total generation wall time into the wide event.
+ *
+ * Complements the middleware-based `createAILogger`: the middleware captures
+ * token usage and streaming metrics at the model level, while the integration
+ * captures application-level lifecycle events (tool execution, total duration).
+ *
+ * When passed an `AILogger`, shares its accumulator so both paths write to
+ * the same `ai.*` field. Can also be used standalone with a `RequestLogger`.
+ *
+ * @example Combined with middleware (recommended)
+ * ```ts
+ * import { createAILogger, createEvlogIntegration } from 'evlog/ai'
+ *
+ * const log = useLogger(event)
+ * const ai = createAILogger(log)
+ *
+ * const result = await generateText({
+ *   model: ai.wrap('anthropic/claude-sonnet-4.6'),
+ *   tools: { getWeather },
+ *   experimental_telemetry: {
+ *     isEnabled: true,
+ *     integrations: [createEvlogIntegration(ai)],
+ *   },
+ * })
+ * ```
+ *
+ * @example Standalone (no middleware wrapping)
+ * ```ts
+ * import { createEvlogIntegration } from 'evlog/ai'
+ *
+ * const integration = createEvlogIntegration(log)
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   experimental_telemetry: {
+ *     isEnabled: true,
+ *     integrations: [integration],
+ *   },
+ * })
+ * ```
+ */
+declare function createEvlogIntegration(logOrAi: RequestLogger | AILogger, options?: AILoggerOptions): TelemetryIntegration;
 //#endregion
-export { AIEventData, AILogger, AILoggerOptions, AIStepUsage, ToolInputsOptions, createAILogger, createAIMiddleware };
+export { AIEmbeddingData, AIEventData, AILogger, AILoggerOptions, AIStepUsage, AIToolExecution, ModelCost, ToolInputsOptions, createAILogger, createAIMiddleware, createEvlogIntegration };
 //# sourceMappingURL=index.d.mts.map

package/dist/ai/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/ai/index.ts"],"mappings":";;;;;;;AAQA;UAAiB,iBAAA;;;;;EAKf,SAAA;EAM6B;;;AAM/B;;EANE,SAAA,IAAa,KAAA,WAAgB,QAAA;AAAA;;AAqB/B;;UAfiB,eAAA;EAeW;;;;;;;AAU5B;EAhBE,UAAA,aAAuB,iBAAA;AAAA;;;;UAMR,WAAA;EACf,KAAA;EACA,WAAA;EACA,YAAA;EACA,SAAA;AAAA;;;;UAMe,WAAA;EACf,KAAA;EACA,KAAA;EACA,MAAA;EACA,QAAA;EACA,WAAA;EACA,YAAA;EACA,WAAA;EACA,eAAA;EACA,gBAAA;EACA,eAAA;EACA,YAAA;EACA,SAAA,cAAuB,KAAA;IAAQ,IAAA;IAAc,KAAA;EAAA;EAC7C,UAAA;EACA,KAAA;EACA,UAAA,GAAa,WAAA;EACb,cAAA;EACA,UAAA;EACA,eAAA;EACA,KAAA;AAAA;AAAA,UAGe,QAAA;EAqBR;;;;;;;;AA8ET;;;;;;;;;;;;EA9EE,IAAA,GAAO,KAAA,EAAO,eAAA,GAAkB,cAAA,KAAmB,eAAA;EA8EuD;;AA8B5G;;;;;;;;;EA/FE,YAAA,GAAe,MAAA;IAAU,KAAA;MAAS,MAAA;IAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEpB,kBAAA,CAAmB,GAAA,EAAK,aAAA,EAAe,OAAA,GAAU,eAAA,GAAkB,yBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BnE,cAAA,CAAe,GAAA,EAAK,aAAA,EAAe,OAAA,GAAU,eAAA,GAAkB,QAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/ai/index.ts"],"mappings":";;;;;;;AAQA;UAAiB,iBAAA;;;;;EAKf,SAAA;EAM6B;;;AAM/B;;EANE,SAAA,IAAa,KAAA,WAAgB,QAAA;AAAA;;AAc/B;;UARiB,SAAA;EACf,KAAA;EACA,MAAA;AAAA;;;;UAMe,eAAA;EA2Bf;;;;;AAMF;;;EAxBE,UAAA,aAAuB,iBAAA;EAyBvB;;;;;;AASF;;;;;;;;;;AAUA;EA1BE,IAAA,GAAO,MAAA,SAAe,SAAA;AAAA;;;;UAMP,WAAA;EACf,KAAA;EACA,WAAA;EACA,YAAA;EACA,SAAA;AAAA;;;;UAMe,eAAA;EACf,IAAA;EACA,UAAA;EACA,OAAA;EACA,KAAA;AAAA;;;;UAMe,eAAA;EACf,KAAA;EACA,MAAA;EACA,UAAA;EACA,KAAA;AAAA;;;;UAMe,WAAA;EACf,KAAA;EACA,KAAA;EACA,MAAA;EACA,QAAA;EACA,WAAA;EACA,YAAA;EACA,WAAA;EACA,eAAA;EACA,gBAAA;EACA,eAAA;EACA,YAAA;EACA,SAAA,cAAuB,KAAA;IAAQ,IAAA;IAAc,KAAA;EAAA;EAC7C,UAAA;EACA,KAAA;EACA,UAAA,GAAa,WAAA;EACb,cAAA;EACA,UAAA;EACA,eAAA;EACA,KAAA;EACA,KAAA,GAAQ,eAAA;EACR,eAAA;EACA,SAAA,GAAY,eAAA;EACZ,aAAA;AAAA;AAAA,UAGe,QAAA;EAqBR;;;;;;;;;;;;;AA+BR;;;;;;;EA/BC,IAAA,GAAO,KAAA,EAAO,eAAA,GAAkB,cAAA,KAAmB,eAAA;EAsCnD;;;AAyDF;;;;;;;;;;;;;;EA5EE,YAAA,GAAe,MAAA;IACb,KAAA;MAAS,MAAA;IAAA;IACT,KAAA;IACA,UAAA;IACA,KAAA;EAAA;EAsGmF;;;;EA/FrF,MAAA,EAAQ,gBAAA;AAAA;AAAA,UAGA,gBAAA;EACR,WAAA;EACA,YAAA;EACA,eAAA;EACA,gBAAA;EACA,eAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDc,kBAAA,CAAmB,GAAA,EAAK,aAAA,EAAe,OAAA,GAAU,eAAA,GAAkB,yBAAA;;;;;;;;;;;;;;;;;;;AAocnF;;;;;;;;iBAtagB,cAAA,CAAe,GAAA,EAAK,aAAA,EAAe,OAAA,GAAU,eAAA,GAAkB,QAAA;AAAA,UAgCrE,gBAAA;EACR,KAAA;EACA,KAAA;EACA,KAAA,EAAO,gBAAA;EACP,MAAA;EACA,YAAA;EACA,YAAA;EACA,iBAAA,EAAmB,KAAA;IAAQ,IAAA;IAAc,KAAA;EAAA;EACzC,UAAA,EAAY,WAAA;EACZ,gBAAA;EACA,kBAAA;EACA,cAAA;EACA,SAAA;EACA,cAAA;EACA,UAAA;EACA,iBAAA,EAAmB,iBAAA;EACnB,cAAA,EAAgB,eAAA;EAChB,mBAAA;EACA,eAAA;EACA,SAAA,EAAW,eAAA;EACX,OAAA,EAAS,MAAA,SAAe,SAAA;;EAExB,IAAA,GAAO,aAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgXO,sBAAA,CACd,OAAA,EAAS,aAAA,GAAgB,QAAA,EACzB,OAAA,GAAU,eAAA,GACT,oBAAA"}

package/dist/ai/index.mjs

@@ -1,4 +1,4 @@
-import { gateway, wrapLanguageModel } from "ai";
+import { bindTelemetryIntegration, gateway, wrapLanguageModel } from "ai";
 //#region src/ai/index.ts
 function addUsage(acc, usage) {
 	acc.inputTokens += usage.inputTokens.total ?? 0;
@@ -78,6 +78,7 @@ function createAIMiddleware(log, options) {
 */
 function createAILogger(log, options) {
 	const state = createAccumulatorState(options);
+	state._log = log;
 	const middleware = buildMiddlewareFromState(log, state);
 	return {
 		wrap: (model) => {
@@ -89,8 +90,15 @@ function createAILogger(log, options) {
 		captureEmbed: (result) => {
 			state.calls++;
 			state.usage.inputTokens += result.usage.tokens;
+			state.embedding = {
+				tokens: (state.embedding?.tokens ?? 0) + result.usage.tokens,
+				...result.model ? { model: result.model } : state.embedding?.model ? { model: state.embedding.model } : {},
+				...result.dimensions ? { dimensions: result.dimensions } : state.embedding?.dimensions ? { dimensions: state.embedding.dimensions } : {},
+				...result.count ? { count: (state.embedding?.count ?? 0) + result.count } : state.embedding?.count ? { count: state.embedding.count } : {}
+			};
 			flushState(log, state);
-		}
+		},
+		_state: state
 	};
 }
 function resolveToolInputs(raw) {
@@ -139,9 +147,23 @@ function createAccumulatorState(options) {
 		lastError: void 0,
 		lastResponseId: void 0,
 		toolInputs: enabled,
-		toolInputsOptions: captureOpts
+		toolInputsOptions: captureOpts,
+		toolExecutions: [],
+		generationStartTime: void 0,
+		totalDurationMs: void 0,
+		embedding: void 0,
+		costMap: options?.cost
 	};
 }
+function computeEstimatedCost(state) {
+	if (!state.costMap) return void 0;
+	const lastModel = state.models[state.models.length - 1];
+	if (!lastModel) return void 0;
+	const pricing = state.costMap[lastModel];
+	if (!pricing) return void 0;
+	const total = state.usage.inputTokens / 1e6 * pricing.input + state.usage.outputTokens / 1e6 * pricing.output;
+	return total > 0 ? Math.round(total * 1e6) / 1e6 : void 0;
+}
 function flushState(log, state) {
 	const uniqueModels = [...new Set(state.models)];
 	const lastModel = state.models[state.models.length - 1];
@@ -171,6 +193,11 @@ function flushState(log, state) {
 		if (state.usage.outputTokens > 0 && state.lastMsToFinish > 0) data.tokensPerSecond = Math.round(state.usage.outputTokens / state.lastMsToFinish * 1e3);
 	}
 	if (state.lastError) data.error = state.lastError;
+	if (state.toolExecutions.length > 0) data.tools = [...state.toolExecutions];
+	if (state.totalDurationMs !== void 0) data.totalDurationMs = state.totalDurationMs;
+	if (state.embedding) data.embedding = { ...state.embedding };
+	const cost = computeEstimatedCost(state);
+	if (cost !== void 0) data.estimatedCost = cost;
 	log.set({ ai: data });
 }
 function recordModel(state, provider, modelId, responseModelId) {
@@ -200,7 +227,9 @@ function recordError(log, state, model, error) {
 	flushState(log, state);
 }
 function buildMiddleware(log, options) {
-	return buildMiddlewareFromState(log, createAccumulatorState(options));
+	const state = createAccumulatorState(options);
+	state._log = log;
+	return buildMiddlewareFromState(log, state);
 }
 function buildMiddlewareFromState(log, state) {
 	return {
@@ -334,7 +363,81 @@ function buildMiddlewareFromState(log, state) {
 		}
 	};
 }
+/**
+* Create an AI SDK `TelemetryIntegration` that captures tool execution
+* timing, errors, and total generation wall time into the wide event.
+*
+* Complements the middleware-based `createAILogger`: the middleware captures
+* token usage and streaming metrics at the model level, while the integration
+* captures application-level lifecycle events (tool execution, total duration).
+*
+* When passed an `AILogger`, shares its accumulator so both paths write to
+* the same `ai.*` field. Can also be used standalone with a `RequestLogger`.
+*
+* @example Combined with middleware (recommended)
+* ```ts
+* import { createAILogger, createEvlogIntegration } from 'evlog/ai'
+*
+* const log = useLogger(event)
+* const ai = createAILogger(log)
+*
+* const result = await generateText({
+*   model: ai.wrap('anthropic/claude-sonnet-4.6'),
+*   tools: { getWeather },
+*   experimental_telemetry: {
+*     isEnabled: true,
+*     integrations: [createEvlogIntegration(ai)],
+*   },
+* })
+* ```
+*
+* @example Standalone (no middleware wrapping)
+* ```ts
+* import { createEvlogIntegration } from 'evlog/ai'
+*
+* const integration = createEvlogIntegration(log)
+*
+* const result = await generateText({
+*   model: openai('gpt-4o'),
+*   experimental_telemetry: {
+*     isEnabled: true,
+*     integrations: [integration],
+*   },
+* })
+* ```
+*/
+function createEvlogIntegration(logOrAi, options) {
+	let log;
+	let state;
+	if ("_state" in logOrAi && logOrAi._state) {
+		state = logOrAi._state;
+		log = state._log;
+	} else {
+		log = logOrAi;
+		state = createAccumulatorState(options);
+		state._log = log;
+	}
+	class EvlogIntegration {
+		onStart(_event) {
+			state.generationStartTime = Date.now();
+		}
+		onToolCallFinish(event) {
+			const execution = {
+				name: event.toolCall.toolName,
+				durationMs: event.durationMs,
+				success: event.success
+			};
+			if (!event.success && event.error) execution.error = event.error instanceof Error ? event.error.message : String(event.error);
+			state.toolExecutions.push(execution);
+		}
+		onFinish(_event) {
+			if (state.generationStartTime) state.totalDurationMs = Date.now() - state.generationStartTime;
+			flushState(log, state);
+		}
+	}
+	return bindTelemetryIntegration(new EvlogIntegration());
+}
 //#endregion
-export { createAILogger, createAIMiddleware };
+export { createAILogger, createAIMiddleware, createEvlogIntegration };
 
 //# sourceMappingURL=index.mjs.map