llmist 6.1.0 → 6.2.0

package/dist/{mock-stream-Cq1Sxezz.d.ts → mock-stream-DG4wF-NH.d.ts}

@@ -1,4 +1,5 @@
-import { ZodTypeAny } from 'zod';
+import * as zod from 'zod';
+import { ZodType, ZodTypeAny } from 'zod';
 import { Logger, ILogObj } from 'tslog';
 
 /**
@@ -213,990 +214,1255 @@ interface SpeechModelSpec {
     };
 }
 
-/**
- * Model Catalog Types
- *
- * Type definitions for LLM model specifications including
- * context windows, pricing, features, and capabilities.
- */
-interface ModelPricing {
-    /** Price per 1 million input tokens in USD */
-    input: number;
-    /** Price per 1 million output tokens in USD */
-    output: number;
-    /** Price per 1 million cached input tokens in USD (if supported) */
-    cachedInput?: number;
-    /** Price per 1 million cache write tokens in USD (Anthropic: 1.25x input price) */
-    cacheWriteInput?: number;
+interface LLMGenerationOptions {
+    model: string;
+    messages: LLMMessage[];
+    maxTokens?: number;
+    temperature?: number;
+    topP?: number;
+    stopSequences?: string[];
+    responseFormat?: "text";
+    metadata?: Record<string, unknown>;
+    extra?: Record<string, unknown>;
+    /**
+     * Optional abort signal for cancelling the request mid-flight.
+     *
+     * When the signal is aborted, the provider will attempt to cancel
+     * the underlying HTTP request and the stream will terminate with
+     * an abort error. Use `isAbortError()` from `@/core/errors` to
+     * detect cancellation in error handling.
+     *
+     * @example
+     * ```typescript
+     * const controller = new AbortController();
+     *
+     * const stream = client.stream({
+     *   model: "claude-3-5-sonnet-20241022",
+     *   messages: [{ role: "user", content: "Tell me a long story" }],
+     *   signal: controller.signal,
+     * });
+     *
+     * // Cancel after 5 seconds
+     * setTimeout(() => controller.abort(), 5000);
+     *
+     * try {
+     *   for await (const chunk of stream) {
+     *     process.stdout.write(chunk.text);
+     *   }
+     * } catch (error) {
+     *   if (isAbortError(error)) {
+     *     console.log("\nRequest was cancelled");
+     *   } else {
+     *     throw error;
+     *   }
+     * }
+     * ```
+     */
+    signal?: AbortSignal;
 }
-interface ModelFeatures {
-    /** Supports streaming responses */
-    streaming: boolean;
-    /** Supports function/tool calling */
-    functionCalling: boolean;
-    /** Supports vision/image input */
-    vision: boolean;
-    /** Supports extended thinking/reasoning */
-    reasoning?: boolean;
-    /** Supports structured outputs */
-    structuredOutputs?: boolean;
-    /** Supports fine-tuning */
-    fineTuning?: boolean;
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    /** Number of input tokens served from cache (subset of inputTokens) */
+    cachedInputTokens?: number;
+    /** Number of input tokens written to cache (subset of inputTokens, Anthropic only) */
+    cacheCreationInputTokens?: number;
 }
-interface ModelSpec {
-    /** Provider identifier (e.g., 'openai', 'anthropic', 'gemini') */
-    provider: string;
-    /** Full model identifier used in API calls */
-    modelId: string;
-    /** Human-readable display name */
-    displayName: string;
-    /** Maximum context window size in tokens */
-    contextWindow: number;
-    /** Maximum output tokens per request */
-    maxOutputTokens: number;
-    /** Pricing per 1M tokens */
-    pricing: ModelPricing;
-    /** Training data knowledge cutoff date (YYYY-MM-DD or description) */
-    knowledgeCutoff: string;
-    /** Supported features and capabilities */
-    features: ModelFeatures;
-    /** Additional metadata */
-    metadata?: {
-        /** Model family/series */
-        family?: string;
-        /** Release date */
-        releaseDate?: string;
-        /** Deprecation date if applicable */
-        deprecationDate?: string;
-        /** Notes or special information */
-        notes?: string;
-        /** Whether manual temperature configuration is supported (defaults to true) */
-        supportsTemperature?: boolean;
-    };
+interface LLMStreamChunk {
+    text: string;
+    /**
+     * Indicates that the provider has finished producing output and includes the reason if available.
+     */
+    finishReason?: string | null;
+    /**
+     * Token usage information, typically available in the final chunk when the stream completes.
+     */
+    usage?: TokenUsage;
+    /**
+     * Provider specific payload emitted at the same time as the text chunk. This is useful for debugging and tests.
+     */
+    rawEvent?: unknown;
 }
-interface ModelLimits {
-    contextWindow: number;
-    maxOutputTokens: number;
+interface LLMStream extends AsyncIterable<LLMStreamChunk> {
 }
-interface CostEstimate {
-    inputCost: number;
-    /** Cost for cached input tokens (already included in inputCost calculation) */
-    cachedInputCost: number;
-    /** Cost for cache creation tokens (already included in inputCost calculation, Anthropic only) */
-    cacheCreationCost: number;
-    outputCost: number;
-    totalCost: number;
-    currency: "USD";
+type ProviderIdentifier = string;
+interface ModelDescriptor {
+    provider: string;
+    name: string;
+}
+declare class ModelIdentifierParser {
+    private readonly defaultProvider;
+    constructor(defaultProvider?: string);
+    parse(identifier: string): ModelDescriptor;
 }
 
 /**
- * Strategy interface for context compaction.
+ * Unified event types for the Execution Tree.
  *
- * Strategies define how conversation history is compressed to fit within
- * context window limits. Different strategies trade off between:
- * - Speed (LLM calls vs local processing)
- * - Context preservation (summary quality vs simple truncation)
- * - Cost (summarization model usage)
+ * All events carry full tree context (nodeId, parentId, depth, path).
+ * No special SubagentEvent wrapper needed - subagent events are regular
+ * events with depth > 0.
+ *
+ * @module core/execution-events
  */
 
 /**
- * Context provided to compaction strategies.
+ * Base properties shared by all execution events.
+ * Every event carries full tree context.
  */
-interface CompactionContext {
-    /** Current token count of the conversation */
-    currentTokens: number;
-    /** Target token count after compaction */
-    targetTokens: number;
-    /** Model's context window limits */
-    modelLimits: ModelLimits;
-    /** LLMist client for summarization calls */
-    client: LLMist;
-    /** Model identifier for token counting and summarization */
+interface BaseExecutionEvent {
+    /** Monotonically increasing event ID */
+    eventId: number;
+    /** Event timestamp */
+    timestamp: number;
+    /** Node that emitted this event */
+    nodeId: string;
+    /** Parent node ID (null for root events) */
+    parentId: string | null;
+    /** Nesting depth (0 = root, 1 = child, etc.) */
+    depth: number;
+    /** Full path from root to this node */
+    path: string[];
+}
+/**
+ * Emitted when an LLM call starts.
+ */
+interface LLMCallStartEvent extends BaseExecutionEvent {
+    type: "llm_call_start";
+    /** Iteration number within agent loop (1-indexed) */
+    iteration: number;
+    /** Model identifier */
     model: string;
+    /** Request messages */
+    request?: LLMMessage[];
 }
 /**
- * Result of a compaction operation.
+ * Emitted for each streaming chunk from LLM.
  */
-interface CompactionResult {
-    /** Compacted messages to replace history with */
-    messages: LLMMessage[];
-    /** Summary text if summarization was used */
-    summary?: string;
-    /** The name of the strategy that was ultimately executed */
-    strategyName: string;
-    /** Metadata about the compaction */
-    metadata: {
-        /** Number of messages before compaction */
-        originalCount: number;
-        /** Number of messages after compaction */
-        compactedCount: number;
-        /** Estimated tokens before compaction */
-        tokensBefore: number;
-        /** Estimated tokens after compaction */
-        tokensAfter: number;
-    };
+interface LLMCallStreamEvent extends BaseExecutionEvent {
+    type: "llm_call_stream";
+    /** Text chunk */
+    chunk: string;
 }
 /**
- * Interface for compaction strategy implementations.
- *
- * Strategies receive the conversation history (excluding base messages like
- * system prompt and gadget instructions) and must return a compacted version.
- *
- * @example
- * ```typescript
- * class MyCustomStrategy implements CompactionStrategy {
- *   readonly name = 'my-custom';
- *
- *   async compact(
- *     messages: LLMMessage[],
- *     config: ResolvedCompactionConfig,
- *     context: CompactionContext
- *   ): Promise<CompactionResult> {
- *     // Custom compaction logic
- *     return {
- *       messages: compactedMessages,
- *       metadata: { ... }
- *     };
- *   }
- * }
- * ```
+ * Emitted when an LLM call completes successfully.
  */
-interface CompactionStrategy {
-    /** Human-readable name of the strategy */
-    readonly name: string;
-    /**
-     * Compact the given messages to fit within target token count.
-     *
-     * @param messages - Conversation history messages (excludes system/gadget base)
-     * @param config - Resolved compaction configuration
-     * @param context - Context including token counts and LLM client
-     * @returns Compacted messages with metadata
-     */
-    compact(messages: LLMMessage[], config: ResolvedCompactionConfig, context: CompactionContext): Promise<CompactionResult>;
+interface LLMCallCompleteEvent extends BaseExecutionEvent {
+    type: "llm_call_complete";
+    /** Complete response text */
+    response: string;
+    /** Token usage */
+    usage?: TokenUsage;
+    /** Finish reason from LLM */
+    finishReason?: string | null;
+    /** Cost in USD */
+    cost?: number;
 }
 /**
- * Utility to group messages into logical conversation turns.
- *
- * A "turn" is typically a user message followed by an assistant response.
- * Gadget calls are grouped with the preceding assistant message.
+ * Emitted when an LLM call fails.
  */
-interface MessageTurn {
-    /** Messages in this turn (user + assistant + any gadget results) */
-    messages: LLMMessage[];
-    /** Estimated token count for this turn */
-    tokenEstimate: number;
+interface LLMCallErrorEvent extends BaseExecutionEvent {
+    type: "llm_call_error";
+    /** The error that occurred */
+    error: Error;
+    /** Whether the error was recovered by a controller */
+    recovered: boolean;
 }
-
 /**
- * Configuration types for the context compaction system.
- *
- * Context compaction automatically manages conversation history to prevent
- * context window overflow in long-running agent conversations.
+ * Emitted when a gadget call is parsed from LLM output (before execution).
  */
-
+interface GadgetCallEvent extends BaseExecutionEvent {
+    type: "gadget_call";
+    /** Invocation ID */
+    invocationId: string;
+    /** Gadget name */
+    name: string;
+    /** Parameters */
+    parameters: Record<string, unknown>;
+    /** Dependencies (other invocation IDs) */
+    dependencies: string[];
+}
 /**
- * Event emitted when compaction occurs.
- * This is included in StreamEvent for UI visibility.
+ * Emitted when gadget execution starts.
  */
-interface CompactionEvent$1 {
-    /** The strategy that performed the compaction */
-    strategy: string;
-    /** Token count before compaction */
-    tokensBefore: number;
-    /** Token count after compaction */
-    tokensAfter: number;
-    /** Number of messages before compaction */
-    messagesBefore: number;
-    /** Number of messages after compaction */
-    messagesAfter: number;
-    /** Summary text if summarization was used */
-    summary?: string;
-    /** Agent iteration when compaction occurred */
-    iteration: number;
+interface GadgetStartEvent extends BaseExecutionEvent {
+    type: "gadget_start";
+    /** Invocation ID */
+    invocationId: string;
+    /** Gadget name */
+    name: string;
 }
 /**
- * Statistics about compaction activity.
+ * Emitted when gadget execution completes successfully.
  */
-interface CompactionStats {
-    /** Total number of compactions performed */
-    totalCompactions: number;
-    /** Total tokens saved across all compactions */
-    totalTokensSaved: number;
-    /** Current context usage */
-    currentUsage: {
-        tokens: number;
-        percent: number;
-    };
-    /** Model's context window size */
-    contextWindow: number;
+interface GadgetCompleteEvent extends BaseExecutionEvent {
+    type: "gadget_complete";
+    /** Invocation ID */
+    invocationId: string;
+    /** Gadget name */
+    name: string;
+    /** Result string */
+    result: string;
+    /** Execution time in ms */
+    executionTimeMs: number;
+    /** Cost in USD */
+    cost?: number;
+    /** Media outputs */
+    media?: GadgetMediaOutput[];
 }
 /**
- * Configuration for the context compaction system.
- *
- * @example
- * ```typescript
- * // Custom configuration
- * const agent = await LLMist.createAgent()
- *   .withModel('sonnet')
- *   .withCompaction({
- *     triggerThresholdPercent: 70,
- *     targetPercent: 40,
- *     preserveRecentTurns: 10,
- *   })
- *   .ask('...');
- *
- * // Disable compaction
- * const agent = await LLMist.createAgent()
- *   .withModel('sonnet')
- *   .withoutCompaction()
- *   .ask('...');
- * ```
+ * Emitted when gadget execution fails.
  */
-interface CompactionConfig {
-    /**
-     * Enable or disable compaction.
-     * @default true
-     */
-    enabled?: boolean;
-    /**
-     * The compaction strategy to use.
-     * - 'sliding-window': Fast, drops oldest turns (no LLM call)
-     * - 'summarization': LLM-based compression of old messages
-     * - 'hybrid': Summarizes old messages + keeps recent turns (recommended)
-     * - Or provide a custom CompactionStrategy instance
-     * @default 'hybrid'
-     */
-    strategy?: "sliding-window" | "summarization" | "hybrid" | CompactionStrategy;
-    /**
-     * Context usage percentage that triggers compaction.
-     * When token count exceeds this percentage of the context window,
-     * compaction is performed before the next LLM call.
-     * @default 80
-     */
-    triggerThresholdPercent?: number;
-    /**
-     * Target context usage percentage after compaction.
-     * The compaction will aim to reduce tokens to this percentage.
-     * @default 50
-     */
-    targetPercent?: number;
-    /**
-     * Number of recent turns to preserve during compaction.
-     * A "turn" is a user message + assistant response pair.
-     * Recent turns are kept verbatim while older ones are summarized/dropped.
-     * @default 5
-     */
-    preserveRecentTurns?: number;
-    /**
-     * Model to use for summarization.
-     * If not specified, uses the agent's model.
-     * @default undefined (uses agent's model)
-     */
-    summarizationModel?: string;
-    /**
-     * Custom system prompt for summarization.
-     * If not specified, uses a default prompt optimized for context preservation.
-     */
-    summarizationPrompt?: string;
-    /**
-     * Callback invoked when compaction occurs.
-     * Useful for logging or analytics.
-     */
-    onCompaction?: (event: CompactionEvent$1) => void;
+interface GadgetErrorEvent extends BaseExecutionEvent {
+    type: "gadget_error";
+    /** Invocation ID */
+    invocationId: string;
+    /** Gadget name */
+    name: string;
+    /** Error message */
+    error: string;
+    /** Execution time in ms */
+    executionTimeMs: number;
+}
+/**
+ * Emitted when a gadget is skipped.
+ */
+interface GadgetSkippedEvent$1 extends BaseExecutionEvent {
+    type: "gadget_skipped";
+    /** Invocation ID */
+    invocationId: string;
+    /** Gadget name */
+    name: string;
+    /** Reason for skipping */
+    reason: "dependency_failed" | "controller_skip";
+    /** Error message (combines reason and failedDependencyError for consistency with GadgetErrorEvent) */
+    error: string;
+    /** Failed dependency invocation ID (if dependency_failed) */
+    failedDependency?: string;
+    /** Error message from failed dependency */
+    failedDependencyError?: string;
+}
+/**
+ * Emitted for text output from LLM (pure notification, not a tree node).
+ */
+interface TextEvent extends BaseExecutionEvent {
+    type: "text";
+    /** Text content */
+    content: string;
+}
+/**
+ * Emitted when context compaction occurs.
+ */
+interface CompactionEvent$1 extends BaseExecutionEvent {
+    type: "compaction";
+    /** Tokens before compaction */
+    tokensBefore: number;
+    /** Tokens after compaction */
+    tokensAfter: number;
+    /** Compaction strategy used */
+    strategy: string;
+    /** Messages removed */
+    messagesRemoved: number;
+}
+/**
+ * Emitted when human input is required.
+ */
+interface HumanInputRequiredEvent extends BaseExecutionEvent {
+    type: "human_input_required";
+    /** Question for the user */
+    question: string;
+    /** Gadget name requesting input */
+    gadgetName: string;
+    /** Invocation ID */
+    invocationId: string;
 }
 /**
- * Default configuration values for compaction.
- * Compaction is enabled by default with the hybrid strategy.
+ * Emitted when the execution stream completes.
  */
-declare const DEFAULT_COMPACTION_CONFIG: Required<Omit<CompactionConfig, "summarizationModel" | "summarizationPrompt" | "onCompaction">>;
+interface StreamCompleteEvent extends BaseExecutionEvent {
+    type: "stream_complete";
+    /** Whether any gadgets were executed */
+    didExecuteGadgets: boolean;
+    /** Whether the agent loop should break */
+    shouldBreakLoop: boolean;
+    /** Total cost for this iteration */
+    iterationCost?: number;
+}
 /**
- * Default prompt used for summarization strategy.
+ * All LLM-related events.
  */
-declare const DEFAULT_SUMMARIZATION_PROMPT = "Summarize this conversation history concisely, preserving:\n1. Key decisions made and their rationale\n2. Important facts and data discovered\n3. Errors encountered and how they were resolved\n4. Current task context and goals\n\nFormat as a brief narrative paragraph, not bullet points.\nPrevious conversation:";
+type LLMEvent = LLMCallStartEvent | LLMCallStreamEvent | LLMCallCompleteEvent | LLMCallErrorEvent;
 /**
- * Resolved configuration with all defaults applied.
+ * All gadget-related events.
  */
-interface ResolvedCompactionConfig {
-    enabled: boolean;
-    strategy: "sliding-window" | "summarization" | "hybrid";
-    triggerThresholdPercent: number;
-    targetPercent: number;
-    preserveRecentTurns: number;
-    summarizationModel?: string;
-    summarizationPrompt: string;
-    onCompaction?: (event: CompactionEvent$1) => void;
-}
-
-interface LLMGenerationOptions {
-    model: string;
-    messages: LLMMessage[];
-    maxTokens?: number;
-    temperature?: number;
-    topP?: number;
-    stopSequences?: string[];
-    responseFormat?: "text";
-    metadata?: Record<string, unknown>;
-    extra?: Record<string, unknown>;
-    /**
-     * Optional abort signal for cancelling the request mid-flight.
-     *
-     * When the signal is aborted, the provider will attempt to cancel
-     * the underlying HTTP request and the stream will terminate with
-     * an abort error. Use `isAbortError()` from `@/core/errors` to
-     * detect cancellation in error handling.
-     *
-     * @example
-     * ```typescript
-     * const controller = new AbortController();
-     *
-     * const stream = client.stream({
-     *   model: "claude-3-5-sonnet-20241022",
-     *   messages: [{ role: "user", content: "Tell me a long story" }],
-     *   signal: controller.signal,
-     * });
-     *
-     * // Cancel after 5 seconds
-     * setTimeout(() => controller.abort(), 5000);
-     *
-     * try {
-     *   for await (const chunk of stream) {
-     *     process.stdout.write(chunk.text);
-     *   }
-     * } catch (error) {
-     *   if (isAbortError(error)) {
-     *     console.log("\nRequest was cancelled");
-     *   } else {
-     *     throw error;
-     *   }
-     * }
-     * ```
-     */
-    signal?: AbortSignal;
-}
-interface TokenUsage {
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    /** Number of input tokens served from cache (subset of inputTokens) */
-    cachedInputTokens?: number;
-    /** Number of input tokens written to cache (subset of inputTokens, Anthropic only) */
-    cacheCreationInputTokens?: number;
-}
-interface LLMStreamChunk {
-    text: string;
-    /**
-     * Indicates that the provider has finished producing output and includes the reason if available.
-     */
-    finishReason?: string | null;
-    /**
-     * Token usage information, typically available in the final chunk when the stream completes.
-     */
-    usage?: TokenUsage;
-    /**
-     * Provider specific payload emitted at the same time as the text chunk. This is useful for debugging and tests.
-     */
-    rawEvent?: unknown;
-}
-interface LLMStream extends AsyncIterable<LLMStreamChunk> {
-}
-type ProviderIdentifier = string;
-interface ModelDescriptor {
-    provider: string;
-    name: string;
-}
-declare class ModelIdentifierParser {
-    private readonly defaultProvider;
-    constructor(defaultProvider?: string);
-    parse(identifier: string): ModelDescriptor;
-}
+type GadgetEvent = GadgetCallEvent | GadgetStartEvent | GadgetCompleteEvent | GadgetErrorEvent | GadgetSkippedEvent$1;
+/**
+ * Union of all execution events.
+ */
+type ExecutionEvent = LLMCallStartEvent | LLMCallStreamEvent | LLMCallCompleteEvent | LLMCallErrorEvent | GadgetCallEvent | GadgetStartEvent | GadgetCompleteEvent | GadgetErrorEvent | GadgetSkippedEvent$1 | TextEvent | CompactionEvent$1 | HumanInputRequiredEvent | StreamCompleteEvent;
+/**
+ * Event type discriminator.
+ */
+type ExecutionEventType = ExecutionEvent["type"] | "*";
+/**
+ * Check if an event is an LLM event.
+ */
+declare function isLLMEvent(event: ExecutionEvent): event is LLMEvent;
+/**
+ * Check if an event is a gadget event.
+ */
+declare function isGadgetEvent(event: ExecutionEvent): event is GadgetEvent;
+/**
+ * Check if an event is from a subagent (nested execution).
+ */
+declare function isSubagentEvent(event: ExecutionEvent): boolean;
+/**
+ * Check if an event is from the root agent.
+ */
+declare function isRootEvent(event: ExecutionEvent): boolean;
+/**
+ * Filter events by depth.
+ */
+declare function filterByDepth(events: ExecutionEvent[], depth: number): ExecutionEvent[];
+/**
+ * Filter events by parent node.
+ */
+declare function filterByParent(events: ExecutionEvent[], parentId: string): ExecutionEvent[];
+/**
+ * Filter events to only root-level events.
+ */
+declare function filterRootEvents(events: ExecutionEvent[]): ExecutionEvent[];
+/**
+ * Group events by their parent node.
+ */
+declare function groupByParent(events: ExecutionEvent[]): Map<string | null, ExecutionEvent[]>;
 
 /**
- * Unified event types for the Execution Tree.
+ * First-class Execution Tree model for nested subagent support.
  *
- * All events carry full tree context (nodeId, parentId, depth, path).
- * No special SubagentEvent wrapper needed - subagent events are regular
- * events with depth > 0.
+ * The ExecutionTree is THE single source of truth for execution state.
+ * All nodes (including nested subagent nodes) live in one tree.
+ * Events are projections of tree changes.
  *
- * @module core/execution-events
+ * @module core/execution-tree
  */
 
 /**
- * Base properties shared by all execution events.
- * Every event carries full tree context.
+ * Unique identifier for any execution node.
+ * Format examples: "llm_1", "gadget_abc123", "llm_1_2" (nested)
  */
-interface BaseExecutionEvent {
-    /** Monotonically increasing event ID */
-    eventId: number;
-    /** Event timestamp */
-    timestamp: number;
-    /** Node that emitted this event */
-    nodeId: string;
-    /** Parent node ID (null for root events) */
-    parentId: string | null;
-    /** Nesting depth (0 = root, 1 = child, etc.) */
+type NodeId = string;
+/**
+ * Node type discriminator.
+ */
+type ExecutionNodeType = "llm_call" | "gadget";
+/**
+ * Base properties shared by all execution nodes.
+ */
+interface BaseExecutionNode {
+    /** Unique identifier for this node */
+    id: NodeId;
+    /** Node type discriminator */
+    type: ExecutionNodeType;
+    /** Parent node ID (null for root nodes) */
+    parentId: NodeId | null;
+    /** Nesting depth (0 = root, 1 = child of gadget, etc.) */
     depth: number;
-    /** Full path from root to this node */
-    path: string[];
+    /** Path from root to this node: ["llm_1", "gadget_abc", "llm_1_1"] */
+    path: NodeId[];
+    /** Creation timestamp */
+    createdAt: number;
+    /** Completion timestamp (null if in progress) */
+    completedAt: number | null;
 }
 /**
- * Emitted when an LLM call starts.
+ * LLM call execution node.
  */
-interface LLMCallStartEvent extends BaseExecutionEvent {
-    type: "llm_call_start";
-    /** Iteration number within agent loop (1-indexed) */
+interface LLMCallNode extends BaseExecutionNode {
+    type: "llm_call";
+    /** Iteration number within the agent loop (1-indexed for display) */
     iteration: number;
     /** Model identifier */
     model: string;
-    /** Request messages */
+    /** Request messages (set when call starts) */
     request?: LLMMessage[];
+    /** Accumulated response text */
+    response: string;
+    /** Token usage (set on completion) */
+    usage?: TokenUsage;
+    /** Finish reason from LLM */
+    finishReason?: string | null;
+    /** Cost in USD */
+    cost?: number;
+    /** Child node IDs (gadgets spawned by this LLM call) */
+    children: NodeId[];
 }
 /**
- * Emitted for each streaming chunk from LLM.
+ * Gadget execution state.
  */
-interface LLMCallStreamEvent extends BaseExecutionEvent {
-    type: "llm_call_stream";
-    /** Text chunk */
-    chunk: string;
-}
+type GadgetState = "pending" | "running" | "completed" | "failed" | "skipped";
 /**
- * Emitted when an LLM call completes successfully.
+ * Gadget execution node.
  */
-interface LLMCallCompleteEvent extends BaseExecutionEvent {
-    type: "llm_call_complete";
-    /** Complete response text */
-    response: string;
-    /** Token usage */
-    usage?: TokenUsage;
-    /** Finish reason from LLM */
-    finishReason?: string | null;
+interface GadgetNode extends BaseExecutionNode {
+    type: "gadget";
+    /** Invocation ID (LLM-generated or auto) */
+    invocationId: string;
+    /** Gadget name */
+    name: string;
+    /** Parameters passed to the gadget */
+    parameters: Record<string, unknown>;
+    /** Dependencies (other invocation IDs this gadget waits for) */
+    dependencies: string[];
+    /** Execution state */
+    state: GadgetState;
+    /** Result string (if completed successfully) */
+    result?: string;
+    /** Error message (if failed or skipped) */
+    error?: string;
+    /** Failed dependency invocation ID (if skipped due to dependency) */
+    failedDependency?: string;
+    /** Execution time in milliseconds */
+    executionTimeMs?: number;
     /** Cost in USD */
     cost?: number;
+    /** Media outputs from this gadget */
+    media?: GadgetMediaOutput[];
+    /** Child node IDs (nested LLM calls for subagent gadgets) */
+    children: NodeId[];
+    /** Whether this gadget is a subagent (has nested LLM calls) */
+    isSubagent: boolean;
 }
 /**
- * Emitted when an LLM call fails.
+ * Union of all execution node types.
  */
-interface LLMCallErrorEvent extends BaseExecutionEvent {
-    type: "llm_call_error";
-    /** The error that occurred */
-    error: Error;
-    /** Whether the error was recovered by a controller */
-    recovered: boolean;
+type ExecutionNode = LLMCallNode | GadgetNode;
+interface AddLLMCallParams {
+    /** Iteration number (1-indexed) */
+    iteration: number;
+    /** Model identifier */
+    model: string;
+    /** Request messages */
+    request?: LLMMessage[];
+    /** Parent node ID (for subagent LLM calls) */
+    parentId?: NodeId | null;
 }
-/**
- * Emitted when a gadget call is parsed from LLM output (before execution).
- */
-interface GadgetCallEvent extends BaseExecutionEvent {
-    type: "gadget_call";
+interface AddGadgetParams {
     /** Invocation ID */
     invocationId: string;
     /** Gadget name */
     name: string;
     /** Parameters */
     parameters: Record<string, unknown>;
-    /** Dependencies (other invocation IDs) */
-    dependencies: string[];
+    /** Dependencies */
+    dependencies?: string[];
+    /** Parent LLM call node ID */
+    parentId?: NodeId | null;
 }
-/**
- * Emitted when gadget execution starts.
- */
-interface GadgetStartEvent extends BaseExecutionEvent {
-    type: "gadget_start";
-    /** Invocation ID */
-    invocationId: string;
-    /** Gadget name */
-    name: string;
+interface CompleteLLMCallParams {
+    /** Accumulated response text */
+    response?: string;
+    /** Token usage */
+    usage?: TokenUsage;
+    /** Finish reason */
+    finishReason?: string | null;
+    /** Cost in USD */
+    cost?: number;
 }
-/**
- * Emitted when gadget execution completes successfully.
- */
-interface GadgetCompleteEvent extends BaseExecutionEvent {
-    type: "gadget_complete";
-    /** Invocation ID */
-    invocationId: string;
-    /** Gadget name */
-    name: string;
+interface CompleteGadgetParams {
     /** Result string */
-    result: string;
+    result?: string;
+    /** Error message */
+    error?: string;
+    /** Failed dependency (for skipped gadgets) */
+    failedDependency?: string;
     /** Execution time in ms */
-    executionTimeMs: number;
+    executionTimeMs?: number;
     /** Cost in USD */
     cost?: number;
     /** Media outputs */
     media?: GadgetMediaOutput[];
 }
+
+/** Event listener function type */
+type EventListener = (event: ExecutionEvent) => void;
 /**
- * Emitted when gadget execution fails.
- */
-interface GadgetErrorEvent extends BaseExecutionEvent {
-    type: "gadget_error";
-    /** Invocation ID */
-    invocationId: string;
-    /** Gadget name */
-    name: string;
-    /** Error message */
-    error: string;
-    /** Execution time in ms */
-    executionTimeMs: number;
-}
-/**
- * Emitted when a gadget is skipped.
- */
-interface GadgetSkippedEvent$1 extends BaseExecutionEvent {
-    type: "gadget_skipped";
-    /** Invocation ID */
-    invocationId: string;
-    /** Gadget name */
-    name: string;
-    /** Reason for skipping */
-    reason: "dependency_failed" | "controller_skip";
-    /** Error message (combines reason and failedDependencyError for consistency with GadgetErrorEvent) */
-    error: string;
-    /** Failed dependency invocation ID (if dependency_failed) */
-    failedDependency?: string;
-    /** Error message from failed dependency */
-    failedDependencyError?: string;
-}
-/**
- * Emitted for text output from LLM (pure notification, not a tree node).
+ * The Execution Tree - single source of truth for all execution state.
+ *
+ * Features:
+ * - Stores all nodes (LLM calls, gadgets) in a hierarchical structure
+ * - Emits events on mutations
+ * - Provides query methods for aggregation (costs, media, descendants)
+ * - Supports single shared tree model for nested subagents
+ *
+ * @example
+ * ```typescript
+ * const tree = new ExecutionTree();
+ *
+ * // Add root LLM call
+ * const llmNode = tree.addLLMCall({ iteration: 1, model: "sonnet" });
+ *
+ * // Add gadget under the LLM call
+ * const gadgetNode = tree.addGadget({
+ *   invocationId: "gc_1",
+ *   name: "ReadFile",
+ *   parameters: { path: "/foo.txt" },
+ *   parentId: llmNode.id,
+ * });
+ *
+ * // Complete the gadget
+ * tree.completeGadget(gadgetNode.id, { result: "file contents", executionTimeMs: 50 });
+ *
+ * // Query total cost
+ * console.log(tree.getTotalCost());
+ * ```
  */
-interface TextEvent extends BaseExecutionEvent {
-    type: "text";
-    /** Text content */
-    content: string;
+declare class ExecutionTree {
+    private nodes;
+    private rootIds;
+    private eventListeners;
+    private eventIdCounter;
+    private invocationIdToNodeId;
+    private eventQueue;
+    private eventWaiters;
+    private isCompleted;
+    /**
+     * Base depth for all nodes in this tree.
+     * Used when this tree is a subagent's view into a parent tree.
+     */
+    readonly baseDepth: number;
+    /**
+     * Parent node ID for subagent trees.
+     * All root nodes in this tree will have this as their parentId.
+     */
+    readonly parentNodeId: NodeId | null;
+    constructor(options?: {
+        baseDepth?: number;
+        parentNodeId?: NodeId | null;
+    });
+    private generateLLMCallId;
+    private gadgetIdCounter;
+    private generateGadgetId;
+    private emit;
+    private createBaseEventProps;
+    /**
+     * Add a new LLM call node to the tree.
+     */
+    addLLMCall(params: AddLLMCallParams): LLMCallNode;
+    /**
+     * Add text to an LLM call's response (for streaming).
+     */
+    appendLLMResponse(nodeId: NodeId, chunk: string): void;
+    /**
+     * Complete an LLM call node.
+     */
+    completeLLMCall(nodeId: NodeId, params: CompleteLLMCallParams): void;
+    /**
+     * Mark an LLM call as failed.
+     */
+    failLLMCall(nodeId: NodeId, error: Error, recovered: boolean): void;
+    /**
+     * Add a new gadget node to the tree.
+     */
+    addGadget(params: AddGadgetParams): GadgetNode;
+    /**
+     * Mark a gadget as started (running).
+     */
+    startGadget(nodeId: NodeId): void;
+    /**
+     * Complete a gadget node successfully.
+     */
+    completeGadget(nodeId: NodeId, params: CompleteGadgetParams): void;
+    /**
+     * Mark a gadget as skipped due to dependency failure.
+     */
+    skipGadget(nodeId: NodeId, failedDependency: string, failedDependencyError: string, reason: "dependency_failed" | "controller_skip"): void;
+    /**
+     * Emit a text event (notification only, not stored in tree).
+     */
+    emitText(content: string, llmCallNodeId: NodeId): void;
+    /**
+     * Get a node by ID.
+     */
+    getNode(id: NodeId): ExecutionNode | undefined;
+    /**
+     * Get a gadget node by invocation ID.
+     */
+    getNodeByInvocationId(invocationId: string): GadgetNode | undefined;
+    /**
+     * Get all root nodes (depth 0 for this tree).
+     */
+    getRoots(): ExecutionNode[];
+    /**
+     * Get children of a node.
+     */
+    getChildren(id: NodeId): ExecutionNode[];
+    /**
+     * Get ancestors of a node (from root to parent).
+     */
+    getAncestors(id: NodeId): ExecutionNode[];
+    /**
+     * Get all descendants of a node.
+     */
+    getDescendants(id: NodeId, type?: ExecutionNodeType): ExecutionNode[];
+    /**
+     * Get the current (most recent incomplete) LLM call node.
+     */
+    getCurrentLLMCallId(): NodeId | undefined;
+    /**
+     * Get total cost for entire tree.
+     */
+    getTotalCost(): number;
+    /**
+     * Get total cost for a subtree (node and all descendants).
+     */
+    getSubtreeCost(nodeId: NodeId): number;
+    /**
+     * Get token usage for entire tree.
+     */
+    getTotalTokens(): {
+        input: number;
+        output: number;
+        cached: number;
+    };
+    /**
+     * Get token usage for a subtree.
+     */
+    getSubtreeTokens(nodeId: NodeId): {
+        input: number;
+        output: number;
+        cached: number;
+    };
+    /**
+     * Collect all media from a subtree.
+     */
+    getSubtreeMedia(nodeId: NodeId): GadgetMediaOutput[];
+    /**
+     * Check if a subtree is complete (all nodes finished).
+     */
+    isSubtreeComplete(nodeId: NodeId): boolean;
+    /**
+     * Get node counts.
+     */
+    getNodeCount(): {
+        llmCalls: number;
+        gadgets: number;
+    };
+    /**
+     * Subscribe to events of a specific type.
+     * Returns unsubscribe function.
+     *
+     * @param type - Event type to subscribe to (use "*" for all events)
+     * @param listener - Callback function that receives matching events
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = tree.on("gadget_complete", (event) => {
+     *   if (event.type === "gadget_complete") {
+     *     console.log(`Gadget ${event.name} completed`);
+     *   }
+     * });
+     * ```
+     */
+    on(type: ExecutionEventType, listener: EventListener): () => void;
+    /**
+     * Subscribe to all events.
+     */
+    onAll(listener: EventListener): () => void;
+    /**
+     * Get async iterable of all events.
+     * Events are yielded as they occur.
+     */
+    events(): AsyncGenerator<ExecutionEvent>;
+    /**
+     * Mark the tree as complete (no more events will be emitted).
+     */
+    complete(): void;
+    /**
+     * Check if the tree is complete.
+     */
+    isComplete(): boolean;
 }
+
 /**
- * Emitted when context compaction occurs.
+ * Function-based gadget creation helper.
+ *
+ * For simple gadgets, use createGadget() instead of defining a class.
+ * Parameters are automatically typed from the Zod schema.
+ *
+ * @example
+ * ```typescript
+ * const calculator = createGadget({
+ *   description: "Performs arithmetic operations",
+ *   schema: z.object({
+ *     operation: z.enum(["add", "subtract"]),
+ *     a: z.number(),
+ *     b: z.number(),
+ *   }),
+ *   execute: ({ operation, a, b }) => {
+ *     // Automatically typed!
+ *     return operation === "add" ? String(a + b) : String(a - b);
+ *   },
+ * });
+ * ```
  */
-interface CompactionEvent extends BaseExecutionEvent {
-    type: "compaction";
-    /** Tokens before compaction */
-    tokensBefore: number;
-    /** Tokens after compaction */
-    tokensAfter: number;
-    /** Compaction strategy used */
-    strategy: string;
-    /** Messages removed */
-    messagesRemoved: number;
-}
+
 /**
- * Emitted when human input is required.
+ * Infer the TypeScript type from a Zod schema.
  */
-interface HumanInputRequiredEvent extends BaseExecutionEvent {
-    type: "human_input_required";
-    /** Question for the user */
-    question: string;
-    /** Gadget name requesting input */
-    gadgetName: string;
-    /** Invocation ID */
-    invocationId: string;
-}
+type InferSchema$1<T> = T extends ZodType<infer U> ? U : never;
 /**
- * Emitted when the execution stream completes.
+ * Configuration for creating a function-based gadget.
  */
-interface StreamCompleteEvent extends BaseExecutionEvent {
-    type: "stream_complete";
-    /** Whether any gadgets were executed */
-    didExecuteGadgets: boolean;
-    /** Whether the agent loop should break */
-    shouldBreakLoop: boolean;
-    /** Total cost for this iteration */
-    iterationCost?: number;
+interface CreateGadgetConfig<TSchema extends ZodType> {
+    /** Optional custom name (defaults to "FunctionGadget") */
+    name?: string;
+    /** Human-readable description of what the gadget does */
+    description: string;
+    /** Zod schema for parameter validation */
+    schema: TSchema;
+    /**
+     * Execution function with typed parameters.
+     * Can return string or { result, cost? }.
+     * Optionally receives ExecutionContext for callback-based cost reporting.
+     */
+    execute: (params: InferSchema$1<TSchema>, ctx?: ExecutionContext) => GadgetExecuteReturn | Promise<GadgetExecuteReturn>;
+    /** Optional timeout in milliseconds */
+    timeoutMs?: number;
+    /** Optional usage examples to help LLMs understand proper invocation */
+    examples?: GadgetExample<InferSchema$1<TSchema>>[];
 }
 /**
- * All LLM-related events.
- */
-type LLMEvent = LLMCallStartEvent | LLMCallStreamEvent | LLMCallCompleteEvent | LLMCallErrorEvent;
-/**
- * All gadget-related events.
- */
-type GadgetEvent = GadgetCallEvent | GadgetStartEvent | GadgetCompleteEvent | GadgetErrorEvent | GadgetSkippedEvent$1;
-/**
- * Union of all execution events.
- */
-type ExecutionEvent = LLMCallStartEvent | LLMCallStreamEvent | LLMCallCompleteEvent | LLMCallErrorEvent | GadgetCallEvent | GadgetStartEvent | GadgetCompleteEvent | GadgetErrorEvent | GadgetSkippedEvent$1 | TextEvent | CompactionEvent | HumanInputRequiredEvent | StreamCompleteEvent;
-/**
- * Event type discriminator.
- */
-type ExecutionEventType = ExecutionEvent["type"] | "*";
-/**
- * Check if an event is an LLM event.
- */
-declare function isLLMEvent(event: ExecutionEvent): event is LLMEvent;
-/**
- * Check if an event is a gadget event.
- */
-declare function isGadgetEvent(event: ExecutionEvent): event is GadgetEvent;
-/**
- * Check if an event is from a subagent (nested execution).
+ * Creates a gadget from a function (simpler than class-based approach).
+ *
+ * This is perfect for simple gadgets where you don't need the full
+ * power of a class. Parameters are automatically typed from the schema.
+ *
+ * @param config - Configuration with execute function and schema
+ * @returns Gadget instance ready to be registered
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ * import { createGadget } from 'llmist';
+ *
+ * // Simple calculator gadget
+ * const calculator = createGadget({
+ *   description: "Performs arithmetic operations",
+ *   schema: z.object({
+ *     operation: z.enum(["add", "subtract", "multiply", "divide"]),
+ *     a: z.number().describe("First number"),
+ *     b: z.number().describe("Second number"),
+ *   }),
+ *   execute: ({ operation, a, b }) => {
+ *     // Parameters are automatically typed!
+ *     switch (operation) {
+ *       case "add": return String(a + b);
+ *       case "subtract": return String(a - b);
+ *       case "multiply": return String(a * b);
+ *       case "divide": return String(a / b);
+ *     }
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Async gadget with custom name and timeout
+ * const weather = createGadget({
+ *   name: "weather",
+ *   description: "Fetches current weather for a city",
+ *   schema: z.object({
+ *     city: z.string().min(1).describe("City name"),
+ *   }),
+ *   timeoutMs: 10000,
+ *   execute: async ({ city }) => {
+ *     const response = await fetch(`https://api.weather.com/${city}`);
+ *     const data = await response.json();
+ *     return `Weather in ${city}: ${data.description}, ${data.temp}°C`;
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use with agent
+ * const agent = LLMist.createAgent()
+ *   .withGadgets(calculator, weather)
+ *   .ask("What's the weather in Paris and what's 10 + 5?");
+ * ```
  */
-declare function isSubagentEvent(event: ExecutionEvent): boolean;
+declare function createGadget<TSchema extends ZodType>(config: CreateGadgetConfig<TSchema>): AbstractGadget;
+
 /**
- * Check if an event is from the root agent.
+ * Type-safe gadget factory with automatic parameter inference.
+ *
+ * Gadget eliminates the need for manual type assertions
+ * by automatically inferring parameter types from the Zod schema.
+ *
+ * @example
+ * ```typescript
+ * class Calculator extends Gadget({
+ *   description: "Performs arithmetic operations",
+ *   schema: z.object({
+ *     operation: z.enum(["add", "subtract"]),
+ *     a: z.number(),
+ *     b: z.number(),
+ *   }),
+ * }) {
+ *   // ✨ params is automatically typed!
+ *   execute(params: this['params']): string {
+ *     const { operation, a, b } = params; // All typed!
+ *     return operation === "add" ? String(a + b) : String(a - b);
+ *   }
+ * }
+ * ```
  */
-declare function isRootEvent(event: ExecutionEvent): boolean;
+
 /**
- * Filter events by depth.
+ * Infer the TypeScript type from a Zod schema.
  */
-declare function filterByDepth(events: ExecutionEvent[], depth: number): ExecutionEvent[];
+type InferSchema<T> = T extends ZodType<infer U> ? U : never;
 /**
- * Filter events by parent node.
+ * Configuration for creating a typed gadget.
  */
-declare function filterByParent(events: ExecutionEvent[], parentId: string): ExecutionEvent[];
+interface GadgetConfig<TSchema extends ZodType> {
+    /** Human-readable description of what the gadget does */
+    description: string;
+    /** Zod schema for parameter validation */
+    schema: TSchema;
+    /** Optional custom name (defaults to class name) */
+    name?: string;
+    /** Optional timeout in milliseconds */
+    timeoutMs?: number;
+    /** Optional usage examples to help LLMs understand proper invocation */
+    examples?: GadgetExample<InferSchema<TSchema>>[];
+}
 /**
- * Filter events to only root-level events.
+ * Factory function to create a typed gadget base class.
+ *
+ * The returned class automatically infers parameter types from the Zod schema,
+ * eliminating the need for manual type assertions in the execute method.
+ *
+ * @param config - Configuration with description and schema
+ * @returns Base class to extend with typed execute method
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ * import { Gadget } from 'llmist';
+ *
+ * class Calculator extends Gadget({
+ *   description: "Performs arithmetic operations",
+ *   schema: z.object({
+ *     operation: z.enum(["add", "subtract", "multiply", "divide"]),
+ *     a: z.number().describe("First number"),
+ *     b: z.number().describe("Second number"),
+ *   }),
+ * }) {
+ *   execute(params: this['params']): string {
+ *     // params is automatically typed as:
+ *     // { operation: "add" | "subtract" | "multiply" | "divide"; a: number; b: number }
+ *     const { operation, a, b } = params;
+ *
+ *     switch (operation) {
+ *       case "add": return String(a + b);
+ *       case "subtract": return String(a - b);
+ *       case "multiply": return String(a * b);
+ *       case "divide": return String(a / b);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With async execution
+ * class WeatherGadget extends Gadget({
+ *   description: "Fetches weather for a city",
+ *   schema: z.object({
+ *     city: z.string().min(1).describe("City name"),
+ *   }),
+ *   timeoutMs: 10000,
+ * }) {
+ *   async execute(params: this['params']): Promise<string> {
+ *     const { city } = params; // Automatically typed as { city: string }
+ *     const weather = await fetchWeather(city);
+ *     return `Weather in ${city}: ${weather}`;
+ *   }
+ * }
+ * ```
  */
-declare function filterRootEvents(events: ExecutionEvent[]): ExecutionEvent[];
+declare function Gadget<TSchema extends ZodType>(config: GadgetConfig<TSchema>): {
+    new (): {
+        description: string;
+        parameterSchema: TSchema;
+        name: string | undefined;
+        timeoutMs: number | undefined;
+        examples: GadgetExample<InferSchema<TSchema>>[] | undefined;
+        /**
+         * Type helper property for accessing inferred parameter type.
+         * This is used in the execute method signature: `execute(params: this['params'])`
+         *
+         * Note: This is just for type inference - the actual params in execute()
+         * will be Record<string, unknown> which you can safely cast to this['params']
+         */
+        readonly params: InferSchema<TSchema>;
+        /**
+         * Execute the gadget. Subclasses should cast params to this['params'].
+         *
+         * @param params - Validated parameters from the LLM
+         * @param ctx - Optional execution context for cost reporting and LLM access
+         * @returns Result as a string, or an object with result and optional cost
+         *
+         * @example
+         * ```typescript
+         * // Simple string return (free gadget)
+         * execute(params: this['params']) {
+         *   return String(params.a + params.b);
+         * }
+         *
+         * // Using context for callback-based cost reporting
+         * execute(params: this['params'], ctx) {
+         *   ctx.reportCost(0.001);
+         *   return "result";
+         * }
+         *
+         * // Using wrapped LLMist for automatic cost tracking
+         * async execute(params: this['params'], ctx) {
+         *   return ctx.llmist.complete('Summarize: ' + params.text);
+         * }
+         * ```
+         */
+        execute(params: Record<string, unknown>, ctx?: ExecutionContext): GadgetExecuteReturn | Promise<GadgetExecuteReturn>;
+        throwIfAborted(ctx?: ExecutionContext): void;
+        onAbort(ctx: ExecutionContext | undefined, cleanup: () => void | Promise<void>): void;
+        createLinkedAbortController(ctx?: ExecutionContext): AbortController;
+        get instruction(): string;
+        getInstruction(optionsOrArgPrefix?: string | {
+            argPrefix?: string;
+            startPrefix?: string;
+            endPrefix?: string;
+        }): string;
+    } & {
+        params: InferSchema<TSchema>;
+    };
+};
+
 /**
- * Group events by their parent node.
+ * Model Catalog Types
+ *
+ * Type definitions for LLM model specifications including
+ * context windows, pricing, features, and capabilities.
  */
-declare function groupByParent(events: ExecutionEvent[]): Map<string | null, ExecutionEvent[]>;
+interface ModelPricing {
+    /** Price per 1 million input tokens in USD */
+    input: number;
+    /** Price per 1 million output tokens in USD */
+    output: number;
+    /** Price per 1 million cached input tokens in USD (if supported) */
+    cachedInput?: number;
+    /** Price per 1 million cache write tokens in USD (Anthropic: 1.25x input price) */
+    cacheWriteInput?: number;
+}
+interface ModelFeatures {
+    /** Supports streaming responses */
+    streaming: boolean;
+    /** Supports function/tool calling */
+    functionCalling: boolean;
+    /** Supports vision/image input */
+    vision: boolean;
+    /** Supports extended thinking/reasoning */
+    reasoning?: boolean;
+    /** Supports structured outputs */
+    structuredOutputs?: boolean;
+    /** Supports fine-tuning */
+    fineTuning?: boolean;
+}
+interface ModelSpec {
+    /** Provider identifier (e.g., 'openai', 'anthropic', 'gemini') */
+    provider: string;
+    /** Full model identifier used in API calls */
+    modelId: string;
+    /** Human-readable display name */
+    displayName: string;
+    /** Maximum context window size in tokens */
+    contextWindow: number;
+    /** Maximum output tokens per request */
+    maxOutputTokens: number;
+    /** Pricing per 1M tokens */
+    pricing: ModelPricing;
+    /** Training data knowledge cutoff date (YYYY-MM-DD or description) */
+    knowledgeCutoff: string;
+    /** Supported features and capabilities */
+    features: ModelFeatures;
+    /** Additional metadata */
+    metadata?: {
+        /** Model family/series */
+        family?: string;
+        /** Release date */
+        releaseDate?: string;
+        /** Deprecation date if applicable */
+        deprecationDate?: string;
+        /** Notes or special information */
+        notes?: string;
+        /** Whether manual temperature configuration is supported (defaults to true) */
+        supportsTemperature?: boolean;
+    };
+}
+interface ModelLimits {
+    contextWindow: number;
+    maxOutputTokens: number;
+}
+interface CostEstimate {
+    inputCost: number;
+    /** Cost for cached input tokens (already included in inputCost calculation) */
+    cachedInputCost: number;
+    /** Cost for cache creation tokens (already included in inputCost calculation, Anthropic only) */
+    cacheCreationCost: number;
+    outputCost: number;
+    totalCost: number;
+    currency: "USD";
+}
 
 /**
- * First-class Execution Tree model for nested subagent support.
- *
- * The ExecutionTree is THE single source of truth for execution state.
- * All nodes (including nested subagent nodes) live in one tree.
- * Events are projections of tree changes.
+ * Strategy interface for context compaction.
  *
- * @module core/execution-tree
+ * Strategies define how conversation history is compressed to fit within
+ * context window limits. Different strategies trade off between:
+ * - Speed (LLM calls vs local processing)
+ * - Context preservation (summary quality vs simple truncation)
+ * - Cost (summarization model usage)
  */
 
 /**
- * Unique identifier for any execution node.
- * Format examples: "llm_1", "gadget_abc123", "llm_1_2" (nested)
- */
-type NodeId = string;
-/**
- * Node type discriminator.
+ * Context provided to compaction strategies.
  */
-type ExecutionNodeType = "llm_call" | "gadget";
+interface CompactionContext {
+    /** Current token count of the conversation */
+    currentTokens: number;
+    /** Target token count after compaction */
+    targetTokens: number;
+    /** Model's context window limits */
+    modelLimits: ModelLimits;
+    /** LLMist client for summarization calls */
+    client: LLMist;
+    /** Model identifier for token counting and summarization */
+    model: string;
+}
 /**
- * Base properties shared by all execution nodes.
+ * Result of a compaction operation.
  */
-interface BaseExecutionNode {
-    /** Unique identifier for this node */
-    id: NodeId;
-    /** Node type discriminator */
-    type: ExecutionNodeType;
-    /** Parent node ID (null for root nodes) */
-    parentId: NodeId | null;
-    /** Nesting depth (0 = root, 1 = child of gadget, etc.) */
-    depth: number;
-    /** Path from root to this node: ["llm_1", "gadget_abc", "llm_1_1"] */
-    path: NodeId[];
-    /** Creation timestamp */
-    createdAt: number;
-    /** Completion timestamp (null if in progress) */
-    completedAt: number | null;
+interface CompactionResult {
+    /** Compacted messages to replace history with */
+    messages: LLMMessage[];
+    /** Summary text if summarization was used */
+    summary?: string;
+    /** The name of the strategy that was ultimately executed */
+    strategyName: string;
+    /** Metadata about the compaction */
+    metadata: {
+        /** Number of messages before compaction */
+        originalCount: number;
+        /** Number of messages after compaction */
+        compactedCount: number;
+        /** Estimated tokens before compaction */
+        tokensBefore: number;
+        /** Estimated tokens after compaction */
+        tokensAfter: number;
+    };
 }
 /**
- * LLM call execution node.
+ * Interface for compaction strategy implementations.
+ *
+ * Strategies receive the conversation history (excluding base messages like
+ * system prompt and gadget instructions) and must return a compacted version.
+ *
+ * @example
+ * ```typescript
+ * class MyCustomStrategy implements CompactionStrategy {
+ *   readonly name = 'my-custom';
+ *
+ *   async compact(
+ *     messages: LLMMessage[],
+ *     config: ResolvedCompactionConfig,
+ *     context: CompactionContext
+ *   ): Promise<CompactionResult> {
+ *     // Custom compaction logic
+ *     return {
+ *       messages: compactedMessages,
+ *       metadata: { ... }
+ *     };
+ *   }
+ * }
+ * ```
  */
-interface LLMCallNode extends BaseExecutionNode {
-    type: "llm_call";
-    /** Iteration number within the agent loop (1-indexed for display) */
-    iteration: number;
-    /** Model identifier */
-    model: string;
-    /** Request messages (set when call starts) */
-    request?: LLMMessage[];
-    /** Accumulated response text */
-    response: string;
-    /** Token usage (set on completion) */
-    usage?: TokenUsage;
-    /** Finish reason from LLM */
-    finishReason?: string | null;
-    /** Cost in USD */
-    cost?: number;
-    /** Child node IDs (gadgets spawned by this LLM call) */
-    children: NodeId[];
+interface CompactionStrategy {
+    /** Human-readable name of the strategy */
+    readonly name: string;
+    /**
+     * Compact the given messages to fit within target token count.
+     *
+     * @param messages - Conversation history messages (excludes system/gadget base)
+     * @param config - Resolved compaction configuration
+     * @param context - Context including token counts and LLM client
+     * @returns Compacted messages with metadata
+     */
+    compact(messages: LLMMessage[], config: ResolvedCompactionConfig, context: CompactionContext): Promise<CompactionResult>;
 }
 /**
- * Gadget execution state.
+ * Utility to group messages into logical conversation turns.
+ *
+ * A "turn" is typically a user message followed by an assistant response.
+ * Gadget calls are grouped with the preceding assistant message.
  */
-type GadgetState = "pending" | "running" | "completed" | "failed" | "skipped";
+interface MessageTurn {
+    /** Messages in this turn (user + assistant + any gadget results) */
+    messages: LLMMessage[];
+    /** Estimated token count for this turn */
+    tokenEstimate: number;
+}
+
 /**
- * Gadget execution node.
+ * Configuration types for the context compaction system.
+ *
+ * Context compaction automatically manages conversation history to prevent
+ * context window overflow in long-running agent conversations.
  */
-interface GadgetNode extends BaseExecutionNode {
-    type: "gadget";
-    /** Invocation ID (LLM-generated or auto) */
-    invocationId: string;
-    /** Gadget name */
-    name: string;
-    /** Parameters passed to the gadget */
-    parameters: Record<string, unknown>;
-    /** Dependencies (other invocation IDs this gadget waits for) */
-    dependencies: string[];
-    /** Execution state */
-    state: GadgetState;
-    /** Result string (if completed successfully) */
-    result?: string;
-    /** Error message (if failed or skipped) */
-    error?: string;
-    /** Failed dependency invocation ID (if skipped due to dependency) */
-    failedDependency?: string;
-    /** Execution time in milliseconds */
-    executionTimeMs?: number;
-    /** Cost in USD */
-    cost?: number;
-    /** Media outputs from this gadget */
-    media?: GadgetMediaOutput[];
-    /** Child node IDs (nested LLM calls for subagent gadgets) */
-    children: NodeId[];
-    /** Whether this gadget is a subagent (has nested LLM calls) */
-    isSubagent: boolean;
-}
+
 /**
- * Union of all execution node types.
+ * Event emitted when compaction occurs.
+ * This is included in StreamEvent for UI visibility.
  */
-type ExecutionNode = LLMCallNode | GadgetNode;
-interface AddLLMCallParams {
-    /** Iteration number (1-indexed) */
+interface CompactionEvent {
+    /** The strategy that performed the compaction */
+    strategy: string;
+    /** Token count before compaction */
+    tokensBefore: number;
+    /** Token count after compaction */
+    tokensAfter: number;
+    /** Number of messages before compaction */
+    messagesBefore: number;
+    /** Number of messages after compaction */
+    messagesAfter: number;
+    /** Summary text if summarization was used */
+    summary?: string;
+    /** Agent iteration when compaction occurred */
     iteration: number;
-    /** Model identifier */
-    model: string;
-    /** Request messages */
-    request?: LLMMessage[];
-    /** Parent node ID (for subagent LLM calls) */
-    parentId?: NodeId | null;
-}
-interface AddGadgetParams {
-    /** Invocation ID */
-    invocationId: string;
-    /** Gadget name */
-    name: string;
-    /** Parameters */
-    parameters: Record<string, unknown>;
-    /** Dependencies */
-    dependencies?: string[];
-    /** Parent LLM call node ID */
-    parentId?: NodeId | null;
-}
-interface CompleteLLMCallParams {
-    /** Accumulated response text */
-    response?: string;
-    /** Token usage */
-    usage?: TokenUsage;
-    /** Finish reason */
-    finishReason?: string | null;
-    /** Cost in USD */
-    cost?: number;
-}
-interface CompleteGadgetParams {
-    /** Result string */
-    result?: string;
-    /** Error message */
-    error?: string;
-    /** Failed dependency (for skipped gadgets) */
-    failedDependency?: string;
-    /** Execution time in ms */
-    executionTimeMs?: number;
-    /** Cost in USD */
-    cost?: number;
-    /** Media outputs */
-    media?: GadgetMediaOutput[];
 }
-
-/** Event listener function type */
-type EventListener = (event: ExecutionEvent) => void;
 /**
- * The Execution Tree - single source of truth for all execution state.
- *
- * Features:
- * - Stores all nodes (LLM calls, gadgets) in a hierarchical structure
- * - Emits events on mutations
- * - Provides query methods for aggregation (costs, media, descendants)
- * - Supports single shared tree model for nested subagents
+ * Statistics about compaction activity.
+ */
+interface CompactionStats {
+    /** Total number of compactions performed */
+    totalCompactions: number;
+    /** Total tokens saved across all compactions */
+    totalTokensSaved: number;
+    /** Current context usage */
+    currentUsage: {
+        tokens: number;
+        percent: number;
+    };
+    /** Model's context window size */
+    contextWindow: number;
+}
+/**
+ * Configuration for the context compaction system.
  *
  * @example
  * ```typescript
- * const tree = new ExecutionTree();
- *
- * // Add root LLM call
- * const llmNode = tree.addLLMCall({ iteration: 1, model: "sonnet" });
- *
- * // Add gadget under the LLM call
- * const gadgetNode = tree.addGadget({
- *   invocationId: "gc_1",
- *   name: "ReadFile",
- *   parameters: { path: "/foo.txt" },
- *   parentId: llmNode.id,
- * });
- *
- * // Complete the gadget
- * tree.completeGadget(gadgetNode.id, { result: "file contents", executionTimeMs: 50 });
+ * // Custom configuration
+ * const agent = await LLMist.createAgent()
+ *   .withModel('sonnet')
+ *   .withCompaction({
+ *     triggerThresholdPercent: 70,
+ *     targetPercent: 40,
+ *     preserveRecentTurns: 10,
+ *   })
+ *   .ask('...');
  *
- * // Query total cost
- * console.log(tree.getTotalCost());
+ * // Disable compaction
+ * const agent = await LLMist.createAgent()
+ *   .withModel('sonnet')
+ *   .withoutCompaction()
+ *   .ask('...');
  * ```
  */
-declare class ExecutionTree {
-    private nodes;
-    private rootIds;
-    private eventListeners;
-    private eventIdCounter;
-    private invocationIdToNodeId;
-    private eventQueue;
-    private eventWaiters;
-    private isCompleted;
-    /**
-     * Base depth for all nodes in this tree.
-     * Used when this tree is a subagent's view into a parent tree.
-     */
-    readonly baseDepth: number;
-    /**
-     * Parent node ID for subagent trees.
-     * All root nodes in this tree will have this as their parentId.
-     */
-    readonly parentNodeId: NodeId | null;
-    constructor(options?: {
-        baseDepth?: number;
-        parentNodeId?: NodeId | null;
-    });
-    private generateLLMCallId;
-    private gadgetIdCounter;
-    private generateGadgetId;
-    private emit;
-    private createBaseEventProps;
-    /**
-     * Add a new LLM call node to the tree.
-     */
-    addLLMCall(params: AddLLMCallParams): LLMCallNode;
-    /**
-     * Add text to an LLM call's response (for streaming).
-     */
-    appendLLMResponse(nodeId: NodeId, chunk: string): void;
-    /**
-     * Complete an LLM call node.
-     */
-    completeLLMCall(nodeId: NodeId, params: CompleteLLMCallParams): void;
-    /**
-     * Mark an LLM call as failed.
-     */
-    failLLMCall(nodeId: NodeId, error: Error, recovered: boolean): void;
-    /**
-     * Add a new gadget node to the tree.
-     */
-    addGadget(params: AddGadgetParams): GadgetNode;
-    /**
-     * Mark a gadget as started (running).
-     */
-    startGadget(nodeId: NodeId): void;
-    /**
-     * Complete a gadget node successfully.
-     */
-    completeGadget(nodeId: NodeId, params: CompleteGadgetParams): void;
-    /**
-     * Mark a gadget as skipped due to dependency failure.
-     */
-    skipGadget(nodeId: NodeId, failedDependency: string, failedDependencyError: string, reason: "dependency_failed" | "controller_skip"): void;
-    /**
-     * Emit a text event (notification only, not stored in tree).
-     */
-    emitText(content: string, llmCallNodeId: NodeId): void;
-    /**
-     * Get a node by ID.
-     */
-    getNode(id: NodeId): ExecutionNode | undefined;
-    /**
-     * Get a gadget node by invocation ID.
-     */
-    getNodeByInvocationId(invocationId: string): GadgetNode | undefined;
-    /**
-     * Get all root nodes (depth 0 for this tree).
-     */
-    getRoots(): ExecutionNode[];
-    /**
-     * Get children of a node.
-     */
-    getChildren(id: NodeId): ExecutionNode[];
-    /**
-     * Get ancestors of a node (from root to parent).
-     */
-    getAncestors(id: NodeId): ExecutionNode[];
-    /**
-     * Get all descendants of a node.
-     */
-    getDescendants(id: NodeId, type?: ExecutionNodeType): ExecutionNode[];
-    /**
-     * Get the current (most recent incomplete) LLM call node.
-     */
-    getCurrentLLMCallId(): NodeId | undefined;
-    /**
-     * Get total cost for entire tree.
-     */
-    getTotalCost(): number;
-    /**
-     * Get total cost for a subtree (node and all descendants).
-     */
-    getSubtreeCost(nodeId: NodeId): number;
-    /**
-     * Get token usage for entire tree.
-     */
-    getTotalTokens(): {
-        input: number;
-        output: number;
-        cached: number;
-    };
-    /**
-     * Get token usage for a subtree.
-     */
-    getSubtreeTokens(nodeId: NodeId): {
-        input: number;
-        output: number;
-        cached: number;
-    };
+interface CompactionConfig {
     /**
-     * Collect all media from a subtree.
+     * Enable or disable compaction.
+     * @default true
      */
-    getSubtreeMedia(nodeId: NodeId): GadgetMediaOutput[];
+    enabled?: boolean;
     /**
-     * Check if a subtree is complete (all nodes finished).
+     * The compaction strategy to use.
+     * - 'sliding-window': Fast, drops oldest turns (no LLM call)
+     * - 'summarization': LLM-based compression of old messages
+     * - 'hybrid': Summarizes old messages + keeps recent turns (recommended)
+     * - Or provide a custom CompactionStrategy instance
+     * @default 'hybrid'
      */
-    isSubtreeComplete(nodeId: NodeId): boolean;
+    strategy?: "sliding-window" | "summarization" | "hybrid" | CompactionStrategy;
     /**
-     * Get node counts.
+     * Context usage percentage that triggers compaction.
+     * When token count exceeds this percentage of the context window,
+     * compaction is performed before the next LLM call.
+     * @default 80
      */
-    getNodeCount(): {
-        llmCalls: number;
-        gadgets: number;
-    };
+    triggerThresholdPercent?: number;
     /**
-     * Subscribe to events of a specific type.
-     * Returns unsubscribe function.
-     *
-     * @param type - Event type to subscribe to (use "*" for all events)
-     * @param listener - Callback function that receives matching events
-     * @returns Unsubscribe function
-     *
-     * @example
-     * ```typescript
-     * const unsubscribe = tree.on("gadget_complete", (event) => {
-     *   if (event.type === "gadget_complete") {
-     *     console.log(`Gadget ${event.name} completed`);
-     *   }
-     * });
-     * ```
+     * Target context usage percentage after compaction.
+     * The compaction will aim to reduce tokens to this percentage.
+     * @default 50
      */
-    on(type: ExecutionEventType, listener: EventListener): () => void;
+    targetPercent?: number;
     /**
-     * Subscribe to all events.
+     * Number of recent turns to preserve during compaction.
+     * A "turn" is a user message + assistant response pair.
+     * Recent turns are kept verbatim while older ones are summarized/dropped.
+     * @default 5
      */
-    onAll(listener: EventListener): () => void;
+    preserveRecentTurns?: number;
     /**
-     * Get async iterable of all events.
-     * Events are yielded as they occur.
+     * Model to use for summarization.
+     * If not specified, uses the agent's model.
+     * @default undefined (uses agent's model)
      */
-    events(): AsyncGenerator<ExecutionEvent>;
+    summarizationModel?: string;
     /**
-     * Mark the tree as complete (no more events will be emitted).
+     * Custom system prompt for summarization.
+     * If not specified, uses a default prompt optimized for context preservation.
      */
-    complete(): void;
+    summarizationPrompt?: string;
     /**
-     * Check if the tree is complete.
+     * Callback invoked when compaction occurs.
+     * Useful for logging or analytics.
      */
-    isComplete(): boolean;
+    onCompaction?: (event: CompactionEvent) => void;
+}
+/**
+ * Default configuration values for compaction.
+ * Compaction is enabled by default with the hybrid strategy.
+ */
+declare const DEFAULT_COMPACTION_CONFIG: Required<Omit<CompactionConfig, "summarizationModel" | "summarizationPrompt" | "onCompaction">>;
+/**
+ * Default prompt used for summarization strategy.
+ */
+declare const DEFAULT_SUMMARIZATION_PROMPT = "Summarize this conversation history concisely, preserving:\n1. Key decisions made and their rationale\n2. Important facts and data discovered\n3. Errors encountered and how they were resolved\n4. Current task context and goals\n\nFormat as a brief narrative paragraph, not bullet points.\nPrevious conversation:";
+/**
+ * Resolved configuration with all defaults applied.
+ */
+interface ResolvedCompactionConfig {
+    enabled: boolean;
+    strategy: "sliding-window" | "summarization" | "hybrid";
+    triggerThresholdPercent: number;
+    targetPercent: number;
+    preserveRecentTurns: number;
+    summarizationModel?: string;
+    summarizationPrompt: string;
+    onCompaction?: (event: CompactionEvent) => void;
 }
 
 /**
@@ -1610,7 +1876,7 @@ type StreamEvent = {
     invocationId: string;
 } | {
     type: "compaction";
-    event: CompactionEvent$1;
+    event: CompactionEvent;
 } | SubagentStreamEvent | StreamCompletionEvent;
 /** Event for forwarding subagent activity through the stream */
 interface SubagentStreamEvent {
@@ -2110,6 +2376,52 @@ interface ExecutionContext {
      * ```
      */
     depth?: number;
+    /**
+     * Host llmist exports for external gadgets.
+     *
+     * External gadgets MUST use these instead of importing from 'llmist'
+     * to ensure they use the same version as the host CLI, enabling proper
+     * tree sharing and feature compatibility.
+     *
+     * Use the `getHostExports(ctx)` helper function to access these exports
+     * with proper error handling.
+     *
+     * @example
+     * ```typescript
+     * import { getHostExports, Gadget, z } from 'llmist';
+     *
+     * class BrowseWeb extends Gadget({...}) {
+     *   async execute(params, ctx) {
+     *     const { AgentBuilder } = getHostExports(ctx);
+     *     const agent = new AgentBuilder()
+     *       .withParentContext(ctx)
+     *       .ask(params.task);
+     *   }
+     * }
+     * ```
+     */
+    hostExports?: HostExports;
+}
+/**
+ * Host llmist exports provided to external gadgets via ExecutionContext.
+ *
+ * This ensures external gadgets use the same class instances as the host CLI,
+ * enabling proper tree sharing and avoiding the "dual-package problem" where
+ * different versions of llmist have incompatible classes.
+ */
+interface HostExports {
+    /** AgentBuilder for creating subagents with proper tree sharing */
+    AgentBuilder: typeof AgentBuilder;
+    /** Gadget factory for defining gadgets */
+    Gadget: typeof Gadget;
+    /** createGadget for functional gadget definitions */
+    createGadget: typeof createGadget;
+    /** ExecutionTree for tree operations */
+    ExecutionTree: typeof ExecutionTree;
+    /** LLMist client */
+    LLMist: typeof LLMist;
+    /** Zod schema builder */
+    z: typeof zod.z;
 }
 /**
  * Parent agent configuration passed to gadgets.
@@ -3929,7 +4241,7 @@ interface ObserveCompactionContext {
     /** Agent iteration when compaction occurred */
     iteration: number;
     /** Details of the compaction event */
-    event: CompactionEvent$1;
+    event: CompactionEvent;
     /** Cumulative compaction statistics */
     stats: CompactionStats;
     /** Logger instance */
@@ -4500,7 +4812,7 @@ declare class Agent {
      * }
      * ```
      */
-    compact(): Promise<CompactionEvent$1 | null>;
+    compact(): Promise<CompactionEvent | null>;
     /**
      * Get compaction statistics.
      *
@@ -6030,4 +6342,4 @@ declare function createTextMockStream(text: string, options?: {
     usage?: MockResponse["usage"];
 }): LLMStream;
 
-export { type ModelDescriptor as $, AbstractGadget as A, type MessageContent as B, type CompactionConfig as C, GadgetRegistry as D, MediaStore as E, type AgentContextConfig as F, type GadgetMediaOutput as G, type HintTemplate as H, type IConversationManager as I, type SubagentConfigMap as J, type SubagentEvent as K, type LLMMessage as L, MockProviderAdapter as M, ExecutionTree as N, type NodeId as O, type ExecutionContext as P, type GadgetExecuteReturn as Q, type ResolvedCompactionConfig as R, type StreamEvent as S, type TokenUsage as T, type GadgetExample as U, type ParsedGadgetCall as V, type GadgetExecutionResult as W, type MediaKind as X, type MediaMetadata as Y, type GadgetExecuteResultWithMedia as Z, type ProviderAdapter as _, type LLMStream as a, type GadgetSkippedEvent$1 as a$, type ModelSpec as a0, type LLMGenerationOptions as a1, type ImageModelSpec as a2, type ImageGenerationOptions as a3, type ImageGenerationResult as a4, type SpeechModelSpec as a5, type SpeechGenerationOptions as a6, type SpeechGenerationResult as a7, type HistoryMessage as a8, type TrailingMessage as a9, type ObserveGadgetCompleteContext as aA, type ObserveGadgetStartContext as aB, type ObserveLLMCallContext as aC, type ObserveLLMCompleteContext as aD, type ObserveLLMErrorContext as aE, type Observers as aF, type SubagentContext as aG, DEFAULT_COMPACTION_CONFIG as aH, DEFAULT_SUMMARIZATION_PROMPT as aI, type LLMistOptions as aJ, type AddGadgetParams as aK, type AddLLMCallParams as aL, type CompleteGadgetParams as aM, type CompleteLLMCallParams as aN, type ExecutionNode as aO, type ExecutionNodeType as aP, type GadgetNode as aQ, type GadgetState as aR, type LLMCallNode as aS, type BaseExecutionEvent as aT, type CompactionEvent as aU, type ExecutionEvent as aV, type ExecutionEventType as aW, type GadgetCallEvent as aX, type GadgetCompleteEvent as aY, type GadgetErrorEvent as aZ, type GadgetEvent as a_, type TrailingMessageContext as aa, AgentBuilder as ab, type EventHandlers as ac, collectEvents as ad, collectText as ae, runWithHandlers as af, type AfterGadgetExecutionAction as ag, type AfterGadgetExecutionControllerContext as ah, type AfterLLMCallAction as ai, type AfterLLMCallControllerContext as aj, type AfterLLMErrorAction as ak, type AgentOptions as al, type BeforeGadgetExecutionAction as am, type BeforeLLMCallAction as an, type ChunkInterceptorContext as ao, type Controllers as ap, type GadgetExecutionControllerContext as aq, type GadgetParameterInterceptorContext as ar, type GadgetResultInterceptorContext as as, type Interceptors as at, type LLMCallControllerContext as au, type LLMErrorControllerContext as av, type MessageInterceptorContext as aw, type MessageTurn as ax, type ObserveChunkContext as ay, type ObserveCompactionContext as az, type LLMStreamChunk as b, complete as b$, type GadgetStartEvent as b0, type HumanInputRequiredEvent as b1, type LLMCallCompleteEvent as b2, type LLMCallErrorEvent as b3, type LLMCallStartEvent as b4, type LLMCallStreamEvent as b5, type LLMEvent as b6, type StreamCompleteEvent as b7, type TextEvent as b8, filterByDepth as b9, isImagePart as bA, isTextPart as bB, parseDataUrl as bC, text as bD, toBase64 as bE, type MessageRole as bF, extractMessageText as bG, LLMMessageBuilder as bH, normalizeMessageContent as bI, type CostEstimate as bJ, type ModelFeatures as bK, type ModelLimits as bL, type ModelPricing as bM, type VisionAnalyzeOptions as bN, type VisionAnalyzeResult as bO, type ProviderIdentifier as bP, ModelIdentifierParser as bQ, type HintContext as bR, type PromptContext as bS, type PromptTemplate as bT, type PromptTemplateConfig as bU, DEFAULT_HINTS as bV, DEFAULT_PROMPTS as bW, resolveHintTemplate as bX, resolvePromptTemplate as bY, resolveRulesTemplate as bZ, type TextGenerationOptions as b_, filterByParent as ba, filterRootEvents as bb, groupByParent as bc, isGadgetEvent as bd, isLLMEvent as be, isRootEvent as bf, isSubagentEvent as bg, type AudioContentPart as bh, type AudioMimeType as bi, type AudioSource as bj, type ContentPart as bk, type ImageBase64Source as bl, type ImageContentPart as bm, type ImageMimeType as bn, type ImageSource as bo, type ImageUrlSource as bp, type TextContentPart as bq, audioFromBase64 as br, audioFromBuffer as bs, detectAudioMimeType as bt, detectImageMimeType as bu, imageFromBase64 as bv, imageFromBuffer as bw, imageFromUrl as bx, isAudioPart as by, isDataUrl as bz, createMockAdapter as c, stream as c0, type GadgetClass as c1, type GadgetOrClass as c2, type CostReportingLLMist as c3, type GadgetExecuteResult as c4, type GadgetSkippedEvent as c5, type StoredMedia as c6, type SubagentStreamEvent as c7, type TextOnlyAction as c8, type TextOnlyContext as c9, type TextOnlyCustomHandler as ca, type TextOnlyGadgetConfig as cb, type TextOnlyHandler as cc, type TextOnlyStrategy as cd, MockBuilder as d, createMockClient as e, MockManager as f, getMockManager as g, createMockStream as h, createTextMockStream as i, type MockAudioData as j, type MockImageData as k, type MockMatcher as l, mockLLM as m, type MockMatcherContext as n, type MockOptions as o, type MockRegistration as p, type MockResponse as q, type MockStats as r, type AgentHooks as s, ModelRegistry as t, LLMist as u, type CompactionEvent$1 as v, type CompactionStats as w, type CompactionStrategy as x, type CompactionContext as y, type CompactionResult as z };
+export { type LLMGenerationOptions as $, AbstractGadget as A, type MessageContent as B, type CompactionConfig as C, GadgetRegistry as D, MediaStore as E, type AgentContextConfig as F, type GadgetMediaOutput as G, type HintTemplate as H, type IConversationManager as I, type SubagentConfigMap as J, type SubagentEvent as K, type LLMMessage as L, MockProviderAdapter as M, ExecutionTree as N, type NodeId as O, type ParsedGadgetCall as P, type GadgetExecutionResult as Q, type ResolvedCompactionConfig as R, type StreamEvent as S, type TokenUsage as T, type MediaKind as U, type MediaMetadata as V, type GadgetExecuteResultWithMedia as W, type ExecutionContext as X, type ProviderAdapter as Y, type ModelDescriptor as Z, type ModelSpec as _, type LLMStream as a, type GadgetStartEvent as a$, type ImageModelSpec as a0, type ImageGenerationOptions as a1, type ImageGenerationResult as a2, type SpeechModelSpec as a3, type SpeechGenerationOptions as a4, type SpeechGenerationResult as a5, type HostExports as a6, type HistoryMessage as a7, type TrailingMessage as a8, type TrailingMessageContext as a9, type ObserveGadgetStartContext as aA, type ObserveLLMCallContext as aB, type ObserveLLMCompleteContext as aC, type ObserveLLMErrorContext as aD, type Observers as aE, type SubagentContext as aF, DEFAULT_COMPACTION_CONFIG as aG, DEFAULT_SUMMARIZATION_PROMPT as aH, type LLMistOptions as aI, type AddGadgetParams as aJ, type AddLLMCallParams as aK, type CompleteGadgetParams as aL, type CompleteLLMCallParams as aM, type ExecutionNode as aN, type ExecutionNodeType as aO, type GadgetNode as aP, type GadgetState as aQ, type LLMCallNode as aR, type BaseExecutionEvent as aS, type CompactionEvent$1 as aT, type ExecutionEvent as aU, type ExecutionEventType as aV, type GadgetCallEvent as aW, type GadgetCompleteEvent as aX, type GadgetErrorEvent as aY, type GadgetEvent as aZ, type GadgetSkippedEvent$1 as a_, AgentBuilder as aa, type EventHandlers as ab, collectEvents as ac, collectText as ad, runWithHandlers as ae, type AfterGadgetExecutionAction as af, type AfterGadgetExecutionControllerContext as ag, type AfterLLMCallAction as ah, type AfterLLMCallControllerContext as ai, type AfterLLMErrorAction as aj, type AgentOptions as ak, type BeforeGadgetExecutionAction as al, type BeforeLLMCallAction as am, type ChunkInterceptorContext as an, type Controllers as ao, type GadgetExecutionControllerContext as ap, type GadgetParameterInterceptorContext as aq, type GadgetResultInterceptorContext as ar, type Interceptors as as, type LLMCallControllerContext as at, type LLMErrorControllerContext as au, type MessageInterceptorContext as av, type MessageTurn as aw, type ObserveChunkContext as ax, type ObserveCompactionContext as ay, type ObserveGadgetCompleteContext as az, type LLMStreamChunk as b, stream as b$, type HumanInputRequiredEvent as b0, type LLMCallCompleteEvent as b1, type LLMCallErrorEvent as b2, type LLMCallStartEvent as b3, type LLMCallStreamEvent as b4, type LLMEvent as b5, type StreamCompleteEvent as b6, type TextEvent as b7, filterByDepth as b8, filterByParent as b9, isTextPart as bA, parseDataUrl as bB, text as bC, toBase64 as bD, type MessageRole as bE, extractMessageText as bF, LLMMessageBuilder as bG, normalizeMessageContent as bH, type CostEstimate as bI, type ModelFeatures as bJ, type ModelLimits as bK, type ModelPricing as bL, type VisionAnalyzeOptions as bM, type VisionAnalyzeResult as bN, type ProviderIdentifier as bO, ModelIdentifierParser as bP, type HintContext as bQ, type PromptContext as bR, type PromptTemplate as bS, type PromptTemplateConfig as bT, DEFAULT_HINTS as bU, DEFAULT_PROMPTS as bV, resolveHintTemplate as bW, resolvePromptTemplate as bX, resolveRulesTemplate as bY, type TextGenerationOptions as bZ, complete as b_, filterRootEvents as ba, groupByParent as bb, isGadgetEvent as bc, isLLMEvent as bd, isRootEvent as be, isSubagentEvent as bf, type AudioContentPart as bg, type AudioMimeType as bh, type AudioSource as bi, type ContentPart as bj, type ImageBase64Source as bk, type ImageContentPart as bl, type ImageMimeType as bm, type ImageSource as bn, type ImageUrlSource as bo, type TextContentPart as bp, audioFromBase64 as bq, audioFromBuffer as br, detectAudioMimeType as bs, detectImageMimeType as bt, imageFromBase64 as bu, imageFromBuffer as bv, imageFromUrl as bw, isAudioPart as bx, isDataUrl as by, isImagePart as bz, createMockAdapter as c, type CreateGadgetConfig as c0, createGadget as c1, type GadgetClass as c2, type GadgetOrClass as c3, type GadgetConfig as c4, Gadget as c5, type CostReportingLLMist as c6, type GadgetExample as c7, type GadgetExecuteResult as c8, type GadgetExecuteReturn as c9, type GadgetSkippedEvent as ca, type StoredMedia as cb, type SubagentStreamEvent as cc, type TextOnlyAction as cd, type TextOnlyContext as ce, type TextOnlyCustomHandler as cf, type TextOnlyGadgetConfig as cg, type TextOnlyHandler as ch, type TextOnlyStrategy as ci, MockBuilder as d, createMockClient as e, MockManager as f, getMockManager as g, createMockStream as h, createTextMockStream as i, type MockAudioData as j, type MockImageData as k, type MockMatcher as l, mockLLM as m, type MockMatcherContext as n, type MockOptions as o, type MockRegistration as p, type MockResponse as q, type MockStats as r, type AgentHooks as s, ModelRegistry as t, LLMist as u, type CompactionEvent as v, type CompactionStats as w, type CompactionStrategy as x, type CompactionContext as y, type CompactionResult as z };