evlog 2.19.1 → 2.20.0

package/dist/eve/index.d.mts

@@ -0,0 +1,72 @@
+import { et as LoggerConfig, l as AuditableLogger } from "../audit-BZrUvjfW.mjs";
+import { t as BaseEvlogOptions } from "../middleware-fbtEs6bq.mjs";
+import { ModelCost } from "../ai/index.mjs";
+import { HookDefinition } from "eve/hooks";
+
+//#region src/eve/index.d.ts
+/** Options for {@link defineEvlogHook}. */
+interface EvlogEveOptions extends BaseEvlogOptions {
+  /** Passed to {@link initLogger} on the first hook invocation. */
+  init?: LoggerConfig;
+  /**
+   * When `true` (default), user message content from `message.received` is
+   * omitted from the wide event. Set to `false` to include a truncated preview.
+   */
+  redactMessage?: boolean;
+  /**
+   * Pricing map for {@link AIEventData.estimatedCost}. Keys are model IDs,
+   * values are dollars per 1M tokens — same shape as `evlog/ai`.
+   */
+  cost?: Record<string, ModelCost>;
+  /**
+   * Model ID used with `cost` when eve stream events do not expose the model
+   * name. When `cost` has exactly one entry, that key is used automatically.
+   */
+  model?: string;
+  /**
+   * Max in-memory sessions for context carry-over and approval state.
+   * Oldest sessions are evicted when exceeded. Default `256`.
+   */
+  maxSessions?: number;
+}
+/** Minimal session shape accepted by {@link useLogger} as a fallback lookup key. */
+interface EveTurnSessionContext {
+  readonly session: {
+    readonly id: string;
+    readonly turn?: {
+      readonly id?: string;
+    };
+  };
+}
+declare function useLogger(ctx?: EveTurnSessionContext): AuditableLogger;
+/**
+ * Create an eve stream hook that emits one evlog wide event per agent turn.
+ *
+ * Export the result as the default export of `agent/hooks/evlog.ts`. eve
+ * auto-discovers hook files; evlog maps turn lifecycle events to a wide event
+ * with AI usage, tool executions, and your drain/enrich/keep pipeline.
+ *
+ * Complements eve Agent Runs and OpenTelemetry — it does not replace them.
+ *
+ * @example
+ * ```ts
+ * // agent/hooks/evlog.ts
+ * import { defineEvlogHook } from 'evlog/eve'
+ * import { createAxiomDrain } from 'evlog/axiom'
+ *
+ * export default defineEvlogHook({
+ *   drain: createAxiomDrain(),
+ *   enrich: (ctx) => {
+ *     ctx.event.runtime = process.env.VERCEL_REGION
+ *   },
+ * })
+ * ```
+ */
+declare function defineEvlogHook(options?: EvlogEveOptions): HookDefinition;
+/** @internal Simulates eve tool execution where AsyncLocalStorage did not propagate. */
+declare function detachActiveTurnLoggerForTests(): void;
+/** @internal Resets module state between unit tests. Clears turn maps, session context, and the Eve init flag. */
+declare function resetEvlogEveForTests(): void;
+//#endregion
+export { EveTurnSessionContext, EvlogEveOptions, type ModelCost, defineEvlogHook, detachActiveTurnLoggerForTests, resetEvlogEveForTests, useLogger };
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/eve/index.ts"],"mappings":";;;;;;;UAiBiB,eAAA,SAAwB,gBAAA;EAAR;EAE/B,IAAA,GAAO,YAAA;EAAA;;;;EAKP,aAAA;EAPuD;;;;EAYvD,IAAA,GAAO,MAAA,SAAe,SAAA;EAAtB;;;;EAKA,KAAA;EAKW;;AAIb;;EAJE,WAAA;AAAA;;UAIe,qBAAA;EAAA,SACN,OAAA;IAAA,SACE,EAAA;IAAA,SACA,IAAA;MAAA,SAAkB,EAAA;IAAA;EAAA;AAAA;AAAA,iBA4Of,SAAA,CAAU,GAAA,GAAM,qBAAA,GAAwB,eAAA;;;;;;AA8WxD;;;;;;;;;AA2MA;;;;;AAMA;;;;iBAjNgB,eAAA,CAAgB,OAAA,GAAS,eAAA,GAAuB,cAAA;;iBA2MhD,8BAAA,CAAA;;iBAMA,qBAAA,CAAA"}

