evlog 2.8.0 → 2.9.0

package/README.md

@@ -464,6 +464,33 @@ Use `useLogger()` to access the logger from anywhere in the call stack.
 
 See the full [elysia example](https://github.com/HugoRCD/evlog/tree/main/examples/elysia) for a complete working project.
 
+## React Router
+
+```typescript
+// app/root.tsx
+import { initLogger } from 'evlog'
+import { evlog, loggerContext } from 'evlog/react-router'
+
+initLogger({ env: { service: 'react-router-api' } })
+
+export const middleware: Route.MiddlewareFunction[] = [
+  evlog(),
+]
+
+// app/routes/api.users.$id.tsx
+import { loggerContext } from 'evlog/react-router'
+
+export async function loader({ params, context }: Route.LoaderArgs) {
+  const log = context.get(loggerContext)
+  log.set({ users: { count: 42 } })
+  return { users: [] }
+}
+```
+
+Use `context.get(loggerContext)` in loaders/actions, or `useLogger()` from anywhere in the call stack. Requires `v8_middleware: true` in `react-router.config.ts`.
+
+See the full [react-router example](https://github.com/HugoRCD/evlog/tree/main/examples/react-router) for a complete working project.
+
 ## NestJS
 
 ```typescript
@@ -1095,6 +1122,7 @@ try {
 | **Nitro v3** | `modules: [evlog()]` with `import evlog from 'evlog/nitro/v3'` |
 | **Nitro v2** | `modules: [evlog()]` with `import evlog from 'evlog/nitro'` |
 | **TanStack Start** | Nitro v3 module setup ([example](./examples/tanstack-start)) |
+| **React Router** | `evlog()` middleware with `import { evlog } from 'evlog/react-router'` ([example](./examples/react-router)) |
 | **NestJS** | `EvlogModule.forRoot()` with `import { EvlogModule } from 'evlog/nestjs'` ([example](./examples/nestjs)) |
 | **Express** | `app.use(evlog())` with `import { evlog } from 'evlog/express'` ([example](./examples/express)) |
 | **Hono** | `app.use(evlog())` with `import { evlog } from 'evlog/hono'` ([example](./examples/hono)) |

package/dist/adapters/axiom.d.mts

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

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

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

package/dist/adapters/fs.d.mts

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

package/dist/adapters/otlp.d.mts

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

package/dist/adapters/posthog.d.mts

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

package/dist/adapters/sentry.d.mts

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

package/dist/ai/index.d.mts

@@ -1,8 +1,47 @@
-import { g as RequestLogger } from "../types-CBpJBj_7.mjs";
+import { g as RequestLogger } from "../types-BpsDbwHU.mjs";
 import { GatewayModelId } from "ai";
-import { LanguageModelV3 } from "@ai-sdk/provider";
+import { LanguageModelV3, LanguageModelV3Middleware } from "@ai-sdk/provider";
 
 //#region src/ai/index.d.ts
+/**
+ * Fine-grained control over tool call input capture.
+ */
+interface ToolInputsOptions {
+  /**
+   * Max character length for the stringified input JSON.
+   * Inputs exceeding this limit are truncated with a `…` suffix.
+   */
+  maxLength?: number;
+  /**
+   * Custom transform applied to each captured input before storing.
+   * Receives the parsed input and tool name; return value is stored.
+   * Runs before `maxLength` truncation.
+   */
+  transform?: (input: unknown, toolName: string) => unknown;
+}
+/**
+ * Options for `createAILogger` and `createAIMiddleware`.
+ */
+interface AILoggerOptions {
+  /**
+   * When enabled, `toolCalls` contains `{ name, input }` objects instead of plain tool name strings.
+   * Opt-in because inputs can be large and may contain sensitive data.
+   *
+   * - `true` — capture all inputs as-is
+   * - `{ maxLength, transform }` — capture with truncation or custom transform
+   * @default false
+   */
+  toolInputs?: boolean | ToolInputsOptions;
+}
+/**
+ * Per-step token usage breakdown for multi-step agent runs.
+ */
+interface AIStepUsage {
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  toolCalls?: string[];
+}
 /**
  * Shape of the `ai` field written to the wide event.
  */
@@ -18,8 +57,13 @@ interface AIEventData {
   cacheWriteTokens?: number;
   reasoningTokens?: number;
   finishReason?: string;
-  toolCalls?: string[];
+  toolCalls?: string[] | Array<{
+    name: string;
+    input: unknown;
+  }>;
+  responseId?: string;
   steps?: number;
+  stepsUsage?: AIStepUsage[];
   msToFirstChunk?: number;
   msToFinish?: number;
   tokensPerSecond?: number;
@@ -34,6 +78,9 @@ interface AILogger {
    * Accepts a `LanguageModelV3` object or a model string (e.g. `'anthropic/claude-sonnet-4.6'`).
    * Strings are resolved via the AI SDK gateway.
    *
+   * Also works with pre-wrapped models (e.g. from supermemory, guardrails):
+   * `ai.wrap(withSupermemory(base, orgId))` composes correctly.
+   *
    * @example
    * ```ts
    * const ai = createAILogger(log)
@@ -61,6 +108,31 @@ interface AILogger {
     };
   }) => void;
 }
