eve 0.33.2 → 0.34.0

package/dist/src/tracing/content-attributes.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Which span attributes carry conversation content, and in which direction.
+ *
+ * Two vocabularies land on the same spans: the ones eve sets on its own
+ * `agent.*` spans, and the ones the AI SDK's OpenTelemetry integration sets on
+ * the model-call spans beneath them. A destination that declined content has to
+ * be rid of both, so both are listed here rather than in the module that writes
+ * each.
+ *
+ * Listed by name rather than by prefix because the prefixes are shared with
+ * metadata that must survive: `ai.response.finish_reason` and
+ * `gen_ai.tool.name` say what happened, not what was said. The cost is that a
+ * new content attribute in a dependency is not covered until it is added here.
+ */
+/** What one destination is willing to receive. */
+export interface ResolvedContentOptions {
+    readonly recordInputs: boolean;
+    readonly recordOutputs: boolean;
+}
+/**
+ * The attributes with the declined content removed, or `undefined` when there
+ * was none to remove.
+ *
+ * The `undefined` return is what lets the caller forward the original span
+ * untouched in the common case, so a destination that declined a direction the
+ * span never carried costs one pass over its keys and no allocation.
+ */
+export declare function withoutDeclinedContent(attributes: Readonly<Record<string, unknown>>, content: ResolvedContentOptions): Record<string, unknown> | undefined;

package/dist/src/tracing/content-attributes.js

@@ -0,0 +1 @@
+const INPUT_CONTENT_ATTRIBUTES=new Set([`agent.channel.delivery.input`,`ai.documents`,`ai.prompt`,`ai.prompt.messages`,`ai.prompt.system`,`ai.prompt.toolChoice`,`ai.prompt.tools`,`ai.value`,`ai.values`,`gen_ai.input.messages`,`gen_ai.system_instructions`,`gen_ai.tool.call.arguments`,`gen_ai.tool.definitions`]),OUTPUT_CONTENT_ATTRIBUTES=new Set([`ai.embedding`,`ai.embeddings`,`ai.ranking`,`ai.response.files`,`ai.response.object`,`ai.response.reasoning`,`ai.response.text`,`ai.response.toolCalls`,`ai.response.tool_calls`,`ai.response.tool_results`,`ai.toolCall.args`,`ai.toolCall.result`,`gen_ai.output.messages`,`gen_ai.tool.call.result`]);function isDeclined(n,r){return!r.recordInputs&&INPUT_CONTENT_ATTRIBUTES.has(n)?!0:!r.recordOutputs&&OUTPUT_CONTENT_ATTRIBUTES.has(n)}function withoutDeclinedContent(e,t){let n=Object.keys(e);if(!n.some(e=>isDeclined(e,t)))return;let r={};for(let i of n)isDeclined(i,t)||(r[i]=e[i]);return r}export{withoutDeclinedContent};

package/dist/src/tracing/content-span-processor.d.ts

@@ -0,0 +1,19 @@
+import type { SpanProcessor } from "#compiled/@vercel/otel/index.js";
+import { type ResolvedContentOptions } from "#tracing/content-attributes.js";
+/**
+ * Puts one destination's content policy in front of it.
+ *
+ * Content is written onto a span if any destination wants it, so the span
+ * reaching a destination that declined still carries it. This cannot strip the
+ * attribute in place: that span object is shared with every other processor in
+ * the pipeline, and editing it would strip the attribute everywhere. So it
+ * gives the destination a facade whose attributes omit what it declined.
+ *
+ * One facade follows the original from start through end. This preserves the
+ * object identity stateful processors key on without ever exposing the original
+ * span or its attribute map. Methods stay bound to the original, so private SDK
+ * state remains reachable without eve knowing that SDK's concrete span shape.
+ *
+ * @internal
+ */
+export declare function contentFilteringProcessor(downstream: SpanProcessor, content: ResolvedContentOptions): SpanProcessor;

package/dist/src/tracing/content-span-processor.js

