Skip to content

armgit / eve

Public Imported from GitHub
0

The Open Framework for Building Agents

fix(eve): preserve OTel session metadata (#3488)

Chad Hietalaed88ff4fb0bc
diff --git a/.changeset/preserve-otel-session-metadata.md b/.changeset/preserve-otel-session-metadata.md
new file mode 100644
index 000000000..2f23c7c53
--- /dev/null
+++ b/.changeset/preserve-otel-session-metadata.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+Preserve canonical OpenTelemetry session metadata when channel delivery instrumentation runs before the session lifecycle event.
diff --git a/packages/eve/src/execution/session/turn-step.test.ts b/packages/eve/src/execution/session/turn-step.test.ts
index d1ca85f83..f80170f4b 100644
--- a/packages/eve/src/execution/session/turn-step.test.ts
+++ b/packages/eve/src/execution/session/turn-step.test.ts
@@ -91,12 +91,27 @@ function turnStep(input: Omit<TurnStepInput, "input"> & { readonly input?: Legac
import { routeProxiedDeliverStep } from "#execution/proxied-deliver-step.js";
const bindSessionInstrumentationSpy = vi.hoisted(() => vi.fn());
+/** When set, `bindSessionInstrumentation` binds this runtime instead of the global one. */
+const instrumentationRuntimeOverride = vi.hoisted(() => ({
+ current: undefined as import("#instrumentation/runtime.js").InstrumentationRuntime | undefined,
+}));
vi.mock("#instrumentation/runtime.js", async (importOriginal) => {
const actual = await importOriginal<typeof import("#instrumentation/runtime.js")>();
return {
...actual,
bindSessionInstrumentation(input: Parameters<typeof actual.bindSessionInstrumentation>[0]) {
bindSessionInstrumentationSpy(input);
+ if (instrumentationRuntimeOverride.current !== undefined) {
+ return actual.bindInstrumentationRuntime(
+ instrumentationRuntimeOverride.current,
+ input.ctx,
+ {
+ agentName: input.agentName,
+ rootSessionId: input.rootSessionId,
+ sessionId: input.sessionId,
+ },
+ );
+ }
return actual.bindSessionInstrumentation(input);
},
};
@@ -2140,6 +2155,88 @@ describe("turnStep", () => {
).rejects.toThrow("Task mode cannot complete while input requests remain pending.");
});
+ it("prepares the session trace boundary before instrumenting a first-turn delivery", async () => {
+ const published: string[] = [];
+ const prepareSessionTrace = vi.fn(async () => {
+ published.push("prepareSessionTrace");
+ return { spanId: "1".repeat(16), traceFlags: 1, traceId: "1".repeat(32) };
+ });
+ const prepareTurnTrace = vi.fn(async () => {
+ published.push("prepareTurnTrace");
+ return { spanId: "2".repeat(16), traceFlags: 1, traceId: "1".repeat(32) };
+ });
+ instrumentationRuntimeOverride.current = {
+ forceFlush: async () => undefined,
+ hooks: {
+ capturesContent: false,
+ publish: async (event) => {
+ published.push(event.type);
+ },
+ },
+ otelSettings: undefined,
+ prepareSessionTrace,
+ prepareTurnTrace,
+ runInContext: (_operation, execute) => execute(),
+ shutdown: async () => undefined,
+ };
+ try {
+ const session = createStubSession();
+ installSessionStoreMocks([session]);
+ vi.mocked(createExecutionNodeStep).mockImplementation(() => {
+ return async (stepSession): Promise<StepResult> => ({
+ next: { done: true, output: "ok" },
+ session: stepSession,
+ });
+ });
+ const compiledBundle = {
+ adapterRegistry: {
+ adaptersByKind: new Map([[threadContextAdapter.kind, threadContextAdapter]]),
+ },
+ compiledArtifactsSource: {} as never,
+ graph: {
+ nodesByNodeId: new Map(),
+ root: { sandboxRegistry: { sandbox: null }, turnAgent: TestTurnAgent },
+ },
+ moduleMap: { nodes: {} },
+ hookRegistry: createEmptyHookRegistry(),
+ resolvedAgent: { config: {} },
+ subagentRegistry: {},
+ toolRegistry: {},
+ turnAgent: TestTurnAgent,
+ } as never;
+ vi.mocked(getCompiledRuntimeAgentBundle).mockResolvedValue(compiledBundle);
+ const ctx = new ContextContainer();
+ ctx.set(AuthKey, null);
+ ctx.set(BundleKey, compiledBundle);
+ ctx.set(ChannelKey, threadContextAdapter);
+ ctx.set(ContinuationTokenKey, "first-turn-delivery");
+ ctx.set(ModeKey, "task");
+ ctx.set(SessionIdKey, "session-1");
+
+ await turnStep({
+ input: {
+ kind: "deliver",
+ payloads: [{ message: "hello" }],
+ deliveryMetadata: [
+ { channelKind: "http", channelName: "web", deliveryId: "delivery-1", payloadIndex: 0 },
+ ],
+ },
+ sessionWritable: createTestWritable(),
+ serializedContext: serializeContext(ctx),
+ sessionState: createStubSessionState(),
+ });
+
+ // The session boundary is prepared before the delivery is instrumented,
+ // and turn trace state is left to the tool loop.
+ const deliveryIndex = published.indexOf("channel.delivery.started");
+ expect(deliveryIndex).toBeGreaterThan(-1);
+ expect(published.slice(0, deliveryIndex)).toContain("prepareSessionTrace");
+ expect(published.slice(0, deliveryIndex)).not.toContain("prepareTurnTrace");
+ } finally {
+ instrumentationRuntimeOverride.current = undefined;
+ }
+ });
+
it("uses the selected dynamic subagent model for execution identity", async () => {
bindSessionInstrumentationSpy.mockClear();
const session = createStubSession();
diff --git a/packages/eve/src/execution/session/turn-step.ts b/packages/eve/src/execution/session/turn-step.ts
index c32fe0cc6..e9aa1fe06 100644
--- a/packages/eve/src/execution/session/turn-step.ts
+++ b/packages/eve/src/execution/session/turn-step.ts
@@ -196,6 +196,15 @@ async function runSessionStep(input: TurnStepInput): Promise<DurableStepResult>
}
if (rawDelivery !== undefined) {
+ // Prepare only the session boundary here. Turn trace state is owned by the
+ // tool loop: preparing it this early would persist stale principals and a
+ // stale start time for deliveries that never start a turn (the park path).
+ await contextStorage.run(ctx, () =>
+ instrumentation?.preparePreamble({
+ sequence: initialEmissionState.sequence,
+ sessionStarted: initialEmissionState.sessionStarted,
+ }),
+ );
await contextStorage.run(ctx, () =>
instrumentation?.instrumentChannelDelivery({
agentName: bundle.turnAgent.id,
diff --git a/packages/eve/src/tracing/agent-channel-delivery-instrumentation.ts b/packages/eve/src/tracing/agent-channel-delivery-instrumentation.ts
index f3bdd5499..599afe3af 100644
--- a/packages/eve/src/tracing/agent-channel-delivery-instrumentation.ts
+++ b/packages/eve/src/tracing/agent-channel-delivery-instrumentation.ts
@@ -5,14 +5,12 @@ import type {
InstrumentationChannelDeliveryTerminalEvent,
InstrumentationHandlerContext,
InstrumentationProviderDefinition,
- InstrumentationSessionStartedEvent,
} from "#instrumentation/lifecycle.js";
import { contextStorage } from "#context/container.js";
import { ActiveChannelDeliveriesKey } from "#context/keys.js";
-import { sessionIdempotencyKey } from "#instrumentation/lifecycle.js";
import type { JsonValue } from "#shared/json.js";
import { contentAttribute } from "#tracing/agent-otel-content.js";
-import type { AgentSessionTraceState, AgentTraceStateStore } from "#tracing/agent-trace-state.js";
+import type { AgentTraceStateStore } from "#tracing/agent-trace-state.js";
import { isSampledTrace } from "#tracing/sampled-trace.js";
interface ChannelDeliveryState {
@@ -22,9 +20,6 @@ interface ChannelDeliveryState {
/** Captures one-to-one channel delivery metadata on the activation that consumes it. */
export function createAgentChannelDeliveryInstrumentation(input: {
- readonly ensureSessionContext: (
- event: InstrumentationSessionStartedEvent,
- ) => Promise<AgentSessionTraceState>;
readonly recordInputs: boolean;
readonly stateStore: AgentTraceStateStore;
}): Pick<
@@ -38,22 +33,13 @@ export function createAgentChannelDeliveryInstrumentation(input: {
event: InstrumentationChannelDeliveryStartedEvent,
ctx: InstrumentationHandlerContext,
): Promise<void> => {
- const session = await input.ensureSessionContext({
- agentName: event.agentName,
- channelAudience: event.delivery.channelAudience,
- channelKind: event.delivery.channelKind,
- idempotencyKey: sessionIdempotencyKey(event.sessionId),
- parentTraceContext: event.parentTraceContext,
- rootSessionId: event.rootSessionId,
- sessionId: event.sessionId,
- traceSeed: event.traceSeed,
- type: "session.started",
- });
+ const session = await input.stateStore.getSession(event.sessionId);
const turn =
event.turnId === undefined || event.sequence === undefined
? undefined
: await input.stateStore.getTurn(event.sessionId, event.turnId);
- if (!isSampledTrace(turn?.context ?? session.context)) return;
+ const traceContext = turn?.context ?? session?.context;
+ if (traceContext === undefined || !isSampledTrace(traceContext)) return;
const inputAttribute = input.recordInputs ? contentAttribute(event.input) : undefined;
const state: Record<string, JsonValue> = {};
if (inputAttribute !== undefined) state.inputAttribute = inputAttribute;
diff --git a/packages/eve/src/tracing/agent-otel-provider.test.ts b/packages/eve/src/tracing/agent-otel-provider.test.ts
index 500938f02..78b5570f1 100644
--- a/packages/eve/src/tracing/agent-otel-provider.test.ts
+++ b/packages/eve/src/tracing/agent-otel-provider.test.ts
@@ -1072,26 +1072,30 @@ describe("createAgentOtelInstrumentation", () => {
turnId: "turn_0",
type: "channel.delivery.completed" as const,
};
+ const sessionEvent = {
+ agentName: "support",
+ channelAudience: "public" as const,
+ channelKind: "channel:slack",
+ idempotencyKey: sessionIdempotencyKey("session-1"),
+ rootSessionId: "session-1",
+ sessionId: "session-1",
+ type: "session.started" as const,
+ };
+ const turnEvent = {
+ idempotencyKey: turnIdempotencyKey("session-1", "turn_0"),
+ rootSessionId: "session-1",
+ sequence: 0,
+ sessionId: "session-1",
+ turnId: "turn_0",
+ type: "turn.started" as const,
+ };
await contextStorage.run(ctx, async () => {
- await runtime.hooks.publish({
- agentName: "support",
- channelAudience: "public",
- channelKind: "channel:slack",
- idempotencyKey: sessionIdempotencyKey("session-1"),
- rootSessionId: "session-1",
- sessionId: "session-1",
- type: "session.started",
- });
+ await runtime.prepareSessionTrace(sessionEvent);
+ await runtime.prepareTurnTrace(turnEvent);
await runtime.hooks.publish(started);
- await runtime.hooks.publish({
- idempotencyKey: turnIdempotencyKey("session-1", "turn_0"),
- rootSessionId: "session-1",
- sequence: 0,
- sessionId: "session-1",
- turnId: "turn_0",
- type: "turn.started",
- });
+ await runtime.hooks.publish(sessionEvent);
+ await runtime.hooks.publish(turnEvent);
ctx.set(ActiveChannelDeliveriesKey, [
{
agentName: started.agentName,
@@ -1143,6 +1147,24 @@ describe("createAgentOtelInstrumentation", () => {
channelName: "eve",
deliveryId: `delivery-remote-${suffix}`,
}));
+ const sessionEvent = {
+ agentName: "weather",
+ channelKind: "http",
+ idempotencyKey: sessionIdempotencyKey("remote-session"),
+ parentTraceContext,
+ rootSessionId: "parent-session",
+ sessionId: "remote-session",
+ type: "session.started" as const,
+ };
+ const turnEvent = {
+ idempotencyKey: turnIdempotencyKey("remote-session", "turn-remote"),
+ parentTraceContext,
+ rootSessionId: "parent-session",
+ sequence: 0,
+ sessionId: "remote-session",
+ turnId: "turn-remote",
+ type: "turn.started" as const,
+ };
await contextStorage.run(ctx, async () => {
for (const delivery of deliveries) {
@@ -1157,24 +1179,10 @@ describe("createAgentOtelInstrumentation", () => {
type: "channel.delivery.started",
});
}
- await runtime.hooks.publish({
- agentName: "weather",
- channelKind: "http",
- idempotencyKey: sessionIdempotencyKey("remote-session"),
- parentTraceContext,
- rootSessionId: "parent-session",
- sessionId: "remote-session",
- type: "session.started",
- });
- await runtime.hooks.publish({
- idempotencyKey: turnIdempotencyKey("remote-session", "turn-remote"),
- parentTraceContext,
- rootSessionId: "parent-session",
- sequence: 0,
- sessionId: "remote-session",
- turnId: "turn-remote",
- type: "turn.started",
- });
+ await runtime.prepareSessionTrace(sessionEvent);
+ await runtime.prepareTurnTrace(turnEvent);
+ await runtime.hooks.publish(sessionEvent);
+ await runtime.hooks.publish(turnEvent);
ctx.set(
ActiveChannelDeliveriesKey,
deliveries.map((delivery) => ({
@@ -1204,7 +1212,7 @@ describe("createAgentOtelInstrumentation", () => {
await runtime.provider.forceFlush();
const spans = runtime.exporter.getFinishedSpans();
- const turn = byName(spans, "invoke_agent")[0]!;
+ const turn = byName(spans, "invoke_agent weather")[0]!;
expect(byName(spans, "agent.session")).toHaveLength(0);
expect(byName(spans, "agent.channel.delivery")).toHaveLength(0);
expect(turn.parentSpanContext).toBeUndefined();
@@ -1220,7 +1228,125 @@ describe("createAgentOtelInstrumentation", () => {
"gen_ai.operation.name": "invoke_agent",
});
expect(turn.attributes).not.toHaveProperty("agent.channel.delivery.id");
- expect(turn.attributes).not.toHaveProperty("gen_ai.agent.name");
+ });
+
+ it("uses canonical root session metadata after a delivery arrives first", async () => {
+ const stateStore = new InMemoryAgentTraceStateStore();
+ const runtime = createRuntime(stateStore);
+ const ctx = new ContextContainer();
+ const parentTraceContext = {
+ isRemote: true as const,
+ spanId: "2222222222222222",
+ traceFlags: 1,
+ traceId: "11111111111111111111111111111111",
+ };
+ const sessionId = "session-canonical-metadata";
+ const sessionEvent = {
+ agentName: "weather",
+ channelAudience: "public" as const,
+ channelType: "http",
+ idempotencyKey: sessionIdempotencyKey(sessionId),
+ parentTraceContext,
+ rootSessionId: sessionId,
+ scheduleId: "sched-1",
+ sessionId,
+ title: "Investigate the incident",
+ type: "session.started" as const,
+ };
+ const turnEvent = {
+ idempotencyKey: turnIdempotencyKey(sessionId, "turn_0"),
+ parentTraceContext,
+ rootSessionId: sessionId,
+ sequence: 0,
+ sessionId,
+ turnId: "turn_0",
+ type: "turn.started" as const,
+ };
+
+ await contextStorage.run(ctx, async () => {
+ await runtime.hooks.publish({
+ delivery: {
+ channelAudience: "public",
+ channelKind: "http",
+ channelName: "eve",
+ deliveryId: "delivery-first",
+ },
+ idempotencyKey: "channel-delivery:session-canonical-metadata:delivery-first",
+ parentTraceContext,
+ rootSessionId: sessionId,
+ sequence: 0,
+ sessionId,
+ turnId: "turn_0",
+ type: "channel.delivery.started",
+ });
+ expect(stateStore.getSession(sessionId)).toBeUndefined();
+
+ await runtime.prepareSessionTrace(sessionEvent);
+ await runtime.prepareTurnTrace(turnEvent);
+ expect(stateStore.getSession(sessionId)).toMatchObject({
+ channelType: "http",
+ scheduleId: "sched-1",
+ title: "Investigate the incident",
+ });
+
+ await runtime.hooks.publish(sessionEvent);
+ await runtime.hooks.publish(turnEvent);
+ await completeTurn(runtime.hooks, sessionId, "turn_0");
+ });
+ await runtime.provider.forceFlush();
+
+ const turn = byName(runtime.exporter.getFinishedSpans(), "invoke_agent weather")[0]!;
+ expect(turn.attributes).toMatchObject({
+ "agent.channel.kind": "http",
+ "agent.schedule.id": "sched-1",
+ "agent.session.title": "Investigate the incident",
+ });
+ });
+
+ it("stores canonical parent lineage after a delivery arrives first", async () => {
+ const stateStore = new InMemoryAgentTraceStateStore();
+ const runtime = createRuntime(stateStore);
+ const sessionId = "session-canonical-lineage";
+ const parentLineage = {
+ callId: "call-1",
+ sessionId: "parent-session",
+ subagentName: "reviewer",
+ turnId: "turn_0",
+ };
+ const sessionEvent = {
+ agentName: "reviewer",
+ channelAudience: "public" as const,
+ channelType: "http",
+ idempotencyKey: sessionIdempotencyKey(sessionId),
+ parentLineage,
+ rootSessionId: "parent-session",
+ sessionId,
+ type: "session.started" as const,
+ };
+
+ await runtime.hooks.publish({
+ delivery: {
+ channelAudience: "public",
+ channelKind: "http",
+ channelName: "eve",
+ deliveryId: "delivery-first",
+ },
+ idempotencyKey: "channel-delivery:session-canonical-lineage:delivery-first",
+ rootSessionId: "parent-session",
+ sequence: 0,
+ sessionId,
+ turnId: "turn_0",
+ type: "channel.delivery.started",
+ });
+ expect(stateStore.getSession(sessionId)).toBeUndefined();
+
+ await runtime.prepareSessionTrace(sessionEvent);
+ await runtime.hooks.publish(sessionEvent);
+
+ expect(stateStore.getSession(sessionId)).toMatchObject({
+ channelType: "http",
+ parentLineage,
+ });
});
it("emits one bounded activation trace rooted at invoke_agent", async () => {
diff --git a/packages/eve/src/tracing/agent-otel-provider.ts b/packages/eve/src/tracing/agent-otel-provider.ts
index 2738b5a17..8ef8abfcd 100644
--- a/packages/eve/src/tracing/agent-otel-provider.ts
+++ b/packages/eve/src/tracing/agent-otel-provider.ts
@@ -152,8 +152,10 @@ export function createAgentOtelInstrumentation(
tracer: input.tracer,
});
const memory = createAgentMemoryInstrumentation({ ...input, environment });
- const { ensureSessionContext, prepareSessionTrace, prepareTurnTrace } =
- createAgentOtelSessionContext({ ...input, environment });
+ const { prepareSessionTrace, prepareTurnTrace } = createAgentOtelSessionContext({
+ ...input,
+ environment,
+ });
const projectEvent = async (event: InstrumentationEvent): Promise<InstrumentationEvent> => {
const session = await input.stateStore.getSession(sessionIdForEvent(event));
@@ -512,7 +514,6 @@ export function createAgentOtelInstrumentation(
};
const channelDeliveries = createAgentChannelDeliveryInstrumentation({
- ensureSessionContext,
recordInputs,
stateStore: input.stateStore,
});
@@ -695,6 +696,4 @@ function contextFromSpanContext(spanContext: SpanContext): Context {
return trace.setSpan(ROOT_CONTEXT, trace.wrapSpanContext(spanContext));
}
-function errorText(error: unknown): unknown {
- return error instanceof Error ? error.message : error;
-}
+const errorText = (error: unknown): unknown => (error instanceof Error ? error.message : error);
diff --git a/packages/eve/src/tracing/agent-otel-runtime-context.test.ts b/packages/eve/src/tracing/agent-otel-runtime-context.test.ts
index 1309e9163..244af61a9 100644
--- a/packages/eve/src/tracing/agent-otel-runtime-context.test.ts
+++ b/packages/eve/src/tracing/agent-otel-runtime-context.test.ts
@@ -87,6 +87,19 @@ describe("agentActivationAttributes", () => {
expect(attributes["agent.session.title"]).toBeUndefined();
});
+ it("normalizes a raw channel type when the normalized kind is absent", () => {
+ const attributes = agentActivationAttributes({
+ agentName: "general",
+ frameworkVersion: "test",
+ session: session({ channelKind: undefined, channelType: "slack" }),
+ sessionId: "root-session",
+ turn: turn(),
+ turnId: "turn_0",
+ });
+
+ expect(attributes["agent.channel.kind"]).toBe("unknown");
+ });
+
it("keeps actual channel delivery metadata on delegated activations", () => {
const attributes = agentActivationAttributes({
agentName: "general",
diff --git a/packages/eve/src/tracing/agent-otel-runtime-context.ts b/packages/eve/src/tracing/agent-otel-runtime-context.ts
index 2600c9590..2284bf773 100644
--- a/packages/eve/src/tracing/agent-otel-runtime-context.ts
+++ b/packages/eve/src/tracing/agent-otel-runtime-context.ts
@@ -2,6 +2,7 @@ import type { AgentSessionTraceState, AgentTurnTraceState } from "#tracing/agent
import { agentSpanNamingAttributes } from "#tracing/agent-span-naming.js";
import { agentInvocationSpanName } from "#tracing/agent-span-contract.js";
import { agentTraceIdentityAttributes } from "#tracing/agent-otel-attributes.js";
+import { normalizeInstrumentationChannelKind } from "#internal/instrumentation.js";
type SpanAttributePrimitive = string | number | boolean;
type SpanAttributeValue = SpanAttributePrimitive | SpanAttributePrimitive[];
@@ -21,7 +22,12 @@ export function agentActivationAttributes(input: {
const isSubagent = parentLineage !== undefined;
const channelKind =
input.turn.channelDelivery?.channelKind ??
- (isSubagent ? undefined : input.session?.channelKind);
+ (isSubagent
+ ? undefined
+ : (input.session?.channelKind ??
+ (input.session?.channelType === undefined
+ ? undefined
+ : normalizeInstrumentationChannelKind(input.session.channelType))));
const scheduleId = isSubagent ? undefined : input.session?.scheduleId;
const origin =
isSubagent || channelKind === undefined
diff --git a/packages/eve/src/tracing/agent-otel-session-context.ts b/packages/eve/src/tracing/agent-otel-session-context.ts
index 1b26dddd9..148a67483 100644
--- a/packages/eve/src/tracing/agent-otel-session-context.ts
+++ b/packages/eve/src/tracing/agent-otel-session-context.ts
@@ -65,6 +65,7 @@ export function createAgentOtelSessionContext(
agentName: event.agentName,
channelAudience,
channelKind: event.channelKind,
+ channelType: event.channelType,
decision,
context: initialSessionContext(input, event, decision),
parentLineage: event.parentLineage,
diff --git a/packages/eve/src/tracing/agent-telemetry-contract.integration.test.ts b/packages/eve/src/tracing/agent-telemetry-contract.integration.test.ts
index de3101dd4..eee4d7ca0 100644
--- a/packages/eve/src/tracing/agent-telemetry-contract.integration.test.ts
+++ b/packages/eve/src/tracing/agent-telemetry-contract.integration.test.ts
@@ -285,6 +285,7 @@ describe("exported agent telemetry contract", () => {
})!;
let dispatch: ReturnType<typeof prepareAgentInvocationTrace>;
await contextStorage.run(parent, async () => {
+ await binding.preparePreamble({ sequence: 0, sessionStarted: false });
await binding.instrumentChannelDelivery({
ctx: parent,
agentName: "parent",
@@ -310,6 +311,7 @@ describe("exported agent telemetry contract", () => {
],
},
});
+ // The tool loop prepares turn trace state after the delivery is instrumented.
await binding.preparePreamble({ sequence: 0, sessionStarted: false, turnId: "turn_0" });
await hooks.publish({
idempotencyKey: attemptIdempotencyKey(scope),
diff --git a/packages/eve/src/tracing/agent-trace-context-codec.ts b/packages/eve/src/tracing/agent-trace-context-codec.ts
index 85c38fa06..7439f5698 100644
--- a/packages/eve/src/tracing/agent-trace-context-codec.ts
+++ b/packages/eve/src/tracing/agent-trace-context-codec.ts
@@ -99,6 +99,7 @@ function deserializeSession(value: unknown): AgentSessionTraceState | undefined
agentName: typeof value.agentName === "string" ? value.agentName : undefined,
channelAudience: normalizeChannelAudience(value.channelAudience),
channelKind: typeof value.channelKind === "string" ? value.channelKind : undefined,
+ channelType: typeof value.channelType === "string" ? value.channelType : undefined,
context: value.context,
decision: readInstrumentationDecision(value.decision),
parentLineage: deserializeParentLineage(value.parentLineage),
diff --git a/packages/eve/src/tracing/agent-trace-context-store.test.ts b/packages/eve/src/tracing/agent-trace-context-store.test.ts
index 8e0c083aa..3afc685a0 100644
--- a/packages/eve/src/tracing/agent-trace-context-store.test.ts
+++ b/packages/eve/src/tracing/agent-trace-context-store.test.ts
@@ -20,6 +20,7 @@ describe("ContextAgentTraceStateStore", () => {
const store = new ContextAgentTraceStateStore();
store.setSession("session-1", {
agentName: "weather",
+ channelType: "http",
context: spanContext("1", "2"),
rootSessionId: "session-1",
});
@@ -49,7 +50,10 @@ describe("ContextAgentTraceStateStore", () => {
const restored = await deserializeContext(serialized);
await contextStorage.run(restored, () => {
const store = new ContextAgentTraceStateStore();
- expect(store.getSession("session-1")?.context).toEqual(spanContext("1", "2"));
+ expect(store.getSession("session-1")).toMatchObject({
+ channelType: "http",
+ context: spanContext("1", "2"),
+ });
expect(store.getTurn("session-1", "turn-1")?.context).toEqual(spanContext("1", "3"));
expect(store.getTurn("session-1", "turn-1")).toMatchObject({
channelDelivery: {
diff --git a/packages/eve/src/tracing/agent-trace-state.ts b/packages/eve/src/tracing/agent-trace-state.ts
index da8316286..63ac16195 100644
--- a/packages/eve/src/tracing/agent-trace-state.ts
+++ b/packages/eve/src/tracing/agent-trace-state.ts
@@ -17,6 +17,7 @@ export interface AgentSessionTraceState {
readonly channelAudience?: ChannelAudience;
readonly agentName?: string;
readonly channelKind?: string;
+ readonly channelType?: string;
readonly context: SpanContext;
readonly decision?: InstrumentationDecision;
readonly parentLineage?: InstrumentationParentLineage;