eve 0.78.0 → 0.79.0

package/dist/src/compiled/@eve/tracing/core/scopes.d.ts

@@ -0,0 +1,59 @@
+import { type McpLifecycle } from "./mcp.js";
+import type { AgentTelemetry, CaptureDecision, ContentSerializer, ExecutionContext, Operation, ScopeData, ScopeIdentity, ScopeRecord, ScopeTerminal, TraceErrorHandler, TraceLink, TraceReference, Usage } from "./types.js";
+export interface ChildOptions {
+    readonly links?: readonly TraceLink[];
+    readonly startTimeMs?: number;
+}
+export interface LiveOperation extends Operation {
+    child(data: ScopeData, key?: string, options?: ChildOptions): Promise<LiveOperation>;
+    /** Returns an unsettled child with this identity, without starting one. */
+    find(data: ScopeData): LiveOperation | undefined;
+    /** Unsettled children, in start order. */
+    readonly children: readonly LiveOperation[];
+    usage(usage: Usage, key?: string): Promise<void>;
+    /** Carries a model call's messages up to its turn: the first input and the latest output. */
+    turnContent(content: {
+        readonly input?: string;
+        readonly output?: string;
+    }): void;
+    error(error?: unknown, type?: string): void;
+    /** Replaces the host context for this operation and its descendants. */
+    useContext(context: ExecutionContext): void;
+    /** Fills in a deferred operation's details from a later call with the same identity. */
+    refine(data: ScopeData, startTimeMs?: number): void;
+    /** Lowers capture for this operation and its children, and drops retained content it no longer allows. */
+    narrow(capture: CaptureDecision): void;
+    /** Completes this operation, or closes the open descendants of a finished one. */
+    release(result: ScopeTerminal): Promise<void>;
+    /** Finished, with no unfinished descendants. */
+    readonly settled: boolean;
+    readonly callId?: string;
+    readonly mcp: McpLifecycle;
+    record(): ScopeRecord;
+}
+export declare function createScopes(input: {
+    readonly telemetry: AgentTelemetry;
+    readonly serializer: ContentSerializer;
+    readonly durable: boolean;
+    readonly onError?: TraceErrorHandler;
+}): {
+    /** Starts a turn tree. Durable turns reserve their IDs from `key`. */
+    start(facts: {
+        identity: ScopeIdentity;
+        key: string;
+        capture: CaptureDecision;
+        data: ScopeData;
+        parent?: TraceReference;
+        reference?: TraceReference;
+        startTimeMs?: number;
+        links?: readonly TraceLink[];
+        context?: ExecutionContext;
+        onChange?: () => Promise<void>;
+    }): Promise<LiveOperation>;
+    /** Rebuilds a tree from a checkpoint, or returns `undefined` for an unusable one. */
+    restore(snapshot: unknown, options?: {
+        capture?: CaptureDecision;
+        context?: ExecutionContext;
+        onChange?: () => Promise<void>;
+    }): Promise<LiveOperation | undefined>;
+};

package/dist/src/compiled/@eve/tracing/core/snapshot.d.ts

@@ -0,0 +1,7 @@
+import type { ScopeRecord } from "./types.js";
+import type { ContentSerializer } from "./types.js";
+import type { TraceSnapshot } from "./types.js";
+export declare function boundedSerializer(serializer: ContentSerializer, onError?: import("./types.js").TraceErrorHandler): ContentSerializer;
+export declare function traceSnapshot(value: unknown): TraceSnapshot;
+export declare function validSnapshot(value: unknown, maxBytes?: number, depth?: number): value is ScopeRecord;
+export declare function snapshotRecord(record: ScopeRecord, serializer: ContentSerializer): ScopeRecord;

package/dist/src/compiled/@eve/tracing/core/span-kinds.d.ts

@@ -0,0 +1,12 @@
+export declare const invocationName: (name?: string) => string;
+export declare function applyAttributes(span: {
+    setAttribute(key: string, value: Exclude<Attributes[string], undefined>): unknown;
+}, attributes: Attributes): void;
+import type { ContentSerializer } from "./types.js";
+import type { ScopeData, ScopeRecord, ScopeTerminal } from "./types.js";
+import type { Attributes, CaptureDecision, PreparedSpan } from "./types.js";
+import type { TraceOperation } from "./writer.js";
+export declare function parentKinds(data: ScopeData): readonly ScopeData["type"][];
+export declare function prepareScope(record: Omit<ScopeRecord, "reference">, serializer: ContentSerializer): PreparedSpan;
+export declare function completeScope(span: TraceOperation, data: ScopeData, result: ScopeTerminal, capture: CaptureDecision, startTimeMs: number, serializer: ContentSerializer): void;
+export declare function capturedScopeData(data: ScopeData, capture: CaptureDecision): ScopeData;

package/dist/src/compiled/@eve/tracing/core/types.d.ts