@@ -0,0 +1 @@
+import{hasSessionRelease}from"#tracing/local-traces.js";import{withoutDeclinedContent}from"#tracing/content-attributes.js";function contentFilteringProcessor(t,n){if(n.recordInputs&&n.recordOutputs)return t;let r=new WeakMap,i={forceFlush:()=>t.forceFlush(),onEnd:e=>{if(typeof e!=`object`||!e){t.onEnd(e);return}let i=facadeFor(e,n,r);i.refresh();try{t.onEnd(i.value)}finally{r.delete(e)}},onStart:(e,i)=>{if(typeof e!=`object`||!e){t.onStart(e,i);return}t.onStart(facadeFor(e,n,r).value,i)},shutdown:()=>t.shutdown()};return hasSessionRelease(t)?{...i,releaseSession:e=>t.releaseSession(e)}:i}function facadeFor(e,t,n){let r=n.get(e);if(r!==void 0)return r;let i={},a=[],o={},s=Object.create(Reflect.getPrototypeOf(e)),c=new Map,refresh=()=>{refreshAttributes(i,e,t),refreshEvents(a,e,t),refreshStatus(o,e,t)},l,readOriginal=t=>{let n=Reflect.get(e,t,e);if(typeof n!=`function`||t===`constructor`)return n;let r=c.get(t);if(r!==void 0)return r;let created=(...t)=>{let r=Reflect.apply(n,e,t);return refresh(),r===e?l:r};return c.set(t,created),created};Object.defineProperty(s,"attributes",{configurable:!0,enumerable:!0,value:i}),Object.defineProperty(s,"events",{configurable:!0,enumerable:!0,value:a}),Object.defineProperty(s,"status",{configurable:!0,enumerable:!0,value:o});for(let t of Reflect.ownKeys(e)){if(t===`attributes`||t===`events`||t===`status`)continue;let n=Reflect.getOwnPropertyDescriptor(e,t);Object.defineProperty(s,t,{configurable:!0,enumerable:n?.enumerable??!1,get:()=>readOriginal(t)})}l=new Proxy(s,{get:(e,t,n)=>Object.hasOwn(e,t)?Reflect.get(e,t,n):readOriginal(t)});let u={refresh,value:l};return u.refresh(),n.set(e,u),u}function refreshAttributes(e,n,r){for(let t of Object.keys(e))delete e[t];let i=n.attributes;if(typeof i!=`object`||!i)return;let a=withoutDeclinedContent(i,r);Object.assign(e,a??i)}function refreshEvents(e,t,n){e.length=0;let r=t.events;if(Array.isArray(r)){if(n.recordOutputs){e.push(...r);return}for(let t of r){if(typeof t!=`object`||!t)continue;let n=t;n.name!==`exception`&&e.push({...n,attributes:void 0})}}}function refreshStatus(e,t,n){for(let t of Object.keys(e))delete e[t];let r=t.status;if(typeof r!=`object`||!r)return;let i=r;i.code!==void 0&&(e.code=i.code),n.recordOutputs&&i.message!==void 0&&(e.message=i.message)}export{contentFilteringProcessor};

package/dist/src/tracing/install-instrumentation-runtime.d.ts

@@ -0,0 +1,19 @@
+import { type InstrumentationProviderDefinition } from "#harness/instrumentation-lifecycle.js";
+import { type InstrumentationRuntime } from "#harness/instrumentation-runtime.js";
+import type { CollectedOtel } from "#tracing/otel-declaration.js";
+/**
+ * Installs the process instrumentation runtime around a collected pipeline.
+ *
+ * Both layouts land here. `eve dev`'s zero-config default and an authored
+ * `agent/instrumentation/` directory differ only in where the declared values
+ * came from, so sharing the install keeps them on one runtime path.
+ *
+ * A directory that declared no OpenTelemetry still gets a bus: its providers
+ * see every event, they just have no spans to hang them on.
+ */
+export declare function installInstrumentationRuntime(input: {
+    readonly collected: CollectedOtel;
+    readonly frameworkVersion: string;
+    readonly providers: readonly InstrumentationProviderDefinition[];
+    readonly serviceName: string;
+}): InstrumentationRuntime;

package/dist/src/tracing/install-instrumentation-runtime.js

@@ -0,0 +1 @@
+import{createLogger,formatError}from"#internal/logging.js";import{ContextAgentTraceStateStore}from"#tracing/agent-trace-context-store.js";import{registerInstrumentationRuntime}from"#harness/instrumentation-runtime.js";import{trace}from"#compiled/@opentelemetry/api/index.js";import{createInstrumentationHooks}from"#harness/instrumentation-lifecycle.js";import{hasSessionRelease}from"#tracing/local-traces.js";import{createAgentOtelInstrumentation}from"#tracing/agent-otel-provider.js";import{registerOtelPipeline}from"#tracing/otel-registration.js";const log=createLogger(`tracing.install-instrumentation-runtime`);function installInstrumentationRuntime(e){let t=[],a=[],o,runInContext=(e,t)=>t();if(e.collected.declared){o=registerOtelPipeline({pipeline:e.collected.pipeline,serviceName:e.serviceName});let r=createAgentOtelInstrumentation({frameworkVersion:e.frameworkVersion,idGenerator:o.idGenerator,recordInputs:e.collected.settings.recordInputs,recordOutputs:e.collected.settings.recordOutputs,stateStore:new ContextAgentTraceStateStore,tracer:trace.getTracer(`eve.agent`,e.frameworkVersion)});t.push({...r.hook,stateNamespace:`internal:otel`}),runInContext=r.runInContext;let i=e.collected.pipeline.spanProcessors.filter(isSpanProcessor).filter(hasSessionRelease);i.length>0&&a.push(sessionReleaseProvider(i))}let s=[...t,...e.providers,...a],c;return registerInstrumentationRuntime({forceFlush:()=>settleAll([...o===void 0?[]:[o.forceFlush],...s.map(e=>()=>e.flush?.())]),hooks:createInstrumentationHooks({parallel:e.providers,serialAfter:a,serialBefore:t}),otelSettings:e.collected.declared?e.collected.settings:void 0,runInContext,shutdown:()=>(c??=settleAll([...o===void 0?[]:[o.shutdown],...s.map(e=>()=>e.shutdown?.())]),c)})}function isSpanProcessor(e){return e!==`auto`}function sessionReleaseProvider(e){let release=async t=>{await Promise.all(e.map(e=>e.releaseSession(t.sessionId)))};return{events:{"session.completed":release,"session.failed":release},name:`eve.session-release`,stateNamespace:`internal:session-release`}}async function settleAll(e){let n=await Promise.allSettled(e.map(async e=>e()));for(let e of n)e.status===`rejected`&&log.warn(`instrumentation drain failed`,{error:formatError(e.reason)})}export{installInstrumentationRuntime};

