@telemetry-dev/eve 0.1.1 → 0.1.2

package/README.md

@@ -10,7 +10,7 @@ lifecycle-hook, and HTTP-client surfaces.
 npm install @telemetry-dev/eve eve
 ```
 
-Requires `eve >=0.19.0 <1` and Node.js 24 or newer.
+Requires `eve >=0.47.0 <1` and Node.js 24 or newer.
 
 ## Environment
 
@@ -93,17 +93,21 @@ const client = wrapEveClient(new Client({ host: "http://127.0.0.1:3000" }), {
   agentName: "support-agent",
 });
 
-const session = client.session();
-const response = await session.send("Summarize this incident.");
+const { response, session } = await client.sessions.create({
+  message: "Summarize this incident.",
+});
 const result = await response.result();
+const followUp = await session.send("What do we do next?");
 ```
 
-`wrapEveClient()` creates one caller-side `invoke_agent` span per `ClientSession.send()` turn. It
-records the outgoing message or HITL input responses as span input, sets `gen_ai.conversation.id` from
-Eve's response session id, streams TTFT from the first message/reasoning delta, accumulates usage from
-`step.completed`, records final message/result output, and marks failures/cancellations as errors.
+`wrapEveClient()` makes one caller-side `invoke_agent` span for each turn: `sessions.create()`,
+`ClientSession.send()`, and `ClientSession.respond()`. It records the outgoing message or the HITL
+input responses as span input, sets `gen_ai.conversation.id` from
+the session state or Eve's response session id (so all turns of one session share one trace), streams
+TTFT from the first message/reasoning delta, accumulates usage from `step.completed`, records final
+message/result output, and marks failures/cancellations as errors.
 
-`ClientSession.stream()`, `Client.info()`, and `Client.health()` are intentionally not spanned.
+`ClientSession.stream()`, `sessions.attach()`, `Client.info()`, and `Client.health()` are not spanned.
 Attach-streams are unbounded and the probe routes are not agent turns.
 
 ## Trace shape
@@ -120,25 +124,62 @@ A typical turn contains:
   context and any custom runtime context you return from `step.started`.
 - Lifecycle logs joined to the same session via `gen_ai.conversation.id`.
 
-Eve's internal workflow-engine spans (`workflow.execute`, `step.execute`, `world.*`, `hook.resume`,
-etc., tracer scope `workflow`) are excluded by default so traces stay AI-centric. Pass
-`spanFilter: () => true` to export them too.
+By default, only AI spans are exported: tracer scopes `eve`, `eve.agent`, `gen_ai`, and this SDK. Spans from
+other libraries on the same global tracer provider (for example better-auth, Nitro, or eve's
+`workflow` engine) are dropped. Pass `spanFilter: () => true` to export every span.
 
 ## Content capture
 
-Server-side model content follows Eve's `recordInputs` / `recordOutputs` settings. Caller-side wrapper
-content follows the telemetry.dev SDK `captureInput` / `captureOutput` settings. The SDK mask and
-truncation options apply to captured client-wrapper inputs, outputs, and logs.
+Server-side model content depends on Eve's trace policy and the destination capture settings.
+`telemetryDevInstrumentation()` maps `captureInput` / `captureOutput` to `recordInputs` /
+`recordOutputs`. The defaults are `true`, but these flags cannot override Eve's trace policy.
+In Eve 0.47.0 and 0.50.0, the default policy records content only for a `public` audience,
+even if `EVE_DEV=1`. HTTP clients, web chat, and schedules have an `unknown` audience.
+
+For approved local content capture, use Eve's provider layout.
+Remove `agent/instrumentation.ts`.
+Set `experimental.instrumentationProviders` to `true` in the Eve configuration.
+Add these two files:
+
+```ts
+// agent/instrumentation/otel.ts
+import { otel } from "eve/instrumentation/otel";
+
+export default otel({ tracePolicy: () => true });
+```
+
+```ts
+// agent/instrumentation/telemetry-dev.ts
+import { telemetryDevOtelIntegration } from "@telemetry-dev/eve";
+
+export default telemetryDevOtelIntegration();
+```
+
+This policy selects Eve's audience-aware capture.
+For local `unknown`-audience channels, run `eve dev` or set `EVE_DEV=1` in the Eve server process.
+Without `EVE_DEV=1`, local unknown-audience channels export metadata only.
+Local private channels always export metadata only.
+Destination settings and forwarded parent policies can decrease content capture.
+
+The legacy single-file `telemetryDevInstrumentation()` API has no `tracePolicy` option.
+Thus, it cannot record model content for new unknown-audience sessions on these Eve versions.
+The single-file layout remains suitable for metadata-only traces.
+Do not combine the two layouts.
+This package cannot restore content that Eve removed.
+
+Caller-side wrapper content follows the telemetry.dev SDK `captureInput` / `captureOutput`
+settings. The SDK mask and truncation options apply to captured client-wrapper inputs, outputs,
+and logs.
 
 ## Limitations
 
 - Pass options to exactly one entry point in a process. Initialization is one-shot so duplicate entry
   points do not replace the first configuration.
 - `ClientSession.stream()` is not spanned.
-- Cost is computed server-side by telemetry.dev from usage and pricing data; Eve stream events carry
-  no cost fields, so the client wrapper records usage only.
-- The client wrapper's `invoke_agent` span ends when the response stream is consumed (iteration or
-  `result()`); an unconsumed response leaves the span unexported.
+- The client wrapper exports a total cost only after an error-free terminal event. Each completed step must report a finite, non-negative `usage.costUsd` value, including zero. Otherwise, the wrapper omits the total but still records token usage. Model information is also necessary for server-side pricing.
+- When caller and server spans share a trace and matching Eve turn metadata, the caller cost replaces the server's main model-call costs. Tool and subagent costs stay separate. Without that match, the two reported totals stay unchanged.
+- The client wrapper ends its `invoke_agent` span after stream use or an abort signal. Without these actions, the span stays open.
+- Eve 0.50 gives `telemetryDevOtelIntegration()` no tracer-provider or parent-context hook. Thus, Eve provider spans cannot join the deterministic session trace.
 - Inline subagent child streams (`subagent.event`) are not fanned out in full; the hook logs
   `subagent.started`, `subagent.called`, `subagent.completed`, and child failure events.
 - Eve workflow `$eve.*` run tags are a Vercel-dashboard surface and are not visible to OpenTelemetry,

