llmist 6.1.0 → 6.2.0

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-import { ZodType, ZodTypeAny } from 'zod';
+import { ZodTypeAny } from 'zod';
 export { z } from 'zod';
-import { s as AgentHooks, t as ModelRegistry, u as LLMist, C as CompactionConfig, I as IConversationManager, v as CompactionEvent, L as LLMMessage, w as CompactionStats, x as CompactionStrategy, R as ResolvedCompactionConfig, y as CompactionContext, z as CompactionResult, B as MessageContent, G as GadgetMediaOutput, H as HintTemplate, S as StreamEvent, T as TokenUsage, D as GadgetRegistry, E as MediaStore, F as AgentContextConfig, J as SubagentConfigMap, K as SubagentEvent, N as ExecutionTree, O as NodeId, b as LLMStreamChunk, P as ExecutionContext, Q as GadgetExecuteReturn, U as GadgetExample, A as AbstractGadget, V as ParsedGadgetCall, W as GadgetExecutionResult, X as MediaKind, Y as MediaMetadata, Z as GadgetExecuteResultWithMedia, _ as ProviderAdapter, $ as ModelDescriptor, a0 as ModelSpec, a1 as LLMGenerationOptions, a as LLMStream, a2 as ImageModelSpec, a3 as ImageGenerationOptions, a4 as ImageGenerationResult, a5 as SpeechModelSpec, a6 as SpeechGenerationOptions, a7 as SpeechGenerationResult } from './mock-stream-Cq1Sxezz.cjs';
-export { aK as AddGadgetParams, aL as AddLLMCallParams, ag as AfterGadgetExecutionAction, ah as AfterGadgetExecutionControllerContext, ai as AfterLLMCallAction, aj as AfterLLMCallControllerContext, ak as AfterLLMErrorAction, ab as AgentBuilder, al as AgentOptions, bh as AudioContentPart, bi as AudioMimeType, bj as AudioSource, aT as BaseExecutionEvent, am as BeforeGadgetExecutionAction, an as BeforeLLMCallAction, ao as ChunkInterceptorContext, aM as CompleteGadgetParams, aN as CompleteLLMCallParams, bk as ContentPart, ap as Controllers, bJ as CostEstimate, c3 as CostReportingLLMist, aH as DEFAULT_COMPACTION_CONFIG, bV as DEFAULT_HINTS, bW as DEFAULT_PROMPTS, aI as DEFAULT_SUMMARIZATION_PROMPT, ac as EventHandlers, aV as ExecutionEvent, aW as ExecutionEventType, aO as ExecutionNode, aP as ExecutionNodeType, aX as GadgetCallEvent, c1 as GadgetClass, aY as GadgetCompleteEvent, aZ as GadgetErrorEvent, a_ as GadgetEvent, c4 as GadgetExecuteResult, aq as GadgetExecutionControllerContext, aQ as GadgetNode, c2 as GadgetOrClass, ar as GadgetParameterInterceptorContext, as as GadgetResultInterceptorContext, c5 as GadgetSkippedEvent, b0 as GadgetStartEvent, aR as GadgetState, bR as HintContext, a8 as HistoryMessage, b1 as HumanInputRequiredEvent, bl as ImageBase64Source, bm as ImageContentPart, bn as ImageMimeType, bo as ImageSource, bp as ImageUrlSource, at as Interceptors, b2 as LLMCallCompleteEvent, au as LLMCallControllerContext, b3 as LLMCallErrorEvent, aS as LLMCallNode, b4 as LLMCallStartEvent, b5 as LLMCallStreamEvent, av as LLMErrorControllerContext, b6 as LLMEvent, bH as LLMMessageBuilder, aJ as LLMistOptions, aw as MessageInterceptorContext, bF as MessageRole, ax as MessageTurn, d as MockBuilder, f as MockManager, l as MockMatcher, n as MockMatcherContext, o as MockOptions, M as MockProviderAdapter, p as MockRegistration, q as MockResponse, r as MockStats, bK as ModelFeatures, bQ as ModelIdentifierParser, bL as ModelLimits, bM as ModelPricing, ay as ObserveChunkContext, az as ObserveCompactionContext, aA as ObserveGadgetCompleteContext, aB as ObserveGadgetStartContext, aC as ObserveLLMCallContext, aD as ObserveLLMCompleteContext, aE as ObserveLLMErrorContext, aF as Observers, bS as PromptContext, bT as PromptTemplate, bU as PromptTemplateConfig, bP as ProviderIdentifier, c6 as StoredMedia, b7 as StreamCompleteEvent, aG as SubagentContext, c7 as SubagentStreamEvent, bq as TextContentPart, b8 as TextEvent, b_ as TextGenerationOptions, c8 as TextOnlyAction, c9 as TextOnlyContext, ca as TextOnlyCustomHandler, cb as TextOnlyGadgetConfig, cc as TextOnlyHandler, cd as TextOnlyStrategy, a9 as TrailingMessage, aa as TrailingMessageContext, aU as TreeCompactionEvent, a$ as TreeGadgetSkippedEvent, bN as VisionAnalyzeOptions, bO as VisionAnalyzeResult, br as audioFromBase64, bs as audioFromBuffer, ad as collectEvents, ae as collectText, b$ as complete, c as createMockAdapter, e as createMockClient, h as createMockStream, i as createTextMockStream, bt as detectAudioMimeType, bu as detectImageMimeType, bG as extractMessageText, b9 as filterByDepth, ba as filterByParent, bb as filterRootEvents, g as getMockManager, bc as groupByParent, bv as imageFromBase64, bw as imageFromBuffer, bx as imageFromUrl, by as isAudioPart, bz as isDataUrl, bd as isGadgetEvent, bA as isImagePart, be as isLLMEvent, bf as isRootEvent, bg as isSubagentEvent, bB as isTextPart, m as mockLLM, bI as normalizeMessageContent, bC as parseDataUrl, bX as resolveHintTemplate, bY as resolvePromptTemplate, bZ as resolveRulesTemplate, af as runWithHandlers, c0 as stream, bD as text, bE as toBase64 } from './mock-stream-Cq1Sxezz.cjs';
+import { s as AgentHooks, t as ModelRegistry, u as LLMist, C as CompactionConfig, I as IConversationManager, v as CompactionEvent, L as LLMMessage, w as CompactionStats, x as CompactionStrategy, R as ResolvedCompactionConfig, y as CompactionContext, z as CompactionResult, B as MessageContent, G as GadgetMediaOutput, H as HintTemplate, S as StreamEvent, T as TokenUsage, D as GadgetRegistry, E as MediaStore, F as AgentContextConfig, J as SubagentConfigMap, K as SubagentEvent, N as ExecutionTree, O as NodeId, b as LLMStreamChunk, P as ParsedGadgetCall, Q as GadgetExecutionResult, A as AbstractGadget, U as MediaKind, V as MediaMetadata, W as GadgetExecuteResultWithMedia, X as ExecutionContext, Y as ProviderAdapter, Z as ModelDescriptor, _ as ModelSpec, $ as LLMGenerationOptions, a as LLMStream, a0 as ImageModelSpec, a1 as ImageGenerationOptions, a2 as ImageGenerationResult, a3 as SpeechModelSpec, a4 as SpeechGenerationOptions, a5 as SpeechGenerationResult, a6 as HostExports } from './mock-stream-DG4wF-NH.cjs';
+export { aJ as AddGadgetParams, aK as AddLLMCallParams, af as AfterGadgetExecutionAction, ag as AfterGadgetExecutionControllerContext, ah as AfterLLMCallAction, ai as AfterLLMCallControllerContext, aj as AfterLLMErrorAction, aa as AgentBuilder, ak as AgentOptions, bg as AudioContentPart, bh as AudioMimeType, bi as AudioSource, aS as BaseExecutionEvent, al as BeforeGadgetExecutionAction, am as BeforeLLMCallAction, an as ChunkInterceptorContext, aL as CompleteGadgetParams, aM as CompleteLLMCallParams, bj as ContentPart, ao as Controllers, bI as CostEstimate, c6 as CostReportingLLMist, c0 as CreateGadgetConfig, aG as DEFAULT_COMPACTION_CONFIG, bU as DEFAULT_HINTS, bV as DEFAULT_PROMPTS, aH as DEFAULT_SUMMARIZATION_PROMPT, ab as EventHandlers, aU as ExecutionEvent, aV as ExecutionEventType, aN as ExecutionNode, aO as ExecutionNodeType, c5 as Gadget, aW as GadgetCallEvent, c2 as GadgetClass, aX as GadgetCompleteEvent, c4 as GadgetConfig, aY as GadgetErrorEvent, aZ as GadgetEvent, c7 as GadgetExample, c8 as GadgetExecuteResult, c9 as GadgetExecuteReturn, ap as GadgetExecutionControllerContext, aP as GadgetNode, c3 as GadgetOrClass, aq as GadgetParameterInterceptorContext, ar as GadgetResultInterceptorContext, ca as GadgetSkippedEvent, a$ as GadgetStartEvent, aQ as GadgetState, bQ as HintContext, a7 as HistoryMessage, b0 as HumanInputRequiredEvent, bk as ImageBase64Source, bl as ImageContentPart, bm as ImageMimeType, bn as ImageSource, bo as ImageUrlSource, as as Interceptors, b1 as LLMCallCompleteEvent, at as LLMCallControllerContext, b2 as LLMCallErrorEvent, aR as LLMCallNode, b3 as LLMCallStartEvent, b4 as LLMCallStreamEvent, au as LLMErrorControllerContext, b5 as LLMEvent, bG as LLMMessageBuilder, aI as LLMistOptions, av as MessageInterceptorContext, bE as MessageRole, aw as MessageTurn, d as MockBuilder, f as MockManager, l as MockMatcher, n as MockMatcherContext, o as MockOptions, M as MockProviderAdapter, p as MockRegistration, q as MockResponse, r as MockStats, bJ as ModelFeatures, bP as ModelIdentifierParser, bK as ModelLimits, bL as ModelPricing, ax as ObserveChunkContext, ay as ObserveCompactionContext, az as ObserveGadgetCompleteContext, aA as ObserveGadgetStartContext, aB as ObserveLLMCallContext, aC as ObserveLLMCompleteContext, aD as ObserveLLMErrorContext, aE as Observers, bR as PromptContext, bS as PromptTemplate, bT as PromptTemplateConfig, bO as ProviderIdentifier, cb as StoredMedia, b6 as StreamCompleteEvent, aF as SubagentContext, cc as SubagentStreamEvent, bp as TextContentPart, b7 as TextEvent, bZ as TextGenerationOptions, cd as TextOnlyAction, ce as TextOnlyContext, cf as TextOnlyCustomHandler, cg as TextOnlyGadgetConfig, ch as TextOnlyHandler, ci as TextOnlyStrategy, a8 as TrailingMessage, a9 as TrailingMessageContext, aT as TreeCompactionEvent, a_ as TreeGadgetSkippedEvent, bM as VisionAnalyzeOptions, bN as VisionAnalyzeResult, bq as audioFromBase64, br as audioFromBuffer, ac as collectEvents, ad as collectText, b_ as complete, c1 as createGadget, c as createMockAdapter, e as createMockClient, h as createMockStream, i as createTextMockStream, bs as detectAudioMimeType, bt as detectImageMimeType, bF as extractMessageText, b8 as filterByDepth, b9 as filterByParent, ba as filterRootEvents, g as getMockManager, bb as groupByParent, bu as imageFromBase64, bv as imageFromBuffer, bw as imageFromUrl, bx as isAudioPart, by as isDataUrl, bc as isGadgetEvent, bz as isImagePart, bd as isLLMEvent, be as isRootEvent, bf as isSubagentEvent, bA as isTextPart, m as mockLLM, bH as normalizeMessageContent, bB as parseDataUrl, bW as resolveHintTemplate, bX as resolvePromptTemplate, bY as resolveRulesTemplate, ae as runWithHandlers, b$ as stream, bC as text, bD as toBase64 } from './mock-stream-DG4wF-NH.cjs';
 import { Logger, ILogObj } from 'tslog';
 import { MessageCreateParamsStreaming, MessageStreamEvent } from '@anthropic-ai/sdk/resources/messages';
 import OpenAI from 'openai';
