@fifthrevision/axle 0.6.5 → 0.7.0

package/dist/index.d.ts

@@ -1,208 +1,13 @@
 import * as z from 'zod';
-import z__default, { ZodObject, z as z$1 } from 'zod';
-import Anthropic from '@anthropic-ai/sdk';
-import { GoogleGenAI } from '@google/genai';
-import OpenAI from 'openai';
+import { ZodObject, z as z$1 } from 'zod';
 
-type PlainObject = Record<string, unknown>;
-type ProgramOptions = {
-    dryRun?: boolean;
-    config?: string;
-    warnUnused?: boolean;
-    job?: string;
-    log?: boolean;
-    debug?: boolean;
-    args?: string[];
-};
 interface Stats {
     in: number;
     out: number;
 }
 
-interface RecorderLevelFunctions {
-    log: (...message: (string | unknown | Error)[]) => void;
-    heading: {
-        log: (...message: (string | unknown | Error)[]) => void;
-    };
-}
-type RecorderEntry = {
-    level: LogLevel;
-    time: number;
-    kind: VisualLevel;
-    payload: PlainObject[];
-};
-type VisualLevel = "heading" | "body";
-declare enum LogLevel {
-    Trace = 10,
-    Debug = 20,
-    Info = 30,
-    Warn = 40,
-    Error = 50,
-    Fatal = 60
-}
-interface RecorderWriter {
-    handleEvent(event: RecorderEntry): void | Promise<void>;
-    flush?(): Promise<void>;
-}
-
-declare class Recorder {
-    instanceId: `${string}-${string}-${string}-${string}-${string}`;
-    private currentLevel;
-    private logs;
-    private writers;
-    private _debug;
-    private _info;
-    private _warn;
-    private _error;
-    constructor();
-    buildMethods(): void;
-    set level(level: LogLevel);
-    get level(): LogLevel;
-    get info(): RecorderLevelFunctions;
-    get warn(): RecorderLevelFunctions;
-    get error(): RecorderLevelFunctions;
-    get debug(): RecorderLevelFunctions;
-    subscribe(writer: RecorderWriter): void;
-    unsubscribe(writer: RecorderWriter): void;
-    private publish;
-    private logFunction;
-    private createLoggingFunction;
-    getLogs(level?: LogLevel): RecorderEntry[];
-    /**
-     * Ensures all writers have completed their pending operations
-     * Call this before exiting the process to ensure logs are written
-     */
-    shutdown(): Promise<void>;
-}
-
-interface Tool<TSchema extends ZodObject<any> = ZodObject<any>> {
-    name: string;
-    description: string;
-    schema: TSchema;
-    execute(input: z$1.infer<TSchema>): Promise<string>;
-    configure?(config: Record<string, any>): void;
-}
-type ToolDefinition = Pick<Tool, "name" | "description" | "schema">;
-
-interface FileInfo {
-    path: string;
-    base64?: string;
-    content?: string;
-    mimeType: string;
-    size: number;
-    name: string;
-    type: "image" | "document" | "text";
-}
-type TextFileInfo = FileInfo & {
-    content: string;
-    base64?: never;
-    type: "text";
-};
-type Base64FileInfo = FileInfo & {
-    base64: string;
-    content?: never;
-    type: "image" | "document";
-};
-
-declare enum ResultType {
-    String = "string",
-    List = "string[]",
-    Number = "number",
-    Boolean = "boolean"
-}
-type ResultTypeUnion = `${ResultType}`;
-type DeclarativeSchema = {
-    [key: string]: ResultTypeUnion | DeclarativeSchema | DeclarativeSchema[];
-};
-type OutputSchema = Record<string, z__default.ZodTypeAny>;
-type InferedOutputSchema<T extends OutputSchema> = {
-    [K in keyof T]: z__default.output<T[K]>;
-};
-
-declare abstract class AbstractInstruct<T extends OutputSchema> {
-    readonly name = "instruct";
-    prompt: string;
-    system: string | null;
-    inputs: Record<string, string>;
-    tools: Record<string, Tool>;
-    files: Base64FileInfo[];
-    textReferences: Array<{
-        content: string;
-        name?: string;
-    }>;
-    instructions: string[];
-    schema: T;
-    rawResponse: string;
-    protected _taggedSections: {
-        tags: Record<string, string>;
-        remaining: string;
-    } | undefined;
-    protected _result: InferedOutputSchema<T> | undefined;
-    protected constructor(prompt: string, schema: T);
-    setInputs(inputs: Record<string, string>): void;
-    addInput(name: string, value: string): void;
-    addTools(tools: Tool[]): void;
-    addTool(tool: Tool): void;
-    addImage(file: FileInfo): void;
-    addDocument(file: FileInfo): void;
-    addFile(file: FileInfo): void;
-    addReference(textFile: FileInfo | TextFileInfo | string, options?: {
-        name?: string;
-    }): void;
-    addInstructions(instruction: string): void;
-    hasTools(): boolean;
-    hasFiles(): boolean;
-    get result(): InferedOutputSchema<T> | undefined;
-    compile(variables: Record<string, string>, runtime?: {
-        recorder?: Recorder;
-        options?: {
-            warnUnused?: boolean;
-        };
-    }): {
-        message: string;
-        instructions: string;
-    };
-    protected createUserMessage(variables: Record<string, string>, runtime?: {
-        recorder?: Recorder;
-        options?: {
-            warnUnused?: boolean;
-        };
-    }): string;
-    protected createInstructions(instructions?: string): string;
-    protected generateFieldInstructions(key: string, schema: z.ZodTypeAny): string;
-    finalize(rawValue: string, runtime?: {
-        recorder?: Recorder;
-    }): InferedOutputSchema<T>;
-    private preprocessValue;
-    protected parseTaggedSections(input: string): {
-        tags: Record<string, string>;
-        remaining: string;
-    };
-}
-
-declare class Instruct<T extends OutputSchema> extends AbstractInstruct<T> {
-    constructor(prompt: string, schema: T);
-    static with<T extends OutputSchema>(prompt: string, schema: T): Instruct<T>;
-    static with<T extends DeclarativeSchema>(prompt: string, schema: T): Instruct<OutputSchema>;
-    static with(prompt: string): Instruct<{
-        response: z.ZodString;
-    }>;
-}
-
-interface ActionContext {
-    input: string;
-    variables: Record<string, any>;
-    options?: ProgramOptions;
-    recorder?: Recorder;
-}
-interface Action {
-    name: string;
-    execute(context: ActionContext): Promise<string | void>;
-}
-type WorkflowStep = Instruct<any> | Action;
-
 interface StreamChunk {
-    type: "start" | "text" | "tool-call-start" | "tool-call-delta" | "tool-call-complete" | "thinking-start" | "thinking-delta" | "complete" | "error";
+    type: "start" | "text-start" | "text-delta" | "text-complete" | "tool-call-start" | "tool-call-complete" | "thinking-start" | "thinking-delta" | "thinking-summary-delta" | "thinking-complete" | "internal-tool-start" | "internal-tool-complete" | "complete" | "error";
     id?: string;
     data?: any;
 }
@@ -221,10 +26,31 @@ interface StreamCompleteChunk extends StreamChunk {
         usage: Stats;
     };
 }
