@ddwang/magnitude-core 0.3.1-ddwang.1

package/dist/index.d.cts

@@ -0,0 +1,825 @@
+import EventEmitter from 'eventemitter3';
+import z$1, { Schema, z, ZodTypeAny, ZodSchema } from 'zod';
+import { Image as Image$1 } from '@boundaryml/baml';
+import sharp, { Sharp } from 'sharp';
+import { BrowserContext, Page, PageScreenshotOptions, Browser, BrowserContextOptions, LaunchOptions } from 'playwright';
+import { PostHog } from 'posthog-node';
+import pino from 'pino';
+
+type Base64Image = `data:image/${'jpeg' | 'png' | 'gif'};base64,${string}`;
+type WebAction = NavigateWebAction | ClickWebAction | TypeWebAction | ScrollWebAction | SwitchTabWebAction;
+interface NavigateWebAction {
+    variant: 'load';
+    url: string;
+}
+interface ClickWebAction {
+    variant: 'click';
+    x: number;
+    y: number;
+}
+interface TypeWebAction {
+    variant: 'type';
+    x: number;
+    y: number;
+    content: string;
+}
+interface ScrollWebAction {
+    variant: 'scroll';
+    x: number;
+    y: number;
+    deltaX: number;
+    deltaY: number;
+}
+type SwitchTabWebAction = {
+    variant: 'tab';
+    index: number;
+};
+interface PixelCoordinate {
+    x: number;
+    y: number;
+}
+
+/**
+ * "Intents" are natural language descriptors that align 1:1 with executable web actions.
+ * Micro converts intents into web actions.
+ */
+
+interface Action {
+    variant: string;
+    [key: string]: any;
+}
+type ActionIntent = ClickIntent | TypeIntent | ScrollIntent | SwitchTabIntent;
+type Intent = ActionIntent | CheckIntent;
+interface ClickIntent {
+    variant: 'click';
+    target: string;
+}
+interface TypeIntent {
+    variant: 'type';
+    target: string;
+    content: string;
+}
+interface ScrollIntent {
+    variant: 'scroll';
+    target: string;
+    deltaX: number;
+    deltaY: number;
+}
+type SwitchTabIntent = SwitchTabWebAction;
+interface CheckIntent {
+    variant: 'check';
+    checks: string[];
+}
+
+type BrowserAgentRole = 'act' | 'extract' | 'query';
+declare const allBrowserAgentRoles: BrowserAgentRole[];
+type LLMClient = (AnthropicClient | ClaudeCodeClient | BedrockClient | GoogleAIClient | GoogleVertexClient | OpenAIClient | OpenAIGenericClient | AzureOpenAIClient) & {
+    roles?: BrowserAgentRole[];
+};
+interface AnthropicClient {
+    provider: 'anthropic';
+    options: {
+        model: string;
+        apiKey?: string;
+        temperature?: number;
+        promptCaching?: boolean;
+    };
+}
+interface ClaudeCodeClient {
+    provider: 'claude-code';
+    options: {
+        model: string;
+        temperature?: number;
+        promptCaching?: boolean;
+    };
+}
+interface BedrockClient {
+    provider: 'aws-bedrock';
+    options: {
+        model: string;
+        temperature?: number;
+    };
+}
+interface GoogleAIClient {
+    provider: 'google-ai';
+    options: {
+        model: string;
+        apiKey?: string;
+        temperature?: number;
+        baseUrl?: string;
+    };
+}
+interface GoogleVertexClient {
+    provider: 'vertex-ai';
+    options: {
+        model: string;
+        location?: string;
+        baseUrl?: string;
+        projectId?: string;
+        credentials?: string | object;
+        anthropicVersion?: string;
+        temperature?: number;
+    };
+}
+interface OpenAIClient {
+    provider: 'openai';
+    options: {
+        model: string;
+        apiKey?: string;
+        temperature?: number;
+    };
+}
+interface AzureOpenAIClient {
+    provider: 'azure-openai';
+    options: {
+        resourceName: string;
+        deploymentId: string;
+        apiVersion: string;
+        apiKey: string;
+    };
+}
+interface OpenAIGenericClient {
+    provider: 'openai-generic';
+    options: {
+        model: string;
+        baseUrl: string;
+        apiKey?: string;
+        temperature?: number;
+        headers?: Record<string, string>;
+    };
+}
+interface LLMClientIdentifier {
+    provider: string;
+    model: string;
+}
+interface ModelUsage {
+    llm: LLMClientIdentifier;
+    inputTokens: number;
+    outputTokens: number;
+    cacheWriteInputTokens?: number;
+    cacheReadInputTokens?: number;
+    inputCost?: number;
+    outputCost?: number;
+}
+
+interface AgentEvents {
+    'start': () => void;
+    'stop': () => void;
+    'thought': (thought: string) => void;
+    'actStarted': (task: string, options: ActOptions) => void;
+    'actDone': (task: string, options: ActOptions) => void;
+    'actionStarted': (action: Action) => void;
+    'actionDone': (action: Action) => void;
+    'pause': () => void;
+    'resume': () => void;
+    'tokensUsed': (usage: ModelUsage) => void;
+}
+
+type StoredMedia = {
+    type: 'media';
+    format: string;
+    storage: 'base64';
+    base64: string;
+};
+interface StoredPrimitive {
+    type: 'primitive';
+    content: string | boolean | number;
+}
+type MultiMediaPrimitive = StoredMedia | StoredPrimitive | undefined | null;
+type MultiMediaArray = Array<MultiMediaJson>;
+type MultiMediaObject = {
+    [key: string]: MultiMediaJson;
+};
+type MultiMediaJson = MultiMediaPrimitive | MultiMediaArray | MultiMediaObject;
+
+declare class Image {
+    /**
+     * Wrapper for a Sharp image with conveniences to go to/from base64, convert to BAML, or serialize as JSON
+     */
+    private img;
+    constructor(img: Sharp);
+    static fromBase64(base64: string): Image;
+    getFormat(): Promise<keyof sharp.FormatEnum>;
+    /**
+     * Convert the image to a JSON representation
+     */
+    toJson(): Promise<StoredMedia>;
+    toBase64(): Promise<string>;
+    toBaml(): Promise<Image$1>;
+    saveToFile(filepath: string): Promise<void>;
+    getDimensions(): Promise<{
+        width: number;
+        height: number;
+    }>;
+    resize(width: number, height: number): Promise<Image>;
+}
+
+/*************************************************************************************************
+
+Welcome to Baml! To use this generated code, please run one of the following:
+
+$ npm install @boundaryml/baml
+$ yarn add @boundaryml/baml
+$ pnpm add @boundaryml/baml
+
+*************************************************************************************************/
+
+interface AgentContext {
+    instructions?: string | null;
+    observationContent: MultiMediaMessage[];
+    connectorInstructions: ConnectorInstructions[];
+}
+interface ConnectorInstructions {
+    connectorId: string;
+    instructions: string;
+}
+interface MultiMediaMessage {
+    role: "user" | "assistant";
+    cacheControl: boolean;
+    content: (Image$1 | string)[];
+}
+
+type MultiMediaContentPart = Image$1 | string;
+
+type ObservableDataPrimitive = Image | string | number | boolean | null | undefined;
+type ObservableDataArray = Array<RenderableContent>;
+type ObservableDataObject = {
+    [key: string]: RenderableContent;
+};
+type RenderableContent = ObservableDataPrimitive | ObservableDataArray | ObservableDataObject;
+type ObservationRole = 'user' | 'assistant';
+interface ObservationRetentionOptions {
+    type: string;
+    limit?: number;
+    dedupe?: boolean;
+}
+type ObservationSource = `connector:${string}` | `action:taken:${string}` | `action:result:${string}` | `thought`;
+declare class Observation {
+    readonly source: ObservationSource;
+    readonly role: ObservationRole;
+    readonly timestamp: number;
+    readonly content: RenderableContent;
+    readonly retention?: ObservationRetentionOptions;
+    constructor(source: ObservationSource, role: ObservationRole, content: RenderableContent, retention?: ObservationRetentionOptions, timestamp?: number);
+    static fromConnector(connectorId: string, content: RenderableContent, options?: ObservationRetentionOptions): Observation;
+    static fromActionTaken(actionId: string, content: RenderableContent, options?: ObservationRetentionOptions): Observation;
+    static fromActionResult(actionId: string, content: RenderableContent, options?: ObservationRetentionOptions): Observation;
+    static fromThought(content: RenderableContent, options?: ObservationRetentionOptions): Observation;
+    toString(): string;
+    toJson(): Promise<MultiMediaJson>;
+    render(options?: {
+        prefix?: MultiMediaContentPart[];
+        postfix?: MultiMediaContentPart[];
+        cacheControl?: boolean;
+    }): Promise<MultiMediaMessage>;
+    hash(): Promise<string>;
+    equals(obs: Observation): Promise<boolean>;
+}
+
+interface ActionDefinition<T> {
+    name: string;
+    description?: string;
+    schema: Schema<T>;
+    resolver: ({ input, agent }: {
+        input: T;
+        agent: Agent;
+    }) => Promise<void | RenderableContent>;
+    render: (action: T) => string;
+}
+declare function createAction<S extends ZodTypeAny>(action: {
+    name: string;
+    description?: string;
+    schema?: S;
+    resolver: ({ input, agent }: {
+        input: z.infer<S>;
+        agent: Agent;
+    }) => Promise<void | RenderableContent>;
+    render?: (action: z.infer<S>) => string;
+}): ActionDefinition<z.infer<S>>;
+type ActionPayload<A extends ActionDefinition<any>> = {
+    name: A['name'];
+} & z.infer<A['schema']>;
+
+interface AgentConnector {
+    id: string;
+    onStart?(): Promise<void>;
+    onStop?(): Promise<void>;
+    getActionSpace?(): ActionDefinition<any>[];
+    collectObservations?(): Promise<Observation[]>;
+    getInstructions?(): Promise<void | string>;
+}
+
+interface SerializedAgentMemory {
+    instructions?: string;
+    observations: {
+        source: ObservationSource;
+        role: ObservationRole;
+        timestamp: number;
+        data: MultiMediaJson;
+        options?: ObservationRetentionOptions;
+    }[];
+}
+interface AgentMemoryOptions {
+    instructions?: string | null;
+    promptCaching?: boolean;
+    thoughtLimit?: number;
+}
+interface MemoryRenderOptions {
+}
+declare class AgentMemory {
+    private options;
+    private observations;
+    private freezeMask?;
+    private cacheControlIndices;
+    constructor(options?: AgentMemoryOptions);
+    get instructions(): string | null;
+    render(options?: MemoryRenderOptions): Promise<MultiMediaMessage[]>;
+    simpleRender(): Promise<(Image$1 | string)[]>;
+    isEmpty(): boolean;
+    recordThought(content: string): void;
+    recordObservation(obs: Observation): void;
+    getLastThoughtMessage(): string | null;
+    toJSON(): Promise<SerializedAgentMemory>;
+    loadJSON(data: SerializedAgentMemory): Promise<void>;
+}
+
+declare function mergeMessages(messages: MultiMediaMessage[]): MultiMediaMessage[];
+
+interface ModelHarnessEvents {
+    'tokensUsed': (usage: ModelUsage) => {};
+}
+
+declare class MultiModelHarness {
+    /**
+     * Delegates model responsibilites to different LLMs and consolidates their usage
+     */
+    private roles;
+    private uniqueModels;
+    readonly events: EventEmitter<ModelHarnessEvents>;
+    constructor(clients: LLMClient[]);
+    setup(): Promise<void>;
+    describe(): string;
+    partialAct<T>(context: AgentContext, task: string, data: MultiMediaContentPart[], actionVocabulary: ActionDefinition<T>[]): Promise<{
+        reasoning: string;
+        actions: Action[];
+    }>;
+    extract<T extends z$1.Schema>(instructions: string, schema: T, screenshot: Image, domContent: string): Promise<z$1.infer<T>>;
+    query<T extends z$1.Schema>(context: AgentContext, query: string, schema: T): Promise<z$1.infer<T>>;
+    get numUniqueModels(): number;
+}
+
+interface AgentOptions {
+    llm?: LLMClient | LLMClient[];
+    connectors?: AgentConnector[];
+    actions?: ActionDefinition<any>[];
+    prompt?: string | null;
+    telemetry?: boolean;
+}
+interface ActOptions {
+    prompt?: string;
+    data?: RenderableContent;
+    memory?: AgentMemory;
+}
+declare class Agent {
+    private options;
+    private connectors;
+    private actions;
+    private memoryOptions;
+    readonly models: MultiModelHarness;
+    readonly events: EventEmitter<AgentEvents>;
+    private doneActing;
+    private _paused;
+    private _pauseResolve;
+    protected latestTaskMemory: AgentMemory;
+    constructor(baseConfig?: Partial<AgentOptions>);
+    getConnector<C extends AgentConnector>(connectorClass: new (...args: any[]) => C): C | undefined;
+    require<C extends AgentConnector>(connectorClass: new (...args: any[]) => C): C;
+    start(): Promise<void>;
+    identifyAction(action: Action): ActionDefinition<any>;
+    exec(action: Action, memory?: AgentMemory): Promise<void>;
+    protected _recordConnectorObservations(memory: AgentMemory): Promise<void>;
+    get memory(): AgentMemory;
+    act(taskOrSteps: string | string[], options?: ActOptions): Promise<void>;
+    _traceAct(task: string, memory: AgentMemory, options?: ActOptions): Promise<void>;
+    private _buildContext;
+    _act(description: string, memory: AgentMemory, options?: ActOptions): Promise<void>;
+    query<T extends z$1.Schema>(query: string, schema: T): Promise<z$1.infer<T>>;
+    queueDone(): Promise<void>;
+    private _waitIfPaused;
+    pause(): void;
+    resume(): void;
+    get paused(): boolean;
+    stop(): Promise<void>;
+}
+
+interface ActionVisualizerOptions {
+    showCursor?: boolean;
+    showHoverCircle?: boolean;
+    showClickRipple?: boolean;
+    showDragLine?: boolean;
+    showTypeEffects?: boolean;
+}
+declare class ActionVisualizer {
+    private options;
+    private context;
+    private page;
+    private cursor;
+    private mouseEffects;
+    private typeEffects;
+    constructor(context: BrowserContext, options: ActionVisualizerOptions);
+    setup(): Promise<void>;
+    setActivePage(page: Page): Promise<void>;
+    moveVirtualCursor(x: number, y: number): Promise<void>;
+    hideAll(): Promise<void>;
+    showAll(): Promise<void>;
+}
+
+interface TabState {
+    activeTab: number;
+    tabs: {
+        title: string;
+        url: string;
+    }[];
+}
+
+interface WebHarnessOptions {
+    virtualScreenDimensions?: {
+        width: number;
+        height: number;
+    };
+    visuals?: ActionVisualizerOptions;
+    switchTabsOnActivity?: boolean;
+}
+interface WebHarnessEvents {
+    'activePageChanged': (page: Page) => Promise<void>;
+}
+declare class WebHarness {
+    /**
+     * Executes web actions on a page
+     * Not responsible for browser lifecycle
+     */
+    readonly context: BrowserContext;
+    private options;
+    private stability;
+    readonly visualizer: ActionVisualizer;
+    private transformer;
+    private tabs;
+    readonly events: EventEmitter<WebHarnessEvents>;
+    constructor(context: BrowserContext, options?: WebHarnessOptions);
+    setActivePage(page: Page): Promise<void>;
+    retrieveTabState(): Promise<TabState>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    get page(): Page;
+    screenshot(options?: PageScreenshotOptions): Promise<Image>;
+    _type(content: string): Promise<void>;
+    transformCoordinates({ x, y }: {
+        x: number;
+        y: number;
+    }): Promise<{
+        x: number;
+        y: number;
+    }>;
+    click({ x, y }: {
+        x: number;
+        y: number;
+    }, options?: {
+        transform: boolean;
+    }): Promise<void>;
+    private _click;
+    rightClick({ x, y }: {
+        x: number;
+        y: number;
+    }, options?: {
+        transform: boolean;
+    }): Promise<void>;
+    doubleClick({ x, y }: {
+        x: number;
+        y: number;
+    }, options?: {
+        transform: boolean;
+    }): Promise<void>;
+    drag({ x1, y1, x2, y2 }: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    }, options?: {
+        transform: boolean;
+    }): Promise<void>;
+    type({ content }: {
+        content: string;
+    }): Promise<void>;
+    clickAndType({ x, y, content }: {
+        x: number;
+        y: number;
+        content: string;
+    }, options?: {
+        transform: boolean;
+    }): Promise<void>;
+    scroll({ x, y, deltaX, deltaY }: {
+        x: number;
+        y: number;
+        deltaX: number;
+        deltaY: number;
+    }, options?: {
+        transform: boolean;
+    }): Promise<void>;
+    switchTab({ index }: {
+        index: number;
+    }): Promise<void>;
+    newTab(): Promise<void>;
+    navigate(url: string): Promise<void>;
+    selectAll(): Promise<void>;
+    enter(): Promise<void>;
+    backspace(): Promise<void>;
+    tab(): Promise<void>;
+    goBack(): Promise<void>;
+    executeAction(action: WebAction): Promise<void>;
+    waitForStability(timeout?: number): Promise<void>;
+}
+
+type BrowserOptions = {
+    instance: Browser;
+    contextOptions?: BrowserContextOptions;
+} | {
+    cdp: string;
+    contextOptions?: BrowserContextOptions;
+} | {
+    launchOptions?: LaunchOptions;
+    contextOptions?: BrowserContextOptions;
+} | {
+    context: BrowserContext;
+};
+declare class BrowserProvider {
+    private activeBrowsers;
+    private logger;
+    private constructor();
+    static getInstance(): BrowserProvider;
+    private _launchOrReuseBrowser;
+    _createAndTrackContext(options: BrowserOptions): Promise<BrowserContext>;
+    newContext(options?: BrowserOptions): Promise<BrowserContext>;
+    private _applyEmulationSettings;
+}
+
+interface BrowserConnectorOptions {
+    browser?: BrowserOptions;
+    url?: string;
+    virtualScreenDimensions?: {
+        width: number;
+        height: number;
+    };
+    minScreenshots?: number;
+    visuals?: ActionVisualizerOptions;
+}
+interface BrowserConnectorStateData {
+    screenshot: Image;
+    tabs: TabState;
+}
+declare class BrowserConnector implements AgentConnector {
+    readonly id: string;
+    private harness;
+    private options;
+    private browser?;
+    private context;
+    private logger;
+    constructor(options?: BrowserConnectorOptions);
+    onStart(): Promise<void>;
+    onStop(): Promise<void>;
+    getActionSpace(): ActionDefinition<any>[];
+    getHarness(): WebHarness;
+    private captureCurrentState;
+    transformScreenshot(screenshot: Image): Promise<Image>;
+    getLastScreenshot(): Promise<Image>;
+    collectObservations(): Promise<Observation[]>;
+    getInstructions(): Promise<void | string>;
+}
+
+declare function startBrowserAgent(options?: AgentOptions & BrowserConnectorOptions & {
+    narrate?: boolean;
+}): Promise<BrowserAgent>;
+type ExtractedOutput = string | number | boolean | bigint | Date | null | undefined | {
+    [key: string]: ExtractedOutput;
+} | ExtractedOutput[];
+interface BrowserAgentEvents {
+    'nav': (url: string) => void;
+    'extractStarted': (instructions: string, schema: ZodSchema) => void;
+    'extractDone': (instructions: string, data: ExtractedOutput) => void;
+}
+declare class BrowserAgent extends Agent {
+    readonly browserAgentEvents: EventEmitter<BrowserAgentEvents>;
+    constructor({ agentOptions, browserOptions }: {
+        agentOptions?: Partial<AgentOptions>;
+        browserOptions?: BrowserConnectorOptions;
+    });
+    get page(): Page;
+    get context(): BrowserContext;
+    nav(url: string): Promise<void>;
+    extract<T extends Schema>(instructions: string, schema: T): Promise<z$1.infer<T>>;
+}
+
+/**
+ * Generic desktop automation interface.
+ * Implementations can use any desktop automation technology
+ * (Lume, PyAutoGUI, Windows UI Automation, etc.)
+ */
+interface DesktopInterface {
+    click(x: number, y: number): Promise<void>;
+    rightClick(x: number, y: number): Promise<void>;
+    doubleClick(x: number, y: number): Promise<void>;
+    moveCursor(x: number, y: number): Promise<void>;
+    drag(fromX: number, fromY: number, toX: number, toY: number): Promise<void>;
+    scroll(x: number, y: number, deltaX: number, deltaY: number): Promise<void>;
+    type(text: string): Promise<void>;
+    key(key: string): Promise<void>;
+    hotkey(keys: string[]): Promise<void>;
+    screenshot(): Promise<Buffer>;
+    getScreenSize(): Promise<{
+        width: number;
+        height: number;
+    }>;
+    navigate?(url: string): Promise<void>;
+    getActiveWindow?(): Promise<{
+        title: string;
+        app: string;
+    }>;
+    getOpenWindows?(): Promise<Array<{
+        title: string;
+        app: string;
+        isActive: boolean;
+    }>>;
+    focusWindow?(title: string): Promise<void>;
+    openApplication?(name: string): Promise<void>;
+    closeApplication?(name: string): Promise<void>;
+}
+interface DesktopConnectorOptions {
+    desktopInterface: DesktopInterface;
+    virtualScreenDimensions?: {
+        width: number;
+        height: number;
+    };
+    minScreenshots?: number;
+}
+declare class DesktopConnector implements AgentConnector {
+    readonly id: string;
+    private desktopInterface;
+    private options;
+    private logger;
+    constructor(options: DesktopConnectorOptions);
+    onStart(): Promise<void>;
+    onStop(): Promise<void>;
+    getActionSpace(): ActionDefinition<any>[];
+    collectObservations(): Promise<Observation[]>;
+    private formatWindowInfo;
+    getInterface(): DesktopInterface;
+}
+
+interface AgentErrorOptions {
+    variant?: string;
+    adaptable?: boolean;
+}
+declare class AgentError extends Error {
+    readonly options: Required<AgentErrorOptions>;
+    constructor(message: string, options?: AgentErrorOptions);
+}
+
+/**
+ * Represents any reason why a test case could have failed, for example:
+ * - Step could not be completed
+ * - Check did not pass
+ * - Could not navigate to starting URL
+ * - Time or action based timeout
+ * - Operation cancelled by signal
+ * - ...
+ */
+type FailureDescriptor = BugDetectedFailure | MisalignmentFailure | NetworkFailure | BrowserFailure | RateLimitFailure | ApiKeyFailure | UnknownFailure | CancelledFailure;
+type BugSeverity = 'critical' | 'high' | 'medium' | 'low';
+/**
+ * Step and check failures are classified into one of:
+ * BugDetectedFailure: seems to be something wrong with the application itself
+ * MisalignmentFailure: seems to be a discrepency between the test case and the interface
+ *    OR the agent did not properly recognize the relationship between test case and interface
+ */
+interface BugDetectedFailure {
+    variant: 'bug';
+    title: string;
+    expectedResult: string;
+    actualResult: string;
+    severity: BugSeverity;
+}
+interface MisalignmentFailure {
+    /**
+     * Major misalignment: when a step/check fails due to:
+     * 1. Poorly written step/check that is completely unrelated to the interface
+     * 2. Or interface has changed so much that step/check no longer applicable
+     * 3. Planner did not do good enough job adjusting recipe for minor misalignment
+     * Misalignment could be due to a poorly written test case OR bad agent behavior.
+     */
+    variant: 'misalignment';
+    message: string;
+}
+interface NetworkFailure {
+    /**
+     * For example, failure to connect to starting URL, or any other network errors
+     * that would completely prevent the test from executing.
+     */
+    variant: 'network';
+    message: string;
+}
+interface BrowserFailure {
+    /**
+     * E.g. something goes wrong with playwright interactions, any DOM manipulation, etc.
+     */
+    variant: 'browser';
+    message: string;
+}
+interface RateLimitFailure {
+    variant: 'rate_limit';
+    message: string;
+}
+interface ApiKeyFailure {
+    variant: 'api_key';
+    message: string;
+}
+interface UnknownFailure {
+    variant: 'unknown';
+    message: string;
+}
+interface CancelledFailure {
+    /**
+     * Operation was cancelled, typically by an AbortSignal from a controlling process (e.g., test runner pool).
+     */
+    variant: 'cancelled';
+}
+
+type RetryMode = {
+    mode: 'retry_on_partial_message';
+    errorSubstrings: string[];
+} | {
+    mode: 'retry_all';
+};
+type RetryParams = {
+    retryLimit: number;
+    delayMs: number;
+    showWarnOnRetry: boolean;
+};
+type RetryOptions = RetryMode & RetryParams;
+declare function retryOnErrorIsSuccess<T>(fnToRetry: () => Promise<T>, retryOptions: RetryMode & Partial<RetryParams>): Promise<boolean>;
+declare function retryOnError<T>(fnToRetry: () => Promise<T>, retryOptions: RetryMode & Partial<RetryParams>): Promise<T>;
+/**
+ * Performs a deep comparison between two values to determine if they are equivalent.
+ *
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @param cache A WeakMap to handle circular references. Should not be provided by the caller.
+ * @returns `true` if the values are deeply equal, `false` otherwise.
+ */
+declare function deepEquals(a: any, b: any, cache?: WeakMap<object, WeakSet<object>>): boolean;
+
+interface TestDataEntry {
+    key: string;
+    value: string;
+    sensitive: boolean;
+}
+interface TestData {
+    data?: TestDataEntry[];
+    other?: string;
+}
+interface TestStepDefinition {
+    description: string;
+    checks: string[];
+    testData: TestData;
+}
+interface TestCaseDefinition {
+    url: string;
+    steps: TestStepDefinition[];
+    recipe?: Intent[];
+}
+type TestCaseResult = SuccessfulTestCaseResult | FailedTestCaseResult;
+interface SuccessfulTestCaseResult {
+    passed: true;
+    recipe: Intent[];
+}
+interface FailedTestCaseResult {
+    passed: false;
+    failure: FailureDescriptor;
+}
+
+declare const createId: () => string;
+declare const posthog: PostHog;
+declare function getMachineId(): string;
+declare function getCodebaseId(): string | undefined;
+declare function sendTelemetry(eventName: string, properties: Record<string, any>): Promise<void>;
+
+declare function buildDefaultBrowserAgentOptions({ agentOptions, browserOptions }: {
+    agentOptions: AgentOptions;
+    browserOptions: BrowserConnectorOptions;
+}): {
+    agentOptions: AgentOptions;
+    browserOptions: BrowserConnectorOptions;
+};
+
+declare const logger: pino.Logger<never, boolean>;
+
+export { Agent, AgentError, AgentMemory, BrowserAgent, BrowserConnector, BrowserProvider, DesktopConnector, Observation, WebHarness, allBrowserAgentRoles, buildDefaultBrowserAgentOptions, createAction, createId, deepEquals, getCodebaseId, getMachineId, logger, mergeMessages, posthog, retryOnError, retryOnErrorIsSuccess, sendTelemetry, startBrowserAgent };
+export type { ActOptions, Action, ActionDefinition, ActionIntent, ActionPayload, AgentConnector, AgentErrorOptions, AgentEvents, AgentMemoryOptions, AgentOptions, AnthropicClient, ApiKeyFailure, AzureOpenAIClient, Base64Image, BedrockClient, BrowserAgentRole, BrowserConnectorOptions, BrowserConnectorStateData, BrowserFailure, BrowserOptions, BugDetectedFailure, BugSeverity, CancelledFailure, CheckIntent, ClaudeCodeClient, ClickIntent, ClickWebAction, DesktopConnectorOptions, DesktopInterface, FailedTestCaseResult, FailureDescriptor, GoogleAIClient, GoogleVertexClient, Intent, LLMClient, LLMClientIdentifier, MemoryRenderOptions, MisalignmentFailure, ModelUsage, NavigateWebAction, NetworkFailure, ObservableDataArray, ObservableDataObject, ObservableDataPrimitive, ObservationRetentionOptions, ObservationRole, ObservationSource, OpenAIClient, OpenAIGenericClient, PixelCoordinate, RateLimitFailure, RenderableContent, RetryMode, RetryOptions, RetryParams, ScrollIntent, ScrollWebAction, SerializedAgentMemory, SuccessfulTestCaseResult, SwitchTabIntent, SwitchTabWebAction, TestCaseDefinition, TestCaseResult, TestData, TestDataEntry, TestStepDefinition, TypeIntent, TypeWebAction, UnknownFailure, WebAction, WebHarnessEvents, WebHarnessOptions };