@cognipeer/agent-sdk 0.16.0 → 0.18.0

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import { ZodError, ZodSchema, z, ZodTypeAny } from 'zod';
 import { JSONSchema7 } from 'json-schema';
-import { P as ProviderType, M as ModelRuleLearnedEvent, E as EmbeddingRequest, a as EmbeddingResponse, C as ChatCompletionRequest, b as ChatCompletionResponse, c as ChatCompletionChunk, J as JevProviderConfig, O as OpenAICompatibleProviderConfig, d as OpenAIProviderConfig, R as RulePatch, U as UnifiedMessage, T as ToolDefinition, e as TokenUsage, A as AnthropicProviderConfig, f as AzureProviderConfig, B as BedrockProviderConfig, V as VertexProviderConfig, g as ReasoningRequestConfig, h as ProviderConfig, i as ProviderError } from './model-rules-Bg9nSqyN.cjs';
-export { a4 as AudioContent, I as EffortMapping, a0 as EmbeddingInputType, $ as EmbeddingUsage, a3 as FileContent, Z as FinishReason, a2 as ImageContent, v as MAX_ADJUSTMENTS, k as MODEL_RULES, W as MaxTokensParam, D as ModelRule, F as ModelRules, Q as OffMechanism, Y as ParsedModelError, _ as ProviderResponseFields, a5 as ProviderToolCall, a6 as ProviderTransportConfig, H as ReasoningEffort, N as ReasoningStyle, G as ResolvedModelRule, K as RuleFamily, L as RuleSource, X as SamplingField, S as TemperatureRule, a1 as TextContent, n as allowsSampling, o as applyDropParams, u as asModelRequestError, z as clearLearnedModelRules, p as effortBudget, j as emptyUsage, x as getLearnedModelRulePatch, w as listLearnedModelRules, m as mapReasoningEffort, q as mergeRulePatch, l as modelIdCandidates, s as parseModelError, y as rememberModelRulePatch, r as resolveModelRule, t as runWithModelAdjustments } from './model-rules-Bg9nSqyN.cjs';
+import { P as ProviderType, M as ModelRuleLearnedEvent, E as EmbeddingRequest, a as EmbeddingResponse, C as ChatCompletionRequest, b as ChatCompletionResponse, c as ChatCompletionChunk, J as JevProviderConfig, O as OpenAICompatibleProviderConfig, d as OpenAIProviderConfig, R as RulePatch, U as UnifiedMessage, T as ToolDefinition, e as TokenUsage, A as AnthropicProviderConfig, f as AzureProviderConfig, B as BedrockProviderConfig, V as VertexProviderConfig, g as ReasoningRequestConfig, h as ProviderConfig, i as ProviderError } from './model-rules--welxWDw.cjs';
+export { a4 as AudioContent, I as EffortMapping, a0 as EmbeddingInputType, $ as EmbeddingUsage, a3 as FileContent, Z as FinishReason, a2 as ImageContent, v as MAX_ADJUSTMENTS, k as MODEL_RULES, W as MaxTokensParam, D as ModelRule, F as ModelRules, Q as OffMechanism, Y as ParsedModelError, _ as ProviderResponseFields, a5 as ProviderToolCall, a6 as ProviderTransportConfig, H as ReasoningEffort, N as ReasoningStyle, G as ResolvedModelRule, K as RuleFamily, L as RuleSource, X as SamplingField, S as TemperatureRule, a1 as TextContent, n as allowsSampling, o as applyDropParams, u as asModelRequestError, z as clearLearnedModelRules, p as effortBudget, j as emptyUsage, x as getLearnedModelRulePatch, w as listLearnedModelRules, m as mapReasoningEffort, q as mergeRulePatch, l as modelIdCandidates, s as parseModelError, y as rememberModelRulePatch, r as resolveModelRule, t as runWithModelAdjustments } from './model-rules--welxWDw.cjs';
 
 /** Describes what a model/provider natively supports. */
 type ModelCapabilities = {
@@ -75,6 +75,7 @@ interface BaseChatMessage {
             arguments: string;
         };
         thoughtSignature?: string;
+        idSynthesized?: boolean;
     }>;
     tool_call_id?: string;
     usage?: any;
