@mu-agent/mu 0.1.0 → 0.2.1

package/dist/types/profile-browser/agent/permissions.d.ts

@@ -0,0 +1,18 @@
+import type { PermissionMode, PermissionRule } from "../../core/index.js";
+export declare const SCOPES: {
+    readonly observe: "browser:observe";
+    readonly navigate: "browser:navigate";
+    readonly interact: "browser:interact";
+    readonly commit: "browser:commit";
+    readonly secret: "browser:secret";
+    readonly upload: "browser:upload";
+    readonly script: "browser:script";
+    readonly delegate: "browser:delegate";
+    readonly share: "browser:share";
+};
+export declare const BROWSER_PERMISSION_DEFAULTS: PermissionRule[];
+export declare function hostRules(allowedHosts: string[], blockedHosts: string[]): PermissionRule[];
+export declare function browserPermissionModes(hosts?: PermissionRule[]): PermissionMode[];
+export declare function rememberedPermissionsPath(home: string): string;
+export declare function loadRememberedPermissions(home: string, onWarning?: (message: string) => void): PermissionRule[];
+export declare function rememberAllow(home: string, permission: string, pattern: string): PermissionRule[];

package/dist/types/profile-browser/agent/prompts.d.ts

@@ -0,0 +1,4 @@
+import type { PromptSection } from "../../ai/index.js";
+export declare function browserPrompt(modelRef: string): PromptSection[];
+export declare const BROWSER_TASK_PROMPT = "You are a browser sub-task, running alongside others for the main agent in a browser window of your own.\n- Your first browser action opens your window. You see and use only the tabs you open (and popups from them); other tabs belong to the main agent or other sub-tasks.\n- The brief is all you know about the task; the rules above still apply. Only take consequential actions the brief explicitly authorizes (the user still approves each one), and stop where the brief says to stop.\n- Keep the progress file the brief names (under progress/) up to date as you finish steps; never edit another sub-task's file.\n- Anything only the user can do (sign in, a CAPTCHA, an answer your files do not give) is a blocker: stop and report exactly what is needed.\n- Before finishing, close the tabs you no longer need. Leave open only a tab the user should review (for example a filled form waiting for their submit) and name it in your report.\n- Report the outcome, what was submitted and the confirmation the page showed, what is left and why, and any tab left open.";
+export declare const BROWSER_SIDE_BOUNDARY = "This is a side conversation about the browser session. Do not operate the browser, submit forms or change pages unless the user deliberately changes the side conversation's permission mode.";

package/dist/types/profile-browser/agent/state.d.ts

@@ -0,0 +1,48 @@
+import { type AgentMessage } from "../../core/index.js";
+import type { CommitStrength } from "../actions/classify.js";
+export interface NoteEntry {
+    key: string;
+    text: string;
+}
+export interface CommitRecord {
+    id: string;
+    at: number;
+    host: string;
+    url: string;
+    action: string;
+    target: string;
+    valuesDigest?: string;
+}
+export interface CommitDetails extends CommitRecord {
+    name?: string;
+    sends?: string[];
+    strength: CommitStrength;
+}
+export declare const STATE_TYPE = "browser-state";
+export declare const DEFAULT_NOTE_KEY = "notes";
+export declare class NotesStore {
+    private readonly notes;
+    entries(): NoteEntry[];
+    get(key: string): string | undefined;
+    append(key: string, text: string): void;
+    replace(key: string, text: string): void;
+    clear(key?: string): void;
+    load(entries: NoteEntry[]): void;
+}
+export declare class CommitLedger {
+    private list;
+    records(): CommitRecord[];
+    append(record: CommitRecord): void;
+    load(records: CommitRecord[]): void;
+}
+export declare function formatNotes(entries: NoteEntry[]): string;
+export declare function formatLedger(records: CommitRecord[]): string;
+export declare class BrowserState {
+    readonly ledger: CommitLedger;
+    readonly notes: NotesStore;
+    sessionId: string | undefined;
+    constructor(ledger?: CommitLedger);
+    rebuild(messages: AgentMessage[]): void;
+    private snapshotText;
+    snapshotIfChanged(messages: AgentMessage[]): AgentMessage[];
+}

package/dist/types/profile-browser/browser/connect.d.ts

