@browserbasehq/stagehand 2.5.3-alpha-4994eabfa8016347ec001b40ceadb0c905403470 → 4.0.0-alpha-49bc5b68e4fbeb28a120b301b51c31a36db7d922

package/dist/lib/dom/process.d.ts

@@ -1,17 +0,0 @@
-/**
- * Finds and returns a list of scrollable elements on the page,
- * ordered from the element with the largest scrollHeight to the smallest.
- *
- * @param topN Optional maximum number of scrollable elements to return.
- *             If not provided, all found scrollable elements are returned.
- * @returns An array of HTMLElements sorted by descending scrollHeight.
- */
-export declare function getScrollableElements(topN?: number): HTMLElement[];
-/**
- * Calls getScrollableElements, then for each element calls generateXPaths,
- * and returns the first XPath for each.
- *
- * @param topN (optional) integer limit on how many scrollable elements to process
- * @returns string[] list of XPaths (1 for each scrollable element)
- */
-export declare function getScrollableElementXpaths(topN?: number): Promise<string[]>;

package/dist/lib/dom/utils.d.ts

@@ -1,7 +0,0 @@
-/**
- * Tests if the element actually responds to .scrollTo(...)
- * and that scrollTop changes as expected.
- */
-export declare function canElementScroll(elem: HTMLElement): boolean;
-export declare function getNodeFromXpath(xpath: string): Node;
-export declare function waitForElementScrollEnd(element: HTMLElement, idleMs?: number): Promise<void>;

package/dist/lib/dom/xpathUtils.d.ts

@@ -1,14 +0,0 @@
-/**
- * Escapes a string for use in an XPath expression.
- * Handles special characters, including single and double quotes.
- * @param value - The string to escape.
- * @returns The escaped string safe for XPath.
- */
-export declare function escapeXPathString(value: string): string;
-/**
- * Generates both a complicated XPath and a standard XPath for a given DOM element.
- * @param element - The target DOM element.
- * @param documentOverride - Optional document override.
- * @returns An object containing both XPaths.
- */
-export declare function generateXPathsForElement(element: ChildNode): Promise<string[]>;

package/dist/lib/handlers/actHandler.d.ts

@@ -1,33 +0,0 @@
-import { LogLine } from "../../types/log";
-import { LLMClient } from "../llm/LLMClient";
-import { StagehandPage } from "../StagehandPage";
-import { ActResult, ObserveResult, ActOptions } from "@/types/stagehand";
-import { StagehandObserveHandler } from "@/lib/handlers/observeHandler";
-/**
- * NOTE: Vision support has been removed from this version of Stagehand.
- * If useVision or verifierUseVision is set to true, a warning is logged and
- * the flow continues as if vision = false.
- */
-export declare class StagehandActHandler {
-    private readonly stagehandPage;
-    private readonly logger;
-    private readonly selfHeal;
-    private readonly experimental;
-    constructor({ logger, stagehandPage, selfHeal, experimental, }: {
-        logger: (logLine: LogLine) => void;
-        stagehandPage: StagehandPage;
-        selfHeal: boolean;
-        experimental: boolean;
-    });
-    /**
-     * Perform an immediate Playwright action based on an ObserveResult object
-     * that was returned from `page.observe(...)`.
-     */
-    actFromObserveResult(observe: ObserveResult, domSettleTimeoutMs?: number): Promise<ActResult>;
-    /**
-     * Perform an act based on an instruction.
-     * This method will observe the page and then perform the act on the first element returned.
-     */
-    observeAct(actionOrOptions: ActOptions, observeHandler: StagehandObserveHandler, llmClient: LLMClient, requestId: string): Promise<ActResult>;
-    private _performPlaywrightMethod;
-}

package/dist/lib/handlers/cuaAgentHandler.d.ts