+/**
+ * Create the evlog AI middleware that captures AI SDK data into a wide event.
+ *
+ * Use this when you need explicit middleware composition with other wrappers
+ * (e.g. supermemory, guardrails). For most cases, use `createAILogger` instead.
+ *
+ * Note: `captureEmbed` is not available with the raw middleware — use
+ * `createAILogger` if you need embedding capture.
+ *
+ * @example Nuxt API route with supermemory
+ * ```ts
+ * import { createAIMiddleware } from 'evlog/ai'
+ * import { wrapLanguageModel } from 'ai'
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const log = useLogger(event)
+ *
+ *   const model = wrapLanguageModel({
+ *     model: withSupermemory(base, orgId),
+ *     middleware: [createAIMiddleware(log, { toolInputs: true })],
+ *   })
+ * })
+ * ```
+ */
+declare function createAIMiddleware(log: RequestLogger, options?: AILoggerOptions): LanguageModelV3Middleware;
 /**
  * Create an AI logger that captures AI SDK data into the wide event.
  *
@@ -81,8 +153,13 @@ interface AILogger {
  *   onFinish: ({ text }) => saveConversation(text),
  * })
  * ```
+ *
+ * @example Capture tool call inputs
+ * ```ts
+ * const ai = createAILogger(log, { toolInputs: true })
+ * ```
  */
-declare function createAILogger(log: RequestLogger): AILogger;
+declare function createAILogger(log: RequestLogger, options?: AILoggerOptions): AILogger;
 //#endregion
-export { AIEventData, AILogger, createAILogger };
+export { AIEventData, AILogger, AILoggerOptions, AIStepUsage, ToolInputsOptions, createAILogger, createAIMiddleware };
 //# 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,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;EACA,KAAA;EACA,cAAA;EACA,UAAA;EACA,eAAA;EACA,KAAA;AAAA;AAAA,UAGe,QAAA;EAHV;;AAGP;;;;;;;;;;;;;;;EAkBE,IAAA,GAAO,KAAA,EAAO,eAAA,GAAkB,cAAA,KAAmB,eAAA;EAapC;;;AA8DjB;;;;;;;;EA9DE,YAAA,GAAe,MAAA;IAAU,KAAA;MAAS,MAAA;IAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;iBA8DpB,cAAA,CAAe,GAAA,EAAK,aAAA,GAAgB,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;;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"}

package/dist/ai/index.mjs