package/dist/src/tracing/local-instrumentation-runtime.js

@@ -1 +1 @@
-import{ContextAgentTraceStateStore}from"#tracing/agent-trace-context-store.js";import{getInstrumentationRuntime,registerInstrumentationRuntime}from"#harness/instrumentation-runtime.js";import{context,trace}from"#compiled/@opentelemetry/api/index.js";import{registerOTel}from"#compiled/@vercel/otel/index.js";import{createAgentOtelInstrumentation}from"#tracing/agent-otel-provider.js";import{AgentSpanIdGenerator}from"#tracing/agent-span-id-generator.js";import{AgentTraceSpanProcessor}from"#tracing/agent-trace-span-processor.js";import{createInstrumentationHooks}from"#harness/instrumentation-lifecycle.js";import{requestLocalTraceStorePrune,resolveLocalTraceRetentionSettings}from"#tracing/local-trace-retention.js";import{LocalTraceSpanProcessor}from"#tracing/local-trace-span-processor.js";function installLocalInstrumentationRuntime(t){let n=getInstrumentationRuntime();if(n!==void 0)return n;let r=resolveLocalTraceRetentionSettings(),i=new AgentTraceSpanProcessor(r.enabled?[new LocalTraceSpanProcessor(t.appRoot)]:[]),a=new AgentSpanIdGenerator;registerOTel({autoDetectResources:!1,idGenerator:a,instrumentations:[],propagators:[`none`],serviceName:t.serviceName,spanProcessors:[i]});let o=trace.getTracer(`eve.registration`).startSpan(`eve.otel.registration`),s=trace.setSpan(context.active(),o),c=context.with(s,()=>trace.getActiveSpan()===o);if(o.end(),!i.isAttached()||!c)throw Error(`eve could not register OpenTelemetry because another runtime already exists.`);let l=createAgentOtelInstrumentation({captureContent:process.env.EVE_TRACES_CONTENT!==`off`,frameworkVersion:t.frameworkVersion,idGenerator:a,stateStore:new ContextAgentTraceStateStore,tracer:trace.getTracer(`eve.agent`,t.frameworkVersion)}),u={events:{"session.completed":releaseSessionTrace,"session.failed":releaseSessionTrace}};return requestPrune(),registerInstrumentationRuntime({forceFlush:()=>i.forceFlush(),hooks:createInstrumentationHooks([l.hook,u]),runInContext:l.runInContext});async function releaseSessionTrace(e){await i.forceFlush(),i.releaseSession(e.sessionId)&&requestPrune()}function requestPrune(){r.enabled&&requestLocalTraceStorePrune({activeTraceIds:i.activeTraceIds(),appRoot:t.appRoot,maxAgeMs:r.maxAgeMs,maxTotalBytes:r.maxTotalBytes,retainCount:r.retainCount})}}export{installLocalInstrumentationRuntime};
+import{getInstrumentationRuntime}from"#harness/instrumentation-runtime.js";import{installInstrumentationRuntime}from"#tracing/install-instrumentation-runtime.js";import{collectOtelPipeline,otel,otelIntegration}from"#tracing/otel-declaration.js";import{createLocalTracesProcessor,resolveLocalTracesContent}from"#tracing/local-traces.js";function installLocalInstrumentationRuntime(e){let t=getInstrumentationRuntime();if(t!==void 0)return t;let n=createLocalTracesProcessor({appRoot:e.appRoot});return installInstrumentationRuntime({collected:collectOtelPipeline([otel(),otelIntegration({...resolveLocalTracesContent(),spanProcessors:[n]})]),frameworkVersion:e.frameworkVersion,providers:[],serviceName:e.serviceName})}export{installLocalInstrumentationRuntime};

package/dist/src/tracing/local-traces.d.ts

@@ -0,0 +1,56 @@
+import type { SpanProcessor } from "#compiled/@vercel/otel/index.js";
+/**
+ * The local spool, as a span processor.
+ *
+ * Session liveness and retention live in here rather than in the runtime that
+ * installs it, so nothing an author puts in the same `spanProcessors` list can
+ * see them — and eve's accept filter never reaches an author's exporters.
+ */
+export interface LocalTracesProcessor extends SpanProcessor {
+    /**
+     * Settles pending writes and drops one root session's liveness, then bounds
+     * the store. A subagent child owns no traces, so releasing one is a no-op
+     * and leaves the shared trace pinned until its root finishes.
+     */
+    releaseSession(sessionId: string): Promise<boolean>;
+}
+/**
+ * Reports whether a processor tracks which session owns which trace, so eve can
+ * tell it when that session is done.
+ *
+ * Anything standing between eve and the spool has to answer for the spool, so
+ * this is the check a wrapper uses to decide whether it must forward the call.
+ *
+ * @internal
+ */
+export declare function hasSessionRelease(processor: SpanProcessor): processor is LocalTracesProcessor;
+/**
+ * Writes the OTLP/JSON spool under `.eve/traces/v1`.
+ *
+ * `EVE_TRACES=off` removes the writer but keeps the processor: eve still has
+ * to observe spans to track which session owns which trace.
+ *
+ * Internal because of `releaseSession`, which eve's runtime drives off session
+ * lifecycle. The authored surface is `localTraces()`, which wraps this in an
+ * `OtelIntegration`.
+ */
+export declare function createLocalTracesProcessor(input?: {
+    readonly appRoot?: string;
+}): LocalTracesProcessor;
+/**
+ * The local spool's content policy: its options, intersected with
+ * `EVE_TRACES_CONTENT`.
+ *
+ * The variable used to be the process-wide switch. It now applies to this one
+ * destination, and only ever narrows — `off` still wins where it applies, but
+ * it no longer decides what a hosted backend beside it receives.
+ *
+ * @internal
+ */
+export declare function resolveLocalTracesContent(options?: {
+    readonly recordInputs?: boolean;
+    readonly recordOutputs?: boolean;
+}): {
+    readonly recordInputs: boolean;
+    readonly recordOutputs: boolean;
+};

