@fifthrevision/axle 0.31.0 → 0.32.0

package/README.md

@@ -164,8 +164,10 @@ const result = await handle.final;
 if (!result.ok) throw new Error(result.error.kind);
 ```
 
-`generate()` does the same but without streaming — it returns the final result
-directly as a promise:
+`generate()` is the same request and the same tool loop with the non-streaming
+return shape: it resolves the handle's `final` directly as a promise. The
+transport underneath is always streaming, so the two never differ in what
+they send or what they return:
 
 ```typescript
 import { generate } from "@fifthrevision/axle";
@@ -224,29 +226,36 @@ conversation and start a new call. Non-positive limits throw at call time.
 accepted by `Agent`, `generate()`, `stream()`, and `PromptCompactor`:
 
 ```typescript
-type ReasoningSetting = "default" | "off" | "on" | { effort: "low" | "medium" | "high" };
+type ReasoningSetting =
+  "default" | "off" | "on" | { effort: "low" | "medium" | "high"; display?: "visible" | "hidden" };
 
 await generate({ provider, model, messages, reasoning: { effort: "high" } });
 ```
 
-| Setting               | Meaning                                                                                                                    |
-| --------------------- | -------------------------------------------------------------------------------------------------------------------------- |
-| omitted / `"default"` | No reasoning fields are sent; the model runs at its provider default                                                       |
-| `"off"`               | The provider's explicit disable. Models that cannot turn thinking off (Fable, Gemini 3, Gemini 2.5 Pro) reject the request |
-| `"on"`                | Same as `{ effort: "medium" }`                                                                                             |
-| `{ effort }`          | A named level on modern models, or a fixed token budget (2,048 / 8,192 / 16,384) on models that only accept budgets        |
+| Setting               | Meaning                                                                                                                                                                                                                                                          |
+| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| omitted / `"default"` | No reasoning fields are sent; the model runs at its provider default                                                                                                                                                                                             |
+| `"off"`               | The provider's explicit disable. Models that cannot turn thinking off (Fable, Gemini 3, Gemini 2.5 Pro) reject the request                                                                                                                                       |
+| `"on"`                | Same as `{ effort: "medium" }`                                                                                                                                                                                                                                   |
+| `{ effort }`          | A named level on modern models, or a fixed token budget (2,048 / 8,192 / 16,384) on models that only accept budgets                                                                                                                                              |
+| `{ effort, display }` | `"visible"` (default) asks the provider to disclose its thinking; `"hidden"` asks it not to, and Axle withholds thinking from the transcript on every provider. On Anthropic the server also skips streaming thinking tokens, improving time to first text token |
 
 Effort is relative within a model, not comparable across models. `"on"`
 enables reasoning but does not guarantee a visible thinking block on every
-response. Axle does not validate support: an unsupported combination comes
-back as a provider error. Anything beyond these levels, such as `xhigh`, an
-exact budget, or thinking display, goes through `providerOptions`, which is
-applied after the portable mapping and overrides it.
+response. `display` controls whether thinking is disclosed, not its form:
+Anthropic, OpenAI, and Gemini return a summary, open-weight models return
+raw text, and chat-completions endpoints have no request field for it;
+under `"hidden"` their thinking stays on the message but never reaches the
+transcript. Axle does not validate support: an unsupported
+combination comes back as a provider error. Anything beyond these levels,
+such as `xhigh`, an exact budget, or an OpenAI summary length, goes through
+`providerOptions`, which is applied after the portable mapping and overrides
+it.
 
 Anthropic needs an output cap on every request. When you don't pass
-`maxOutputTokens`, `stream()` uses the model's ceiling and `generate()` uses
-21,000, the largest cap the Anthropic SDK sends without streaming. The
-per-provider translation is documented in `docs/architecture/reasoning.md`.
+`maxOutputTokens`, Axle uses the model's registry ceiling, else 64,000, on
+`stream()`, `generate()`, and `Agent` alike. The per-provider translation is
+documented in `docs/architecture/reasoning.md`.
 
 ### Results
 