-interface StreamTextChunk extends StreamChunk {
-    type: "text";
+interface StreamErrorChunk extends StreamChunk {
+    type: "error";
+    data: {
+        type: string;
+        message: string;
+        usage?: Stats;
+        raw?: any;
+    };
+}
+interface StreamTextStartChunk extends StreamChunk {
+    type: "text-start";
+    data: {
+        index: number;
+    };
+}
+interface StreamTextDeltaChunk extends StreamChunk {
+    type: "text-delta";
     data: {
+        index: number;
         text: string;
+    };
+}
+interface StreamTextCompleteChunk extends StreamChunk {
+    type: "text-complete";
+    data: {
         index: number;
     };
 }
@@ -232,7 +58,9 @@ interface StreamThinkingStartChunk extends StreamChunk {
     type: "thinking-start";
     data: {
         index: number;
+        id?: string;
         redacted?: boolean;
+        signature?: string;
     };
 }
 interface StreamThinkingDeltaChunk extends StreamChunk {
@@ -242,6 +70,19 @@ interface StreamThinkingDeltaChunk extends StreamChunk {
         text: string;
     };
 }
+interface StreamThinkingSummaryDeltaChunk extends StreamChunk {
+    type: "thinking-summary-delta";
+    data: {
+        index: number;
+        text: string;
+    };
+}
+interface StreamThinkingCompleteChunk extends StreamChunk {
+    type: "thinking-complete";
+    data: {
+        index: number;
+    };
+}
 interface StreamToolCallStartChunk extends StreamChunk {
     type: "tool-call-start";
     data: {
@@ -259,93 +100,126 @@ interface StreamToolCallCompleteChunk extends StreamChunk {
         arguments: any;
     };
 }
-interface StreamErrorChunk extends StreamChunk {
-    type: "error";
+interface StreamInternalToolStartChunk extends StreamChunk {
+    type: "internal-tool-start";
     data: {
-        type: string;
-        message: string;
-        usage?: Stats;
-        raw?: any;
+        index: number;
+        id: string;
+        name: string;
     };
 }
-type AnyStreamChunk = StreamStartChunk | StreamCompleteChunk | StreamTextChunk | StreamToolCallStartChunk | StreamToolCallCompleteChunk | StreamThinkingStartChunk | StreamThinkingDeltaChunk | StreamErrorChunk;
-
-type AxleMessage = AxleUserMessage | AxleAssistantMessage | AxleToolCallMessage;
-interface AxleUserMessage {
-    role: "user";
-    name?: string;
-    content: string | Array<ContentPart>;
-}
-interface AxleAssistantMessage {
-    role: "assistant";
-    id: string;
-    model?: string;
-    content: Array<ContentPartText | ContentPartThinking | ContentPartToolCall>;
-    finishReason?: AxleStopReason;
+interface StreamInternalToolCompleteChunk extends StreamChunk {
+    type: "internal-tool-complete";
+    data: {
+        index: number;
+        id: string;
+        name: string;
+        output?: unknown;
+    };
 }
-interface AxleToolCallMessage {
-    role: "tool";
-    content: Array<AxleToolCallResult>;
+type AnyStreamChunk = StreamStartChunk | StreamCompleteChunk | StreamErrorChunk | StreamTextStartChunk | StreamTextDeltaChunk | StreamTextCompleteChunk | StreamThinkingStartChunk | StreamThinkingDeltaChunk | StreamThinkingSummaryDeltaChunk | StreamThinkingCompleteChunk | StreamToolCallStartChunk | StreamToolCallCompleteChunk | StreamInternalToolStartChunk | StreamInternalToolCompleteChunk;
+
+interface Tool<TSchema extends ZodObject<any> = ZodObject<any>> {
+    name: string;
+    description: string;
+    schema: TSchema;
+    execute(input: z$1.infer<TSchema>): Promise<string>;
+    configure?(config: Record<string, any>): void;
+    summarize?(input: z$1.infer<TSchema>): string;
 }
-interface AxleToolCallResult {
-    id: string;
+type ToolDefinition = Pick<Tool, "name" | "description" | "schema">;
+
+type SpanStatus = "ok" | "error";
+type EventLevel = "debug" | "info" | "warn" | "error";
+type SpanType = string;
+interface SpanEvent {
     name: string;
-    content: string;
+    timestamp: number;
+    level: EventLevel;
+    attributes?: Record<string, unknown>;
+}
+interface SpanData {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    type?: SpanType;
+    startTime: number;
+    endTime?: number;
+    status: SpanStatus;
+    attributes: Record<string, unknown>;
+    events: SpanEvent[];
+    result?: SpanResult;
+}
+interface SpanOptions {
+    type?: SpanType;
+}
+type SpanResult = LLMResult | ToolResult;
+interface LLMResult {
+    kind: "llm";
+    model: string;
+    request: LLMRequest;
+    response: LLMResponse;
+    usage?: TokenUsage;
+    finishReason?: string;
 }
-type ContentPart = ContentPartText | ContentPartFile | ContentPartToolCall | ContentPartThinking;
-interface ContentPartText {
-    type: "text";
-    text: string;
+interface LLMRequest {
+    messages: unknown[];
+    system?: string;
+    tools?: unknown[];
 }
-interface ContentPartFile {
-    type: "file";
-    file: FileInfo;
+interface LLMResponse {
+    content: unknown;
 }
-interface ContentPartThinking {
-    type: "thinking";
-    text: string;
-    redacted?: boolean;
-    encrypted?: string;
-    signature?: string;
+interface TokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
 }
-interface ContentPartToolCall {
-    type: "tool-call";
-    id: string;
+interface ToolResult {
+    kind: "tool";
     name: string;
-    parameters: Record<string, unknown>;
+    input: unknown;
+    output: unknown;
+}
+interface TraceWriter {
+    onSpanStart(span: SpanData): void;
+    onSpanUpdate?(span: SpanData): void;
+    onSpanEnd(span: SpanData): void;
+    onEvent?(span: SpanData, event: SpanEvent): void;
+    onLLMStreamStart?(span: SpanData): void;
+    onLLMStreamChunk?(span: SpanData, chunk: string): void;
+    onLLMStreamEnd?(span: SpanData, result: LLMResult): void;
+    flush?(): Promise<void>;
 }
-
-type OllamaProviderConfig = {
-    url?: string;
-    model: string;
-};
-type AnthropicProviderConfig = {
-    "api-key": string;
-    model?: string;
-};
-type OpenAIProviderConfig = {
-    "api-key": string;
-    model?: string;
-};
-type GeminiProviderConfig = {
-    "api-key": string;
-    model?: string;
-};
-interface AIProviderConfig {
-    ollama: OllamaProviderConfig;
-    anthropic: AnthropicProviderConfig;
-    openai: OpenAIProviderConfig;
-    gemini: GeminiProviderConfig;
+/**
+ * Tracing context for a span. Created by Tracer.startSpan().
+ * Can create child spans and log events within the span's scope.
+ */
+interface TracingContext {
+    startSpan(name: string, options?: SpanOptions): TracingContext;
+    end(status?: SpanStatus): void;
+    debug(message: string, attributes?: Record<string, unknown>): void;
+    info(message: string, attributes?: Record<string, unknown>): void;
+    warn(message: string, attributes?: Record<string, unknown>): void;
+    error(message: string, attributes?: Record<string, unknown>): void;
+    setAttribute(key: string, value: unknown): void;
+    setAttributes(attributes: Record<string, unknown>): void;
+    setResult(result: SpanResult): void;
+    startLLMStream(): void;
+    appendLLMStream(chunk: string): void;
+    endLLMStream(result: LLMResult): void;
 }
+
 interface AIProvider {
     get name(): string;
-    get model(): string;
-    createGenerationRequest(params: {
+    /** @internal */
+    createGenerationRequest(model: string, params: {
         messages: Array<AxleMessage>;
         system?: string;
         tools?: Array<ToolDefinition>;
         context: {
-            recorder?: Recorder;
+            tracer?: TracingContext;
         };
         options?: {
             temperature?: number;
@@ -357,13 +231,15 @@ interface AIProvider {
             [key: string]: any;
         };
     }): Promise<ModelResult>;
-    createStreamingRequest?(params: {
+    /** @internal */
+    createStreamingRequest?(model: string, params: {
         messages: Array<AxleMessage>;
         system?: string;
         tools?: Array<ToolDefinition>;
         context: {
-            recorder?: Recorder;
+            tracer?: TracingContext;
         };
+        signal?: AbortSignal;
         options?: {
             temperature?: number;
             top_p?: number;
@@ -397,367 +273,114 @@ interface ModelError {
 }
 type ModelResult = ModelResponse | ModelError;
 declare enum AxleStopReason {
-    Stop = 0,
-    Length = 1,
-    FunctionCall = 2,
-    Error = 3,
-    Custom = 4
-}
-
-declare class AxleError extends Error {
-    readonly code: string;
-    readonly id?: string;
-    readonly details?: Record<string, any>;
-    constructor(message: string, options?: {
-        code?: string;
-        id?: string;
-        details?: Record<string, any>;
-        cause?: Error;
-    });
+    Stop = "stop",
+    Length = "length",
+    FunctionCall = "function_call",
+    Error = "error",
+    Custom = "custom",
+    Cancelled = "cancelled"
 }
 
-interface Planner {
-    plan(steps: WorkflowStep[]): Promise<Run[]>;
+interface FileInfo {
+    path: string;
+    base64?: string;
+    content?: string;
+    mimeType: string;
+    size: number;
+    name: string;
+    type: "image" | "document" | "text";
 }
+type TextFileInfo = FileInfo & {
+    content: string;
+    base64?: never;
+    type: "text";
+};
+type Base64FileInfo = FileInfo & {
+    base64: string;
+    content?: never;
+    type: "image" | "document";
+};
+/**
+ * Load a file with the specified encoding or auto-detect based on file extension
+ * @param filePath - Path to the file
+ * @param encoding - How to load the file: "utf-8" for text, "base64" for binary, or omit for auto-detection
+ * @returns FileInfo object with appropriate content based on encoding
+ */
+declare function loadFileContent(filePath: string): Promise<FileInfo>;
+declare function loadFileContent(filePath: string, encoding: "utf-8"): Promise<TextFileInfo>;
+declare function loadFileContent(filePath: string, encoding: "base64"): Promise<Base64FileInfo>;
 
-interface Run {
-    steps: WorkflowStep[];
-    variables: Record<string, any>;
-}
-interface SerializedExecutionResponse {
-    response: string;
-    stats: Stats;
-}
-interface WorkflowResult<T = any> {
-    response: T;
-    stats?: Stats;
-    error?: AxleError;
-    success: boolean;
-}
-interface WorkflowExecutable {
-    execute: (context: {
-        provider: AIProvider;
-        variables: Record<string, any>;
-        options?: ProgramOptions;
-        stats?: Stats;
-        recorder?: Recorder;
-        name?: string;
-    }) => Promise<WorkflowResult>;
-}
-interface DAGNodeDefinition {
-    step: WorkflowStep | WorkflowStep[];
-    dependsOn?: string | string[];
-}
-interface DAGConcurrentNodeDefinition {
-    planner: Planner;
-    steps: WorkflowStep[];
-    dependsOn?: string | string[];
-}
-interface DAGDefinition {
-    [nodeName: string]: WorkflowStep | WorkflowStep[] | DAGNodeDefinition | DAGConcurrentNodeDefinition;
+type AxleMessage = AxleUserMessage | AxleAssistantMessage | AxleToolCallMessage;
+interface AxleUserMessage {
+    role: "user";
+    name?: string;
+    content: string | Array<ContentPart>;
 }
-interface DAGWorkflowOptions {
-    continueOnError?: boolean;
-    maxConcurrency?: number;
+interface AxleAssistantMessage {
+    role: "assistant";
+    id: string;
+    model?: string;
+    content: Array<ContentPartText | ContentPartThinking | ContentPartToolCall | ContentPartInternalTool>;
+    finishReason?: AxleStopReason;
 }
-
-declare class Axle {
-    provider: AIProvider;
-    private stats;
-    private variables;
-    recorder: Recorder;
-    constructor(config: Partial<AIProviderConfig>);
-    addWriter(writer: RecorderWriter): void;
-    /**
-     * The execute function takes in a list of Tasks
-     * @param steps
-     * @returns
-     */
-    execute(...steps: WorkflowStep[]): Promise<WorkflowResult>;
-    /**
-     * Execute a DAG workflow
-     * @param dagDefinition - The DAG definition object
-     * @param variables - Additional variables to pass to the workflow
-     * @param options - DAG execution options
-     * @returns Promise<WorkflowResult>
-     */
-    executeDAG(dagDefinition: DAGDefinition, variables?: Record<string, any>, options?: DAGWorkflowOptions): Promise<WorkflowResult>;
-    get logs(): RecorderEntry[];
-    /**
-     * Load a file with the specified encoding or auto-detect based on file extension
-     * @param filePath - Path to the file
-     * @param encoding - How to load the file: "utf-8" for text, "base64" for binary, or omit for auto-detection
-     * @returns FileInfo object with appropriate content based on encoding
-     */
-    static loadFileContent(filePath: string): Promise<FileInfo>;
-    static loadFileContent(filePath: string, encoding: "utf-8"): Promise<TextFileInfo>;
-    static loadFileContent(filePath: string, encoding: "base64"): Promise<Base64FileInfo>;
+interface AxleToolCallMessage {
+    role: "tool";
+    content: Array<AxleToolCallResult>;
 }
-
-declare class ChainOfThought<T extends OutputSchema> extends AbstractInstruct<T> {
-    constructor(prompt: string, schema: T);
-    static with<T extends OutputSchema>(prompt: string, schema: T): ChainOfThought<T>;
-    static with<T extends DeclarativeSchema>(prompt: string, schema: T): ChainOfThought<OutputSchema>;
-    static with(prompt: string): ChainOfThought<{
-        response: z.ZodString;
-    }>;
-    createInstructions(instructions?: string): string;
-    finalize(rawValue: string, runtime?: {
-        recorder?: Recorder;
-    }): InferedOutputSchema<T> & {
-        thinking: string;
-    };
+interface AxleToolCallResult {
+    id: string;
+    name: string;
+    content: string;
 }
-
-declare const Models$2: {
-    readonly CLAUDE_SONNET_4_5_20250929: "claude-sonnet-4-5-20250929";
-    readonly CLAUDE_SONNET_4_5_LATEST: "claude-sonnet-4-5";
-    readonly CLAUDE_HAIKU_4_5: "claude-haiku-4-5";
-    readonly CLAUDE_OPUS_4_1_20250805: "claude-opus-4-1-20250805";
-    readonly CLAUDE_OPUS_4_1_LATEST: "claude-opus-4-1";
-    readonly CLAUDE_OPUS_4_20250514: "claude-opus-4-20250514";
-    readonly CLAUDE_OPUS_4_LATEST: "claude-opus-4-0";
-    readonly CLAUDE_SONNET_4_20250514: "claude-sonnet-4-20250514";
-    readonly CLAUDE_SONNET_4_LATEST: "claude-sonnet-4-0";
-    readonly CLAUDE_3_7_SONNET_20250219: "claude-3-7-sonnet-20250219";
-    readonly CLAUDE_3_7_SONNET_LATEST: "claude-3-7-sonnet-latest";
-    readonly CLAUDE_3_5_SONNET_20241022: "claude-3-5-sonnet-20241022";
-    readonly CLAUDE_3_5_HAIKU_20241022: "claude-3-5-haiku-20241022";
-    readonly CLAUDE_3_5_HAIKU_LATEST: "claude-3-5-haiku-latest";
-    readonly CLAUDE_3_5_SONNET_20240620: "claude-3-5-sonnet-20240620";
-};
-declare const DEFAULT_MODEL$2: "claude-haiku-4-5";
-
-declare const NAME$3: "anthropic";
-declare class AnthropicProvider implements AIProvider {
-    name: "anthropic";
-    client: Anthropic;
-    model: string;
-    constructor(apiKey: string, model?: string);
-    createGenerationRequest(params: {
-        messages: Array<AxleMessage>;
-        system?: string;
-        tools?: Array<ToolDefinition>;
-        context: {
-            recorder?: Recorder;
-        };
-        options?: {
-            temperature?: number;
-            top_p?: number;
-            max_tokens?: number;
-            frequency_penalty?: number;
-            presence_penalty?: number;
-            stop?: string | string[];
-            [key: string]: any;
-        };
-    }): Promise<ModelResult>;
-    createStreamingRequest(params: {
-        messages: Array<AxleMessage>;
-        system?: string;
-        tools?: Array<ToolDefinition>;
-        context: {
-            recorder?: Recorder;
-        };
-        options?: {
-            temperature?: number;
-            top_p?: number;
-            max_tokens?: number;
-            frequency_penalty?: number;
-            presence_penalty?: number;
-            stop?: string | string[];
-            [key: string]: any;
-        };
-    }): AsyncGenerator<AnyStreamChunk, void, unknown>;
+type ContentPart = ContentPartText | ContentPartFile | ContentPartToolCall | ContentPartThinking | ContentPartInternalTool;
+interface ContentPartText {
+    type: "text";
+    text: string;
 }
-
-declare namespace index$3 {
-  export {
-    DEFAULT_MODEL$2 as DEFAULT_MODEL,
-    Models$2 as Models,
-    NAME$3 as NAME,
-    AnthropicProvider as Provider,
-  };
+interface ContentPartFile {
+    type: "file";
+    file: FileInfo;
 }
-
-declare const Models$1: {
-    readonly GEMINI_2_5_PRO: "gemini-2.5-pro";
-    readonly GEMINI_2_5_FLASH: "gemini-2.5-flash";
-    readonly GEMINI_2_5_FLASH_PREVIEW_05_20: "gemini-2.5-flash-preview-05-20";
-    readonly GEMINI_2_5_FLASH_LITE: "gemini-2.5-flash-lite";
-    readonly GEMINI_2_5_FLASH_LITE_PREVIEW_06_17: "gemini-2.5-flash-lite-preview-06-17";
-    readonly GEMINI_2_5_FLASH_LIVE_PREVIEW: "gemini-live-2.5-flash-preview";
-    readonly GEMINI_2_5_FLASH_PREVIEW_NATIVE_AUDIO_DIALOG: "gemini-2.5-flash-preview-native-audio-dialog";
-    readonly GEMINI_2_5_FLASH_EXP_NATIVE_AUDIO_THINKING_DIALOG: "gemini-2.5-flash-exp-native-audio-thinking-dialog";
-    readonly GEMINI_2_5_FLASH_IMAGE_PREVIEW: "gemini-2.5-flash-image-preview";
-    readonly GEMINI_2_5_FLASH_PREVIEW_TTS: "gemini-2.5-flash-preview-tts";
-    readonly GEMINI_2_5_PRO_PREVIEW_TTS: "gemini-2.5-pro-preview-tts";
-    readonly GEMINI_2_0_FLASH: "gemini-2.0-flash";
-    readonly GEMINI_2_0_FLASH_001: "gemini-2.0-flash-001";
-    readonly GEMINI_2_0_FLASH_EXP: "gemini-2.0-flash-exp";
-    readonly GEMINI_2_0_FLASH_PREVIEW_IMAGE_GENERATION: "gemini-2.0-flash-preview-image-generation";
-    readonly GEMINI_2_0_FLASH_LITE: "gemini-2.0-flash-lite";
-    readonly GEMINI_2_0_FLASH_LITE_001: "gemini-2.0-flash-lite-001";
-    readonly GEMINI_2_0_FLASH_LIVE_001: "gemini-2.0-flash-live-001";
-    readonly GEMINI_1_5_PRO: "gemini-1.5-pro";
-    readonly GEMINI_1_5_PRO_LATEST: "gemini-1.5-pro-latest";
-    readonly GEMINI_1_5_PRO_001: "gemini-1.5-pro-001";
-    readonly GEMINI_1_5_PRO_002: "gemini-1.5-pro-002";
-    readonly GEMINI_1_5_FLASH: "gemini-1.5-flash";
-    readonly GEMINI_1_5_FLASH_LATEST: "gemini-1.5-flash-latest";
-    readonly GEMINI_1_5_FLASH_001: "gemini-1.5-flash-001";
-    readonly GEMINI_1_5_FLASH_002: "gemini-1.5-flash-002";
-    readonly GEMINI_1_5_FLASH_8B: "gemini-1.5-flash-8b";
-    readonly GEMINI_1_5_FLASH_8B_LATEST: "gemini-1.5-flash-8b-latest";
-    readonly GEMINI_1_5_FLASH_8B_001: "gemini-1.5-flash-8b-001";
-    readonly GEMMA_3N_E4B_IT: "gemma-3n-e4b-it";
-    readonly GEMMA_3_1B_IT: "gemma-3-1b-it";
-    readonly GEMMA_3_4B_IT: "gemma-3-4b-it";
-    readonly GEMMA_3_12B_IT: "gemma-3-12b-it";
-    readonly GEMMA_3_27B_IT: "gemma-3-27b-it";
-    readonly LEARNLM_2_0_FLASH_EXPERIMENTAL: "learnlm-2.0-flash-experimental";
-    readonly EMBEDDING_001: "embedding-001";
-    readonly TEXT_EMBEDDING_004: "text-embedding-004";
-};
-declare const DEFAULT_MODEL$1: "gemini-2.5-flash";
-
-declare const NAME$2: "Gemini";
-declare class GeminiProvider implements AIProvider {
-    name: "Gemini";
-    client: GoogleGenAI;
-    model: string;
-    constructor(apiKey: string, model?: string);
-    createGenerationRequest(params: {
-        messages: Array<AxleMessage>;
-        system?: string;
-        tools?: Array<ToolDefinition>;
-        context: {
-            recorder?: Recorder;
-        };
-        options?: {
-            temperature?: number;
-            top_p?: number;
-            max_tokens?: number;
-            frequency_penalty?: number;
-            presence_penalty?: number;
-            stop?: string | string[];
-            [key: string]: any;
-        };
-    }): Promise<ModelResult>;
-    createStreamingRequest(params: {
-        messages: Array<AxleMessage>;
-        system?: string;
-        tools?: Array<ToolDefinition>;
-        context: {
-            recorder?: Recorder;
-        };
-        options?: {
-            temperature?: number;
-            top_p?: number;
-            max_tokens?: number;
-            frequency_penalty?: number;
-            presence_penalty?: number;
-            stop?: string | string[];
-            [key: string]: any;
-        };
-    }): AsyncGenerator<AnyStreamChunk, void, unknown>;
+interface ContentPartThinking {
+    type: "thinking";
+    id?: string;
+    text: string;
+    summary?: string;
+    redacted?: boolean;
+    encrypted?: string;
+    signature?: string;
 }
-
-declare namespace index$2 {
-  export {
-    DEFAULT_MODEL$1 as DEFAULT_MODEL,
-    Models$1 as Models,
-    NAME$2 as NAME,
-    GeminiProvider as Provider,
-  };
+interface ContentPartToolCall {
+    type: "tool-call";
+    id: string;
+    name: string;
+    parameters: Record<string, unknown>;
 }
-
-declare const DEFAULT_OLLAMA_URL = "http://localhost:11434";
-declare const NAME$1: "Ollama";
-declare class OllamaProvider implements AIProvider {
+interface ContentPartInternalTool {
+    type: "internal-tool";
+    id: string;
     name: string;
-    url: string;
-    model: string;
-    recorder?: Recorder;
-    constructor(model: string, url?: string);
-    createGenerationRequest(params: {
-        messages: Array<AxleMessage>;
-        system?: string;
-        tools?: Array<ToolDefinition>;
-        context: {
-            recorder?: Recorder;
-        };
-        options?: {
-            temperature?: number;
-            top_p?: number;
-            max_tokens?: number;
-            frequency_penalty?: number;
-            presence_penalty?: number;
-            stop?: string | string[];
-            [key: string]: any;
-        };
-    }): Promise<ModelResult>;
-    createStreamingRequest(params: {
-        messages: Array<AxleMessage>;
-        system?: string;
-        tools?: Array<ToolDefinition>;
-        context: {
-            recorder?: Recorder;
-        };
-        options?: {
-            temperature?: number;
-            top_p?: number;
-            max_tokens?: number;
-            frequency_penalty?: number;
-            presence_penalty?: number;
-            stop?: string | string[];
-            [key: string]: any;
-        };
-    }): AsyncGenerator<AnyStreamChunk, void, unknown>;
+    input?: unknown;
+    output?: unknown;
 }
 
-declare const NAME: "OpenAI";
-declare class OpenAIProvider implements AIProvider {
-    name: "OpenAI";
-    client: OpenAI;
-    model: string;
-    constructor(apiKey: string, model?: string | undefined);
-    createGenerationRequest(params: {
-        messages: Array<AxleMessage>;
-        system?: string;
-        tools?: Array<ToolDefinition>;
-        context: {
-            recorder?: Recorder;
-        };
-        options?: {
-            temperature?: number;
-            top_p?: number;
-            max_tokens?: number;
-            frequency_penalty?: number;
-            presence_penalty?: number;
-            stop?: string | string[];
-            [key: string]: any;
-        };
-    }): Promise<ModelResult>;
-    createStreamingRequest(params: {
-        messages: Array<AxleMessage>;
-        system?: string;
-        tools?: Array<ToolDefinition>;
-        context: {
-            recorder?: Recorder;
-        };
-        options?: {
-            temperature?: number;
-            top_p?: number;
-            max_tokens?: number;
-            frequency_penalty?: number;
-            presence_penalty?: number;
-            stop?: string | string[];
-            [key: string]: any;
-        };
-    }): AsyncGenerator<AnyStreamChunk, void, unknown>;
+declare class History {
+    system: string;
+    private _messages;
+    constructor(messages?: AxleMessage[]);
+    get messages(): AxleMessage[];
+    addSystem(message: string): void;
+    addUser(message: string): void;
+    addUser(parts: AxleUserMessage["content"]): void;
+    addAssistant(message: string): void;
+    addAssistant(params: Omit<AxleAssistantMessage, "role">): void;
+    addToolResults(input: Array<AxleToolCallResult>): void;
+    add(messages: AxleMessage | AxleMessage[]): void;
+    latest(): AxleMessage | undefined;
+    toString(): string;
 }
 
-interface GenerateOptions {
+interface GenerateTurnOptions {
     temperature?: number;
     top_p?: number;
     max_tokens?: number;
@@ -766,266 +389,310 @@ interface GenerateOptions {
     stop?: string | string[];
     [key: string]: any;
 }
-interface GenerateProps {
+interface GenerateTurnProps {
     provider: AIProvider;
+    model: string;
     messages: Array<AxleMessage>;
     system?: string;
     tools?: Array<ToolDefinition>;
-    recorder?: Recorder;
-    options?: GenerateOptions;
+    tracer?: TracingContext;
+    options?: GenerateTurnOptions;
 }
-declare function generate(props: GenerateProps): Promise<ModelResult>;
+declare function generateTurn(props: GenerateTurnProps): Promise<ModelResult>;
 
-interface StreamProps {
+type ToolCallResult = {
+    type: "success";
+    content: string;
+} | {
+    type: "error";
+    error: {
+        type: string;
+        message: string;
+        fatal?: boolean;
+        retryable?: boolean;
+    };
+};
+type ToolCallCallback = (name: string, parameters: Record<string, unknown>) => Promise<ToolCallResult | null | undefined>;
+type GenerateError = {
+    type: "model";
+    error: ModelError;
+} | {
+    type: "tool";
+    error: {
+        name: string;
+        message: string;
+    };
+};
+type GenerateResult = {
+    result: "success";
+    messages: AxleMessage[];
+    final?: AxleAssistantMessage;
+    usage?: Stats;
+} | {
+    result: "error";
+    messages: AxleMessage[];
+    error: GenerateError;
+    usage?: Stats;
+};
+type StreamResult = GenerateResult | {
+    result: "cancelled";
+    messages: AxleMessage[];
+    partial?: AxleAssistantMessage;
+    usage: Stats;
+};
+
+type StreamPartType = "text" | "thinking";
+type PartStartCallback = (index: number, type: StreamPartType) => void;
+type PartUpdateCallback = (index: number, type: StreamPartType, delta: string, accumulated: string) => void;
+type PartEndCallback = (index: number, type: StreamPartType, final: string) => void;
+type InternalToolEvent = {
+    type: "start";
+    index: number;
+    id: string;
+    name: string;
+} | {
+    type: "complete";
+    index: number;
+    id: string;
+    name: string;
+    output?: unknown;
+};
+type InternalToolCallback = (event: InternalToolEvent) => void;
+type ErrorCallback = (error: GenerateError) => void;
+interface StreamOptions {
     provider: AIProvider;
+    model: string;
     messages: Array<AxleMessage>;
     system?: string;
     tools?: Array<ToolDefinition>;
-    recorder?: Recorder;
-    options?: GenerateOptions;
-}
-interface StreamResult {
-    get final(): Promise<ModelResult>;
-    get current(): AxleAssistantMessage;
-    [Symbol.asyncIterator](): AsyncIterator<AnyStreamChunk>;
+    onToolCall?: ToolCallCallback;
+    maxIterations?: number;
+    tracer?: TracingContext;
+    options?: GenerateTurnOptions;
+}
+interface StreamHandle {
+    onPartStart(callback: PartStartCallback): void;
+    onPartUpdate(callback: PartUpdateCallback): void;
+    onPartEnd(callback: PartEndCallback): void;
+    onInternalTool(callback: InternalToolCallback): void;
+    onError(callback: ErrorCallback): void;
+    cancel(): void;
+    readonly final: Promise<StreamResult>;
+}
+declare function stream(options: StreamOptions): StreamHandle;
+
+type OutputSchema = Record<string, z.ZodTypeAny>;
+type ParsedSchema<T extends OutputSchema> = {
+    [K in keyof T]: z.output<T[K]>;
+};
+declare function parseResponse<T extends OutputSchema>(rawValue: string, schema?: T): ParsedSchema<T> | string;
+
+declare class Instruct<TSchema extends OutputSchema | undefined = undefined> {
+    prompt: string;
+    inputs: Record<string, string>;
+    files: Base64FileInfo[];
+    textReferences: Array<{
+        content: string;
+        name?: string;
+    }>;
+    instructions: string[];
+    schema: TSchema;
+    constructor(prompt: string, schema?: TSchema);
+    setInputs(inputs: Record<string, string>): void;
+    addInput(name: string, value: string): void;
+    addFile(file: FileInfo | string, options?: {
+        name?: string;
+    }): void;
+    addInstructions(instruction: string): void;
+    hasFiles(): boolean;
 }
-declare function stream(props: StreamProps): StreamResult;
 
-declare const index$1_DEFAULT_OLLAMA_URL: typeof DEFAULT_OLLAMA_URL;
-declare namespace index$1 {
-  export {
-    index$1_DEFAULT_OLLAMA_URL as DEFAULT_OLLAMA_URL,
-    NAME$1 as NAME,
-    OllamaProvider as Provider,
-  };
+interface AgentConfig {
+    provider: AIProvider;
+    model: string;
+    system?: string;
+    tools?: Tool[];
+    tracer?: TracingContext;
+}
+interface AgentResult<T = string> {
+    response: T | null;
+    messages: AxleMessage[];
+    final: AxleAssistantMessage | undefined;
+    usage: Stats;
+}
+interface AgentHandle<T = string> {
+    cancel(): void;
+    readonly final: Promise<AgentResult<T>>;
 }
+declare class Agent {
+    readonly provider: AIProvider;
+    readonly model: string;
+    readonly history: History;
+    readonly tracer?: TracingContext;
+    system: string | undefined;
+    tools: Record<string, Tool>;
+    private partStartCallback?;
+    private partUpdateCallback?;
+    private partEndCallback?;
+    private internalToolCallback?;
+    private errorCallback?;
+    constructor(config: AgentConfig);
+    addTool(tool: Tool): void;
+    addTools(tools: Tool[]): void;
+    hasTools(): boolean;
+    onPartStart(callback: PartStartCallback): void;
+    onPartUpdate(callback: PartUpdateCallback): void;
+    onPartEnd(callback: PartEndCallback): void;
+    onInternalTool(callback: InternalToolCallback): void;
+    onError(callback: ErrorCallback): void;
+    send(message: string): AgentHandle<string>;
+    send(instruct: Instruct<undefined>, variables?: Record<string, string>): AgentHandle<string>;
+    send<TSchema extends OutputSchema>(instruct: Instruct<TSchema>, variables?: Record<string, string>): AgentHandle<ParsedSchema<TSchema>>;
+    private execute;
+}
+
+declare function compileInstruct(instruct: Instruct<any>, variables?: Record<string, string>): string;
+
+declare function anthropic(apiKey: string): AIProvider;
+
+declare const Anthropic: {
+    readonly Models: {
+        readonly CLAUDE_OPUS_4_6: "claude-opus-4-6";
+        readonly CLAUDE_OPUS_4_5_20251101: "claude-opus-4-5-20251101";
+        readonly CLAUDE_OPUS_4_5_LATEST: "claude-opus-4-5-20251101";
+        readonly CLAUDE_HAIKU_4_5_20251001: "claude-haiku-4-5-20251001";
+        readonly CLAUDE_HAIKU_4_5: "claude-haiku-4-5-20251001";
+        readonly CLAUDE_SONNET_4_5_20250929: "claude-sonnet-4-5-20250929";
+        readonly CLAUDE_SONNET_4_5_LATEST: "claude-sonnet-4-5-20250929";
+        readonly CLAUDE_OPUS_4_1_20250805: "claude-opus-4-1-20250805";
+        readonly CLAUDE_OPUS_4_1_LATEST: "claude-opus-4-1-20250805";
+        readonly CLAUDE_OPUS_4_20250514: "claude-opus-4-20250514";
+        readonly CLAUDE_OPUS_4_LATEST: "claude-opus-4-20250514";
+        readonly CLAUDE_SONNET_4_20250514: "claude-sonnet-4-20250514";
+        readonly CLAUDE_SONNET_4_LATEST: "claude-sonnet-4-20250514";
+        readonly CLAUDE_3_7_SONNET_20250219: "claude-3-7-sonnet-20250219";
+        readonly CLAUDE_3_7_SONNET_LATEST: "claude-3-7-sonnet-20250219";
+        readonly CLAUDE_3_5_HAIKU_20241022: "claude-3-5-haiku-20241022";
+        readonly CLAUDE_3_5_HAIKU_LATEST: "claude-3-5-haiku-20241022";
+        readonly CLAUDE_3_HAIKU_20240307: "claude-3-haiku-20240307";
+    };
+    readonly DefaultModel: "claude-haiku-4-5-20251001";
+};
 
-declare const Models: {
-    readonly GPT_5: "gpt-5";
-    readonly GPT_5_MINI: "gpt-5-mini";
-    readonly GPT_5_NANO: "gpt-5-nano";
-    readonly GPT_5_CHAT_LATEST: "gpt-5-chat-latest";
-    readonly GPT_5_PRO: "gpt-5-pro";
-    readonly GPT_5_CODEX: "gpt-5-codex";
-    readonly GPT_4_5_PREVIEW: "gpt-4.5-preview";
-    readonly GPT_4_5_PREVIEW_2025_02_27: "gpt-4.5-preview-2025-02-27";
-    readonly GPT_4_1: "gpt-4.1";
-    readonly GPT_4_1_2025_04_14: "gpt-4.1-2025-04-14";
-    readonly GPT_4_1_MINI: "gpt-4.1-mini";
-    readonly GPT_4_1_MINI_2025_04_14: "gpt-4.1-mini-2025-04-14";
-    readonly GPT_4_1_NANO: "gpt-4.1-nano";
-    readonly GPT_4_1_NANO_2025_04_14: "gpt-4.1-nano-2025-04-14";
-    readonly GPT_4O: "gpt-4o";
-    readonly GPT_4O_2024_05_13: "gpt-4o-2024-05-13";
-    readonly GPT_4O_2024_08_06: "gpt-4o-2024-08-06";
-    readonly GPT_4O_2024_11_20: "gpt-4o-2024-11-20";
-    readonly GPT_4O_MINI: "gpt-4o-mini";
-    readonly GPT_4O_MINI_2024_07_18: "gpt-4o-mini-2024-07-18";
-    readonly GPT_4O_AUDIO_PREVIEW: "gpt-4o-audio-preview";
-    readonly GPT_4O_AUDIO_PREVIEW_2024_10_01: "gpt-4o-audio-preview-2024-10-01";
-    readonly GPT_4O_AUDIO_PREVIEW_2024_12_17: "gpt-4o-audio-preview-2024-12-17";
-    readonly GPT_4O_AUDIO_PREVIEW_2025_06_03: "gpt-4o-audio-preview-2025-06-03";
-    readonly GPT_4O_MINI_AUDIO_PREVIEW: "gpt-4o-mini-audio-preview";
-    readonly GPT_4O_MINI_AUDIO_PREVIEW_2024_12_17: "gpt-4o-mini-audio-preview-2024-12-17";
-    readonly GPT_REALTIME: "gpt-realtime";
-    readonly GPT_REALTIME_MINI: "gpt-realtime-mini";
-    readonly GPT_4O_REALTIME_PREVIEW: "gpt-4o-realtime-preview";
-    readonly GPT_4O_REALTIME_PREVIEW_2024_10_01: "gpt-4o-realtime-preview-2024-10-01";
-    readonly GPT_4O_REALTIME_PREVIEW_2024_12_17: "gpt-4o-realtime-preview-2024-12-17";
-    readonly GPT_4O_REALTIME_PREVIEW_2025_06_03: "gpt-4o-realtime-preview-2025-06-03";
-    readonly GPT_4O_MINI_REALTIME_PREVIEW: "gpt-4o-mini-realtime-preview";
-    readonly GPT_4O_MINI_REALTIME_PREVIEW_2024_12_17: "gpt-4o-mini-realtime-preview-2024-12-17";
-    readonly GPT_4O_SEARCH_PREVIEW: "gpt-4o-search-preview";
-    readonly GPT_4O_SEARCH_PREVIEW_2025_03_11: "gpt-4o-search-preview-2025-03-11";
-    readonly GPT_4O_MINI_SEARCH_PREVIEW: "gpt-4o-mini-search-preview";
-    readonly GPT_4O_MINI_SEARCH_PREVIEW_2025_03_11: "gpt-4o-mini-search-preview-2025-03-11";
-    readonly GPT_4O_TRANSCRIBE: "gpt-4o-transcribe";
-    readonly GPT_4O_MINI_TRANSCRIBE: "gpt-4o-mini-transcribe";
-    readonly GPT_4O_MINI_TTS: "gpt-4o-mini-tts";
-    readonly GPT_IMAGE_1: "gpt-image-1";
-    readonly GPT_IMAGE_1_MINI: "gpt-image-1-mini";
-    readonly O4_MINI: "o4-mini";
-    readonly O4_MINI_2025_04_16: "o4-mini-2025-04-16";
-    readonly O3: "o3";
-    readonly O3_PRO: "o3-pro";
-    readonly O3_MINI: "o3-mini";
-    readonly O3_MINI_2025_01_31: "o3-mini-2025-01-31";
-    readonly O1_PRO: "o1-pro";
-    readonly O1_PRO_2025_03_19: "o1-pro-2025-03-19";
-    readonly O1: "o1";
-    readonly O1_2024_12_17: "o1-2024-12-17";
-    readonly O1_MINI: "o1-mini";
-    readonly O1_MINI_2024_09_12: "o1-mini-2024-09-12";
-    readonly O1_PREVIEW: "o1-preview";
-    readonly O1_PREVIEW_2024_09_12: "o1-preview-2024-09-12";
-    readonly GPT_OSS_120B: "gpt-oss-120b";
-    readonly GPT_OSS_7B: "gpt-oss-7b";
-    readonly SORA_2: "sora-2";
-    readonly SORA_2025_05_02: "sora-2025-05-02";
-    readonly CODEX_MINI: "codex-mini";
-    readonly COMPUTER_USE_PREVIEW: "computer-use-preview";
+declare function chatCompletions(baseUrl: string, apiKey?: string): AIProvider;
+
+declare function gemini(apiKey: string): AIProvider;
+
+declare const Gemini: {
+    readonly Models: {
+        readonly GEMINI_3_PRO_PREVIEW: "gemini-3-pro-preview";
+        readonly GEMINI_3_FLASH_PREVIEW: "gemini-3-flash-preview";
+        readonly GEMINI_3_PRO_IMAGE_PREVIEW: "gemini-3-pro-image-preview";
+        readonly GEMINI_2_5_PRO: "gemini-2.5-pro";
+        readonly GEMINI_2_5_PRO_PREVIEW_TTS: "gemini-2.5-pro-preview-tts";
+        readonly GEMINI_2_5_FLASH: "gemini-2.5-flash";
+        readonly GEMINI_2_5_FLASH_LATEST: "gemini-2.5-flash";
+        readonly GEMINI_2_5_FLASH_PREVIEW_09_2025: "gemini-2.5-flash-preview-09-2025";
+        readonly GEMINI_2_5_FLASH_PREVIEW_TTS: "gemini-2.5-flash-preview-tts";
+        readonly GEMINI_2_5_FLASH_NATIVE_AUDIO_LATEST: "gemini-2.5-flash-native-audio-latest";
+        readonly GEMINI_2_5_FLASH_NATIVE_AUDIO_PREVIEW_09_2025: "gemini-2.5-flash-native-audio-preview-09-2025";
+        readonly GEMINI_2_5_FLASH_NATIVE_AUDIO_PREVIEW_12_2025: "gemini-2.5-flash-native-audio-preview-12-2025";
+        readonly GEMINI_2_5_FLASH_IMAGE: "gemini-2.5-flash-image";
+        readonly GEMINI_2_5_FLASH_LITE: "gemini-2.5-flash-lite";
+        readonly GEMINI_2_5_FLASH_LITE_LATEST: "gemini-2.5-flash-lite";
+        readonly GEMINI_2_5_FLASH_LITE_PREVIEW_09_2025: "gemini-2.5-flash-lite-preview-09-2025";
+        readonly GEMINI_2_5_COMPUTER_USE_PREVIEW_10_2025: "gemini-2.5-computer-use-preview-10-2025";
+        readonly GEMINI_2_0_FLASH: "gemini-2.0-flash";
+        readonly GEMINI_2_0_FLASH_001: "gemini-2.0-flash-001";
+        readonly GEMINI_2_0_FLASH_LATEST: "gemini-2.0-flash";
+        readonly GEMINI_2_0_FLASH_EXP_IMAGE_GENERATION: "gemini-2.0-flash-exp-image-generation";
+        readonly GEMINI_2_0_FLASH_LITE: "gemini-2.0-flash-lite";
+        readonly GEMINI_2_0_FLASH_LITE_001: "gemini-2.0-flash-lite-001";
+        readonly GEMINI_2_0_FLASH_LITE_LATEST: "gemini-2.0-flash-lite";
+        readonly GEMINI_EXP_1206: "gemini-exp-1206";
+        readonly GEMINI_FLASH_LATEST: "gemini-flash-latest";
+        readonly GEMINI_FLASH_LITE_LATEST: "gemini-flash-lite-latest";
+        readonly GEMINI_PRO_LATEST: "gemini-pro-latest";
+        readonly GEMMA_3_27B_IT: "gemma-3-27b-it";
+        readonly GEMMA_3_12B_IT: "gemma-3-12b-it";
+        readonly GEMMA_3_4B_IT: "gemma-3-4b-it";
+        readonly GEMMA_3_1B_IT: "gemma-3-1b-it";
+        readonly GEMMA_3N_E4B_IT: "gemma-3n-e4b-it";
+        readonly GEMMA_3N_E2B_IT: "gemma-3n-e2b-it";
+        readonly DEEP_RESEARCH_PRO_PREVIEW_12_2025: "deep-research-pro-preview-12-2025";
+        readonly GEMINI_ROBOTICS_ER_1_5_PREVIEW: "gemini-robotics-er-1.5-preview";
+        readonly NANO_BANANA_PRO_PREVIEW: "nano-banana-pro-preview";
+        readonly AQA: "aqa";
+    };
+    readonly DefaultModel: "gemini-2.5-flash";
 };
-declare const DEFAULT_MODEL: "gpt-5";
 
-declare const index_DEFAULT_MODEL: typeof DEFAULT_MODEL;
-declare const index_Models: typeof Models;
-declare const index_NAME: typeof NAME;
-declare namespace index {
-  export {
-    index_DEFAULT_MODEL as DEFAULT_MODEL,
-    index_Models as Models,
-    index_NAME as NAME,
-    OpenAIProvider as Provider,
-  };
-}
+interface GenerateOptions {
+    provider: AIProvider;
+    model: string;
+    messages: Array<AxleMessage>;
+    system?: string;
+    tools?: Array<ToolDefinition>;
+    onToolCall: ToolCallCallback;
+    maxIterations?: number;
+    tracer?: TracingContext;
+    options?: GenerateTurnOptions;
+}
+declare function generate(options: GenerateOptions): Promise<GenerateResult>;
+
+declare function openai(apiKey: string): AIProvider;
+
+declare const OpenAI: {
+    readonly Models: {
+        readonly GPT_5_2: "gpt-5.2";
+        readonly GPT_5_2_2025_12_11: "gpt-5.2-2025-12-11";
+        readonly GPT_5_2_CHAT_LATEST: "gpt-5.2-chat-latest";
+        readonly GPT_5_2_PRO: "gpt-5.2-pro";
+        readonly GPT_5_2_PRO_2025_12_11: "gpt-5.2-pro-2025-12-11";
+        readonly GPT_5_2_CODEX: "gpt-5.2-codex";
+        readonly GPT_5_1: "gpt-5.1";
+        readonly GPT_5_1_2025_11_13: "gpt-5.1-2025-11-13";
+        readonly GPT_5_1_CHAT_LATEST: "gpt-5.1-chat-latest";
+        readonly GPT_5_1_CODEX: "gpt-5.1-codex";
+        readonly GPT_5_1_CODEX_MAX: "gpt-5.1-codex-max";
+        readonly GPT_5_1_CODEX_MINI: "gpt-5.1-codex-mini";
+        readonly GPT_5: "gpt-5";
+        readonly GPT_5_2025_08_07: "gpt-5-2025-08-07";
+        readonly GPT_5_CHAT_LATEST: "gpt-5-chat-latest";
+        readonly GPT_5_CODEX: "gpt-5-codex";
+        readonly GPT_5_MINI: "gpt-5-mini";
+        readonly GPT_5_MINI_2025_08_07: "gpt-5-mini-2025-08-07";
+        readonly GPT_5_NANO: "gpt-5-nano";
+        readonly GPT_5_NANO_2025_08_07: "gpt-5-nano-2025-08-07";
+        readonly GPT_5_PRO: "gpt-5-pro";
+        readonly GPT_5_PRO_2025_10_06: "gpt-5-pro-2025-10-06";
+        readonly GPT_4_1: "gpt-4.1";
+        readonly GPT_4_1_2025_04_14: "gpt-4.1-2025-04-14";
+        readonly GPT_4_1_MINI: "gpt-4.1-mini";
+        readonly GPT_4_1_MINI_2025_04_14: "gpt-4.1-mini-2025-04-14";
+        readonly GPT_4_1_NANO: "gpt-4.1-nano";
+        readonly GPT_4_1_NANO_2025_04_14: "gpt-4.1-nano-2025-04-14";
+        readonly O4_MINI: "o4-mini";
+        readonly O4_MINI_2025_04_16: "o4-mini-2025-04-16";
+        readonly O3: "o3";
+        readonly O3_2025_04_16: "o3-2025-04-16";
+        readonly O3_PRO: "o3-pro";
+        readonly O3_PRO_2025_06_10: "o3-pro-2025-06-10";
+        readonly O3_MINI: "o3-mini";
+        readonly O3_MINI_2025_01_31: "o3-mini-2025-01-31";
+        readonly O1_PRO: "o1-pro";
+        readonly O1_PRO_2025_03_19: "o1-pro-2025-03-19";
+        readonly O1: "o1";
+        readonly O1_2024_12_17: "o1-2024-12-17";
+    };
+    readonly DefaultModel: "gpt-5-mini";
+};
 
 declare const BraveProviderConfigSchema: z$1.ZodObject<{
     "api-key": z$1.ZodString;
     rateLimit: z$1.ZodOptional<z$1.ZodNumber>;
 }, z$1.core.$strip>;
 type BraveProviderConfig = z$1.infer<typeof BraveProviderConfigSchema>;
-declare const JobSchema: z$1.ZodPipe<z$1.ZodTransform<any, any>, z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
-    type: z$1.ZodLiteral<"serial">;
-    tools: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-    steps: z$1.ZodArray<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
-        uses: z$1.ZodLiteral<"chat">;
-        system: z$1.ZodOptional<z$1.ZodString>;
-        message: z$1.ZodString;
-        output: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
-        replace: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            source: z$1.ZodLiteral<"file">;
-            pattern: z$1.ZodString;
-            files: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>;
-        }, z$1.core.$strip>>>;
-        tools: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-        images: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-        documents: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-        references: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-    }, z$1.core.$strip>, z$1.ZodObject<{
-        uses: z$1.ZodLiteral<"write-to-disk">;
-        output: z$1.ZodString;
-        keys: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>;
-    }, z$1.core.$strip>], "uses">>;
-}, z$1.core.$strip>, z$1.ZodObject<{
-    type: z$1.ZodLiteral<"batch">;
-    tools: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-    batch: z$1.ZodArray<z$1.ZodObject<{
-        type: z$1.ZodLiteral<"files">;
-        source: z$1.ZodString;
-        bind: z$1.ZodString;
-        "skip-if": z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            type: z$1.ZodLiteral<"file-exist">;
-            pattern: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-    }, z$1.core.$strip>>;
-    steps: z$1.ZodArray<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
-        uses: z$1.ZodLiteral<"chat">;
-        system: z$1.ZodOptional<z$1.ZodString>;
-        message: z$1.ZodString;
-        output: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
-        replace: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            source: z$1.ZodLiteral<"file">;
-            pattern: z$1.ZodString;
-            files: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>;
-        }, z$1.core.$strip>>>;
-        tools: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-        images: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-        documents: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-        references: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-    }, z$1.core.$strip>, z$1.ZodObject<{
-        uses: z$1.ZodLiteral<"write-to-disk">;
-        output: z$1.ZodString;
-        keys: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>;
-    }, z$1.core.$strip>], "uses">>;
-}, z$1.core.$strip>], "type">>;
-type Job = z$1.infer<typeof JobSchema>;
-type SerialJob = Extract<Job, {
-    type: "serial";
-}>;
-type BatchJob = Extract<Job, {
-    type: "batch";
-}>;
-declare const DAGJobSchema: z$1.ZodRecord<z$1.ZodString, z$1.ZodPipe<z$1.ZodTransform<any, any>, z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
-    type: z$1.ZodLiteral<"serial">;
-    tools: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-    steps: z$1.ZodArray<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
-        uses: z$1.ZodLiteral<"chat">;
-        system: z$1.ZodOptional<z$1.ZodString>;
-        message: z$1.ZodString;
-        output: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
-        replace: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            source: z$1.ZodLiteral<"file">;
-            pattern: z$1.ZodString;
-            files: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>;
-        }, z$1.core.$strip>>>;
-        tools: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-        images: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-        documents: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-        references: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-    }, z$1.core.$strip>, z$1.ZodObject<{
-        uses: z$1.ZodLiteral<"write-to-disk">;
-        output: z$1.ZodString;
-        keys: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>;
-    }, z$1.core.$strip>], "uses">>;
-    dependsOn: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>;
-}, z$1.core.$strip>, z$1.ZodObject<{
-    type: z$1.ZodLiteral<"batch">;
-    tools: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-    batch: z$1.ZodArray<z$1.ZodObject<{
-        type: z$1.ZodLiteral<"files">;
-        source: z$1.ZodString;
-        bind: z$1.ZodString;
-        "skip-if": z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            type: z$1.ZodLiteral<"file-exist">;
-            pattern: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-    }, z$1.core.$strip>>;
-    steps: z$1.ZodArray<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
-        uses: z$1.ZodLiteral<"chat">;
-        system: z$1.ZodOptional<z$1.ZodString>;
-        message: z$1.ZodString;
-        output: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
-        replace: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            source: z$1.ZodLiteral<"file">;
-            pattern: z$1.ZodString;
-            files: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>;
-        }, z$1.core.$strip>>>;
-        tools: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-        images: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-        documents: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-        references: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-            file: z$1.ZodString;
-        }, z$1.core.$strip>>>;
-    }, z$1.core.$strip>, z$1.ZodObject<{
-        uses: z$1.ZodLiteral<"write-to-disk">;
-        output: z$1.ZodString;
-        keys: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>;
-    }, z$1.core.$strip>], "uses">>;
-    dependsOn: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>;
-}, z$1.core.$strip>], "type">>>;
-type DAGJob = z$1.infer<typeof DAGJobSchema>;
 
 declare const braveSearchSchema: z.ZodObject<{
     searchTerm: z.ZodString;
@@ -1058,171 +725,82 @@ declare const calculatorSchema: z$1.ZodObject<{
 declare const calculatorTool: Tool<typeof calculatorSchema>;
 
 /**
- * WriteToDisk Action
- *
- * Writes content to a file on disk. This action is typically used as a workflow
- * step following an LLM call to persist the generated output.
- *
- * ## CLI Job Definition (YAML)
- *
- * In job YAML files, use the `write-to-disk` step type:
- *
- * ```yaml
- * steps:
- *   - uses: chat
- *     message: Generate a greeting for {{name}}
- *   - uses: write-to-disk
- *     output: ./output/greeting-{{name}}.txt
- * ```
- *
- * ### Properties
- *
- * | Property | Type                 | Required | Description                                      |
- * |----------|----------------------|----------|--------------------------------------------------|
- * | `uses`   | `"write-to-disk"`    | Yes      | Identifies this as a WriteToDisk step            |
- * | `output` | `string`             | Yes      | File path template (supports `{{}}` placeholders)|
- * | `keys`   | `string \| string[]` | No       | Variable keys to include in output content       |
- *
- * ### Examples
- *
- * **Basic usage** - writes the LLM response to a file:
- * ```yaml
- * - uses: write-to-disk
- *   output: ./output/result.txt
- * ```
- *
- * **With path variables** - uses `{{}}` placeholders in path:
- * ```yaml
- * - uses: write-to-disk
- *   output: ./output/greeting-{{name}}.txt
- * ```
- *
- * **With file pattern** (batch processing) - uses `*` to substitute file stem:
- * ```yaml
- * - uses: write-to-disk
- *   output: ./output/results-*.txt
- * ```
- *
- * **With specific keys** - outputs only specified variables:
- * ```yaml
- * - uses: write-to-disk
- *   output: ./output/summary.txt
- *   keys: summary
- * ```
- *
- * **With multiple keys** - outputs multiple variables, each on a new line:
- * ```yaml
- * - uses: write-to-disk
- *   output: ./output/report.txt
- *   keys:
- *     - title
- *     - summary
- *     - conclusion
- * ```
- *
- * ## Placeholder Styles
- *
- * This action uses `{{variable}}` placeholder style for all variable substitution:
- *
- * - **Path template** (`output`): Uses `{{variable}}` placeholders
- *   - Example: `./output/greeting-{{name}}.txt`
- *   - Also supports `*` for file stem substitution in batch processing
- *
- * - **Content template** (`keys`): Uses `{{variable}}` placeholders
- *   - Default template: `{{response}}`
- *   - When `keys` is specified, generates: `{{key1}}\n{{key2}}\n...`
- *
- * ## Variables Available
- *
- * All variables from the workflow context are available for substitution:
- * - `response` - The text response from the previous LLM step
- * - `$previous` - The full output object from the previous step
- * - `file` - File info object when processing batches (contains `stem`, `name`, `ext`, etc.)
- * - Any custom variables defined in the workflow or extracted by previous steps
- *
- * @see WriteToDiskStep in `src/cli/configs/types.ts` for the TypeScript interface
- * @see writeToDiskConverter in `src/cli/converters/writeToDisk.ts` for CLI conversion logic
+ * Root tracer that manages writers and creates spans.
+ * Use startSpan() to create TracingContext instances for hierarchical tracing.
+ * All logging happens within spans - the Tracer itself is just configuration and factory.
  */
-declare class WriteToDisk implements Action {
-    private pathTemplate;
-    private contentTemplate;
-    name: string;
+declare class Tracer {
+    private writers;
+    private _minLevel;
+    get minLevel(): EventLevel;
+    set minLevel(level: EventLevel);
+    addWriter(writer: TraceWriter): void;
+    removeWriter(writer: TraceWriter): void;
+    startSpan(name: string, options?: SpanOptions): TracingContext;
+    flush(): Promise<void>;
+    /** @internal */
+    _notifySpanEnd(spanData: SpanData): void;
+    /** @internal */
+    _notifySpanUpdate(spanData: SpanData): void;
+    /** @internal */
+    _notifyEvent(spanData: SpanData, event: SpanEvent): void;
+    /** @internal */
+    _notifySpanStart(spanData: SpanData): void;
+    /** @internal */
+    _notifyLLMStreamStart(spanData: SpanData): void;
+    /** @internal */
+    _notifyLLMStreamChunk(spanData: SpanData, chunk: string): void;
+    /** @internal */
+    _notifyLLMStreamEnd(spanData: SpanData, result: LLMResult): void;
+    /** @internal */
+    _shouldLog(level: EventLevel): boolean;
+}
+
+interface SimpleWriterOptions {
+    /** Minimum event level to display (default: "info") */
+    minLevel?: EventLevel;
+    /** Show internal spans - typically enabled via --debug flag (default: false) */
+    showInternal?: boolean;
+    /** Show timestamps (default: true) */
+    showTimestamp?: boolean;
+    /** Show duration on span end (default: true) */
+    showDuration?: boolean;
+    /** Custom output function (default: console.log) */
+    output?: (line: string) => void;
+}
+declare class SimpleWriter implements TraceWriter {
+    private minLevel;
+    private showInternal;
+    private showTimestamp;
+    private showDuration;
+    private output;
+    private spans;
+    private visibleDepths;
+    constructor(options?: SimpleWriterOptions);
+    private shouldShowEvent;
+    private isSpanVisible;
     /**
-     * Creates a new WriteToDisk action.
-     *
-     * @param pathTemplate - The file path template. Supports:
-     *   - `{{variable}}` placeholders for variable substitution
-     *   - `*` for file stem substitution (batch processing)
-     * @param contentTemplate - The content template using `{{variable}}` placeholders.
-     *   Defaults to `{{response}}` to output the LLM response.
+     * Find the nearest visible ancestor span for a given span.
+     * Returns null if no visible ancestor exists (root level).
      */
-    constructor(pathTemplate: string, contentTemplate?: string);
+    private findVisibleAncestor;
     /**
-     * Executes the write-to-disk action.
-     *
-     * Resolves the path and content templates using workflow variables,
-     * then writes the content to the resolved file path.
-     *
-     * @param context - The action execution context containing:
-     *   - `variables`: All workflow variables available for substitution
-     *   - `options`: Execution options (e.g., `dryRun`)
-     *   - `recorder`: Optional recorder for logging
-     * @returns A promise that resolves when the file has been written
+     * Calculate the visible depth for a span.
+     * Only counts visible ancestors in the depth.
      */
-    execute(context: ActionContext): Promise<void>;
-}
-
-interface ConcurrentWorkflow {
-    (jobConfig: BatchJob): WorkflowExecutable;
-    (planner: Planner, ...steps: WorkflowStep[]): WorkflowExecutable;
-}
-declare const concurrentWorkflow: ConcurrentWorkflow;
-
-interface DAGWorkflow {
-    (definition: DAGDefinition | DAGJob, options?: DAGWorkflowOptions): WorkflowExecutable;
-}
-declare const dagWorkflow: DAGWorkflow;
-
-interface SerialWorkflow {
-    (jobConfig: SerialJob): WorkflowExecutable;
-    (...steps: WorkflowStep[]): WorkflowExecutable;
-}
-declare const serialWorkflow: SerialWorkflow;
-
-declare class Conversation {
-    system: string;
-    private _messages;
-    constructor(messages?: AxleMessage[]);
-    get messages(): AxleMessage[];
-    addSystem(message: string): void;
-    addUser(message: string): void;
-    addUser(parts: AxleUserMessage["content"]): void;
-    addAssistant(message: string): void;
-    addAssistant(params: Omit<AxleAssistantMessage, "role">): void;
-    addToolResults(input: Array<AxleToolCallResult>): void;
-    latest(): AxleMessage | undefined;
-    toString(): string;
-}
-
-declare class ConsoleWriter implements RecorderWriter {
-    private tasks;
-    private entries;
-    private truncate;
-    private intervalId;
-    private spinnerInterval;
-    private lastRender;
-    private isRendering;
-    private inline;
-    constructor(options?: {
-        truncate?: number;
-        inline?: boolean;
-    });
-    private startSpinner;
-    private stopSpinner;
-    private renderTasks;
-    handleEvent(event: RecorderEntry): void;
-    destroy(): void;
-}
-
-export { index$3 as Anthropic, Axle, AxleStopReason, ChainOfThought, ConsoleWriter, Conversation, index$2 as Gemini, Instruct, LogLevel, index$1 as Ollama, index as OpenAI, WriteToDisk, braveSearchTool, calculatorTool, concurrentWorkflow, dagWorkflow, generate, serialWorkflow, stream };
-export type { AIProvider, Action, ActionContext, AxleAssistantMessage, AxleMessage, AxleToolCallMessage, AxleToolCallResult, AxleUserMessage, ContentPart, ContentPartFile, ContentPartText, ContentPartThinking, ContentPartToolCall, DAGDefinition, DAGWorkflowOptions, FileInfo, SerializedExecutionResponse, Tool, ToolDefinition, WorkflowStep };
+    private calculateVisibleDepth;
+    private formatTimestamp;
+    private formatDuration;
+    private formatIndent;
+    private formatSpanName;
+    onSpanStart(span: SpanData): void;
+    onSpanEnd(span: SpanData): void;
+    onSpanUpdate(span: SpanData): void;
+    onEvent(span: SpanData, event: SpanEvent): void;
+    onLLMStreamStart(span: SpanData): void;
+    onLLMStreamChunk(_span: SpanData, _chunk: string): void;
+    onLLMStreamEnd(span: SpanData, result: LLMResult): void;
+}
+
+export { Agent, Anthropic, AxleStopReason, Gemini, History, Instruct, OpenAI, SimpleWriter, Tracer, anthropic, braveSearchTool, calculatorTool, chatCompletions, compileInstruct, gemini, generate, generateTurn, loadFileContent, openai, parseResponse, stream };
+export type { AIProvider, AgentConfig, AgentHandle, AgentResult, AxleAssistantMessage, AxleMessage, AxleToolCallMessage, AxleToolCallResult, AxleUserMessage, ContentPart, ContentPartFile, ContentPartText, ContentPartThinking, ContentPartToolCall, EventLevel, FileInfo, SimpleWriterOptions, SpanData, SpanOptions, SpanType, Tool, ToolDefinition, TraceWriter, TracingContext };