@browserbasehq/orca 3.0.0-preview.1 → 3.0.0-preview.4

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,71 +0,0 @@
-import { z } from "zod/v3";
-import { LogLine } from "./v3/types/log";
-import { LLMClient } from "./v3/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, logger, userProvidedInstructions, logInferenceToFile, }: {
-    instruction: string;
-    domElements: string;
-    schema: z.ZodObject<z.ZodRawShape>;
-    llmClient: LLMClient;
-    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, userProvidedInstructions, logger, logInferenceToFile, }: {
-    instruction: string;
-    domElements: string;
-    llmClient: LLMClient;
-    userProvidedInstructions?: string;
-    logger: (message: LogLine) => void;
-    logInferenceToFile?: boolean;
-}): Promise<{
-    elements: {
-        elementId: string;
-        description: string;
-        method: string;
-        arguments: string[];
-    }[];
-    prompt_tokens: number;
-    completion_tokens: number;
-    inference_time_ms: number;
-}>;
-export declare function act({ instruction, domElements, llmClient, userProvidedInstructions, logger, logInferenceToFile, }: {
-    instruction: string;
-    domElements: string;
-    llmClient: LLMClient;
-    userProvidedInstructions?: string;
-    logger: (message: LogLine) => void;
-    logInferenceToFile?: boolean;
-}): Promise<{
-    element: {
-        elementId: string;
-        description: string;
-        method: string;
-        arguments: string[];
-    };
-    prompt_tokens: number;
-    completion_tokens: number;
-    inference_time_ms: number;
-    twoStep: boolean;
-}>;
-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;
-}

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

