@hyperbrowser/agent/dist/types/agent/types.d.ts

Hyperbrowsers Web Agent

import { z } from "zod";
import { ActionOutput } from "./actions/types";
import { Page } from "playwright";
export declare const AgentOutputFn: (actionsSchema: z.ZodUnion<readonly [z.AnyZodObject, ...z.AnyZodObject[]]>) => z.ZodObject<{
    thoughts: z.ZodString;
    memory: z.ZodString;
    nextGoal: z.ZodString;
    actions: z.ZodArray<z.ZodUnion<readonly [z.AnyZodObject, ...z.AnyZodObject[]]>, "many">;
}, "strip", z.ZodTypeAny, {
    thoughts: string;
    memory: string;
    nextGoal: string;
    actions: {
        [x: string]: any;
    }[];
}, {
    thoughts: string;
    memory: string;
    nextGoal: string;
    actions: {
        [x: string]: any;
    }[];
}>;
export type AgentOutput = z.infer<ReturnType<typeof AgentOutputFn>>;
export interface AgentStep {
    idx: number;
    agentOutput: AgentOutput;
    actionOutputs: ActionOutput[];
}
export interface TaskParams {
    maxSteps?: number;
    debugDir?: string;
    outputSchema?: z.AnyZodObject;
    onStep?: (step: AgentStep) => Promise<void> | void;
    onComplete?: (output: TaskOutput) => Promise<void> | void;
    debugOnAgentOutput?: (step: AgentOutput) => void;
}
export interface TaskOutput {
    status?: TaskStatus;
    steps: AgentStep[];
    output?: string;
}
export interface Task {
    getStatus: () => TaskStatus;
    pause: () => TaskStatus;
    resume: () => TaskStatus;
    cancel: () => TaskStatus;
}
export declare enum TaskStatus {
    PENDING = "pending",
    RUNNING = "running",
    PAUSED = "paused",
    CANCELLED = "cancelled",
    COMPLETED = "completed",
    FAILED = "failed"
}
export declare const endTaskStatuses: Set<TaskStatus>;
export interface TaskState {
    id: string;
    task: string;
    status: TaskStatus;
    startingPage: Page;
    steps: AgentStep[];
    output?: string;
    error?: string;
}
export interface HyperVariable {
    key: string;
    value: string;
    description: string;
}
export interface HyperPage extends Page {
    ai: (task: string, params?: TaskParams) => Promise<TaskOutput>;
    aiAsync: (task: string, params?: TaskParams) => Promise<Task>;
    extract<T extends z.AnyZodObject | undefined = undefined>(task?: string, outputSchema?: T): Promise<T extends z.AnyZodObject ? z.infer<T> : string>;
}