@@ -0,0 +1,292 @@
+export type AttributeValue = string | number | boolean | (string | null | undefined)[] | (number | null | undefined)[] | (boolean | null | undefined)[];
+export type Attributes = Readonly<Record<string, AttributeValue | undefined>>;
+export type TraceJson = null | boolean | number | string | readonly TraceJson[] | {
+    readonly [key: string]: TraceJson;
+};
+declare const traceSnapshotBrand: unique symbol;
+export type TraceSnapshot = TraceJson & {
+    readonly [traceSnapshotBrand]: true;
+};
+export type SpanType = "activation" | "step" | "model" | "tool" | "approval" | "memory" | "channelRequest" | "mcp";
+export type SpanKind = "INTERNAL" | "CLIENT" | "SERVER" | "PRODUCER" | "CONSUMER";
+/** Host-owned process-local context. Never stored in a checkpoint. */
+export type ExecutionContext = object;
+export interface TraceReference {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly traceFlags: number;
+    readonly isRemote?: boolean;
+    readonly tracestate?: string;
+}
+export interface CaptureDecision {
+    readonly emit: boolean;
+    readonly recordInputs: boolean;
+    readonly recordOutputs: boolean;
+}
+export interface TraceErrorContext {
+    readonly phase: "start" | "serialize" | "complete" | "context" | "restore" | "checkpoint";
+    readonly operation?: SpanType;
+    readonly reference?: TraceReference;
+}
+export type TraceErrorHandler = (error: unknown, context: TraceErrorContext) => void;
+export interface TraceLink {
+    readonly context: TraceReference;
+    readonly relationship: string;
+}
+export interface PreparedSpan {
+    readonly type: SpanType;
+    readonly operationId: string;
+    readonly name: string;
+    readonly kind?: SpanKind;
+    readonly attributes: Attributes;
+    readonly parent?: TraceReference;
+    readonly root?: boolean;
+    readonly startTimeMs?: number;
+    readonly links?: readonly TraceLink[];
+}
+export interface SpanWriter {
+    readonly reference: TraceReference;
+    setAttribute(key: string, value: AttributeValue): void;
+    addEvent(name: string, attributes?: Attributes, timeMs?: number): void;
+    fail(error?: unknown, errorType?: string): void;
+    setStatus(code: "UNSET" | "OK" | "ERROR"): void;
+    end(timeMs?: number): void;
+}
+/** Span output and context propagation used by agent tracing. */
+export interface AgentTelemetry {
+    /** Starts a span. A `reference` requests that exact trace and span ID. */
+    startSpan(span: PreparedSpan, options?: {
+        readonly reference?: TraceReference;
+        readonly context?: ExecutionContext;
+    }): SpanWriter;
+    /** Returns the operation active in the current execution context. */
+    active(): ActiveOperation | undefined;
+    /** Runs `execute` with `operation` as the active trace context. */
+    run<T>(operation: ActiveOperation, execute: () => T, context?: ExecutionContext): T;
+    /** Runs `execute` without creating spans. */
+    suppressed?<T>(execute: () => T): T;
+    /** Decides whether a durable turn's trace is recorded. Defaults to recording. */
+    samples?(traceId: string, span: PreparedSpan): boolean;
+    /** Derives stable IDs from keys. Present only when `startSpan` honors `reference`. */
+    readonly ids?: {
+        traceId(key: string): string;
+        spanId(key: string): string;
+    };
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+/** Durable storage for in-flight turns. Values are JSON; keys are chosen by the library. */
+export interface TraceCheckpointer {
+    get(key: string): unknown | PromiseLike<unknown>;
+    set(key: string, value: TraceSnapshot): void | PromiseLike<void>;
+    delete(key: string): void | PromiseLike<void>;
+}
+export interface ActiveOperation {
+    readonly type: SpanType;
+    readonly reference: TraceReference;
+    readonly capture: CaptureDecision;
+    readonly mcp?: import("./mcp.js").McpLifecycle;
+}
+export interface MappingContext {
+    readonly type: SpanType;
+    readonly operationId: string;
+}
+export interface OutputMapping {
+    attributes(span: MappingContext, attributes: Attributes): Attributes;
+    link(span: MappingContext, link: TraceLink): Attributes;
+}
+export interface RunIdentity {
+    readonly conversationId: string;
+    readonly runId: string;
+    readonly turnId: string;
+}
+export interface FrameworkIdentity {
+    readonly name: string;
+    readonly version?: string;
+}
+export interface Usage {
+    readonly costUsd?: number;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly inputTokenDetails?: {
+        readonly cacheReadTokens?: number;
+        readonly cacheWriteTokens?: number;
+    };
+}
+/** `subagent-call` and `remote-agent-call` delegate to another agent. */
+export type ToolKind = string;
+export interface ContentSerializer {
+    json(value: unknown): string | undefined;
+    text(value: string): string | undefined;
+    inputMessages(value: unknown): string | undefined;
+    instructions(value: unknown): string | undefined;
+    toolDefinitions(value: unknown): string | undefined;
+    outputMessages(value: readonly ContentPart[], finishReason: string): string | undefined;
+    toolResults(value: readonly Record<string, unknown>[]): string | undefined;
+}
+export interface ModelResult {
+    readonly usage: Usage;
+    readonly responseId?: string;
+    readonly responseModelId?: string;
+    readonly finishReason: string;
+    readonly content?: readonly ContentPart[];
+}
+export interface ScopeIdentity extends RunIdentity {
+    readonly agentName?: string;
+    readonly framework?: FrameworkIdentity;
+}
+export interface TurnMetadata {
+    readonly attributes?: Attributes;
+    readonly sequence: number;
+    readonly subagent?: boolean;
+    readonly subagentName?: string;
+    readonly parentCallId?: string;
+    readonly parentRunId?: string;
+    readonly channel?: {
+        kind?: string;
+        origin?: string;
+    };
+}
+export interface StepOptions {
+    readonly index: number;
+    readonly attempt?: number;
+    readonly channel?: {
+        kind?: string;
+        origin?: string;
+    };
+    readonly runtimeContext?: Readonly<Record<string, unknown>>;
+}
+export interface ModelOptions {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly messages?: readonly unknown[];
+    readonly instructions?: unknown;
+    /** Tools offered to the model, recorded as `gen_ai.tool.definitions`. */
+    readonly tools?: unknown;
+    readonly runtimeContext?: Readonly<Record<string, unknown>>;
+}
+export interface ToolOptions {
+    readonly callId: string;
+    readonly name: string;
+    readonly kind?: ToolKind;
+    readonly arguments?: unknown;
+}
+export type ScopeData = {
+    readonly type: "activation";
+    readonly options: TurnMetadata;
+} | {
+    readonly type: "step";
+    readonly options: StepOptions;
+} | {
+    readonly type: "model";
+    readonly options: ModelOptions;
+} | {
+    readonly type: "tool";
+    readonly options: ToolOptions;
+} | {
+    readonly type: "approval";
+    readonly options: {
+        requestId: string;
+        request?: unknown;
+        callId: string;
+        toolName: string;
+    };
+} | {
+    readonly type: "memory";
+    readonly options: {
+        operation: "search_memory" | "upsert_memory";
+        phase: string;
+        slot: string;
+        storeId: string;
+    };
+};
+export interface ScopeTerminal {
+    readonly outcome?: string;
+    /** Ends the operation without recording an outcome, when the host never learned one. */
+    readonly outcomeUnknown?: boolean;
+    readonly failed?: boolean;
+    readonly error?: unknown;
+    readonly errorCode?: string;
+    readonly output?: unknown;
+    readonly response?: unknown;
+    readonly usage?: Usage;
+    readonly model?: ModelResult;
+    readonly recordCount?: number;
+    readonly records?: readonly {
+        id?: string;
+        content: string;
+    }[];
+    readonly endTimeMs?: number;
+}
+export interface ScopeRecord {
+    readonly version?: 1;
+    readonly finished?: boolean;
+    /** Write token used to detect a checkpoint changed by another process. */
+    readonly revision?: string;
+    readonly key: string;
+    readonly identity: ScopeIdentity;
+    readonly data: ScopeData;
+    readonly reference: TraceReference;
+    readonly parent?: TraceReference;
+    readonly attempt?: {
+        readonly index: number;
+        readonly attempt: number;
+    };
+    readonly capture: CaptureDecision;
+    readonly startTimeMs: number;
+    readonly links?: readonly TraceLink[];
+    readonly usage?: Usage;
+    readonly usageKeys?: readonly string[];
+    readonly attributes?: Attributes;
+    readonly childSequence?: number;
+    readonly children?: readonly ScopeRecord[];
+    readonly terminal?: ScopeTerminal;
+}
+export interface Operation {
+    child(data: ScopeData, key?: string): Promise<Operation>;
+    waitUntil(completion: Promise<void>): void;
+    readonly type: ScopeData["type"];
+    readonly reference: TraceReference;
+    readonly parent?: TraceReference;
+    readonly startTimeMs: number;
+    readonly capture: CaptureDecision;
+    readonly finished: boolean;
+    snapshot(): TraceSnapshot;
+    run<T>(execute: () => T, ceiling?: CaptureDecision): T;
+    attributes(attributes: Attributes): void;
+    update(input: {
+        attributes?: Attributes;
+        links?: readonly TraceLink[];
+    }): void;
+    complete(result?: ScopeTerminal & {
+        errorType?: string;
+        result?: ModelResult;
+    }): Promise<void>;
+    fail(error: unknown): Promise<void>;
+    modelCall(input: ModelOptions, key?: string): Promise<Operation>;
+}
+export type ContentPart = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "reasoning";
+    readonly text: string;
+} | {
+    readonly type: "tool-call";
+    readonly callId: string;
+    readonly toolName: string;
+    readonly input: unknown;
+} | {
+    readonly type: "tool-result";
+    readonly callId: string;
+    readonly toolName: string;
+    readonly input: unknown;
+    readonly output: unknown;
+} | {
+    readonly type: "tool-error";
+    readonly callId: string;
+    readonly toolName: string;
+    readonly input: unknown;
+    readonly error: unknown;
+};
+export {};