package/dist/src/tracing/local-traces.js

@@ -0,0 +1 @@
+import{LocalTraceSpanProcessor}from"#tracing/local-trace-span-processor.js";import{AgentTraceSpanProcessor}from"#tracing/agent-trace-span-processor.js";import{requestLocalTraceStorePrune,resolveLocalTraceRetentionSettings}from"#tracing/local-trace-retention.js";function hasSessionRelease(e){return typeof e.releaseSession==`function`}function createLocalTracesProcessor(n={}){let r=n.appRoot??process.env.EVE_DEV_WORKER_APP_ROOT;if(r===void 0)return inertLocalTracesProcessor();let i=resolveLocalTraceRetentionSettings(),a=new AgentTraceSpanProcessor(i.enabled?[new LocalTraceSpanProcessor(r)]:[]),requestPrune=()=>{i.enabled&&requestLocalTraceStorePrune({activeTraceIds:a.activeTraceIds(),appRoot:r,maxAgeMs:i.maxAgeMs,maxTotalBytes:i.maxTotalBytes,retainCount:i.retainCount})};return requestPrune(),{forceFlush:()=>a.forceFlush(),onEnd:e=>a.onEnd(e),onStart:(e,t)=>a.onStart(e,t),async releaseSession(e){return await a.forceFlush(),a.releaseSession(e)?(requestPrune(),!0):!1},shutdown:()=>a.shutdown()}}function resolveLocalTracesContent(e={}){let t=process.env.EVE_TRACES_CONTENT!==`off`;return{recordInputs:t&&e.recordInputs!==!1,recordOutputs:t&&e.recordOutputs!==!1}}function inertLocalTracesProcessor(){return{forceFlush:async()=>void 0,onEnd:()=>void 0,onStart:()=>void 0,releaseSession:async()=>!1,shutdown:async()=>void 0}}export{createLocalTracesProcessor,hasSessionRelease,resolveLocalTracesContent};

package/dist/src/tracing/otel-declaration.d.ts

