@axlsdk/axl 0.21.1 → 0.22.0

package/dist/index.d.cts

@@ -2,6 +2,74 @@ import { z, ZodError } from 'zod';
 import { EventEmitter } from 'node:events';
 import { Readable } from 'node:stream';
 
+/** Ordered, model-facing input. Strings retain the legacy shorthand. */
+type ModelInput = string | readonly InputContentPart[];
+type InputTextPart = {
+    readonly type: 'text';
+    readonly text: string;
+};
+type InputMediaSource = {
+    readonly type: 'url';
+    readonly url: string;
+    readonly mediaType?: string;
+} | {
+    readonly type: 'bytes';
+    readonly data: Uint8Array;
+    readonly mediaType: string;
+} | {
+    readonly type: 'base64';
+    readonly data: string;
+    readonly mediaType: string;
+} | {
+    readonly type: 'provider-file';
+    readonly provider: string;
+    readonly reference: string;
+    readonly mediaType?: string;
+};
+type InputImagePart = {
+    readonly type: 'image';
+    readonly source: InputMediaSource;
+    readonly label?: string;
+};
+type InputContentPart = InputTextPart | InputImagePart;
+/** Maximum decoded bytes retained across inline images in one logical input. */
+declare const MAX_INLINE_MODEL_INPUT_BYTES: number;
+/** Bounded, observation-safe representation of a rich input. */
+type ModelInputDescriptor = {
+    readonly parts: readonly ({
+        readonly type: 'text';
+        readonly characters: number;
+    } | {
+        readonly type: 'image';
+        readonly source: InputMediaSource['type'];
+        readonly mediaType?: string;
+        readonly bytes?: number;
+        readonly locator?: string;
+        readonly label?: string;
+    })[];
+};
+/** Return legacy text unchanged, or the deterministic ordered text projection. */
+declare function inputText(input: ModelInput): string;
+
+type InputModalitySupport = {
+    image?: {
+        sources: readonly InputMediaSource['type'][];
+    };
+};
+type ProviderInputValidationRequest = {
+    model: string;
+    input: ModelInput;
+    /** Application-owned history that will accompany this input. Validators must
+     * cover every rich part/source across both input and history. */
+    history: readonly ChatMessage[];
+    stream: boolean;
+    hasTools: boolean;
+    responseMode: 'text' | 'structured';
+    providerOptions?: Record<string, unknown>;
+};
+type ProviderInputValidationResult = {
+    effectiveModel: string;
+};
 /**
  * Tool definition in OpenAI-compatible format.
  * All providers normalize to this format internally.
@@ -126,6 +194,10 @@ type StreamChunk = {
 interface Provider {
     /** Human-readable name for the provider (e.g. "openai", "anthropic") */
     readonly name?: string;
+    /** Coarse, model-aware input metadata for UI/documentation. */
+    inputCapabilities?(model: string): InputModalitySupport;
+    /** Authoritative request-scoped rich-input validation. Omission means text-only. */
+    validateInput?(request: ProviderInputValidationRequest): ProviderInputValidationResult;
     /**
      * Send a chat completion request and return the full response.
      */
@@ -333,6 +405,8 @@ type DelegateOptions<T = unknown> = {
     nativeStructuredOutput?: boolean;
     /** Model URI for the internal router agent (default: first candidate's model). */
     routerModel?: string;
+    /** Route using the full evidence (default) or only its ordered text projection. */
+    routerInput?: 'full' | 'text';
     /** Additional metadata passed to the router and selected agent. */
     metadata?: Record<string, unknown>;
     /** Number of retries for structured output validation (passed to the final ask). */
@@ -356,11 +430,11 @@ type ExecutionStatus = 'running' | 'completed' | 'failed' | 'waiting';
  * derive `AxlEventType` from this tuple and use it to validate stream filters,
  * redaction tables, and exhaustiveness assertions.
  */
-declare const AXL_EVENT_TYPES: readonly ["workflow_start", "workflow_end", "ask_start", "ask_end", "agent_call_start", "agent_call_end", "token", "tool_call_start", "tool_call_end", "tool_call_rejected", "tool_approval", "delegate", "handoff_start", "handoff_return", "pipeline", "partial_object", "string_delta", "verify", "schema_diagnostic", "log", "memory_remember", "memory_recall", "memory_forget", "checkpoint_save", "checkpoint_replay", "await_human", "await_human_resolved", "guardrail", "schema_check", "validate", "done", "error"];
+declare const AXL_EVENT_TYPES: readonly ["workflow_start", "workflow_end", "transcription_start", "transcription_end", "ask_start", "ask_end", "agent_call_start", "agent_call_end", "token", "tool_call_start", "tool_call_end", "tool_call_rejected", "tool_approval", "delegate", "handoff_start", "handoff_return", "pipeline", "partial_object", "string_delta", "verify", "schema_diagnostic", "log", "memory_remember", "memory_recall", "memory_forget", "checkpoint_save", "checkpoint_replay", "await_human", "await_human_resolved", "guardrail", "schema_check", "validate", "done", "error"];
 /** Discriminator union derived from `AXL_EVENT_TYPES`. */
 type AxlEventType = (typeof AXL_EVENT_TYPES)[number];
 /** Backward-compatible name for the canonical v2 writer discriminator list. */
-declare const AXL_EVENT_TYPES_V2: readonly ["workflow_start", "workflow_end", "ask_start", "ask_end", "agent_call_start", "agent_call_end", "token", "tool_call_start", "tool_call_end", "tool_call_rejected", "tool_approval", "delegate", "handoff_start", "handoff_return", "pipeline", "partial_object", "string_delta", "verify", "schema_diagnostic", "log", "memory_remember", "memory_recall", "memory_forget", "checkpoint_save", "checkpoint_replay", "await_human", "await_human_resolved", "guardrail", "schema_check", "validate", "done", "error"];
+declare const AXL_EVENT_TYPES_V2: readonly ["workflow_start", "workflow_end", "transcription_start", "transcription_end", "ask_start", "ask_end", "agent_call_start", "agent_call_end", "token", "tool_call_start", "tool_call_end", "tool_call_rejected", "tool_approval", "delegate", "handoff_start", "handoff_return", "pipeline", "partial_object", "string_delta", "verify", "schema_diagnostic", "log", "memory_remember", "memory_recall", "memory_forget", "checkpoint_save", "checkpoint_replay", "await_human", "await_human_resolved", "guardrail", "schema_check", "validate", "done", "error"];
 /** Accepted/rejected tool lifecycle discriminators in event schema v2. */
 declare const AXL_TOOL_LIFECYCLE_TYPES_V2: readonly ["tool_call_start", "tool_call_end", "tool_call_rejected"];
 /** Resolved model parameters sent to the provider for an LLM call. */
@@ -382,6 +456,8 @@ type AgentCallParams = {
 type AgentCallStartData = {
     /** Original user prompt passed to `ctx.ask()`. Does not include retry feedback or tool results. */
     prompt: string;
+    /** Bounded rich-input shape; omitted for legacy string calls. */
+    input?: ModelInputDescriptor;
     /** Resolved system prompt (after evaluating dynamic system selectors). */
     system?: string;
     /** Resolved model parameters sent to the provider for this call. */
@@ -394,6 +470,12 @@ type AgentCallStartData = {
     toolNames?: string[];
     /** Full ChatMessage[] sent to the provider this turn. Only populated when `trace.level === 'full'`. */
     messages?: ChatMessage[];
+    /** Descriptor-only counterparts for rich messages in a full snapshot. The
+     * matching `messages[index].content` is its text projection, never media. */
+    messageInputs?: readonly {
+        readonly index: number;
+        readonly input: ModelInputDescriptor;
+    }[];
 };
 /**
  * Data shape for `agent_call_end` events — the **response** side of the call.
@@ -402,8 +484,10 @@ type AgentCallStartData = {
  *
  * Pair invariant: every `agent_call_start` is followed by exactly one
  * `agent_call_end`, even on provider error. On the error path `response` is
- * empty and `error` carries the provider's message; cost/tokens/duration are
- * still emitted (top-level on the event) when partial usage is available.
+ * empty and `error` carries the provider's message for legacy string calls.
+ * Rich-input calls use a fixed safe message because providers can echo inline
+ * media in their request errors. Cost/tokens/duration are still emitted
+ * (top-level on the event) when partial usage is available.
  */
 type AgentCallEndData = {
     /** Final LLM response content for this turn. Empty string on error. */
@@ -416,8 +500,9 @@ type AgentCallEndData = {
      *  reading `agent_call_end` (cost lives here) can bucket without joining. */
     retryReason?: 'schema' | 'validate' | 'guardrail';
     /** Provider error message when the call threw (network failure, 4xx/5xx,
-     *  abort, etc). Mutually exclusive with `response` content. Subject to
-     *  `config.trace.redact` (vendor errors can echo prompt text). */
+     *  abort, etc). Mutually exclusive with `response` content. Rich-input
+     *  calls always use a fixed safe projection, independently of trace
+     *  redaction, because vendor errors can echo request media. */
     error?: string;
     /** HTTP status when the thrown error was a `ProviderError` (`0` for network
      *  failures). Omitted for non-provider errors. The raw error body is
@@ -426,6 +511,14 @@ type AgentCallEndData = {
     /** Semantic failover hint from a thrown `ProviderError` (see
      *  `ProviderError.retryable`). Omitted for non-provider errors. */
     retryable?: boolean;
+    /** Stable typed error code for a rich-input failure, when available. */
+    code?: string;
+    /** Provider identifier from a typed provider error on a rich-input failure. */
+    provider?: string;
+    /** Provider request id from a typed provider error on a rich-input failure. */
+    requestId?: string;
+    /** Retry-after delay in milliseconds from a typed provider error on a rich-input failure. */
+    retryAfterMs?: number;
 };
 /** Data shape for `tool_call_end` events. */
 type ToolCallData = {
@@ -907,6 +1000,7 @@ type LegacyAxlEventPayloadV1 = (AxlEventBase & {
 }) | (AxlEventBase & AskScoped & {
     type: 'ask_start';
     prompt: string;
+    input?: ModelInputDescriptor;
 }) | (AxlEventBase & AskScoped & {
     type: 'ask_end';
     /** Discriminated outcome — narrow on `outcome.ok`. Ask-internal throws
@@ -1109,13 +1203,69 @@ type LegacyAxlEventV1 = LegacyAxlEventPayloadV1 & {
 type ToolCallRejectedEvent = Extract<ToolLifecycleEventV2, {
     type: 'tool_call_rejected';
 }>;
+/** Current-schema-only operation events. Deliberately excluded from the
+ * frozen legacy v1 payload so old persisted records never gain new variants. */
+type TranscriptionLifecycleEventV2 = (AxlEventBase & {
+    schemaVersion: 2;
+    type: 'transcription_start';
+    transcriptionId: string;
+    model?: string;
+    data: {
+        provider?: string;
+        model?: string;
+        audio: {
+            source: string;
+            bytes?: number;
+            mediaType?: string;
+        };
+    };
+}) | (AxlEventBase & {
+    schemaVersion: 2;
+    type: 'transcription_end';
+    transcriptionId: string;
+    model?: string;
+    duration: number;
+    cost?: number;
+    tokens?: {
+        input?: number;
+        output?: number;
+    };
+    data: {
+        status: 'completed' | 'failed' | 'aborted';
+        provider?: string;
+        model?: string;
+        audio?: {
+            source: string;
+            bytes?: number;
+            mediaType?: string;
+        };
+        text?: string;
+        usage?: {
+            audioSeconds?: number;
+            inputTokens?: number;
+            outputTokens?: number;
+            totalTokens?: number;
+            cost?: number;
+        };
+        pricingStatus?: 'priced' | 'unpriced' | 'zero';
+        cleanupStatus?: 'not_required' | 'deleted' | 'failed' | 'timed_out';
+        error?: string;
+        errorCode?: 'TRANSCRIPTION_PROVIDER_ERROR';
+        providerError?: {
+            status: number;
+            retryable: boolean;
+            retryAfterMs?: number;
+            requestId?: string;
+        };
+    };
+});
 /** Event contract written by the next breaking runtime.
  *
  * This additive prototype lets consumers and type tests lock the schema before
  * the runtime writer switches. Every v2 event carries the version directly;
  * `tool_denied` and the v1 tool end shape cannot be represented.
  */
-type AxlEventV2 = ToolLifecycleEventV2 | (Exclude<LegacyAxlEventPayloadV1, {
+type AxlEventV2 = ToolLifecycleEventV2 | TranscriptionLifecycleEventV2 | (Exclude<LegacyAxlEventPayloadV1, {
     type: 'tool_call_start' | 'tool_call_end' | 'tool_denied';
 }> & {
     schemaVersion: 2;
@@ -1140,6 +1290,7 @@ type GuardrailResult = {
 /** Input guardrail function. Runs before the LLM call. */
 type InputGuardrail = (prompt: string, ctx: {
     metadata: Record<string, unknown>;
+    input: ModelInput;
 }) => GuardrailResult | Promise<GuardrailResult>;
 /** Output guardrail function. Runs after the LLM response. */
 type OutputGuardrail = (response: string, ctx: {
@@ -1243,6 +1394,7 @@ type HandoffRecord = {
 type AgentCallInfo = {
     agent: string;
     prompt: string;
+    input?: ModelInputDescriptor;
     response: string;
     model: string;
     cost: number;
@@ -1264,7 +1416,7 @@ type AgentCallInfo = {
 type ChatRole = 'system' | 'user' | 'assistant' | 'tool';
 type ChatMessage = {
     role: ChatRole;
-    content: string;
+    content: string | readonly InputContentPart[];
     name?: string;
     tool_calls?: ToolCallMessage[];
     tool_call_id?: string;
@@ -1315,6 +1467,78 @@ declare class AxlError extends Error {
     readonly code: string;
     constructor(code: string, message: string);
 }
+/** Thrown when the public logical model-input shape is malformed. */
+declare class InvalidModelInputError extends AxlError {
+    constructor(message: string);
+}
+/** Thrown before dispatch when a provider/model cannot accept a rich input. */
+declare class UnsupportedModelInputError extends AxlError {
+    readonly provider: string;
+    readonly model: string;
+    readonly modality: string;
+    readonly source?: string;
+    constructor(options: {
+        provider: string;
+        model: string;
+        modality: string;
+        source?: string;
+        feature?: string;
+    });
+}
+/** Thrown when the public transcription request contains unsupported or unsafe input. */
+declare class InvalidTranscriptionInputError extends AxlError {
+    constructor(message: string);
+}
+/** Thrown before dispatch when no explicit transcription adapter can serve a URI. */
+declare class UnsupportedTranscriptionInputError extends AxlError {
+    readonly provider: string;
+    readonly model: string;
+    constructor(options: {
+        provider: string;
+        model: string;
+        feature?: string;
+    });
+}
+/** Safe boundary error for an adapter failure. The original provider error is
+ * retained only as a non-enumerable cause because vendor messages/bodies may
+ * echo raw audio or provider-file references. */
+declare class TranscriptionOperationError extends AxlError {
+    readonly provider: string;
+    readonly model: string;
+    readonly usage?: {
+        audioSeconds?: number;
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+        cost?: number;
+    };
+    readonly pricingStatus?: 'priced' | 'unpriced' | 'zero';
+    readonly cleanupStatus?: 'not_required' | 'deleted' | 'failed' | 'timed_out';
+    /** Safe HTTP diagnostics projected from ProviderError when available. */
+    readonly status?: number;
+    readonly retryable?: boolean;
+    readonly retryAfterMs?: number;
+    readonly requestId?: string;
+    readonly cause?: unknown;
+    constructor(options: {
+        provider: string;
+        model: string;
+        usage?: {
+            audioSeconds?: number;
+            inputTokens?: number;
+            outputTokens?: number;
+            totalTokens?: number;
+            cost?: number;
+        };
+        pricingStatus?: 'priced' | 'unpriced' | 'zero';
+        cleanupStatus?: 'not_required' | 'deleted' | 'failed' | 'timed_out';
+        status?: number;
+        retryable?: boolean;
+        retryAfterMs?: number;
+        requestId?: string;
+        cause?: unknown;
+    });
+}
 /**
  * Strict observation overflow. Kept in the shared error module so every
  * recovery boundary can identify the same non-recoverable control error.
@@ -1434,7 +1658,7 @@ type Agent = {
     readonly _config: AgentConfig;
     readonly _name: string;
     /** Direct invocation for prototyping (no workflow context) */
-    ask<T = string>(prompt: string, options?: AskOptions<T>): Promise<T>;
+    ask<T = string>(prompt: ModelInput, options?: AskOptions<T>): Promise<T>;
     /** Resolve model string for given context */
     resolveModel(ctx?: {
         metadata?: Record<string, unknown>;
@@ -2139,6 +2363,12 @@ type OpenAICompatibleOptions = {
  */
 declare class OpenAICompatibleProvider implements Provider {
     readonly name: string;
+    inputCapabilities(model: string): {
+        image?: {
+            sources: readonly InputMediaSource['type'][];
+        };
+    };
+    validateInput(request: ProviderInputValidationRequest): ProviderInputValidationResult;
     /** `json_schema` is honored natively when the profile's `supportsJsonSchema`
      *  capability is true for this model (the default); otherwise the engine
      *  downgrades the request to plain `json_object` (see `buildRequestBody`),
@@ -2736,6 +2966,96 @@ declare class ProviderRegistry {
     clearFactories(): void;
 }
 
+/** Audio supplied to a transcription provider. Network and file-system sources
+ * are deliberately excluded: callers retain control of all I/O. */
+type RecordedAudioSource = {
+    readonly type: 'bytes';
+    readonly data: Uint8Array;
+    readonly mediaType: string;
+} | {
+    readonly type: 'base64';
+    readonly data: string;
+    readonly mediaType: string;
+} | {
+    readonly type: 'provider-file';
+    readonly provider: string;
+    readonly reference: string;
+    readonly mediaType?: string;
+};
+type TranscriptionRequest = {
+    readonly model: string;
+    readonly audio: RecordedAudioSource;
+    readonly language?: string;
+    readonly timestamps?: 'segment' | 'word';
+    readonly diarization?: boolean;
+    readonly providerOptions?: Record<string, unknown>;
+};
+type Transcript = {
+    readonly text: string;
+    readonly detectedLanguages?: readonly string[];
+    readonly segments?: readonly {
+        readonly text: string;
+        readonly start: number;
+        readonly end: number;
+        readonly speaker?: string;
+    }[];
+    readonly words?: readonly {
+        readonly text: string;
+        readonly start: number;
+        readonly end: number;
+        readonly speaker?: string;
+    }[];
+    readonly usage?: {
+        readonly audioSeconds?: number;
+        readonly inputTokens?: number;
+        readonly outputTokens?: number;
+        readonly totalTokens?: number;
+        readonly cost?: number;
+    };
+    readonly pricingStatus?: 'priced' | 'unpriced' | 'zero';
+    readonly providerMetadata?: Readonly<Record<string, unknown>>;
+};
+/** Maximum decoded size of caller-supplied inline audio. */
+declare const MAX_INLINE_TRANSCRIPTION_BYTES: number;
+
+type TranscriptionCapabilities = {
+    readonly sources: readonly RecordedAudioSource['type'][];
+    readonly timestamps?: readonly ('segment' | 'word')[];
+    readonly diarization?: boolean;
+};
+type TranscriptionProviderRequest = Omit<TranscriptionRequest, 'model'> & {
+    readonly model: string;
+    readonly signal?: AbortSignal;
+};
+type TranscriptionProviderResult = {
+    readonly transcript: Transcript;
+    /** Internal cleanup outcome. Never includes a provider file identifier. */
+    readonly cleanupStatus?: 'not_required' | 'deleted' | 'failed' | 'timed_out';
+};
+interface TranscriptionProvider {
+    readonly capabilities: (model: string) => TranscriptionCapabilities | undefined;
+    transcribe(request: TranscriptionProviderRequest): Promise<TranscriptionProviderResult>;
+}
+
+type TranscriptionProviderFactory = (config: AxlConfig) => TranscriptionProvider;
+type ResolvedTranscriptionProvider = {
+    provider: TranscriptionProvider;
+    model: string;
+    providerName: string;
+};
+/** Dedicated registry: transcription URIs are always explicit `provider:model`.
+ * It intentionally has no chat-provider/default-model or test fallback. */
+declare class TranscriptionProviderRegistry {
+    private instances;
+    private factories;
+    constructor();
+    register(name: string, factory: TranscriptionProviderFactory): void;
+    registerInstance(name: string, provider: TranscriptionProvider): void;
+    has(name: string): boolean;
+    get(name: string, config?: AxlConfig): TranscriptionProvider;
+    resolve(uri: string, config?: AxlConfig): ResolvedTranscriptionProvider;
+}
+
 /**
  * Manages connections to multiple MCP servers.
  * Discovers tools, filters by agent config, and routes tool calls.
@@ -2893,6 +3213,15 @@ declare function zodToJsonSchema(schema: z.ZodType): Record<string, unknown>;
  * and content with leading/trailing text around a JSON object/array.
  */
 declare function extractJson(content: string): string;
+type ObserverErrorProjection = {
+    readonly message: string;
+    readonly name: string;
+};
+type RichFailureState = {
+    associations: unknown[];
+    overflowed: boolean;
+    indeterminate: boolean;
+};
 /**
  * Active `ctx.budget()` accounting state. One mutable object per budget block,
  * shared by reference across the block's async branches (spawn/race/map).
@@ -2932,6 +3261,7 @@ type WorkflowContextInit = {
     metadata?: Record<string, unknown>;
     config: AxlConfig;
     providerRegistry: ProviderRegistry;
+    transcriptionProviderRegistry?: TranscriptionProviderRegistry;
     sessionHistory?: ChatMessage[];
     onTrace?: (event: AxlEvent) => void;
     pendingDecisions?: Map<string, PendingDecisionResolver>;
@@ -2997,6 +3327,9 @@ type WorkflowContextInit = {
     /** Internal: root-shared lifecycle state. Prevents child contexts from
      *  emitting trace events after the workflow terminal. */
     workflowLifecycleState?: WorkflowLifecycleState;
+    /** Internal: bounded rich-failure state shared by child contexts in one
+     * execution. Never pass across independently created contexts. */
+    richFailureState?: RichFailureState;
     /** Runtime terminal barrier for abort-ignoring race/quorum branches. */
     branchDrainTimeoutMs?: number;
 };
@@ -3033,6 +3366,7 @@ declare class WorkflowContext<TInput = unknown> {
     get totalCost(): number;
     private config;
     private providerRegistry;
+    private transcriptionProviderRegistry?;
     private sessionHistory;
     private onTrace?;
     private pendingDecisions?;
@@ -3058,6 +3392,10 @@ declare class WorkflowContext<TInput = unknown> {
      */
     private autoCheckpointCounters;
     private readonly branchDrainState;
+    /** Bounded exact-identity failure association for this execution tree.
+     * Unlike a process-global marker, this cannot affect another context that
+     * happens to reuse the same Error object. */
+    private readonly richFailureState;
     /** Root-shared idempotency guards for workflow lifecycle emission.
      *  Both `runtime.execute()` and `runtime.stream()` have paths where a
      *  post-emit side-effect (checkpoint deletion, state-store persistence)
@@ -3175,6 +3513,10 @@ declare class WorkflowContext<TInput = unknown> {
      * was removed in 0.16.0.
      */
     createChildContext(): WorkflowContext;
+    /** Associate an exact thrown value with rich input in this execution only. */
+    private recordRichFailure;
+    /** @internal Safe observer projection for a failure associated with rich input. */
+    _observerErrorProjection(error: unknown): ObserverErrorProjection | undefined;
     /**
      * Resolve the current abort signal.
      * Branch-scoped signals (from race/spawn/map/budget) in AsyncLocalStorage
@@ -3190,7 +3532,7 @@ declare class WorkflowContext<TInput = unknown> {
      * never start. Every accepted request emits one terminal event before a
      * continuation message or abort escapes this coordinator. */
     private observeToolInvocation;
-    ask<T = string>(agent: Agent, prompt: string, options?: AskOptions<T>): Promise<T>;
+    ask<T = string>(agent: Agent, prompt: ModelInput, options?: AskOptions<T>): Promise<T>;
     private executeAgentCall;
     /**
      * Push the final assistant message into session history, preserving providerMetadata
@@ -3372,7 +3714,10 @@ declare class WorkflowContext<TInput = unknown> {
      * @param prompt - The prompt to send to the selected agent
      * @param options - Optional: schema, routerModel, metadata, retries
      */
-    delegate<T = string>(agents: Agent[], prompt: string, options?: DelegateOptions<T>): Promise<T>;
+    delegate<T = string>(agents: Agent[], prompt: ModelInput, options?: DelegateOptions<T>): Promise<T>;
+    /** Transcribe recorded audio through the dedicated transcription registry.
+     * This operation never enters the chat history or chat-provider path. */
+    transcribe(request: TranscriptionRequest): Promise<Transcript>;
     /**
      * Internal emitter input — intentionally loose so call sites don't need to
      * build a perfectly-narrowed discriminated-union member. The resulting
@@ -3595,7 +3940,7 @@ declare class AxlStream extends Readable implements AsyncIterable<AxlEvent> {
     /** Signal an error. `executionId` is required for the same reason as
      *  `_done`: terminal events must carry a real id even when the
      *  failure happens before any real trace event fires (review S4). */
-    _error(error: Error, executionId: string): void;
+    _error(error: Error, executionId: string, observerMessage?: string, observerName?: string): void;
     /** Concatenated root-only text from committed attempts plus the
      *  current in-flight attempt(s). Retried (gate-rejected) attempts
      *  are excluded — see spec/16 §4.3. Reading mid-attempt returns the
@@ -3782,6 +4127,7 @@ declare class AxlRuntime extends EventEmitter {
     private tools;
     private agents;
     private providerRegistry;
+    private transcriptionProviderRegistry;
     private stateStore;
     private executions;
     private pendingDecisionResolvers;
@@ -3974,6 +4320,8 @@ declare class AxlRuntime extends EventEmitter {
     createContext(options?: CreateContextOptions): WorkflowContext;
     /** Register a custom provider instance. */
     registerProvider(name: string, provider: Provider): void;
+    /** Register a dedicated transcription adapter. It is never used for chat. */
+    registerTranscriptionProvider(name: string, provider: TranscriptionProvider): void;
     /** Resolve a provider:model URI to a Provider instance and model name. */
     resolveProvider(uri: string): {
         provider: Provider;
@@ -4487,7 +4835,7 @@ declare function stringStreamFromEvents(source: AsyncIterable<AxlEvent>, opts?:
  * tuple so exhaustiveness fixtures can cross-check against
  * `AXL_EVENT_TYPES`.
  */
-declare const COST_BEARING_LEAF_TYPES: readonly ["agent_call_end", "tool_call_end", "memory_remember", "memory_recall"];
+declare const COST_BEARING_LEAF_TYPES: readonly ["agent_call_end", "tool_call_end", "memory_remember", "memory_recall", "transcription_end"];
 /**
  * True when an event reports a POSITIVE token count — i.e. it did measurable,
  * billable work. This is the discriminator the unpriced-cost signal (T2.5) uses:
@@ -4506,6 +4854,18 @@ declare function hasPositiveTokens(event: {
         cacheWrite?: number;
     } | null;
 }): boolean;
+/** Audio duration is independently billable work even when a provider exposes
+ * no token count. Kept alongside token accounting so unpriced duration cannot
+ * silently look like a free operation. */
+declare function hasPositiveBillableWork(event: {
+    tokens?: Parameters<typeof hasPositiveTokens>[0]['tokens'];
+    data?: {
+        usage?: {
+            audioSeconds?: number;
+            totalTokens?: number;
+        };
+    } | null;
+}): boolean;
 /**
  * True when a cost value is usable for accounting: a finite, non-negative
  * number. A NON-usable cost (`undefined`, `NaN`, `Infinity`, negative) on a
@@ -4635,39 +4995,6 @@ declare function getExecutionEventSchemaVersion(execution: {
  */
 declare function normalizeStoredExecution(execution: HistoricalExecutionInfo): HistoricalExecutionInfo;
 
-/**
- * Per-variant redaction rules for `AxlEvent`.
- *
- * `config.trace.redact` is an observability-boundary filter that scrubs
- * user/LLM content from events before they reach consumers. Two layers
- * historically applied this filter independently:
- *
- *   1. Core: `WorkflowContext.emitEvent()` — emit-time scrub before `onTrace`.
- *   2. Studio: `redactStreamEvent()` — wire-boundary scrub before WS broadcast
- *      and again at REST serialization (`redactExecutionInfo`).
- *
- * Both layers walked the same `AxlEvent` discriminated union, with separate
- * if/else and switch/case ladders. Adding a new variant required updating
- * both. They had drifted: WS missed `workflow_start`/`workflow_end`,
- * `log`, and the full `memory_*` walk that core applied. Defense-in-depth
- * also broke for runtimes that flipped `redact` after emitting events —
- * REST reads of stored `ExecutionInfo.events` would leak fields the WS
- * layer didn't know to scrub.
- *
- * `REDACTION_RULES` is the single source of truth: a `Record<AxlEventType,
- * RuleFor<...>>` so adding a new variant to `AXL_EVENT_TYPES` without a
- * corresponding entry is a typecheck error. Every rule is pure (no
- * mutation), so the same rule runs at emit time and at the wire boundary
- * with identical results.
- *
- * Numeric/structural fields (`cost`, `tokens`, `duration`, `askId`,
- * `parentAskId`, `depth`, `agent`, `executionId`, `step`, `timestamp`,
- * `callId`, `tool`, `model`, `workflow`) are NEVER scrubbed — they're
- * non-PII observability metadata and load-bearing for cost rails. Rules
- * preserve these by spreading `{ ...event }` and only overriding the
- * specific user-content field(s) for that variant.
- */
-
 declare const REDACTED = "[redacted]";
 type RuleFor<T extends AxlEventType> = (event: AxlEventOf<T>) => AxlEventOf<T>;
 type V2ToolEventType = ToolLifecycleEventV2['type'];
@@ -4684,6 +5011,126 @@ declare const REDACTION_RULES: {
     tool_call_rejected: V2ToolRule<"tool_call_rejected">;
     workflow_start: RuleFor<"workflow_start">;
     workflow_end: RuleFor<"workflow_end">;
+    transcription_start: (e: AxlEventBase & {
+        schemaVersion: 2;
+        type: "transcription_start";
+        transcriptionId: string;
+        model?: string;
+        data: {
+            provider?: string;
+            model?: string;
+            audio: {
+                source: string;
+                bytes?: number;
+                mediaType?: string;
+            };
+        };
+    }) => AxlEventBase & {
+        schemaVersion: 2;
+        type: "transcription_start";
+        transcriptionId: string;
+        model?: string;
+        data: {
+            provider?: string;
+            model?: string;
+            audio: {
+                source: string;
+                bytes?: number;
+                mediaType?: string;
+            };
+        };
+    };
+    transcription_end: (e: AxlEventBase & {
+        schemaVersion: 2;
+        type: "transcription_end";
+        transcriptionId: string;
+        model?: string;
+        duration: number;
+        cost?: number;
+        tokens?: {
+            input?: number;
+            output?: number;
+        };
+        data: {
+            status: "completed" | "failed" | "aborted";
+            provider?: string;
+            model?: string;
+            audio?: {
+                source: string;
+                bytes?: number;
+                mediaType?: string;
+            };
+            text?: string;
+            usage?: {
+                audioSeconds?: number;
+                inputTokens?: number;
+                outputTokens?: number;
+                totalTokens?: number;
+                cost?: number;
+            };
+            pricingStatus?: "priced" | "unpriced" | "zero";
+            cleanupStatus?: "not_required" | "deleted" | "failed" | "timed_out";
+            error?: string;
+            errorCode?: "TRANSCRIPTION_PROVIDER_ERROR";
+            providerError?: {
+                status: number;
+                retryable: boolean;
+                retryAfterMs?: number;
+                requestId?: string;
+            };
+        };
+    }) => {
+        data: {
+            error?: string;
+            text?: string;
+            status: "completed" | "failed" | "aborted";
+            provider?: string;
+            model?: string;
+            audio?: {
+                source: string;
+                bytes?: number;
+                mediaType?: string;
+            };
+            usage?: {
+                audioSeconds?: number;
+                inputTokens?: number;
+                outputTokens?: number;
+                totalTokens?: number;
+                cost?: number;
+            };
+            pricingStatus?: "priced" | "unpriced" | "zero";
+            cleanupStatus?: "not_required" | "deleted" | "failed" | "timed_out";
+            errorCode?: "TRANSCRIPTION_PROVIDER_ERROR";
+            providerError?: {
+                status: number;
+                retryable: boolean;
+                retryAfterMs?: number;
+                requestId?: string;
+            };
+        };
+        executionId: string;
+        step: number;
+        timestamp: number;
+        workflow?: string;
+        agent?: string;
+        model?: string;
+        promptVersion?: string;
+        cost?: number;
+        tokens?: ({
+            input?: number;
+            output?: number;
+            reasoning?: number;
+            cached?: number;
+            cacheWrite?: number;
+        } & {
+            input?: number;
+            output?: number;
+        }) | undefined;
+        duration: number;
+        schemaVersion: 2;
+        type: "transcription_end";
+        transcriptionId: string;
+    };
     ask_start: RuleFor<"ask_start">;
     ask_end: RuleFor<"ask_end">;
     agent_call_start: RuleFor<"agent_call_start">;
@@ -4837,6 +5284,12 @@ declare class OpenAIProvider extends OpenAICompatibleProvider {
  */
 declare class OpenAIResponsesProvider implements Provider {
     readonly name = "openai-responses";
+    inputCapabilities(model: string): {
+        image?: {
+            sources: readonly InputMediaSource['type'][];
+        };
+    };
+    validateInput(request: ProviderInputValidationRequest): ProviderInputValidationResult;
     /** The Responses API honors `json_schema` (structured outputs) natively. */
     nativeStructuredOutputSupport(): 'schema';
     private baseUrl;
@@ -4867,6 +5320,8 @@ declare class OpenAIResponsesProvider implements Provider {
      */
     private mapResponseFormat;
     private parseResponse;
+    /** Responses usage does not report a media-inclusive price, so rich calls stay unpriced. */
+    private requestContainsImages;
     private parseSSEStream;
     private handleStreamEvent;
     private extractErrorMessage;
@@ -4887,6 +5342,12 @@ declare class OpenAIResponsesProvider implements Provider {
  */
 declare class AnthropicProvider implements Provider {
     readonly name = "anthropic";
+    inputCapabilities(model: string): {
+        image?: {
+            sources: readonly InputMediaSource['type'][];
+        };
+    };
+    validateInput(request: ProviderInputValidationRequest): ProviderInputValidationResult;
     /** Anthropic ignores native `json_schema` structurally — Axl uses a system
      *  prompt JSON instruction + client-side Zod validation (see buildRequest). */
     nativeStructuredOutputSupport(): 'unsupported';
@@ -4957,6 +5418,12 @@ declare class AnthropicProvider implements Provider {
  */
 declare class GeminiProvider implements Provider {
     readonly name = "google";
+    inputCapabilities(model: string): {
+        image?: {
+            sources: readonly InputMediaSource['type'][];
+        };
+    };
+    validateInput(request: ProviderInputValidationRequest): ProviderInputValidationResult;
     /** Gemini accepts a `responseSchema` but `sanitizeSchemaForGemini` strips
      *  keywords it doesn't support (`$ref`/`$defs`/`additionalProperties`/…), so a
      *  derived schema can lose constraints — lossy, not faithful. */
@@ -4975,6 +5442,14 @@ declare class GeminiProvider implements Provider {
     private resolveKey;
     chat(messages: ChatMessage[], options: ChatOptions): Promise<ProviderResponse>;
     stream(messages: ChatMessage[], options: ChatOptions): AsyncGenerator<StreamChunk>;
+    private chatInteraction;
+    private streamInteraction;
+    private buildInteractionRequestBody;
+    private assertSafeInteractionOptions;
+    private mapInteractionInput;
+    private parseInteractionResponse;
+    private parseInteractionSSEStream;
+    private assertInteractionTerminalStatus;
     private buildHeaders;
     private extractErrorMessage;
     private pricingContext;
@@ -5126,6 +5601,64 @@ declare const SGLANG_PROFILE: ProviderProfile;
  */
 declare const BUILTIN_PROFILES: ProviderProfile[];
 
+declare class OpenAITranscriptionProvider implements TranscriptionProvider {
+    readonly name = "openai-transcription";
+    private readonly baseUrl;
+    private readonly apiKeySource;
+    private readonly governor?;
+    constructor(options?: {
+        apiKey?: ApiKeySource;
+        baseUrl?: string;
+        dangerouslyAllowInsecureHttp?: boolean;
+        rateLimit?: RateLimitConfig;
+    });
+    capabilities(model: string): TranscriptionCapabilities | undefined;
+    transcribe(request: TranscriptionProviderRequest): Promise<TranscriptionProviderResult>;
+    private resolveKey;
+}
+
+declare class GeminiTranscriptionProvider implements TranscriptionProvider {
+    readonly name = "gemini-transcription";
+    private readonly baseUrl;
+    private readonly apiKeySource;
+    private readonly governor?;
+    constructor(options?: {
+        apiKey?: ApiKeySource;
+        baseUrl?: string;
+        dangerouslyAllowInsecureHttp?: boolean;
+        rateLimit?: RateLimitConfig;
+    });
+    capabilities(model: string): TranscriptionCapabilities | undefined;
+    transcribe(request: TranscriptionProviderRequest): Promise<TranscriptionProviderResult>;
+    private transcribeReference;
+    private transcribeUpload;
+    /** A finalization response with a name creates a caller-owned cleanup obligation
+     * even when its URI/state is malformed. `transcribeUpload` stores the name before
+     * strictly parsing the rest of the file representation. */
+    private upload;
+    private waitForReady;
+    private infer;
+    private fileFromJson;
+    private cleanup;
+    private resolveKey;
+}
+
+declare class OpenRouterTranscriptionProvider implements TranscriptionProvider {
+    readonly name = "openrouter-transcription";
+    private readonly baseUrl;
+    private readonly apiKeySource;
+    private readonly governor?;
+    constructor(options?: {
+        apiKey?: ApiKeySource;
+        baseUrl?: string;
+        dangerouslyAllowInsecureHttp?: boolean;
+        rateLimit?: RateLimitConfig;
+    });
+    capabilities(model: string): TranscriptionCapabilities | undefined;
+    transcribe(request: TranscriptionProviderRequest): Promise<TranscriptionProviderResult>;
+    private resolveKey;
+}
+
 /**
  * In-memory implementation of StateStore.
  * Fast for development and testing, but lost on process restart.
@@ -5576,4 +6109,4 @@ declare class NoopSpanManager implements SpanManager {
  */
 declare function createSpanManager(config?: TelemetryConfig): Promise<SpanManager>;
 
-export { AXL_EVENT_TYPES, AXL_EVENT_TYPES_V2, AXL_TOOL_LIFECYCLE_TYPES_V2, AZURE_PROFILE, type Agent, type AgentCallEndData, type AgentCallInfo, type AgentCallParams, type AgentCallStartData, type AgentConfig, AnthropicProvider, type AnyWorkflow, type ApiKeySource, type AskOptions, type AskScoped, type AuthHeader, type AwaitHumanData, type AwaitHumanOptions, type AwaitHumanResolvedData, type AxlConfig, AxlError, type AxlEvent, type AxlEventBase, AxlEventBus, type AxlEventOf, type AxlEventType, type AxlEventV2, type AxlEventV2Of, AxlRuntime, AxlStream, BEDROCK_PROFILE, BUILTIN_PROFILES, BudgetExceededError, type BudgetOptions, type BudgetResult, CONFIG_CANDIDATES, COST_BEARING_LEAF_TYPES, type CapabilityFlags, type ChatMessage, type ChatOptions, type CheckpointEventData, type CoalescedPartialObject, type CreateContextOptions, DEEPSEEK_PROFILE, type DecisionCleanupFailedEvent, type DelegateData, type DelegateOptions, type Effort, type EmbedResult, type EmbedUsage, type Embedder, type EvalExecuteWorkflow, type EvalHistoryEntry, type EventStreamOptions, EventStreamOverflowError, type ExecuteOptions, type ExecutionInfo, type ExecutionInfoV1, type ExecutionInfoV2, type ExecutionState, GROQ_PROFILE, GeminiProvider, type GuardrailBlockHandler, type GuardrailData, GuardrailError, type GuardrailResult, type GuardrailsConfig, type HandoffDescriptor, type HandoffRecord, type HandoffReturnData, type HandoffStartData, type HistoricalAxlEvent, type HistoricalExecutionInfo, type HumanDecision, InMemoryVectorStore, type InputGuardrail, LLAMACPP_PROFILE, LMSTUDIO_PROFILE, type LegacyAxlEventV1, type LegacyExecutionInfoV1, MISTRAL_PROFILE, type MapOptions, MaxTurnsError, McpManager, type McpServer, type McpServerConfig, type McpToolDefinition, type McpToolResult, type MemoryConfig, type MemoryEventData, MemoryManager, MemoryStore, NoConsensus, NoopSpanManager, OLLAMA_PROFILE, OPENAI_PRICING, OPENAI_PROFILE, OPENROUTER_PROFILE, type ObservationStatus, type OpenAICompatibleOptions, OpenAICompatibleProvider, OpenAIEmbedder, OpenAIProvider, OpenAIResponsesProvider, type OutputGuardrail, type OutputValidator, type PendingDecision, type PerModel, type PricingSource, type PricingTable, type Provider, type ProviderAdapter, ProviderError, type ProviderProfile, ProviderRegistry, type ProviderResponse, QuorumNotMet, REDACTED, REDACTION_RULES, type RaceOptions, type RateLimitConfig, RateLimiter, type ReasoningCapture, type ReasoningEmit, type ReasoningProfile, type ReasoningRoundTrip, type RecallOptions, type RecallResult, RedisStore, type RememberOptions, type RememberResult, type ResolvedThinkingOptions, type Result, type RetryPolicy, SGLANG_PROFILE, SQLiteStore, type SchemaCheckData, type SchemaDiagnosticData, type SchemaPromptOption, Session, type SessionOptions, type SpanHandle, type SpanManager, type SpawnOptions, SqliteVectorStore, type StateStore, type StreamChunk, type StringDeltaData, type StringStreamEvent, type StringStreamFilter, type TelemetryConfig, ThinkTagScanner, TimeoutError, type Tool, type ToolApprovalData, type ToolArgumentIssue, type ToolCallCancellation, type ToolCallData, type ToolCallEndData, type ToolCallFailure, type ToolCallMessage, type ToolCallOutcome, type ToolCallRejectedData, type ToolCallRejectedEvent, type ToolCallStartData, type ToolCallStartDataV2, type ToolChoice, type ToolConfig, type ToolDeniedData, type ToolEventError, ToolFailure, type ToolFailureConstructor, type ToolFailureOptions, type ToolHooks, type ToolLifecycleEventV2, type ToolModelOutput, ToolModelOutputError, UnsupportedEventSchemaVersionError, VLLM_PROFILE, type ValidateData, type ValidateResult, ValidationError, type VectorEntry, type VectorResult, type VectorStore, type VerifyData, VerifyError, type VerifyOptions, type VerifyRetry, type VoteOptions, type Workflow, type WorkflowConfig, WorkflowContext, type WorkflowContextInit, type WorkflowEndData, type WorkflowStartData, XAI_PROFILE, agent, createSpanManager, defineConfig, estimateOpenAICost, eventCostContribution, expandGlob, extractJson, extractThinkTags, findConfig, getEventSchemaVersion, getExecutionEventSchemaVersion, hasPositiveTokens, importModule, isCostBearingLeaf, isRetryableStatus, isRootLevel, isUnpricedLeaf, isUsableCost, needsTsxLoader, normalizeStoredExecution, openaiReasoningEmit, parsePartialJson, pickDefault, pickExport, priceFromTable, reasoningEffortEmit, reasoningObjectEmit, redactEvent, redactHistoricalEvent, registerConditions, resolveApiKey, resolvePerModel, resolveRuntime, resolveThinkingOptions, stringStreamFromEvents, tool, workflow, zodToJsonSchema };
+export { AXL_EVENT_TYPES, AXL_EVENT_TYPES_V2, AXL_TOOL_LIFECYCLE_TYPES_V2, AZURE_PROFILE, type Agent, type AgentCallEndData, type AgentCallInfo, type AgentCallParams, type AgentCallStartData, type AgentConfig, AnthropicProvider, type AnyWorkflow, type ApiKeySource, type AskOptions, type AskScoped, type AuthHeader, type AwaitHumanData, type AwaitHumanOptions, type AwaitHumanResolvedData, type AxlConfig, AxlError, type AxlEvent, type AxlEventBase, AxlEventBus, type AxlEventOf, type AxlEventType, type AxlEventV2, type AxlEventV2Of, AxlRuntime, AxlStream, BEDROCK_PROFILE, BUILTIN_PROFILES, BudgetExceededError, type BudgetOptions, type BudgetResult, CONFIG_CANDIDATES, COST_BEARING_LEAF_TYPES, type CapabilityFlags, type ChatMessage, type ChatOptions, type CheckpointEventData, type CoalescedPartialObject, type CreateContextOptions, DEEPSEEK_PROFILE, type DecisionCleanupFailedEvent, type DelegateData, type DelegateOptions, type Effort, type EmbedResult, type EmbedUsage, type Embedder, type EvalExecuteWorkflow, type EvalHistoryEntry, type EventStreamOptions, EventStreamOverflowError, type ExecuteOptions, type ExecutionInfo, type ExecutionInfoV1, type ExecutionInfoV2, type ExecutionState, GROQ_PROFILE, GeminiProvider, GeminiTranscriptionProvider, type GuardrailBlockHandler, type GuardrailData, GuardrailError, type GuardrailResult, type GuardrailsConfig, type HandoffDescriptor, type HandoffRecord, type HandoffReturnData, type HandoffStartData, type HistoricalAxlEvent, type HistoricalExecutionInfo, type HumanDecision, InMemoryVectorStore, type InputContentPart, type InputGuardrail, type InputImagePart, type InputMediaSource, type InputModalitySupport, type InputTextPart, InvalidModelInputError, InvalidTranscriptionInputError, LLAMACPP_PROFILE, LMSTUDIO_PROFILE, type LegacyAxlEventV1, type LegacyExecutionInfoV1, MAX_INLINE_MODEL_INPUT_BYTES, MAX_INLINE_TRANSCRIPTION_BYTES, MISTRAL_PROFILE, type MapOptions, MaxTurnsError, McpManager, type McpServer, type McpServerConfig, type McpToolDefinition, type McpToolResult, type MemoryConfig, type MemoryEventData, MemoryManager, MemoryStore, type ModelInput, type ModelInputDescriptor, NoConsensus, NoopSpanManager, OLLAMA_PROFILE, OPENAI_PRICING, OPENAI_PROFILE, OPENROUTER_PROFILE, type ObservationStatus, type OpenAICompatibleOptions, OpenAICompatibleProvider, OpenAIEmbedder, OpenAIProvider, OpenAIResponsesProvider, OpenAITranscriptionProvider, OpenRouterTranscriptionProvider, type OutputGuardrail, type OutputValidator, type PendingDecision, type PerModel, type PricingSource, type PricingTable, type Provider, type ProviderAdapter, ProviderError, type ProviderInputValidationRequest, type ProviderInputValidationResult, type ProviderProfile, ProviderRegistry, type ProviderResponse, QuorumNotMet, REDACTED, REDACTION_RULES, type RaceOptions, type RateLimitConfig, RateLimiter, type ReasoningCapture, type ReasoningEmit, type ReasoningProfile, type ReasoningRoundTrip, type RecallOptions, type RecallResult, type RecordedAudioSource, RedisStore, type RememberOptions, type RememberResult, type ResolvedThinkingOptions, type Result, type RetryPolicy, SGLANG_PROFILE, SQLiteStore, type SchemaCheckData, type SchemaDiagnosticData, type SchemaPromptOption, Session, type SessionOptions, type SpanHandle, type SpanManager, type SpawnOptions, SqliteVectorStore, type StateStore, type StreamChunk, type StringDeltaData, type StringStreamEvent, type StringStreamFilter, type TelemetryConfig, ThinkTagScanner, TimeoutError, type Tool, type ToolApprovalData, type ToolArgumentIssue, type ToolCallCancellation, type ToolCallData, type ToolCallEndData, type ToolCallFailure, type ToolCallMessage, type ToolCallOutcome, type ToolCallRejectedData, type ToolCallRejectedEvent, type ToolCallStartData, type ToolCallStartDataV2, type ToolChoice, type ToolConfig, type ToolDeniedData, type ToolEventError, ToolFailure, type ToolFailureConstructor, type ToolFailureOptions, type ToolHooks, type ToolLifecycleEventV2, type ToolModelOutput, ToolModelOutputError, type Transcript, type TranscriptionCapabilities, TranscriptionOperationError, type TranscriptionProvider, TranscriptionProviderRegistry, type TranscriptionProviderRequest, type TranscriptionProviderResult, type TranscriptionRequest, UnsupportedEventSchemaVersionError, UnsupportedModelInputError, UnsupportedTranscriptionInputError, VLLM_PROFILE, type ValidateData, type ValidateResult, ValidationError, type VectorEntry, type VectorResult, type VectorStore, type VerifyData, VerifyError, type VerifyOptions, type VerifyRetry, type VoteOptions, type Workflow, type WorkflowConfig, WorkflowContext, type WorkflowContextInit, type WorkflowEndData, type WorkflowStartData, XAI_PROFILE, agent, createSpanManager, defineConfig, estimateOpenAICost, eventCostContribution, expandGlob, extractJson, extractThinkTags, findConfig, getEventSchemaVersion, getExecutionEventSchemaVersion, hasPositiveBillableWork, hasPositiveTokens, importModule, inputText, isCostBearingLeaf, isRetryableStatus, isRootLevel, isUnpricedLeaf, isUsableCost, needsTsxLoader, normalizeStoredExecution, openaiReasoningEmit, parsePartialJson, pickDefault, pickExport, priceFromTable, reasoningEffortEmit, reasoningObjectEmit, redactEvent, redactHistoricalEvent, registerConditions, resolveApiKey, resolvePerModel, resolveRuntime, resolveThinkingOptions, stringStreamFromEvents, tool, workflow, zodToJsonSchema };