package/dist/src/compiled/@eve/tracing/core/writer.d.ts

@@ -0,0 +1,15 @@
+import type { PreparedSpan, SpanWriter, ExecutionContext, AgentTelemetry, TraceReference, CaptureDecision, TraceErrorHandler } from "./types.js";
+export interface TraceOperation extends SpanWriter {
+    readonly capture: CaptureDecision;
+    readonly finished: boolean;
+    run<T>(execute: () => T): T;
+    /** Lowers what the span accepts from now on. */
+    narrow(capture: CaptureDecision): void;
+}
+export declare function createSpanWriter(input: {
+    telemetry: Pick<AgentTelemetry, "startSpan" | "run" | "suppressed">;
+    onError?: TraceErrorHandler;
+}): {
+    start: (span: PreparedSpan, capture: CaptureDecision, host?: ExecutionContext, reserved?: TraceReference) => TraceOperation;
+    startReserved: (span: PreparedSpan, reference: TraceReference, capture: CaptureDecision, host?: ExecutionContext) => TraceOperation;
+};

package/dist/src/compiled/@eve/tracing/delegation.d.ts

@@ -0,0 +1,2 @@
+export { createAgentDelegationTransport } from "./adapters/agent-transport.js";
+export { currentAgentHandoff, withAgentHandoff, type AgentHandoff } from "./core/delegation.js";

package/dist/src/compiled/@eve/tracing/delegation.js

@@ -0,0 +1 @@
+import{n as e,t}from"../../_chunks/workflow/delegation-BqhZ398D.js";const n=`x-agent-tracing`,r=new TextEncoder;function i(e,t){return typeof e==`string`&&e.length===t&&/^[a-f0-9]+$/u.test(e)&&!/^0+$/u.test(e)}function a(e,i){return(a,o)=>{let s=t();if(s===void 0)return e(a,o);let c=JSON.stringify(s);if(r.encode(c).length>i)return e(a,o);let l=new Headers(o?.headers??(a instanceof Request?a.headers:void 0));return l.set(n,c),e(a,{...o,headers:l,redirect:`error`})}}function o(t,a,o,s){let c=t.get(n);if(c===null||c.length>s||r.encode(c).length>s)return o();let l,u=(()=>{try{return l=JSON.parse(c),typeof l!=`object`||!l||![l.conversationId,l.parentRunId,l.parentCallId,l.agentName].every(e=>typeof e==`string`&&e.length>0&&e.length<=1024)||!i(l.caller.traceId,32)||!i(l.caller.spanId,16)||![0,1].includes(l.caller.traceFlags)||l.caller.tracestate!==void 0&&(typeof l.caller.tracestate!=`string`||l.caller.tracestate.length>512)||![l.capture.emit,l.capture.recordInputs,l.capture.recordOutputs].every(e=>typeof e==`boolean`)||!a(l)?void 0:l}catch{return}})();if(u===void 0)return o();let d={...u,remote:!0,capture:{emit:u.capture.emit&&u.caller.traceFlags===1,recordInputs:u.capture.emit&&u.caller.traceFlags===1&&u.capture.recordInputs,recordOutputs:u.capture.emit&&u.caller.traceFlags===1&&u.capture.recordOutputs}};return e(d,()=>o(d))}function s(t=(e,t)=>globalThis.fetch(e,t)){let n=8192;return{fetch:a(t,n),transport:e=>a(e,n),receive(e,t,r){return o(e,t,r,n)},resume(t,n){return e(t,()=>n(t))}}}export{s as createAgentDelegationTransport,t as currentAgentHandoff,e as withAgentHandoff};

package/dist/src/compiled/@eve/tracing/index.d.ts

@@ -0,0 +1,6 @@
+export { createAgentTracing, type AgentTracing, type AgentTracingOptions, type AgentMemoryTracing, type TurnInput, type ResumeInput, } from "./agent-tracing.js";
+export { otelTelemetry, type OtelTelemetryOptions } from "./adapters/otel.js";
+export { AgentSpanIdGenerator } from "./adapters/otel-ids.js";
+export type { Operation, TurnOperation, AttemptInput, AttemptOperation, ToolInput, ModelOperation, ToolOperation, ApprovalOperation, MemoryOperation, ModelCallReturn, ModelStreamReturn, } from "./operations.js";
+export type { ActiveOperation, AgentTelemetry, Attributes, CaptureDecision, ContentPart, ContentSerializer, ExecutionContext, MappingContext, OutputMapping, PreparedSpan, SpanWriter, TraceCheckpointer, TraceErrorContext, TraceErrorHandler, TraceLink, TraceReference, TraceSnapshot, Usage, } from "./core/types.js";
+export { currentCapture } from "./capture.js";

package/dist/src/compiled/@eve/tracing/index.js