@@ -1,58 +0,0 @@
-import { AgentExecuteOptions, AgentHandlerOptions, AgentResult } from "@/types/agent";
-import { ToolSet } from "ai/dist";
-import { LogLine } from "../../types/log";
-import { StagehandPage } from "../StagehandPage";
-import { AgentClient } from "../agent/AgentClient";
-import { StagehandAgent } from "../agent/StagehandAgent";
-import { Stagehand } from "../index";
-export declare class CuaAgentHandler {
-    private stagehand;
-    private stagehandPage;
-    private agent;
-    private provider;
-    private logger;
-    private agentClient;
-    private options;
-    private screenshotCollector?;
-    private highlightCursor;
-    constructor(stagehand: Stagehand, stagehandPage: StagehandPage, logger: (message: LogLine) => void, options: AgentHandlerOptions, tools?: ToolSet);
-    private setupAgentClient;
-    /**
-     * Execute a task with the agent
-     */
-    execute(optionsOrInstruction: AgentExecuteOptions | string): Promise<AgentResult>;
-    /**
-     * Execute a single action on the page
-     */
-    private executeAction;
-    private updateClientViewport;
-    private updateClientUrl;
-    getAgent(): StagehandAgent;
-    getClient(): AgentClient;
-    captureAndSendScreenshot(): Promise<unknown>;
-    /**
-     * Inject a cursor element into the page for visual feedback
-     */
-    private injectCursor;
-    /**
-     * Update the cursor position on the page
-     */
-    private updateCursorPosition;
-    /**
-     * Animate a click at the given position
-     */
-    private animateClick;
-    private get page();
-    /**
-     * Set the screenshot collector for this agent handler
-     */
-    setScreenshotCollector(collector: any): void;
-    /**
-     * Get the screenshot collector
-     */
-    getScreenshotCollector(): any;
-    /**
-     * Set the tools for this agent handler
-     */
-    setTools(tools: ToolSet): void;
-}

package/dist/lib/handlers/extractHandler.d.ts

@@ -1,54 +0,0 @@
-import { z } from "zod/v3";
-import { ZodPathSegments } from "../../types/stagehand";
-import { LLMClient } from "../llm/LLMClient";
-import { StagehandPage } from "../StagehandPage";
-import { Stagehand } from "../index";
-export declare class StagehandExtractHandler {
-    private readonly stagehand;
-    private readonly stagehandPage;
-    private readonly logger;
-    private readonly userProvidedInstructions?;
-    private readonly experimental;
-    constructor({ stagehand, logger, stagehandPage, userProvidedInstructions, experimental, }: {
-        stagehand: Stagehand;
-        logger: (message: {
-            category?: string;
-            message: string;
-            level?: number;
-            auxiliary?: {
-                [key: string]: {
-                    value: string;
-                    type: string;
-                };
-            };
-        }) => void;
-        stagehandPage: StagehandPage;
-        userProvidedInstructions?: string;
-        experimental: boolean;
-    });
-    extract<T extends z.AnyZodObject>({ instruction, schema, content, llmClient, requestId, domSettleTimeoutMs, useTextExtract, selector, iframes, }?: {
-        instruction?: string;
-        schema?: T;
-        content?: z.infer<T>;
-        chunksSeen?: Array<number>;
-        llmClient?: LLMClient;
-        requestId?: string;
-        domSettleTimeoutMs?: number;
-        useTextExtract?: boolean;
-        selector?: string;
-        iframes?: boolean;
-    }): Promise<z.infer<T>>;
-    private extractPageText;
-    private domExtract;
-}
-/**
- * Scans the provided Zod schema for any `z.string().url()` fields and
- * replaces them with `z.number()`.
- *
- * @param schema - The Zod object schema to transform.
- * @returns A tuple containing:
- *   1. The transformed schema (or the original schema if no changes were needed).
- *   2. An array of {@link ZodPathSegments} objects representing all the replaced URL fields,
- *      with each path segment showing where in the schema the replacement occurred.
- */
-export declare function transformUrlStringsToNumericIds<T extends z.ZodObject<z.ZodRawShape>>(schema: T): [T, ZodPathSegments[]];

