@browserbasehq/orca 3.0.0-preview.0

package/dist/lib/v3/agent/tools/v3-act.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod/v3";
+import type { V3 } from "@/lib/v3/v3";
+export declare const createActTool: (v3: V3, executionModel?: string) => import("ai/dist").Tool<z.ZodObject<{
+    action: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    action?: string;
+}, {
+    action?: string;
+}>, {
+    success: boolean;
+    action: string;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    action?: undefined;
+}> & {
+    execute: (args: {
+        action?: string;
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        action: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        action?: undefined;
+    }>;
+};

package/dist/lib/v3/agent/tools/v3-ariaTree.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod/v3";
+import type { V3 } from "@/lib/v3/v3";
+export declare const createAriaTreeTool: (v3: V3) => import("ai/dist").Tool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {
+    content: string;
+    pageUrl: string;
+}> & {
+    execute: (args: {}, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        content: string;
+        pageUrl: string;
+    }>;
+};

package/dist/lib/v3/agent/tools/v3-close.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod/v3";
+export declare const createCloseTool: () => import("ai/dist").Tool<z.ZodObject<{
+    reasoning: z.ZodString;
+    taskComplete: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    reasoning?: string;
+    taskComplete?: boolean;
+}, {
+    reasoning?: string;
+    taskComplete?: boolean;
+}>, {
+    success: boolean;
+    reasoning: string;
+    taskComplete: boolean;
+}> & {
+    execute: (args: {
+        reasoning?: string;
+        taskComplete?: boolean;
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        reasoning: string;
+        taskComplete: boolean;
+    }>;
+};

package/dist/lib/v3/agent/tools/v3-extract.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod/v3";
+import type { V3 } from "@/lib/v3/v3";
+import type { LogLine } from "../../types/log";
+export declare const createExtractTool: (v3: V3, executionModel?: string, logger?: (message: LogLine) => void) => import("ai/dist").Tool<z.ZodObject<{
+    instruction: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodString>;
+    selector: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    instruction?: string;
+    selector?: string;
+    schema?: string;
+}, {
+    instruction?: string;
+    selector?: string;
+    schema?: string;
+}>, {
+    success: boolean;
+    result: any;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    result?: undefined;
+}> & {
+    execute: (args: {
+        instruction?: string;
+        selector?: string;
+        schema?: string;
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        result: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        result?: undefined;
+    }>;
+};

package/dist/lib/v3/agent/tools/v3-fillform.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod/v3";
+import type { V3 } from "@/lib/v3/v3";
+export declare const createFillFormTool: (v3: V3, executionModel?: string) => import("ai/dist").Tool<z.ZodObject<{
+    fields: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value?: string;
+        action?: string;
+    }, {
+        value?: string;
+        action?: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    fields?: {
+        value?: string;
+        action?: string;
+    }[];
+}, {
+    fields?: {
+        value?: string;
+        action?: string;
+    }[];
+}>, {
+    success: boolean;
+    actions: unknown[];
+}> & {
+    execute: (args: {
+        fields?: {
+            value?: string;
+            action?: string;
+        }[];
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        actions: unknown[];
+    }>;
+};

package/dist/lib/v3/agent/tools/v3-goto.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod/v3";
+import type { V3 } from "@/lib/v3/v3";
+export declare const createGotoTool: (v3: V3) => import("ai/dist").Tool<z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url?: string;
+}, {
+    url?: string;
+}>, {
+    success: boolean;
+    url: string;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    url?: undefined;
+}> & {
+    execute: (args: {
+        url?: string;
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        url: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        url?: undefined;
+    }>;
+};

package/dist/lib/v3/agent/tools/v3-navback.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod/v3";
+import type { V3 } from "@/lib/v3/v3";
+export declare const createNavBackTool: (v3: V3) => import("ai/dist").Tool<z.ZodObject<{
+    reasoning: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    reasoning?: string;
+}, {
+    reasoning?: string;
+}>, {
+    success: boolean;
+}> & {
+    execute: (args: {
+        reasoning?: string;
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+    }>;
+};

package/dist/lib/v3/agent/tools/v3-screenshot.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod/v3";
+import type { V3 } from "@/lib/v3/v3";
+export declare const createScreenshotTool: (v3: V3) => import("ai/dist").Tool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {
+    base64: string;
+    timestamp: number;
+    pageUrl: string;
+}> & {
+    execute: (args: {}, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        base64: string;
+        timestamp: number;
+        pageUrl: string;
+    }>;
+};

package/dist/lib/v3/agent/tools/v3-scroll.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod/v3";
+import type { V3 } from "@/lib/v3/v3";
+export declare const createScrollTool: (v3: V3) => import("ai/dist").Tool<z.ZodObject<{
+    pixels: z.ZodNumber;
+    direction: z.ZodEnum<["up", "down"]>;
+}, "strip", z.ZodTypeAny, {
+    pixels?: number;
+    direction?: "up" | "down";
+}, {
+    pixels?: number;
+    direction?: "up" | "down";
+}>, {
+    success: boolean;
+    pixels: number;
+}> & {
+    execute: (args: {
+        pixels?: number;
+        direction?: "up" | "down";
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        pixels: number;
+    }>;
+};

package/dist/lib/v3/agent/tools/v3-wait.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod/v3";
+import type { V3 } from "@/lib/v3/v3";
+export declare const createWaitTool: (v3: V3) => import("ai/dist").Tool<z.ZodObject<{
+    timeMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    timeMs?: number;
+}, {
+    timeMs?: number;
+}>, {
+    success: boolean;
+    waited: number;
+}> & {
+    execute: (args: {
+        timeMs?: number;
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        waited: number;
+    }>;
+};

package/dist/lib/v3/agent/utils/cuaKeyMapping.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Universal key mapping utility for converting various key representations
+ * to Playwright-compatible key names. Used by all CUA clients and handlers.
+ */
+/**
+ * Maps a key name from various formats to Playwright-compatible format
+ * @param key The key name in any supported format
+ * @returns The Playwright-compatible key name
+ */
+export declare function mapKeyToPlaywright(key: string): string;

package/dist/lib/v3/agent/utils/imageCompression.d.ts

@@ -0,0 +1,18 @@
+import { AnthropicMessage, AnthropicToolResult } from "../../types/agent";
+export type ResponseInputItem = AnthropicMessage | AnthropicToolResult;
+/**
+ * Finds all items in the conversation history that contain images
+ * @param items - Array of conversation items to check
+ * @returns Array of indices where images were found
+ */
+export declare function findItemsWithImages(items: ResponseInputItem[]): number[];
+/**
+ * Compresses conversation history by removing images from older items
+ * while keeping the most recent images intact
+ * @param items - Array of conversation items to process
+ * @param keepMostRecentCount - Number of most recent image-containing items to preserve (default: 2)
+ * @returns Object with processed items
+ */
+export declare function compressConversationImages(items: ResponseInputItem[], keepMostRecentCount?: number): {
+    items: ResponseInputItem[];
+};

package/dist/lib/v3/agent/utils/messageProcessing.d.ts

@@ -0,0 +1,13 @@
+import { type LanguageModelV1CallOptions } from "ai";
+export interface CompressionStats {
+    originalSize: number;
+    compressedSize: number;
+    savedChars: number;
+    compressionRatio: number;
+    screenshotCount: number;
+    ariaTreeCount: number;
+}
+export declare function processMessages(params: LanguageModelV1CallOptions): {
+    processedPrompt: LanguageModelV1CallOptions["prompt"];
+    stats: CompressionStats;
+};

package/dist/lib/v3/dom/build/scriptV3Content.d.ts

@@ -0,0 +1 @@
+export declare const v3ScriptContent = "(()=>{function b(_={}){let S=n=>{let{hostToRoot:l}=n,m=t=>{let o=[];if(t instanceof Document)return t.documentElement&&o.push(t.documentElement),o;if(t instanceof ShadowRoot||t instanceof DocumentFragment)return o.push(...Array.from(t.children)),o;if(t instanceof Element){o.push(...Array.from(t.children));let a=t.shadowRoot;a&&o.push(...Array.from(a.children));let r=l.get(t);return r&&o.push(...Array.from(r.children)),o}return o},v=t=>{let o=[],a=[...m(t)];for(;a.length;){let r=a.shift();o.push(r),a.push(...m(r))}return o},y=t=>{let o=String(t||\"\").trim();if(!o)return null;let a=o.replace(/^xpath=/i,\"\"),r=[];{let e=0;for(;e<a.length;){let d=\"child\";a.startsWith(\"//\",e)?(d=\"desc\",e+=2):a[e]===\"/\"&&(d=\"child\",e+=1);let h=e;for(;e<a.length&&a[e]!==\"/\";)e++;let u=a.slice(h,e).trim();if(!u)continue;let p=u.match(/^(.*?)(\\[(\\d+)\\])?$/u),i=(p?.[1]??u).trim(),c=p?.[3]?Math.max(1,Number(p[3])):null,R=i===\"\"?\"*\":i.toLowerCase();r.push({axis:d,raw:u,tag:R,index:c})}}n.debug&&console.info(\"[v3-piercer][resolve] start\",{url:location.href,steps:r.map(e=>({axis:e.axis,raw:e.raw,tag:e.tag,index:e.index}))});let g=[document];for(let e of r){let d=e.index,h=null;for(let u of g){let p=e.axis===\"child\"?m(u):v(u),i=[];for(let c of p)(e.tag===\"*\"||c.localName===e.tag)&&i.push(c);if(n.debug&&console.info(\"[v3-piercer][resolve] step\",{axis:e.axis,tag:e.tag,index:d,poolCount:p.length,matchesCount:i.length}),!!i.length){if(d!=null){let c=d-1;h=c>=0&&c<i.length?i[c]:null}else h=i[0];if(h)break}}if(!h)return n.debug&&console.info(\"[v3-piercer][resolve] no-match\",{step:e.raw}),null;g=[h]}let E=g.length?g[0]:null;return n.debug&&console.info(\"[v3-piercer][resolve] done\",{found:!!E,tag:E?.localName??\"\"}),E};window.__stagehandV3__={getClosedRoot:t=>l.get(t),stats:()=>({installed:!0,url:location.href,isTop:window.top===window,open:n.openCount,closed:n.closedCount}),resolveSimpleXPath:y}},f=Element.prototype.attachShadow;if(f.__v3Patched&&f.__v3State){f.__v3State.debug=!0,S(f.__v3State);return}let s={hostToRoot:new WeakMap,openCount:0,closedCount:0,debug:!0},x=f,w=function(n){let l=n?.mode??\"open\",m=x.call(this,n);try{s.hostToRoot.set(this,m),l===\"closed\"?s.closedCount++:s.openCount++,s.debug&&console.info(\"[v3-piercer] attachShadow\",{tag:this.tagName?.toLowerCase()??\"\",mode:l,url:location.href})}catch{}return m};if(w.__v3Patched=!0,w.__v3State=s,Object.defineProperty(Element.prototype,\"attachShadow\",{configurable:!0,writable:!0,value:w}),_.tagExisting)try{let n=document.createTreeWalker(document,NodeFilter.SHOW_ELEMENT);for(;n.nextNode();){let l=n.currentNode;l.shadowRoot&&(s.hostToRoot.set(l,l.shadowRoot),s.openCount++)}}catch{}window.__stagehandV3Injected=!0,S(s),s.debug&&console.info(\"[v3-piercer] installed\",{url:location.href,isTop:window.top===window,readyState:document.readyState})}b({debug:!0,tagExisting:!1});})();\n";

package/dist/lib/v3/dom/genDomScripts.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/v3/dom/index.d.ts

@@ -0,0 +1 @@
+export * from "./piercer.runtime";

package/dist/lib/v3/dom/piercer.entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/v3/dom/piercer.runtime.d.ts

@@ -0,0 +1,25 @@
+export interface V3ShadowPatchOptions {
+    debug?: boolean;
+    tagExisting?: boolean;
+}
+export interface StagehandV3Backdoor {
+    /** Closed shadow-root accessors */
+    getClosedRoot(host: Element): ShadowRoot | undefined;
+    /** Stats + quick health check */
+    stats(): {
+        installed: true;
+        url: string;
+        isTop: boolean;
+        open: number;
+        closed: number;
+    };
+    /** Simple composed-tree resolver (axis '/', '//' and trailing [n] only; no iframe hops) */
+    resolveSimpleXPath(xp: string): Element | null;
+}
+declare global {
+    interface Window {
+        __stagehandV3Injected?: boolean;
+        __stagehandV3__?: StagehandV3Backdoor;
+    }
+}
+export declare function installV3ShadowPiercer(opts?: V3ShadowPatchOptions): void;

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

@@ -0,0 +1,18 @@
+import { ActHandlerParams, V3FunctionName } from "@/lib/v3/types";
+import { LLMClient } from "../llm/LLMClient";
+import { AvailableModel, ClientOptions } from "../types/model";
+import type { Page } from "../understudy/page";
+import type { Action, ActResult } from "../types/stagehand";
+export declare class ActHandler {
+    private readonly llmClient;
+    private readonly defaultModelName;
+    private readonly defaultClientOptions;
+    private readonly systemPrompt;
+    private readonly logInferenceToFile;
+    private readonly selfHeal;
+    private readonly onMetrics?;
+    private readonly defaultDomSettleTimeoutMs?;
+    constructor(llmClient: LLMClient, defaultModelName: AvailableModel, defaultClientOptions: ClientOptions, systemPrompt?: string, logInferenceToFile?: boolean, selfHeal?: boolean, onMetrics?: (functionName: V3FunctionName, promptTokens: number, completionTokens: number, inferenceTimeMs: number) => void, defaultDomSettleTimeoutMs?: number);
+    act(params: ActHandlerParams): Promise<ActResult>;
+    actFromObserveResult(action: Action, page: Page, domSettleTimeoutMs?: number): Promise<ActResult>;
+}

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

@@ -0,0 +1,29 @@
+import { z, ZodTypeAny } from "zod/v3";
+import { ExtractHandlerParams, V3FunctionName } from "@/lib/v3/types";
+import { LLMClient } from "../llm/LLMClient";
+import { AvailableModel, ClientOptions } from "../types/model";
+import { ZodPathSegments } from "../types/stagehand";
+/**
+ * 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 ZodTypeAny>(schema: T): [T, ZodPathSegments[]];
+export declare class ExtractHandler {
+    private readonly llmClient;
+    private readonly defaultModelName;
+    private readonly defaultClientOptions;
+    private readonly systemPrompt;
+    private readonly logInferenceToFile;
+    private readonly experimental;
+    private readonly onMetrics?;
+    constructor(llmClient: LLMClient, defaultModelName: AvailableModel, defaultClientOptions: ClientOptions, systemPrompt?: string, logInferenceToFile?: boolean, experimental?: boolean, onMetrics?: (functionName: V3FunctionName, promptTokens: number, completionTokens: number, inferenceTimeMs: number) => void);
+    extract<T extends ZodTypeAny>(params: ExtractHandlerParams<T>): Promise<z.infer<T> | {
+        pageText: string;
+    }>;
+}

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

@@ -0,0 +1,18 @@
+import { Frame } from "../../understudy/frame";
+import { Locator } from "../../understudy/locator";
+import type { Page } from "../../understudy/page";
+export declare class UnderstudyCommandException extends Error {
+    constructor(message: string);
+}
+export interface UnderstudyMethodHandlerContext {
+    method: string;
+    locator: Locator;
+    xpath: string;
+    args: ReadonlyArray<string>;
+    frame: Frame;
+    page: Page;
+    initialUrl: string;
+    domSettleTimeoutMs?: number;
+}
+export declare function performUnderstudyMethod(page: Page, frame: Frame, method: string, rawXPath: string, args: ReadonlyArray<unknown>, domSettleTimeoutMs?: number): Promise<void>;
+export declare function selectOption(ctx: UnderstudyMethodHandlerContext): Promise<void>;

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

@@ -0,0 +1,15 @@
+import { ObserveHandlerParams, V3FunctionName } from "@/lib/v3/types";
+import { AvailableModel, ClientOptions } from "../types/model";
+import { LLMClient } from "../llm/LLMClient";
+import { Action } from "../types/stagehand";
+export declare class ObserveHandler {
+    private readonly llmClient;
+    private readonly defaultModelName;
+    private readonly defaultClientOptions;
+    private readonly systemPrompt;
+    private readonly logInferenceToFile;
+    private readonly experimental;
+    private readonly onMetrics?;
+    constructor(llmClient: LLMClient, defaultModelName: AvailableModel, defaultClientOptions: ClientOptions, systemPrompt?: string, logInferenceToFile?: boolean, experimental?: boolean, onMetrics?: (functionName: V3FunctionName, promptTokens: number, completionTokens: number, inferenceTimeMs: number) => void);
+    observe(params: ObserveHandlerParams): Promise<Action[]>;
+}

package/dist/lib/v3/handlers/v3AgentHandler.d.ts

@@ -0,0 +1,17 @@
+import { AgentExecuteOptions, AgentResult } from "../types/agent";
+import { LogLine } from "../types/log";
+import { LLMClient } from "../llm/LLMClient";
+import { ToolSet } from "ai";
+import { V3 } from "@/lib/v3/v3";
+export declare class V3AgentHandler {
+    private v3;
+    private logger;
+    private llmClient;
+    private executionModel?;
+    private systemInstructions?;
+    private mcpTools?;
+    constructor(v3: V3, logger: (message: LogLine) => void, llmClient: LLMClient, executionModel?: string, systemInstructions?: string, mcpTools?: ToolSet);
+    execute(instructionOrOptions: string | AgentExecuteOptions): Promise<AgentResult>;
+    private buildSystemPrompt;
+    private createTools;
+}

package/dist/lib/v3/handlers/v3CuaAgentHandler.d.ts

@@ -0,0 +1,26 @@
+import { AgentExecuteOptions, AgentHandlerOptions, AgentResult } from "../types/agent";
+import { LogLine } from "../types/log";
+import { V3 } from "@/lib/v3/v3";
+import { ToolSet } from "ai";
+export declare class V3CuaAgentHandler {
+    private v3;
+    private agent;
+    private provider;
+    private logger;
+    private agentClient;
+    private options;
+    constructor(v3: V3, logger: (message: LogLine) => void, options: AgentHandlerOptions, tools?: ToolSet);
+    private setupAgentClient;
+    execute(optionsOrInstruction: AgentExecuteOptions | string): Promise<AgentResult>;
+    private executeAction;
+    private ensureXPath;
+    private describePointerAction;
+    private describeTypeAction;
+    private describeDragAction;
+    private buildInstructionFallback;
+    private recordCuaActStep;
+    private updateClientViewport;
+    private updateClientUrl;
+    captureAndSendScreenshot(): Promise<unknown>;
+    private injectCursor;
+}

package/dist/lib/v3/index.d.ts

@@ -0,0 +1,10 @@
+export { V3 } from "./v3";
+export { V3 as Stagehand } from "./v3";
+export * from "./types/agent";
+export * from "./types/model";
+export * from "./types/log";
+export * from "./types/stagehand";
+export * from "./types/stagehandApiErrors";
+export * from "./types/stagehandErrors";
+export * from "./llm/LLMClient";
+export { connectToMCPServer } from "../v3/mcp/connection";

package/dist/lib/v3/launch/browserbase.d.ts

@@ -0,0 +1,8 @@
+import Browserbase from "@browserbasehq/sdk";
+export declare function createBrowserbaseSession(apiKey: string, projectId: string, params?: Omit<Browserbase.Sessions.SessionCreateParams, "projectId"> & {
+    projectId?: string;
+}, resumeSessionId?: string): Promise<{
+    ws: string;
+    sessionId: string;
+    bb: Browserbase;
+}>;

package/dist/lib/v3/launch/local.d.ts

@@ -0,0 +1,13 @@
+import { LaunchedChrome } from "chrome-launcher";
+interface LaunchLocalOptions {
+    chromePath?: string;
+    chromeFlags?: string[];
+    headless?: boolean;
+    userDataDir?: string;
+    connectTimeoutMs?: number;
+}
+export declare function launchLocalChrome(opts: LaunchLocalOptions): Promise<{
+    ws: string;
+    chrome: LaunchedChrome;
+}>;
+export {};

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

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

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

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

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

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

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

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