package/dist/index.d.mts

@@ -1,5 +1,6 @@
-import { ClientOverrides, ClientOverrides as ClientOverrides$1, TelemetryOptions } from "@telemetry-dev/sdk";
+import { ClientOverrides, ClientOverrides as ClientOverrides$1, TelemetryOptions, TelemetrySpanProcessorOptions } from "@telemetry-dev/sdk";
 import { Client } from "eve/client";
+import { OtelIntegration } from "eve/instrumentation/otel";
 import { HookDefinition } from "eve/hooks";
 import { InstrumentationDefinition, InstrumentationEvents, InstrumentationRuntimeContext } from "eve/instrumentation";
 
@@ -34,4 +35,16 @@ interface TelemetryDevInstrumentationOptions extends TelemetryDevEveOptions {
 }
 declare function telemetryDevInstrumentation(options?: TelemetryDevInstrumentationOptions, overrides?: ClientOverrides$1): InstrumentationDefinition;
 //#endregion
-export { type TelemetryDevEveOptions, type TelemetryDevInstrumentationOptions, type WrapEveClientOptions, telemetryDevHook, telemetryDevInstrumentation, wrapEveClient };
+//#region src/otel.d.ts
+interface TelemetryDevOtelIntegrationOptions extends Omit<TelemetrySpanProcessorOptions, "spanExporter"> {
+  recordInputs?: boolean;
+  recordOutputs?: boolean;
+}
+/**
+ * telemetry.dev as a destination in eve's `agent/instrumentation/` provider layout
+ * (`experimental.instrumentationProviders`). Export it from one file in that directory.
+ * eve owns the tracer provider there, so this attaches a processor instead of registering one.
+ */
+declare function telemetryDevOtelIntegration(options?: TelemetryDevOtelIntegrationOptions): OtelIntegration;
+//#endregion
+export { type TelemetryDevEveOptions, type TelemetryDevInstrumentationOptions, type TelemetryDevOtelIntegrationOptions, type WrapEveClientOptions, telemetryDevHook, telemetryDevInstrumentation, telemetryDevOtelIntegration, wrapEveClient };

package/dist/index.mjs

@@ -1,13 +1,21 @@
-import { init, log, startSpan } from "@telemetry-dev/sdk";
+import { SCOPE_NAME, TelemetrySpanProcessor, init, log, startSpan } from "@telemetry-dev/sdk";
 import { MessageResponse, isCurrentTurnBoundaryEvent } from "eve/client";
+import { otelIntegration } from "eve/instrumentation/otel";
 //#region src/config.ts
 let initialized = false;
+const AI_SCOPES = {
+	eve: true,
+	"eve.agent": true,
+	gen_ai: true,
+	[SCOPE_NAME]: true
+};
+const isAiScope = (scope) => Object.hasOwn(AI_SCOPES, scope);
 /**
 * Initializes the telemetry.dev SDK exactly once per process for this integration.
-* registerGlobal:true lets eve's tracers (scopes "eve" and "gen_ai") resolve to
-* the SDK provider. spanFilter defaults to exporting everything except eve's
-* internal workflow-engine spans (scope "workflow"); pass spanFilter: () => true
-* to export those too.
+* registerGlobal:true lets eve's tracers resolve to the SDK provider. spanFilter defaults to
+* exporting only AI scopes (see AI_SCOPES); pass spanFilter: () => true to export every span.
+* eve starts each `ai.eve.turn` under a workflow-engine span of its own trace, so the turn is
+* re-rooted under the session parent and every turn of a session lands in one trace.
 */
 function ensureInit(options = {}, overrides) {
 	if (initialized) return;
@@ -16,7 +24,11 @@ function ensureInit(options = {}, overrides) {
 		...options,
 		sdkName: "@telemetry-dev/eve",
 		registerGlobal: true,
-		spanFilter: options.spanFilter ?? ((span) => span.instrumentationScope.name !== "workflow")
+		spanFilter: options.spanFilter ?? ((span) => isAiScope(span.instrumentationScope.name)),
+		sessionRootOf: (name, attributes) => {
+			const sessionId = attributes["eve.session.id"];
+			return name === "ai.eve.turn" && typeof sessionId === "string" ? sessionId : void 0;
+		}
 	}, overrides);
 }
 //#endregion
@@ -52,9 +64,6 @@ function failureError(code, message) {
 	if (code) error.name = code;
 	return error;
 }
-function inputForSpan(payload) {
-	return payload.message ?? payload.inputResponses;
-}
 function bindOrReturn(target, prop) {
 	const value = target[prop];
 	return value instanceof Function ? value.bind(target) : value;
@@ -85,16 +94,21 @@ function addLifecycleEvent(span, event) {
 		default: return;
 	}
 }