@@ -0,0 +1,44 @@
+import { type CdpConnection } from "../cdp/connection.js";
+import { type DiscoveredBrowser } from "./discover.js";
+import { type BrowserEndpoint, type LaunchOptions, type Size } from "./launch.js";
+export interface BrowserLauncher {
+    discover(prefs: {
+        executable?: string | undefined;
+        channel?: string | undefined;
+    }): Promise<DiscoveredBrowser>;
+    launch(options: LaunchOptions): Promise<BrowserEndpoint>;
+}
+export declare const defaultLauncher: BrowserLauncher;
+interface Signals {
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number | undefined;
+}
+export declare function endpointAlive(wsUrl: string, options?: Signals): Promise<boolean>;
+export declare function resolveCdpUrl(endpoint: string, options?: Signals): Promise<string>;
+export declare function profileLocked(userDataDir: string): boolean;
+export interface ManagedConnectOptions {
+    userDataDir: string;
+    headless: boolean;
+    viewport: Size;
+    executable?: string | undefined;
+    channel?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    launcher?: BrowserLauncher | undefined;
+    signal?: AbortSignal | undefined;
+}
+export interface ConnectedBrowser {
+    connection: CdpConnection;
+    endpoint: BrowserEndpoint;
+    browser?: DiscoveredBrowser;
+}
+export declare function connectManaged(options: ManagedConnectOptions): Promise<ConnectedBrowser>;
+export declare function connectToEndpoint(endpoint: string, options?: Signals): Promise<ConnectedBrowser>;
+export interface ManagedState {
+    running: boolean;
+    endpoint?: string;
+    locked: boolean;
+}
+export declare function managedState(userDataDir: string): Promise<ManagedState>;
+export declare function closeManaged(userDataDir: string): Promise<boolean>;
+export {};

package/dist/types/profile-browser/browser/discover.d.ts

@@ -0,0 +1,31 @@
+export type BrowserChannel = "chrome" | "chromium" | "brave" | "edge";
+export declare const BROWSER_CHANNELS: BrowserChannel[];
+export interface BrowserCandidate {
+    channel: BrowserChannel;
+    path: string;
+}
+export interface DiscoveredBrowser {
+    path: string;
+    channel: BrowserChannel | "custom";
+    product: string;
+    version: string;
+}
+export interface DiscoverDeps {
+    platform: NodeJS.Platform;
+    env: Record<string, string | undefined>;
+    home: string;
+    exists: (path: string) => boolean;
+    which: (command: string) => string | null;
+    probeVersion: (path: string) => Promise<string | undefined>;
+}
+export declare function knownPaths(platform: NodeJS.Platform, env: Record<string, string | undefined>, home: string): BrowserCandidate[];
+export declare function parseVersionOutput(output: string): {
+    product: string;
+    version: string;
+};
+export declare function defaultDiscoverDeps(): DiscoverDeps;
+export declare function findCandidates(channel: BrowserChannel | undefined, deps: DiscoverDeps): BrowserCandidate[];
+export declare function discoverBrowser(prefs?: {
+    executable?: string | undefined;
+    channel?: string | undefined;
+}, deps?: DiscoverDeps): Promise<DiscoveredBrowser>;

package/dist/types/profile-browser/browser/downloads.d.ts

@@ -0,0 +1,24 @@
+import type { CdpConnection } from "../cdp/connection.js";
+export interface DownloadRecord {
+    guid: string;
+    url: string;
+    filename: string;
+    path: string;
+    state: "in progress" | "completed" | "canceled";
+    receivedBytes: number;
+    totalBytes: number;
+    startedAt: number;
+}
+export declare class DownloadTracker {
+    readonly directory: string;
+    private readonly records;
+    private readonly listeners;
+    constructor(directory: string);
+    attach(connection: CdpConnection, signal?: AbortSignal): Promise<void>;
+    private notify;
+    list(): DownloadRecord[];
+    since(time: number): DownloadRecord[];
+    waitForStart(time: number, capMs: number, signal?: AbortSignal): Promise<void>;
+    waitForFinished(time: number, capMs: number, signal?: AbortSignal): Promise<void>;
+}
+export declare function formatDownloads(records: DownloadRecord[]): string;

package/dist/types/profile-browser/browser/frames.d.ts