@@ -0,0 +1,150 @@
+import type { PropagatorOrName, SamplerOrName, SpanExporter, SpanProcessor, SpanProcessorOrName } from "#compiled/@vercel/otel/index.js";
+import { type InstrumentationProvider } from "#public/instrumentation/provider.js";
+import type { ResolvedContentOptions } from "#tracing/content-attributes.js";
+/**
+ * The process-wide OpenTelemetry settings, declared by `otel()`.
+ *
+ * Everything here is a singleton, which is why it is one file: a process has
+ * one tracer provider, so it has one resource, one sampler, and one propagator
+ * set. Destinations are the plural half and live in `otelIntegration()`.
+ *
+ * `contextManager` and `instrumentations` are deliberately absent: eve's span
+ * nesting depends on the former, and the latter cannot reach anything eve
+ * imported before setup ran.
+ */
+export interface OtelOptions {
+    /**
+     * The function identifier attached to telemetry spans
+     * (`ai.telemetry.functionId`). Defaults to the agent name.
+     */
+    readonly functionId?: string;
+    /**
+     * Whether to emit the inbound HTTP `SERVER` span that wraps each channel
+     * request — the parent of the turn trace and of any `hook.resume` or
+     * outgoing HTTP spans. Defaults to `false`.
+     */
+    readonly traceChannelRequests?: boolean;
+    /**
+     * Resource attributes merged into eve's own, which already carry the
+     * service name.
+     */
+    readonly resource?: Readonly<Record<string, unknown>>;
+    /**
+     * Head sampling, and it is global: it decides whether a span is created at
+     * all, so it thins eve's own sinks and the `traceparent` eve propagates
+     * along with your exporters. To thin one backend only, drop spans in a
+     * processor.
+     */
+    readonly sampler?: SamplerOrName;
+    /** Composed into one propagator. All inject; the first to extract wins. */
+    readonly propagators?: readonly PropagatorOrName[];
+}
+/**
+ * What one destination records of the conversation itself.
+ *
+ * Declining is per destination, not per process: content is written onto the
+ * span if any destination wants it, and one that declined never exports it. So
+ * an agent whose every destination declines still never materializes a prompt —
+ * the union of nothing is nothing — but a local spool and a hosted backend no
+ * longer have to agree.
+ */
+export interface ContentOptions {
+    /** Record model prompts and tool call inputs. Defaults to `true`. */
+    readonly recordInputs?: boolean;
+    /** Record model responses and tool call outputs. Defaults to `true`. */
+    readonly recordOutputs?: boolean;
+}
+/** Where one `otelIntegration()` sends spans, and what it records. */
+export interface OtelIntegrationOptions extends ContentOptions {
+    /** Merged into the pipeline in declaration order. */
+    readonly spanProcessors?: readonly SpanProcessor[];
+    /** Wrapped in eve's batching processor and appended after `spanProcessors`. */
+    readonly traceExporter?: SpanExporter;
+}
+declare const OTEL_DECLARATION: unique symbol;
+declare const OTEL_INTEGRATION: unique symbol;
+/**
+ * The declared OpenTelemetry pipeline settings. eve collects this before
+ * building the tracer provider, so it is a value rather than a side effect.
+ */
+export interface OtelDeclaration extends InstrumentationProvider {
+    readonly [OTEL_DECLARATION]: true;
+    readonly options: OtelOptions;
+}
+/** One declared destination. A process may have as many as it has files. */
+export interface OtelIntegration extends InstrumentationProvider {
+    readonly [OTEL_INTEGRATION]: true;
+    /** Resolved from `ContentOptions`, so the union does not re-apply defaults. */
+    readonly content: ResolvedContentOptions;
+    readonly spanProcessors: readonly SpanProcessorOrName[];
+}
+/**
+ * Declares the process-wide OpenTelemetry settings.
+ *
+ * Export it from `agent/instrumentation/otel.ts`. Omitting the file is the
+ * common case: eve registers the pipeline for whatever destinations are
+ * declared beside it, and this only names what those destinations share.
+ */
+export declare function otel(options?: OtelOptions): OtelDeclaration;
+/**
+ * Declares one destination for this agent's traces.
+ *
+ * A `traceExporter` is wrapped in eve's batching processor, which is what makes
+ * the one-line form of a hosted backend enough. Pass `spanProcessors` instead
+ * when the destination needs its own batching, sampling, or filtering.
+ *
+ * Declining content wraps every processor here, an author's included: they are
+ * this destination, and the point of declining is that nothing under it sees
+ * what was said.
+ */
+export declare function otelIntegration(options?: OtelIntegrationOptions): OtelIntegration;
+/** Vercel Agent Runs through the production request-context transport. @internal */
+export declare function agentRunsIntegration(options?: ContentOptions): OtelIntegration;
+export declare function resolveContentOptions(options: ContentOptions): ResolvedContentOptions;
+export declare function isOtelDeclaration(value: unknown): value is OtelDeclaration;
+export declare function isOtelIntegration(value: unknown): value is OtelIntegration;
+/** The one pipeline a process can register. @internal */
+export interface OtelPipeline {
+    readonly propagators?: readonly PropagatorOrName[];
+    readonly resource?: Readonly<Record<string, unknown>>;
+    readonly sampler?: SamplerOrName;
+    readonly spanProcessors: readonly SpanProcessorOrName[];
+}
+/** What the harness reads at turn time, as opposed to at registration. @internal */
+export interface OtelHarnessSettings {
+    readonly functionId?: string;
+    readonly traceChannelRequests: boolean;
+    /**
+     * What to write onto a span at all, as opposed to what any one destination
+     * exports. `agent/instrumentation.ts` sets this directly; a provider
+     * directory arrives at it as the union of its destinations.
+     */
+    readonly recordInputs?: boolean;
+    readonly recordOutputs?: boolean;
+}
+/** @internal */
+export interface CollectedOtel {
+    /**
+     * Whether anything declared OpenTelemetry. False means eve should leave the
+     * global tracer provider slot alone rather than register an empty pipeline.
+     */
+    readonly declared: boolean;
+    readonly pipeline: OtelPipeline;
+    readonly settings: OtelHarnessSettings;
+}
+/**
+ * Folds the declared values into the one pipeline a process can register.
+ *
+ * Destinations concatenate in declaration order. The singletons cannot: two
+ * `otel()` values is a boot error rather than a silent win for whichever eve
+ * happened to visit first. With one declaration per file that collision needs
+ * two files both exporting `otel()`, which is the only way to reach it.
+ *
+ * Content capture is the union of what the destinations asked for, because it
+ * governs what is written rather than what is exported. Each destination's own
+ * processors already drop what it declined.
+ *
+ * @internal
+ */
+export declare function collectOtelPipeline(values: readonly unknown[]): CollectedOtel;
+export {};

package/dist/src/tracing/otel-declaration.js