-async function* instrumentedStream(response, span, start, payload) {
+async function* instrumentedStream(response, span, start, signal, endCancelled) {
 	const usage = {};
 	let sawUsage = false;
 	let output;
 	let finishReason;
+	let costUsd;
+	let allCostsKnown = true;
 	let timeToFirstChunkMs;
 	let error;
+	let done = false;
 	let sawTerminalEvent = false;
 	const finish = () => {
-		if (!sawTerminalEvent && error === void 0) if (payload.signal?.aborted) {
+		if (done) return;
+		done = true;
+		if (!sawTerminalEvent && error === void 0) if (signal?.aborted) {
 			error = failureError("cancelled", "cancelled");
 			finishReason ??= "cancelled";
 		} else {
@@ -104,6 +118,7 @@ async function* instrumentedStream(response, span, start, payload) {
 		span.end({
 			usage: sawUsage ? usage : void 0,
 			finishReason,
+			costUsd: sawTerminalEvent && error === void 0 && allCostsKnown && Number.isFinite(costUsd) ? costUsd : void 0,
 			output,
 			timeToFirstChunkMs,
 			error: error instanceof Error ? error : error === void 0 ? void 0 : /* @__PURE__ */ new Error("error")
@@ -112,6 +127,16 @@ async function* instrumentedStream(response, span, start, payload) {
 	try {
 		for await (const event of response) {
 			const data = eventData$1(event);
+			if (event.type === "turn.started") {
+				const turnTrace = asRecord$1(data.trace);
+				const traceId = stringField$1(turnTrace, "traceId");
+				const spanId = stringField$1(turnTrace, "spanId");
+				const turnId = stringField$1(data, "turnId");
+				if (traceId && spanId && turnId) {
+					span.span.setAttribute("td.eve.turn_root", `${traceId}/${spanId}`);
+					span.span.setAttribute("eve.turn.id", turnId);
+				}
+			}
 			if (isCurrentTurnBoundaryEvent(event)) sawTerminalEvent = true;
 			if (timeToFirstChunkMs === void 0 && (event.type === "message.appended" || event.type === "reasoning.appended")) timeToFirstChunkMs = performance.now() - start;
 			if (event.type === "step.completed") {
@@ -120,6 +145,9 @@ async function* instrumentedStream(response, span, start, payload) {
 				sawUsage = addUsage(usage, "outputTokens", numberField$1(eventUsage, "outputTokens")) || sawUsage;
 				sawUsage = addUsage(usage, "cacheReadInputTokens", numberField$1(eventUsage, "cacheReadTokens")) || sawUsage;
 				sawUsage = addUsage(usage, "cacheCreationInputTokens", numberField$1(eventUsage, "cacheWriteTokens")) || sawUsage;
+				const stepCost = numberField$1(eventUsage, "costUsd");
+				if (stepCost === void 0 || !Number.isFinite(stepCost) || stepCost < 0) allCostsKnown = false;
+				else costUsd = (costUsd ?? 0) + stepCost;
 				finishReason = stringField$1(data, "finishReason") ?? finishReason;
 			}
 			if (event.type === "message.completed" && stringField$1(data, "finishReason") !== "tool-calls") output = data.message;
@@ -132,49 +160,104 @@ async function* instrumentedStream(response, span, start, payload) {
 				}
 				finishReason = "error";
 			}
+			if (event.type === "turn.cancelled") {
+				error = failureError("cancelled", "cancelled");
+				finishReason = "cancelled";
+			}
 			addLifecycleEvent(span, event);
 			yield event;
 		}
 	} catch (caught) {
-		if (payload.signal?.aborted) {
+		if (signal?.aborted) {
 			error = failureError("cancelled", "cancelled");
 			finishReason ??= "cancelled";
 		} else error = caught instanceof Error ? caught : new Error(String(caught));
 		throw caught;
 	} finally {
 		finish();
+		if (endCancelled) signal?.removeEventListener("abort", endCancelled);
+	}
+}
+async function tracedTurn(options, input, turnOptions, knownSessionId, send) {
+	const startTime = /* @__PURE__ */ new Date();
+	const start = performance.now();
+	const signal = turnOptions?.signal;
+	const spanFor = (sessionId) => startSpan(options.spanName ?? "invoke_agent", {
+		type: "agent",
+		agentName: options.agentName,
+		input,
+		startTime,
+		attributes: sessionId === void 0 ? void 0 : { "gen_ai.conversation.id": sessionId }
+	});
+	let response;
+	try {
+		response = await send();
+	} catch (error) {
+		const span = spanFor(knownSessionId);
+		if (signal?.aborted) span.end({
+			error: failureError("cancelled", "cancelled"),
+			finishReason: "cancelled"
+		});
+		else span.end({ error: error instanceof Error ? error : new Error(String(error)) });
+		throw error;
 	}
+	const span = spanFor(response.sessionId);
+	let streamStarted = false;
+	let endedBeforeStream = false;
+	const endCancelled = () => {
+		if (streamStarted) return;
+		endedBeforeStream = true;
+		span.end({
+			error: failureError("cancelled", "cancelled"),
+			finishReason: "cancelled"
+		});
+	};
+	if (signal?.aborted) endCancelled();
+	else signal?.addEventListener("abort", endCancelled, { once: true });
+	return new MessageResponse({
+		cancelTurn: () => response.cancel(),
+		createStream: () => {
+			streamStarted = true;
+			if (endedBeforeStream) return (async function* () {
+				yield* response;
+			})();
+			return instrumentedStream(response, span, start, signal, endCancelled);
+		},
+		sessionId: response.sessionId
+	});
 }
 function wrapSession(session, options) {
 	return new Proxy(session, { get(target, prop) {
 		if (prop === "send") {
-			const wrappedSend = async (input) => {
-				const turnPayload = input instanceof String || input?.constructor === String ? { message: String(input) } : input;
-				const span = startSpan(options.spanName ?? "invoke_agent", {
-					type: "agent",
-					agentName: options.agentName,
-					input: inputForSpan(turnPayload)
-				});
-				const start = performance.now();
-				let response;
-				try {
-					response = await target.send(input);
-				} catch (error) {
-					if (turnPayload.signal?.aborted) span.end({
-						error: failureError("cancelled", "cancelled"),
-						finishReason: "cancelled"
-					});
-					else span.end({ error: error instanceof Error ? error : new Error(String(error)) });
-					throw error;
-				}
-				span.span.setAttribute("gen_ai.conversation.id", response.sessionId);
-				return new MessageResponse({
-					continuationToken: response.continuationToken,
-					sessionId: response.sessionId,
-					createStream: () => instrumentedStream(response, span, start, turnPayload)
-				});
+			const send = (message, turnOptions) => tracedTurn(options, message, turnOptions, target.state.sessionId, () => target.send(message, turnOptions));
+			return send;
+		}
+		if (prop === "respond") {
+			const respond = (inputResponses, turnOptions) => tracedTurn(options, inputResponses, turnOptions, target.state.sessionId, () => target.respond(inputResponses, turnOptions));
+			return respond;
+		}
+		return bindOrReturn(target, prop);
+	} });
+}
+function wrapSessions(sessions, options) {
+	return new Proxy(sessions, { get(target, prop) {
+		if (prop === "create") {
+			const create = async (input) => {
+				let session;
+				return {
+					response: await tracedTurn(options, input.message, input, void 0, async () => {
+						const created = await target.create(input);
+						session = created.session;
+						return created.response;
+					}),
+					session: wrapSession(session, options)
+				};
 			};
-			return wrappedSend;
+			return create;
+		}
+		if (prop === "attach") {
+			const attach = (sessionId, attachOptions) => wrapSession(target.attach(sessionId, attachOptions), options);
+			return attach;
 		}
 		return bindOrReturn(target, prop);
 	} });
@@ -182,8 +265,9 @@ function wrapSession(session, options) {
 function wrapEveClient(client, options = {}, overrides) {
 	const { agentName: _agentName, spanName: _spanName, ...sdkOptions } = options;
 	ensureInit(sdkOptions, overrides);
+	const sessions = wrapSessions(client.sessions, options);
 	return new Proxy(client, { get(target, prop) {
-		if (prop === "session") return (state) => wrapSession(target.session(state), options);
+		if (prop === "sessions") return sessions;
 		return bindOrReturn(target, prop);
 	} });
 }
@@ -240,7 +324,7 @@ function reportError$1(onError, error) {
 	} catch {}
 }
 function emit(event, ctx, level, message, attributes = {}, baseEvent = event) {
-	const at = event.meta?.at;
+	const at = event.meta.at;
 	log(message, {
 		level,
 		eventName: event.type,
@@ -264,10 +348,11 @@ function logEvent(event, ctx) {
 		case "session.started": {
 			const runtime = asRecord(data.runtime);
 			const invocation = asRecord(data.invocation);
+			const trace = asRecord(data.trace);
 			emit(event, ctx, "info", "Session started", {
 				"eve.version": stringField(runtime, "eveVersion"),
-				"gen_ai.request.model": stringField(runtime, "modelId"),
 				"eve.agent.id": stringField(runtime, "agentId"),
+				"eve.trace.id": stringField(trace, "traceId"),
 				"eve.parent.session_id": stringField(invocation, "parentSessionId"),
 				"eve.parent.call_id": stringField(invocation, "parentCallId"),
 				"eve.parent.turn_id": stringField(invocation, "parentTurnId"),
@@ -281,6 +366,9 @@ function logEvent(event, ctx) {
 		case "message.received":
 			emit(event, ctx, "debug", "User message received");
 			return;
+		case "step.started":
+			emit(event, ctx, "debug", "Step started", { "gen_ai.request.model": stringField(data, "modelId") });
+			return;
 		case "step.completed": {
 			const usage = asRecord(data.usage);
 			emit(event, ctx, "info", stepCompletedMessage(data), {
@@ -336,31 +424,7 @@ function logEvent(event, ctx) {
 				"eve.subagent.name": stringField(data, "subagentName"),
 				"gen_ai.tool.call.id": stringField(data, "callId")
 			};
-			if (childType === "step.failed") {
-				emit(event, ctx, "error", `Subagent step failed: ${stringField(childData, "message") ?? ""}`, {
-					...attrs,
-					"error.code": stringField(childData, "code"),
-					"eve.error.details": jsonField(childData, "details")
-				}, {
-					...child,
-					data: childData,
-					type: childType
-				});
-				return;
-			}
-			if (childType === "turn.failed") {
-				emit(event, ctx, "error", `Subagent turn failed: ${stringField(childData, "message") ?? ""}`, {
-					...attrs,
-					"error.code": stringField(childData, "code"),
-					"eve.error.details": jsonField(childData, "details")
-				}, {
-					...child,
-					data: childData,
-					type: childType
-				});
-				return;
-			}
-			if (childType === "session.failed") emit(event, ctx, "error", `Subagent session failed: ${stringField(childData, "message") ?? ""}`, {
+			if (childType === "step.failed" || childType === "turn.failed" || childType === "session.failed") emit(event, ctx, "error", `Subagent ${childType.replace(".", " ")}: ${stringField(childData, "message") ?? ""}`, {
 				...attrs,
 				"error.code": stringField(childData, "code"),
 				"eve.error.details": jsonField(childData, "details")
@@ -401,6 +465,9 @@ function logEvent(event, ctx) {
 		case "turn.completed":
 			emit(event, ctx, "info", "Turn completed");
 			return;
+		case "turn.cancelled":
+			emit(event, ctx, "warn", "Turn cancelled");
+			return;
 		case "turn.failed":
 			emit(event, ctx, "error", `Turn failed: ${stringField(data, "message") ?? ""}`, {
 				"error.code": stringField(data, "code"),
@@ -478,4 +545,22 @@ function telemetryDevInstrumentation(options = {}, overrides) {
 	return definition;
 }
 //#endregion
-export { telemetryDevHook, telemetryDevInstrumentation, wrapEveClient };
+//#region src/otel.ts
+/**
+* telemetry.dev as a destination in eve's `agent/instrumentation/` provider layout
+* (`experimental.instrumentationProviders`). Export it from one file in that directory.
+* eve owns the tracer provider there, so this attaches a processor instead of registering one.
+*/
+function telemetryDevOtelIntegration(options = {}) {
+	const { recordInputs, recordOutputs, ...processorOptions } = options;
+	return otelIntegration({
+		recordInputs,
+		recordOutputs,
+		spanProcessors: [new TelemetrySpanProcessor({
+			...processorOptions,
+			spanFilter: processorOptions.spanFilter ?? ((span) => isAiScope(span.instrumentationScope.name))
+		})]
+	});
+}
+//#endregion
+export { telemetryDevHook, telemetryDevInstrumentation, telemetryDevOtelIntegration, wrapEveClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telemetry-dev/eve",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Eve (Vercel agent framework) telemetry integration for telemetry.dev.",
   "keywords": [
     "agents",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@telemetry-dev/sdk": "^0.1.1"
+    "@telemetry-dev/sdk": "^0.1.2"
   },
   "devDependencies": {
     "@opentelemetry/sdk-logs": "^0.218.0",
@@ -45,14 +45,14 @@
     "@types/node": "^25.5.0",
     "@typescript/native-preview": "7.0.0-dev.20260328.1",
     "ai": "7.0.0",
-    "eve": "0.19.0",
+    "eve": "0.50.0",
     "typescript": "^6.0.2",
     "vite-plus": "0.1.20",
     "vitest": "npm:@voidzero-dev/vite-plus-test@0.1.20",
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "eve": ">=0.19.0 <1"
+    "eve": ">=0.47.0 <1"
   },
   "scripts": {
     "build": "pnpm exec vp pack",

package/src/client.ts

@@ -8,10 +8,11 @@ import {
 import type {
   Client,
   ClientSession,
-  HandleMessageStreamEvent,
+  ClientSessions,
+  InputResponse,
+  MessageStreamEvent,
   SendTurnInput,
-  SendTurnPayload,
-  SessionState,
+  SendTurnOptions,
 } from "eve/client";
 import { isCurrentTurnBoundaryEvent, MessageResponse } from "eve/client";
 
@@ -48,7 +49,7 @@ function numberField(record: EventRecord | undefined, key: string): number | und
   return value?.constructor === Number ? value : undefined;
 }
 
-function eventData(event: HandleMessageStreamEvent): EventRecord {
+function eventData(event: MessageStreamEvent): EventRecord {
   if (!("data" in event)) return {};
   return asRecord(event.data as EventValue) ?? {};
 }
@@ -75,16 +76,12 @@ function failureError(code: string | undefined, message: string | undefined): Er
   return error;
 }
 
-function inputForSpan<TOutput>(payload: SendTurnPayload<TOutput>) {
-  return payload.message ?? payload.inputResponses;
-}
-
 function bindOrReturn<T extends object>(target: T, prop: string | symbol) {
   const value = target[prop as keyof T];
   return value instanceof Function ? value.bind(target) : value;
 }
 
-function addLifecycleEvent(span: SpanHandle, event: HandleMessageStreamEvent): void {
+function addLifecycleEvent(span: SpanHandle, event: MessageStreamEvent): void {
   const data = eventData(event);
   switch (event.type) {
     case "subagent.called": {
@@ -125,19 +122,25 @@ async function* instrumentedStream<TOutput>(
   response: MessageResponse<TOutput>,
   span: SpanHandle,
   start: number,
-  payload: SendTurnPayload<TOutput>,
-): AsyncGenerator<HandleMessageStreamEvent> {
+  signal: AbortSignal | undefined,
+  endCancelled: (() => void) | undefined,
+): AsyncGenerator<MessageStreamEvent> {
   const usage: TokenUsage = {};
   let sawUsage = false;
   let output: unknown;
   let finishReason: string | undefined;
+  let costUsd: number | undefined;
+  let allCostsKnown = true;
   let timeToFirstChunkMs: number | undefined;
   let error: unknown;
+  let done = false;
   let sawTerminalEvent = false;
 
   const finish = (): void => {
+    if (done) return;
+    done = true;
     if (!sawTerminalEvent && error === undefined) {
-      if (payload.signal?.aborted) {
+      if (signal?.aborted) {
         error = failureError("cancelled", "cancelled");
         finishReason ??= "cancelled";
       } else {
@@ -148,6 +151,10 @@ async function* instrumentedStream<TOutput>(
     span.end({
       usage: sawUsage ? usage : undefined,
       finishReason,
+      costUsd:
+        sawTerminalEvent && error === undefined && allCostsKnown && Number.isFinite(costUsd)
+          ? costUsd
+          : undefined,
       output,
       timeToFirstChunkMs,
       error: error instanceof Error ? error : error === undefined ? undefined : new Error("error"),
@@ -157,6 +164,16 @@ async function* instrumentedStream<TOutput>(
   try {
     for await (const event of response) {
       const data = eventData(event);
+      if (event.type === "turn.started") {
+        const turnTrace = asRecord(data.trace);
+        const traceId = stringField(turnTrace, "traceId");
+        const spanId = stringField(turnTrace, "spanId");
+        const turnId = stringField(data, "turnId");
+        if (traceId && spanId && turnId) {
+          span.span.setAttribute("td.eve.turn_root", `${traceId}/${spanId}`);
+          span.span.setAttribute("eve.turn.id", turnId);
+        }
+      }
       if (isCurrentTurnBoundaryEvent(event)) sawTerminalEvent = true;
       if (
         timeToFirstChunkMs === undefined &&
@@ -180,6 +197,12 @@ async function* instrumentedStream<TOutput>(
             "cacheCreationInputTokens",
             numberField(eventUsage, "cacheWriteTokens"),
           ) || sawUsage;
+        const stepCost = numberField(eventUsage, "costUsd");
+        if (stepCost === undefined || !Number.isFinite(stepCost) || stepCost < 0) {
+          allCostsKnown = false;
+        } else {
+          costUsd = (costUsd ?? 0) + stepCost;
+        }
         finishReason = stringField(data, "finishReason") ?? finishReason;
       }
 
@@ -204,12 +227,16 @@ async function* instrumentedStream<TOutput>(
         }
         finishReason = "error";
       }
+      if (event.type === "turn.cancelled") {
+        error = failureError("cancelled", "cancelled");
+        finishReason = "cancelled";
+      }
 
       addLifecycleEvent(span, event);
       yield event;
     }
   } catch (caught) {
-    if (payload.signal?.aborted) {
+    if (signal?.aborted) {
       error = failureError("cancelled", "cancelled");
       finishReason ??= "cancelled";
     } else {
@@ -218,52 +245,116 @@ async function* instrumentedStream<TOutput>(
     throw caught;
   } finally {
     finish();
+    if (endCancelled) signal?.removeEventListener("abort", endCancelled);
+  }
+}
+
+async function tracedTurn<TOutput>(
+  options: WrapEveClientOptions,
+  input: SendTurnInput["message"] | readonly InputResponse[],
+  turnOptions: SendTurnOptions<TOutput> | undefined,
+  knownSessionId: string | undefined,
+  send: () => Promise<MessageResponse<TOutput>>,
+): Promise<MessageResponse<TOutput>> {
+  // The session id is only known after the POST (first turn), so the span starts once the
+  // request resolves with the original start time; that lets it join the session trace.
+  const startTime = new Date();
+  const start = performance.now();
+  const signal = turnOptions?.signal;
+  const spanFor = (sessionId: string | undefined) =>
+    startSpan(options.spanName ?? "invoke_agent", {
+      type: "agent",
+      agentName: options.agentName,
+      input,
+      startTime,
+      attributes: sessionId === undefined ? undefined : { "gen_ai.conversation.id": sessionId },
+    });
+  let response: MessageResponse<TOutput>;
+  try {
+    response = await send();
+  } catch (error) {
+    const span = spanFor(knownSessionId);
+    if (signal?.aborted) {
+      span.end({ error: failureError("cancelled", "cancelled"), finishReason: "cancelled" });
+    } else {
+      span.end({ error: error instanceof Error ? error : new Error(String(error)) });
+    }
+    throw error;
+  }
+  const span = spanFor(response.sessionId);
+  let streamStarted = false;
+  let endedBeforeStream = false;
+  const endCancelled = () => {
+    if (streamStarted) return;
+    endedBeforeStream = true;
+    span.end({ error: failureError("cancelled", "cancelled"), finishReason: "cancelled" });
+  };
+  if (signal?.aborted) {
+    endCancelled();
+  } else {
+    signal?.addEventListener("abort", endCancelled, { once: true });
   }
+  // MessageResponse's constructor is @internal in eve; re-wrapping the stream has no
+  // public alternative. cancel() forwards to the original response, whose turn id
+  // resolves because instrumentedStream consumes it.
+  return new MessageResponse<TOutput>({
+    cancelTurn: () => response.cancel(),
+    createStream: () => {
+      streamStarted = true;
+      // The span already ended on abort; hand back the raw stream instead of ending it twice.
+      if (endedBeforeStream)
+        return (async function* () {
+          yield* response;
+        })();
+      return instrumentedStream(response, span, start, signal, endCancelled);
+    },
+    sessionId: response.sessionId,
+  });
 }
 
 function wrapSession(session: ClientSession, options: WrapEveClientOptions): ClientSession {
   return new Proxy(session, {
     get(target, prop) {
       if (prop === "send") {
-        const wrappedSend: ClientSession["send"] = async <TOutput = unknown>(
+        const send: ClientSession["send"] = (message, turnOptions) =>
+          tracedTurn(options, message, turnOptions, target.state.sessionId, () =>
+            target.send(message, turnOptions),
+          );
+        return send;
+      }
+      if (prop === "respond") {
+        const respond: ClientSession["respond"] = (inputResponses, turnOptions) =>
+          tracedTurn(options, inputResponses, turnOptions, target.state.sessionId, () =>
+            target.respond(inputResponses, turnOptions),
+          );
+        return respond;
+      }
+      return bindOrReturn(target, prop);
+    },
+  });
+}
+
+function wrapSessions(sessions: ClientSessions, options: WrapEveClientOptions): ClientSessions {
+  return new Proxy(sessions, {
+    get(target, prop) {
+      if (prop === "create") {
+        const create: ClientSessions["create"] = async <TOutput = unknown>(
           input: SendTurnInput<TOutput>,
         ) => {
-          const payload =
-            input instanceof String || input?.constructor === String
-              ? { message: String(input) }
-              : input;
-          const turnPayload = payload as SendTurnPayload<TOutput>;
-          const span = startSpan(options.spanName ?? "invoke_agent", {
-            type: "agent",
-            agentName: options.agentName,
-            input: inputForSpan(turnPayload),
-          });
-          const start = performance.now();
-          let response: MessageResponse<TOutput>;
-          try {
-            response = await target.send(input);
-          } catch (error) {
-            if (turnPayload.signal?.aborted) {
-              span.end({
-                error: failureError("cancelled", "cancelled"),
-                finishReason: "cancelled",
-              });
-            } else {
-              span.end({ error: error instanceof Error ? error : new Error(String(error)) });
-            }
-            throw error;
-          }
-
-          span.span.setAttribute("gen_ai.conversation.id", response.sessionId);
-          // MessageResponse's constructor is @internal in eve; re-wrapping the stream has no
-          // public alternative. Revisit on eve upgrades.
-          return new MessageResponse<TOutput>({
-            continuationToken: response.continuationToken,
-            sessionId: response.sessionId,
-            createStream: () => instrumentedStream(response, span, start, turnPayload),
+          let session: ClientSession | undefined;
+          const response = await tracedTurn(options, input.message, input, undefined, async () => {
+            const created = await target.create(input);
+            session = created.session;
+            return created.response;
           });
+          return { response, session: wrapSession(session!, options) };
         };
-        return wrappedSend;
+        return create;
+      }
+      if (prop === "attach") {
+        const attach: ClientSessions["attach"] = (sessionId, attachOptions) =>
+          wrapSession(target.attach(sessionId, attachOptions), options);
+        return attach;
       }
       return bindOrReturn(target, prop);
     },
@@ -277,11 +368,10 @@ export function wrapEveClient<C extends Client>(
 ): C {
   const { agentName: _agentName, spanName: _spanName, ...sdkOptions } = options;
   ensureInit(sdkOptions, overrides);
+  const sessions = wrapSessions(client.sessions, options);
   return new Proxy(client, {
     get(target, prop) {
-      if (prop === "session") {
-        return (state?: SessionState | string) => wrapSession(target.session(state), options);
-      }
+      if (prop === "sessions") return sessions;
       return bindOrReturn(target, prop);
     },
   }) as C;

package/src/config.ts

@@ -1,4 +1,10 @@
-import { init, shutdown, type ClientOverrides, type TelemetryOptions } from "@telemetry-dev/sdk";
+import {
+  init,
+  SCOPE_NAME,
+  shutdown,
+  type ClientOverrides,
+  type TelemetryOptions,
+} from "@telemetry-dev/sdk";
 
 /** Options accepted by every @telemetry-dev/eve entry point. */
 export type TelemetryDevEveOptions = Omit<TelemetryOptions, "registerGlobal" | "sdkName">;
@@ -7,12 +13,25 @@ export type { ClientOverrides };
 
 let initialized = false;
 
+// eve's agent spans ("eve" in agent/instrumentation.ts, "eve.agent" in the provider layout), the
+// AI SDK's model-call and tool spans ("gen_ai", emitted by @ai-sdk/otel), and this SDK's own
+// client-wrapper spans. Everything else on the global provider (better-auth, Nitro, eve's
+// "workflow" engine) is not AI telemetry.
+const AI_SCOPES = {
+  eve: true,
+  "eve.agent": true,
+  gen_ai: true,
+  [SCOPE_NAME]: true,
+} satisfies Record<string, true>;
+
+export const isAiScope = (scope: string): boolean => Object.hasOwn(AI_SCOPES, scope);
+
 /**
  * Initializes the telemetry.dev SDK exactly once per process for this integration.
- * registerGlobal:true lets eve's tracers (scopes "eve" and "gen_ai") resolve to
- * the SDK provider. spanFilter defaults to exporting everything except eve's
- * internal workflow-engine spans (scope "workflow"); pass spanFilter: () => true
- * to export those too.
+ * registerGlobal:true lets eve's tracers resolve to the SDK provider. spanFilter defaults to
+ * exporting only AI scopes (see AI_SCOPES); pass spanFilter: () => true to export every span.
+ * eve starts each `ai.eve.turn` under a workflow-engine span of its own trace, so the turn is
+ * re-rooted under the session parent and every turn of a session lands in one trace.
  */
 export function ensureInit(
   options: TelemetryDevEveOptions = {},
@@ -25,7 +44,11 @@ export function ensureInit(
       ...options,
       sdkName: "@telemetry-dev/eve",
       registerGlobal: true,
-      spanFilter: options.spanFilter ?? ((span) => span.instrumentationScope.name !== "workflow"),
+      spanFilter: options.spanFilter ?? ((span) => isAiScope(span.instrumentationScope.name)),
+      sessionRootOf: (name, attributes) => {
+        const sessionId = attributes["eve.session.id"];
+        return name === "ai.eve.turn" && typeof sessionId === "string" ? sessionId : undefined;
+      },
     },
     overrides,
   );

package/src/hook.ts

@@ -1,5 +1,5 @@
 import { log, type LogLevel } from "@telemetry-dev/sdk";
-import type { HandleMessageStreamEvent } from "eve/client";
+import type { MessageStreamEvent } from "eve/client";
 import type { HookContext, HookDefinition } from "eve/hooks";
 
 import { ensureInit, type ClientOverrides, type TelemetryDevEveOptions } from "./config.ts";
@@ -12,7 +12,7 @@ function asRecord(value: Value): Attrs | undefined {
   return value as Attrs;
 }
 
-function eventData(event: HandleMessageStreamEvent): Attrs {
+function eventData(event: MessageStreamEvent): Attrs {
   if (!("data" in event)) return {};
   return asRecord(event.data as Value) ?? {};
 }
@@ -37,7 +37,7 @@ function jsonField(record: Attrs | undefined, key: string): string | undefined {
   }
 }
 
-function baseAttributes(event: HandleMessageStreamEvent, ctx: HookContext) {
+function baseAttributes(event: MessageStreamEvent, ctx: HookContext) {
   const data = eventData(event);
   return {
     "gen_ai.conversation.id": ctx.session.id,
@@ -69,14 +69,14 @@ function reportError(onError: ((error: Error) => void) | undefined, error: Error
 }
 
 function emit(
-  event: HandleMessageStreamEvent,
+  event: MessageStreamEvent,
   ctx: HookContext,
   level: LogLevel,
   message: string,
   attributes: Attrs = {},
-  baseEvent: HandleMessageStreamEvent = event,
+  baseEvent: MessageStreamEvent = event,
 ): void {
-  const at = event.meta?.at;
+  const at = event.meta.at;
   log(message, {
     level,
     eventName: event.type,
@@ -97,17 +97,18 @@ function stepCompletedMessage(data: Attrs): string {
   return `Step completed (${finishReason})${suffix}`;
 }
 
-function logEvent(event: HandleMessageStreamEvent, ctx: HookContext): void {
+function logEvent(event: MessageStreamEvent, ctx: HookContext): void {
   const data = eventData(event);
 
   switch (event.type) {
     case "session.started": {
       const runtime = asRecord(data.runtime);
       const invocation = asRecord(data.invocation);
+      const trace = asRecord(data.trace);
       emit(event, ctx, "info", "Session started", {
         "eve.version": stringField(runtime, "eveVersion"),
-        "gen_ai.request.model": stringField(runtime, "modelId"),
         "eve.agent.id": stringField(runtime, "agentId"),
+        "eve.trace.id": stringField(trace, "traceId"),
         "eve.parent.session_id": stringField(invocation, "parentSessionId"),
         "eve.parent.call_id": stringField(invocation, "parentCallId"),
         "eve.parent.turn_id": stringField(invocation, "parentTurnId"),
@@ -121,6 +122,11 @@ function logEvent(event: HandleMessageStreamEvent, ctx: HookContext): void {
     case "message.received":
       emit(event, ctx, "debug", "User message received");
       return;
+    case "step.started":
+      emit(event, ctx, "debug", "Step started", {
+        "gen_ai.request.model": stringField(data, "modelId"),
+      });
+      return;
     case "step.completed": {
       const usage = asRecord(data.usage);
       emit(event, ctx, "info", stepCompletedMessage(data), {
@@ -194,31 +200,16 @@ function logEvent(event: HandleMessageStreamEvent, ctx: HookContext): void {
         "eve.subagent.name": stringField(data, "subagentName"),
         "gen_ai.tool.call.id": stringField(data, "callId"),
       };
-      if (childType === "step.failed") {
-        emit(
-          event,
-          ctx,
-          "error",
-          `Subagent step failed: ${stringField(childData, "message") ?? ""}`,
-          {
-            ...attrs,
-            "error.code": stringField(childData, "code"),
-            "eve.error.details": jsonField(childData, "details"),
-          },
-          {
-            ...child,
-            data: childData,
-            type: childType,
-          } as HandleMessageStreamEvent,
-        );
-        return;
-      }
-      if (childType === "turn.failed") {
+      if (
+        childType === "step.failed" ||
+        childType === "turn.failed" ||
+        childType === "session.failed"
+      ) {
         emit(
           event,
           ctx,
           "error",
-          `Subagent turn failed: ${stringField(childData, "message") ?? ""}`,
+          `Subagent ${childType.replace(".", " ")}: ${stringField(childData, "message") ?? ""}`,
           {
             ...attrs,
             "error.code": stringField(childData, "code"),
@@ -228,26 +219,7 @@ function logEvent(event: HandleMessageStreamEvent, ctx: HookContext): void {
             ...child,
             data: childData,
             type: childType,
-          } as HandleMessageStreamEvent,
-        );
-        return;
-      }
-      if (childType === "session.failed") {
-        emit(
-          event,
-          ctx,
-          "error",
-          `Subagent session failed: ${stringField(childData, "message") ?? ""}`,
-          {
-            ...attrs,
-            "error.code": stringField(childData, "code"),
-            "eve.error.details": jsonField(childData, "details"),
-          },
-          {
-            ...child,
-            data: childData,
-            type: childType,
-          } as HandleMessageStreamEvent,
+          } as MessageStreamEvent,
         );
       }
       return;
@@ -284,6 +256,9 @@ function logEvent(event: HandleMessageStreamEvent, ctx: HookContext): void {
     case "turn.completed":
       emit(event, ctx, "info", "Turn completed");
       return;
+    case "turn.cancelled":
+      emit(event, ctx, "warn", "Turn cancelled");
+      return;
     case "turn.failed":
       emit(event, ctx, "error", `Turn failed: ${stringField(data, "message") ?? ""}`, {
         "error.code": stringField(data, "code"),

package/src/index.ts

@@ -5,3 +5,4 @@ export {
   telemetryDevInstrumentation,
   type TelemetryDevInstrumentationOptions,
 } from "./instrumentation.ts";
+export { telemetryDevOtelIntegration, type TelemetryDevOtelIntegrationOptions } from "./otel.ts";

package/src/otel.ts

@@ -0,0 +1,34 @@
+import { TelemetrySpanProcessor, type TelemetrySpanProcessorOptions } from "@telemetry-dev/sdk";
+import { otelIntegration, type OtelIntegration } from "eve/instrumentation/otel";
+
+import { isAiScope } from "./config.ts";
+
+export interface TelemetryDevOtelIntegrationOptions extends Omit<
+  TelemetrySpanProcessorOptions,
+  "spanExporter"
+> {
+  recordInputs?: boolean;
+  recordOutputs?: boolean;
+}
+
+/**
+ * telemetry.dev as a destination in eve's `agent/instrumentation/` provider layout
+ * (`experimental.instrumentationProviders`). Export it from one file in that directory.
+ * eve owns the tracer provider there, so this attaches a processor instead of registering one.
+ */
+export function telemetryDevOtelIntegration(
+  options: TelemetryDevOtelIntegrationOptions = {},
+): OtelIntegration {
+  const { recordInputs, recordOutputs, ...processorOptions } = options;
+  return otelIntegration({
+    recordInputs,
+    recordOutputs,
+    spanProcessors: [
+      new TelemetrySpanProcessor({
+        ...processorOptions,
+        spanFilter:
+          processorOptions.spanFilter ?? ((span) => isAiScope(span.instrumentationScope.name)),
+      }),
+    ],
+  });
+}