@@ -0,0 +1,34 @@
+import type { CdpConnection } from "../cdp/connection.js";
+import { CdpSession } from "../cdp/session.js";
+export interface FrameInfo {
+    frameId: string;
+    parentId?: string | undefined;
+    url: string;
+    loaderId?: string | undefined;
+    session: CdpSession;
+}
+export declare class FrameRegistry {
+    private readonly connection;
+    readonly root: CdpSession;
+    private readonly frames;
+    private readonly children;
+    private readonly offs;
+    private readonly worlds;
+    private readonly sessionHooks;
+    private readonly hookOffs;
+    constructor(connection: CdpConnection, root: CdpSession);
+    get mainFrameId(): string | undefined;
+    list(): FrameInfo[];
+    get(frameId: string): FrameInfo | undefined;
+    childSessions(): CdpSession[];
+    onSession(hook: (session: CdpSession) => () => void): void;
+    private runHook;
+    start(signal?: AbortSignal): Promise<void>;
+    isolatedWorld(frameId: string, signal?: AbortSignal): Promise<number>;
+    forgetWorlds(frameId?: string): void;
+    dispose(): void;
+    private record;
+    private watchSession;
+    private removeFrame;
+    private adoptChild;
+}

package/dist/types/profile-browser/browser/launch.d.ts

@@ -0,0 +1,42 @@
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface BrowserEndpoint {
+    wsUrl: string;
+    launched: boolean;
+    pid?: number;
+}
+export interface LaunchOptions {
+    path: string;
+    userDataDir: string;
+    headless: boolean;
+    viewport: Size;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number | undefined;
+}
+export declare const LAUNCH_LOG = "mu-browser.log";
+export declare function managedArgs(options: {
+    userDataDir: string;
+    headless: boolean;
+    viewport: Size;
+    args?: string[] | undefined;
+}): string[];
+export declare function ensureProfileDir(userDataDir: string): void;
+export declare function parseDevToolsActivePort(content: string): string | undefined;
+export declare function readDevToolsActivePort(userDataDir: string): string | undefined;
+export declare function launchBrowser(options: LaunchOptions): Promise<BrowserEndpoint>;
+export declare function killBrowserProcess(pid: number | undefined): void;
+export interface SignInBrowser {
+    pid: number | undefined;
+    exited: Promise<number | null>;
+    close: () => Promise<void>;
+}
+export declare function launchForSignIn(options: {
+    path: string;
+    userDataDir: string;
+    url: string;
+    args?: string[] | undefined;
+}): SignInBrowser;

package/dist/types/profile-browser/browser/manager.d.ts