@@ -24,6 +24,33 @@ function resolveProviderAndModel(provider, modelId) {
 	};
 }
 /**
+* Create the evlog AI middleware that captures AI SDK data into a wide event.
+*
+* Use this when you need explicit middleware composition with other wrappers
+* (e.g. supermemory, guardrails). For most cases, use `createAILogger` instead.
+*
+* Note: `captureEmbed` is not available with the raw middleware — use
+* `createAILogger` if you need embedding capture.
+*
+* @example Nuxt API route with supermemory
+* ```ts
+* import { createAIMiddleware } from 'evlog/ai'
+* import { wrapLanguageModel } from 'ai'
+*
+* export default defineEventHandler(async (event) => {
+*   const log = useLogger(event)
+*
+*   const model = wrapLanguageModel({
+*     model: withSupermemory(base, orgId),
+*     middleware: [createAIMiddleware(log, { toolInputs: true })],
+*   })
+* })
+* ```
+*/
+function createAIMiddleware(log, options) {
+	return buildMiddleware(log, options);
+}
+/**
 * Create an AI logger that captures AI SDK data into the wide event.
 *
 * Uses model middleware (`wrapLanguageModel`) to transparently intercept
@@ -43,75 +70,173 @@ function resolveProviderAndModel(provider, modelId) {
 *   onFinish: ({ text }) => saveConversation(text),
 * })
 * ```
+*
+* @example Capture tool call inputs
+* ```ts
+* const ai = createAILogger(log, { toolInputs: true })
+* ```
 */