@@ -717,7 +726,7 @@ try {
 ```
 
 `TurnEvent` types: `turn:user`, `turn:start`, `turn:end`, `part:start`,
-`part:end`, `text:delta`, `text:citation`, `thinking:delta`,
+`part:end`, `text:delta`, `text:citation`, `thinking:raw-delta`,
 `thinking:summary-delta`, `thinking:update`, `action:args-delta`,
 `action:running`, `action:progress`, `action:complete`, `action:error`,
 `action:child-event`, `compaction:update`, `compaction:complete`,
@@ -854,7 +863,7 @@ and completion.
 
 `StreamEvent` types: `step:start`, `step:complete`, `tool-results:start`,
 `tool-results:complete`, `text:start`, `text:delta`, `text:citation`,
-`text:end`, `citation`, `thinking:start`, `thinking:delta`,
+`text:end`, `citation`, `thinking:start`, `thinking:raw-delta`,
 `thinking:summary-delta`, `thinking:update`, `thinking:end`, `tool:request`,
 `tool:args-delta`, `tool:exec-start`, `tool:exec-delta`, `tool:exec-complete`,
 `tool:exec-error`, `provider-tool:start`, `provider-tool:complete`, `error`.

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-import { $ as ThinkingContinuity, At as SpanData, B as AxleUserMessage, C as CompactionPart, Ct as TokenStats, D as SubagentAction, Dt as LLMResponse, E as ProviderToolAction, Et as LLMRequest, F as TurnStatus, Ft as SpanType, G as ContentPartCitation, H as CitationOutputSpan, I as AxleAssistantMessage, It as TokenUsage, J as ContentPartText, K as ContentPartFile, L as AxleMessage, Lt as ToolResult, M as Turn, Mt as SpanOptions, N as TurnMetadata, Nt as SpanResult, O as TextPart, Ot as LLMResult, P as TurnPart, Pt as SpanStatus, Q as MessageMetadata, R as AxleToolCallMessage, Rt as TraceWriter, S as CitationPart, St as Stats, T as FilePart, Tt as EventLevel, U as CitationSource, V as Citation, W as ContentPart, X as ContentPartToolCall, Y as ContentPartThinking, Z as DocumentLocator, _ as ActionPart, _t as FileResolveFormat, a as CompactionStamp, at as ModelError, b as AnnotationPlacement, bt as ResolvedFileSource, c as ExecutableTool, ct as ProviderOptions, d as ToolDefinition, dt as ReasoningEffort, et as ToolResultPart, f as ToolProgressChunk, ft as ReasoningSetting, g as TurnEvent, gt as FileProviderId, h as AnnotationTarget, ht as FileKind, it as ContextUsage, j as ToolAction, jt as SpanEvent, k as ThinkingPart, kt as Span, l as ProviderTool, lt as ResolvedProviderTool, m as AnnotationEvent, mt as FileInfo, n as TranscriptApplyResult, nt as AxleModelRequestOptions, o as getCompactionStamp, ot as ModelResult, p as ToolRegistry, pt as DeferredFileInfo, 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 FileResolveRequest, w as CompactionUpdate, wt as UsageEntry, x as AnnotationStatus, xt as loadFileContent, y as Annotation, yt as FileResolver, z as AxleToolCallResult } from "./transcript-BuUBiQX6.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 ToolChoice, 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 ReasoningEffort, m as AnnotationEvent, mt as FileProviderId, n as TranscriptApplyResult, nt as AxleModelRequestOptions, o as getCompactionStamp, ot as ProviderClientOptions, p as ToolRegistry, pt as FileKind, q as ContentPartProviderTool, r as TranscriptInput, rt as AxleStopReason, s as validateCompactedMessages, st as ProviderOptions, t as Transcript, tt as AIProvider, u as ToolContext, ut as ReasoningSetting, 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-IlzS5MWE.js";
 import * as z$2 from "zod";
-import { ZodObject, z } from "zod";
-
+import { ZodObject, z as z$1 } from "zod";
 //#region src/tools/webSearch.d.ts
 interface WebSearchRequest {
   query: string;
@@ -37,13 +36,13 @@ interface BraveWebSearchOptions {
   freshness?: "pd" | "pw" | "pm" | "py" | `${string}to${string}`;
   timeoutMs?: number;
 }
-declare function braveWebSearch(options: BraveWebSearchOptions): WebSearchBackend;
+export declare function braveWebSearch(options: BraveWebSearchOptions): WebSearchBackend;
 //#endregion
 //#region src/config.d.ts
 interface AxleConfiguration {
   webSearchFallback?: WebSearchBackend;
 }
-declare function configureAxle(options: AxleConfiguration): void;
+export declare function configureAxle(options: AxleConfiguration): void;
 //#endregion
 //#region src/mcp/MCP.d.ts
 interface MCPStdioConfig {
@@ -60,7 +59,7 @@ interface MCPHttpConfig {
   headers?: Record<string, string>;
 }
 type MCPConfig = MCPStdioConfig | MCPHttpConfig;
-declare class MCP {
+export declare class MCP {
   private config;
   private client;
   private transport;
@@ -94,7 +93,7 @@ declare class MCP {
 //#region src/core/parse.d.ts
 type OutputSchema = z$2.ZodTypeAny;
 type ParsedSchema<T extends OutputSchema> = z$2.output<T>;
-declare function parseResponse<T extends OutputSchema>(rawValue: string, schema?: T): ParsedSchema<T> | string;
+export declare function parseResponse<T extends OutputSchema>(rawValue: string, schema?: T): ParsedSchema<T> | string;
 //#endregion
 //#region src/core/Instruct.d.ts
 type InstructInputs = Record<string, unknown>;
@@ -113,7 +112,7 @@ interface InstructOptions<TSchema extends OutputSchema | undefined = OutputSchem
   vars?: InstructVarsMode;
   metadata?: MessageMetadata;
 }
-declare class Instruct<TSchema extends OutputSchema | undefined = undefined> {
+export declare class Instruct<TSchema extends OutputSchema | undefined = undefined> {
   prompt: string;
   inputs: InstructInputs;
   files: FileInfo[];
@@ -161,7 +160,7 @@ type LogFn = (entry: LogEntry) => void;
  * reconstruct the trace skeleton from the log stream alone. The full span tree
  * also reaches a real span exporter via a separate writer.
  */
-declare class LogWriter implements TraceWriter {
+export declare class LogWriter implements TraceWriter {
   private readonly log;
   constructor(log: LogFn);
   onSpanStart(): void;
@@ -174,7 +173,7 @@ interface TracerOptions {
   minLevel?: EventLevel;
   writers?: TraceWriter[];
 }
-declare class Tracer {
+export declare class Tracer {
   private rec;
   constructor(options?: TracerOptions);
   get minLevel(): EventLevel;
@@ -186,7 +185,7 @@ declare class Tracer {
 }
 //#endregion
 //#region src/errors/AxleError.d.ts
-declare class AxleError extends Error {
+export declare class AxleError extends Error {
   readonly code: string;
   readonly id?: string;
   readonly details?: Record<string, any>;
@@ -207,7 +206,7 @@ declare class AxleError extends Error {
 }
 //#endregion
 //#region src/errors/AxleAbortError.d.ts
-declare class AxleAbortError extends AxleError {
+export declare class AxleAbortError extends AxleError {
   readonly reason: unknown;
   readonly messages?: AxleMessage[];
   readonly partial?: AxleAssistantMessage;
@@ -233,7 +232,7 @@ declare class AxleAbortError extends AxleError {
 }
 //#endregion
 //#region src/errors/AxleToolFatalError.d.ts
-declare class AxleToolFatalError extends AxleError {
+export declare class AxleToolFatalError extends AxleError {
   readonly toolName?: string;
   readonly messages?: AxleMessage[];
   readonly partial?: AxleAssistantMessage;
@@ -291,7 +290,7 @@ type AxleFailure = {
 };
 /** @deprecated Use AxleFailure. */
 type GenerateError = AxleFailure;
-type GenerateResult<TResponse = AxleAssistantMessage> = {
+type StreamResult<TResponse = AxleAssistantMessage> = {
   ok: true;
   response: TResponse;
   messages: AxleMessage[];
@@ -319,7 +318,7 @@ type GenerateResult<TResponse = AxleAssistantMessage> = {
    */
   stopped?: "max-steps" | "token-limit";
 };
-type StreamResult<TResponse = AxleAssistantMessage> = GenerateResult<TResponse>;
+type GenerateResult<TResponse = AxleAssistantMessage> = StreamResult<TResponse>;
 //#endregion
 //#region src/utils/utils.d.ts
 interface Handle<T> {
@@ -541,8 +540,10 @@ type CompactionCallback = (state: {
 }, context: {
   usage: ContextUsage;
   signal?: AbortSignal;
-  trigger: CompactionTrigger; /** Engine-generated id for this compaction; the emitted part shares it. */
-  id: string; /** Update transient reader-facing state on the running part. */
+  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[];
@@ -574,7 +575,7 @@ interface SendMessageOptions extends AxleModelRequestOptions {
 }
 //#endregion
 //#region src/core/agent/Agent.d.ts
-declare class Agent {
+export declare class Agent {
   readonly provider: AIProvider;
   readonly model: string;
   readonly name?: string;
@@ -686,7 +687,7 @@ declare class Agent {
  * 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>;
+export declare function createAgentConfig(definition: AgentDefinition, resolver: AgentDefinitionResolver): Promise<AgentConfig>;
 //#endregion
 //#region src/compaction/PromptCompactor.d.ts
 interface PromptCompactorOptions {
@@ -718,7 +719,7 @@ interface PromptCompactorOptions {
  *
  * @experimental Compaction is under active design and may change in any release.
  */
-declare class PromptCompactor {
+export declare class PromptCompactor {
   private readonly provider;
   private readonly model;
   private readonly prompt;
@@ -734,7 +735,7 @@ declare class PromptCompactor {
 }
 //#endregion
 //#region src/errors/AxleAgentAbortError.d.ts
-declare class AxleAgentAbortError extends AxleAbortError {
+export declare class AxleAgentAbortError extends AxleAbortError {
   readonly turn?: Turn;
   constructor(message?: string, options?: {
     reason?: unknown;
@@ -759,7 +760,7 @@ declare class AxleAgentAbortError extends AxleAbortError {
 }
 //#endregion
 //#region src/errors/InstructVariableError.d.ts
-declare class InstructVariableError extends AxleError {
+export declare class InstructVariableError extends AxleError {
   readonly missingVariables: string[];
   constructor(missingVariables: string[]);
   toJSON(): {
@@ -774,7 +775,7 @@ declare class InstructVariableError extends AxleError {
 }
 //#endregion
 //#region src/errors/TaskError.d.ts
-declare class TaskError extends AxleError {
+export declare class TaskError extends AxleError {
   constructor(message: string, options?: {
     id?: string;
     taskType?: string;
@@ -785,7 +786,7 @@ declare class TaskError extends AxleError {
 }
 //#endregion
 //#region src/providers/anthropic/provider.d.ts
-declare function anthropic(apiKey: string, options?: ProviderClientOptions): AIProvider;
+export declare function anthropic(apiKey: string, options?: ProviderClientOptions): AIProvider;
 //#endregion
 //#region src/providers/chatcompletions/utils.d.ts
 type ChatCompletionsVendor = "openrouter" | "together";
@@ -795,9 +796,9 @@ interface ChatCompletionsOptions extends ProviderClientOptions {
   apiKey?: string;
   vendor?: ChatCompletionsVendor;
 }
-declare function chatCompletions(baseUrl: string, options?: ChatCompletionsOptions): AIProvider;
-declare function chatCompletions(baseUrl: string, apiKey?: string): AIProvider;
-declare function chatCompletions(baseUrl: string, apiKey: string, options?: Omit<ChatCompletionsOptions, "apiKey">): AIProvider;
+export declare function chatCompletions(baseUrl: string, options?: ChatCompletionsOptions): AIProvider;
+export declare function chatCompletions(baseUrl: string, apiKey?: string): AIProvider;
+export declare function chatCompletions(baseUrl: string, apiKey: string, options?: Omit<ChatCompletionsOptions, "apiKey">): AIProvider;
 //#endregion
 //#region src/providers/context.d.ts
 interface ContextEstimateInput {
@@ -808,52 +809,10 @@ interface ContextEstimateInput {
   messages: AxleMessage[];
   limit?: number;
 }
-declare function estimateContextUsage(input: ContextEstimateInput): ContextUsage;
+export declare function estimateContextUsage(input: ContextEstimateInput): ContextUsage;
 //#endregion
 //#region src/providers/gemini/provider.d.ts
-declare function gemini(apiKey: string, options?: ProviderClientOptions): AIProvider;
-//#endregion
-//#region src/providers/generate.d.ts
-interface GenerateParams extends AxleModelRequestOptions {
-  provider: AIProvider;
-  model: string;
-  messages: Array<AxleMessage>;
-  system?: string;
-  tools?: ExecutableTool[];
-  providerTools?: ProviderTool[];
-  registry?: ToolRegistry;
-  onToolCall?: ToolCallCallback;
-  maxSteps?: number;
-  /**
-   * Context budget for the tool loop, in tokens. Checked at each request
-   * boundary against the previous model call's reported usage (effective
-   * input + output); when crossed, the loop returns `stopped: "token-limit"`
-   * with everything accumulated so far.
-   */
-  maxContextTokens?: number;
-  span?: Span;
-  fileResolver?: FileResolver;
-}
-interface GenerateInstructParams<TSchema extends OutputSchema | undefined> extends Omit<GenerateParams, "messages"> {
-  messages?: Array<AxleMessage>;
-  instruct: Instruct<TSchema>;
-}
-type GenerateInstructResult<TSchema extends OutputSchema | undefined> = GenerateResult<InstructResponse<TSchema>>;
-declare function generate<TSchema extends OutputSchema | undefined>(options: GenerateInstructParams<TSchema>): Promise<GenerateInstructResult<TSchema>>;
-declare function generate(options: GenerateParams): Promise<GenerateResult>;
-//#endregion
-//#region src/providers/generateStep.d.ts
-interface GenerateStepParams extends AxleModelRequestOptions {
-  provider: AIProvider;
-  model: string;
-  messages: Array<AxleMessage>;
-  system?: string;
-  tools?: Array<ToolDefinition>;
-  providerTools?: Array<ResolvedProviderTool>;
-  span?: Span;
-  fileResolver?: FileResolver;
-}
-declare function generateStep(props: GenerateStepParams): Promise<ModelResult>;
+export declare function gemini(apiKey: string, options?: ProviderClientOptions): AIProvider;
 //#endregion
 //#region src/providers/stream.d.ts
 type StreamEvent = {
@@ -889,11 +848,10 @@ type StreamEvent = {
   providerMetadata?: Record<string, unknown>;
 } | {
   type: "thinking:start";
-  redacted?: boolean;
   continuity?: ThinkingContinuity;
   providerMetadata?: Record<string, unknown>;
 } | {
-  type: "thinking:delta";
+  type: "thinking:raw-delta";
   delta: string;
   accumulated: string;
 } | {
@@ -902,12 +860,12 @@ type StreamEvent = {
   accumulated: string;
 } | {
   type: "thinking:update";
-  redacted?: boolean;
   continuity?: ThinkingContinuity;
   providerMetadata?: Record<string, unknown>;
 } | {
   type: "thinking:end";
-  final: string;
+  summary?: string;
+  raw?: string;
 } | {
   type: "tool:request";
   id: string;
@@ -994,11 +952,23 @@ type StreamInstructResult<TSchema extends OutputSchema | undefined> = StreamResu
 interface StreamInstructHandle<TSchema extends OutputSchema | undefined> extends Omit<StreamHandle, "final"> {
   readonly final: Promise<StreamInstructResult<TSchema>>;
 }
-declare function stream<TSchema extends OutputSchema | undefined>(options: StreamInstructParams<TSchema>): StreamInstructHandle<TSchema>;
-declare function stream(options: StreamParams): StreamHandle;
+export declare function stream<TSchema extends OutputSchema | undefined>(options: StreamInstructParams<TSchema>): StreamInstructHandle<TSchema>;
+export declare function stream(options: StreamParams): StreamHandle;
+export declare function stream(options: StreamParams | StreamInstructParams<any>): StreamHandle;
+//#endregion
+//#region src/providers/generate.d.ts
+type GenerateParams = StreamParams;
+type GenerateInstructParams<TSchema extends OutputSchema | undefined> = StreamInstructParams<TSchema>;
+type GenerateInstructResult<TSchema extends OutputSchema | undefined> = StreamInstructResult<TSchema>;
+/**
+ * The non-streaming return shape of `stream()`: the same request, the same
+ * tool loop, and the same result, resolved as a promise instead of a handle.
+ */
+export declare function generate<TSchema extends OutputSchema | undefined>(options: GenerateInstructParams<TSchema>): Promise<GenerateInstructResult<TSchema>>;
+export declare function generate(options: GenerateParams): Promise<GenerateResult>;
 //#endregion
 //#region src/providers/openai/provider.d.ts
-declare function openai(apiKey: string, options?: ProviderClientOptions): AIProvider;
+export declare function openai(apiKey: string, options?: ProviderClientOptions): AIProvider;
 //#endregion
 //#region src/tools/agentTool.d.ts
 interface CreateAgentToolOptions<TSchema extends ZodObject<any>> {
@@ -1006,12 +976,12 @@ interface CreateAgentToolOptions<TSchema extends ZodObject<any>> {
   description: string;
   schema: TSchema;
   /** Create the child agent for this tool call. Fresh agents are recommended. */
-  createAgent: (input: z.infer<TSchema>, ctx: ToolContext) => MaybePromise<Agent>;
+  createAgent: (input: z$1.infer<TSchema>, ctx: ToolContext) => MaybePromise<Agent>;
   /**
    * Convert tool input into the child-agent user prompt. Defaults to a compact
    * JSON task payload.
    */
-  prompt?: string | ((input: z.infer<TSchema>) => string);
+  prompt?: string | ((input: z$1.infer<TSchema>) => string);
   /** Per-send request overrides for the child agent. */
   request?: AxleModelRequestOptions;
 }
@@ -1026,7 +996,7 @@ interface CreateAgentToolOptions<TSchema extends ZodObject<any>> {
  * @experimental Shapes related to subagent rendering may change in a minor
  * release.
  */
-declare function createAgentTool<TSchema extends ZodObject<any>>(options: CreateAgentToolOptions<TSchema>): ExecutableTool<TSchema>;
+export declare function createAgentTool<TSchema extends ZodObject<any>>(options: CreateAgentToolOptions<TSchema>): ExecutableTool<TSchema>;
 //#endregion
 //#region src/tools/parallelize.d.ts
 interface ParallelizeOptions {
@@ -1062,12 +1032,12 @@ interface ParallelToolResult<TInput = unknown> {
  * @experimental The generated tool's result parts (`ParallelToolResult`) may
  * change in a minor release.
  */
-declare function parallelize<TSchema extends ZodObject<any>>(tool: ExecutableTool<TSchema>, options?: ParallelizeOptions): ExecutableTool<ZodObject<{
-  items: z.ZodArray<TSchema>;
+export declare function parallelize<TSchema extends ZodObject<any>>(tool: ExecutableTool<TSchema>, options?: ParallelizeOptions): ExecutableTool<ZodObject<{
+  items: z$1.ZodArray<TSchema>;
 }>>;
 //#endregion
 //#region src/turns/eventBuilder.d.ts
-declare class TurnEventBuilder {
+export declare class TurnEventBuilder {
   private currentTurnId;
   private currentTurnTiming;
   private currentTextPart;
@@ -1098,7 +1068,7 @@ interface SimpleWriterOptions {
   /** Custom output function (default: console.log) */
   output?: (line: string) => void;
 }
-declare class SimpleWriter implements TraceWriter {
+export declare class SimpleWriter implements TraceWriter {
   private minLevel;
   private showInternal;
   private showTimestamp;
@@ -1132,8 +1102,8 @@ declare class SimpleWriter implements TraceWriter {
 }
 //#endregion
 //#region src/utils/stats.d.ts
-declare function createStats(): Stats;
-declare function addStats(total: Stats, usage?: Stats): void;
-declare function mergeStats(...usages: Array<Stats | undefined>): Stats;
+export declare function createStats(): Stats;
+export declare function addStats(total: Stats, usage?: Stats): void;
+export declare function mergeStats(...usages: Array<Stats | undefined>): Stats;
 //#endregion
-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 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 ReasoningEffort, type ReasoningSetting, 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 };
+export { type AIProvider, type ActionPart, type ActionResult, 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, type AxleAssistantMessage, type AxleConfiguration, type AxleFailure, type AxleMessage, type AxleModelRequestOptions, AxleStopReason, type AxleToolCallMessage, type AxleToolCallResult, 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 GenerateError, type GenerateInstructParams, type GenerateInstructResult, type GenerateParams, type GenerateResult, type Handle, type InstructContextSection, type InstructInputs, type InstructOptions, type InstructRenderOptions, type InstructResponse, type InstructVarsMode, type LLMRequest, type LLMResponse, type LLMResult, type LogEntry, type LogFn, type MCPConfig, type MCPHttpConfig, type MCPStdioConfig, type MaybePromise, type MessageMetadata, type ObservabilityOptions, type OutputSchema, type ParallelToolResult, type ParallelizeOptions, type ParsedSchema, type PromptCompactorOptions, type ProviderClientOptions, type ProviderDefinition, type ProviderOptions, type ProviderTool, type ProviderToolAction, type ProviderToolDefinitionRef, type ReasoningEffort, type ReasoningSetting, type ResolvedAgentDefinition, type ResolvedFileSource, type SavedAgent, type SendMessageOptions, type ShouldCompactOnTriggerCallback, 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, 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, type TracerOptions, Transcript, type TranscriptApplyResult, type TranscriptInput, type Turn, type TurnEvent, type TurnEventCallback, type TurnMetadata, type TurnPart, type TurnStatus, type UsageEntry, type WebSearchBackend, type WebSearchBackendContext, type WebSearchRequest, type WebSearchResponse, type WebSearchResult, getCompactionStamp, loadFileContent, validateCompactedMessages };