@@ -0,0 +1,135 @@
+import { DataFlowGuard } from "../agent/dataflow.js";
+import { type CdpConnection } from "../cdp/connection.js";
+import { SecretRegistry } from "../page/secrets.js";
+import { type BrowserLauncher, type ConnectedBrowser } from "./connect.js";
+import { DownloadTracker } from "./downloads.js";
+import type { Size } from "./launch.js";
+import { Tab, type TabInfo } from "./tabs.js";
+export interface BrowserManagerOptions {
+    connect: "managed" | "cdp";
+    profileName: string;
+    userDataDir: string;
+    cdpUrl?: string | undefined;
+    executable?: string | undefined;
+    channel?: string | undefined;
+    headless: boolean;
+    viewport: Size;
+    args?: string[] | undefined;
+    keepOpen: boolean;
+    launcher?: BrowserLauncher | undefined;
+    downloadsDir?: string | undefined;
+}
+export interface BrowserStatus {
+    mode: "managed" | "cdp";
+    profile: string;
+    userDataDir?: string;
+    endpoint?: string;
+    connected: boolean;
+    launched: boolean;
+    pid?: number;
+    product?: string;
+    version?: string;
+    executable?: string;
+    headless: boolean;
+    tabs: number;
+    activeTab?: TabInfo;
+}
+interface PageTarget {
+    targetId: string;
+    tabId: string;
+    url: string;
+    title: string;
+    openerId?: string | undefined;
+    openedByAgent: boolean;
+    createdAt: number;
+    lastUsed: number;
+    owner: string;
+    leftBy?: string | undefined;
+}
+export declare const MAX_LANES = 3;
+declare class SharedBrowser {
+    connected: ConnectedBrowser | undefined;
+    connecting: Promise<ConnectedBrowser> | undefined;
+    readonly pages: Map<string, PageTarget>;
+    readonly attached: Map<string, Tab>;
+    readonly attaching: Map<string, Promise<Tab>>;
+    readonly tabIds: Map<string, string>;
+    nextTab: number;
+    nextLane: number;
+    closingIntentionally: boolean;
+    product: {
+        product: string;
+        version: string;
+        executable?: string;
+    } | undefined;
+    abort: AbortController;
+    readonly lanes: Set<BrowserManager>;
+    readonly waiting: Set<() => void>;
+    readonly downloads: DownloadTracker;
+    readonly secrets: SecretRegistry;
+    readonly dataflow: DataFlowGuard;
+    constructor(downloadsDir: string | undefined);
+}
+export declare class BrowserManager {
+    readonly options: BrowserManagerOptions;
+    private readonly shared;
+    readonly laneId: string;
+    readonly label: string | undefined;
+    private activeTargetId;
+    private notices;
+    withoutScreenshot: number;
+    switchStreak: number;
+    approvedRetry: {
+        key: string;
+        url: string;
+        remaining: number;
+    } | undefined;
+    private slots;
+    constructor(options: BrowserManagerOptions, shared?: SharedBrowser, lane?: {
+        id: string;
+        label: string;
+    });
+    get downloads(): DownloadTracker;
+    get secrets(): SecretRegistry;
+    get dataflow(): DataFlowGuard;
+    private get pages();
+    private get attached();
+    get isConnected(): boolean;
+    get connection(): CdpConnection | undefined;
+    actionSignal(signal?: AbortSignal): AbortSignal;
+    stop(): void;
+    drainNotices(): string[];
+    ensureConnected(signal?: AbortSignal): Promise<CdpConnection>;
+    private connect;
+    private requireCdpUrl;
+    private onDisconnect;
+    private tabIdFor;
+    private trackTarget;
+    observationSlot(tabId: string): number;
+    private forgetTarget;
+    private targetGone;
+    currentTab(): Tab | undefined;
+    private own;
+    private info;
+    tabs(): TabInfo[];
+    openedSince(since: number, openerTargetIds: string[]): TabInfo[];
+    private attach;
+    activeTab(signal?: AbortSignal): Promise<Tab>;
+    ensureForeground(tab: Tab, signal?: AbortSignal): Promise<void>;
+    private recoverCrashed;
+    private closeStaleAgentTab;
+    private touch;
+    openTab(url?: string, signal?: AbortSignal): Promise<Tab>;
+    private targetFor;
+    switchTab(tabId: string, signal?: AbortSignal): Promise<Tab>;
+    closeTab(tabId: string, signal?: AbortSignal): Promise<void>;
+    openLane(label: string, signal: AbortSignal): Promise<BrowserManager>;
+    private laneFreed;
+    release(): Promise<void>;
+    status(): BrowserStatus;
+    shutdown(options?: {
+        close?: boolean;
+    }): Promise<void>;
+}
+export declare function isDisconnectError(error: unknown): boolean;
+export {};

package/dist/types/profile-browser/browser/tabs.d.ts

@@ -0,0 +1,52 @@
+import type { CdpConnection } from "../cdp/connection.js";
+import { type CdpSession } from "../cdp/session.js";
+import { NetworkTracker } from "../page/network.js";
+import { RefTable } from "../page/refs.js";
+import { FrameRegistry } from "./frames.js";
+export interface TabInfo {
+    tabId: string;
+    url: string;
+    title: string;
+    active: boolean;
+    openedByAgent: boolean;
+    leftBy?: string;
+}
+export interface JsDialog {
+    type: "alert" | "confirm" | "prompt" | "beforeunload";
+    message: string;
+    defaultPrompt?: string;
+}
+export declare class Tab {
+    readonly tabId: string;
+    readonly targetId: string;
+    readonly session: CdpSession;
+    readonly frames: FrameRegistry;
+    url: string;
+    title: string;
+    readonly openedByAgent: boolean;
+    dialog: JsDialog | undefined;
+    crashed: boolean;
+    readonly refs: RefTable;
+    readonly links: Set<string>;
+    readonly network: NetworkTracker;
+    previous: {
+        documentId: string;
+        refs: Set<string>;
+        texts: Set<string>;
+    } | undefined;
+    lastFingerprint: string | undefined;
+    unchangedStreak: number;
+    private readonly offs;
+    private constructor();
+    static attach(connection: CdpConnection, target: {
+        targetId: string;
+        url: string;
+        title: string;
+    }, tabId: string, openedByAgent: boolean, signal?: AbortSignal, emulateViewport?: {
+        width: number;
+        height: number;
+    }): Promise<Tab>;
+    get detached(): boolean;
+    info(active: boolean): TabInfo;
+    dispose(): void;
+}

package/dist/types/profile-browser/cdp/connection.d.ts