@@ -0,0 +1 @@
+import{PROVIDER}from"#public/instrumentation/provider.js";import{batchSpanProcessor}from"#tracing/batch-span-processor.js";import{contentFilteringProcessor}from"#tracing/content-span-processor.js";import{vercelRuntimeSpanProcessor}from"#tracing/vercel-runtime-span-exporter.js";const OTEL_DECLARATION=Symbol.for(`eve.instrumentation.otel`),OTEL_INTEGRATION=Symbol.for(`eve.instrumentation.otel-integration`);function otel(t={}){return{[OTEL_DECLARATION]:!0,[PROVIDER]:!0,options:t}}function otelIntegration(r={}){let i={recordInputs:r.recordInputs!==!1,recordOutputs:r.recordOutputs!==!1},o=r.spanProcessors??[],s=r.traceExporter===void 0?o:[...o,batchSpanProcessor(r.traceExporter)];return{[OTEL_INTEGRATION]:!0,[PROVIDER]:!0,content:i,spanProcessors:i.recordInputs&&i.recordOutputs?s:s.map(e=>contentFilteringProcessor(e,i))}}function agentRunsIntegration(t={}){let i=resolveContentOptions(t);return{[OTEL_INTEGRATION]:!0,[PROVIDER]:!0,content:i,spanProcessors:i.recordInputs&&i.recordOutputs?[`auto`]:[contentFilteringProcessor(vercelRuntimeSpanProcessor(),i)]}}function resolveContentOptions(e){return{recordInputs:e.recordInputs!==!1,recordOutputs:e.recordOutputs!==!1}}function isOtelDeclaration(e){return typeof e==`object`&&!!e&&e[OTEL_DECLARATION]===!0}function isOtelIntegration(e){return typeof e==`object`&&!!e&&e[OTEL_INTEGRATION]===!0}function collectOtelPipeline(e){let t=[],n,r=!1,i=!1,a=!1;for(let o of e){if(isOtelIntegration(o)){r=!0,i||=o.content.recordInputs,a||=o.content.recordOutputs,t.push(...o.spanProcessors);continue}if(isOtelDeclaration(o)){if(n!==void 0)throw Error("Instrumentation declares `otel()` more than once. One process has one OpenTelemetry tracer provider, so it has one resource, one sampler, and one propagator set — declare them in a single `otel()`.");r=!0,n=o}}let o=n?.options??{};return{declared:r,pipeline:{propagators:o.propagators,resource:o.resource,sampler:o.sampler,spanProcessors:t},settings:{functionId:o.functionId,recordInputs:i,recordOutputs:a,traceChannelRequests:o.traceChannelRequests===!0}}}export{agentRunsIntegration,collectOtelPipeline,isOtelDeclaration,isOtelIntegration,otel,otelIntegration,resolveContentOptions};

package/dist/src/tracing/otel-registration.d.ts

@@ -0,0 +1,21 @@
+import { AgentSpanIdGenerator } from "#tracing/agent-span-id-generator.js";
+import type { OtelPipeline } from "#tracing/otel-declaration.js";
+/**
+ * Builds the process's one OpenTelemetry tracer provider from a merged
+ * declaration, then proves it took the global slot.
+ *
+ * `registerOTel` reports a refused registration only through `diag`, which
+ * goes nowhere unless `OTEL_LOG_LEVEL` is set, so a second caller would export
+ * nothing and say nothing. eve primes its id generator and installs a private
+ * propagator, then verifies both through the global APIs.
+ */
+export declare function registerOtelPipeline(input: {
+    readonly pipeline: OtelPipeline;
+    readonly serviceName: string;
+}): RegisteredOtelPipeline;
+/** Lifecycle retained from the tracer provider that owns every destination. */
+export interface RegisteredOtelPipeline {
+    readonly forceFlush: () => Promise<void>;
+    readonly idGenerator: AgentSpanIdGenerator;
+    readonly shutdown: () => Promise<void>;
+}

package/dist/src/tracing/otel-registration.js

