@fifthrevision/axle 0.9.0 → 0.10.0

package/dist/index.d.mts

@@ -0,0 +1,1173 @@
+import * as z$2 from "zod";
+import { ZodObject, z } from "zod";
+
+//#region src/types.d.ts
+interface Stats {
+  in: number;
+  out: number;
+}
+//#endregion
+//#region src/messages/stream.d.ts
+interface StreamChunk {
+  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;
+}
+interface StreamStartChunk extends StreamChunk {
+  type: "start";
+  id: string;
+  data: {
+    model: string;
+    timestamp: number;
+  };
+}
+interface StreamCompleteChunk extends StreamChunk {
+  type: "complete";
+  data: {
+    finishReason: AxleStopReason;
+    usage: Stats;
+  };
+}
+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;
+  };
+}
+interface StreamThinkingStartChunk extends StreamChunk {
+  type: "thinking-start";
+  data: {
+    index: number;
+    id?: string;
+    redacted?: boolean;
+    signature?: string;
+  };
+}
+interface StreamThinkingDeltaChunk extends StreamChunk {
+  type: "thinking-delta";
+  data: {
+    index: number;
+    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: {
+    index: number;
+    id: string;
+    name: string;
+  };
+}
+interface StreamToolCallCompleteChunk extends StreamChunk {
+  type: "tool-call-complete";
+  data: {
+    index: number;
+    id: string;
+    name: string;
+    arguments: any;
+    providerMetadata?: Record<string, unknown>;
+  };
+}
+interface StreamInternalToolStartChunk extends StreamChunk {
+  type: "internal-tool-start";
+  data: {
+    index: number;
+    id: string;
+    name: string;
+  };
+}
+interface StreamInternalToolCompleteChunk extends StreamChunk {
+  type: "internal-tool-complete";
+  data: {
+    index: number;
+    id: string;
+    name: string;
+    output?: unknown;
+  };
+}
+type AnyStreamChunk = StreamStartChunk | StreamCompleteChunk | StreamErrorChunk | StreamTextStartChunk | StreamTextDeltaChunk | StreamTextCompleteChunk | StreamThinkingStartChunk | StreamThinkingDeltaChunk | StreamThinkingSummaryDeltaChunk | StreamThinkingCompleteChunk | StreamToolCallStartChunk | StreamToolCallCompleteChunk | StreamInternalToolStartChunk | StreamInternalToolCompleteChunk;
+//#endregion
+//#region src/tracer/types.d.ts
+type SpanStatus = "ok" | "error";
+type EventLevel = "debug" | "info" | "warn" | "error";
+type SpanType = string;
+interface SpanEvent {
+  name: 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;
+}
+interface LLMRequest {
+  messages: unknown[];
+  system?: string;
+  tools?: unknown[];
+}
+interface LLMResponse {
+  content: unknown;
+}
+interface TokenUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+}
+interface ToolResult {
+  kind: "tool";
+  name: string;
+  input: unknown;
+  output: unknown;
+}
+interface TraceWriter {
+  onSpanStart(span: SpanData): void;
+  onSpanUpdate?(span: SpanData): void;
+  onSpanEnd(span: SpanData): void;
+  onEvent?(span: SpanData, event: SpanEvent): void;
+  flush?(): Promise<void>;
+}
+/**
+ * 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;
+}
+//#endregion
+//#region src/providers/types.d.ts
+interface AIProvider {
+  get name(): string;
+  /** @internal */
+  createGenerationRequest(model: string, params: {
+    messages: Array<AxleMessage>;
+    system?: string;
+    tools?: Array<ToolDefinition>;
+    context: {
+      tracer?: TracingContext;
+    };
+    options?: {
+      temperature?: number;
+      top_p?: number;
+      max_tokens?: number;
+      frequency_penalty?: number;
+      presence_penalty?: number;
+      stop?: string | string[];
+      [key: string]: any;
+    };
+  }): Promise<ModelResult>;
+  /** @internal */
+  createStreamingRequest?(model: string, params: {
+    messages: Array<AxleMessage>;
+    system?: string;
+    tools?: Array<ToolDefinition>;
+    context: {
+      tracer?: TracingContext;
+    };
+    signal?: AbortSignal;
+    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 ModelResponse {
+  type: "success";
+  role: "assistant";
+  id: string;
+  model: string;
+  text: string;
+  content: Array<ContentPartText | ContentPartThinking | ContentPartToolCall>;
+  finishReason: AxleStopReason;
+  usage: Stats;
+  raw: any;
+}
+interface ModelError {
+  type: "error";
+  error: {
+    type: string;
+    message: string;
+  };
+  usage?: Stats;
+  raw?: any;
+}
+type ModelResult = ModelResponse | ModelError;
+declare enum AxleStopReason {
+  Stop = "stop",
+  Length = "length",
+  FunctionCall = "function_call",
+  Error = "error",
+  Custom = "custom",
+  Cancelled = "cancelled"
+}
+//#endregion
+//#region src/utils/file.d.ts
+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>;
+//#endregion
+//#region src/messages/message.d.ts
+type AxleMessage = AxleUserMessage | AxleAssistantMessage | AxleToolCallMessage;
+interface AxleUserMessage {
+  role: "user";
+  id?: string;
+  name?: string;
+  content: string | Array<ContentPart>;
+}
+interface AxleAssistantMessage {
+  role: "assistant";
+  id: string;
+  model?: string;
+  content: Array<ContentPartText | ContentPartThinking | ContentPartToolCall | ContentPartInternalTool>;
+  finishReason?: AxleStopReason;
+}
+interface AxleToolCallMessage {
+  role: "tool";
+  id: string;
+  content: Array<AxleToolCallResult>;
+}
+type ToolResultPart = {
+  type: "text";
+  text: string;
+} | {
+  type: "image";
+  data: string;
+  mimeType: string;
+};
+interface AxleToolCallResult {
+  id: string;
+  name: string;
+  content: string | ToolResultPart[];
+  isError?: boolean;
+}
+type ContentPart = ContentPartText | ContentPartFile | ContentPartToolCall | ContentPartThinking | ContentPartInternalTool;
+interface ContentPartText {
+  type: "text";
+  text: string;
+}
+interface ContentPartFile {
+  type: "file";
+  file: FileInfo;
+}
+interface ContentPartThinking {
+  type: "thinking";
+  id?: string;
+  text: string;
+  summary?: string;
+  redacted?: boolean;
+  encrypted?: string;
+  signature?: string;
+}
+interface ContentPartToolCall {
+  type: "tool-call";
+  id: string;
+  name: string;
+  parameters: Record<string, unknown>;
+  providerMetadata?: Record<string, unknown>;
+}
+interface ContentPartInternalTool {
+  type: "internal-tool";
+  id: string;
+  name: string;
+  input?: unknown;
+  output?: unknown;
+}
+//#endregion
+//#region src/tools/types.d.ts
+interface ExecutableTool<TSchema extends ZodObject<any> = ZodObject<any>> {
+  type?: "function";
+  name: string;
+  description: string;
+  schema: TSchema;
+  execute(input: z.infer<TSchema>): Promise<string | ToolResultPart[]>;
+  configure?(config: Record<string, any>): void;
+  summarize?(input: z.infer<TSchema>): string;
+}
+interface ServerTool {
+  type: "server";
+  name: string;
+  config?: Record<string, unknown>;
+}
+type AxleTool = ExecutableTool | ServerTool;
+type ToolDefinition = Pick<ExecutableTool, "name" | "description" | "schema">;
+//#endregion
+//#region src/mcp/MCP.d.ts
+interface MCPStdioConfig {
+  transport: "stdio";
+  name?: string;
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+interface MCPHttpConfig {
+  transport: "http";
+  name?: string;
+  url: string;
+  headers?: Record<string, string>;
+}
+type MCPConfig = MCPStdioConfig | MCPHttpConfig;
+declare class MCP {
+  private config;
+  private client;
+  private transport;
+  private cachedMcpTools;
+  private _connected;
+  constructor(config: MCPConfig);
+  get name(): string | undefined;
+  get connected(): boolean;
+  connect(options?: {
+    tracer?: TracingContext;
+  }): Promise<void>;
+  listTools(options?: {
+    prefix?: string;
+    tracer?: TracingContext;
+  }): Promise<ExecutableTool[]>;
+  listToolDefinitions(options?: {
+    prefix?: string;
+    tracer?: TracingContext;
+  }): Promise<ToolDefinition[]>;
+  refreshTools(): Promise<ExecutableTool[]>;
+  close(options?: {
+    tracer?: TracingContext;
+  }): Promise<void>;
+  private fetchTools;
+  private assertConnected;
+}
+//#endregion
+//#region src/store/types.d.ts
+interface FileStore {
+  read(path: string): Promise<string | null>;
+  write(path: string, content: string): Promise<void>;
+}
+//#endregion
+//#region src/memory/types.d.ts
+interface MemoryContext {
+  name?: string;
+  scope?: Record<string, string>;
+  system?: string;
+  messages: AxleMessage[];
+  newMessages?: AxleMessage[];
+  store: FileStore;
+  tracer?: TracingContext;
+}
+interface RecallResult {
+  systemSuffix?: string;
+}
+interface AgentMemory {
+  recall(context: MemoryContext): Promise<RecallResult>;
+  record(context: MemoryContext): Promise<void>;
+  tools?(): ExecutableTool[];
+}
+//#endregion
+//#region src/turns/types.d.ts
+type TurnStatus = "streaming" | "complete" | "cancelled" | "error";
+interface Turn {
+  id: string;
+  owner: "user" | "agent";
+  parts: TurnPart[];
+  status: TurnStatus;
+  usage?: Stats;
+}
+type TurnPart = TextPart | FilePart | ThinkingPart | ActionPart;
+interface TextPart {
+  id: string;
+  type: "text";
+  text: string;
+}
+interface FilePart {
+  id: string;
+  type: "file";
+  file: FileInfo;
+}
+interface ThinkingPart {
+  id: string;
+  type: "thinking";
+  text: string;
+  summary?: string;
+  redacted?: boolean;
+}
+interface ActionPartBase {
+  id: string;
+  type: "action";
+  kind: string;
+  status: "pending" | "running" | "complete" | "cancelled" | "error";
+}
+interface ToolAction extends ActionPartBase {
+  kind: "tool";
+  detail: {
+    name: string;
+    parameters: Record<string, unknown>;
+    result?: ActionResult;
+  };
+}
+interface SubagentAction extends ActionPartBase {
+  kind: "agent";
+  detail: {
+    name: string;
+    config?: Record<string, unknown>;
+    children: Turn[];
+    result?: ActionResult;
+  };
+}
+interface InternalToolAction extends ActionPartBase {
+  kind: "internal-tool";
+  detail: {
+    name: string;
+    input?: unknown;
+    result?: ActionResult;
+  };
+}
+type ActionPart = ToolAction | SubagentAction | InternalToolAction;
+type ActionResult = {
+  type: "success";
+  content: unknown;
+} | {
+  type: "error";
+  error: {
+    type: string;
+    message: string;
+  };
+};
+//#endregion
+//#region src/turns/events.d.ts
+type AgentEvent = {
+  type: "session:restore";
+  turns: Turn[];
+  config?: Record<string, unknown>;
+} | {
+  type: "turn:user";
+  turn: Turn;
+} | {
+  type: "turn:start";
+  turnId: string;
+} | {
+  type: "turn:end";
+  turnId: string;
+  status: TurnStatus;
+  usage: Stats;
+} | {
+  type: "part:start";
+  turnId: string;
+  part: TurnPart;
+} | {
+  type: "text:delta";
+  turnId: string;
+  partId: string;
+  delta: string;
+} | {
+  type: "thinking:delta";
+  turnId: string;
+  partId: string;
+  delta: string;
+} | {
+  type: "part:end";
+  turnId: string;
+  partId: string;
+} | {
+  type: "action:running";
+  turnId: string;
+  partId: string;
+  parameters?: Record<string, unknown>;
+} | {
+  type: "action:complete";
+  turnId: string;
+  partId: string;
+  result: ActionResult;
+} | {
+  type: "action:error";
+  turnId: string;
+  partId: string;
+  error: {
+    type: string;
+    message: string;
+  };
+} | {
+  type: "action:child-event";
+  turnId: string;
+  partId: string;
+  event: AgentEvent;
+} | {
+  type: "error";
+  error: {
+    type: string;
+    message: string;
+  };
+};
+//#endregion
+//#region src/utils/utils.d.ts
+interface Handle<T> {
+  cancel(): void;
+  readonly final: Promise<T>;
+}
+/**
+ * Creates a cancellable, queued async handle.
+ * Waits for `queue` before running `work`, merges an optional external signal
+ * with an internal abort controller, and returns the handle + settled promise
+ * for queue chaining.
+ */
+declare function createHandle<T>(queue: Promise<void>, work: (signal: AbortSignal) => Promise<T>, externalSignal?: AbortSignal): {
+  handle: Handle<T>;
+  settled: Promise<void>;
+};
+//#endregion
+//#region src/core/history.d.ts
+declare class History {
+  private _turns;
+  private _log;
+  constructor(init?: {
+    turns?: Turn[];
+    log?: AxleMessage[];
+  });
+  get turns(): Turn[];
+  get log(): AxleMessage[];
+  addTurn(turn: Turn): void;
+  appendToLog(messages: AxleMessage | AxleMessage[]): void;
+  latestTurn(): Turn | undefined;
+  toString(): string;
+}
+//#endregion
+//#region src/core/parse.d.ts
+type OutputSchema = Record<string, z$2.ZodTypeAny>;
+type ParsedSchema<T extends OutputSchema> = { [K in keyof T]: z$2.output<T[K]> };
+declare function parseResponse<T extends OutputSchema>(rawValue: string, schema?: T): ParsedSchema<T> | string;
+//#endregion
+//#region src/core/Instruct.d.ts
+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;
+}
+//#endregion
+//#region src/core/Agent.d.ts
+interface AgentOptions {
+  strictVariables?: boolean;
+}
+interface AgentConfig {
+  provider: AIProvider;
+  model: string;
+  system?: string;
+  name?: string;
+  scope?: Record<string, string>;
+  tools?: AxleTool[];
+  mcps?: MCP[];
+  memory?: AgentMemory;
+  tracer?: TracingContext;
+  options?: AgentOptions;
+}
+interface AgentResult<T = string> {
+  response: T | null;
+  turn: Turn | undefined;
+  usage: Stats;
+}
+type AgentHandle<T = string> = Handle<AgentResult<T>>;
+type AgentEventCallback = (event: AgentEvent) => void;
+interface SendMessageOptions {
+  signal?: AbortSignal;
+}
+interface SendInstructOptions extends SendMessageOptions {
+  variables?: Record<string, string>;
+}
+declare class Agent {
+  readonly provider: AIProvider;
+  readonly model: string;
+  readonly history: History;
+  readonly tracer?: TracingContext;
+  readonly name?: string;
+  readonly scope?: Record<string, string>;
+  readonly store: FileStore;
+  system: string | undefined;
+  tools: Record<string, ExecutableTool>;
+  serverTools: ServerTool[];
+  private mcps;
+  private mcpToolsResolved;
+  private memory?;
+  private options;
+  private eventCallbacks;
+  private sendQueue;
+  constructor(config: AgentConfig);
+  addTool(tool: AxleTool): void;
+  addTools(tools: AxleTool[]): void;
+  addMcp(mcp: MCP): void;
+  addMcps(mcps: MCP[]): void;
+  hasTools(): boolean;
+  on(callback: AgentEventCallback): void;
+  send(message: string, options?: SendMessageOptions): AgentHandle<string>;
+  send(instruct: Instruct<undefined>, options?: SendInstructOptions): AgentHandle<string>;
+  send<TSchema extends OutputSchema>(instruct: Instruct<TSchema>, options?: SendInstructOptions): AgentHandle<ParsedSchema<TSchema>>;
+  private resolveMcpTools;
+  private emitEvent;
+  private run;
+}
+//#endregion
+//#region src/core/compile.d.ts
+interface CompileOptions {
+  strictVariables?: boolean;
+}
+declare function compileInstruct(instruct: Instruct<any>, variables?: Record<string, string>, options?: CompileOptions): string;
+//#endregion
+//#region src/providers/anthropic/provider.d.ts
+declare function anthropic(apiKey: string): AIProvider;
+//#endregion
+//#region src/providers/anthropic/index.d.ts
+declare const Anthropic: {
+  readonly Models: {
+    readonly CLAUDE_SONNET_4_6: "claude-sonnet-4-6";
+    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: "claude-opus-4-5-20251101";
+    readonly CLAUDE_SONNET_4_5_20250929: "claude-sonnet-4-5-20250929";
+    readonly CLAUDE_SONNET_4_5: "claude-sonnet-4-5-20250929";
+    readonly CLAUDE_HAIKU_4_5_20251001: "claude-haiku-4-5-20251001";
+    readonly CLAUDE_HAIKU_4_5: "claude-haiku-4-5-20251001";
+    readonly CLAUDE_OPUS_4_1_20250805: "claude-opus-4-1-20250805";
+    readonly CLAUDE_OPUS_4_1: "claude-opus-4-1-20250805";
+    readonly CLAUDE_OPUS_4_20250514: "claude-opus-4-20250514";
+    readonly CLAUDE_OPUS_4: "claude-opus-4-20250514";
+    readonly CLAUDE_SONNET_4_20250514: "claude-sonnet-4-20250514";
+    readonly CLAUDE_SONNET_4: "claude-sonnet-4-20250514";
+    readonly CLAUDE_3_HAIKU_20240307: "claude-3-haiku-20240307";
+    readonly CLAUDE_3_HAIKU: "claude-3-haiku-20240307";
+  };
+  readonly DefaultModel: "claude-haiku-4-5-20251001";
+};
+//#endregion
+//#region src/providers/chatcompletions/provider.d.ts
+declare function chatCompletions(baseUrl: string, apiKey?: string): AIProvider;
+//#endregion
+//#region src/providers/gemini/provider.d.ts
+declare function gemini(apiKey: string): AIProvider;
+//#endregion
+//#region src/providers/gemini/index.d.ts
+declare const Gemini: {
+  readonly Models: {
+    readonly GEMINI_3_1_PRO_PREVIEW: "gemini-3.1-pro-preview";
+    readonly GEMINI_3_1_PRO_PREVIEW_CUSTOMTOOLS: "gemini-3.1-pro-preview-customtools";
+    readonly GEMINI_3_1_FLASH_LITE_PREVIEW: "gemini-3.1-flash-lite-preview";
+    readonly GEMINI_3_PRO_PREVIEW: "gemini-3-pro-preview";
+    readonly GEMINI_3_FLASH_PREVIEW: "gemini-3-flash-preview";
+    readonly GEMINI_2_5_PRO: "gemini-2.5-pro";
+    readonly GEMINI_2_5_FLASH: "gemini-2.5-flash";
+    readonly GEMINI_2_5_FLASH_LITE: "gemini-2.5-flash-lite";
+    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_LITE: "gemini-2.0-flash-lite";
+    readonly GEMINI_2_0_FLASH_LITE_001: "gemini-2.0-flash-lite-001";
+    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_4_31B_IT: "gemma-4-31b-it";
+    readonly GEMMA_4_E4B_IT: "gemma-4-26b-a4b-it";
+    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 DefaultModel: "gemini-3.1-flash-lite-preview";
+};
+//#endregion
+//#region src/providers/helpers.d.ts
+type ToolCallResult = {
+  type: "success";
+  content: string | ToolResultPart[];
+} | {
+  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;
+};
+//#endregion
+//#region src/providers/generateTurn.d.ts
+interface GenerateTurnOptions {
+  temperature?: number;
+  top_p?: number;
+  max_tokens?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+  stop?: string | string[];
+  [key: string]: any;
+}
+interface GenerateTurnProps {
+  provider: AIProvider;
+  model: string;
+  messages: Array<AxleMessage>;
+  system?: string;
+  tools?: Array<ToolDefinition>;
+  tracer?: TracingContext;
+  options?: GenerateTurnOptions;
+}
+declare function generateTurn(props: GenerateTurnProps): Promise<ModelResult>;
+//#endregion
+//#region src/providers/generate.d.ts
+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>;
+//#endregion
+//#region src/providers/stream.d.ts
+type StreamEvent = {
+  type: "turn:start";
+  id: string;
+  model: string;
+} | {
+  type: "turn:complete";
+  message: AxleAssistantMessage;
+  usage?: Stats;
+} | {
+  type: "tool-results:start";
+  id: string;
+} | {
+  type: "tool-results:complete";
+  message: AxleToolCallMessage;
+} | {
+  type: "text:start";
+  index: number;
+} | {
+  type: "text:delta";
+  index: number;
+  delta: string;
+  accumulated: string;
+} | {
+  type: "text:end";
+  index: number;
+  final: string;
+} | {
+  type: "thinking:start";
+  index: number;
+} | {
+  type: "thinking:delta";
+  index: number;
+  delta: string;
+  accumulated: string;
+} | {
+  type: "thinking:end";
+  index: number;
+  final: string;
+} | {
+  type: "tool:request";
+  index: number;
+  id: string;
+  name: string;
+} | {
+  type: "tool:exec-start";
+  index: number;
+  id: string;
+  name: string;
+  parameters: Record<string, unknown>;
+} | {
+  type: "tool:exec-complete";
+  index: number;
+  id: string;
+  name: string;
+  result: ToolCallResult;
+} | {
+  type: "internal-tool:start";
+  index: number;
+  id: string;
+  name: string;
+} | {
+  type: "internal-tool:complete";
+  index: number;
+  id: string;
+  name: string;
+  output?: unknown;
+} | {
+  type: "error";
+  error: GenerateError;
+};
+type StreamEventCallback = (event: StreamEvent) => void;
+interface StreamOptions {
+  provider: AIProvider;
+  model: string;
+  messages: Array<AxleMessage>;
+  system?: string;
+  tools?: Array<ToolDefinition>;
+  serverTools?: Array<ServerTool>;
+  onToolCall?: ToolCallCallback;
+  maxIterations?: number;
+  tracer?: TracingContext;
+  options?: GenerateTurnOptions;
+  signal?: AbortSignal;
+}
+interface StreamHandle {
+  on(callback: StreamEventCallback): void;
+  cancel(): void;
+  readonly final: Promise<StreamResult>;
+}
+declare function stream(options: StreamOptions): StreamHandle;
+//#endregion
+//#region src/providers/openai/provider.d.ts
+declare function openai(apiKey: string): AIProvider;
+//#endregion
+//#region src/providers/openai/index.d.ts
+declare const OpenAI: {
+  readonly Models: {
+    readonly GPT_5_4_2026_03_05: "gpt-5.4-2026-03-05";
+    readonly GPT_5_4: "gpt-5.4";
+    readonly GPT_5_4_PRO_2026_03_05: "gpt-5.4-pro-2026-03-05";
+    readonly GPT_5_4_PRO: "gpt-5.4-pro";
+    readonly GPT_5_4_MINI_2026_03_17: "gpt-5.4-mini-2026-03-17";
+    readonly GPT_5_4_MINI: "gpt-5.4-mini";
+    readonly GPT_5_4_NANO_2026_03_17: "gpt-5.4-nano-2026-03-17";
+    readonly GPT_5_4_NANO: "gpt-5.4-nano";
+    readonly GPT_5_2_2025_12_11: "gpt-5.2-2025-12-11";
+    readonly GPT_5_2: "gpt-5.2";
+    readonly GPT_5_2_CHAT_LATEST: "gpt-5.2-chat-latest";
+    readonly GPT_5_2_PRO_2025_12_11: "gpt-5.2-pro-2025-12-11";
+    readonly GPT_5_2_PRO: "gpt-5.2-pro";
+    readonly GPT_5_1_2025_11_13: "gpt-5.1-2025-11-13";
+    readonly GPT_5_1: "gpt-5.1";
+    readonly GPT_5_1_CHAT_LATEST: "gpt-5.1-chat-latest";
+    readonly GPT_5_2025_08_07: "gpt-5-2025-08-07";
+    readonly GPT_5: "gpt-5";
+    readonly GPT_5_CHAT_LATEST: "gpt-5-chat-latest";
+    readonly GPT_5_PRO_2025_10_06: "gpt-5-pro-2025-10-06";
+    readonly GPT_5_PRO: "gpt-5-pro";
+    readonly GPT_5_MINI_2025_08_07: "gpt-5-mini-2025-08-07";
+    readonly GPT_5_MINI: "gpt-5-mini";
+    readonly GPT_5_NANO_2025_08_07: "gpt-5-nano-2025-08-07";
+    readonly GPT_5_NANO: "gpt-5-nano";
+    readonly GPT_4_1_2025_04_14: "gpt-4.1-2025-04-14";
+    readonly GPT_4_1: "gpt-4.1";
+    readonly GPT_4_1_MINI_2025_04_14: "gpt-4.1-mini-2025-04-14";
+    readonly GPT_4_1_MINI: "gpt-4.1-mini";
+    readonly GPT_4_1_NANO_2025_04_14: "gpt-4.1-nano-2025-04-14";
+    readonly GPT_4_1_NANO: "gpt-4.1-nano";
+    readonly GPT_4O_2024_11_20: "gpt-4o-2024-11-20";
+    readonly GPT_4O_2024_08_06: "gpt-4o-2024-08-06";
+    readonly GPT_4O_2024_05_13: "gpt-4o-2024-05-13";
+    readonly GPT_4O: "gpt-4o";
+    readonly GPT_4O_MINI_2024_07_18: "gpt-4o-mini-2024-07-18";
+    readonly GPT_4O_MINI: "gpt-4o-mini";
+    readonly O4_MINI_2025_04_16: "o4-mini-2025-04-16";
+    readonly O4_MINI: "o4-mini";
+    readonly O3_2025_04_16: "o3-2025-04-16";
+    readonly O3: "o3";
+    readonly O3_PRO_2025_06_10: "o3-pro-2025-06-10";
+    readonly O3_PRO: "o3-pro";
+    readonly O3_MINI_2025_01_31: "o3-mini-2025-01-31";
+    readonly O3_MINI: "o3-mini";
+    readonly O1_2024_12_17: "o1-2024-12-17";
+    readonly O1: "o1";
+    readonly O1_PRO_2025_03_19: "o1-pro-2025-03-19";
+    readonly O1_PRO: "o1-pro";
+  };
+  readonly DefaultModel: "gpt-5.4-mini";
+};
+//#endregion
+//#region src/cli/configs/schemas.d.ts
+declare const BraveProviderConfigSchema: z.ZodObject<{
+  "api-key": z.ZodString;
+  rateLimit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type BraveProviderConfig = z.infer<typeof BraveProviderConfigSchema>;
+//#endregion
+//#region src/tools/brave.d.ts
+declare const braveSearchSchema: z$2.ZodObject<{
+  searchTerm: z$2.ZodString;
+}, z$2.core.$strip>;
+declare class BraveSearchTool implements ExecutableTool<typeof braveSearchSchema> {
+  name: string;
+  description: string;
+  schema: z$2.ZodObject<{
+    searchTerm: z$2.ZodString;
+  }, z$2.core.$strip>;
+  apiKey: string | undefined;
+  throttle: number | undefined;
+  lastExecTime: number;
+  constructor(config?: BraveProviderConfig);
+  configure(config: BraveProviderConfig): void;
+  execute(params: z$2.infer<typeof braveSearchSchema>): Promise<string>;
+}
+declare const braveSearchTool: BraveSearchTool;
+//#endregion
+//#region src/tools/calculator.d.ts
+declare const calculatorSchema: z.ZodObject<{
+  operation: z.ZodEnum<{
+    add: "add";
+    subtract: "subtract";
+    multiply: "multiply";
+    divide: "divide";
+  }>;
+  a: z.ZodNumber;
+  b: z.ZodNumber;
+}, z.core.$strip>;
+declare const calculatorTool: ExecutableTool<typeof calculatorSchema>;
+//#endregion
+//#region src/turns/builder.d.ts
+declare class TurnBuilder {
+  private currentTurn;
+  private currentTextPart;
+  private currentThinkingPart;
+  private toolIdMap;
+  private accumulatedUsage;
+  createUserTurn(message: AxleUserMessage): {
+    turn: Turn;
+    events: AgentEvent[];
+  };
+  startAgentTurn(): {
+    turn: Turn;
+    events: AgentEvent[];
+  };
+  handleStreamEvent(event: StreamEvent): AgentEvent[];
+  finalizeTurn(outcome?: "complete" | "cancelled" | "error"): AgentEvent[];
+  private closeOpenParts;
+  private findActionPart;
+}
+//#endregion
+//#region src/tracer/tracer.d.ts
+/**
+ * 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 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 */
+  _shouldLog(level: EventLevel): boolean;
+}
+//#endregion
+//#region src/tracer/writers/simple.d.ts
+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;
+  /** Render markdown in event messages that have markdown: true attribute (default: false) */
+  markdown?: 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 markdown;
+  private output;
+  private spans;
+  private visibleDepths;
+  constructor(options?: SimpleWriterOptions);
+  private shouldShowEvent;
+  private isSpanVisible;
+  /**
+   * Find the nearest visible ancestor span for a given span.
+   * Returns null if no visible ancestor exists (root level).
+   */
+  private findVisibleAncestor;
+  /**
+   * Calculate the visible depth for a span.
+   * Only counts visible ancestors in the depth.
+   */
+  private calculateVisibleDepth;
+  private formatTimestamp;
+  private formatDuration;
+  private formatIndent;
+  private formatSpanName;
+  private renderMarkdown;
+  onSpanStart(span: SpanData): void;
+  onSpanEnd(span: SpanData): void;
+  onSpanUpdate(span: SpanData): void;
+  onEvent(span: SpanData, event: SpanEvent): void;
+}
+//#endregion
+//#region src/memory/ProceduralMemory.d.ts
+interface ProceduralMemoryConfig {
+  provider: AIProvider;
+  model: string;
+  enableTools?: boolean;
+}
+declare class ProceduralMemory implements AgentMemory {
+  private provider;
+  private model;
+  private enableTools;
+  private lastStore?;
+  private lastName?;
+  private lastScope?;
+  constructor(config: ProceduralMemoryConfig);
+  recall(context: MemoryContext): Promise<RecallResult>;
+  record(context: MemoryContext): Promise<void>;
+  tools(): ExecutableTool[];
+  private formatMessages;
+  private parseInstructions;
+  private getStorePath;
+  private loadStore;
+  private saveStore;
+}
+//#endregion
+//#region src/store/LocalFileStore.d.ts
+declare class LocalFileStore implements FileStore {
+  readonly rootPath: string;
+  constructor(rootPath: string);
+  read(path: string): Promise<string | null>;
+  write(path: string, content: string): Promise<void>;
+}
+//#endregion
+export { type AIProvider, type ActionPart, type ActionResult, Agent, type AgentConfig, type AgentEvent, type AgentEventCallback, type AgentHandle, type AgentMemory, type AgentResult, Anthropic, type AxleAssistantMessage, type AxleMessage, AxleStopReason, type AxleTool, type AxleToolCallMessage, type AxleToolCallResult, type AxleUserMessage, type ContentPart, type ContentPartFile, type ContentPartInternalTool, type ContentPartText, type ContentPartThinking, type ContentPartToolCall, type EventLevel, type ExecutableTool, type FileInfo, type FilePart, type FileStore, Gemini, type Handle, History, Instruct, type InternalToolAction, LocalFileStore, MCP, type MCPConfig, type MCPHttpConfig, type MCPStdioConfig, type MemoryContext, OpenAI, ProceduralMemory, type ProceduralMemoryConfig, type RecallResult, type SendInstructOptions, type SendMessageOptions, type ServerTool, SimpleWriter, type SimpleWriterOptions, type SpanData, type SpanOptions, type SpanType, type StreamEvent, type StreamEventCallback, type StreamHandle, type StreamResult, type SubagentAction, type TextPart, type ThinkingPart, type ToolAction, type ToolDefinition, type ToolResultPart, type TraceWriter, Tracer, type TracingContext, type Turn, TurnBuilder, type TurnPart, type TurnStatus, anthropic, braveSearchTool, calculatorTool, chatCompletions, compileInstruct, createHandle, gemini, generate, generateTurn, loadFileContent, openai, parseResponse, stream };