@@ -0,0 +1,53 @@
+import type { CommandName, CommandParams, CommandResult, EventName, EventParams, SendOptions } from "./types.js";
+export declare const DEFAULT_CDP_TIMEOUT_MS = 10000;
+export type CdpErrorKind = "stale-node" | "context-gone" | "target-closed" | "timeout" | "aborted" | "protocol";
+export declare function classifyProtocolError(message: string): CdpErrorKind;
+export declare class CdpError extends Error {
+    readonly kind: CdpErrorKind;
+    readonly method: string;
+    readonly code: number;
+    constructor(kind: CdpErrorKind, method: string, message: string, code?: number);
+}
+export declare function isCdpError(error: unknown, ...kinds: CdpErrorKind[]): error is CdpError;
+export interface CdpTransport {
+    send(message: string): void;
+    close(): void;
+    onMessage(handler: (data: string) => void): void;
+    onClose(handler: (reason: string) => void): void;
+}
+export declare class CdpConnection {
+    private readonly transport;
+    private nextId;
+    private readonly pending;
+    private readonly listeners;
+    private readonly closeWatchers;
+    private closeReason;
+    private resolveClosed;
+    readonly closed: Promise<{
+        reason: string;
+    }>;
+    constructor(transport: CdpTransport);
+    get isClosed(): boolean;
+    send<M extends CommandName>(method: M, params?: CommandParams<M>, options?: SendOptions): Promise<CommandResult<M>>;
+    on<E extends EventName>(event: E, handler: (params: EventParams<E>, sessionId: string | undefined) => void, options?: {
+        sessionId?: string | undefined;
+    }): () => void;
+    waitFor<E extends EventName>(event: E, options?: {
+        sessionId?: string | undefined;
+        predicate?: (params: EventParams<E>) => boolean;
+        signal?: AbortSignal | undefined;
+        timeoutMs?: number | undefined;
+    }): Promise<EventParams<E>>;
+    close(): Promise<void>;
+    private receive;
+    private dropSession;
+    private shutdown;
+}
+export declare function openWebSocketTransport(url: string, options?: {
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number | undefined;
+}): Promise<CdpTransport>;
+export declare function connectCdp(wsUrl: string, options?: {
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number | undefined;
+}): Promise<CdpConnection>;

package/dist/types/profile-browser/cdp/session.d.ts

@@ -0,0 +1,23 @@
+import type { CdpConnection } from "./connection.js";
+import type { CommandName, CommandParams, CommandResult, EventName, EventParams, SendOptions } from "./types.js";
+export declare class CdpSession {
+    readonly connection: CdpConnection;
+    readonly sessionId: string;
+    readonly targetId: string;
+    private detachedFlag;
+    private readonly offDetach;
+    constructor(connection: CdpConnection, sessionId: string, targetId: string);
+    get detached(): boolean;
+    send<M extends CommandName>(method: M, params?: CommandParams<M>, options?: Omit<SendOptions, "sessionId">): Promise<CommandResult<M>>;
+    on<E extends EventName>(event: E, handler: (params: EventParams<E>) => void): () => void;
+    waitFor<E extends EventName>(event: E, options?: {
+        predicate?: (params: EventParams<E>) => boolean;
+        signal?: AbortSignal | undefined;
+        timeoutMs?: number | undefined;
+    }): Promise<EventParams<E>>;
+    detach(): Promise<void>;
+}
+export declare function attachToTarget(connection: CdpConnection, targetId: string, options?: {
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number | undefined;
+}): Promise<CdpSession>;

package/dist/types/profile-browser/cdp/types.d.ts

@@ -0,0 +1,10 @@
+export type CommandName = string;
+export type EventName = string;
+export type CommandParams<_M extends CommandName> = Record<string, unknown> | undefined;
+export type CommandResult<_M extends CommandName> = any;
+export type EventParams<_E extends EventName> = any;
+export interface SendOptions {
+    sessionId?: string | undefined;
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number | undefined;
+}

package/dist/types/profile-browser/commands.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "../core/index.js";
+import type { CommitLedger } from "./agent/state.js";
+import type { BrowserManager } from "./browser/manager.js";
+export declare function formatStatus(browser: BrowserManager, ledger: CommitLedger): string;
+export declare function browserCommands(browser: BrowserManager, ledger: CommitLedger): Command[];