@@ -0,0 +1 @@
+import{context,propagation,trace}from"#compiled/@opentelemetry/api/index.js";import{registerOTel}from"#compiled/@vercel/otel/index.js";import{AgentSpanIdGenerator}from"#tracing/agent-span-id-generator.js";const REGISTRATION_SPAN_NAME=`eve.otel.registration`,REPLAY_DEDUPLICATION_LIMIT=1e5;var RegistrationMarkerPropagator=class{#e=!1;extract(e){return e}fields(){return[]}inject(){this.#e=!0}isInstalled(){return this.#e=!1,propagation.inject(context.active(),{},{set:()=>{}}),this.#e}},PrivateSpanFilteringProcessor=class{endedSpans=new Set;forwardedSpans=new Set;pendingByParent=new Map;processors;startedSpans=new Set;constructor(e){this.processors=e}async forceFlush(){await Promise.all(this.processors.map(e=>e.forceFlush()))}onEnd(e){if(isRegistrationSpan(e))return;let t=spanIdentity(e);if(t!==void 0){if(this.endedSpans.has(t))return;if(this.endedSpans.size>=REPLAY_DEDUPLICATION_LIMIT){let e=this.endedSpans.values().next().value;e!==void 0&&this.endedSpans.delete(e)}this.endedSpans.add(t)}let n=parentIdentity(e);if(n!==void 0&&this.startedSpans.has(n)&&!this.forwardedSpans.has(n)){let t=this.pendingByParent.get(n)??[];t.push(e),this.pendingByParent.set(n,t);return}this.forward(e,t)}onStart(e,t){if(isRegistrationSpan(e))return;let n=spanIdentity(e);n!==void 0&&addBounded(this.startedSpans,n);for(let n of this.processors)n.onStart(e,t)}async shutdown(){await Promise.all(this.processors.map(e=>e.shutdown()))}forward(e,t){for(let t of this.processors)t.onEnd(e);if(t===void 0)return;addBounded(this.forwardedSpans,t);let n=this.pendingByParent.get(t);if(n!==void 0){this.pendingByParent.delete(t);for(let e of n)this.forward(e,spanIdentity(e))}}};function registerOtelPipeline(e){let{pipeline:t}=e,n=new AgentSpanIdGenerator,i=new RegistrationMarkerPropagator,a={attributes:t.resource,autoDetectResources:!1,idGenerator:n,instrumentations:[],propagators:[...t.propagators??[`none`],i],serviceName:e.serviceName,spanProcessors:t.spanProcessors.map(e=>isSpanProcessor(e)?new PrivateSpanFilteringProcessor([e]):e)};registerOTel(t.sampler===void 0?a:{...a,traceSampler:t.sampler});let o=globalTracerUses(n),s=i.isInstalled();if((!o||!s)&&rollbackRegistration({ownsPropagator:s,ownsTracer:o}),!o)throw Error("eve could not register OpenTelemetry because another runtime already owns the global tracer provider. Remove the other `registerOTel` call, or move its exporters into eve's `otelIntegration({ spanProcessors: [...] })`.");if(!s)throw Error("eve could not register OpenTelemetry because another runtime already owns the global propagator. Remove the other global propagator registration and declare propagators through eve's `otel()` instead.");let c=runtimeTracerProvider();if(typeof c.forceFlush!=`function`||typeof c.shutdown!=`function`)throw rollbackRegistration({ownsPropagator:s,ownsTracer:o}),Error(`The registered OpenTelemetry tracer provider has no lifecycle methods.`);return{forceFlush:()=>c.forceFlush(),idGenerator:n,shutdown:()=>c.shutdown()}}function rollbackRegistration(e){if(e.ownsPropagator&&propagation.disable(),!e.ownsTracer)return;let r=runtimeTracerProvider();if(typeof r.shutdown==`function`)try{r.shutdown().catch(()=>{})}catch{}trace.disable()}function runtimeTracerProvider(){let e=trace.getTracerProvider();return e.getDelegate?.()??e}function globalTracerUses(e){let t=e.allocateSpanId();return e.withSpanId(t,()=>trace.getTracer(`eve.registration`).startSpan(REGISTRATION_SPAN_NAME)).spanContext().spanId===t}function isRegistrationSpan(e){return typeof e==`object`&&!!e&&`name`in e&&e.name===REGISTRATION_SPAN_NAME}function spanIdentity(e){if(typeof e!=`object`||!e||!(`spanContext`in e)||typeof e.spanContext!=`function`)return;let t=e.spanContext();return typeof t.traceId==`string`&&typeof t.spanId==`string`?`${t.traceId}:${t.spanId}`:void 0}function parentIdentity(e){if(typeof e!=`object`||!e||!(`parentSpanContext`in e))return;let t=e.parentSpanContext;return typeof t?.traceId==`string`&&typeof t.spanId==`string`?`${t.traceId}:${t.spanId}`:void 0}function addBounded(e,t){if(e.size>=REPLAY_DEDUPLICATION_LIMIT){let t=e.values().next().value;t!==void 0&&e.delete(t)}e.add(t)}function isSpanProcessor(e){return e!==`auto`}export{registerOtelPipeline};

package/dist/src/tracing/vercel-runtime-span-exporter.d.ts

@@ -0,0 +1,5 @@
+import type { SpanExporter, SpanProcessor } from "#compiled/@vercel/otel/index.js";
+/** The request-context transport behind @vercel/otel's automatic processor. */
+export declare function vercelRuntimeSpanExporter(): SpanExporter;
+/** Reports immediately so the span stays attached to its request context. */
+export declare function vercelRuntimeSpanProcessor(): SpanProcessor;

package/dist/src/tracing/vercel-runtime-span-exporter.js

@@ -0,0 +1 @@
+import{createLogger,formatError}from"#internal/logging.js";import{TraceFlags}from"#compiled/@opentelemetry/api/index.js";import{JsonTraceSerializer}from"#compiled/@opentelemetry/otlp-transformer/index.js";const VERCEL_REQUEST_CONTEXT=Symbol.for(`@vercel/request-context`),log=createLogger(`tracing.vercel-runtime-span-exporter`);function vercelRuntimeSpanExporter(){return{export(e,t){let n=globalThis[VERCEL_REQUEST_CONTEXT]?.get()?.telemetry;if(n===void 0){t({code:0});return}try{let i=JsonTraceSerializer.serializeRequest([...e]);if(i===void 0)throw Error(`Failed to serialize spans.`);n.reportSpans(JSON.parse(new TextDecoder().decode(i))),t({code:0})}catch(e){t({code:1,error:e instanceof Error?e:Error(String(e))})}},forceFlush:async()=>void 0,shutdown:async()=>void 0}}function vercelRuntimeSpanProcessor(){let e=vercelRuntimeSpanExporter(),n=!1;return{forceFlush:()=>e.forceFlush?.()??Promise.resolve(),onEnd(r){n||!isSampled(r)||e.export([r],e=>{e.code!==0&&log.warn(`Agent Runs export failed`,{error:formatError(e.error??Error(`Span export failed.`))})})},onStart(){},async shutdown(){n=!0,await e.shutdown()}}}function isSampled(e){if(typeof e!=`object`||!e||!(`spanContext`in e))return!1;let t=e.spanContext;if(typeof t!=`function`)return!1;let r=Reflect.apply(t,e,[]);return typeof r.traceFlags==`number`&&(r.traceFlags&TraceFlags.SAMPLED)===TraceFlags.SAMPLED}export{vercelRuntimeSpanExporter,vercelRuntimeSpanProcessor};

package/dist/src/vue/index.js

@@ -1,3 +1,3 @@
-import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-3oBnxzhV.js";
+import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-FJkEMXYk.js";
 
 export { defaultMessageReducer, useEveAgent };

package/dist/src/vue/use-eve-agent.js

@@ -1,3 +1,3 @@
-import { t as useEveAgent } from "../chunks/use-eve-agent-3oBnxzhV.js";
+import { t as useEveAgent } from "../chunks/use-eve-agent-FJkEMXYk.js";
 
 export { useEveAgent };

package/docs/guides/instrumentation.md

@@ -58,6 +58,28 @@ You are responsible for ensuring any observability or eval provider is approved
 
 The third configurable surface, [runtime context events](#runtime-context), attaches per-model-call values to these spans.
 
+## Channel delivery traces
+
+Instrumentation providers receive `channel.delivery.started` followed by
+`channel.delivery.completed`, `channel.delivery.cancelled`, or
+`channel.delivery.failed` for every inbound channel operation. The lifecycle
+covers durable processing through the terminal state of the resulting turn, not
+messages an adapter sends back to Slack, Telegram, Twilio, or another platform.
+Several deliveries can coalesce into one turn while retaining separate lifecycle
+pairs, and an adapter can consume a delivery without starting a turn.
+
+Each operation has a framework-owned `deliveryId` distinct from its optional
+platform request ID. Metadata-only providers receive identity, channel, session,
+and outcome fields. Content providers additionally receive only eve's known
+message, context, input-response, and output-schema fields; adapter-specific
+payload fields are never projected.
+
+The built-in OpenTelemetry provider maps each pair to an
+`agent.channel.delivery` consumer span under the durable session window. When
+`traceChannelRequests: true` creates an inbound HTTP server span, the delivery
+span links to it with `eve.link.type=channel.request` rather than using the
+short-lived request span as its parent.
+
 ## Runtime context
 
 _Runtime context_ is an [AI SDK concept](https://ai-sdk.dev/docs/reference/ai-sdk-core/stream-text): a user-defined object that flows through a generation lifecycle. eve exposes it through `events["step.started"]`, a callback that runs once eve has assembled the model input for an attempt and returns `{ runtimeContext }`. Because eve registers the AI SDK's OpenTelemetry integration with runtime context enabled, those returned values ride onto the model-call span and its children. The field is named `runtimeContext`, not `metadata`, because AI SDK v7 carries per-call attributes on runtime context rather than a dedicated metadata field.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.33.2",
+  "version": "0.34.0",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [
@@ -206,6 +206,11 @@
       "import": "./dist/src/public/instrumentation/index.js",
       "default": "./dist/src/public/instrumentation/index.js"
     },
+    "./instrumentation/otel": {
+      "types": "./dist/src/public/instrumentation/otel.d.ts",
+      "import": "./dist/src/public/instrumentation/otel.js",
+      "default": "./dist/src/public/instrumentation/otel.js"
+    },
     "./schedules": {
       "types": "./dist/src/public/schedules/index.d.ts",
       "import": "./dist/src/public/schedules/index.js",
@@ -307,6 +312,7 @@
     "@clack/core": "1.3.1",
     "@nuxt/kit": "^4.0.0",
     "@opentelemetry/context-async-hooks": "2.6.1",
+    "@opentelemetry/core": "2.6.1",
     "@opentelemetry/otlp-transformer": "0.214.0",
     "@opentelemetry/sdk-trace-base": "2.6.1",
     "@photon-ai/chat-adapter-imessage": "3.2.0",

package/dist/src/harness/otel-integration.d.ts

@@ -1,12 +0,0 @@
-import { type Telemetry } from "ai";
-/**
- * Registers the AI SDK OpenTelemetry integration once so that model
- * calls emit OTel spans, including runtime-context attributes. Safe to
- * call multiple times — only the first call has an effect.
- *
- * In AI SDK v7 the built-in OTel tracing was moved to `@ai-sdk/otel`
- * and must be registered explicitly.
- */
-export declare function ensureOtelIntegration(): void;
-/** Creates the existing OTel integration for explicit per-call composition. */
-export declare function createOtelIntegration(): Telemetry;

package/dist/src/harness/otel-integration.js

@@ -1 +0,0 @@
-import{registerTelemetry}from"ai";import{OpenTelemetry}from"#compiled/@ai-sdk/otel/index.js";let registered=!1;function ensureOtelIntegration(){registered||(registered=!0,registerTelemetry(createOtelIntegration()))}function createOtelIntegration(){return new OpenTelemetry({runtimeContext:!0})}export{createOtelIntegration,ensureOtelIntegration};