@@ -1473,116 +1473,6 @@ declare function getProvider(model: string): string | undefined;
  */
 declare function getModelId(model: string): string;
 
-/**
- * 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);
- *   },
- * });
- * ```
- */
-
-/**
- * Infer the TypeScript type from a Zod schema.
- */
-type InferSchema$1<T> = T extends ZodType<infer U> ? U : never;
-/**
- * Configuration for creating a function-based gadget.
- */
-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>>[];
-}
-/**
- * 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 createGadget<TSchema extends ZodType>(config: CreateGadgetConfig<TSchema>): AbstractGadget;
-
 /**
  * Signal that a gadget throws to indicate task completion and agent termination.
  *
@@ -1825,161 +1715,6 @@ declare class GadgetCallParser {
     reset(): void;
 }
 
-/**
- * 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);
- *   }
- * }
- * ```
- */
-
-/**
- * Infer the TypeScript type from a Zod schema.
- */
-type InferSchema<T> = T extends ZodType<infer U> ? U : never;
-/**
- * Configuration for creating a typed gadget.
- */
-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>>[];
-}
-/**
- * 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 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>;
-    };
-};
-
 /**
  * Helper functions for gadget authors to easily return media outputs.
  *
@@ -2720,4 +2455,43 @@ declare class OpenAIChatProvider extends BaseProviderAdapter {
 }
 declare function createOpenAIProviderFromEnv(): OpenAIChatProvider | null;
 
-export { AbortException, AbstractGadget, AgentHooks, AnthropicMessagesProvider, CompactionConfig, CompactionContext, CompactionEvent, CompactionManager, CompactionResult, CompactionStats, CompactionStrategy, ConversationManager, type CreateGadgetConfig, ExecutionContext, ExecutionTree, Gadget, GadgetCallParser, type GadgetConfig, GadgetExample, GadgetExecuteResultWithMedia, GadgetExecuteReturn, GadgetExecutionResult, GadgetExecutor, GadgetMediaOutput, GadgetOutputStore, GadgetRegistry, GeminiGenerativeProvider, HintTemplate, type HintsConfig, HookPresets, HumanInputRequiredException, HybridStrategy, IConversationManager, type IterationHintOptions, LLMGenerationOptions, LLMMessage, LLMStream, LLMStreamChunk, LLMist, type LoggerOptions, type LoggingOptions, MODEL_ALIASES, MediaKind, MediaMetadata, MediaStore, MessageContent, ModelDescriptor, ModelRegistry, ModelSpec, NodeId, OpenAIChatProvider, type ParallelGadgetHintOptions, ParsedGadgetCall, ProviderAdapter, type ResolveValueOptions, ResolvedCompactionConfig, SlidingWindowStrategy, type StoredOutput, StreamEvent, type StreamProcessingResult, StreamProcessor, type StreamProcessorOptions, SubagentEvent, SummarizationStrategy, TaskCompletionSignal, TimeoutException, TokenUsage, type ValidationIssue, type ValidationResult, createAnthropicProviderFromEnv, createGadget, createGadgetOutputViewer, createGeminiProviderFromEnv, createHints, createLogger, createMediaOutput, createOpenAIProviderFromEnv, defaultLogger, discoverProviderAdapters, getModelId, getProvider, hasProviderPrefix, iterationProgressHint, parallelGadgetHint, resolveConfig, resolveModel, resolveSubagentModel, resolveValue, resultWithAudio, resultWithFile, resultWithImage, resultWithImages, resultWithMedia, validateAndApplyDefaults, validateGadgetParams };
+/**
+ * Get host llmist exports from execution context.
+ *
+ * External gadgets MUST use this instead of importing classes directly from 'llmist'
+ * to ensure they use the same version as the host CLI, enabling proper tree sharing
+ * and avoiding the "dual-package problem".
+ *
+ * @param ctx - The execution context passed to gadget.execute()
+ * @returns The host's llmist exports (AgentBuilder, Gadget, etc.)
+ * @throws Error if ctx or ctx.hostExports is undefined
+ *
+ * @example
+ * ```typescript
+ * import { getHostExports, Gadget, z } from 'llmist';
+ * import type { ExecutionContext } from 'llmist';
+ *
+ * class BrowseWeb extends Gadget({
+ *   name: 'BrowseWeb',
+ *   description: 'Browse a website autonomously',
+ *   schema: z.object({ task: z.string(), url: z.string() }),
+ * }) {
+ *   async execute(params: this['params'], ctx?: ExecutionContext) {
+ *     // Get host's AgentBuilder to ensure tree sharing works correctly
+ *     const { AgentBuilder } = getHostExports(ctx!);
+ *
+ *     const agent = new AgentBuilder()
+ *       .withParentContext(ctx!)
+ *       .withGadgets(Navigate, Click, Screenshot)
+ *       .ask(params.task);
+ *
+ *     for await (const event of agent.run()) {
+ *       // Events flow through host's shared tree
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare function getHostExports(ctx: ExecutionContext): HostExports;
+
+export { AbortException, AbstractGadget, AgentHooks, AnthropicMessagesProvider, CompactionConfig, CompactionContext, CompactionEvent, CompactionManager, CompactionResult, CompactionStats, CompactionStrategy, ConversationManager, ExecutionContext, ExecutionTree, GadgetCallParser, GadgetExecuteResultWithMedia, GadgetExecutionResult, GadgetExecutor, GadgetMediaOutput, GadgetOutputStore, GadgetRegistry, GeminiGenerativeProvider, HintTemplate, type HintsConfig, HookPresets, HostExports, HumanInputRequiredException, HybridStrategy, IConversationManager, type IterationHintOptions, LLMGenerationOptions, LLMMessage, LLMStream, LLMStreamChunk, LLMist, type LoggerOptions, type LoggingOptions, MODEL_ALIASES, MediaKind, MediaMetadata, MediaStore, MessageContent, ModelDescriptor, ModelRegistry, ModelSpec, NodeId, OpenAIChatProvider, type ParallelGadgetHintOptions, ParsedGadgetCall, ProviderAdapter, type ResolveValueOptions, ResolvedCompactionConfig, SlidingWindowStrategy, type StoredOutput, StreamEvent, type StreamProcessingResult, StreamProcessor, type StreamProcessorOptions, SubagentEvent, SummarizationStrategy, TaskCompletionSignal, TimeoutException, TokenUsage, type ValidationIssue, type ValidationResult, createAnthropicProviderFromEnv, createGadgetOutputViewer, createGeminiProviderFromEnv, createHints, createLogger, createMediaOutput, createOpenAIProviderFromEnv, defaultLogger, discoverProviderAdapters, getHostExports, getModelId, getProvider, hasProviderPrefix, iterationProgressHint, parallelGadgetHint, resolveConfig, resolveModel, resolveSubagentModel, resolveValue, resultWithAudio, resultWithFile, resultWithImage, resultWithImages, resultWithMedia, validateAndApplyDefaults, validateGadgetParams };