-function createAILogger(log) {
-	let calls = 0;
-	let steps = 0;
-	const usage = {
-		inputTokens: 0,
-		outputTokens: 0,
-		cacheReadTokens: 0,
-		cacheWriteTokens: 0,
-		reasoningTokens: 0
-	};
-	const models = [];
-	const providers = [];
-	const allToolCalls = [];
-	let lastFinishReason;
-	let lastMsToFirstChunk;
-	let lastMsToFinish;
-	let lastError;
-	function flush() {
-		const uniqueModels = [...new Set(models)];
-		const lastModel = models[models.length - 1];
-		const lastProvider = providers[providers.length - 1];
-		const data = {
-			calls,
-			inputTokens: usage.inputTokens,
-			outputTokens: usage.outputTokens,
-			totalTokens: usage.inputTokens + usage.outputTokens
-		};
-		if (lastModel) data.model = lastModel;
-		if (lastProvider) data.provider = lastProvider;
-		if (uniqueModels.length > 1) data.models = uniqueModels;
-		if (usage.cacheReadTokens > 0) data.cacheReadTokens = usage.cacheReadTokens;
-		if (usage.cacheWriteTokens > 0) data.cacheWriteTokens = usage.cacheWriteTokens;
-		if (usage.reasoningTokens > 0) data.reasoningTokens = usage.reasoningTokens;
-		if (lastFinishReason) data.finishReason = lastFinishReason;
-		if (allToolCalls.length > 0) data.toolCalls = [...allToolCalls];
-		if (steps > 1) data.steps = steps;
-		if (lastMsToFirstChunk !== void 0) data.msToFirstChunk = lastMsToFirstChunk;
-		if (lastMsToFinish !== void 0) {
-			data.msToFinish = lastMsToFinish;
-			if (usage.outputTokens > 0 && lastMsToFinish > 0) data.tokensPerSecond = Math.round(usage.outputTokens / lastMsToFinish * 1e3);
+function createAILogger(log, options) {
+	const state = createAccumulatorState(options);
+	const middleware = buildMiddlewareFromState(log, state);
+	return {
+		wrap: (model) => {
+			return wrapLanguageModel({
+				model: typeof model === "string" ? gateway(model) : model,
+				middleware
+			});
+		},
+		captureEmbed: (result) => {
+			state.calls++;
+			state.usage.inputTokens += result.usage.tokens;
+			flushState(log, state);
 		}
-		if (lastError) data.error = lastError;
-		log.set({ ai: data });
+	};
+}
+function resolveToolInputs(raw) {
+	if (!raw) return {
+		enabled: false,
+		options: void 0
+	};
+	if (raw === true) return {
+		enabled: true,
+		options: void 0
+	};
+	return {
+		enabled: true,
+		options: raw
+	};
+}
+function processToolInput(input, toolName, options) {
+	let value = input;
+	if (options?.transform) value = options.transform(value, toolName);
+	if (options?.maxLength) {
+		const str = typeof value === "string" ? value : JSON.stringify(value);
+		if (str.length > options.maxLength) return `${str.slice(0, options.maxLength)}…`;
 	}
-	function recordModel(provider, modelId, responseModelId) {
-		const resolved = resolveProviderAndModel(provider, responseModelId ?? modelId);
-		models.push(resolved.model);
-		providers.push(resolved.provider);
+	return value;
+}
+function createAccumulatorState(options) {
+	const { enabled, options: captureOpts } = resolveToolInputs(options?.toolInputs);
+	return {
+		calls: 0,
+		steps: 0,
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			reasoningTokens: 0
+		},
+		models: [],
+		lastProvider: void 0,
+		allToolCalls: [],
+		allToolCallInputs: [],
+		stepsUsage: [],
+		lastFinishReason: void 0,
+		lastMsToFirstChunk: void 0,
+		lastMsToFinish: void 0,
+		lastError: void 0,
+		lastResponseId: void 0,
+		toolInputs: enabled,
+		toolInputsOptions: captureOpts
+	};
+}
+function flushState(log, state) {
+	const uniqueModels = [...new Set(state.models)];
+	const lastModel = state.models[state.models.length - 1];
+	const data = {
+		calls: state.calls,
+		inputTokens: state.usage.inputTokens,
+		outputTokens: state.usage.outputTokens,
+		totalTokens: state.usage.inputTokens + state.usage.outputTokens
+	};
+	if (lastModel) data.model = lastModel;
+	if (state.lastProvider) data.provider = state.lastProvider;
+	if (uniqueModels.length > 1) data.models = uniqueModels;
+	if (state.usage.cacheReadTokens > 0) data.cacheReadTokens = state.usage.cacheReadTokens;
+	if (state.usage.cacheWriteTokens > 0) data.cacheWriteTokens = state.usage.cacheWriteTokens;
+	if (state.usage.reasoningTokens > 0) data.reasoningTokens = state.usage.reasoningTokens;
+	if (state.lastFinishReason) data.finishReason = state.lastFinishReason;
+	if (state.toolInputs && state.allToolCallInputs.length > 0) data.toolCalls = [...state.allToolCallInputs];
+	else if (state.allToolCalls.length > 0) data.toolCalls = [...state.allToolCalls];
+	if (state.lastResponseId) data.responseId = state.lastResponseId;
+	if (state.steps > 1) {
+		data.steps = state.steps;
+		data.stepsUsage = [...state.stepsUsage];
+	}
+	if (state.lastMsToFirstChunk !== void 0) data.msToFirstChunk = state.lastMsToFirstChunk;
+	if (state.lastMsToFinish !== void 0) {
+		data.msToFinish = state.lastMsToFinish;
+		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;
+	log.set({ ai: data });
+}
+function recordModel(state, provider, modelId, responseModelId) {
+	const resolved = resolveProviderAndModel(provider, responseModelId ?? modelId);
+	state.models.push(resolved.model);
+	state.lastProvider = resolved.provider;
+}
+function safeParseJSON(input) {
+	try {
+		return JSON.parse(input);
+	} catch {
+		return input;
 	}
-	const middleware = {
+}
+function recordError(log, state, model, error) {
+	state.calls++;
+	state.steps++;
+	recordModel(state, model.provider, model.modelId);
+	state.lastFinishReason = "error";
+	state.lastError = error instanceof Error ? error.message : String(error);
+	const resolved = resolveProviderAndModel(model.provider, model.modelId);
+	state.stepsUsage.push({
+		model: resolved.model,
+		inputTokens: 0,
+		outputTokens: 0
+	});
+	flushState(log, state);
+}
+function buildMiddleware(log, options) {
+	return buildMiddlewareFromState(log, createAccumulatorState(options));
+}
+function buildMiddlewareFromState(log, state) {
+	return {
+		specificationVersion: "v3",
 		wrapGenerate: async ({ doGenerate, model }) => {
 			try {
 				const result = await doGenerate();
-				calls++;
-				steps++;
-				addUsage(usage, result.usage);
-				recordModel(model.provider, model.modelId, result.response?.modelId);
-				lastFinishReason = result.finishReason.unified;
-				for (const item of result.content) if (item.type === "tool-call") allToolCalls.push(item.toolName);
-				flush();
+				state.calls++;
+				state.steps++;
+				addUsage(state.usage, result.usage);
+				recordModel(state, model.provider, model.modelId, result.response?.modelId);
+				state.lastFinishReason = result.finishReason.unified;
+				if (result.response?.id) state.lastResponseId = result.response.id;
+				const stepToolCalls = [];
+				for (const item of result.content) if (item.type === "tool-call") {
+					state.allToolCalls.push(item.toolName);
+					stepToolCalls.push(item.toolName);
+					if (state.toolInputs) {
+						const raw = typeof item.input === "string" ? safeParseJSON(item.input) : item.input;
+						state.allToolCallInputs.push({
+							name: item.toolName,
+							input: processToolInput(raw, item.toolName, state.toolInputsOptions)
+						});
+					}
+				}
+				const resolvedModel = resolveProviderAndModel(model.provider, result.response?.modelId ?? model.modelId);
+				state.stepsUsage.push({
+					model: resolvedModel.model,
+					inputTokens: result.usage.inputTokens.total ?? 0,
+					outputTokens: result.usage.outputTokens.total ?? 0,
+					...stepToolCalls.length > 0 ? { toolCalls: stepToolCalls } : {}
+				});
+				flushState(log, state);
 				return result;
 			} catch (error) {
-				calls++;
-				steps++;
-				recordModel(model.provider, model.modelId);
-				lastFinishReason = "error";
-				lastError = error instanceof Error ? error.message : String(error);
-				flush();
+				recordError(log, state, model, error);
 				throw error;
 			}
 		},
@@ -121,25 +246,43 @@ function createAILogger(log) {
 			let streamUsage;
 			let streamFinishReason;
 			let streamModelId;
+			let streamResponseId;
 			const streamToolCalls = [];
+			const streamToolInputBuffers = /* @__PURE__ */ new Map();
 			let streamError;
 			let doStreamResult;
 			try {
 				doStreamResult = await doStream();
 			} catch (error) {
-				calls++;
-				steps++;
-				recordModel(model.provider, model.modelId);
-				lastFinishReason = "error";
-				lastError = error instanceof Error ? error.message : String(error);
-				flush();
+				recordError(log, state, model, error);
 				throw error;
 			}
 			const { stream, ...rest } = doStreamResult;
 			const transformStream = new TransformStream({
 				transform(chunk, controller) {
 					if (!firstChunkTime && chunk.type === "text-delta") firstChunkTime = Date.now();
-					if (chunk.type === "tool-input-start") streamToolCalls.push(chunk.toolName);
+					if (chunk.type === "tool-input-start") {
+						streamToolCalls.push(chunk.toolName);
+						if (state.toolInputs) streamToolInputBuffers.set(chunk.id, {
+							name: chunk.toolName,
+							chunks: []
+						});
+					}
+					if (chunk.type === "tool-input-delta" && state.toolInputs) {
+						const buffer = streamToolInputBuffers.get(chunk.id);
+						if (buffer) buffer.chunks.push(chunk.delta);
+					}
+					if (chunk.type === "tool-input-end" && state.toolInputs) {
+						const buffer = streamToolInputBuffers.get(chunk.id);
+						if (buffer) {
+							const raw = safeParseJSON(buffer.chunks.join(""));
+							state.allToolCallInputs.push({
+								name: buffer.name,
+								input: processToolInput(raw, buffer.name, state.toolInputsOptions)
+							});
+							streamToolInputBuffers.delete(chunk.id);
+						}
+					}
 					if (chunk.type === "finish") {
 						streamUsage = {
 							inputTokens: chunk.usage.inputTokens.total ?? 0,
@@ -150,27 +293,38 @@ function createAILogger(log) {
 						};
 						streamFinishReason = chunk.finishReason.unified;
 					}
-					if (chunk.type === "response-metadata" && "modelId" in chunk && chunk.modelId) streamModelId = chunk.modelId;
+					if (chunk.type === "response-metadata") {
+						if (chunk.modelId) streamModelId = chunk.modelId;
+						if (chunk.id) streamResponseId = chunk.id;
+					}
 					if (chunk.type === "error") streamError = chunk.error instanceof Error ? chunk.error.message : String(chunk.error);
 					controller.enqueue(chunk);
 				},
 				flush() {
-					calls++;
-					steps++;
+					state.calls++;
+					state.steps++;
 					if (streamUsage) {
-						usage.inputTokens += streamUsage.inputTokens;
-						usage.outputTokens += streamUsage.outputTokens;
-						usage.cacheReadTokens += streamUsage.cacheReadTokens;
-						usage.cacheWriteTokens += streamUsage.cacheWriteTokens;
-						usage.reasoningTokens += streamUsage.reasoningTokens;
+						state.usage.inputTokens += streamUsage.inputTokens;
+						state.usage.outputTokens += streamUsage.outputTokens;
+						state.usage.cacheReadTokens += streamUsage.cacheReadTokens;
+						state.usage.cacheWriteTokens += streamUsage.cacheWriteTokens;
+						state.usage.reasoningTokens += streamUsage.reasoningTokens;
 					}
-					recordModel(model.provider, model.modelId, streamModelId);
-					lastFinishReason = streamFinishReason;
-					for (const name of streamToolCalls) allToolCalls.push(name);
-					if (firstChunkTime) lastMsToFirstChunk = firstChunkTime - streamStart;
-					lastMsToFinish = Date.now() - streamStart;
-					if (streamError) lastError = streamError;
-					flush();
+					recordModel(state, model.provider, model.modelId, streamModelId);
+					state.lastFinishReason = streamFinishReason;
+					state.allToolCalls.push(...streamToolCalls);
+					if (streamResponseId) state.lastResponseId = streamResponseId;
+					if (firstChunkTime) state.lastMsToFirstChunk = firstChunkTime - streamStart;
+					state.lastMsToFinish = Date.now() - streamStart;
+					if (streamError) state.lastError = streamError;
+					const resolvedModel = resolveProviderAndModel(model.provider, streamModelId ?? model.modelId);
+					state.stepsUsage.push({
+						model: resolvedModel.model,
+						inputTokens: streamUsage?.inputTokens ?? 0,
+						outputTokens: streamUsage?.outputTokens ?? 0,
+						...streamToolCalls.length > 0 ? { toolCalls: [...streamToolCalls] } : {}
+					});
+					flushState(log, state);
 				}
 			});
 			return {
@@ -179,21 +333,8 @@ function createAILogger(log) {
 			};
 		}
 	};
-	return {
-		wrap: (model) => {
-			return wrapLanguageModel({
-				model: typeof model === "string" ? gateway(model) : model,
-				middleware
-			});
-		},
-		captureEmbed: (result) => {
-			calls++;
-			usage.inputTokens += result.usage.tokens;
-			flush();
-		}
-	};
 }
 //#endregion
-export { createAILogger };
+export { createAILogger, createAIMiddleware };
 
 //# sourceMappingURL=index.mjs.map