@@ -1,20 +0,0 @@
-import { 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 OpenAIClient extends LLMClient {
-    type: "openai";
-    private client;
-    private cache;
-    private enableCaching;
-    clientOptions: ClientOptions;
-    constructor({ enableCaching, cache, modelName, clientOptions, }: {
-        logger: (message: LogLine) => void;
-        enableCaching?: boolean;
-        cache?: LLMCache;
-        modelName: AvailableModel;
-        clientOptions?: ClientOptions;
-    });
-    createChatCompletion<T = LLMResponse>({ options: optionsInitial, logger, retries, }: CreateChatCompletionOptions): Promise<T>;
-}

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

@@ -1,20 +0,0 @@
-import { LanguageModel } from "ai";
-import { ChatCompletion } from "openai/resources";
-import { LogLine } from "../../types/log";
-import { LLMCache } from "../cache/LLMCache";
-import { CreateChatCompletionOptions, LLMClient } from "./LLMClient";
-export declare class AISdkClient extends LLMClient {
-    type: "aisdk";
-    private model;
-    private logger?;
-    private cache;
-    private enableCaching;
-    constructor({ model, logger, enableCaching, cache, }: {
-        model: LanguageModel;
-        logger?: (message: LogLine) => void;
-        enableCaching?: boolean;
-        cache?: LLMCache;
-    });
-    getLanguageModel(): LanguageModel;
-    createChatCompletion<T = ChatCompletion>({ options, }: CreateChatCompletionOptions): Promise<T>;
-}

package/dist/lib/logger.d.ts

@@ -1,54 +0,0 @@
-import pino from "pino";
-import { LogLine } from "./v3/types/log";
-export interface LoggerOptions {
-    pretty?: boolean;
-    level?: pino.Level;
-    destination?: pino.DestinationStream;
-    usePino?: boolean;
-}
-/**
- * Creates a configured Pino logger instance
- */
-export declare function createLogger(options?: LoggerOptions): import("pino/pino").Logger<never, boolean>;
-/**
- * StagehandLogger class that wraps Pino for our specific needs
- */
-export declare class StagehandLogger {
-    /**
-     * We maintain a single shared Pino instance when `usePino` is enabled.
-     * This prevents spawning a new worker thread for every Stagehand instance
-     * (which happens when `pino-pretty` transport is used), eliminating the
-     * memory/RSS growth observed when many Stagehand objects are created and
-     * disposed within the same process (e.g. a request-per-instance API).
-     */
-    private static sharedPinoLogger;
-    private logger?;
-    private verbose;
-    private externalLogger?;
-    private usePino;
-    private isTest;
-    constructor(options?: LoggerOptions, externalLogger?: (logLine: LogLine) => void);
-    /**
-     * Set the verbosity level
-     */
-    setVerbosity(level: 0 | 1 | 2): void;
-    /**
-     * Log a message using our LogLine format
-     */
-    log(logLine: LogLine): void;
-    /**
-     * Helper to format auxiliary data for structured logging
-     */
-    private formatAuxiliaryData;
-    /**
-     * Convenience methods for different log levels
-     */
-    error(message: string, data?: Record<string, unknown>): void;
-    warn(message: string, data?: Record<string, unknown>): void;
-    info(message: string, data?: Record<string, unknown>): void;
-    debug(message: string, data?: Record<string, unknown>): void;
-    /**
-     * Convert a plain object to our auxiliary format
-     */
-    private convertToAuxiliary;
-}

package/dist/lib/mcp/connection.d.ts

@@ -1,11 +0,0 @@
-import { Client, ClientOptions } from "@modelcontextprotocol/sdk/client/index.js";
-export interface ConnectToMCPServerOptions {
-    serverUrl: string | URL;
-    clientOptions?: ClientOptions;
-}
-export interface StdioServerConfig {
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-}
-export declare const connectToMCPServer: (serverConfig: string | URL | StdioServerConfig | ConnectToMCPServerOptions) => Promise<Client>;

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

@@ -1,3 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/dist/esm/client";
-import { ToolSet } from "ai/dist";
-export declare const resolveTools: (clients: (Client | string)[], userTools: ToolSet) => Promise<ToolSet>;

package/dist/lib/prompt.d.ts

@@ -1,12 +0,0 @@
-import { ChatMessage } from "./v3/llm/LLMClient";
-export declare function buildUserInstructionsString(userProvidedInstructions?: string): string;
-export declare function buildExtractSystemPrompt(isUsingPrintExtractedDataTool?: boolean, userProvidedInstructions?: string): ChatMessage;
-export declare function buildExtractUserPrompt(instruction: string, domElements: string, isUsingPrintExtractedDataTool?: boolean): ChatMessage;
-export declare function buildMetadataSystemPrompt(): ChatMessage;
-export declare function buildMetadataPrompt(instruction: string, extractionResponse: object): ChatMessage;
-export declare function buildObserveSystemPrompt(userProvidedInstructions?: string): ChatMessage;
-export declare function buildObserveUserMessage(instruction: string, domElements: string): ChatMessage;
-export declare function buildActSystemPrompt(userProvidedInstructions?: string): ChatMessage;
-export declare function buildActPrompt(action: string, supportedActions: string[], variables?: Record<string, string>): string;
-export declare function buildStepTwoPrompt(originalUserAction: string, previousAction: string, supportedActions: string[], variables?: Record<string, string>): string;
-export declare function buildOperatorSystemPrompt(goal: string): ChatMessage;

package/dist/lib/utils.d.ts

@@ -1,65 +0,0 @@
-import { Schema } from "@google/genai";
-import { z, ZodTypeAny } from "zod/v3";
-import { LogLine } from "./v3/types/log";
-import { ModelProvider } from "./v3/types/model";
-import { ZodPathSegments } from "./v3/types/stagehand";
-export declare function validateZodSchema(schema: z.ZodTypeAny, data: unknown): boolean;
-/**
- * Detects if the code is running in the Bun runtime environment.
- * @returns {boolean} True if running in Bun, false otherwise.
- */
-export declare function isRunningInBun(): boolean;
-export declare function toGeminiSchema(zodSchema: z.ZodTypeAny): Schema;
-export declare function getZodType(schema: z.ZodTypeAny): string;
-/**
- * Recursively traverses a given Zod schema, scanning for any fields of type `z.string().url()`.
- * For each such field, it replaces the `z.string().url()` with `z.number()`.
- *
- * This function is used internally by higher-level utilities (e.g., transforming entire object schemas)
- * and handles nested objects, arrays, unions, intersections, optionals.
- *
- * @param schema - The Zod schema to transform.
- * @param currentPath - An array of string/number keys representing the current schema path (used internally for recursion).
- * @returns A two-element tuple:
- *   1. The updated Zod schema, with any `.url()` fields replaced by `z.number()`.
- *   2. An array of {@link ZodPathSegments} objects representing each replaced field, including the path segments.
- */
-export declare function transformSchema(schema: z.ZodTypeAny, currentPath: Array<string | number>): [z.ZodTypeAny, ZodPathSegments[]];
-/**
- * Once we get the final extracted object that has numeric IDs in place of URLs,
- * use `injectUrls` to walk the object and replace numeric IDs
- * with the real URL strings from idToUrlMapping. The `path` may include `*`
- * for array indices (indicating "all items in the array").
- */
-export declare function injectUrls(obj: unknown, path: Array<string | number>, idToUrlMapping: Record<string, string>): void;
-/**
- * Mapping from LLM provider names to their corresponding environment variable names for API keys.
- */
-export declare const providerEnvVarMap: Partial<Record<ModelProvider | string, string>>;
-/**
- * Loads an API key for a provider, checking environment variables.
- * @param provider The name of the provider (e.g., 'openai', 'anthropic')
- * @param logger Optional logger for info/error messages
- * @returns The API key if found, undefined otherwise
- */
-export declare function loadApiKeyFromEnv(provider: string | undefined, logger: (logLine: LogLine) => void): string | undefined;
-export declare function trimTrailingTextNode(path: string | undefined): string | undefined;
-export interface JsonSchemaProperty {
-    type: string;
-    enum?: unknown[];
-    items?: JsonSchemaProperty;
-    properties?: Record<string, JsonSchemaProperty>;
-    required?: string[];
-    minimum?: number;
-    maximum?: number;
-    description?: string;
-}
-export interface JsonSchema extends JsonSchemaProperty {
-    type: string;
-}
-/**
- * Converts a JSON Schema object to a Zod schema
- * @param schema The JSON Schema object to convert
- * @returns A Zod schema equivalent to the input JSON Schema
- */
-export declare function jsonSchemaToZod(schema: JsonSchema): ZodTypeAny;

package/dist/lib/v3/agent/AgentClient.d.ts

@@ -1,18 +0,0 @@
-import { AgentAction, AgentResult, AgentType, AgentExecutionOptions } from "../types/agent";
-/**
- * Abstract base class for agent clients
- * This provides a common interface for all agent implementations
- */
-export declare abstract class AgentClient {
-    type: AgentType;
-    modelName: string;
-    clientOptions: Record<string, unknown>;
-    userProvidedInstructions?: string;
-    constructor(type: AgentType, modelName: string, userProvidedInstructions?: string);
-    abstract execute(options: AgentExecutionOptions): Promise<AgentResult>;
-    abstract captureScreenshot(options?: Record<string, unknown>): Promise<unknown>;
-    abstract setViewport(width: number, height: number): void;
-    abstract setCurrentUrl(url: string): void;
-    abstract setScreenshotProvider(provider: () => Promise<string>): void;
-    abstract setActionHandler(handler: (action: AgentAction) => Promise<void>): void;
-}