@telemetry-dev/eve 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 telemetry.dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# @telemetry-dev/eve
+
+Eve telemetry integration for [telemetry.dev](https://telemetry.dev). It wires Vercel's
+[Eve](https://eve.dev) agent framework to telemetry.dev through Eve's native OpenTelemetry,
+lifecycle-hook, and HTTP-client surfaces.
+
+## Install
+
+```sh
+npm install @telemetry-dev/eve eve
+```
+
+Requires `eve >=0.19.0 <1` and Node.js 24 or newer.
+
+## Environment
+
+| Variable                    | Required | Default                        | Notes                                                                   |
+| --------------------------- | -------- | ------------------------------ | ----------------------------------------------------------------------- |
+| `TELEMETRY_DEV_API_KEY`     | yes      | —                              | Ingest key (`td_live_…`). No key ⇒ the integration is a complete no-op. |
+| `TELEMETRY_DEV_BASE_URL`    | no       | `https://ingest.telemetry.dev` | Trailing slashes are stripped.                                          |
+| `TELEMETRY_DEV_ENVIRONMENT` | no       | `production`                   | Environment label on every trace/log.                                   |
+| `OTEL_SERVICE_NAME`         | no       | SDK default                    | Server instrumentation falls back to the Eve agent name after this env. |
+
+All four are also settable through SDK options. Pass SDK options to exactly one entry point in a
+process; whichever initializes first wins. If you only use `telemetryDevHook()` or
+`wrapEveClient()`, pass `serviceName` explicitly or set `OTEL_SERVICE_NAME`.
+
+## Server instrumentation
+
+Create `agent/instrumentation.ts`:
+
+```ts
+import { telemetryDevInstrumentation } from "@telemetry-dev/eve";
+
+export default telemetryDevInstrumentation();
+```
+
+This registers telemetry.dev as the global OpenTelemetry provider during Eve startup, so Eve's tracer
+scope (`"eve"`) and the AI SDK GenAI tracer scope (`"gen_ai"`) export to telemetry.dev.
+
+Useful options:
+
+```ts
+export default telemetryDevInstrumentation({
+  functionId: "support-agent",
+  recordInputs: false,
+  recordOutputs: true,
+  runtimeContext: { "team.id": "support" },
+  stepStarted(input) {
+    return { runtimeContext: { "channel.kind": input.channel.kind } };
+  },
+});
+```
+
+`recordInputs` defaults to `captureInput ?? true`; `recordOutputs` defaults to
+`captureOutput ?? true`. Runtime context is attached by Eve to model-call spans under the
+`ai.settings.context.` prefix. The integration also adds `user.id` when Eve auth exposes a principal.
+
+## Lifecycle logs
+
+Create `agent/hooks/telemetry-dev.ts`:
+
+```ts
+import { telemetryDevHook } from "@telemetry-dev/eve";
+
+export default telemetryDevHook();
+```
+
+The hook emits bounded lifecycle logs for:
+
+- session start/completion/failure;
+- turn start/completion/failure;
+- user message receipt without message content;
+- step completion/failure with usage where available;
+- non-completed tool results;
+- HITL input requests and authorization outcomes;
+- subagent calls/completions;
+- compaction requests/completions.
+
+Every log includes `gen_ai.conversation.id`, `gen_ai.agent.name`, Eve turn/step ids when present, and
+`eventName` equal to the Eve stream-event type. Hook handlers are fail-open; instrumentation errors are
+routed to `onError` and never thrown back into Eve.
+
+## Client wrapper
+
+For apps that call an Eve agent over HTTP:
+
+```ts
+import { wrapEveClient } from "@telemetry-dev/eve";
+import { Client } from "eve/client";
+
+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 result = await response.result();
+```
+
+`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.
+
+`ClientSession.stream()`, `Client.info()`, and `Client.health()` are intentionally not spanned.
+Attach-streams are unbounded and the probe routes are not agent turns.
+
+## Trace shape
+
+A typical turn contains:
+
+- Eve server root span `ai.eve.turn`, normalized by telemetry.dev as `invoke_agent`.
+- Nested AI SDK GenAI spans: `chat {modelId}`, `step N`, provider `chat {modelId}` client spans, and
+  `execute_tool {toolName}` spans.
+- Usage attributes such as `gen_ai.usage.input_tokens`, `gen_ai.usage.output_tokens`, cache token
+  counts, finish reasons, response ids, TTFT, and time-per-output-chunk when Eve's AI SDK integration
+  emits them.
+- Runtime context attributes under `ai.settings.context.*`, including Eve session/turn/step/channel
+  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.
+
+## 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.
+
+## 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.
+- 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,
+  so this package does not capture them.

package/dist/index.d.mts

@@ -0,0 +1,37 @@
+import { ClientOverrides, ClientOverrides as ClientOverrides$1, TelemetryOptions } from "@telemetry-dev/sdk";
+import { Client } from "eve/client";
+import { HookDefinition } from "eve/hooks";
+import { InstrumentationDefinition, InstrumentationEvents, InstrumentationRuntimeContext } from "eve/instrumentation";
+
+//#region src/config.d.ts
+/** Options accepted by every @telemetry-dev/eve entry point. */
+type TelemetryDevEveOptions = Omit<TelemetryOptions, "registerGlobal">;
+//#endregion
+//#region src/client.d.ts
+interface WrapEveClientOptions extends TelemetryDevEveOptions {
+  /** gen_ai.agent.name on turn spans. */
+  agentName?: string;
+  /** Span name for each send() turn. Default "invoke_agent". */
+  spanName?: string;
+}
+declare function wrapEveClient<C extends Client>(client: C, options?: WrapEveClientOptions, overrides?: ClientOverrides): C;
+//#endregion
+//#region src/hook.d.ts
+declare function telemetryDevHook(options?: TelemetryDevEveOptions, overrides?: ClientOverrides$1): HookDefinition;
+//#endregion
+//#region src/instrumentation.d.ts
+interface TelemetryDevInstrumentationOptions extends TelemetryDevEveOptions {
+  /** ai.telemetry.functionId override; eve defaults it to the agent name. */
+  functionId?: string;
+  /** Record model inputs on spans. Default: captureInput ?? true. */
+  recordInputs?: boolean;
+  /** Record model outputs on spans. Default: captureOutput ?? true. */
+  recordOutputs?: boolean;
+  /** Static runtime context merged into every model-call span. */
+  runtimeContext?: InstrumentationRuntimeContext;
+  /** User step.started callback, composed with the integration's own. */
+  stepStarted?: InstrumentationEvents["step.started"];
+}
+declare function telemetryDevInstrumentation(options?: TelemetryDevInstrumentationOptions, overrides?: ClientOverrides$1): InstrumentationDefinition;
+//#endregion
+export { type TelemetryDevEveOptions, type TelemetryDevInstrumentationOptions, type WrapEveClientOptions, telemetryDevHook, telemetryDevInstrumentation, wrapEveClient };

package/dist/index.mjs

@@ -0,0 +1,465 @@
+import { init, log, startSpan } from "@telemetry-dev/sdk";
+import { MessageResponse, isCurrentTurnBoundaryEvent } from "eve/client";
+//#region src/config.ts
+let initialized = false;
+/**
+* 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.
+*/
+function ensureInit(options = {}, overrides) {
+	if (initialized) return;
+	initialized = true;
+	init({
+		...options,
+		registerGlobal: true,
+		spanFilter: options.spanFilter ?? ((span) => span.instrumentationScope.name !== "workflow")
+	}, overrides);
+}
+//#endregion
+//#region src/client.ts
+function asRecord$1(value) {
+	if (value === null || typeof value !== "object") return void 0;
+	return value;
+}
+function stringField$1(record, key) {
+	const value = record?.[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberField$1(record, key) {
+	const value = record?.[key];
+	return typeof value === "number" ? value : void 0;
+}
+function eventData$1(event) {
+	if (!("data" in event)) return {};
+	return asRecord$1(event.data) ?? {};
+}
+function eventAttributes(attributes) {
+	const out = {};
+	for (const [key, value] of Object.entries(attributes)) if (value !== void 0) out[key] = value;
+	return out;
+}
+function addUsage(usage, key, value) {
+	if (value === void 0) return false;
+	usage[key] = (usage[key] ?? 0) + value;
+	return true;
+}
+function failureError(code, message) {
+	const error = new Error(message ?? code ?? "error");
+	if (code) error.name = code;
+	return error;
+}
+function inputForSpan(payload) {
+	return payload.message ?? payload.inputResponses;
+}
+function bindOrReturn(target, prop) {
+	const value = Reflect.get(target, prop, target);
+	return typeof value === "function" ? value.bind(target) : value;
+}
+function addLifecycleEvent(span, event) {
+	const data = eventData$1(event);
+	switch (event.type) {
+		case "subagent.called": {
+			const remote = asRecord$1(data.remote);
+			span.span.addEvent(event.type, eventAttributes({
+				"eve.subagent.name": stringField$1(data, "name"),
+				"gen_ai.tool.name": stringField$1(data, "toolName"),
+				"gen_ai.tool.call.id": stringField$1(data, "callId"),
+				"eve.child.session_id": stringField$1(data, "childSessionId"),
+				"eve.workflow.id": stringField$1(data, "workflowId"),
+				"eve.remote.url": stringField$1(remote, "url")
+			}));
+			return;
+		}
+		case "input.requested": {
+			const requests = Array.isArray(data.requests) ? data.requests : void 0;
+			span.span.addEvent(event.type, eventAttributes({ "eve.input.request_count": requests?.length }));
+			return;
+		}
+		case "authorization.required":
+			span.span.addEvent(event.type, eventAttributes({ "eve.authorization.name": stringField$1(data, "name") }));
+			return;
+		default: return;
+	}
+}
+async function* instrumentedStream(response, span, start, payload) {
+	const usage = {};
+	let sawUsage = false;
+	let output;
+	let finishReason;
+	let timeToFirstChunkMs;
+	let error;
+	let sawTerminalEvent = false;
+	const finish = () => {
+		if (!sawTerminalEvent && error === void 0) if (payload.signal?.aborted) {
+			error = failureError("cancelled", "cancelled");
+			finishReason ??= "cancelled";
+		} else {
+			error = failureError("stream_incomplete", "stream ended before a terminal event");
+			finishReason ??= "error";
+		}
+		span.end({
+			usage: sawUsage ? usage : void 0,
+			finishReason,
+			output,
+			timeToFirstChunkMs,
+			error
+		});
+	};
+	try {
+		for await (const event of response) {
+			const data = eventData$1(event);
+			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") {
+				const eventUsage = asRecord$1(data.usage);
+				sawUsage = addUsage(usage, "inputTokens", numberField$1(eventUsage, "inputTokens")) || sawUsage;
+				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;
+				finishReason = stringField$1(data, "finishReason") ?? finishReason;
+			}
+			if (event.type === "message.completed" && stringField$1(data, "finishReason") !== "tool-calls") output = data.message;
+			if (event.type === "result.completed") output = data.result;
+			if (event.type === "turn.failed" || event.type === "session.failed" || event.type === "step.failed") {
+				if (error === void 0) {
+					const code = stringField$1(data, "code");
+					error = failureError(code, stringField$1(data, "message"));
+					if (code) span.span.setAttribute("error.code", code);
+				}
+				finishReason = "error";
+			}
+			addLifecycleEvent(span, event);
+			yield event;
+		}
+	} catch (caught) {
+		if (payload.signal?.aborted) {
+			error = failureError("cancelled", "cancelled");
+			finishReason ??= "cancelled";
+		} else error = caught;
+		throw caught;
+	} finally {
+		finish();
+	}
+}
+function wrapSession(session, options) {
+	return new Proxy(session, { get(target, prop) {
+		if (prop === "send") {
+			const wrappedSend = async (input) => {
+				const payload = typeof input === "string" ? { message: input } : input;
+				const span = startSpan(options.spanName ?? "invoke_agent", {
+					type: "agent",
+					agentName: options.agentName,
+					input: inputForSpan(payload)
+				});
+				const start = performance.now();
+				let response;
+				try {
+					response = await target.send(input);
+				} catch (error) {
+					if (payload.signal?.aborted) span.end({
+						error: failureError("cancelled", "cancelled"),
+						finishReason: "cancelled"
+					});
+					else span.end({ 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, payload)
+				});
+			};
+			return wrappedSend;
+		}
+		return bindOrReturn(target, prop);
+	} });
+}
+function wrapEveClient(client, options = {}, overrides) {
+	const { agentName: _agentName, spanName: _spanName, ...sdkOptions } = options;
+	ensureInit(sdkOptions, overrides);
+	return new Proxy(client, { get(target, prop) {
+		if (prop === "session") return (state) => wrapSession(target.session(state), options);
+		return bindOrReturn(target, prop);
+	} });
+}
+//#endregion
+//#region src/hook.ts
+function asRecord(value) {
+	if (value === null || typeof value !== "object") return void 0;
+	return value;
+}
+function eventData(event) {
+	if (!("data" in event)) return {};
+	return asRecord(event.data) ?? {};
+}
+function stringField(record, key) {
+	const value = record?.[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberField(record, key) {
+	const value = record?.[key];
+	return typeof value === "number" ? value : void 0;
+}
+function jsonField(record, key) {
+	const value = record?.[key];
+	if (value === void 0) return void 0;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+}
+function baseAttributes(event, ctx) {
+	const data = eventData(event);
+	return {
+		"gen_ai.conversation.id": ctx.session.id,
+		"gen_ai.agent.name": ctx.agent.name,
+		"eve.channel.kind": ctx.channel.kind,
+		"eve.turn.id": stringField(data, "turnId"),
+		"eve.step.index": numberField(data, "stepIndex"),
+		"eve.turn.sequence": numberField(data, "sequence")
+	};
+}
+function toolAttrs(result) {
+	const record = asRecord(result);
+	const subagentName = stringField(record, "subagentName");
+	return {
+		"gen_ai.tool.name": stringField(record, "toolName") ?? (subagentName ? `eve:subagent:${subagentName}` : void 0),
+		"gen_ai.tool.call.id": stringField(record, "callId"),
+		"eve.subagent.name": subagentName
+	};
+}
+function reportError$1(onError, error) {
+	try {
+		onError?.(error);
+	} catch {}
+}
+function emit(event, ctx, level, message, attributes = {}, baseEvent = event) {
+	const at = event.meta?.at;
+	log(message, {
+		level,
+		eventName: event.type,
+		timestamp: at ? new Date(at) : void 0,
+		attributes: {
+			...baseAttributes(baseEvent, ctx),
+			...attributes
+		}
+	});
+}
+function stepCompletedMessage(data) {
+	const finishReason = stringField(data, "finishReason") ?? "unknown";
+	const usage = asRecord(data.usage);
+	const inputTokens = numberField(usage, "inputTokens");
+	const outputTokens = numberField(usage, "outputTokens");
+	return `Step completed (${finishReason})${inputTokens !== void 0 && outputTokens !== void 0 ? `: ${inputTokens} in / ${outputTokens} out tokens` : ""}`;
+}
+function logEvent(event, ctx) {
+	const data = eventData(event);
+	switch (event.type) {
+		case "session.started": {
+			const runtime = asRecord(data.runtime);
+			const invocation = asRecord(data.invocation);
+			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.parent.session_id": stringField(invocation, "parentSessionId"),
+				"eve.parent.call_id": stringField(invocation, "parentCallId"),
+				"eve.parent.turn_id": stringField(invocation, "parentTurnId"),
+				"eve.subagent.name": stringField(invocation, "name")
+			});
+			return;
+		}
+		case "turn.started":
+			emit(event, ctx, "debug", "Turn started");
+			return;
+		case "message.received":
+			emit(event, ctx, "debug", "User message received");
+			return;
+		case "step.completed": {
+			const usage = asRecord(data.usage);
+			emit(event, ctx, "info", stepCompletedMessage(data), {
+				"gen_ai.usage.input_tokens": numberField(usage, "inputTokens"),
+				"gen_ai.usage.output_tokens": numberField(usage, "outputTokens"),
+				"eve.usage.cache_read_tokens": numberField(usage, "cacheReadTokens"),
+				"eve.usage.cache_write_tokens": numberField(usage, "cacheWriteTokens")
+			});
+			return;
+		}
+		case "step.failed":
+			emit(event, ctx, "error", `Step failed: ${stringField(data, "message") ?? ""}`, {
+				"error.code": stringField(data, "code"),
+				"eve.error.details": jsonField(data, "details")
+			});
+			return;
+		case "action.result": {
+			const status = stringField(data, "status");
+			if (status === "completed") return;
+			const error = asRecord(data.error);
+			emit(event, ctx, status === "failed" ? "error" : "warn", `Tool ${status ?? "failed"}: ${stringField(error, "message") ?? ""}`, {
+				"error.code": stringField(error, "code"),
+				...toolAttrs(data.result)
+			});
+			return;
+		}
+		case "input.requested":
+			emit(event, ctx, "info", "Input requested (HITL)", { "eve.input.request_count": (Array.isArray(data.requests) ? data.requests : void 0)?.length });
+			return;
+		case "authorization.required":
+			emit(event, ctx, "warn", `Authorization required: ${stringField(data, "name") ?? ""}`, { "eve.authorization.name": stringField(data, "name") });
+			return;
+		case "authorization.completed": {
+			const outcome = stringField(data, "outcome");
+			emit(event, ctx, outcome === "authorized" ? "info" : "warn", `Authorization ${outcome ?? "completed"}: ${stringField(data, "name") ?? ""}`, {
+				"eve.authorization.name": stringField(data, "name"),
+				"eve.authorization.outcome": outcome,
+				"eve.authorization.reason": stringField(data, "reason")
+			});
+			return;
+		}
+		case "subagent.started":
+			emit(event, ctx, "info", "Subagent started", {
+				"eve.subagent.name": stringField(data, "subagentName"),
+				"gen_ai.tool.call.id": stringField(data, "callId")
+			});
+			return;
+		case "subagent.event": {
+			const child = asRecord(data.event);
+			const childData = asRecord(child?.data);
+			const childType = stringField(child, "type");
+			const attrs = {
+				"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);
+				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);
+				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);
+			return;
+		}
+		case "subagent.called": {
+			const remote = asRecord(data.remote);
+			emit(event, ctx, "info", `Subagent called: ${stringField(data, "name") ?? ""}`, {
+				"eve.subagent.name": stringField(data, "name"),
+				"gen_ai.tool.name": stringField(data, "toolName"),
+				"gen_ai.tool.call.id": stringField(data, "callId"),
+				"eve.child.session_id": stringField(data, "childSessionId"),
+				"eve.workflow.id": stringField(data, "workflowId"),
+				"eve.remote.url": stringField(remote, "url")
+			});
+			return;
+		}
+		case "subagent.completed":
+			emit(event, ctx, "info", "Subagent completed", {
+				"eve.subagent.name": stringField(data, "subagentName"),
+				"gen_ai.tool.call.id": stringField(data, "callId")
+			});
+			return;
+		case "compaction.requested":
+			emit(event, ctx, "info", `Compaction requested (${stringField(data, "modelId") ?? ""})`, {
+				"gen_ai.request.model": stringField(data, "modelId"),
+				"gen_ai.usage.input_tokens": numberField(data, "usageInputTokens")
+			});
+			return;
+		case "compaction.completed":
+			emit(event, ctx, "debug", "Compaction completed", { "gen_ai.request.model": stringField(data, "modelId") });
+			return;
+		case "turn.completed":
+			emit(event, ctx, "info", "Turn completed");
+			return;
+		case "turn.failed":
+			emit(event, ctx, "error", `Turn failed: ${stringField(data, "message") ?? ""}`, {
+				"error.code": stringField(data, "code"),
+				"eve.error.details": jsonField(data, "details")
+			});
+			return;
+		case "session.waiting":
+			emit(event, ctx, "debug", "Session waiting");
+			return;
+		case "session.completed":
+			emit(event, ctx, "info", "Session completed");
+			return;
+		case "session.failed":
+			emit(event, ctx, "error", `Session failed: ${stringField(data, "message") ?? ""}`, {
+				"error.code": stringField(data, "code"),
+				"eve.error.details": jsonField(data, "details")
+			});
+			return;
+		default: return;
+	}
+}
+function telemetryDevHook(options = {}, overrides) {
+	return { events: { "*"(event, ctx) {
+		try {
+			ensureInit(options, overrides);
+			logEvent(event, ctx);
+		} catch (error) {
+			reportError$1(options.onError, error);
+		}
+	} } };
+}
+//#endregion
+//#region src/instrumentation.ts
+const envServiceName = () => typeof process !== "undefined" ? process.env.OTEL_SERVICE_NAME : void 0;
+function reportError(onError, error) {
+	try {
+		onError?.(error);
+	} catch {}
+}
+function telemetryDevInstrumentation(options = {}, overrides) {
+	const { functionId, recordInputs, recordOutputs, runtimeContext, stepStarted, ...sdkOptions } = options;
+	const definition = {
+		recordInputs: recordInputs ?? sdkOptions.captureInput ?? true,
+		recordOutputs: recordOutputs ?? sdkOptions.captureOutput ?? true,
+		setup({ agentName }) {
+			try {
+				ensureInit({
+					...sdkOptions,
+					serviceName: sdkOptions.serviceName ?? envServiceName() ?? agentName
+				}, overrides);
+			} catch (error) {
+				reportError(sdkOptions.onError, error);
+			}
+		},
+		events: { "step.started"(input) {
+			const ctx = { ...runtimeContext };
+			const userId = input.session.auth.initiator?.principalId ?? input.session.auth.current?.principalId;
+			if (userId) ctx["user.id"] = userId;
+			try {
+				const userResult = stepStarted?.(input);
+				if (userResult?.runtimeContext) Object.assign(ctx, userResult.runtimeContext);
+			} catch (error) {
+				reportError(sdkOptions.onError, error);
+			}
+			return Object.keys(ctx).length > 0 ? { runtimeContext: ctx } : void 0;
+		} }
+	};
+	if (functionId !== void 0) return {
+		...definition,
+		functionId
+	};
+	return definition;
+}
+//#endregion
+export { telemetryDevHook, telemetryDevInstrumentation, wrapEveClient };