llmist 1.2.0 → 1.3.1

package/dist/{mock-stream-DKF5yatf.d.ts → mock-stream-DNt-HBTn.d.ts}

@@ -1,5 +1,319 @@
-import { Logger, ILogObj } from 'tslog';
 import { ZodTypeAny } from 'zod';
+import { Logger, ILogObj } from 'tslog';
+
+/**
+ * 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 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";
+}
+
+/**
+ * Strategy interface for context compaction.
+ *
+ * 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)
+ */
+
+/**
+ * Context provided to compaction strategies.
+ */
+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;
+}
+/**
+ * Result of a compaction operation.
+ */
+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 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 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>;
+}
+/**
+ * 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.
+ */
+interface MessageTurn {
+    /** Messages in this turn (user + assistant + any gadget results) */
+    messages: LLMMessage[];
+    /** Estimated token count for this turn */
+    tokenEstimate: number;
+}
+
+/**
+ * Configuration types for the context compaction system.
+ *
+ * Context compaction automatically manages conversation history to prevent
+ * context window overflow in long-running agent conversations.
+ */
+
+/**
+ * Event emitted when compaction occurs.
+ * This is included in StreamEvent for UI visibility.
+ */
+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;
+}
+/**
+ * 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
+ * // 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('...');
+ * ```
+ */
+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) => 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;
+}
 
 /**
  * Example of gadget usage to help LLMs understand proper invocation.
@@ -44,6 +358,7 @@ interface ParsedGadgetCall {
     parameters?: Record<string, unknown>;
     parseError?: string;
 }
+
 type StreamEvent = {
     type: "text";
     content: string;
@@ -58,6 +373,9 @@ type StreamEvent = {
     question: string;
     gadgetName: string;
     invocationId: string;
+} | {
+    type: "compaction";
+    event: CompactionEvent;
 };
 
 type TextOnlyHandler = TextOnlyStrategy | TextOnlyGadgetConfig | TextOnlyCustomHandler;
@@ -193,10 +511,27 @@ interface PromptContext {
     /** Names of all gadgets */
     gadgetNames: string[];
 }
+/**
+ * Context provided to hint template functions for rendering dynamic hints.
+ */
+interface HintContext {
+    /** Current iteration (1-based for readability) */
+    iteration: number;
+    /** Maximum iterations allowed */
+    maxIterations: number;
+    /** Iterations remaining (maxIterations - iteration) */
+    remaining: number;
+    /** Number of gadget calls in the current response */
+    gadgetCallCount?: number;
+}
 /**
  * Template that can be either a static string or a function that renders based on context.
  */
 type PromptTemplate = string | ((context: PromptContext) => string);
+/**
+ * Template for hints that can be either a static string or a function that renders based on hint context.
+ */
+type HintTemplate = string | ((context: HintContext) => string);
 /**
  * Configuration for customizing all prompts used internally by llmist.
  *
@@ -244,11 +579,33 @@ interface PromptConfig {
      * Should be a function that returns formatted example strings.
      */
     customExamples?: (context: PromptContext) => string;
+    /**
+     * Hint shown when LLM uses only one gadget per response.
+     * Encourages parallel gadget usage for efficiency.
+     */
+    parallelGadgetsHint?: HintTemplate;
+    /**
+     * Template for iteration progress hint.
+     * Informs the LLM about remaining iterations to help plan work.
+     *
+     * When using a string template, supports placeholders:
+     * - {iteration}: Current iteration (1-based)
+     * - {maxIterations}: Maximum iterations allowed
+     * - {remaining}: Iterations remaining
+     */
+    iterationProgressHint?: HintTemplate;
 }
+/**
+ * Default hint templates used by llmist.
+ */
+declare const DEFAULT_HINTS: {
+    readonly parallelGadgetsHint: "Tip: You can call multiple gadgets in a single response for efficiency.";
+    readonly iterationProgressHint: "[Iteration {iteration}/{maxIterations}] Plan your actions accordingly.";
+};
 /**
  * Default prompt templates used by llmist.
  */