package/dist/lib/handlers/handlerUtils/actHandlerUtils.d.ts

@@ -1,21 +0,0 @@
-import { Page, Locator, FrameLocator } from "playwright";
-import { MethodHandlerContext } from "@/types/act";
-export declare function deepLocatorWithShadow(root: Page | FrameLocator, xpath: string): Promise<Locator>;
-export declare function deepLocator(root: Page | FrameLocator, xpath: string): Locator;
-/**
- * A mapping of playwright methods that may be chosen by the LLM to their
- * implementation.
- */
-export declare const methodHandlerMap: Record<string, (ctx: MethodHandlerContext) => Promise<void>>;
-export declare function scrollToNextChunk(ctx: MethodHandlerContext): Promise<void>;
-export declare function scrollToPreviousChunk(ctx: MethodHandlerContext): Promise<void>;
-export declare function scrollElementIntoView(ctx: MethodHandlerContext): Promise<void>;
-export declare function scrollElementToPercentage(ctx: MethodHandlerContext): Promise<void>;
-export declare function fillOrType(ctx: MethodHandlerContext): Promise<void>;
-export declare function pressKey(ctx: MethodHandlerContext): Promise<void>;
-export declare function selectOption(ctx: MethodHandlerContext): Promise<void>;
-export declare function clickElement(ctx: MethodHandlerContext): Promise<void>;
-/**
- * Fallback method: if method is not in our map but *is* a valid Playwright locator method.
- */
-export declare function fallbackLocatorMethod(ctx: MethodHandlerContext): Promise<void>;

package/dist/lib/handlers/observeHandler.d.ts

@@ -1,40 +0,0 @@
-import { LogLine } from "../../types/log";
-import { Stagehand } from "../index";
-import { LLMClient } from "../llm/LLMClient";
-import { StagehandPage } from "../StagehandPage";
-export declare class StagehandObserveHandler {
-    private readonly stagehand;
-    private readonly logger;
-    private readonly stagehandPage;
-    private readonly experimental;
-    private readonly userProvidedInstructions?;
-    constructor({ stagehand, logger, stagehandPage, userProvidedInstructions, experimental, }: {
-        stagehand: Stagehand;
-        logger: (logLine: LogLine) => void;
-        stagehandPage: StagehandPage;
-        userProvidedInstructions?: string;
-        experimental: boolean;
-    });
-    observe({ instruction, llmClient, requestId, returnAction, onlyVisible, drawOverlay, fromAct, iframes, }: {
-        instruction: string;
-        llmClient: LLMClient;
-        requestId: string;
-        domSettleTimeoutMs?: number;
-        returnAction?: boolean;
-        /**
-         * @deprecated The `onlyVisible` parameter has no effect in this version of Stagehand and will be removed in later versions.
-         */
-        onlyVisible?: boolean;
-        drawOverlay?: boolean;
-        fromAct?: boolean;
-        iframes?: boolean;
-    }): Promise<({
-        selector: string;
-        description: string;
-    } | {
-        selector: string;
-        method: string;
-        arguments: string[];
-        description: string;
-    })[]>;
-}

package/dist/lib/handlers/stagehandAgentHandler.d.ts

@@ -1,27 +0,0 @@
-import { AgentExecuteOptions, AgentResult } from "@/types/agent";
-import { LogLine } from "@/types/log";
-import { LLMClient } from "../llm/LLMClient";
-import { ToolSet } from "ai";
-import { Stagehand } from "../index";
-export declare class StagehandAgentHandler {
-    private stagehand;
-    private logger;
-    private llmClient;
-    private executionModel?;
-    private systemInstructions?;
-    private tools?;
-    private screenshotCollector?;
-    constructor(stagehand: Stagehand, logger: (message: LogLine) => void, llmClient: LLMClient, executionModel?: string, systemInstructions?: string, tools?: ToolSet);
-    execute(instructionOrOptions: string | AgentExecuteOptions): Promise<AgentResult>;
-    private buildSystemPrompt;
-    private createTools;
-    /**
-     * Set the screenshot collector for this agent handler
-     */
-    setScreenshotCollector(collector: any): void;
-    /**
-     * Get the screenshot collector
-     */
-    getScreenshotCollector(): any;
-    setTools(tools: ToolSet): void;
-}