@@ -0,0 +1 @@
+import{f as e,g as t,i as n,l as r,m as i,n as a,o,r as s,s as c,t as l,u,v as d}from"../../_chunks/workflow/mcp-CrGp4EC8.js";import{n as f,t as p}from"../../_chunks/workflow/delegation-BqhZ398D.js";import{createHash as m,randomBytes as h,randomUUID as g}from"node:crypto";var _=class{#e;#t;allocateSpanId(){return y(16)}deriveSpanId(e){return v(e)}deriveTraceId(e){let t=m(`sha256`).update(e).digest(`hex`).slice(0,32);return/^0+$/u.test(t)?`00000000000000000000000000000001`:t}generateSpanId(){let e=this.#e;return e===void 0?y(16):(this.#e=void 0,e)}generateTraceId(){let e=this.#t;return e===void 0?y(32):(this.#t=void 0,e)}withSpanId(e,t){this.#e=e;try{return t()}finally{this.#e=void 0}}withTraceId(e,t){this.#t=e;try{return t()}finally{this.#t=void 0}}};function v(e){let t=m(`sha256`).update(e).digest(`hex`).slice(0,16);return/^0+$/u.test(t)?`0000000000000001`:t}function y(e){let t;do{t=``;for(let n=0;n<e;n+=1)t+=`0123456789abcdef`[Math.trunc(Math.random()*16)]}while(!/[1-9a-f]/u.test(t));return t}function b(e,t,n,r){let i=!1;try{return e.run(t,()=>(i=!0,n()),r)}catch(t){if(i)throw t;if(e.suppressed!==void 0)try{return e.suppressed(()=>(i=!0,n()))}catch(e){if(i)throw e}return n()}}function x(e){function n(t,n=`complete`,r){try{return t()}catch(t){try{e.onError?.(t,{phase:n,reference:r})}catch{}return}}function r(r,i,a,o){let s=u(r.attributes,i)??r.attributes,c=i.emit?n(()=>e.telemetry.startSpan({...r,attributes:s},{reference:o,context:a}),`start`,o):void 0,l=c?.reference??{traceId:`0`.repeat(32),spanId:`0`.repeat(16),traceFlags:0},d=!1;return{reference:l,get capture(){return i},narrow(e){i=t(i,e)},get finished(){return d},setAttribute(e,t){let r=u({[e]:t},i);!d&&(r===void 0||e in r)&&n(()=>c?.setAttribute(e,r===void 0?t:r[e]))},addEvent(e,t,r){d||n(()=>c?.addEvent(e,t===void 0?void 0:u(t,i)??t,r))},fail(e,t){d||n(()=>c?.fail(i.recordOutputs?e:void 0,t??(e instanceof Error?e.name:void 0)))},setStatus(e){d||n(()=>c?.setStatus(e))},end(e){d||(d=!0,n(()=>c?.end(e)))},run(t){return d?t():b(e.telemetry,{type:r.type,reference:l,capture:i},t,a)}}}return{start:r,startReserved:(e,t,n,i)=>r(e,n,i,t)}}const S=32768,C=65536;function w(e,t){function n(n,r){try{let t=Reflect.apply(e[n],e,r);return t===void 0||new TextEncoder().encode(t).length>S?void 0:t}catch(e){try{t?.(e,{phase:`serialize`})}catch{}return}}return{json:e=>n(`json`,[e]),text:e=>n(`text`,[e]),inputMessages:e=>n(`inputMessages`,[e]),instructions:e=>n(`instructions`,[e]),toolDefinitions:e=>n(`toolDefinitions`,[e]),outputMessages:(e,t)=>n(`outputMessages`,[e,t]),toolResults:e=>n(`toolResults`,[e])}}function T(e){return new TextEncoder().encode(JSON.stringify({...e,children:void 0})).length}function ee(e){return JSON.parse(JSON.stringify(e))}function E(e,t=C,n=0){try{if(n>16||typeof e!=`object`||!e)return!1;let r=e;if(r.children!==void 0&&(!Array.isArray(r.children)||r.children.length>1e4||!r.children.every(e=>E(e,t,n+1)))||r.version!==1||r.finished!==void 0&&typeof r.finished!=`boolean`||r.childSequence!==void 0&&(!Number.isSafeInteger(r.childSequence)||r.childSequence<0)||typeof r.key!=`string`||typeof r.startTimeMs!=`number`||!Number.isFinite(r.startTimeMs)||r.reference.traceFlags!==0&&r.reference.traceFlags!==1||r.reference.tracestate!==void 0&&(typeof r.reference.tracestate!=`string`||r.reference.tracestate.length>512)||r.parent!==void 0&&(!/^[a-f0-9]{32}$/u.test(r.parent.traceId)||!/^[a-f0-9]{16}$/u.test(r.parent.spanId))||![r.identity.conversationId,r.identity.runId,r.identity.turnId].every(e=>typeof e==`string`))return!1;let i=r.data.options;return!(!{activation:[],step:[],model:[`provider`,`modelId`],tool:[`callId`,`name`],approval:[`requestId`,`callId`,`toolName`],memory:[`operation`,`phase`,`slot`,`storeId`]}[r.data.type].every(e=>typeof i[e]==`string`)||r.data.type===`activation`&&!Number.isSafeInteger(i.sequence)||r.data.type===`step`&&!Number.isSafeInteger(i.index)||r.data.type===`memory`&&i.operation!==`search_memory`&&i.operation!==`upsert_memory`||!/^[a-f0-9]{32}$/u.test(r.reference.traceId)||!/^[a-f0-9]{16}$/u.test(r.reference.spanId)||typeof r.reference.traceFlags!=`number`||![r.capture.emit,r.capture.recordInputs,r.capture.recordOutputs].every(e=>typeof e==`boolean`)||![`activation`,`step`,`model`,`tool`,`approval`,`memory`].includes(r.data.type)||typeof r.data.options!=`object`||r.data.options===null||T(r)>t)}catch{return!1}}function D(e,t){let n=e.terminal;e={...e,children:e.children?.map(n=>D({...n,capture:{emit:n.capture.emit&&e.capture.emit,recordInputs:n.capture.recordInputs&&e.capture.recordInputs,recordOutputs:n.capture.recordOutputs&&e.capture.recordOutputs}},t))},e={...e,terminal:n===void 0||e.finished?void 0:{...n,errorCode:n.errorCode??(n.error instanceof Error?n.error.name:void 0),error:e.capture.recordOutputs?n.error instanceof Error?{name:n.error.name,message:t.text(n.error.message)}:n.error:void 0,output:e.capture.recordOutputs?n.output:void 0,response:e.capture.recordOutputs?n.response:void 0,records:e.capture.recordInputs?n.records:void 0,model:n.model===void 0?void 0:{...n.model,content:e.capture.recordOutputs?n.model.content:void 0}}},e={...e,attributes:u(e.attributes??{},e.capture)??e.attributes};let r=s(e.data,e.capture),i;try{i=t.json(r)}catch{}let a=()=>{let t=s(r,{emit:e.capture.emit,recordInputs:!1,recordOutputs:!1});return t.type===`step`&&(t={...t,options:{...t.options,runtimeContext:void 0}}),t.type===`model`&&(t={...t,options:{...t.options,runtimeContext:void 0}}),JSON.parse(JSON.stringify({...e,version:1,data:t,terminal:e.terminal===void 0?void 0:{outcome:e.terminal.outcome,failed:e.terminal.failed,errorCode:e.terminal.errorCode,usage:e.terminal.usage},attributes:u(e.attributes??{},{recordInputs:!1,recordOutputs:!1})??e.attributes}))};if(i===void 0||new TextEncoder().encode(i).length>S)return a();try{let t=JSON.parse(JSON.stringify({...e,version:1,data:JSON.parse(i)}));return T(t)<=C?t:a()}catch{return a()}}const O=1e4,k={emit:!1,recordInputs:!1,recordOutputs:!1},te=new Set([`activation`,`tool`,`approval`]),ne=new Set([`tool`,`approval`]);function A(e){return encodeURIComponent(String(e))}function j(e){switch(e.type){case`step`:return`step:${A(e.options.index)}:${A(e.options.attempt??0)}`;case`tool`:return`tool:${A(e.options.callId)}`;case`approval`:return`approval:${A(e.options.requestId)}`;default:return}}function M(e){let t=e.failed||e.outcome===`failed`;return{...e,model:`result`in e?e.result:e.model,failed:t,errorCode:`errorType`in e?e.errorType:e.errorCode}}function N(e){let i=e.telemetry,d=w(e.serializer,e.onError),p=x({telemetry:i,onError:e.onError}),m=(t,n)=>{try{e.onError?.(t,n)}catch{}};function g(t,n,r,a,o){let s=i.ids;if(e.durable&&s!==void 0&&t.type!==`model`&&t.type!==`memory`){if(t.type===`activation`&&r!==void 0)return{traceId:r.traceId,spanId:s.spanId(n),traceFlags:o.emit?r.traceFlags&1:0};if(t.type===`activation`){let e=s.traceId(n);return{traceId:e,spanId:s.spanId(n),traceFlags:o.emit&&(i.samples?.(e,a)??!0)?1:0}}return r===void 0?void 0:{...r,spanId:s.spanId(n),isRemote:!1}}}async function _(e,t,n,r,i,a,o){try{return await v(e,t,n,r,i,a,o)}catch(t){return m(t,{phase:`start`,operation:n.type,reference:a.reference}),v(e,k,s(n,k),r,i,{...a,sample:!1,reference:{traceId:a.reference?.traceId??r?.reference.traceId??a.parent?.traceId??h(16).toString(`hex`),spanId:a.reference?.spanId??h(8).toString(`hex`),traceFlags:0}},o)}}async function v(h,v,y,x,S,C,w){if(C.terminal?.error!==null&&typeof C.terminal?.error==`object`&&!(C.terminal.error instanceof Error)&&`message`in C.terminal.error&&typeof C.terminal.error.message==`string`){let e=Error(C.terminal.error.message);e.name=C.terminal.errorCode??`Error`,C={...C,terminal:{...C.terminal,error:e}}}let T=C.key,E=C.startTimeMs??Date.now(),N=C.parent??x?.reference;v.emit&&(v=t(v,i.active()?.capture));let P=v,F=s(y,P),I=c({identity:h,data:F,attempt:S,capture:P,key:T,parent:N,startTimeMs:E,links:C.links},d);I={...I,attributes:{...I.attributes,...C.attributes}},F=D({key:T,identity:h,data:F,capture:P,reference:C.reference??{traceId:`0`.repeat(32),spanId:`0`.repeat(16),traceFlags:0},startTimeMs:E},d).data;let L=C.deferred??(e.durable&&te.has(F.type)),R=C.executionContext,z=C.reference??g(y,T,N,I,P);C.sample===!0&&z!==void 0&&(z={...z,traceFlags:z.traceFlags&1&&P.emit&&(N!==void 0||(i.samples?.(z.traceId,I)??!0))?1:0});let B=L?void 0:p.start(I,P,R,z),V=z??B?.reference;if(V===void 0)throw Error(`A deferred trace scope requires a reserved reference.`);let H=!!(V.traceFlags&1);P={emit:P.emit&&H,recordInputs:P.emit&&H&&P.recordInputs,recordOutputs:P.emit&&H&&P.recordOutputs},F=s(F,P);let U=C.finished??!1,W=C.terminal,G=new Map,K=new Set,q=C.childSequence??0,J=C.usage,Y=new Set(C.usageKeys??[]),X={},re=F.type===`tool`?F.options.callId:void 0;function Z(){w()}function Q(){return t(P,i.active()?.capture)}async function ie(t,n,r={}){let i=G.get(n);if(e.durable&&i!==void 0&&!i.settled)return i.refine(t,r.startTimeMs),i;if(U)throw Error(`The operation is not permitted in this trace scope.`);for(let[e,t]of G)t.settled&&G.delete(e);let o=P;G.size>=O&&(m(Error(`Trace unfinished-child limit reached.`),{phase:`start`,operation:t.type,reference:V}),o=k),t.type===`model`&&B!==void 0&&a(B,{"agent.model.id":t.options.modelId});let s=await _(h,o,t,$,t.type===`step`?{index:t.options.index,attempt:t.options.attempt??0}:S,{key:n,executionContext:R,links:r.links,startTimeMs:r.startTimeMs},w);return(o.emit||G.size<O)&&G.set(n,s),await w(),s}async function ae(e,t){let n=F.type===`step`||F.type===`activation`;for(let r of G.values())(t||!n||!ne.has(r.type))&&await r.release({failed:e.failed,error:e.error,outcome:`abandoned`})}async function oe(t){if(K.size>0&&await Promise.allSettled(K),U)return;let r=Q();r.recordOutputs||(t={...t,error:void 0}),W?.failed&&(t={...t,outcome:t.outcome===`completed`?`failed`:t.outcome,failed:!0,error:W.error,errorCode:t.errorCode??W.errorCode}),U=!0,W=t,await ae(t,t.failed===!0||!e.durable),B??=p.start(I,P,R,V);let i=F.type===`activation`&&t.usage===void 0?{...t,usage:J}:t;try{n(B,F,i,{...r,emit:P.emit},E,d)}catch(e){m(e,{phase:`complete`,operation:F.type,reference:V})}if(a(B,X),F.type===`model`&&t.model!==void 0){await x?.usage(t.model.usage,T);let e=t.model.content;if(r.recordOutputs&&P.recordOutputs&&e!==void 0){let n=d.outputMessages(e,t.model.finishReason);n!==void 0&&x?.turnContent({output:n})}}B.end(t.endTimeMs),await w()}let $={waitUntil(e){K.add(e),x?.waitUntil(e),e.then(()=>K.delete(e),()=>K.delete(e))},snapshot:()=>ee($.record()),attributes:e=>$.update({attributes:e}),modelCall:(e,t)=>$.child({type:`model`,options:e},t),fail(e){return $.error(e),$.complete({outcome:`failed`,failed:!0})},update(e){if(U)return;let t=u(e.attributes??{},Q())??e.attributes;F.type===`activation`&&(F={...F,options:{...F.options,attributes:{...F.options.attributes,...t}}}),I={...I,attributes:{...I.attributes,...t},links:e.links??I.links},B!==void 0&&a(B,t),Z()},useContext(e){R=e;for(let t of G.values())t.useContext(e)},refine(e,t){if(U||B!==void 0)return;if(t!==void 0&&t<E&&(E=t),e.type===`tool`&&F.type===`tool`){let t=F.options;F=s({type:`tool`,options:{...t,kind:t.kind??e.options.kind,arguments:t.arguments??(Q().recordInputs?e.options.arguments:void 0)}},P)}let n=c({identity:h,data:F,attempt:S,capture:P,key:T,parent:N,startTimeMs:E,links:I.links},d),r=Object.fromEntries(Object.entries(n.attributes).filter(([,e])=>e!==void 0));I={...I,name:n.name,kind:n.kind,startTimeMs:E,attributes:{...I.attributes,...r}},Z()},narrow(e){P={...t(P,e),emit:P.emit},F=s(F,P);let n=u(I.attributes,P)??I.attributes;I={...I,attributes:F.type===`activation`?{...n,"agent.trace.content.input":P.recordInputs,"agent.trace.content.output":P.recordOutputs}:n};let r=u(X,P)??X;for(let e of Object.keys(X))e in r||delete X[e];!P.recordOutputs&&W?.error!==void 0&&(W={...W,error:void 0}),B?.narrow(P);for(let e of G.values())e.narrow(P);Z()},async release(t){U?await ae(t,t.failed===!0||!e.durable):await oe(M(t))},record(){return D({version:1,finished:U,terminal:W,usage:J,usageKeys:[...Y],attributes:{...I.attributes,...X},childSequence:q,children:[...G.values()].filter(e=>!e.settled).map(e=>e.record()),key:T,identity:h,data:F,capture:P,reference:V,parent:N,startTimeMs:E,attempt:S,links:I.links},d)},get parent(){return N},get startTimeMs(){return E},child(t,n,r){if(!o(t).includes(F.type))throw Error(`The operation is not permitted in this trace scope.`);let i=n===void 0?(e.durable?j(t):void 0)??`${t.type}:${q++}`:`${t.type}:${A(n)}`;return ie(t,`${T}/${i}`,r)},find(e){let t=j(e),n=t===void 0?void 0:G.get(`${T}/${t}`);return n===void 0||n.settled?void 0:n},get children(){return[...G.values()].filter(e=>!e.settled)},type:F.type,reference:V,callId:re,get capture(){return P},mcp:l({serializer:d,...P,write(e){let t=u(e,Q())??e;Object.assign(X,t),B!==void 0&&a(B,t)},error(e,t){$.error(e,t)}}),get finished(){return U},get settled(){return U&&[...G.values()].every(e=>e.settled)},run(e,n){if(U)throw Error(`The trace scope has already finished.`);let r=t(t(P,n),i.active()?.capture),a=F.type===`tool`&&(F.options.kind===`subagent-call`||F.options.kind===`remote-agent-call`)?F.options:void 0,o=a===void 0?e:()=>f({caller:V,conversationId:h.conversationId,parentRunId:h.runId,parentCallId:a.callId,agentName:a.name,capture:r},e);return b(i,{type:$.type,reference:V,capture:r,mcp:$.mcp},o,R)},async complete(e=W??{}){U||await oe(M(e))},async usage(e,t){t!==void 0&&Y.has(t)||(t!==void 0&&Y.add(t),B!==void 0&&a(B,r(e)),J={inputTokens:e.inputTokens===void 0?J?.inputTokens:(J?.inputTokens??0)+e.inputTokens,outputTokens:e.outputTokens===void 0?J?.outputTokens:(J?.outputTokens??0)+e.outputTokens,costUsd:e.costUsd===void 0?J?.costUsd:(J?.costUsd??0)+e.costUsd},await x?.usage(e,t))},turnContent(e){if(F.type!==`activation`)return x?.turnContent(e);if(U)return;let t={};e.input!==void 0&&I.attributes[`gen_ai.input.messages`]===void 0&&(t[`gen_ai.input.messages`]=e.input),e.output!==void 0&&(t[`gen_ai.output.messages`]=e.output),Object.keys(t).length>0&&$.update({attributes:t})},error(e,t){W={...W,failed:!0,error:Q().recordOutputs?e:void 0,errorCode:t??(e instanceof Error?e.name:void 0)},B!==void 0&&B.fail(W.error,W.errorCode),Z()}};for(let e of C.children??[])G.set(e.key,await _(e.identity,t(e.capture,P),e.data,$,e.attempt,{...e,deferred:!0,executionContext:R},w));!U&&B!==void 0&&F.type===`step`&&B.addEvent(`step.started`,void 0,E);let se=I.attributes[`gen_ai.input.messages`];return!U&&F.type===`model`&&typeof se==`string`&&x?.turnContent({input:se}),$}return{start(e){return _(e.identity,e.capture,e.data,void 0,void 0,{key:e.key,parent:e.parent,reference:e.reference,sample:e.reference!==void 0&&e.data.type===`activation`,startTimeMs:e.startTimeMs,links:e.links,executionContext:e.context},e.onChange??(()=>Promise.resolve()))},async restore(e,n={}){if(!E(e)){m(Error(`Invalid tracing checkpoint.`),{phase:`restore`});return}return _(e.identity,t(e.capture,n.capture),e.data,void 0,e.attempt,{...e,deferred:!0,executionContext:n.context},n.onChange??(()=>Promise.resolve()))}}}function P(e,t,n){try{e?.(t,{phase:n})}catch{}}function F(e,t={outcome:`completed`},n){async function r(r,i){if(i===void 0)return e(r);let a=await e(r),o=t;try{let e=await a.run(()=>i(a));try{o=r.describe?.(e)??t}catch(e){P(n,e,`complete`)}return e}catch(e){throw o={outcome:`failed`,errorType:e instanceof Error?e.name:`_OTHER`,error:e},e}finally{try{await a.complete(o)}catch(e){P(n,e,`complete`)}}}return r}function I(e,t,n){let r=t=>Object.defineProperties(t,{finished:{get:()=>e.finished},capture:{get:()=>e.capture},parent:{get:()=>e.parent}}),i={type:e.type,reference:e.reference,get startTimeMs(){return e.startTimeMs},get parent(){return e.parent},get finished(){return e.finished},get capture(){return e.capture},run:(t,n)=>e.run(t,n),attributes:t=>e.attributes(t),complete:t=>e.complete(t),fail:t=>e.fail(t),recordError:(t,n)=>e.error(t,n)},a=async(t,r,i)=>I(await e.child(t,r,i),t,n),o=F(async({startTimeMs:e,...t})=>a({type:`tool`,options:t},void 0,{startTimeMs:e}),void 0,n),s=e=>e===void 0?void 0:I(e,e.record().data,n),c=F(async e=>a({type:`memory`,options:e}),void 0,n);if(t.type===`activation`)return r({...i,memory:c,links:t=>e.update({links:t}),findAttempt:t=>s(e.find({type:`step`,options:{index:t.stepIndex,attempt:t.attempt}})),findTool:t=>s(L(e,t)),attempt:F(async e=>a({type:`step`,options:{index:e.stepIndex,attempt:e.attempt,runtimeContext:e.runtimeContext,channel:e.channel}},void 0,{links:e.links}),void 0,n)});if(t.type===`step`){let t=e=>F(async t=>a({type:`tool`,options:{callId:t.callId,name:t.agentName,kind:e}}),void 0,n),s=(e,t)=>a({type:`model`,options:e},t);async function l(e,t){if(typeof t!=`function`)return s(e,t);let r=await s(e),i;try{i=await r.run(t)}catch(e){try{await r.fail(e)}catch(e){P(n,e,`complete`)}throw e}try{await r.complete({outcome:`completed`,result:i})}catch(e){P(n,e,`complete`)}return i.result}return r({...i,memory:c,tool:o,callSubAgent:t(`subagent-call`),callRemoteAgent:t(`remote-agent-call`),modelCall:l,async modelStream(t,r){let i=await s(t);try{let t=await i.run(r),a=Promise.resolve(t.completion).then(e=>i.complete({outcome:`completed`,result:e}),e=>i.fail(e)).catch(e=>P(n,e,`complete`));return e.waitUntil(a),t.result}catch(e){try{await i.fail(e)}catch(e){P(n,e,`complete`)}throw e}}})}return t.type===`tool`?r({...i,memory:c,tool:o,findApproval:n=>s(e.find({type:`approval`,options:{requestId:n,callId:t.options.callId,toolName:t.options.name}})),approval:F(async e=>a({type:`approval`,options:{...e,callId:t.options.callId,toolName:t.options.name}}),{outcome:`ignored`},n)}):i}function L(e,t){for(let n of e.children){if(n.type===`tool`&&n.callId===t)return n;if(n.type===`step`||n.type===`tool`){let e=L(n,t);if(e!==void 0)return e}}}const R={emit:!0,recordInputs:!1,recordOutputs:!1};function z(n){let r=n.telemetry??e(),i=n.checkpointer;if(i!==void 0&&r.ids===void 0)throw Error(`Durable agent tracing needs stable span IDs. Pass the AgentSpanIdGenerator installed on your tracer provider to otelTelemetry({ idGenerator }).`);let a=(e,t)=>{try{n.onError?.(e,t)}catch{}},o=N({telemetry:r,serializer:n.serializer??d,durable:i!==void 0,onError:n.onError}),s=new Map;function c(e){return i===void 0?`turn:${g()}`:[`turn`,e.runId,e.turnId].map(encodeURIComponent).join(`:`)}function l(e,t){let n=Promise.resolve();return()=>{let r=t();return i===void 0||r===void 0?n:(r.writes++,n=n.then(async()=>{try{if(r.root.settled)s.delete(e),await i.delete(e);else{let t=g();await i.set(e,ee({...r.root.record(),revision:t})),r.revision=t}}catch(e){a(e,{phase:`checkpoint`,operation:`activation`})}finally{r.writes--}}),n)}}async function u(e){try{return await i.get(e)}catch(e){a(e,{phase:`restore`,operation:`activation`});return}}async function f(e,t,n,r,a){let s=i===void 0?void 0:await u(e);if(t!==void 0&&(t.writes>0||s?.revision===t.revision))return r!==void 0&&t.root.useContext(r),a!==void 0&&t.root.narrow(a),t;let c,d=l(e,()=>c),f=s===void 0?void 0:await o.restore(s,{capture:a,context:r,onChange:d}),p=f??await n?.(d);if(p!==void 0)return c={root:p,revision:s?.revision,writes:0},f===void 0&&await d(),c}function m(e,t){let n=s.get(e),r=(async()=>t(n===void 0?void 0:await n.catch(()=>void 0)))();return s.set(e,r),r.then(t=>{(t===void 0||t.root.settled)&&s.delete(e)},()=>s.delete(e)),s.size>1e3&&s.delete(s.keys().next().value),r}function h(e,n){return i=>{let a=p(),s=t(e.capture??R,a?.capture),c=a!==void 0&&e.sequence===0,l=e.parent??(c&&a?.remote!==!0?a?.caller:void 0),u=[...c&&a?.remote===!0?[{relationship:`agent.dispatch`,context:a.caller}]:[],...e.links??[]];return o.start({identity:{...e.identity,conversationId:a?.conversationId??e.identity.conversationId,agentName:e.agentName,framework:e.framework},key:n,capture:s,parent:l,reference:r.ids===void 0?void 0:e.reference,startTimeMs:e.startTimeMs,data:{type:`activation`,options:{sequence:e.sequence,attributes:e.attributes,channel:e.channel,subagent:a!==void 0||e.lineage!==void 0,subagentName:a?.agentName??e.lineage?.agentName,parentRunId:a?.parentRunId??e.lineage?.parentRunId,parentCallId:a?.parentCallId??e.lineage?.parentCallId}},links:u.length===0?void 0:u,context:e.context,onChange:i})}}function _(e){return I(e,{type:`activation`,options:{sequence:0}},n.onError)}async function v(e){let t=c(e.identity);return _((i===void 0?await f(t,void 0,h(e,t),e.context):await m(t,n=>f(t,n,h(e,t),e.context,e.capture))).root)}async function y(e){if(i===void 0)return;let t=c(e.identity),n=await m(t,n=>f(t,n,void 0,e.context));return n===void 0?void 0:_(n.root)}async function b(e){try{await e()}catch(e){a(e,{phase:`complete`})}}async function x(e,t,n){let i=r.active(),s=await o.start({identity:t.identity,key:`memory:${g()}`,capture:t.capture??i?.capture??R,parent:t.parent??i?.reference,context:t.context,data:{type:`memory`,options:{operation:e,phase:t.phase,slot:t.slot,storeId:t.storeId}}}),c;try{c=await s.run(n)}catch(e){throw await s.fail(e).catch(e=>a(e,{phase:`complete`})),e}return await s.complete({outcome:`completed`,...t.describe?.(c)}).catch(e=>a(e,{phase:`complete`})),c}return{turn:F(v,void 0,n.onError),resume:y,memory:{search:(e,t)=>x(`search_memory`,e,t),write:(e,t)=>x(`upsert_memory`,e,t)},forceFlush:()=>b(()=>r.forceFlush()),shutdown:()=>b(()=>r.shutdown())}}export{_ as AgentSpanIdGenerator,z as createAgentTracing,i as currentCapture,e as otelTelemetry};

package/dist/src/compiled/@eve/tracing/operations.d.ts

@@ -0,0 +1,96 @@
+import type { LiveOperation } from "./core/scopes.js";
+import type { StepOptions, TraceLink, ScopeData, ScopeTerminal, ModelOptions, ToolOptions, ModelResult, CaptureDecision, Attributes, TraceReference, TraceErrorHandler } from "./core/types.js";
+type Completion = ScopeTerminal & {
+    errorType?: string;
+    result?: ModelResult;
+};
+export interface Operation {
+    readonly type: ScopeData["type"];
+    readonly reference: TraceReference;
+    readonly parent?: TraceReference;
+    readonly startTimeMs: number;
+    readonly finished: boolean;
+    readonly capture: CaptureDecision;
+    run<T>(execute: () => T, ceiling?: CaptureDecision): T;
+    attributes(attributes: Attributes): void;
+    complete(result?: Completion): Promise<void>;
+    fail(error: unknown): Promise<void>;
+    /** Records a failure without ending the operation; completion keeps it. */
+    recordError(error: unknown, errorType?: string): void;
+}
+export interface WrappedOperation<I, H extends Operation> {
+    (input: I): Promise<H>;
+    <T>(input: I & {
+        describe?: (value: T) => Completion;
+    }, execute: (operation: H) => T | PromiseLike<T>): Promise<T>;
+}
+type MemoryInput = Extract<ScopeData, {
+    type: "memory";
+}>["options"];
+export interface AttemptInput {
+    readonly stepIndex: number;
+    readonly attempt: number;
+    readonly runtimeContext?: StepOptions["runtimeContext"];
+    readonly channel?: StepOptions["channel"];
+    readonly links?: readonly TraceLink[];
+}
+export interface TurnOperation extends Operation {
+    attempt: WrappedOperation<AttemptInput, AttemptOperation>;
+    /** Returns an open attempt without starting one. Durable turns only. */
+    findAttempt(input: {
+        stepIndex: number;
+        attempt: number;
+    }): AttemptOperation | undefined;
+    /** Returns an open tool call from any attempt of this turn. Durable turns only. */
+    findTool(callId: string): ToolOperation | undefined;
+    /** Replaces the turn's links before its deferred span is exported. */
+    links(links: readonly TraceLink[]): void;
+    memory: WrappedOperation<MemoryInput, MemoryOperation>;
+}
+/**
+ * One tool call. In a durable turn, calling `tool` again with the same `callId`
+ * returns the same call and fills in details it did not have, such as `kind`,
+ * `arguments`, or an earlier `startTimeMs`.
+ */
+export interface ToolInput extends ToolOptions {
+    readonly startTimeMs?: number;
+}
+export interface AttemptOperation extends Operation {
+    tool: WrappedOperation<ToolInput, ToolOperation>;
+    callSubAgent: WrappedOperation<{
+        callId: string;
+        agentName: string;
+    }, ToolOperation>;
+    callRemoteAgent: WrappedOperation<{
+        callId: string;
+        agentName: string;
+    }, ToolOperation>;
+    modelCall(input: ModelOptions, key?: string): Promise<ModelOperation>;
+    modelCall<T>(input: ModelOptions, execute: () => ModelCallReturn<T> | PromiseLike<ModelCallReturn<T>>): Promise<T>;
+    modelStream<T>(input: ModelOptions, execute: () => ModelStreamReturn<T> | PromiseLike<ModelStreamReturn<T>>): Promise<T>;
+    memory: WrappedOperation<MemoryInput, MemoryOperation>;
+}
+export interface ToolOperation extends Operation {
+    approval: WrappedOperation<{
+        requestId: string;
+        request?: unknown;
+    }, ApprovalOperation>;
+    /** Returns an open approval without starting one. Durable turns only. */
+    findApproval(requestId: string): ApprovalOperation | undefined;
+    /** A tool call made while this tool runs, such as a connector's nested call. */
+    tool: WrappedOperation<ToolInput, ToolOperation>;
+    memory: WrappedOperation<MemoryInput, MemoryOperation>;
+}
+export type ModelOperation = Operation;
+export type ApprovalOperation = Operation;
+export type MemoryOperation = Operation;
+export interface ModelCallReturn<T> extends ModelResult {
+    readonly result: T;
+}
+export interface ModelStreamReturn<T> {
+    readonly result: T;
+    readonly completion: PromiseLike<ModelResult>;
+}
+export declare function wrappedOperation<I, H extends Operation>(start: (input: I) => Promise<H>, fallback?: Completion, onError?: TraceErrorHandler): WrappedOperation<I, H>;
+export declare function operationHandle(runtime: LiveOperation, data: ScopeData, onError?: TraceErrorHandler): TurnOperation | AttemptOperation | ToolOperation | Operation;
+export {};

package/dist/src/compiled/@eve/tracing/otel.d.ts

@@ -0,0 +1,12 @@
+/**
+ * OpenTelemetry plumbing for hosts that run their own spans beside agent
+ * tracing: active-operation lookup, capture context, content bounds, and MCP
+ * enrichment. Agent tracing itself needs only the package root.
+ */
+export { activeTraceOperation, withErrorContent } from "./adapters/otel.js";
+export { withCapture } from "./capture.js";
+export { boundedPrincipalId, contentAttribute, telemetryByteLength, truncateTelemetryText, CONTENT_ATTRIBUTE_LIMIT, } from "./adapters/serialization.js";
+export { withoutDeclinedContent, type ResolvedContentOptions } from "./core/content-policy.js";
+export { mcpLifecycle, type McpLifecycle, type McpUpdate } from "./core/mcp.js";
+export { invocationName } from "./core/span-kinds.js";
+export { USAGE_FIELDS } from "./core/attributes.js";

package/dist/src/compiled/@eve/tracing/otel.js

@@ -0,0 +1 @@
+import{S as e,_ as t,a as n,b as r,c as i,d as a,h as o,p as s,t as c,u as l,x as u,y as d}from"../../_chunks/workflow/mcp-CrGp4EC8.js";export{t as CONTENT_ATTRIBUTE_LIMIT,i as USAGE_FIELDS,a as activeTraceOperation,d as boundedPrincipalId,r as contentAttribute,n as invocationName,c as mcpLifecycle,u as telemetryByteLength,e as truncateTelemetryText,o as withCapture,s as withErrorContent,l as withoutDeclinedContent};

package/dist/src/compiled/@opentelemetry/api/index.d.ts

@@ -31,6 +31,10 @@ export interface Link {
   attributes?: Attributes;
 }
 
+export interface TracerProvider {
+  getTracer(name: string, version?: string): Tracer;
+}
+
 export interface Tracer {
   startSpan(
     name: string,