-declare const DEFAULT_PROMPTS: Required<Omit<PromptConfig, "rules" | "customExamples"> & {
+declare const DEFAULT_PROMPTS: Required<Omit<PromptConfig, "rules" | "customExamples" | "parallelGadgetsHint" | "iterationProgressHint"> & {
     rules: (context: PromptContext) => string[];
     customExamples: null;
 }>;
@@ -260,6 +617,16 @@ declare function resolvePromptTemplate(template: PromptTemplate | undefined, def
  * Resolve rules template to an array of strings.
  */
 declare function resolveRulesTemplate(rules: PromptConfig["rules"] | undefined, context: PromptContext): string[];
+/**
+ * Resolve a hint template to a string using the given context.
+ * Supports both function templates and string templates with placeholders.
+ *
+ * @param template - The hint template to resolve
+ * @param defaultValue - Default value if template is undefined
+ * @param context - Context for rendering the template
+ * @returns The resolved hint string
+ */
+declare function resolveHintTemplate(template: HintTemplate | undefined, defaultValue: string, context: HintContext): string;
 
 type LLMRole = "system" | "user" | "assistant";
 interface LLMMessage {
@@ -301,82 +668,6 @@ declare class LLMMessageBuilder {
     build(): LLMMessage[];
 }
 
-/**
- * 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 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";
-}
-
 interface LLMGenerationOptions {
     model: string;
     messages: LLMMessage[];
@@ -1213,6 +1504,22 @@ interface Observers {
     onGadgetExecutionComplete?: (context: ObserveGadgetCompleteContext) => void | Promise<void>;
     /** Called for each stream chunk */
     onStreamChunk?: (context: ObserveChunkContext) => void | Promise<void>;
+    /** Called when context compaction occurs */
+    onCompaction?: (context: ObserveCompactionContext) => void | Promise<void>;
+}
+/**
+ * Context provided when context compaction occurs.
+ * Read-only observation point.
+ */
+interface ObserveCompactionContext {
+    /** Agent iteration when compaction occurred */
+    iteration: number;
+    /** Details of the compaction event */
+    event: CompactionEvent;
+    /** Cumulative compaction statistics */
+    stats: CompactionStats;
+    /** Logger instance */
+    logger: Logger<ILogObj>;
 }
 /**
  * Context for chunk interception.
@@ -1311,6 +1618,8 @@ interface Interceptors {
  */
 interface LLMCallControllerContext {
     iteration: number;
+    /** Maximum iterations configured for the agent */
+    maxIterations: number;
     options: LLMGenerationOptions;
     logger: Logger<ILogObj>;
 }
@@ -1329,12 +1638,16 @@ type BeforeLLMCallAction = {
  */
 interface AfterLLMCallControllerContext {
     iteration: number;
+    /** Maximum iterations configured for the agent */
+    maxIterations: number;
     options: Readonly<LLMGenerationOptions>;
     finishReason: string | null;
     /** Token usage including cached token counts when available */
     usage?: TokenUsage;
     /** The final message (after interceptors) that will be added to history */
     finalMessage: string;
+    /** Number of gadget calls in the current response */
+    gadgetCallCount: number;
     logger: Logger<ILogObj>;
 }
 /**
@@ -1535,6 +1848,8 @@ interface AgentOptions {
     gadgetOutputLimit?: boolean;
     /** Max gadget output as % of model context window (default: 15) */
     gadgetOutputLimitPercent?: number;
+    /** Context compaction configuration (enabled by default) */
+    compactionConfig?: CompactionConfig;
 }
 /**
  * Agent: Lean orchestrator that delegates to StreamProcessor.
@@ -1574,6 +1889,7 @@ declare class Agent {
     private readonly outputStore;
     private readonly outputLimitEnabled;
     private readonly outputLimitCharLimit;
+    private readonly compactionManager?;
     /**
      * Creates a new Agent instance.
      * @internal This constructor is private. Use LLMist.createAgent() or AgentBuilder instead.
@@ -1598,6 +1914,46 @@ declare class Agent {
      * ```
      */
     getRegistry(): GadgetRegistry;
+    /**
+     * Manually trigger context compaction.
+     *
+     * Forces compaction regardless of threshold. Useful for:
+     * - Pre-emptive context management before expected long operations
+     * - Testing compaction behavior
+     *
+     * @returns CompactionEvent if compaction was performed, null if not configured or no history
+     *
+     * @example
+     * ```typescript
+     * const agent = await LLMist.createAgent()
+     *   .withModel('sonnet')
+     *   .withCompaction()
+     *   .ask('...');
+     *
+     * // Manually compact before a long operation
+     * const event = await agent.compact();
+     * if (event) {
+     *   console.log(`Saved ${event.tokensBefore - event.tokensAfter} tokens`);
+     * }
+     * ```
+     */
+    compact(): Promise<CompactionEvent | null>;
+    /**
+     * Get compaction statistics.
+     *
+     * @returns CompactionStats if compaction is enabled, null otherwise
+     *
+     * @example
+     * ```typescript
+     * const stats = agent.getCompactionStats();
+     * if (stats) {
+     *   console.log(`Total compactions: ${stats.totalCompactions}`);
+     *   console.log(`Tokens saved: ${stats.totalTokensSaved}`);
+     *   console.log(`Current usage: ${stats.currentUsage.percent.toFixed(1)}%`);
+     * }
+     * ```
+     */
+    getCompactionStats(): CompactionStats | null;
     /**
      * Run the agent loop.
      * Clean, simple orchestration - all complexity is in StreamProcessor.
@@ -1701,6 +2057,7 @@ declare class AgentBuilder {
     private defaultGadgetTimeoutMs?;
     private gadgetOutputLimit?;
     private gadgetOutputLimitPercent?;
+    private compactionConfig?;
     constructor(client?: LLMist);
     /**
      * Set the model to use.
@@ -2027,6 +2384,51 @@ declare class AgentBuilder {
      * ```
      */
     withGadgetOutputLimitPercent(percent: number): this;
+    /**
+     * Configure context compaction.
+     *
+     * Context compaction automatically manages conversation history to prevent
+     * context window overflow in long-running agent conversations.
+     *
+     * @param config - Compaction configuration options
+     * @returns This builder for chaining
+     *
+     * @example
+     * ```typescript
+     * // Custom thresholds
+     * .withCompaction({
+     *   triggerThresholdPercent: 70,
+     *   targetPercent: 40,
+     *   preserveRecentTurns: 10,
+     * })
+     *
+     * // Different strategy
+     * .withCompaction({
+     *   strategy: 'sliding-window',
+     * })
+     *
+     * // With callback
+     * .withCompaction({
+     *   onCompaction: (event) => {
+     *     console.log(`Saved ${event.tokensBefore - event.tokensAfter} tokens`);
+     *   }
+     * })
+     * ```
+     */
+    withCompaction(config: CompactionConfig): this;
+    /**
+     * Disable context compaction.
+     *
+     * By default, compaction is enabled. Use this method to explicitly disable it.
+     *
+     * @returns This builder for chaining
+     *
+     * @example
+     * ```typescript
+     * .withoutCompaction() // Disable automatic compaction
+     * ```
+     */
+    withoutCompaction(): this;
     /**
      * Add a synthetic gadget call to the conversation history.
      *
@@ -2144,6 +2546,50 @@ declare class AgentBuilder {
     build(): Agent;
 }
 
+/**
+ * Core interfaces for the Agent architecture.
+ * These interfaces define the contracts for the composable services that make up the agent system.
+ */
+
+/**
+ * Manages the conversation history and message building.
+ * This interface abstracts conversation state management from the orchestration logic.
+ */
+interface IConversationManager {
+    /**
+     * Adds a user message to the conversation.
+     */
+    addUserMessage(content: string): void;
+    /**
+     * Adds an assistant message to the conversation.
+     */
+    addAssistantMessage(content: string): void;
+    /**
+     * Adds a gadget call and its result to the conversation.
+     */
+    addGadgetCall(gadgetName: string, parameters: Record<string, unknown>, result: string): void;
+    /**
+     * Gets the complete conversation history including base messages (system prompts, gadget instructions).
+     */
+    getMessages(): LLMMessage[];
+    /**
+     * Gets only the conversation history messages (excludes base messages).
+     * Used by compaction to determine what can be compressed.
+     */
+    getHistoryMessages(): LLMMessage[];
+    /**
+     * Gets the base messages (system prompts, gadget instructions).
+     * These are never compacted and always included at the start.
+     */
+    getBaseMessages(): LLMMessage[];
+    /**
+     * Replaces the conversation history with new messages.
+     * Used by compaction to update history after compression.
+     * @param newHistory - The compacted history messages to replace with
+     */
+    replaceHistory(newHistory: LLMMessage[]): void;
+}
+
 /**
  * Context provided to matcher functions to determine if a mock should be used.
  */
@@ -2712,4 +3158,4 @@ declare function createTextMockStream(text: string, options?: {
     usage?: MockResponse["usage"];
 }): LLMStream;
 
-export { type MessageInterceptorContext as $, type AgentHooks as A, BaseGadget as B, runWithHandlers as C, type AfterGadgetExecutionAction as D, type EventHandlers as E, type AfterGadgetExecutionControllerContext as F, GadgetRegistry as G, type HistoryMessage as H, type AfterLLMCallAction as I, type AfterLLMCallControllerContext as J, type AfterLLMErrorAction as K, type LLMMessage as L, MockProviderAdapter as M, type AgentOptions as N, type BeforeGadgetExecutionAction as O, type ParsedGadgetCall as P, type BeforeLLMCallAction as Q, type ChunkInterceptorContext as R, type StreamEvent as S, type TokenUsage as T, type Controllers as U, type GadgetExecutionControllerContext as V, type GadgetParameterInterceptorContext as W, type GadgetResultInterceptorContext as X, type Interceptors as Y, type LLMCallControllerContext as Z, type LLMErrorControllerContext as _, MockBuilder as a, type ObserveChunkContext as a0, type ObserveGadgetCompleteContext as a1, type ObserveGadgetStartContext as a2, type ObserveLLMCallContext as a3, type ObserveLLMCompleteContext as a4, type ObserveLLMErrorContext as a5, type Observers as a6, type LLMistOptions as a7, LLMist as a8, type LLMRole as a9, LLMMessageBuilder as aa, type CostEstimate as ab, type ModelFeatures as ac, type ModelLimits as ad, type ModelPricing as ae, type ProviderIdentifier as af, ModelIdentifierParser as ag, type PromptConfig as ah, type PromptContext as ai, type PromptTemplate as aj, DEFAULT_PROMPTS as ak, resolvePromptTemplate as al, resolveRulesTemplate as am, type QuickOptions as an, complete as ao, stream as ap, type GadgetClass as aq, type GadgetOrClass as ar, type TextOnlyAction as as, type TextOnlyContext as at, type TextOnlyCustomHandler as au, type TextOnlyGadgetConfig as av, type TextOnlyHandler as aw, type TextOnlyStrategy as ax, createMockClient as b, createMockAdapter as c, MockManager as d, createMockStream as e, createTextMockStream as f, getMockManager as g, type MockMatcher as h, type MockMatcherContext as i, type MockOptions as j, type MockRegistration as k, type MockResponse as l, mockLLM as m, type MockStats as n, ModelRegistry as o, type LLMStreamChunk as p, type GadgetExample as q, type GadgetExecutionResult as r, type ProviderAdapter as s, type ModelDescriptor as t, type ModelSpec as u, type LLMGenerationOptions as v, type LLMStream as w, AgentBuilder as x, collectEvents as y, collectText as z };
+export { type BeforeGadgetExecutionAction as $, type AgentHooks as A, BaseGadget as B, type CompactionStrategy as C, type ModelDescriptor as D, type ModelSpec as E, type LLMGenerationOptions as F, GadgetRegistry as G, type HintTemplate as H, type IConversationManager as I, type HistoryMessage as J, AgentBuilder as K, type LLMStream as L, MockProviderAdapter as M, type EventHandlers as N, collectEvents as O, type ParsedGadgetCall as P, collectText as Q, type ResolvedCompactionConfig as R, type StreamEvent as S, type TokenUsage as T, runWithHandlers as U, type AfterGadgetExecutionAction as V, type AfterGadgetExecutionControllerContext as W, type AfterLLMCallAction as X, type AfterLLMCallControllerContext as Y, type AfterLLMErrorAction as Z, type AgentOptions as _, type LLMStreamChunk as a, type BeforeLLMCallAction as a0, type ChunkInterceptorContext as a1, type Controllers as a2, type GadgetExecutionControllerContext as a3, type GadgetParameterInterceptorContext as a4, type GadgetResultInterceptorContext as a5, type Interceptors as a6, type LLMCallControllerContext as a7, type LLMErrorControllerContext as a8, type MessageInterceptorContext as a9, resolveHintTemplate as aA, resolvePromptTemplate as aB, resolveRulesTemplate as aC, type QuickOptions as aD, complete as aE, stream as aF, type GadgetClass as aG, type GadgetOrClass as aH, type TextOnlyAction as aI, type TextOnlyContext as aJ, type TextOnlyCustomHandler as aK, type TextOnlyGadgetConfig as aL, type TextOnlyHandler as aM, type TextOnlyStrategy as aN, type ObserveChunkContext as aa, type ObserveGadgetCompleteContext as ab, type ObserveGadgetStartContext as ac, type ObserveLLMCallContext as ad, type ObserveLLMCompleteContext as ae, type ObserveLLMErrorContext as af, type Observers as ag, type MessageTurn as ah, type ObserveCompactionContext as ai, DEFAULT_COMPACTION_CONFIG as aj, DEFAULT_SUMMARIZATION_PROMPT as ak, type LLMistOptions as al, type LLMRole as am, LLMMessageBuilder as an, type CostEstimate as ao, type ModelFeatures as ap, type ModelLimits as aq, type ModelPricing as ar, type ProviderIdentifier as as, ModelIdentifierParser as at, type HintContext as au, type PromptConfig as av, type PromptContext as aw, type PromptTemplate as ax, DEFAULT_HINTS as ay, DEFAULT_PROMPTS as az, type LLMMessage as b, createMockAdapter as c, MockBuilder as d, createMockClient as e, MockManager as f, getMockManager as g, createMockStream as h, createTextMockStream as i, type MockMatcher as j, type MockMatcherContext as k, type MockOptions as l, mockLLM as m, type MockRegistration as n, type MockResponse as o, type MockStats as p, ModelRegistry as q, type CompactionContext as r, type CompactionResult as s, LLMist as t, type CompactionConfig as u, type CompactionEvent as v, type CompactionStats as w, type GadgetExample as x, type GadgetExecutionResult as y, type ProviderAdapter as z };