package/dist/lib/index.d.ts

@@ -1,94 +0,0 @@
-import { GotoOptions } from "@/types/playwright";
-import { z } from "zod/v3";
-import { AgentExecuteOptions, AgentResult } from "../types/agent";
-import { EnhancedContext } from "../types/context";
-import { LogLine } from "../types/log";
-import { ClientOptions } from "../types/model";
-import { Page } from "../types/page";
-import { ActOptions, AgentConfig, ConstructorParams, ExtractOptions, HistoryEntry, InitResult, ObserveOptions, StagehandFunctionName, StagehandMetrics } from "../types/stagehand";
-import { StagehandPage } from "./StagehandPage";
-import { StagehandAPI } from "./api";
-import { LLMClient } from "./llm/LLMClient";
-import { LLMProvider } from "./llm/LLMProvider";
-import { connectToMCPServer } from "./mcp/connection";
-export declare class Stagehand {
-    private stagehandPage;
-    private stagehandContext;
-    browserbaseSessionID?: string;
-    readonly domSettleTimeoutMs: number;
-    readonly debugDom: boolean;
-    readonly headless: boolean;
-    verbose: 0 | 1 | 2;
-    llmProvider: LLMProvider;
-    enableCaching: boolean;
-    protected apiKey: string | undefined;
-    private projectId;
-    private externalLogger?;
-    private browserbaseSessionCreateParams?;
-    variables: {
-        [key: string]: unknown;
-    };
-    private contextPath?;
-    llmClient: LLMClient;
-    readonly userProvidedInstructions?: string;
-    private usingAPI;
-    private modelName;
-    apiClient: StagehandAPI | undefined;
-    readonly waitForCaptchaSolves: boolean;
-    private localBrowserLaunchOptions?;
-    readonly selfHeal: boolean;
-    private cleanupCalled;
-    readonly actTimeoutMs: number;
-    readonly logInferenceToFile?: boolean;
-    private stagehandLogger;
-    private disablePino;
-    protected modelClientOptions: ClientOptions;
-    private _env;
-    private _browser;
-    private _isClosed;
-    private _history;
-    readonly experimental: boolean;
-    private _livePageProxy?;
-    private createLivePageProxy;
-    get history(): ReadonlyArray<HistoryEntry>;
-    protected setActivePage(page: StagehandPage): void;
-    get page(): Page;
-    stagehandMetrics: StagehandMetrics;
-    get metrics(): StagehandMetrics;
-    get isClosed(): boolean;
-    updateMetrics(functionName: StagehandFunctionName, promptTokens: number, completionTokens: number, inferenceTimeMs: number): void;
-    private updateTotalMetrics;
-    constructor({ env, apiKey, projectId, verbose, llmProvider, llmClient, logger, browserbaseSessionCreateParams, domSettleTimeoutMs, enableCaching, browserbaseSessionID, modelName, modelClientOptions, systemPrompt, useAPI, localBrowserLaunchOptions, waitForCaptchaSolves, logInferenceToFile, selfHeal, disablePino, experimental, }?: ConstructorParams);
-    private registerSignalHandlers;
-    get logger(): (logLine: LogLine) => void;
-    get env(): "LOCAL" | "BROWSERBASE";
-    get downloadsPath(): string;
-    get context(): EnhancedContext;
-    init(): Promise<InitResult>;
-    log(logObj: LogLine): void;
-    close(): Promise<void>;
-    addToHistory(method: HistoryEntry["method"], parameters: ActOptions | ExtractOptions<z.AnyZodObject> | ObserveOptions | {
-        url: string;
-        options: GotoOptions;
-    } | string, result?: unknown): void;
-    /**
-     * Create an agent instance that can be executed with different instructions
-     * @returns An agent instance with execute() method
-     */
-    agent(options?: AgentConfig): {
-        execute: (instructionOrOptions: string | AgentExecuteOptions) => Promise<AgentResult>;
-        setScreenshotCollector?: (collector: unknown) => void;
-    };
-}
-export * from "../types/agent";
-export * from "../types/browser";
-export * from "../types/log";
-export * from "../types/model";
-export * from "../types/page";
-export * from "../types/playwright";
-export * from "../types/stagehand";
-export * from "../types/stagehandApiErrors";
-export * from "../types/stagehandErrors";
-export * from "./llm/LLMClient";
-export * from "./llm/aisdk";
-export { connectToMCPServer };