package/dist/types/profile-browser/config.d.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import type { BrowserLauncher } from "./browser/connect.js";
+import type { Size } from "./browser/launch.js";
+export interface BrowserProfileOptions {
+    browserProfile?: string | undefined;
+    connect?: "managed" | "cdp" | undefined;
+    cdpUrl?: string | undefined;
+    executable?: string | undefined;
+    channel?: "chrome" | "chromium" | "brave" | "edge" | undefined;
+    headless?: boolean | undefined;
+    vision?: "auto" | "on" | "off" | undefined;
+    viewport?: Size | undefined;
+    keepOpen?: boolean | undefined;
+    downloadsDir?: string | undefined;
+    allowedHosts?: string[] | undefined;
+    blockedHosts?: string[] | undefined;
+    home?: string | undefined;
+    launcher?: BrowserLauncher | undefined;
+    workspace?: string | undefined;
+    codingCommand?: string[] | undefined;
+}
+export interface ResolvedBrowserOptions {
+    browserProfile: string;
+    connect: "managed" | "cdp";
+    cdpUrl?: string;
+    executable?: string;
+    channel?: "chrome" | "chromium" | "brave" | "edge";
+    headless: boolean;
+    vision: "auto" | "on" | "off";
+    viewport: Size;
+    keepOpen: boolean;
+    downloadsDir: string;
+    allowedHosts: string[];
+    blockedHosts: string[];
+    home: string;
+    userDataDir: string;
+    launcher?: BrowserLauncher;
+    workspace: string;
+    codingCommand: string[];
+}
+export declare const browserConfigSchema: z.ZodObject<{
+    browserProfile: z.ZodOptional<z.ZodString>;
+    connect: z.ZodOptional<z.ZodEnum<{
+        managed: "managed";
+        cdp: "cdp";
+    }>>;
+    cdpUrl: z.ZodOptional<z.ZodString>;
+    executable: z.ZodOptional<z.ZodString>;
+    channel: z.ZodOptional<z.ZodEnum<{
+        chrome: "chrome";
+        chromium: "chromium";
+        brave: "brave";
+        edge: "edge";
+    }>>;
+    headless: z.ZodOptional<z.ZodBoolean>;
+    vision: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        on: "on";
+        off: "off";
+    }>>;
+    viewport: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    keepOpen: z.ZodOptional<z.ZodBoolean>;
+    downloadsDir: z.ZodOptional<z.ZodString>;
+    allowedHosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockedHosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    workspace: z.ZodOptional<z.ZodString>;
+    codingCommand: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare function readBrowserConfig(home: string, onWarning: (message: string) => void): z.infer<typeof browserConfigSchema>;
+export declare function resolveBrowserOptions(options?: BrowserProfileOptions, onWarning?: (message: string) => void): ResolvedBrowserOptions;

package/dist/types/profile-browser/evals/live.d.ts

@@ -0,0 +1,64 @@
+import type { Credential, Provider } from "../../ai/index.js";
+import { type AgentMessage, type PermissionRequest } from "../../core/index.js";
+import { type BrowserProfile, browserProfile } from "../index.js";
+import type { FixtureSite } from "../testing/fixture-site.js";
+export type Mode = "default" | "autonomous";
+export interface EvalContext {
+    site: FixtureSite;
+    selfEmail?: string | undefined;
+    tag?: string;
+}
+export interface Judgement {
+    pass: boolean;
+    note: string;
+}
+export interface RunFacts {
+    text: string;
+    asks: PermissionRequest[];
+    messages: AgentMessage[];
+    profile: BrowserProfile;
+}
+export interface EvalTask {
+    id: number;
+    name: string;
+    modes: Mode[];
+    google?: boolean;
+    fresh?: boolean;
+    prompt: (ctx: EvalContext) => string;
+    files?: Record<string, string>;
+    approve?: (request: PermissionRequest) => "allow" | "deny";
+    check: (facts: RunFacts, ctx: EvalContext) => Promise<Judgement>;
+}
+export declare const TASKS: EvalTask[];
+export interface RunMetrics {
+    task: number;
+    mode: Mode;
+    run: number;
+    pass: boolean;
+    note: string;
+    turns: number;
+    wallMs: number;
+    modelMs: number;
+    browserMs: number;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    asks: string[];
+    askDetails?: string[];
+    answer?: string;
+    calls?: string[];
+    error?: string;
+}
+export declare function runTask(task: EvalTask, mode: Mode, run: number, options: {
+    ctx: EvalContext;
+    provider: Provider;
+    modelRef: string;
+    getCredentials: (provider: string) => Promise<Credential | undefined>;
+    profileOptions: Parameters<typeof browserProfile>[0];
+    maxTurns?: number;
+}): Promise<RunMetrics>;
+export declare function formatResults(runs: RunMetrics[], meta: {
+    model: string;
+    date: string;
+    skipped: string[];
+}): string;