@@ -278,6 +279,227 @@ declare function replaceTextContent(content: string | ContentPart[] | unknown, t
 /** Every non-text part of a message, normalized for policy code. */
 declare function collectAttachments(content: string | ContentPart[] | unknown): MediaAttachment[];
 
+/**
+ * Types of the OTLP trace pipeline: the OTLP/JSON wire model the converter
+ * produces, and the public option / result types of the exporter.
+ */
+type OtlpAnyValue = {
+    stringValue?: string;
+    boolValue?: boolean;
+    /** int64 travels as a decimal string in OTLP/JSON. */
+    intValue?: string;
+    doubleValue?: number;
+    arrayValue?: {
+        values: OtlpAnyValue[];
+    };
+    kvlistValue?: {
+        values: OtlpKeyValue[];
+    };
+    /** Base64 in OTLP/JSON. */
+    bytesValue?: string;
+};
+type OtlpKeyValue = {
+    key: string;
+    value: OtlpAnyValue;
+};
+type OtlpSpanEvent = {
+    timeUnixNano: string;
+    name: string;
+    attributes: OtlpKeyValue[];
+};
+type OtlpSpan = {
+    traceId: string;
+    spanId: string;
+    /** Empty string for a root. */
+    parentSpanId: string;
+    traceState?: string;
+    /** W3C trace flags plus the OTLP "has/is remote parent" bits (0x100 / 0x200). */
+    flags: number;
+    name: string;
+    /** 1 INTERNAL, 2 SERVER, 3 CLIENT. */
+    kind: number;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes: OtlpKeyValue[];
+    events?: OtlpSpanEvent[];
+    status: {
+        code: number;
+        message?: string;
+    };
+};
+type OtlpExportTraceServiceRequest = {
+    resourceSpans: Array<{
+        resource: {
+            attributes: OtlpKeyValue[];
+        };
+        scopeSpans: Array<{
+            scope: {
+                name: string;
+                version: string;
+            };
+            spans: OtlpSpan[];
+        }>;
+        schemaUrl?: string;
+    }>;
+};
+/**
+ * Which attribute vocabulary the spans carry. `cognipeer` is the SDK's own
+ * `cognipeer.*` keys, `gen_ai` the OpenTelemetry GenAI semantic conventions,
+ * `both` (the default) emits the two side by side.
+ */
+type OtlpSemconv = "cognipeer" | "gen_ai" | "both";
+type OtlpProtocol = "http/json" | "http/protobuf";
+type OtlpRetryOptions = {
+    /** Attempts in total, the first included. Default 3. */
+    maxAttempts?: number;
+    /** First back-off ceiling. Default 250 ms. */
+    initialDelayMs?: number;
+    /** Back-off ceiling, also the cap on a server's Retry-After. Default 4000 ms. */
+    maxDelayMs?: number;
+    /** Budget for the whole export, attempts and waits included. Default 25000 ms. */
+    maxElapsedMs?: number;
+};
+type OtlpExportOptions = {
+    /**
+     * Full traces endpoint (e.g. `https://collector:4318/v1/traces`). Leave it out
+     * to configure the exporter from the standard `OTEL_EXPORTER_OTLP_*`
+     * environment variables.
+     */
+    endpoint?: string;
+    headers?: Record<string, string>;
+    /** Default `http/json` with an explicit endpoint, `http/protobuf` in env-driven mode. */
+    protocol?: OtlpProtocol;
+    /** Default `none`. */
+    compression?: "gzip" | "none";
+    /** Per attempt. Default 10000 ms. */
+    timeoutMs?: number;
+    /** `false` sends once. */
+    retry?: false | OtlpRetryOptions;
+    /** Default `both`. */
+    semconv?: OtlpSemconv;
+    /** `service.name` on the resource. */
+    serviceName?: string;
+    resourceAttributes?: Record<string, string>;
+    /**
+     * Prompt, response, tool-definition and tool argument/result content on the
+     * spans (`gen_ai.input.messages` and friends). OFF by default and independent
+     * of `tracing.logData`. `true` turns it on with the defaults.
+     */
+    content?: boolean | OtlpContentOptions;
+    /** Injectable for tests; defaults to `globalThis.fetch`, read at export time. */
+    fetch?: (input: string, init?: any) => Promise<any>;
+};
+/** What a span's content attributes are made of; `include` picks from this list. */
+type OtlpContentField = "system" | "input" | "output" | "tools" | "toolArgs" | "toolResults" | "sections";
+type OtlpContentRedactInfo = {
+    field: OtlpContentField;
+    eventType: string;
+    spanId?: string;
+    toolName?: string;
+    model?: string;
+};
+type OtlpContentOptions = {
+    /** Default false. */
+    enabled?: boolean;
+    /** Default: every field. */
+    include?: OtlpContentField[];
+    /** Longer text is cut and marked `...[truncated N chars]`. Default 4096. */
+    maxStringChars?: number;
+    /** A message list keeps its most recent messages. Default 32. */
+    maxMessages?: number;
+    /**
+     * An attribute whose JSON exceeds this is made smaller by dropping whole
+     * messages (oldest first) or, failing that, replaced by `{"truncated":true}`.
+     * JSON is never cut in the middle. Default 32768.
+     */
+    maxAttributeBytes?: number;
+    /**
+     * Runs on each captured field BEFORE the caps apply. Return the (possibly
+     * masked) value, or `null` / `undefined` to leave the field out. A throw
+     * leaves it out too (fail closed). It gets a private copy: mutating it does
+     * not change the trace the file and other sinks hold.
+     */
+    redact?: (value: unknown, info: OtlpContentRedactInfo) => unknown;
+    /** `json` (default): a JSON string. `structured`: OTLP AnyValue arrays and maps. */
+    encoding?: "json" | "structured";
+};
+/** Content options with every default filled in. */
+type ResolvedOtlpContent = Required<Omit<OtlpContentOptions, "redact">> & {
+    redact?: OtlpContentOptions["redact"];
+};
+/** A W3C parent of the root span: where the trace came from. */
+type TraceParent = {
+    traceId: string;
+    spanId: string;
+    /** The incoming trace-flags byte, carried unchanged (bit 0 is `sampled`). */
+    flags: number;
+    sampled: boolean;
+    /** True when the parent lives in another process (the usual case for a traceparent). */
+    remote: boolean;
+    traceState?: string;
+};
+/** A `traceparent` header value, or the pair of W3C headers. */
+type TraceParentInput = string | {
+    traceparent: string;
+    tracestate?: string;
+};
+type OtlpConvertOptions = {
+    semconv: OtlpSemconv;
+    serviceName?: string;
+    resourceAttributes?: Record<string, string>;
+    /** True when this file ends the session: only then is the root span exported. */
+    terminal: boolean;
+    /** The run was cancelled: the root reports `partial`. */
+    cancelled?: boolean;
+    parent?: Pick<TraceParent, "spanId" | "remote" | "traceState"> & {
+        flags?: number;
+        sampled?: boolean;
+    };
+    /** Content capture; absent or disabled means none leaves the process. */
+    content?: ResolvedOtlpContent;
+};
+type OtlpExportResult = {
+    ok: boolean;
+    attempts: number;
+    status?: number;
+    /** Spans in the request (0 when the export was skipped). */
+    spans: number;
+    /** Size of the body that was sent. */
+    bytes: number;
+    error?: string;
+    /** True when nothing was sent: no spans, or exporting is disabled by the environment. */
+    skipped?: boolean;
+    reason?: string;
+    partialSuccess?: {
+        rejectedSpans: number;
+        message?: string;
+    };
+};
+type OtlpExporter = {
+    name: string;
+    endpoint: string;
+    semconv: OtlpSemconv;
+    protocol: OtlpProtocol;
+    /** True when this exporter asks for prompt/response content to be captured. */
+    wantsContent: boolean;
+    /** The content options behind `wantsContent`, defaults filled in. */
+    contentOptions?: ResolvedOtlpContent;
+    exportSession(file: TraceSessionFile, options: {
+        terminal: boolean;
+        cancelled?: boolean;
+        parent?: OtlpConvertOptions["parent"];
+    }): Promise<OtlpExportResult>;
+};
+/** What one exporter did when a session was finalized. */
+type OtlpExportReport = {
+    exporter: string;
+    endpoint: string;
+    /** True for the exporter derived from `tracing.sink`, false for a plugin's. */
+    sink: boolean;
+    terminal: boolean;
+    result: OtlpExportResult;
+};
+
 /**
  * Plugin layer — type surface.
  *
@@ -768,6 +990,13 @@ type AgentPlugin = {
     tools?: ToolInterface[] | ((ctx: PluginSetupContext) => MaybePromise<ToolInterface[]>);
     systemPrompt?: string | ((current: string, ctx: PluginSetupContext) => string);
     toolDescriptions?: Record<string, string | ((defaultDescription: string) => string)>;
+    /**
+     * OTLP exporters the SDK runs when a trace session is finalized, next to the
+     * `otlp` sink. This is how a plugin ships traces to a collector without a
+     * hook of its own: the SDK knows which leg ends the run, the plugin does not.
+     * Requires `tracing: { enabled: true }`.
+     */
+    traceExporters?: OtlpExporter[];
     wrapModel?: (model: unknown, ctx: PluginSetupContext) => unknown;
     provides?: PluginProvides;
     /** Bridge for v1 guardrails carried inside a plugin. */
@@ -779,6 +1008,8 @@ type AgentPlugin = {
 type PluginContributions = {
     tools: ToolInterface[];
     toolDescriptions: Record<string, string | ((defaultDescription: string) => string)>;
+    /** Trace exporters contributed by plugins, in plugin priority order. */
+    traceExporters: OtlpExporter[];
     guardrails: ConversationGuardrail[];
     /** Applied in priority order, before any legacy `promptHooks.transformSystemPrompt`. */
     applySystemPrompt: (base: string) => string;
@@ -1063,6 +1294,20 @@ type SubagentPendingRecord = {
     /** Maps the child's pending approval/question id -> parent-surfaced id. */
     pendingKind: "approval" | "user_question";
     pendingId: string;
+    /** The run's id on `subagent` events and in its trace; the resumed run keeps it. */
+    spawnId?: string;
+    /** Iterations the child had opened when it paused; the resumed run numbers on from there. */
+    iterations?: number;
+    /**
+     * The run's agent span id in the trace. Every segment of the run (the first,
+     * and each resume) records under this one id, so the trace shows one group.
+     * Absent on a record written by 0.17.0: its resume gets a fresh id.
+     */
+    agentSpanId?: string;
+    /** Epoch ms the run's first segment started; the span reports the run from here. */
+    startedAt?: number;
+    /** Segments run so far: 1 once it has paused for the first time. */
+    segments?: number;
 };
 type SubagentToolNames = {
     delegate: string;
@@ -1356,11 +1601,14 @@ type TraceSinkHttpConfig = {
     url: string;
     headers?: Record<string, string>;
 };
+/**
+ * OTLP/HTTP trace export. `endpoint` is the full traces URL; leave it out to
+ * configure the exporter from the standard `OTEL_EXPORTER_OTLP_*` environment
+ * variables (see the OpenTelemetry guide).
+ */
 type TraceSinkOtlpConfig = {
     type: "otlp";
-    endpoint: string;
-    headers?: Record<string, string>;
-};
+} & OtlpExportOptions;
 type TracingMode = "batched" | "streaming";
 type TraceSinkConfig = TraceSinkFileConfig | TraceSinkCustomConfig | TraceSinkCognipeerConfig | TraceSinkHttpConfig | TraceSinkOtlpConfig;
 type TracingConfig = {
@@ -1387,6 +1635,15 @@ type TracingConfig = {
      * attribution/reporting; not interpreted by the SDK itself.
      */
     metadata?: Record<string, string>;
+    /**
+     * W3C trace context of the caller (a `traceparent` header value, or
+     * `{ traceparent, tracestate }`): the exported root span becomes a child of
+     * that span and joins its trace. A static value for every run of this agent;
+     * `InvokeConfig.traceParent` sets it per request and wins. An upstream
+     * `sampled=0` flag suppresses the OTLP export only (file, cognipeer, http and
+     * custom sinks still record). Invalid values are ignored with one warning.
+     */
+    parent?: TraceParentInput;
 };
 type SmartAgentTracingConfig = TracingConfig;
 type AgentOptions = {
@@ -2015,6 +2272,12 @@ type TraceMetadataSection = {
     kind: "metadata";
     label: string;
     data: Record<string, any>;
+    /**
+     * Set on the sections a caller records with `alwaysSections`: ids, status and
+     * timestamps that stay when `logData` is off and that an OTLP export carries
+     * whether or not content capture is on. Never prompt text or arguments.
+     */
+    identity?: boolean;
 };
 /** One tool of the menu offered to the model on a single call. */
 type TraceToolDefinition = {
@@ -2088,6 +2351,10 @@ type TraceEventRecord = {
      * `pending`: a step that is waiting on someone outside the run — a tool
      * approval or a question to the user that was asked when the run paused.
      * The answer is recorded as a separate event when the run resumes.
+     * A sub-agent's span (type span, actor.role subagent) is also pending while its
+     * run waits; the segment that ends the run records it again under the SAME
+     * spanId, finished. Draw one record per spanId: the highest sequence, dropping
+     * earlier pending ones (foldSupersededSpans).
      */
     status: "success" | "error" | "skipped" | "retry" | "pending";
     durationMs?: number;
@@ -2114,12 +2381,45 @@ type TraceEventRecord = {
     responseBytes?: number;
     model?: string;
     provider?: string;
+    /** The provider's response id (`ai_call`). */
+    responseId?: string;
+    /** The model that actually answered, which may differ from the one requested (`ai_call`). */
+    responseModel?: string;
+    /** The provider's own stop reason (`end_turn`, `STOP`, `tool_calls`), before normalisation (`ai_call`). */
+    rawFinishReason?: string;
+    /** Tokens written to the provider's prompt cache (`ai_call`, `summarization`). */
+    cacheWriteTokens?: number;
+    /**
+     * How the provider counts: whether `inputTokens` leaves the cache read/write
+     * tokens out (Anthropic, Bedrock) and whether `outputTokens` leaves the
+     * reasoning tokens out (Vertex). Exporters use it to report totals the way
+     * the OpenTelemetry GenAI conventions define them.
+     */
+    usageBasis?: {
+        inputExcludesCache?: boolean;
+        outputExcludesReasoning?: boolean;
+    };
+    /** True when the model call was streamed (`ai_call`). */
+    streaming?: boolean;
+    /** `json` when the call asked for structured output, else `text` (`ai_call`). */
+    outputType?: "text" | "json";
+    /** The id the PROVIDER gave this tool call (`tool_call`); absent for ids the SDK made up. */
+    toolCallId?: string;
+    /**
+     * Why a call that never ran is recorded: `blocked` (a plugin refused the model
+     * call), `short_circuit` (a plugin or cache answered), `denied` (a policy
+     * refused the tool), `skipped` (a limit or circuit breaker), `cancelled` (the
+     * caller stopped the run).
+     */
+    skipReason?: "blocked" | "short_circuit" | "denied" | "skipped" | "cancelled";
     toolDetails?: TraceToolDetails;
     toolExecutionId?: string;
     retryOf?: string;
+    /** `type` is the error's class name (`RateLimitError`) when it has one. */
     error?: {
         message: string;
         stack?: string;
+        type?: string;
     } | null;
     data?: {
         sections: TraceDataSection[];
@@ -2131,6 +2431,8 @@ type TraceErrorRecord = {
     message: string;
     stack?: string;
     type?: string;
+    /** Class name of the error behind a session-level failure. */
+    errorName?: string;
     timestamp?: string;
 };
 type TraceSessionSummary = {
@@ -2141,6 +2443,12 @@ type TraceSessionSummary = {
     totalBytesIn: number;
     totalBytesOut: number;
     eventCounts: Record<string, number>;
+    /**
+     * Iterations run by sub-agents recording into this session. They count in
+     * `eventCounts.agent_iteration` too; the root agent subtracts them to number
+     * its own iterations.
+     */
+    subagentIterations?: number;
 };
 /**
  * `paused`: the run stopped to wait for a tool approval or an answer from the
@@ -2171,6 +2479,23 @@ type TraceContinuation = {
     /** Totals so far — a continued session reports cumulative totals. */
     summary: TraceSessionSummary;
     errors: TraceErrorRecord[];
+    /**
+     * The remote parent of the root span (`TracingConfig.parent` /
+     * `InvokeConfig.traceParent`), kept so a later leg exports under the same
+     * parent without the caller passing it again. Plain data: no credentials.
+     */
+    parent?: {
+        spanId: string;
+        flags: number;
+        traceState?: string;
+    };
+    /**
+     * Sub-agent spans recorded `pending` that no later record has finished, with
+     * their identity sections only. The OTLP export withholds a pending span until
+     * the run ends; if the run is abandoned instead (`closeTraceContinuation`) the
+     * closing export writes them, so the spans of the earlier legs keep a parent.
+     */
+    pendingSpans?: TraceEventRecord[];
 };
 type TraceSinkSnapshot = {
     type: "file";
@@ -2244,6 +2569,7 @@ type ResolvedTraceSink = {
     type: "otlp";
     endpoint: string;
     headers?: Record<string, string>;
+    exporter: OtlpExporter;
 };
 type ResolvedTraceConfig = {
     enabled: boolean;
@@ -2278,6 +2604,11 @@ type TraceSessionRuntime = {
     sequenceOffset?: number;
     /** 1-based part number; 1 for a session that starts with this invoke. */
     part?: number;
+    /**
+     * Pending sub-agent spans earlier parts recorded (see `TraceContinuation.pendingSpans`).
+     * Not in `events`: only the OTLP export reads them.
+     */
+    carriedSpans?: TraceEventRecord[];
     /**
      * Set once the session has been handed to its sink. A closed session takes no
      * more events: they would never be delivered (and, on a session continued by
@@ -2286,6 +2617,26 @@ type TraceSessionRuntime = {
     closed?: boolean;
     fileBaseDir?: string;
     fileSessionDir?: string;
+    /**
+     * Exporters contributed by plugins (`AgentPlugin.traceExporters`), run next to
+     * the `otlp` sink when the session is finalized.
+     */
+    exporters?: OtlpExporter[];
+    /** What each exporter did when the session was finalized, in run order. */
+    exportReports?: OtlpExportReport[];
+    /** Where the trace came from, when this run is part of a larger trace. */
+    parent?: TraceParent;
+    /**
+     * True when some OTLP exporter asked for prompt/response content. Only then
+     * does `recordTraceEvent` build the content it holds on the record's
+     * non-enumerable side channel. Runtime only.
+     */
+    captureContent?: boolean;
+    /** What `recordTraceEvent` keeps of captured content: the widest message cap among the exporters that want it, and their string cap with headroom. */
+    captureLimits?: {
+        maxStringChars: number;
+        maxMessages: number;
+    };
 };
 type HandoffDescriptor<TParsed = any> = {
     type: "handoff";
@@ -2786,6 +3137,13 @@ type InvokeConfig = RunnableConfig & {
     limits?: Partial<AgentLimits>;
     onStateChange?: (state: SmartState) => boolean;
     checkpointReason?: string;
+    /**
+     * W3C trace context of the request that started this run (a `traceparent`
+     * header value, or `{ traceparent, tracestate }`). The exported root span is
+     * made a child of it. Wins over `TracingConfig.parent`; a run that continues a
+     * paused trace keeps the parent it started with.
+     */
+    traceParent?: TraceParentInput;
     /**
      * Keys of `skills` to open deterministically at the start of this invoke,
      * before the first model call. Each one is opened through the real
@@ -2893,6 +3251,24 @@ type ToolCallContext = {
     toolCallId?: string;
     cancellationToken?: any;
     signal?: AbortSignal;
+    /**
+     * Span id the tools node will give this call's `tool_call` trace event. Known
+     * before the tool runs so that whatever it records (a sub-agent's spans) can
+     * nest under it. Absent when the run is not traced.
+     */
+    traceSpanId?: string;
+    /**
+     * Trace id of the run this call belongs to. With `traceSpanId` it is what a
+     * downstream call (an HTTP request, an MCP `_meta`) needs to join the trace:
+     * `traceparentOf(ctx)` builds the `traceparent` header. Absent when the run is
+     * not traced.
+     */
+    traceId?: string;
+    /**
+     * The W3C trace-flags byte of an incoming `traceparent`, when the run has one;
+     * `traceparentOf` passes it on unchanged. Absent means sampled (`01`).
+     */
+    traceFlags?: number;
 };
 type SmartToolFn = (args: any, context?: ToolCallContext) => Promise<any> | any;
 type ToolCachePolicy = {
@@ -4944,39 +5320,35 @@ declare function defaultBuildPayload(events: LangfuseEvent[], ctx: LangfuseBuild
 declare function langfuseTracing(config?: LangfuseTracingConfig): AgentPlugin;
 
 /**
- * OTLP/HTTP export of a finished run, driven by a hook instead of by a sink.
+ * OTLP export of a run to a collector, declared next to the other plugins.
  *
- * The SDK already ships `otlpSink(endpoint, headers)`, and when observability
- * is configured on its own that remains the right tool — it is wired straight
- * into `finalizeTraceSession` and needs no plugin at all. This plugin exists
- * for the product that wants one array: `plugins: [cognipeerGuardrail(),
- * otelTracing({ endpoint })]`, with tracing and policy declared side by side
- * rather than in two unrelated config blocks.
+ * `plugins: [cognipeerGuardrail(), otelTracing({ endpoint })]` keeps tracing and
+ * policy in one array instead of two unrelated config blocks. The plugin does
+ * not build or send anything itself: it contributes an exporter
+ * (`AgentPlugin.traceExporters`) and the SDK runs it inside
+ * `finalizeTraceSession`, the same path the `otlpSink` uses. That is what makes
+ * the output identical to the sink's: the SDK knows which leg ends the run (the
+ * root span goes out once, with that leg), the plugin never has to.
  *
- * It does NOT re-implement the sink. The conversion is `traceSessionToOtlp`,
- * the same function `otlpSink` uses, applied to the same session object — so a
- * span tree exported through this plugin and one exported through the sink are
- * the same spans. What the plugin adds is placement: it runs on the hook chain,
- * next to the guardrails, and can therefore be turned on and off with them.
+ * The `sessionEnd` observer only reports. It reads what the exporter did for
+ * this run and surfaces it (a `metadata` event, a warning on failure). It also
+ * says so out loud when there is no trace session at all: a silent no-op in an
+ * observability tool is discovered days later, when someone goes looking for
+ * the traces, so `tracing: { enabled: true }` is called out by name.
  *
- * Because it reads the SDK's trace session, it needs `tracing: { enabled: true }`
- * on the agent. Without it there is no session to export and the plugin says so
- * out loud (a `metadata` event plus a warning) rather than doing nothing: a
- * silent no-op in an observability tool is the failure that costs the most,
- * because it is discovered days later when someone goes looking for the traces.
+ * A sub-agent inherits this plugin but records into its parent's session, which
+ * is still being written. Only a root session finalizes and exports, so the
+ * observer returns early for a child run.
  */
 
-type OtelTracingConfig = {
-    /** OTLP/HTTP JSON traces endpoint, e.g. `https://collector.example.com/v1/traces`. */
-    endpoint: string;
-    /** Auth and tenancy headers for the collector. */
-    headers?: Record<string, string>;
-    /** `service.name` on the exported resource. Defaults to the agent's name. */
-    serviceName?: string;
-    /** Plugin name, when exporting to more than one collector at once. */
+type OtelTracingConfig = OtlpExportOptions & {
+    /**
+     * Plugin name, when exporting to more than one collector at once. Defaults to
+     * `otel-tracing`.
+     */
     name?: string;
 };
-declare function otelTracing(config: OtelTracingConfig): AgentPlugin;
+declare function otelTracing(config?: OtelTracingConfig): AgentPlugin;
 
 /**
  * Webhook-backed human-in-the-loop transport for the `approvalTransport` slot.
@@ -5525,6 +5897,41 @@ declare function prepareStrictToolMenu<T extends object>(tools: T[]): {
     restorers: StrictRestorers;
 };
 
+/**
+ * Prompt / response content for GenAI spans (`gen_ai.input.messages`,
+ * `gen_ai.output.messages`, `gen_ai.system_instructions`, `gen_ai.tool.definitions`,
+ * `gen_ai.tool.call.arguments`, `gen_ai.tool.call.result`).
+ *
+ * Content is OFF unless an exporter asks for it, and it is two steps:
+ *
+ * 1. At RECORD time (`buildCapturedContent`, called by `recordTraceEvent` only when
+ *    some exporter wants content): the messages, response, tool menu and tool
+ *    arguments / result are copied into a plain, bounded structure. A copy, because
+ *    the transcript is mutated and rewritten after the call; reasoning parts and
+ *    binary payloads never make it in. It rides on the record under a
+ *    NON-ENUMERABLE symbol key, so the file sink, the custom sink's JSON clones,
+ *    the cognipeer / http sinks and anything persisted never see it.
+ * 2. At EXPORT time (`contentAttributes`): per exporter, the redact hook runs
+ *    first, then the caps (whole messages are dropped, oldest first; JSON is never
+ *    cut in the middle), then the encoding.
+ */
+
+type CaptureSource = {
+    /** The messages as they went to the provider. */
+    input?: unknown[];
+    /** The provider's answer. */
+    output?: unknown;
+    toolDefinitions?: Array<{
+        name: string;
+        description?: string;
+        parameters?: unknown;
+    }>;
+    toolArguments?: unknown;
+    /** Set (even to undefined) only when the tool completed. */
+    toolResult?: unknown;
+    hasToolResult?: boolean;
+};
+
 declare function fileSink(path?: string): TraceSinkConfig;
 type CustomSinkArg = ((event: TraceEventRecord) => void | Promise<void>) | {
     onEvent?: (event: TraceEventRecord) => void | Promise<void>;
@@ -5535,16 +5942,28 @@ declare function cognipeerSink(apiKey: string): TraceSinkConfig;
 declare function cognipeerSink(url: string | undefined, apiKey: string): TraceSinkConfig;
 declare function httpSink(url: string, headers?: Record<string, string>): TraceSinkConfig;
 /**
- * Create an OTLP/HTTP JSON sink that exports traces in OpenTelemetry format.
- * @param endpoint OTLP endpoint URL (e.g. "https://console.cognipeer.com/api/client/v1/traces")
+ * Create an OTLP/HTTP sink that exports traces in OpenTelemetry format (JSON or
+ * protobuf; GenAI and `cognipeer.*` attributes side by side by default).
+ * @param endpoint OTLP traces endpoint (e.g. "https://console.cognipeer.com/api/client/v1/traces").
+ *   Leave it out to configure the exporter from the standard `OTEL_EXPORTER_OTLP_*` environment variables.
  * @param headers Optional headers (e.g. { Authorization: "Bearer ..." })
+ * @param options Protocol, compression, timeout, retry, semconv, service name.
  */
-declare function otlpSink(endpoint: string, headers?: Record<string, string>): TraceSinkConfig;
+declare function otlpSink(endpoint?: string, headers?: Record<string, string>, options?: Omit<OtlpExportOptions, "endpoint" | "headers">): TraceSinkConfig;
+declare function otlpSink(options: OtlpExportOptions): TraceSinkConfig;
 /**
- * Convert a complete TraceSessionFile into an OTLP ExportTraceServiceRequest (JSON).
- * Produces a root span for the session and child spans for each event.
+ * Convert a TraceSessionFile into an OTLP ExportTraceServiceRequest (JSON model).
+ * The root span is part of it only when the file ends the session: a `paused` or
+ * `in_progress` file holds one leg of a longer run and yields its own spans only.
  */
-declare function traceSessionToOtlp(session: TraceSessionFile): Record<string, unknown>;
+declare function traceSessionToOtlp(session: TraceSessionFile, options?: Partial<Omit<OtlpConvertOptions, "content">> & {
+    /**
+     * As on `otlpSink`: off unless given. A stored file holds the payload sections
+     * (prompts, replies, tool arguments and results); they are in `cognipeer.sections`
+     * only when this is on, through its `redact` and caps.
+     */
+    content?: boolean | OtlpContentOptions;
+}): OtlpExportTraceServiceRequest;
 /** Generate a W3C-compatible trace ID (32 hex chars / 128-bit). */
 declare function generateTraceId(): string;
 /** Generate an OTel span ID (16 hex chars / 64-bit). */
@@ -5595,7 +6014,11 @@ declare function recordTraceEvent(session: TraceSessionRuntime | undefined, even
     status?: TraceEventRecord["status"];
     /** Explicit parent span ID. Falls back to session.currentIterationSpanId when omitted. */
     parentSpanId?: string;
+    /** Pre-allocated span ID, for an event whose children are recorded before it is. */
+    spanId?: string;
     durationMs?: number;
+    /** False for a span that wraps events already counted, so the totals do not take the time twice. */
+    countDuration?: boolean;
     inputTokens?: number;
     outputTokens?: number;
     totalTokens?: number;
@@ -5608,16 +6031,37 @@ declare function recordTraceEvent(session: TraceSessionRuntime | undefined, even
     responseBytes?: number;
     model?: string;
     provider?: string;
+    /** What the provider said about the response; see TraceEventRecord. Left out when unknown. */
+    responseId?: string;
+    responseModel?: string;
+    rawFinishReason?: string;
+    cacheWriteTokens?: number;
+    usageBasis?: TraceEventRecord["usageBasis"];
+    streaming?: boolean;
+    outputType?: TraceEventRecord["outputType"];
+    /** The id the PROVIDER gave a tool call; never one the SDK made up. */
+    toolCallId?: string;
+    skipReason?: TraceEventRecord["skipReason"];
     toolDetails?: TraceEventRecord["toolDetails"];
     toolExecutionId?: string;
     retryOf?: string;
     error?: {
         message: string;
         stack?: string;
+        type?: string;
     } | null;
+    /**
+     * Content for exporters that ask for it (OTLP `content`), copied into a
+     * non-enumerable side channel on the record at once: later changes to the
+     * transcript cannot reach it, and no sink but those exporters ever sees it.
+     * Ignored unless some exporter wants content.
+     */
+    capture?: CaptureSource;
     messageList?: any[];
     /** Pre-built sections to use instead of auto-converting messageList */
     sections?: TraceDataSection[];
+    /** Identity sections kept even when logData is off; the caller vouches they carry no payload. */
+    alwaysSections?: TraceDataSection[];
     /**
      * Tool MENU bound to this model call (`ai_call` events). Appended as a
      * `tool_definitions` section AFTER messageList/sections resolution, so it
@@ -5649,6 +6093,26 @@ type DeferredTraceEvent = Parameters<typeof recordTraceEvent>[1];
  * to the sink, and the next leg has not opened one yet.
  */
 declare function isTraceSessionOpen(session: TraceSessionRuntime | undefined): session is TraceSessionRuntime;
+/**
+ * The records a reader should draw. A sub-agent that pauses for a human (an
+ * approval or a question) and later resumes is ONE run recorded in several
+ * segments, and records are append-only: each pause records the run's agent span
+ * `pending`, and the segment that ends the run records it again under the SAME
+ * `spanId`, finished, with `durationMs` covering the run from its first segment
+ * (so the span is drawn over its children from every segment, the wait included). The rule for a
+ * reader: for each `spanId` the record with the highest `sequence` wins, and an
+ * earlier record of that id is dropped only when it is `pending`. Nothing else is
+ * ever dropped, so a repeated id on records that are not `pending` comes back
+ * untouched. Order is preserved.
+ *
+ * The session summary is not rewritten: `eventCounts` keeps counting every record
+ * that was written, which is what the file holds.
+ */
+declare function foldSupersededSpans<T extends {
+    spanId?: string;
+    sequence?: number;
+    status?: string;
+}>(events: readonly T[]): T[];
 /**
  * Records `event` into the open session on `ctx`, or — when there is none —
  * returns a copy of `ctx` holding it for the next invoke to record. Returns
@@ -5664,6 +6128,100 @@ declare function recordOrDeferTraceEvent(ctx: Record<string, any> | undefined, e
  * previous leg recorded, before anything this one does.
  */
 declare function replayDeferredTraceEvents(session: TraceSessionRuntime | undefined, deferred: unknown): void;
+/**
+ * Closes the trace of a run whose last leg paused (or bounced for summarization)
+ * and will not be resumed: the root span, held back until a leg ends the
+ * session, is exported now. Only the OTLP exporters are called (the `otlp` sink
+ * from `tracing`, and `exporters`); the file, cognipeer, http and custom sinks
+ * already have everything this session recorded.
+ *
+ * `events` are trace events that were held for a next leg that never came
+ * (see `recordOrDeferTraceEvent`); they are recorded before the close.
+ * Returns undefined when `continuation` is not one, or nothing would export it.
+ */
+declare function closeTraceContinuation(continuation: unknown, params?: {
+    tracing?: SmartAgentTracingConfig;
+    exporters?: OtlpExporter[];
+    /** How the run ended. Default `partial`: it stopped before an answer. */
+    status?: "success" | "partial" | "error";
+    error?: {
+        message?: string;
+        stack?: string;
+        name?: string;
+    } | null;
+    agentRuntime?: AgentRuntimeConfig;
+    events?: unknown;
+}): Promise<TraceSessionFile | undefined>;
+
+/**
+ * The OTLP/HTTP exporter: converts a trace session file, encodes it (JSON or
+ * protobuf), optionally gzips it and POSTs it, with bounded retries.
+ *
+ * It never throws: a failure comes back as `{ ok: false, error }` and the caller
+ * decides what that means (a sink marks the session partial, a plugin warns).
+ * Retries follow the OTLP specification: 429, 502, 503, 504 and transport errors
+ * or timeouts are retried with full-jitter exponential back-off (a server's
+ * Retry-After wins); every other status is final, 404 and 500 included.
+ *
+ * `globalThis.fetch` is read when an export runs, not when the module loads or
+ * the exporter is created, and the response is treated as the minimum a fetch
+ * mock may offer (`ok`, `status`, `statusText`, `text`, `headers.get`).
+ */
+
+declare function createOtlpExporter(options?: OtlpExportOptions & {
+    name?: string;
+}): OtlpExporter;
+
+/**
+ * W3C Trace Context helpers: reading the `traceparent` / `tracestate` a caller
+ * passes in, and writing one for a downstream call (an HTTP request, an MCP
+ * `_meta`) a tool makes from inside a traced run.
+ */
+
+type ParsedTraceparent = {
+    traceId: string;
+    spanId: string;
+    /** The trace-flags byte, unchanged. */
+    flags: number;
+    sampled: boolean;
+};
+/**
+ * Reads a `traceparent` header. Returns undefined for anything the W3C
+ * specification calls invalid: upper case, wrong lengths, version `ff`,
+ * all-zero ids, extra fields on version 00.
+ */
+declare function parseTraceparent(header: unknown): ParsedTraceparent | undefined;
+/**
+ * Writes a version 00 `traceparent`. `flags` is the trace-flags byte (default
+ * `01`, sampled); pass the incoming byte to propagate a decision unchanged.
+ */
+declare function formatTraceparent(parts: {
+    traceId: string;
+    spanId: string;
+    sampled?: boolean;
+    flags?: number;
+}): string;
+/**
+ * The `traceparent` for a call a tool makes inside a traced run: the tool call's
+ * own span is the parent. Takes the `ToolCallContext` a tool receives, and is
+ * undefined when the run is not traced (there is nothing to propagate).
+ */
+declare function traceparentOf(ctx: {
+    traceId?: string;
+    traceSpanId?: string;
+    traceFlags?: number;
+} | undefined): string | undefined;
+
+/**
+ * The OpenTelemetry GenAI vocabulary the exporter speaks, in one place.
+ *
+ * Pinned to open-telemetry/semantic-conventions-genai at commit 547934a (status
+ * "development": names may still change upstream). No `schemaUrl` is set on the
+ * exported scope because the version that commit belongs to is unpublished;
+ * the commit is recorded here and in the docs instead.
+ */
+
+declare const GENAI_SEMCONV_COMMIT = "547934a";
 
 /** True when the model's rule uses `thinking:{type:"adaptive"}` + `output_config.effort` (Claude 4.6+ / 5.x). */
 declare function supportsAdaptiveThinking(model: unknown): boolean;
@@ -5984,4 +6542,4 @@ declare class ModelRequestError extends ProviderError {
     constructor(init: ModelRequestErrorInit);
 }
 
-export { type AIMessage, ASK_USER_TOOL_NAME, type AgentInstance, type AgentInvokeResult, type AgentLimits, type AgentOptions, type AgentPlugin, type AgentRuleOptions, type AgentRuntimeConfig, type AgentSnapshot, type AgentSnapshotMetadata, type AgentState, AnthropicProvider, AnthropicProviderConfig, type ApprovalTransport, type AuditEntry, type AuditLogConfig, type AzureContentSafetyConfig, AzureProvider, AzureProviderConfig, type BaseChatMessage, type BaseChatMessagePart, type BaseChatModel, type BaseMessage, BaseProvider, type BedrockGuardrailConfig, BedrockProvider, BedrockProviderConfig, type BudgetGuardConfig, type BuildChildConfig, type BuiltInRuntimeProfile, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, type CancellationTokenLike, type CancelledEvent, type CapabilityStatus, ChatCompletionChunk, ChatCompletionRequest, ChatCompletionResponse, type CheckpointPluginConfig, type CheckpointStore, type ChildContextPolicy, type CodeDetectionRuleOptions, type CodeGuardrailOptions, type CognipeerGuardrailConfig, type CompressToolOutputParams, type ContextBuilder, type ContextPilotCCRConfig, type ContextPilotCacheAlignmentConfig, type ContextPilotCompressionConfig, type ContextPilotCompressionStats, type ContextPilotCompressorKind, type ContextPilotConfig, type ContextPilotDedupConfig, type ContextPilotDiffCompressionConfig, type ContextPilotJsonCompressionConfig, type ContextPilotLogCompressionConfig, type ContextPilotResult, type ContextPilotRuntime, type ContextPilotSearchCompressionConfig, type ContextPilotTextCompressionConfig, type ContextPolicy, type ContextToolsStateRef, type ConversationGuardrail, type ConversationPluginConfig, type ConversationStore, type CostEstimator, type CustomRuleCallback, type CustomRuleOptions, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, type DeferredTraceEvent, type DelegationEventStamp, type DelegationMode, type DroppedDirective, EmbeddingRequest, EmbeddingResponse, type EvalCase, type EvalCaseResult, type EvalFamily, type EvalHarnessMetrics, type EvalHarnessParams, type EvalHarnessResult, type EvalProfileDescriptor, type EvalProfileTarget, type FinalAnswerEvent, type GateResult, type GuardrailCallContext, type GuardrailContext, type GuardrailDisposition, type GuardrailEvent, type GuardrailIncident, type GuardrailJudgeEngine, type GuardrailOutcome, GuardrailPhase, type GuardrailPhaseName, type GuardrailPluginOptions, type GuardrailRequest, type GuardrailRule, type GuardrailRuleResult, type GuardrailTransport, type GuardrailVerdict, type GuardrailViolation, HOOK_CONTRACT_VERSION, HOOK_NAMES, type HandoffDescriptor, type HandoffEvent, type HookContext, type HookDecision, type HookHandler, type HookMap, type HookName, type HookRegistrations, HookTimeoutError, type HttpGuardrailOptions, type HumanInTheLoopAskUserConfig, type HumanInTheLoopOptions, type HumanInTheLoopRuntimeConfig, InMemoryMemoryStore, type InjectionScan, type InvokeConfig, type JevClientLike, type JevEngineOptions, type JevNoulAnswer, JevProvider, JevProviderConfig, type JevQuestion, type JevSystemOneRequest, type JevSystemOneResult, type JsonGuardrailOptions, type JsonSchemaRuleOptions, LAST_SUMMARIZATION_CALL_KEY, type LangfuseBuildContext, type LangfuseEvent, type LangfuseEventKind, type LangfuseTracingConfig, type LanguageGuardConfig, type LoadSkillsOptions, type MaybePromise, type McpConfig, type McpConnection, type MediaAttachment, type MediaKind$1 as MediaKind, type MediaPolicyConfig, type MemoryFact, type MemoryProviderKind, type MemoryReadPolicy, type MemoryScope, type MemoryStore, type MemoryWritePolicy, type Message, type MessageUsage, type MetadataEvent, type ModelCapabilities, ModelRequestError, type ModelRequestErrorCode, type ModelRequestErrorInit, ModelRuleLearnedEvent, NativeJsonSchemaStrategy, type NativeModelOptions, type NativeReasoningConfig, OpenAICompatibleProvider, OpenAICompatibleProviderConfig, type OpenAIModerationConfig, OpenAIProvider, OpenAIProviderConfig, type OtelTracingConfig, type OutputGuardConfig, PREOPEN_TOOL_CALL_PREFIX, type PendingToolApproval, type PendingUserQuestion, type PiiDetector, type PiiEntity, type PiiRedactionConfig, type PlanEvent, type PlanStepRecord, type PlanningMode, type PluginContributions, type PluginEvent, type PluginFailureMode, type PluginHost, type PluginHostOptions, type PluginLogger, type PluginProvides, type PluginRunHost, type PluginSetupContext, type PortkeyGatewayConfig, type PortkeyGuardrailConfig, type PreopenSkillsResult, type ProfileConfig, type ProgressEvent, type ProgressUpdate, type PromptHooks, type PromptInjectionFamily, type PromptInjectionGuardConfig, type PromptSource, ProviderConfig, ProviderError, ToolDefinition as ProviderToolDefinition, ProviderType, type RateLimitConfig, type ReasoningConfig, type ReasoningLevel, type RedactionResult, type ReflectionCadence, type ReflectionConfig, type ReflectionEvent, type ReflectionHookContext, type ReflectionRecord, type RegexGuardrailConfig, type RegexGuardrailOptions, type RegexRuleOptions, type ReplanPolicy, type ResolvedContextPilotConfig, type ResolvedSmartAgentConfig, type ResolvedTraceConfig, type ResolvedTraceSink, type ResponseCacheConfig, type RestoreSnapshotOptions, RulePatch, type RuntimeProfile, SMALL_TIER_SKILL_POLICY, type SdkCapabilities, type SerializableSmartState, type SessionMetrics, type SessionMetricsConfig, type Skill, type SkillDisclosure, type SkillExecutionContext, type SkillFrontmatter, type SkillFs, type SkillModelTier, type SkillPolicy, type SkillRegistryRef, type SkillSource, type SkillToolDeps, type SkillToolHeader, type SlotName, type SmartAgentBudgetConfig, type SmartAgentContextConfig, type SmartAgentCustomProfileConfig, type SmartAgentDelegationConfig, type SmartAgentEvent, type SmartAgentInstance, type SmartAgentLimits, type SmartAgentMemoryConfig, type SmartAgentOptions, type SmartAgentPlanningConfig, type SmartAgentSummarizationConfig, type SmartAgentToolResponseConfig, type SmartAgentTracingConfig, type SmartModel, type SmartState, type SmartToolFn, type SnapshotOptions, type SnapshotRuntimeHint, type StreamChunk, type StreamEvent, type StrictRestorers, type StrictTransform, type StructuredOutputError, type StructuredOutputFieldError, StructuredOutputManager, type StructuredOutputManagerConfig, type StructuredOutputResult, type StructuredOutputStrategy, type StructuredSummary, type SubagentDef, type SubagentEvent, type SubagentMode, type SubagentPendingRecord, type SubagentPolicy, type SubagentRegistryRef, type SubagentResult, type SubagentStatus, type SubagentToolDeps, type SubagentToolNames, type SubagentUsage, type SummarizationEvent, type SummarizationMode, type SummarizerInput, type SummarizerResult, type SummarizerStrategy, type SummaryFactItem, type SummaryIntegrityCheck, TOOL_INPUT_DIGEST_KEY, type TokenCounter, TokenUsage, type ToolApprovalEvent, type ToolApprovalResolution, type ToolApprovalStatus, ToolBasedStrategy, type ToolCachePolicy, type ToolCallContext, type ToolCallEvent, type ToolInputDigestOptions, type ToolInputDigestResult, type ToolInputRetentionPolicy, type ToolInterface, type ToolPolicyConfig, type ToolResponseClassification, type ToolResponseRetentionPolicy, type ToolRetentionDeclarations, type ToolRetentionSpec, type ToolRetryPolicy, type ToolRule, type TraceContinuation, type TraceDataSection, type TraceErrorRecord, type TraceEventRecord, type TraceMessagePart, type TraceMessageSection, type TraceMetadataSection, type TraceSessionConfigSnapshot, type TraceSessionFile, type TraceSessionStatus, type TraceSessionSummary, type TraceSinkCognipeerConfig, type TraceSinkConfig, type TraceSinkCustomConfig, type TraceSinkFileConfig, type TraceSinkHttpConfig, type TraceSinkOtlpConfig, type TraceSinkSnapshot, type TraceSummarySection, type TraceToolCallSection, type TraceToolDefinition, type TraceToolDefinitionsSection, type TraceToolDetails, type TraceToolResponseSection, type TraceToolResultSection, type TracingConfig, type TracingMode, UnifiedMessage, type UserQuestionAnswer, type UserQuestionAnswerSet, type UserQuestionEvent, type UserQuestionItem, type UserQuestionOption, type UserQuestionResolution, type UserQuestionStatus, VertexProvider, VertexProviderConfig, type VolatileContentFinding, type VolatileContentPattern, type WebhookApprovalConfig, agentVerdictRule, appendBoundTools, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isTraceSessionOpen, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, loadSkillsFromDisk, mapConsoleHookVerdict, mapTextParts, mcp, mediaKindOf, mediaPolicy, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseSkillFrontmatter, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, readTraceContinuation, recordOrDeferTraceEvent, redactText, regexGuardrail, regexRule, replaceTextContent, replayDeferredTraceEvents, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, supportsAdaptiveThinking, textFromContent, toMessageUsage, toModelResult, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceContinuationOf, traceSectionsFromMessages, traceSessionToOtlp, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
+export { type AIMessage, ASK_USER_TOOL_NAME, type AgentInstance, type AgentInvokeResult, type AgentLimits, type AgentOptions, type AgentPlugin, type AgentRuleOptions, type AgentRuntimeConfig, type AgentSnapshot, type AgentSnapshotMetadata, type AgentState, AnthropicProvider, AnthropicProviderConfig, type ApprovalTransport, type AuditEntry, type AuditLogConfig, type AzureContentSafetyConfig, AzureProvider, AzureProviderConfig, type BaseChatMessage, type BaseChatMessagePart, type BaseChatModel, type BaseMessage, BaseProvider, type BedrockGuardrailConfig, BedrockProvider, BedrockProviderConfig, type BudgetGuardConfig, type BuildChildConfig, type BuiltInRuntimeProfile, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, type CancellationTokenLike, type CancelledEvent, type CapabilityStatus, ChatCompletionChunk, ChatCompletionRequest, ChatCompletionResponse, type CheckpointPluginConfig, type CheckpointStore, type ChildContextPolicy, type CodeDetectionRuleOptions, type CodeGuardrailOptions, type CognipeerGuardrailConfig, type CompressToolOutputParams, type ContextBuilder, type ContextPilotCCRConfig, type ContextPilotCacheAlignmentConfig, type ContextPilotCompressionConfig, type ContextPilotCompressionStats, type ContextPilotCompressorKind, type ContextPilotConfig, type ContextPilotDedupConfig, type ContextPilotDiffCompressionConfig, type ContextPilotJsonCompressionConfig, type ContextPilotLogCompressionConfig, type ContextPilotResult, type ContextPilotRuntime, type ContextPilotSearchCompressionConfig, type ContextPilotTextCompressionConfig, type ContextPolicy, type ContextToolsStateRef, type ConversationGuardrail, type ConversationPluginConfig, type ConversationStore, type CostEstimator, type CustomRuleCallback, type CustomRuleOptions, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, type DeferredTraceEvent, type DelegationEventStamp, type DelegationMode, type DroppedDirective, EmbeddingRequest, EmbeddingResponse, type EvalCase, type EvalCaseResult, type EvalFamily, type EvalHarnessMetrics, type EvalHarnessParams, type EvalHarnessResult, type EvalProfileDescriptor, type EvalProfileTarget, type FinalAnswerEvent, GENAI_SEMCONV_COMMIT, type GateResult, type GuardrailCallContext, type GuardrailContext, type GuardrailDisposition, type GuardrailEvent, type GuardrailIncident, type GuardrailJudgeEngine, type GuardrailOutcome, GuardrailPhase, type GuardrailPhaseName, type GuardrailPluginOptions, type GuardrailRequest, type GuardrailRule, type GuardrailRuleResult, type GuardrailTransport, type GuardrailVerdict, type GuardrailViolation, HOOK_CONTRACT_VERSION, HOOK_NAMES, type HandoffDescriptor, type HandoffEvent, type HookContext, type HookDecision, type HookHandler, type HookMap, type HookName, type HookRegistrations, HookTimeoutError, type HttpGuardrailOptions, type HumanInTheLoopAskUserConfig, type HumanInTheLoopOptions, type HumanInTheLoopRuntimeConfig, InMemoryMemoryStore, type InjectionScan, type InvokeConfig, type JevClientLike, type JevEngineOptions, type JevNoulAnswer, JevProvider, JevProviderConfig, type JevQuestion, type JevSystemOneRequest, type JevSystemOneResult, type JsonGuardrailOptions, type JsonSchemaRuleOptions, LAST_SUMMARIZATION_CALL_KEY, type LangfuseBuildContext, type LangfuseEvent, type LangfuseEventKind, type LangfuseTracingConfig, type LanguageGuardConfig, type LoadSkillsOptions, type MaybePromise, type McpConfig, type McpConnection, type MediaAttachment, type MediaKind$1 as MediaKind, type MediaPolicyConfig, type MemoryFact, type MemoryProviderKind, type MemoryReadPolicy, type MemoryScope, type MemoryStore, type MemoryWritePolicy, type Message, type MessageUsage, type MetadataEvent, type ModelCapabilities, ModelRequestError, type ModelRequestErrorCode, type ModelRequestErrorInit, ModelRuleLearnedEvent, NativeJsonSchemaStrategy, type NativeModelOptions, type NativeReasoningConfig, OpenAICompatibleProvider, OpenAICompatibleProviderConfig, type OpenAIModerationConfig, OpenAIProvider, OpenAIProviderConfig, type OtelTracingConfig, type OtlpContentField, type OtlpContentOptions, type OtlpContentRedactInfo, type OtlpExportOptions, type OtlpExportResult, type OtlpExportTraceServiceRequest, type OtlpExporter, type OtlpProtocol, type OtlpRetryOptions, type OtlpSemconv, type OutputGuardConfig, PREOPEN_TOOL_CALL_PREFIX, type PendingToolApproval, type PendingUserQuestion, type PiiDetector, type PiiEntity, type PiiRedactionConfig, type PlanEvent, type PlanStepRecord, type PlanningMode, type PluginContributions, type PluginEvent, type PluginFailureMode, type PluginHost, type PluginHostOptions, type PluginLogger, type PluginProvides, type PluginRunHost, type PluginSetupContext, type PortkeyGatewayConfig, type PortkeyGuardrailConfig, type PreopenSkillsResult, type ProfileConfig, type ProgressEvent, type ProgressUpdate, type PromptHooks, type PromptInjectionFamily, type PromptInjectionGuardConfig, type PromptSource, ProviderConfig, ProviderError, ToolDefinition as ProviderToolDefinition, ProviderType, type RateLimitConfig, type ReasoningConfig, type ReasoningLevel, type RedactionResult, type ReflectionCadence, type ReflectionConfig, type ReflectionEvent, type ReflectionHookContext, type ReflectionRecord, type RegexGuardrailConfig, type RegexGuardrailOptions, type RegexRuleOptions, type ReplanPolicy, type ResolvedContextPilotConfig, type ResolvedSmartAgentConfig, type ResolvedTraceConfig, type ResolvedTraceSink, type ResponseCacheConfig, type RestoreSnapshotOptions, RulePatch, type RuntimeProfile, SMALL_TIER_SKILL_POLICY, type SdkCapabilities, type SerializableSmartState, type SessionMetrics, type SessionMetricsConfig, type Skill, type SkillDisclosure, type SkillExecutionContext, type SkillFrontmatter, type SkillFs, type SkillModelTier, type SkillPolicy, type SkillRegistryRef, type SkillSource, type SkillToolDeps, type SkillToolHeader, type SlotName, type SmartAgentBudgetConfig, type SmartAgentContextConfig, type SmartAgentCustomProfileConfig, type SmartAgentDelegationConfig, type SmartAgentEvent, type SmartAgentInstance, type SmartAgentLimits, type SmartAgentMemoryConfig, type SmartAgentOptions, type SmartAgentPlanningConfig, type SmartAgentSummarizationConfig, type SmartAgentToolResponseConfig, type SmartAgentTracingConfig, type SmartModel, type SmartState, type SmartToolFn, type SnapshotOptions, type SnapshotRuntimeHint, type StreamChunk, type StreamEvent, type StrictRestorers, type StrictTransform, type StructuredOutputError, type StructuredOutputFieldError, StructuredOutputManager, type StructuredOutputManagerConfig, type StructuredOutputResult, type StructuredOutputStrategy, type StructuredSummary, type SubagentDef, type SubagentEvent, type SubagentMode, type SubagentPendingRecord, type SubagentPolicy, type SubagentRegistryRef, type SubagentResult, type SubagentStatus, type SubagentToolDeps, type SubagentToolNames, type SubagentUsage, type SummarizationEvent, type SummarizationMode, type SummarizerInput, type SummarizerResult, type SummarizerStrategy, type SummaryFactItem, type SummaryIntegrityCheck, TOOL_INPUT_DIGEST_KEY, type TokenCounter, TokenUsage, type ToolApprovalEvent, type ToolApprovalResolution, type ToolApprovalStatus, ToolBasedStrategy, type ToolCachePolicy, type ToolCallContext, type ToolCallEvent, type ToolInputDigestOptions, type ToolInputDigestResult, type ToolInputRetentionPolicy, type ToolInterface, type ToolPolicyConfig, type ToolResponseClassification, type ToolResponseRetentionPolicy, type ToolRetentionDeclarations, type ToolRetentionSpec, type ToolRetryPolicy, type ToolRule, type TraceContinuation, type TraceDataSection, type TraceErrorRecord, type TraceEventRecord, type TraceMessagePart, type TraceMessageSection, type TraceMetadataSection, type TraceParent, type TraceParentInput, type TraceSessionConfigSnapshot, type TraceSessionFile, type TraceSessionStatus, type TraceSessionSummary, type TraceSinkCognipeerConfig, type TraceSinkConfig, type TraceSinkCustomConfig, type TraceSinkFileConfig, type TraceSinkHttpConfig, type TraceSinkOtlpConfig, type TraceSinkSnapshot, type TraceSummarySection, type TraceToolCallSection, type TraceToolDefinition, type TraceToolDefinitionsSection, type TraceToolDetails, type TraceToolResponseSection, type TraceToolResultSection, type TracingConfig, type TracingMode, UnifiedMessage, type UserQuestionAnswer, type UserQuestionAnswerSet, type UserQuestionEvent, type UserQuestionItem, type UserQuestionOption, type UserQuestionResolution, type UserQuestionStatus, VertexProvider, VertexProviderConfig, type VolatileContentFinding, type VolatileContentPattern, type WebhookApprovalConfig, agentVerdictRule, appendBoundTools, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, closeTraceContinuation, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createOtlpExporter, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, foldSupersededSpans, formatTraceparent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isTraceSessionOpen, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, loadSkillsFromDisk, mapConsoleHookVerdict, mapTextParts, mcp, mediaKindOf, mediaPolicy, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseSkillFrontmatter, parseTraceparent, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, readTraceContinuation, recordOrDeferTraceEvent, redactText, regexGuardrail, regexRule, replaceTextContent, replayDeferredTraceEvents, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, supportsAdaptiveThinking, textFromContent, toMessageUsage, toModelResult, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceContinuationOf, traceSectionsFromMessages, traceSessionToOtlp, traceparentOf, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };