@fifthrevision/axle 0.29.0 → 0.30.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as ToolResultPart, A as TurnMetadata, At as SpanResult, B as Citation, C as ProviderToolAction, Ct as LLMRequest, Dt as SpanData, E as ThinkingPart, Et as Span, F as AxleAssistantMessage, Ft as TraceWriter, G as ContentPartFile, H as CitationSource, I as AxleMessage, J as ContentPartThinking, K as ContentPartProviderTool, L as AxleToolCallMessage, M as TurnStatus, Mt as SpanType, N as CompactionRecord, Nt as TokenUsage, O as ToolAction, Ot as SpanEvent, P as validateCompactedMessages, Pt as ToolResult, Q as ThinkingContinuity, R as AxleToolCallResult, S as FilePart, St as EventLevel, T as TextPart, Tt as LLMResult, U as ContentPart, V as CitationOutputSpan, W as ContentPartCitation, X as DocumentLocator, Y as ContentPartToolCall, Z as MessageMetadata, _ as Annotation, _t as ResolvedFileSource, at as ModelResult, b as CitationPart, bt as TokenStats, c as ToolContext, ct as ResolvedProviderTool, d as ToolRegistry, dt as FileInfo, et as AIProvider, f as AnnotationEvent, ft as FileKind, g as ActionResult, gt as FileResolver, h as ActionPart, ht as FileResolveRequest, i as TurnAccumulatorState, it as ModelError, j as TurnPart, jt as SpanStatus, k as Turn, kt as SpanOptions, l as ToolDefinition, lt as ToolChoice, m as TurnEvent, mt as FileResolveFormat, n as TurnAccumulator, nt as AxleStopReason, o as ExecutableTool, ot as ProviderClientOptions, p as AnnotationTarget, pt as FileProviderId, q as ContentPartText, r as TurnAccumulatorResult, rt as ContextUsage, s as ProviderTool, st as ProviderOptions, t as AccumulatableEvent, tt as AxleModelRequestOptions, u as ToolProgressChunk, ut as DeferredFileInfo, v as AnnotationPlacement, vt as loadFileContent, w as SubagentAction, wt as LLMResponse, x as CompactionPart, xt as UsageEntry, y as AnnotationStatus, yt as Stats, z as AxleUserMessage } from "./accumulator-e_1Eq0jB.js";
+import { $ as ThinkingContinuity, At as SpanOptions, B as AxleUserMessage, C as CompactionPart, Ct as EventLevel, D as SubagentAction, Dt as Span, E as ProviderToolAction, Et as LLMResult, F as TurnStatus, Ft as ToolResult, G as ContentPartCitation, H as CitationOutputSpan, I as AxleAssistantMessage, It as TraceWriter, J as ContentPartText, K as ContentPartFile, L as AxleMessage, M as Turn, Mt as SpanStatus, N as TurnMetadata, Nt as SpanType, O as TextPart, Ot as SpanData, P as TurnPart, Pt as TokenUsage, Q as MessageMetadata, R as AxleToolCallMessage, S as CitationPart, St as UsageEntry, T as FilePart, Tt as LLMResponse, U as CitationSource, V as Citation, W as ContentPart, X as ContentPartToolCall, Y as ContentPartThinking, Z as DocumentLocator, _ as ActionPart, _t as FileResolver, a as CompactionStamp, at as ModelError, b as AnnotationPlacement, bt as Stats, c as ExecutableTool, ct as ProviderOptions, d as ToolDefinition, dt as DeferredFileInfo, et as ToolResultPart, f as ToolProgressChunk, ft as FileInfo, g as TurnEvent, gt as FileResolveRequest, h as AnnotationTarget, ht as FileResolveFormat, it as ContextUsage, j as ToolAction, jt as SpanResult, k as ThinkingPart, kt as SpanEvent, l as ProviderTool, lt as ResolvedProviderTool, m as AnnotationEvent, mt as FileProviderId, n as TranscriptApplyResult, nt as AxleModelRequestOptions, o as getCompactionStamp, ot as ModelResult, p as ToolRegistry, pt as FileKind, q as ContentPartProviderTool, r as TranscriptInput, rt as AxleStopReason, s as validateCompactedMessages, st as ProviderClientOptions, t as Transcript, tt as AIProvider, u as ToolContext, ut as ToolChoice, v as ActionResult, vt as ResolvedFileSource, w as CompactionUpdate, wt as LLMRequest, x as AnnotationStatus, xt as TokenStats, y as Annotation, yt as loadFileContent, z as AxleToolCallResult } from "./transcript-D69LP3XR.js";
 import * as z$2 from "zod";
 import { ZodObject, z } from "zod";
 
@@ -99,6 +99,10 @@ declare function parseResponse<T extends OutputSchema>(rawValue: string, schema?
 //#region src/core/Instruct.d.ts
 type InstructInputs = Record<string, unknown>;
 type InstructVarsMode = "required" | "optional";
+interface InstructRenderOptions {
+  vars?: InstructVarsMode;
+}
+type InstructResponse<TSchema extends OutputSchema | undefined> = TSchema extends OutputSchema ? ParsedSchema<TSchema> : string;
 interface InstructContextSection {
   content: string;
   title?: string;
@@ -135,103 +139,12 @@ declare class Instruct<TSchema extends OutputSchema | undefined = undefined> {
     title?: string;
   }): this;
   hasFiles(): boolean;
-  render(options?: {
-    vars?: InstructVarsMode;
-  }): string;
-}
-//#endregion
-//#region src/core/agent/history.d.ts
-/**
- * Complete state for constructing a `History`. Reconstructing from a saved
- * session goes through the constructor — there is no field-by-field mutation.
- */
-interface HistoryInit<TAnnotation extends Annotation = Annotation> {
-  turns?: Turn<TAnnotation>[];
-  messages?: AxleMessage[];
-  archive?: AxleMessage[];
-  compactions?: CompactionRecord[];
-  sessionAnnotations?: TAnnotation[];
-}
-/**
- * In-memory conversation and presentation state for an agent.
- *
- * All state is private; reads return copies and writes go through
- * use-case-specific methods:
- *
- * - `messages` — the active, model-facing conversation. Requests are built
- *   from it; compaction replaces it.
- * - `archive` — every message ever appended, in order, untouched by
- *   compaction. The chronological record, for inspection only.
- * - `turns` — the renderable session turns: user/agent entries and compaction entries.
- *   Forever-accumulating; consumers decide how to render or prune it.
- * - `compactions` — receipts for each applied compaction.
- * - `sessionAnnotations` — session-level render annotations.
- *
- * @typeParam TAnnotation - Annotation union supported by the host renderer.
- */
-declare class History<TAnnotation extends Annotation = Annotation> {
-  private _turns;
-  private _messages;
-  private _archive;
-  private _compactions;
-  private _sessionAnnotations;
-  constructor(init?: HistoryInit<TAnnotation>);
-  get turns(): Turn<TAnnotation>[];
-  get messages(): AxleMessage[];
-  get archive(): AxleMessage[];
-  get compactions(): CompactionRecord[];
-  get sessionAnnotations(): TAnnotation[];
-  /**
-   * Append conversation messages. Every appended message goes to both the
-   * active conversation and the archive, so the archive is always the
-   * complete chronological record regardless of compaction.
-   *
-   * @internal The Agent is History's only writer. Direct writes bypass the
-   * work queue and the event fold, desynchronizing engine state.
-   */
-  append(messages: AxleMessage | AxleMessage[]): void;
-  /**
-   * Replace the renderable turn state wholesale. Used to sync the
-   * accumulated state after applying a turn event.
-   *
-   * @internal The Agent is History's only writer. External writes are
-   * overwritten by the agent's accumulator on the next event.
-   */
-  replaceTurns(turns: Turn<TAnnotation>[], sessionAnnotations: TAnnotation[]): void;
-  /**
-   * Apply a compaction: the new state replaces the active conversation and
-   * the record is kept. The archive is untouched — it already holds
-   * everything ever appended. The corresponding compaction turn arrives
-   * through the event fold, not here.
-   *
-   * @internal The Agent is History's only writer; use `agent.compact()`.
-   * @experimental Compaction is under active design and may change in any release.
-   */
-  compact(messages: AxleMessage[], record: CompactionRecord): void;
-}
-//#endregion
-//#region src/memory/types.d.ts
-interface MemoryContext {
-  /** Optional agent name provided by the host. */
-  agentName?: string;
-  /** Stable conversation/session id from the agent. */
-  sessionId: string;
-  /** Current system prompt, before memory augmentation. */
-  system?: string;
-  /** Full message context available for recall or extraction. */
-  messages: AxleMessage[];
-  /** Newly produced messages to record after a turn completes. */
-  newMessages?: AxleMessage[];
-  /** Optional tracing context. */
-  span?: Span;
-}
-interface RecallResult {
-  systemSuffix?: string;
-}
-interface AgentMemory {
-  recall(context: MemoryContext): Promise<RecallResult>;
-  record(context: MemoryContext): Promise<void>;
-  tools?(): ExecutableTool[];
+  toMessage(options?: {
+    metadata?: MessageMetadata;
+  }): AxleUserMessage;
+  parse(final: AxleAssistantMessage | undefined): InstructResponse<TSchema> | null;
+  validate(options?: InstructRenderOptions): void;
+  render(options?: InstructRenderOptions): string;
 }
 //#endregion
 //#region src/observability/log.d.ts
@@ -431,7 +344,7 @@ interface AgentConfig extends Omit<AxleModelRequestOptions, "signal"> {
   sessionId?: string;
   /** Optional system/developer instruction. */
   system?: string;
-  /** Optional agent name passed to host services such as memory. */
+  /** Optional agent name. */
   name?: string;
   /** Executable tools available to the agent. */
   tools?: ExecutableTool[];
@@ -439,8 +352,6 @@ interface AgentConfig extends Omit<AxleModelRequestOptions, "signal"> {
   providerTools?: ProviderTool[];
   /** MCP clients whose tools should be lazily resolved. */
   mcps?: MCP[];
-  /** Optional memory implementation. */
-  memory?: AgentMemory;
   /** Observability: structured logging and optional span tracing. */
   observability?: ObservabilityOptions;
   /** Optional file resolver for request file references. */
@@ -503,13 +414,13 @@ interface AgentDefinitionRequestOptions extends Omit<AxleModelRequestOptions, "s
  *
  * This is deliberately not executable by itself. Hosts resolve provider and
  * tool references into runtime objects using an `AgentDefinitionResolver`.
- * Harness concerns such as memory implementations, file resolvers, tracing,
- * transport, and stores should be modeled outside this core definition.
+ * Harness concerns such as file resolvers, tracing, transport, and stores
+ * should be modeled outside this core definition.
  */
 interface AgentDefinition {
   /** Agent definition schema version. */
   version: 1;
-  /** Optional agent name passed to host services such as memory. */
+  /** Optional agent name. */
   name?: string;
   /** Provider reference resolved by the host. */
   provider: ProviderDefinition;
@@ -547,40 +458,31 @@ interface ResolvedAgentDefinition {
  */
 type AgentDefinitionResolver = (definition: AgentDefinition) => MaybePromise<ResolvedAgentDefinition>;
 /**
- * Serializable continuation and presentation state for an `Agent`.
- *
- * This is the data needed to continue a model conversation and restore the
- * renderable turn state. It intentionally does not include executable runtime
- * objects such as providers, tools, MCP clients, memory implementations, file
- * resolvers, or tracers. Recreate those from host-owned configuration, then
- * construct a new agent with the session: `new Agent(config, session)`.
+ * Serializable continuation state for an `Agent`: the pure model-facing
+ * conversation, nothing else.
  *
- * @typeParam TAnnotation - Annotation union supported by the host renderer.
+ * It intentionally does not include executable runtime objects (providers,
+ * tools, MCP clients, file resolvers, tracers) or renderable turn
+ * state — transcripts are folds of the event stream owned by the host; persist
+ * your `Transcript.turns` alongside this if you want one back. Recreate
+ * runtime objects from host-owned configuration, then construct a new agent
+ * with the session: `new Agent(config, session)`. Unknown keys in stored
+ * sessions from older versions are ignored.
  */
-interface AgentSession<TAnnotation extends Annotation = Annotation> {
-  /** Agent session schema version. */
-  version: 1;
+interface AgentSession {
   /** Stable conversation/session id. */
   sessionId: string;
   /** Active model-facing conversation used for continuation. */
   messages: AxleMessage[];
-  /** Complete chronological record of every appended message, untouched by compaction. May be empty; absent in pre-compaction snapshots. */
-  archive?: AxleMessage[];
-  /** Compaction records, in order. Empty when no compaction has run; absent in pre-compaction snapshots. */
-  compactions?: CompactionRecord[];
-  /** Renderable turn state for exact UI restoration. */
-  turns?: Turn<TAnnotation>[];
-  /** Session-level annotations for generic renderer state. */
-  sessionAnnotations?: TAnnotation[];
 }
 /**
  * Serializable saved agent payload: definition plus continuation state.
  */
-interface SavedAgent<TAnnotation extends Annotation = Annotation> {
+interface SavedAgent {
   /** Serializable recipe used to reconstruct runtime config. */
   definition: AgentDefinition;
-  /** Serializable continuation and presentation state. */
-  session: AgentSession<TAnnotation>;
+  /** Serializable continuation state. */
+  session: AgentSession;
 }
 interface AgentResult<T = string> {
   ok: true;
@@ -599,37 +501,64 @@ interface AgentErrorResult {
 type AgentHandle<T = string> = Handle<AgentResult<T> | AgentErrorResult>;
 type TurnEventCallback = (event: TurnEvent) => void;
 /**
- * Caller-supplied compaction policy and strategy.
- *
- * The callback owns the decision: return `null` for "not now" (cheap — the
- * usage estimate is local), or the complete new active conversation. The
- * engine owns validation, record stamping, state processing, and event
- * emission.
+ * Compaction is split into three layers, each with one job: `triggers` say
+ * *when to ask automatically*, `shouldCompactOnTrigger` filters those
+ * automatic requests, and `compact` does the work.
  *
  * @experimental Compaction is under active design and may change in any release.
  */
-type CompactionTrigger = "manual" | "beforeTurn" | "afterTurn";
+type AutomaticCompactionTrigger = "beforeTurn" | "afterTurn";
+type CompactionTrigger = "manual" | AutomaticCompactionTrigger;
+/**
+ * The decision: should an automatically triggered compaction run now?
+ * Omitted on the config, every configured automatic trigger runs. Explicit
+ * `agent.compact()` calls bypass this policy. Keep it cheap; it runs on every
+ * configured automatic boundary and must return its boolean synchronously.
+ */
+type ShouldCompactOnTriggerCallback = (state: {
+  messages: AxleMessage[];
+}, context: {
+  usage: ContextUsage;
+  trigger: AutomaticCompactionTrigger;
+}) => boolean;
+/**
+ * The work: produce the complete new active conversation, and optionally a
+ * reader-facing `summary` for the transcript part. There is no decline path —
+ * declining automatic work is `shouldCompactOnTrigger`'s job — and failures
+ * throw. Publish transient display state through `ctx.emit`; updates replace
+ * fields on the running part and keep the event stream flowing during long
+ * summarizations.
+ *
+ * `summary` is a presentation choice, independent of the model-facing
+ * messages: it can be the summary text itself, or something else entirely
+ * ("Reduced the context by 50%"). Omitted, the latest emitted summary remains;
+ * without one, the part renders as a bare divider. Stamp output messages via `MessageMetadata`
+ * (`axleCompaction: { id, role }`, see `CompactionStamp`) so your own prior
+ * output is recognizable on later runs.
+ */
 type CompactionCallback = (state: {
   messages: AxleMessage[];
 }, context: {
   usage: ContextUsage;
   signal?: AbortSignal;
-  trigger: CompactionTrigger;
-  /**
-   * Receipt of the most recent applied compaction, when one exists. Its
-   * `messageCount` marks how many leading messages of `state.messages` are
-   * carried-over compacted content rather than live conversation.
-   */
-  lastCompaction?: CompactionRecord;
-}) => MaybePromise<AxleMessage[] | null>;
+  trigger: CompactionTrigger; /** Engine-generated id for this compaction; the emitted part shares it. */
+  id: string; /** Update transient reader-facing state on the running part. */
+  emit: (update: CompactionUpdate) => void;
+}) => MaybePromise<{
+  messages: AxleMessage[];
+  summary?: string;
+}>;
 /**
- * Compaction implementation and the turn boundaries that invoke it
- * automatically. Manual `agent.compact()` is always available.
+ * Compaction wiring: the work, the optional decision policy, and the turn
+ * boundaries that invoke them automatically. Manual `agent.compact()` is
+ * always available.
  *
  * @experimental Compaction is under active design and may change in any release.
  */
 interface CompactionConfig {
   compact: CompactionCallback;
+  /** Automatic-trigger policy. Absent = run at every configured trigger. */
+  shouldCompactOnTrigger?: ShouldCompactOnTriggerCallback;
   triggers?: {
     beforeTurn?: boolean;
     afterTurn?: boolean;
@@ -648,7 +577,6 @@ interface SendMessageOptions extends AxleModelRequestOptions {
 declare class Agent {
   readonly provider: AIProvider;
   readonly model: string;
-  readonly history: History;
   readonly name?: string;
   readonly fileResolver?: FileResolver;
   readonly requestOptions: Omit<AxleModelRequestOptions, "signal">;
@@ -657,7 +585,6 @@ declare class Agent {
   system: string | undefined;
   private mcps;
   private resolvedMcps;
-  private memory?;
   private spanParent?;
   private ownedTracer?;
   private eventCallbacks;
@@ -665,18 +592,22 @@ declare class Agent {
   private scheduler;
   private turnActive;
   private stopRequested;
-  private accumulator;
+  private transcript;
+  private messagesInternal;
   /**
    * Create an agent from runtime config and, optionally, restore saved session state.
    *
    * When both `config.sessionId` and `session.sessionId` are supplied, the
-   * restored session id wins.
+   * restored session id wins. Unknown keys in sessions stored by older axle
+   * versions are ignored.
    */
   constructor(config: AgentConfig, session?: AgentSession);
   addMcp(mcp: MCP): void;
   addMcps(mcps: MCP[]): void;
   hasTools(): boolean;
   on(callback: TurnEventCallback): () => void;
+  /** The active, model-facing conversation. Requests are built from it; compaction replaces it. */
+  get messages(): AxleMessage[];
   context(): ContextUsage;
   private estimateContext;
   /** Schedule a FIFO conversation turn. */
@@ -702,7 +633,6 @@ declare class Agent {
    */
   clear(): number;
   private executeTurn;
-  private run;
   private resolveMcpTools;
   /**
    * Set the compaction implementation and its optional automatic triggers.
@@ -710,13 +640,15 @@ declare class Agent {
    */
   setCompaction(config: CompactionConfig): void;
   /**
-   * Run the registered compaction callback against the active conversation.
+   * Run the registered compaction against the active conversation.
    *
-   * Compaction is optional: with no callback registered this is a no-op that
-   * resolves `null`. Otherwise the call is enqueued behind in-flight sends so
-   * compaction never races a turn. The callback may return `null` to skip.
-   * Cancellation rejects with `AxleAgentAbortError`, matching `send()`;
-   * other errors propagate — a manual compact was explicitly requested.
+   * Compaction is optional: with no config registered this resolves `false`.
+   * Otherwise the call is enqueued behind in-flight sends so compaction never
+   * races a turn. Explicit compaction bypasses `shouldCompactOnTrigger`: the
+   * engine opens a turn, streams the `CompactionPart` in it, and resolves
+   * `true` once applied. Failures settle the part and turn as errored on the
+   * transcript and reject.
+   * Cancellation rejects with `AxleAgentAbortError`, matching `send()`.
    *
    * Do not await this from inside a running send (a tool's `execute`,
    * `onToolCall`, or a compaction callback): the send holds the queue, so the
@@ -724,28 +656,23 @@ declare class Agent {
    */
   compact(options?: {
     signal?: AbortSignal;
-  }): Promise<CompactionRecord | null>;
+  }): Promise<boolean>;
   private runCompaction;
   /**
    * Capture the serializable session state for later continuation.
    *
    * Enqueued behind in-flight sends and compactions, so the capture is
    * always at rest — a snapshot never contains a streaming or running turn.
-   * The returned object contains message history and renderable turn state,
-   * but not executable configuration such as providers, tools, MCP clients,
-   * memory, or tracers.
+   * The returned object is the pure continuation: session id and the active
+   * model-facing conversation. It contains no renderable turn state —
+   * transcripts are host-owned; persist your `Transcript.turns`
+   * alongside it.
    *
    * Do not await this from inside a running send (a tool's `execute`,
    * `onToolCall`, or a compaction callback): the send holds the queue, so the
    * nested call deadlocks.
    */
   snapshot(): Promise<AgentSession>;
-  /**
-   * The single write path for renderable turn state: every event folds
-   * through the agent-lifetime accumulator, History mirrors the result, and
-   * subscribers are notified. Engine-internal state and consumer-folded
-   * state agree by construction because they run the same fold.
-   */
   private emitEvent;
   private toToolDefinitions;
 }
@@ -756,14 +683,11 @@ declare class Agent {
  *
  * Core resolves only what it can safely construct from serializable data. The
  * host remains responsible for executable dependencies such as providers,
- * tools, and MCP clients. Harness runtime services such as memory and file
- * resolvers should be layered onto the returned config by the host.
+ * tools, and MCP clients. Harness runtime services such as file resolvers
+ * should be layered onto the returned config by the host.
  */
 declare function createAgentConfig(definition: AgentDefinition, resolver: AgentDefinitionResolver): Promise<AgentConfig>;
 //#endregion
-//#region src/core/userTurn.d.ts
-type InstructResponse<TSchema extends OutputSchema | undefined> = TSchema extends OutputSchema ? ParsedSchema<TSchema> : string;
-//#endregion
 //#region src/compaction/PromptCompactor.d.ts
 interface PromptCompactorOptions {
   provider: AIProvider;
@@ -774,7 +698,6 @@ interface PromptCompactorOptions {
   recentUserMessages?: number;
 }
 declare class PromptCompactor {
-  readonly compact: CompactionCallback;
   private readonly provider;
   private readonly model;
   private readonly prompt;
@@ -782,7 +705,8 @@ declare class PromptCompactor {
   private readonly targetTokens;
   private readonly recentUserMessages;
   constructor(options: PromptCompactorOptions);
-  private run;
+  readonly shouldCompactOnTrigger: ShouldCompactOnTriggerCallback;
+  readonly compact: CompactionCallback;
 }
 //#endregion
 //#region src/errors/AxleAgentAbortError.d.ts
@@ -1194,4 +1118,4 @@ declare function createStats(): Stats;
 declare function addStats(total: Stats, usage?: Stats): void;
 declare function mergeStats(...usages: Array<Stats | undefined>): Stats;
 //#endregion
-export { type AIProvider, type AccumulatableEvent, type ActionPart, type ActionResult, Agent, type AgentConfig, type AgentDefinition, type AgentDefinitionRequestOptions, type AgentDefinitionResolver, type AgentErrorResult, type AgentHandle, type AgentMemory, type AgentResult, type AgentSession, type Annotation, type AnnotationEvent, type AnnotationPlacement, type AnnotationStatus, type AnnotationTarget, AxleAbortError, AxleAgentAbortError, type AxleAssistantMessage, type AxleConfiguration, AxleError, type AxleFailure, type AxleMessage, type AxleModelRequestOptions, AxleStopReason, type AxleToolCallMessage, type AxleToolCallResult, AxleToolFatalError, type AxleUserMessage, type BraveWebSearchOptions, type ChatCompletionsOptions, type ChatCompletionsVendor, type Citation, type CitationOutputSpan, type CitationPart, type CitationSource, type CompactionCallback, type CompactionConfig, type CompactionPart, type CompactionRecord, type CompactionTrigger, type ContentPart, type ContentPartCitation, type ContentPartFile, type ContentPartProviderTool, type ContentPartText, type ContentPartThinking, type ContentPartToolCall, type ContextUsage, type CreateAgentToolOptions, type DeferredFileInfo, type DocumentLocator, type EventLevel, type ExecutableTool, type FileInfo, type FileKind, type FilePart, type FileProviderId, type FileResolveFormat, type FileResolveRequest, type FileResolver, type FileStore, type GenerateError, type GenerateInstructParams, type GenerateInstructResult, type GenerateParams, type GenerateResult, type Handle, History, Instruct, type InstructContextSection, type InstructInputs, type InstructOptions, type InstructResponse, InstructVariableError, type InstructVarsMode, type LLMRequest, type LLMResponse, type LLMResult, type LogEntry, type LogFn, LogWriter, MCP, type MCPConfig, type MCPHttpConfig, type MCPStdioConfig, type MaybePromise, type MemoryContext, type MessageMetadata, type ObservabilityOptions, type OutputSchema, type ParallelToolResult, type ParallelizeOptions, type ParsedSchema, PromptCompactor, type PromptCompactorOptions, type ProviderClientOptions, type ProviderDefinition, type ProviderOptions, type ProviderTool, type ProviderToolAction, type ProviderToolDefinitionRef, type RecallResult, type ResolvedAgentDefinition, type ResolvedFileSource, type SavedAgent, type SendMessageOptions, SimpleWriter, type SimpleWriterOptions, type Span, type SpanData, type SpanEvent, type SpanOptions, type SpanResult, type SpanStatus, type SpanType, type Stats, type StreamEvent, type StreamEventCallback, type StreamHandle, type StreamInstructHandle, type StreamInstructParams, type StreamInstructResult, type StreamParams, type StreamResult, type SubagentAction, TaskError, type TextPart, type ThinkingContinuity, type ThinkingPart, type TokenStats, type TokenUsage, type ToolAction, type ToolBatchCompleteCallback, type ToolChoice, type ToolContext, type ToolDefinition, type ToolDefinitionRef, type ToolProgressChunk, ToolRegistry, type ToolResult, type ToolResultPart, type TraceWriter, Tracer, type TracerOptions, type Turn, TurnAccumulator, type TurnAccumulatorResult, type TurnAccumulatorState, type TurnEvent, TurnEventBuilder, type TurnEventCallback, type TurnMetadata, type TurnPart, type TurnStatus, type UsageEntry, type WebSearchBackend, type WebSearchBackendContext, type WebSearchRequest, type WebSearchResponse, type WebSearchResult, addStats, anthropic, braveWebSearch, chatCompletions, configureAxle, createAgentConfig, createAgentTool, createStats, estimateContextUsage, gemini, generate, generateStep, loadFileContent, mergeStats, openai, parallelize, parseResponse, stream, validateCompactedMessages };
+export { type AIProvider, type ActionPart, type ActionResult, Agent, type AgentConfig, type AgentDefinition, type AgentDefinitionRequestOptions, type AgentDefinitionResolver, type AgentErrorResult, type AgentHandle, type AgentResult, type AgentSession, type Annotation, type AnnotationEvent, type AnnotationPlacement, type AnnotationStatus, type AnnotationTarget, type AutomaticCompactionTrigger, AxleAbortError, AxleAgentAbortError, type AxleAssistantMessage, type AxleConfiguration, AxleError, type AxleFailure, type AxleMessage, type AxleModelRequestOptions, AxleStopReason, type AxleToolCallMessage, type AxleToolCallResult, AxleToolFatalError, type AxleUserMessage, type BraveWebSearchOptions, type ChatCompletionsOptions, type ChatCompletionsVendor, type Citation, type CitationOutputSpan, type CitationPart, type CitationSource, type CompactionCallback, type CompactionConfig, type CompactionPart, type CompactionStamp, type CompactionTrigger, type CompactionUpdate, type ContentPart, type ContentPartCitation, type ContentPartFile, type ContentPartProviderTool, type ContentPartText, type ContentPartThinking, type ContentPartToolCall, type ContextUsage, type CreateAgentToolOptions, type DeferredFileInfo, type DocumentLocator, type EventLevel, type ExecutableTool, type FileInfo, type FileKind, type FilePart, type FileProviderId, type FileResolveFormat, type FileResolveRequest, type FileResolver, type FileStore, type GenerateError, type GenerateInstructParams, type GenerateInstructResult, type GenerateParams, type GenerateResult, type Handle, Instruct, type InstructContextSection, type InstructInputs, type InstructOptions, type InstructRenderOptions, type InstructResponse, InstructVariableError, type InstructVarsMode, type LLMRequest, type LLMResponse, type LLMResult, type LogEntry, type LogFn, LogWriter, MCP, type MCPConfig, type MCPHttpConfig, type MCPStdioConfig, type MaybePromise, type MessageMetadata, type ObservabilityOptions, type OutputSchema, type ParallelToolResult, type ParallelizeOptions, type ParsedSchema, PromptCompactor, type PromptCompactorOptions, type ProviderClientOptions, type ProviderDefinition, type ProviderOptions, type ProviderTool, type ProviderToolAction, type ProviderToolDefinitionRef, type ResolvedAgentDefinition, type ResolvedFileSource, type SavedAgent, type SendMessageOptions, type ShouldCompactOnTriggerCallback, SimpleWriter, type SimpleWriterOptions, type Span, type SpanData, type SpanEvent, type SpanOptions, type SpanResult, type SpanStatus, type SpanType, type Stats, type StreamEvent, type StreamEventCallback, type StreamHandle, type StreamInstructHandle, type StreamInstructParams, type StreamInstructResult, type StreamParams, type StreamResult, type SubagentAction, TaskError, type TextPart, type ThinkingContinuity, type ThinkingPart, type TokenStats, type TokenUsage, type ToolAction, type ToolBatchCompleteCallback, type ToolChoice, type ToolContext, type ToolDefinition, type ToolDefinitionRef, type ToolProgressChunk, ToolRegistry, type ToolResult, type ToolResultPart, type TraceWriter, Tracer, type TracerOptions, Transcript, type TranscriptApplyResult, type TranscriptInput, type Turn, type TurnEvent, TurnEventBuilder, type TurnEventCallback, type TurnMetadata, type TurnPart, type TurnStatus, type UsageEntry, type WebSearchBackend, type WebSearchBackendContext, type WebSearchRequest, type WebSearchResponse, type WebSearchResult, addStats, anthropic, braveWebSearch, chatCompletions, configureAxle, createAgentConfig, createAgentTool, createStats, estimateContextUsage, gemini, generate, generateStep, getCompactionStamp, loadFileContent, mergeStats, openai, parallelize, parseResponse, stream, validateCompactedMessages };