package/dist/lib/inference.d.ts

@@ -1,61 +0,0 @@
-import { z } from "zod/v3";
-import { LogLine } from "../types/log";
-import { LLMClient } from "./llm/LLMClient";
-/** Simple usage shape if your LLM returns usage tokens. */
-interface LLMUsage {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-}
-/**
- * For calls that use a schema: the LLMClient may return { data: T; usage?: LLMUsage }
- */
-export interface LLMParsedResponse<T> {
-    data: T;
-    usage?: LLMUsage;
-}
-export declare function extract({ instruction, domElements, schema, llmClient, chunksSeen, chunksTotal, requestId, logger, userProvidedInstructions, logInferenceToFile, }: {
-    instruction: string;
-    domElements: string;
-    schema: z.ZodObject<z.ZodRawShape>;
-    llmClient: LLMClient;
-    chunksSeen: number;
-    chunksTotal: number;
-    requestId: string;
-    userProvidedInstructions?: string;
-    logger: (message: LogLine) => void;
-    logInferenceToFile?: boolean;
-}): Promise<{
-    metadata: {
-        completed: boolean;
-        progress: string;
-    };
-    prompt_tokens: number;
-    completion_tokens: number;
-    inference_time_ms: number;
-}>;
-export declare function observe({ instruction, domElements, llmClient, requestId, userProvidedInstructions, logger, returnAction, logInferenceToFile, fromAct, }: {
-    instruction: string;
-    domElements: string;
-    llmClient: LLMClient;
-    requestId: string;
-    userProvidedInstructions?: string;
-    logger: (message: LogLine) => void;
-    returnAction?: boolean;
-    logInferenceToFile?: boolean;
-    fromAct?: boolean;
-}): Promise<{
-    elements: ({
-        elementId: string;
-        description: string;
-    } | {
-        method: string;
-        arguments: string[];
-        elementId: string;
-        description: string;
-    })[];
-    prompt_tokens: number;
-    completion_tokens: number;
-    inference_time_ms: number;
-}>;
-export {};

package/dist/lib/inferenceLogUtils.d.ts

@@ -1,12 +0,0 @@
-/**
- * Appends a new entry to the act_summary.json file, then writes the file back out.
- */
-export declare function appendSummary<T>(inferenceType: string, entry: T): void;
-/**
- * Writes `data` as JSON into a file in `directory`, using a prefix plus timestamp.
- * Returns both the file name and the timestamp used, so you can log them.
- */
-export declare function writeTimestampedTxtFile(directory: string, prefix: string, data: unknown): {
-    fileName: string;
-    timestamp: string;
-};

package/dist/lib/llm/AnthropicClient.d.ts

@@ -1,21 +0,0 @@
-import { ClientOptions } from "@anthropic-ai/sdk";
-import { LogLine } from "../../types/log";
-import { AvailableModel } from "../../types/model";
-import { LLMCache } from "../cache/LLMCache";
-import { CreateChatCompletionOptions, LLMClient, LLMResponse } from "./LLMClient";
-export declare class AnthropicClient extends LLMClient {
-    type: "anthropic";
-    private client;
-    private cache;
-    private enableCaching;
-    clientOptions: ClientOptions;
-    constructor({ enableCaching, cache, modelName, clientOptions, userProvidedInstructions, }: {
-        logger: (message: LogLine) => void;
-        enableCaching?: boolean;
-        cache?: LLMCache;
-        modelName: AvailableModel;
-        clientOptions?: ClientOptions;
-        userProvidedInstructions?: string;
-    });
-    createChatCompletion<T = LLMResponse>({ options, retries, logger, }: CreateChatCompletionOptions): Promise<T>;
-}

package/dist/lib/llm/CerebrasClient.d.ts

@@ -1,22 +0,0 @@
-import type { ClientOptions } from "openai";
-import { LogLine } from "../../types/log";
-import { AvailableModel } from "../../types/model";
-import { LLMCache } from "../cache/LLMCache";
-import { CreateChatCompletionOptions, LLMClient, LLMResponse } from "./LLMClient";
-export declare class CerebrasClient extends LLMClient {
-    type: "cerebras";
-    private client;
-    private cache;
-    private enableCaching;
-    clientOptions: ClientOptions;
-    hasVision: boolean;
-    constructor({ enableCaching, cache, modelName, clientOptions, userProvidedInstructions, }: {
-        logger: (message: LogLine) => void;
-        enableCaching?: boolean;
-        cache?: LLMCache;
-        modelName: AvailableModel;
-        clientOptions?: ClientOptions;
-        userProvidedInstructions?: string;
-    });
-    createChatCompletion<T = LLMResponse>({ options, retries, logger, }: CreateChatCompletionOptions): Promise<T>;
-}

package/dist/lib/llm/GoogleClient.d.ts

@@ -1,24 +0,0 @@
-import { LogLine } from "../../types/log";
-import { AvailableModel, ClientOptions } from "../../types/model";
-import { LLMCache } from "../cache/LLMCache";
-import { CreateChatCompletionOptions, LLMClient, LLMResponse } from "./LLMClient";
-export declare class GoogleClient extends LLMClient {
-    type: "google";
-    private client;
-    private cache;
-    private enableCaching;
-    clientOptions: ClientOptions;
-    hasVision: boolean;
-    private logger;
-    constructor({ logger, // Added logger based on other clients
-    enableCaching, cache, modelName, clientOptions, }: {
-        logger: (message: LogLine) => void;
-        enableCaching?: boolean;
-        cache?: LLMCache;
-        modelName: AvailableModel;
-        clientOptions?: ClientOptions;
-    });
-    private formatMessages;
-    private formatTools;
-    createChatCompletion<T = LLMResponse>({ options, logger, retries, }: CreateChatCompletionOptions): Promise<T>;
-}

package/dist/lib/llm/GroqClient.d.ts

@@ -1,22 +0,0 @@
-import type { ClientOptions } from "openai";
-import { LogLine } from "../../types/log";
-import { AvailableModel } from "../../types/model";
-import { LLMCache } from "../cache/LLMCache";
-import { CreateChatCompletionOptions, LLMClient, LLMResponse } from "./LLMClient";
-export declare class GroqClient extends LLMClient {
-    type: "groq";
-    private client;
-    private cache;
-    private enableCaching;
-    clientOptions: ClientOptions;
-    hasVision: boolean;
-    constructor({ enableCaching, cache, modelName, clientOptions, userProvidedInstructions, }: {
-        logger: (message: LogLine) => void;
-        enableCaching?: boolean;
-        cache?: LLMCache;
-        modelName: AvailableModel;
-        clientOptions?: ClientOptions;
-        userProvidedInstructions?: string;
-    });
-    createChatCompletion<T = LLMResponse>({ options, retries, logger, }: CreateChatCompletionOptions): Promise<T>;
-}

package/dist/lib/llm/LLMClient.d.ts