package/dist/eve/index.mjs

@@ -0,0 +1,593 @@
+import { C as isLoggerInitialized, w as isLoggerLocked, x as initLogger } from "../audit-BXCYMjcC.mjs";
+import { t as createMiddlewareLogger } from "../middleware-Cdebyfdt.mjs";
+import { n as clearAsyncLocalStorage, r as patchAsyncLocalStorageEnterWith, t as bindAsyncLocalStorage } from "../asyncStorageScope-DnF7Xk8l.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { defineHook } from "eve/hooks";
+//#region src/eve/index.ts
+const DEFAULT_MAX_SESSIONS = 256;
+/** Top-level wide-event keys that stay turn-scoped and are not carried across turns. */
+const TURN_ONLY_KEYS = new Set([
+	"eve",
+	"ai",
+	"message",
+	"method",
+	"path",
+	"status",
+	"duration",
+	"level",
+	"error",
+	"agent",
+	"channel",
+	"approval",
+	"audit",
+	"requestId",
+	"service",
+	"timestamp",
+	"traceId",
+	"spanId"
+]);
+function turnKey(sessionId, turnId) {
+	return `${sessionId}:${turnId}`;
+}
+function freshAccumulator(options) {
+	return {
+		calls: 0,
+		steps: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
+		toolExecutions: [],
+		subagents: [],
+		pausedForInput: false,
+		costMap: options.cost,
+		costModel: resolveCostModel(options)
+	};
+}
+function resolveCostModel(options) {
+	if (options.model) return options.model;
+	const keys = options.cost ? Object.keys(options.cost) : [];
+	if (keys.length === 1) return keys[0];
+}
+function computeEstimatedCost(state) {
+	if (!state.costMap || !state.costModel) return void 0;
+	const pricing = state.costMap[state.costModel];
+	if (!pricing) return void 0;
+	const total = state.inputTokens / 1e6 * pricing.input + state.outputTokens / 1e6 * pricing.output;
+	return total > 0 ? Math.round(total * 1e6) / 1e6 : void 0;
+}
+function buildAiField(state) {
+	const totalTokens = state.inputTokens + state.outputTokens;
+	const data = {
+		calls: state.calls,
+		inputTokens: state.inputTokens,
+		outputTokens: state.outputTokens,
+		totalTokens,
+		steps: state.steps
+	};
+	if (state.costModel) data.model = state.costModel;
+	if (state.cacheReadTokens > 0) data.cacheReadTokens = state.cacheReadTokens;
+	if (state.cacheWriteTokens > 0) data.cacheWriteTokens = state.cacheWriteTokens;
+	if (state.finishReason) data.finishReason = state.finishReason;
+	const estimatedCost = computeEstimatedCost(state);
+	if (estimatedCost !== void 0) data.estimatedCost = estimatedCost;
+	if (state.toolExecutions.length > 0) data.tools = state.toolExecutions.map((t) => ({ ...t }));
+	return data;
+}
+function extractToolName(result) {
+	if (result && typeof result === "object") {
+		const record = result;
+		if (typeof record.toolName === "string") return record.toolName;
+		if (typeof record.subagentName === "string") return record.subagentName;
+		if (typeof record.name === "string") return record.name;
+	}
+	return "unknown";
+}
+function extractCallId(result) {
+	if (result && typeof result === "object") {
+		const { callId } = result;
+		if (typeof callId === "string") return callId;
+	}
+}
+function truncateMessage(message, maxLength = 500) {
+	if (message.length <= maxLength) return message;
+	return `${message.slice(0, maxLength)}…`;
+}
+function ensureInit(options) {
+	const state = getEveGlobalState();
+	if (options.maxSessions !== void 0) state.maxSessions = options.maxSessions;
+	if (isEveInitialized()) return;
+	if (!isLoggerLocked() && !isLoggerInitialized()) initLogger(options.init ?? { env: { service: "eve-agent" } });
+	setEveInitialized(true);
+}
+const turnLoggerStorage = new AsyncLocalStorage();
+patchAsyncLocalStorageEnterWith(turnLoggerStorage);
+const activeTurnLoggers = /* @__PURE__ */ new WeakSet();
+function bindTurnLogger(logger) {
+	bindAsyncLocalStorage(turnLoggerStorage, logger);
+	activeTurnLoggers.add(logger);
+}
+function unbindTurnLogger(logger) {
+	activeTurnLoggers.delete(logger);
+	if (turnLoggerStorage.getStore() === logger) clearAsyncLocalStorage(turnLoggerStorage);
+}
+function resolveTurnLogger(ctx) {
+	const sessionId = ctx.session.id;
+	const turnId = ctx.session.turn?.id ?? activeTurnBySession().get(sessionId);
+	if (!turnId) throw new Error("[evlog] useLogger() could not resolve the active turn. Ensure defineEvlogHook() is registered and the turn has started.");
+	const state = turnStates().get(turnKey(sessionId, turnId));
+	if (!state) throw new Error("[evlog] useLogger() could not find a logger for the current turn. Ensure defineEvlogHook() is registered and the turn has started.");
+	return state.logger;
+}
+/**
+* Turn-scoped logger for eve tool `execute()` handlers.
+*
+* When {@link defineEvlogHook} is registered, the logger is bound via
+* AsyncLocalStorage on `turn.started`. Inside tool handlers, `useLogger()`
+* resolves from ALS when it propagated, otherwise from the sole active turn
+* in the process (typical eve dev). Pass eve tool `ctx` only when multiple
+* sessions are active concurrently.
+*
+* @example
+* ```ts
+* import { useLogger } from 'evlog/eve'
+*
+* export default defineTool({
+*   async execute(input) {
+*     const log = useLogger()
+*     log.set({ order: { id: input.orderId } })
+*   },
+* })
+* ```
+*/
+function resolveActiveTurnLogger() {
+	const active = activeTurnBySession();
+	if (active.size !== 1) return null;
+	const [sessionId, turnId] = active.entries().next().value;
+	return turnStates().get(turnKey(sessionId, turnId))?.logger ?? null;
+}
+function useLogger(ctx) {
+	const fromStorage = turnLoggerStorage.getStore();
+	if (fromStorage && activeTurnLoggers.has(fromStorage)) return fromStorage;
+	if (ctx?.session?.id) return resolveTurnLogger(ctx);
+	const active = resolveActiveTurnLogger();
+	if (active) return active;
+	throw new Error("[evlog] useLogger() was called outside an evlog eve turn. Add agent/hooks/evlog.ts with defineEvlogHook() or pass ctx from the tool handler.");
+}
+const EVE_GLOBAL_STATE = Symbol.for("evlog.eve.state");
+function getEveGlobalState() {
+	const host = globalThis;
+	if (!host[EVE_GLOBAL_STATE]) host[EVE_GLOBAL_STATE] = {
+		turnStates: /* @__PURE__ */ new Map(),
+		activeTurnBySession: /* @__PURE__ */ new Map(),
+		sessionSnapshots: /* @__PURE__ */ new Map(),
+		sessionPendingActions: /* @__PURE__ */ new Map(),
+		sessionApprovals: /* @__PURE__ */ new Map(),
+		sessionRollups: /* @__PURE__ */ new Map(),
+		maxSessions: DEFAULT_MAX_SESSIONS,
+		initialized: false
+	};
+	return host[EVE_GLOBAL_STATE];
+}
+function turnStates() {
+	return getEveGlobalState().turnStates;
+}
+function activeTurnBySession() {
+	return getEveGlobalState().activeTurnBySession;
+}
+function sessionSnapshots() {
+	return getEveGlobalState().sessionSnapshots;
+}
+function sessionPendingActions() {
+	return getEveGlobalState().sessionPendingActions;
+}
+function sessionApprovals() {
+	return getEveGlobalState().sessionApprovals;
+}
+function sessionRollups() {
+	return getEveGlobalState().sessionRollups;
+}
+function touchSession(sessionId) {
+	const rollups = sessionRollups();
+	const rollup = rollups.get(sessionId) ?? {
+		turnCount: 0,
+		lastAccess: 0
+	};
+	rollup.lastAccess = Date.now();
+	rollups.set(sessionId, rollup);
+	evictStaleSessions();
+}
+function clearSessionState(sessionId) {
+	sessionSnapshots().delete(sessionId);
+	sessionRollups().delete(sessionId);
+	sessionPendingActions().delete(sessionId);
+	sessionApprovals().delete(sessionId);
+}
+function evictStaleSessions() {
+	const { maxSessions } = getEveGlobalState();
+	const rollups = sessionRollups();
+	if (rollups.size <= maxSessions) return;
+	const oldest = [...rollups.entries()].sort((a, b) => a[1].lastAccess - b[1].lastAccess).slice(0, rollups.size - maxSessions);
+	for (const [sessionId] of oldest) {
+		if (activeTurnBySession().has(sessionId)) continue;
+		clearSessionState(sessionId);
+	}
+}
+function pruneEmptySessionMaps(sessionId) {
+	if (sessionPendingActions().get(sessionId)?.size === 0) sessionPendingActions().delete(sessionId);
+	if (sessionApprovals().get(sessionId)?.length === 0) sessionApprovals().delete(sessionId);
+}
+function bumpSessionTurnCount(sessionId) {
+	touchSession(sessionId);
+	const rollup = sessionRollups().get(sessionId);
+	rollup.turnCount += 1;
+	return rollup.turnCount;
+}
+/** Turn-level label — only set when the turn ends in a non-routine state. */
+function derivePhase(ctx, accumulator, httpStatus) {
+	const approval = ctx.approval;
+	if (approval?.status === "rejected") return "rejected";
+	if (approval?.status === "pending" || accumulator.pausedForInput) return "awaiting-approval";
+	if (httpStatus >= 400) return "failed";
+}
+function getSessionPendingActions(sessionId) {
+	let map = sessionPendingActions().get(sessionId);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		sessionPendingActions().set(sessionId, map);
+	}
+	return map;
+}
+function trackPendingAction(sessionId, turnId, action) {
+	touchSession(sessionId);
+	getSessionPendingActions(sessionId).set(action.callId, {
+		toolName: action.toolName,
+		startedAt: action.startedAt ?? Date.now(),
+		turnId
+	});
+}
+function resolveToolDurationMs(state, callId) {
+	const pending = callId ? getSessionPendingActions(state.sessionId).get(callId) : void 0;
+	if (pending) {
+		if (pending.turnId !== state.turnId && state.accumulator.stepStartedAt !== void 0) return Math.max(0, Date.now() - state.accumulator.stepStartedAt);
+		return Math.max(0, Date.now() - pending.startedAt);
+	}
+	if (state.accumulator.stepStartedAt !== void 0) return Math.max(0, Date.now() - state.accumulator.stepStartedAt);
+	return 0;
+}
+function consumeSessionApproval(sessionId, toolName, callId) {
+	const list = sessionApprovals().get(sessionId);
+	if (!list?.length) return void 0;
+	const index = list.findIndex((approval) => callId ? approval.callId === callId : approval.toolName === toolName);
+	if (index === -1) return void 0;
+	const [approval] = list.splice(index, 1);
+	if (list.length === 0) sessionApprovals().delete(sessionId);
+	return approval;
+}
+function storeSessionApprovals(sessionId, pending) {
+	touchSession(sessionId);
+	const existing = sessionApprovals().get(sessionId) ?? [];
+	sessionApprovals().set(sessionId, [...existing, ...pending]);
+}
+function isEveInitialized() {
+	return getEveGlobalState().initialized;
+}
+function setEveInitialized(value) {
+	getEveGlobalState().initialized = value;
+}
+function applySessionContext(sessionId, logger) {
+	touchSession(sessionId);
+	const snapshot = sessionSnapshots().get(sessionId);
+	if (snapshot && Object.keys(snapshot).length > 0) logger.set({ ...snapshot });
+}
+function persistSessionContext(sessionId, logger) {
+	const ctx = logger.getContext();
+	const snapshot = { ...sessionSnapshots().get(sessionId) ?? {} };
+	for (const [key, value] of Object.entries(ctx)) if (!TURN_ONLY_KEYS.has(key) && value !== void 0) snapshot[key] = value;
+	sessionSnapshots().set(sessionId, snapshot);
+}
+function flushEveMetadata(state) {
+	if (state.accumulator.subagents.length === 0) return;
+	state.logger.set({ eve: { subagents: state.accumulator.subagents.map((s) => ({ ...s })) } });
+}
+function getOrCreateTurnState(sessionId, turnId, options, ctx) {
+	const key = turnKey(sessionId, turnId);
+	const existing = turnStates().get(key);
+	if (existing) return existing;
+	touchSession(sessionId);
+	const middlewareOptions = {
+		method: "EVE",
+		path: `/sessions/${sessionId}/turns/${turnId}`,
+		requestId: turnId,
+		drain: options.drain,
+		enrich: options.enrich,
+		keep: options.keep,
+		redact: options.redact,
+		plugins: options.plugins,
+		include: options.include,
+		exclude: options.exclude,
+		routes: options.routes
+	};
+	const { logger, finish, skipped } = createMiddlewareLogger(middlewareOptions);
+	if (skipped) return null;
+	const state = {
+		logger,
+		finish,
+		middlewareOptions,
+		accumulator: freshAccumulator(options),
+		sessionId,
+		turnId
+	};
+	applySessionContext(sessionId, logger);
+	logger.set({
+		eve: {
+			sessionId,
+			turnId
+		},
+		agent: {
+			name: ctx.agent.name,
+			...ctx.agent.nodeId ? { nodeId: ctx.agent.nodeId } : {}
+		},
+		channel: {
+			kind: ctx.channel.kind ?? "unknown",
+			...ctx.channel.continuationToken ? { continuing: true } : {}
+		}
+	});
+	turnStates().set(key, state);
+	activeTurnBySession().set(sessionId, turnId);
+	return state;
+}
+function flushAi(state) {
+	state.logger.set({ ai: buildAiField(state.accumulator) });
+}
+async function finishTurn(sessionId, turnId, opts) {
+	const key = turnKey(sessionId, turnId);
+	const state = turnStates().get(key);
+	if (!state) return;
+	try {
+		flushEveMetadata(state);
+		flushAi(state);
+		const httpStatus = opts.status ?? (opts.error ? 500 : 200);
+		const phase = derivePhase(state.logger.getContext(), state.accumulator, httpStatus);
+		const sessionTurns = bumpSessionTurnCount(sessionId);
+		state.logger.set({ eve: {
+			...phase ? { phase } : {},
+			sessionTurns
+		} });
+		persistSessionContext(sessionId, state.logger);
+		await state.finish(opts);
+	} finally {
+		unbindTurnLogger(state.logger);
+		turnStates().delete(key);
+		if (activeTurnBySession().get(sessionId) === turnId) activeTurnBySession().delete(sessionId);
+		pruneEmptySessionMaps(sessionId);
+	}
+}
+function runSafe(fn) {
+	(async () => {
+		try {
+			await fn();
+		} catch (err) {
+			console.error("[evlog] eve hook handler failed:", err);
+		}
+	})();
+}
+function getTurnState(sessionId, turnId) {
+	return turnStates().get(turnKey(sessionId, turnId));
+}
+/**
+* Create an eve stream hook that emits one evlog wide event per agent turn.
+*
+* Export the result as the default export of `agent/hooks/evlog.ts`. eve
+* auto-discovers hook files; evlog maps turn lifecycle events to a wide event
+* with AI usage, tool executions, and your drain/enrich/keep pipeline.
+*
+* Complements eve Agent Runs and OpenTelemetry — it does not replace them.
+*
+* @example
+* ```ts
+* // agent/hooks/evlog.ts
+* import { defineEvlogHook } from 'evlog/eve'
+* import { createAxiomDrain } from 'evlog/axiom'
+*
+* export default defineEvlogHook({
+*   drain: createAxiomDrain(),
+*   enrich: (ctx) => {
+*     ctx.event.runtime = process.env.VERCEL_REGION
+*   },
+* })
+* ```
+*/
+function defineEvlogHook(options = {}) {
+	const redactMessage = options.redactMessage ?? true;
+	return defineHook({ events: {
+		"turn.started"(event, ctx) {
+			try {
+				ensureInit(options);
+				const state = getOrCreateTurnState(ctx.session.id, event.data.turnId, options, ctx);
+				state?.logger.set({ eve: { turnSequence: event.data.sequence } });
+				if (state) bindTurnLogger(state.logger);
+			} catch (err) {
+				console.error("[evlog] eve hook handler failed:", err);
+			}
+		},
+		"message.received"(event, ctx) {
+			runSafe(() => {
+				if (redactMessage) return;
+				const state = getTurnState(ctx.session.id, event.data.turnId);
+				if (!state) return;
+				state.logger.set({ message: { received: truncateMessage(event.data.message) } });
+			});
+		},
+		"step.started"(event, ctx) {
+			runSafe(() => {
+				const state = getTurnState(ctx.session.id, event.data.turnId);
+				if (!state) return;
+				state.accumulator.stepStartedAt = Date.now();
+			});
+		},
+		"step.completed"(event, ctx) {
+			runSafe(() => {
+				const state = getTurnState(ctx.session.id, event.data.turnId);
+				if (!state) return;
+				const acc = state.accumulator;
+				acc.steps += 1;
+				acc.calls += 1;
+				acc.finishReason = event.data.finishReason;
+				const { usage } = event.data;
+				if (usage) {
+					acc.inputTokens += usage.inputTokens ?? 0;
+					acc.outputTokens += usage.outputTokens ?? 0;
+					acc.cacheReadTokens += usage.cacheReadTokens ?? 0;
+					acc.cacheWriteTokens += usage.cacheWriteTokens ?? 0;
+				}
+			});
+		},
+		"actions.requested"(event, ctx) {
+			runSafe(() => {
+				const state = getTurnState(ctx.session.id, event.data.turnId);
+				if (!state) return;
+				bindTurnLogger(state.logger);
+				const startedAt = Date.now();
+				for (const action of event.data.actions) if (action.kind === "tool-call") trackPendingAction(ctx.session.id, event.data.turnId, {
+					callId: action.callId,
+					toolName: action.toolName,
+					startedAt
+				});
+			});
+		},
+		"input.requested"(event, ctx) {
+			runSafe(() => {
+				const state = getTurnState(ctx.session.id, event.data.turnId);
+				if (!state) return;
+				state.accumulator.pausedForInput = true;
+				const pending = event.data.requests.map((req) => ({
+					toolName: req.action.toolName,
+					callId: req.action.callId
+				}));
+				storeSessionApprovals(ctx.session.id, pending);
+				const [first] = pending;
+				if (first) state.logger.set({ approval: {
+					status: "pending",
+					tool: first.toolName
+				} });
+			});
+		},
+		"action.result"(event, ctx) {
+			runSafe(() => {
+				const state = getTurnState(ctx.session.id, event.data.turnId);
+				if (!state) return;
+				const callId = extractCallId(event.data.result);
+				const sessionPending = getSessionPendingActions(state.sessionId);
+				const turnPending = callId ? sessionPending.get(callId) : void 0;
+				const { status } = event.data;
+				const rejected = status === "rejected";
+				const success = status === "completed";
+				const toolName = turnPending?.toolName ?? extractToolName(event.data.result);
+				const durationMs = resolveToolDurationMs(state, callId);
+				if (callId) sessionPending.delete(callId);
+				const execution = {
+					name: toolName,
+					durationMs,
+					success
+				};
+				if (rejected) {
+					execution.error = "rejected";
+					state.accumulator.pausedForInput = false;
+					consumeSessionApproval(state.sessionId, toolName, callId);
+					state.logger.set({ approval: {
+						status: "rejected",
+						tool: toolName
+					} });
+				} else if (success) {
+					const approval = consumeSessionApproval(state.sessionId, toolName, callId);
+					if (approval) {
+						state.accumulator.pausedForInput = false;
+						state.logger.set({ approval: {
+							status: "approved",
+							tool: approval.toolName
+						} });
+					}
+				} else if (event.data.error) execution.error = event.data.error.message;
+				state.accumulator.toolExecutions.push(execution);
+			});
+		},
+		"subagent.called"(event, ctx) {
+			runSafe(() => {
+				const state = getTurnState(ctx.session.id, event.data.turnId);
+				if (!state) return;
+				state.accumulator.subagents.push({
+					callId: event.data.callId,
+					name: event.data.name,
+					toolName: event.data.toolName,
+					childSessionId: event.data.childSessionId,
+					status: "called"
+				});
+			});
+		},
+		"subagent.completed"(event, ctx) {
+			runSafe(() => {
+				const sessionId = ctx.session.id;
+				const turnId = activeTurnBySession().get(sessionId);
+				if (!turnId) return;
+				const state = getTurnState(sessionId, turnId);
+				if (!state) return;
+				const existing = state.accumulator.subagents.find((s) => s.callId === event.data.callId);
+				if (existing) {
+					existing.status = "completed";
+					existing.output = event.data.output;
+				} else state.accumulator.subagents.push({
+					callId: event.data.callId,
+					name: event.data.subagentName,
+					status: "completed",
+					output: event.data.output
+				});
+			});
+		},
+		async "turn.completed"(event, ctx) {
+			try {
+				await finishTurn(ctx.session.id, event.data.turnId, { status: 200 });
+			} catch (err) {
+				console.error("[evlog] eve hook handler failed:", err);
+			}
+		},
+		async "turn.failed"(event, ctx) {
+			try {
+				getTurnState(ctx.session.id, event.data.turnId)?.logger.set({ eve: { failure: {
+					code: event.data.code,
+					message: event.data.message,
+					...event.data.details ? { details: event.data.details } : {}
+				} } });
+				const error = new Error(event.data.message);
+				error.name = event.data.code;
+				await finishTurn(ctx.session.id, event.data.turnId, {
+					error,
+					status: 500
+				});
+			} catch (err) {
+				console.error("[evlog] eve hook handler failed:", err);
+			}
+		}
+	} });
+}
+/** @internal Simulates eve tool execution where AsyncLocalStorage did not propagate. */
+function detachActiveTurnLoggerForTests() {
+	const logger = turnLoggerStorage.getStore();
+	if (logger) unbindTurnLogger(logger);
+}
+/** @internal Resets module state between unit tests. Clears turn maps, session context, and the Eve init flag. */
+function resetEvlogEveForTests() {
+	clearAsyncLocalStorage(turnLoggerStorage);
+	turnStates().clear();
+	activeTurnBySession().clear();
+	sessionSnapshots().clear();
+	sessionPendingActions().clear();
+	sessionApprovals().clear();
+	sessionRollups().clear();
+	setEveInitialized(false);
+	delete globalThis[EVE_GLOBAL_STATE];
+}
+//#endregion
+export { defineEvlogHook, detachActiveTurnLoggerForTests, resetEvlogEveForTests, useLogger };
+
+//# sourceMappingURL=index.mjs.map