evlog 2.19.2 → 2.21.0

package/README.md

@@ -560,6 +560,32 @@ export default async function fetch(request: Request) {
 
 See the full [orpc example](https://github.com/HugoRCD/evlog/tree/main/examples/orpc) for a complete working project.
 
+## eve
+
+```typescript
+// agent/hooks/evlog.ts
+import { defineEvlogHook } from 'evlog/eve'
+import { createAxiomDrain } from 'evlog/axiom'
+
+export default defineEvlogHook({
+  init: { env: { service: 'my-agent' } },
+  drain: createAxiomDrain(),
+  maxSessions: 256,
+})
+```
+
+```typescript
+// agent/tools/my_tool.ts — inside execute()
+import { useLogger } from 'evlog/eve'
+
+const log = useLogger()
+log.set({ order: { id: input.orderId } })
+```
+
+`defineEvlogHook()` maps eve turn lifecycle events to one wide event per turn. Call `useLogger()` in tools — the logger is bound via AsyncLocalStorage on `turn.started`. Pass `ctx` only when ALS is unavailable (`useLogger(ctx)`). Pretty-printing follows `isDev()` by default (tree locally, JSON in production); set `init.pretty: false` explicitly if you need to override. Complements eve Agent Runs and OpenTelemetry — see the [eve use case](https://evlog.dev/use-cases/eve).
+
+See the full [eve example](https://github.com/HugoRCD/evlog/tree/main/examples/eve) for a complete agent layout.
+
 ## Browser
 
 Use the `log` API on the client side for structured browser logging:
@@ -794,7 +820,9 @@ See [the Audit Logs guide](https://evlog.dev/use-cases/audit/overview) for compl
 
 ## AI SDK Integration
 
-Capture token usage, tool calls, model info, and streaming metrics from the [Vercel AI SDK](https://ai-sdk.dev) into wide events. Requires `ai >= 6.0.0`.
+Capture token usage, tool calls, model info, and streaming metrics from the [Vercel AI SDK](https://ai-sdk.dev) into wide events. Compatible with AI SDK v6 and v7 (`ai >= 6.0.168`). AI SDK v7 requires Node.js 22+.
+
+For tool execution timing, abort tracking, and auto embed capture, pass `createEvlogIntegration(ai)` to `telemetry.integrations` (v7) or `experimental_telemetry.integrations` (v6).
 
 ```typescript
 import { streamText } from 'ai'
@@ -1388,6 +1416,7 @@ try {
 | **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)) |
 | **oRPC** | `withEvlog(handler)` + `os.use(evlog())` with `import { evlog, withEvlog } from 'evlog/orpc'` ([example](./examples/orpc)) |
+| **eve** | `defineEvlogHook()` in `agent/hooks/evlog.ts` with `import { defineEvlogHook, useLogger } from 'evlog/eve'` ([example](./examples/eve)) |
 | **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/extend/custom-framework)) |
 | **Analog** | Nitro v2 module setup |

package/dist/adapters/axiom.d.mts

@@ -1,4 +1,4 @@
-import { U as DrainContext, ht as WideEvent } from "../audit-CBfv3rl1.mjs";
+import { U as DrainContext, ht as WideEvent } from "../audit-BZrUvjfW.mjs";
 //#region src/adapters/axiom.d.ts
 interface BaseAxiomConfig {
   /** Axiom dataset name. */

package/dist/adapters/axiom.mjs

@@ -1,5 +1,5 @@
-import { r as httpPost } from "../http-DA3RWQrm.mjs";
-import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig, r as applyDeprecatedAlias } from "../drain-6lV-g7JB.mjs";
+import { r as httpPost } from "../http-CuZ6Cm2M.mjs";
+import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig, r as applyDeprecatedAlias } from "../drain-AD7Mn_5_.mjs";
 //#region src/adapters/axiom.ts
 const AXIOM_FIELDS = [
 	{

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

@@ -1,4 +1,4 @@
-import { U as DrainContext, ht as WideEvent } from "../audit-CBfv3rl1.mjs";
+import { U as DrainContext, ht as WideEvent } from "../audit-BZrUvjfW.mjs";
 //#region src/adapters/better-stack.d.ts
 interface BetterStackConfig {
   /** Better Stack API key (replaces deprecated `sourceToken`). */

package/dist/adapters/better-stack.mjs

@@ -1,5 +1,5 @@
-import { r as httpPost } from "../http-DA3RWQrm.mjs";
-import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig, r as applyDeprecatedAlias } from "../drain-6lV-g7JB.mjs";
+import { r as httpPost } from "../http-CuZ6Cm2M.mjs";
+import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig, r as applyDeprecatedAlias } from "../drain-AD7Mn_5_.mjs";
 //#region src/adapters/better-stack.ts
 const BETTER_STACK_FIELDS = [
 	{

package/dist/adapters/datadog.d.mts

@@ -1,4 +1,4 @@
-import { U as DrainContext, ht as WideEvent } from "../audit-CBfv3rl1.mjs";
+import { U as DrainContext, ht as WideEvent } from "../audit-BZrUvjfW.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 { r as httpPost } from "../http-DA3RWQrm.mjs";
-import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig } from "../drain-6lV-g7JB.mjs";
+import { r as httpPost } from "../http-CuZ6Cm2M.mjs";
+import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig } from "../drain-AD7Mn_5_.mjs";
 //#region src/adapters/datadog.ts
 const DATADOG_FIELDS = [
 	{

package/dist/adapters/fs.d.mts

@@ -1,4 +1,4 @@
-import { $ as LogLevel, U as DrainContext, ht as WideEvent } from "../audit-CBfv3rl1.mjs";
+import { $ as LogLevel, U as DrainContext, ht as WideEvent } from "../audit-BZrUvjfW.mjs";
 //#region src/adapters/fs.d.ts
 interface FsConfig {
   /** Directory for log files. Default: `.evlog/logs` */

package/dist/adapters/fs.mjs

@@ -1,4 +1,4 @@
-import { o as resolveAdapterConfig, t as defineDrain } from "../drain-6lV-g7JB.mjs";
+import { o as resolveAdapterConfig, t as defineDrain } from "../drain-AD7Mn_5_.mjs";
 import { join, sep } from "node:path";
 import { createReadStream } from "node:fs";
 import { appendFile, mkdir, open, readdir, stat, unlink, writeFile } from "node:fs/promises";

package/dist/adapters/hyperdx.d.mts

@@ -1,4 +1,4 @@
-import { U as DrainContext, ht as WideEvent } from "../audit-CBfv3rl1.mjs";
+import { U as DrainContext, ht as WideEvent } from "../audit-BZrUvjfW.mjs";
 import { OTLPConfig } from "./otlp.mjs";
 
 //#region src/adapters/hyperdx.d.ts

package/dist/adapters/hyperdx.mjs

@@ -1,4 +1,4 @@
-import { i as formatPublicEnvKeys, o as resolveAdapterConfig, t as defineDrain } from "../drain-6lV-g7JB.mjs";
+import { i as formatPublicEnvKeys, o as resolveAdapterConfig, t as defineDrain } from "../drain-AD7Mn_5_.mjs";
 import { sendBatchToOTLP } from "./otlp.mjs";
 //#region src/adapters/hyperdx.ts
 /**

package/dist/adapters/memory.d.mts

@@ -1,4 +1,4 @@
-import { $ as LogLevel, U as DrainContext, ht as WideEvent } from "../audit-CBfv3rl1.mjs";
+import { $ as LogLevel, U as DrainContext, ht as WideEvent } from "../audit-BZrUvjfW.mjs";
 //#region src/adapters/memory.d.ts
 /**
  * Configuration for the in-memory drain.

package/dist/adapters/memory.mjs

@@ -1,4 +1,4 @@
-import { o as resolveAdapterConfig, t as defineDrain } from "../drain-6lV-g7JB.mjs";
+import { o as resolveAdapterConfig, t as defineDrain } from "../drain-AD7Mn_5_.mjs";
 //#region src/adapters/memory.ts
 const DEFAULT_STORE = "default";
 const DEFAULT_MAX_EVENTS = 1e3;

package/dist/adapters/otlp.d.mts

@@ -1,4 +1,4 @@
-import { U as DrainContext, ht as WideEvent } from "../audit-CBfv3rl1.mjs";
+import { U as DrainContext, ht as WideEvent } from "../audit-BZrUvjfW.mjs";
 //#region src/adapters/otlp.d.ts
 interface OTLPConfig {
   /** OTLP HTTP endpoint (e.g., http://localhost:4318) */

package/dist/adapters/otlp.mjs

@@ -1,5 +1,5 @@
-import { r as httpPost } from "../http-DA3RWQrm.mjs";
-import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig } from "../drain-6lV-g7JB.mjs";
+import { r as httpPost } from "../http-CuZ6Cm2M.mjs";
+import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig } from "../drain-AD7Mn_5_.mjs";
 import { n as toOtlpAttributeValue } from "../event-qwAv-7AZ.mjs";
 import { n as OTEL_SEVERITY_TEXT, t as OTEL_SEVERITY_NUMBER } from "../severity-CwXUSHt3.mjs";
 //#region src/adapters/otlp.ts

package/dist/adapters/posthog.d.mts

@@ -1,4 +1,4 @@
-import { U as DrainContext, ht as WideEvent } from "../audit-CBfv3rl1.mjs";
+import { U as DrainContext, ht as WideEvent } from "../audit-BZrUvjfW.mjs";
 //#region src/adapters/posthog.d.ts
 /**
  * Mode for {@link createPostHogDrain}.

package/dist/adapters/posthog.mjs

@@ -1,5 +1,5 @@
-import { r as httpPost } from "../http-DA3RWQrm.mjs";
-import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig, t as defineDrain } from "../drain-6lV-g7JB.mjs";
+import { r as httpPost } from "../http-CuZ6Cm2M.mjs";
+import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig, t as defineDrain } from "../drain-AD7Mn_5_.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 { U as DrainContext, ht as WideEvent } from "../audit-CBfv3rl1.mjs";
+import { U as DrainContext, ht as WideEvent } from "../audit-BZrUvjfW.mjs";
 //#region src/adapters/sentry.d.ts
 interface SentryConfig {
   /** Sentry DSN */

package/dist/adapters/sentry.mjs

@@ -1,5 +1,5 @@
-import { r as httpPost } from "../http-DA3RWQrm.mjs";
-import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig } from "../drain-6lV-g7JB.mjs";
+import { r as httpPost } from "../http-CuZ6Cm2M.mjs";
+import { i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig } from "../drain-AD7Mn_5_.mjs";
 import { t as OTEL_SEVERITY_NUMBER } from "../severity-CwXUSHt3.mjs";
 //#region src/adapters/sentry.ts
 const SENTRY_FIELDS = [

package/dist/ai/index.d.mts

@@ -1,8 +1,22 @@
-import { ot as RequestLogger } from "../audit-CBfv3rl1.mjs";
-import { GatewayModelId, TelemetryIntegration } from "ai";
-import { LanguageModelV3, LanguageModelV3Middleware } from "@ai-sdk/provider";
+import { ot as RequestLogger } from "../audit-BZrUvjfW.mjs";
+import { LanguageModel, LanguageModelMiddleware } from "ai";
 
 //#region src/ai/index.d.ts
+/**
+ * Telemetry integration returned by {@link createEvlogIntegration}.
+ * Implements hooks for AI SDK v6 (`onToolCallFinish`, `onFinish`) and v7
+ * (`onToolExecutionEnd`, `onEnd`, `onEmbedEnd`, `onAbort`, `onError`).
+ */
+type EvlogTelemetry = {
+  onStart?: (event: unknown) => void | PromiseLike<void>; /** AI SDK v6 — superseded by `onToolExecutionEnd` in v7. */
+  onToolCallFinish?: (event: unknown) => void | PromiseLike<void>;
+  onToolExecutionEnd?: (event: unknown) => void | PromiseLike<void>; /** AI SDK v6 — superseded by `onEnd` in v7. */
+  onFinish?: (event: unknown) => void | PromiseLike<void>;
+  onEnd?: (event: unknown) => void | PromiseLike<void>;
+  onEmbedEnd?: (event: unknown) => void | PromiseLike<void>;
+  onAbort?: (event: unknown) => void | PromiseLike<void>;
+  onError?: (event: unknown) => void | PromiseLike<void>;
+};
 /**
  * Fine-grained control over tool call input capture.
  */
@@ -68,7 +82,7 @@ interface AIStepUsage {
   toolCalls?: string[];
 }
 /**
- * Tool execution detail captured via `TelemetryIntegration`.
+ * Tool execution detail captured via telemetry integration hooks.
  */
 interface AIToolExecution {
   name: string;
@@ -139,22 +153,29 @@ interface AILogger {
    * 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'`).
+   * Accepts a language model object (`LanguageModelV3` or `LanguageModelV4`)
+   * or a model string (e.g. `'anthropic/claude-sonnet-4.6'`).
    * Strings are resolved via the AI SDK gateway.
    *
+   * On AI SDK v7, the wrapped model is a `LanguageModelV4`. On v6 it remains
+   * a `LanguageModelV3`. Both are accepted as input.
+   *
    * Also works with pre-wrapped models (e.g. from supermemory, guardrails):
    * `ai.wrap(withSupermemory(base, orgId))` composes correctly.
    *
-   * @example
+   * @example Gateway model string
    * ```ts
    * const ai = createAILogger(log)
    * const model = ai.wrap('anthropic/claude-sonnet-4.6')
+   * ```
    *
-   * // Also accepts a model object
+   * @example Provider model object (V3 or V4)
+   * ```ts
+   * const ai = createAILogger(log)
    * const model = ai.wrap(anthropic('claude-sonnet-4.6'))
    * ```
    */
-  wrap: (model: LanguageModelV3 | GatewayModelId) => LanguageModelV3;
+  wrap: (model: LanguageModel) => LanguageModel;
   /**
    * Manually capture token usage from an `embed()` or `embedMany()` result.
    * Embedding models use a different type than language models, so they
@@ -300,7 +321,7 @@ interface UsageAccumulator {
  * })
  * ```
  */
-declare function createAIMiddleware(log: RequestLogger, options?: AILoggerOptions): LanguageModelV3Middleware;
+declare function createAIMiddleware(log: RequestLogger, options?: AILoggerOptions): LanguageModelMiddleware;
 /**
  * Create an AI logger that captures AI SDK data into the wide event.
  *
@@ -371,9 +392,13 @@ interface AccumulatorState {
   _log?: RequestLogger;
 }
 /**
- * Create an AI SDK `TelemetryIntegration` that captures tool execution
+ * Create an AI SDK telemetry integration that captures tool execution
  * timing, errors, and total generation wall time into the wide event.
  *
+ * Compatible with AI SDK v6 (`TelemetryIntegration`) and v7 (`Telemetry`).
+ * On v7, also captures embeddings via `onEmbedEnd`, aborts via `onAbort`,
+ * and unrecoverable errors via `onError`.
+ *
  * 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).
@@ -391,8 +416,7 @@ interface AccumulatorState {
  * const result = await generateText({
  *   model: ai.wrap('anthropic/claude-sonnet-4.6'),
  *   tools: { getWeather },
- *   experimental_telemetry: {
- *     isEnabled: true,
+ *   telemetry: {
  *     integrations: [createEvlogIntegration(ai)],
  *   },
  * })
@@ -406,14 +430,13 @@ interface AccumulatorState {
  *
  * const result = await generateText({
  *   model: openai('gpt-4o'),
- *   experimental_telemetry: {
- *     isEnabled: true,
+ *   telemetry: {
  *     integrations: [integration],
  *   },
  * })
  * ```
  */
-declare function createEvlogIntegration(logOrAi: RequestLogger | AILogger, options?: AILoggerOptions): TelemetryIntegration;
+declare function createEvlogIntegration(logOrAi: RequestLogger | AILogger, options?: AILoggerOptions): EvlogTelemetry;
 //#endregion
-export { AIEmbeddingData, AIEventData, AILogger, AILoggerOptions, AIMetadata, AIMetadataListener, AIStepUsage, AIToolExecution, ModelCost, ToolInputsOptions, createAILogger, createAIMiddleware, createEvlogIntegration };
+export { AIEmbeddingData, AIEventData, AILogger, AILoggerOptions, AIMetadata, AIMetadataListener, AIStepUsage, AIToolExecution, EvlogTelemetry, 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":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/ai/index.ts"],"mappings":"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"}

package/dist/ai/index.mjs

@@ -1,5 +1,7 @@
-import { bindTelemetryIntegration, gateway, wrapLanguageModel } from "ai";
+import * as aiModule from "ai";
+import { gateway, wrapLanguageModel } from "ai";
 //#region src/ai/index.ts
+const { bindTelemetryIntegration } = aiModule;
 function addUsage(acc, usage) {
 	acc.inputTokens += usage.inputTokens.total ?? 0;
 	acc.outputTokens += usage.outputTokens.total ?? 0;
@@ -288,7 +290,7 @@ function buildMiddleware(log, options) {
 }
 function buildMiddlewareFromState(log, state) {
 	return {
-		specificationVersion: "v3",
+		specificationVersion: "v4",
 		wrapGenerate: async ({ doGenerate, model }) => {
 			try {
 				const result = await doGenerate();
@@ -418,10 +420,63 @@ function buildMiddlewareFromState(log, state) {
 		}
 	};
 }
+function formatTelemetryError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function recordToolExecution(state, input) {
+	const execution = {
+		name: input.name,
+		durationMs: input.durationMs,
+		success: input.success
+	};
+	if (input.error) execution.error = input.error;
+	state.toolExecutions.push(execution);
+}
+function adaptV6ToolEvent(event) {
+	return {
+		name: event.toolCall.toolName,
+		durationMs: event.durationMs,
+		success: event.success,
+		error: !event.success && event.error !== void 0 ? formatTelemetryError(event.error) : void 0
+	};
+}
+function adaptV7ToolEvent(event) {
+	const success = event.toolOutput.type === "tool-result";
+	return {
+		name: event.toolCall.toolName,
+		durationMs: event.toolExecutionMs,
+		success,
+		error: !success && event.toolOutput.type === "tool-error" ? formatTelemetryError(event.toolOutput.error) : void 0
+	};
+}
+function recordGenerationEnd(state, log) {
+	if (state.generationStartTime !== void 0) state.totalDurationMs = Date.now() - state.generationStartTime;
+	flushState(log, state);
+}
+function recordEmbedEnd(state, log, event) {
+	state.calls++;
+	state.usage.inputTokens += event.usage.tokens;
+	const dimensions = event.embeddings[0]?.length;
+	state.embedding = {
+		tokens: (state.embedding?.tokens ?? 0) + event.usage.tokens,
+		model: event.modelId,
+		...dimensions !== void 0 ? { dimensions } : state.embedding?.dimensions ? { dimensions: state.embedding.dimensions } : {},
+		count: (state.embedding?.count ?? 0) + event.values.length
+	};
+	flushState(log, state);
+}
+function finalizeIntegration(integration) {
+	if (typeof bindTelemetryIntegration === "function") return bindTelemetryIntegration(integration);
+	return integration;
+}
 /**
-* Create an AI SDK `TelemetryIntegration` that captures tool execution
+* Create an AI SDK telemetry integration that captures tool execution
 * timing, errors, and total generation wall time into the wide event.
 *
+* Compatible with AI SDK v6 (`TelemetryIntegration`) and v7 (`Telemetry`).
+* On v7, also captures embeddings via `onEmbedEnd`, aborts via `onAbort`,
+* and unrecoverable errors via `onError`.
+*
 * 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).
@@ -439,8 +494,7 @@ function buildMiddlewareFromState(log, state) {
 * const result = await generateText({
 *   model: ai.wrap('anthropic/claude-sonnet-4.6'),
 *   tools: { getWeather },
-*   experimental_telemetry: {
-*     isEnabled: true,
+*   telemetry: {
 *     integrations: [createEvlogIntegration(ai)],
 *   },
 * })
@@ -454,8 +508,7 @@ function buildMiddlewareFromState(log, state) {
 *
 * const result = await generateText({
 *   model: openai('gpt-4o'),
-*   experimental_telemetry: {
-*     isEnabled: true,
+*   telemetry: {
 *     integrations: [integration],
 *   },
 * })
@@ -477,20 +530,32 @@ function createEvlogIntegration(logOrAi, options) {
 			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);
+			recordToolExecution(state, adaptV6ToolEvent(event));
+		}
+		onToolExecutionEnd(event) {
+			recordToolExecution(state, adaptV7ToolEvent(event));
 		}
 		onFinish(_event) {
-			if (state.generationStartTime) state.totalDurationMs = Date.now() - state.generationStartTime;
+			recordGenerationEnd(state, log);
+		}
+		onEnd(_event) {
+			recordGenerationEnd(state, log);
+		}
+		onEmbedEnd(event) {
+			recordEmbedEnd(state, log, event);
+		}
+		onAbort(event) {
+			state.lastFinishReason = "abort";
+			const { reason } = event;
+			if (reason !== void 0) state.lastError = formatTelemetryError(reason);
+			recordGenerationEnd(state, log);
+		}
+		onError(error) {
+			state.lastError = formatTelemetryError(error);
 			flushState(log, state);
 		}
 	}
-	return bindTelemetryIntegration(new EvlogIntegration());
+	return finalizeIntegration(new EvlogIntegration());
 }
 //#endregion
 export { createAILogger, createAIMiddleware, createEvlogIntegration };