@@ -1,99 +0,0 @@
-import { LLMTool } from "@/types/llm";
-import { embed, embedMany, experimental_generateImage, experimental_generateSpeech, experimental_transcribe, generateObject, generateText, LanguageModel, streamObject, streamText } from "ai";
-import { ZodType } from "zod/v3";
-import { LogLine } from "../../types/log";
-import { AvailableModel, ClientOptions } from "../../types/model";
-export interface ChatMessage {
-    role: "system" | "user" | "assistant";
-    content: ChatMessageContent;
-}
-export type ChatMessageContent = string | (ChatMessageImageContent | ChatMessageTextContent)[];
-export interface ChatMessageImageContent {
-    type: string;
-    image_url?: {
-        url: string;
-    };
-    text?: string;
-    source?: {
-        type: string;
-        media_type: string;
-        data: string;
-    };
-}
-export interface ChatMessageTextContent {
-    type: string;
-    text: string;
-}
-export declare const AnnotatedScreenshotText = "This is a screenshot of the current page state with the elements annotated on it. Each element id is annotated with a number to the top left of it. Duplicate annotations at the same location are under each other vertically.";
-export interface ChatCompletionOptions {
-    messages: ChatMessage[];
-    temperature?: number;
-    top_p?: number;
-    frequency_penalty?: number;
-    presence_penalty?: number;
-    image?: {
-        buffer: Buffer;
-        description?: string;
-    };
-    response_model?: {
-        name: string;
-        schema: ZodType;
-    };
-    tools?: LLMTool[];
-    tool_choice?: "auto" | "none" | "required";
-    maxTokens?: number;
-    requestId?: string;
-}
-export type LLMResponse = {
-    id: string;
-    object: string;
-    created: number;
-    model: string;
-    choices: {
-        index: number;
-        message: {
-            role: string;
-            content: string | null;
-            tool_calls: {
-                id: string;
-                type: string;
-                function: {
-                    name: string;
-                    arguments: string;
-                };
-            }[];
-        };
-        finish_reason: string;
-    }[];
-    usage: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-};
-export interface CreateChatCompletionOptions {
-    options: ChatCompletionOptions;
-    logger: (message: LogLine) => void;
-    retries?: number;
-}
-export declare abstract class LLMClient {
-    type: "openai" | "anthropic" | "cerebras" | "groq" | (string & {});
-    modelName: AvailableModel | (string & {});
-    hasVision: boolean;
-    clientOptions: ClientOptions;
-    userProvidedInstructions?: string;
-    constructor(modelName: AvailableModel, userProvidedInstructions?: string);
-    abstract createChatCompletion<T = LLMResponse & {
-        usage?: LLMResponse["usage"];
-    }>(options: CreateChatCompletionOptions): Promise<T>;
-    generateObject: typeof generateObject;
-    generateText: typeof generateText;
-    streamText: typeof streamText;
-    streamObject: typeof streamObject;
-    generateImage: typeof experimental_generateImage;
-    embed: typeof embed;
-    embedMany: typeof embedMany;
-    transcribe: typeof experimental_transcribe;
-    generateSpeech: typeof experimental_generateSpeech;
-    getLanguageModel?(): LanguageModel;
-}

package/dist/lib/llm/LLMProvider.d.ts

@@ -1,13 +0,0 @@
-import { LogLine } from "../../types/log";
-import { AvailableModel, ClientOptions, ModelProvider } from "../../types/model";
-import { LLMClient } from "./LLMClient";
-export declare function getAISDKLanguageModel(subProvider: string, subModelName: string, apiKey?: string, baseURL?: string): import("ai/dist").LanguageModelV1;
-export declare class LLMProvider {
-    private logger;
-    private enableCaching;
-    private cache;
-    constructor(logger: (message: LogLine) => void, enableCaching: boolean);
-    cleanRequestCache(requestId: string): void;
-    getClient(modelName: AvailableModel, clientOptions?: ClientOptions): LLMClient;
-    static getModelProvider(modelName: AvailableModel): ModelProvider;
-}