agent-afk 5.1.0 → 5.2.0

package/dist/agent/types/sdk-types.d.ts

@@ -0,0 +1,282 @@
+export type EffortLevel = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan' | 'dontAsk' | 'auto' | 'autonomous';
+export type SettingSource = 'user' | 'project' | 'local';
+export type ApiKeySource = 'user' | 'project' | 'org' | 'temporary' | 'oauth';
+export type SDKStatus = 'compacting' | 'requesting' | null;
+export type ThinkingAdaptive = {
+    type: 'adaptive';
+    display?: 'summarized' | 'omitted';
+};
+export type ThinkingEnabled = {
+    type: 'enabled';
+    budgetTokens?: number;
+    display?: 'summarized' | 'omitted';
+};
+export type ThinkingDisabled = {
+    type: 'disabled';
+};
+export type ThinkingConfig = ThinkingAdaptive | ThinkingEnabled | ThinkingDisabled;
+export type PermissionBehavior = 'allow' | 'deny' | 'ask';
+export type PermissionDecisionClassification = 'user_temporary' | 'user_permanent' | 'user_reject';
+export type PermissionUpdateDestination = 'userSettings' | 'projectSettings' | 'localSettings' | 'session' | 'cliArg';
+export type PermissionRuleValue = {
+    toolName: string;
+    ruleContent?: string;
+};
+export type PermissionUpdate = {
+    type: 'addRules';
+    rules: PermissionRuleValue[];
+    behavior: PermissionBehavior;
+    destination: PermissionUpdateDestination;
+} | {
+    type: 'replaceRules';
+    rules: PermissionRuleValue[];
+    behavior: PermissionBehavior;
+    destination: PermissionUpdateDestination;
+} | {
+    type: 'removeRules';
+    rules: PermissionRuleValue[];
+    behavior: PermissionBehavior;
+    destination: PermissionUpdateDestination;
+} | {
+    type: 'setMode';
+    mode: PermissionMode;
+    destination: PermissionUpdateDestination;
+} | {
+    type: 'addDirectories';
+    directories: string[];
+    destination: PermissionUpdateDestination;
+} | {
+    type: 'removeDirectories';
+    directories: string[];
+    destination: PermissionUpdateDestination;
+};
+export type PermissionResult = {
+    behavior: 'allow';
+    updatedInput?: Record<string, unknown>;
+    updatedPermissions?: PermissionUpdate[];
+    toolUseID?: string;
+    decisionClassification?: PermissionDecisionClassification;
+} | {
+    behavior: 'deny';
+    message: string;
+    interrupt?: boolean;
+    toolUseID?: string;
+    decisionClassification?: PermissionDecisionClassification;
+};
+export type CanUseTool = (toolName: string, input: Record<string, unknown>, options: {
+    signal: AbortSignal;
+    suggestions?: PermissionUpdate[];
+    blockedPath?: string;
+    decisionReason?: string;
+    title?: string;
+    displayName?: string;
+    description?: string;
+    toolUseID: string;
+    agentID?: string;
+}) => Promise<PermissionResult>;
+export type HookEvent = 'PreToolUse' | 'PostToolUse' | 'PostToolUseFailure' | 'Notification' | 'UserPromptSubmit' | 'SessionStart' | 'SessionEnd' | 'Stop' | 'StopFailure' | 'SubagentStart' | 'SubagentStop' | 'PreCompact' | 'PostCompact' | 'PermissionRequest' | 'PermissionDenied' | 'Setup' | 'TeammateIdle' | 'TaskCreated' | 'TaskCompleted' | 'Elicitation' | 'ElicitationResult' | 'ConfigChange' | 'WorktreeCreate' | 'WorktreeRemove' | 'InstructionsLoaded' | 'CwdChanged' | 'FileChanged';
+export type HookJSONOutput = {
+    async: true;
+    asyncTimeout?: number;
+} | {
+    decision?: 'allow' | 'deny' | 'block';
+    reason?: string;
+};
+export type HookCallback = (input: Record<string, unknown>, toolUseID: string | undefined, options: {
+    signal: AbortSignal;
+}) => Promise<HookJSONOutput>;
+export interface HookCallbackMatcher {
+    matcher?: string;
+    hooks: HookCallback[];
+    timeout?: number;
+}
+export type ElicitationRequest = {
+    serverName: string;
+    message: string;
+    mode?: 'form' | 'url';
+    url?: string;
+    elicitationId?: string;
+    requestedSchema?: Record<string, unknown>;
+    title?: string;
+    displayName?: string;
+    description?: string;
+    origin?: 'agent';
+    type?: 'text' | 'confirm' | 'choice' | 'multi_choice' | 'number';
+    choices?: string[];
+    questionDefault?: string | boolean | number;
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    allowSkip?: boolean;
+    allowCustom?: boolean;
+    context?: string;
+};
+export type ElicitationResult = {
+    action: 'accept' | 'decline' | 'cancel' | 'skip';
+    content?: Record<string, unknown>;
+};
+export type OnElicitation = (request: ElicitationRequest, options: {
+    signal: AbortSignal;
+}) => Promise<ElicitationResult>;
+export type AgentDefinition = {
+    description: string;
+    tools?: string[];
+    disallowedTools?: string[];
+    prompt: string;
+    model?: string;
+    mcpServers?: (string | Record<string, unknown>)[];
+    criticalSystemReminder_EXPERIMENTAL?: string;
+    skills?: string[];
+    initialPrompt?: string;
+    maxTurns?: number;
+    background?: boolean;
+    memory?: 'user' | 'project' | 'local';
+    effort?: EffortLevel | number;
+    permissionMode?: PermissionMode;
+};
+export type SdkPluginConfig = {
+    type: 'local';
+    path: string;
+    main?: string;
+};
+export type AccountInfo = {
+    email?: string;
+    organization?: string;
+    subscriptionType?: string;
+    tokenSource?: string;
+    apiKeySource?: string;
+    apiProvider?: 'firstParty' | 'bedrock' | 'vertex' | 'foundry' | 'anthropicAws' | 'mantle';
+};
+export type AgentInfo = {
+    name: string;
+    description: string;
+    model?: string;
+};
+export type ModelInfo = {
+    value: string;
+    displayName: string;
+    description: string;
+    supportsEffort?: boolean;
+    supportedEffortLevels?: EffortLevel[];
+    supportsAdaptiveThinking?: boolean;
+    supportsFastMode?: boolean;
+    supportsAutoMode?: boolean;
+};
+export type McpServerStatus = {
+    name: string;
+    status: 'connected' | 'failed' | 'needs-auth' | 'pending' | 'disabled';
+    serverInfo?: {
+        name: string;
+        version: string;
+    };
+    error?: string;
+    config?: Record<string, unknown>;
+    scope?: string;
+    tools?: {
+        name: string;
+        description?: string;
+        annotations?: {
+            readOnly?: boolean;
+            destructive?: boolean;
+            openWorld?: boolean;
+        };
+    }[];
+};
+export type SlashCommand = {
+    name: string;
+    description: string;
+    argumentHint: string;
+};
+export type SDKControlGetContextUsageResponse = {
+    categories: {
+        name: string;
+        tokens: number;
+        color: string;
+        isDeferred?: boolean;
+    }[];
+    totalTokens: number;
+    maxTokens: number;
+    rawMaxTokens: number;
+    percentage: number;
+    gridRows: {
+        color: string;
+        isFilled: boolean;
+        categoryName: string;
+        tokens: number;
+        percentage: number;
+        squareFullness: number;
+    }[][];
+    model: string;
+    memoryFiles: {
+        path: string;
+        type: string;
+        tokens: number;
+    }[];
+    mcpTools: {
+        name: string;
+        serverName: string;
+        tokens: number;
+        isLoaded?: boolean;
+    }[];
+    deferredBuiltinTools?: {
+        name: string;
+        tokens: number;
+        isLoaded: boolean;
+    }[];
+    systemTools?: {
+        name: string;
+        tokens: number;
+    }[];
+    systemPromptSections?: {
+        name: string;
+        tokens: number;
+    }[];
+    agents: {
+        agentType: string;
+        source: string;
+        tokens: number;
+    }[];
+    slashCommands?: {
+        totalCommands: number;
+        includedCommands: number;
+        tokens: number;
+    };
+    skills?: {
+        totalSkills: number;
+        includedSkills: number;
+        tokens: number;
+        skillFrontmatter: {
+            name: string;
+            source: string;
+            tokens: number;
+        }[];
+    };
+    autoCompactThreshold?: number;
+    isAutoCompactEnabled: boolean;
+    messageBreakdown?: {
+        toolCallTokens: number;
+        toolResultTokens: number;
+        attachmentTokens: number;
+        assistantMessageTokens: number;
+        userMessageTokens: number;
+        redirectedContextTokens: number;
+        unattributedTokens: number;
+        toolCallsByType: {
+            name: string;
+            callTokens: number;
+            resultTokens: number;
+        }[];
+        attachmentsByType: {
+            name: string;
+            tokens: number;
+        }[];
+    };
+    apiUsage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_creation_input_tokens: number;
+        cache_read_input_tokens: number;
+    } | null;
+};

package/dist/agent/types/session-types.d.ts

@@ -0,0 +1,134 @@
+import type { AccountInfo, AgentInfo, ApiKeySource, McpServerStatus, ModelInfo, PermissionMode, SDKControlGetContextUsageResponse, SDKStatus, SlashCommand } from './sdk-types.js';
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+import type { AgentModelInput } from './model-types.js';
+import type { InputStreamRef } from './permission-types.js';
+import type { Message, MessageChunk, ResponseMetadata, SendMessageOptions, StructuredMessageOptions } from './message-types.js';
+import type { ProviderCompactResult, ProviderQuery } from '../provider.js';
+import type { HookRegistry } from '../hooks.js';
+import type { ZodType } from 'zod';
+export type SessionState = 'idle' | 'processing' | 'streaming' | 'compacting' | 'closed';
+export interface SessionIdentity {
+    sessionId?: string;
+    configuredSessionId?: string;
+    resume?: string;
+    resumeSessionAt?: string;
+    continue?: boolean;
+    forkSession?: boolean;
+    persistSession: boolean;
+}
+export interface SessionMetadata {
+    sessionId?: string;
+    model?: string;
+    permissionMode?: PermissionMode;
+    cwd?: string;
+    tools?: string[];
+    slashCommands?: string[];
+    skills?: string[];
+    plugins?: Array<{
+        name: string;
+        path: string;
+    }>;
+    mcpServers?: Array<{
+        name: string;
+        status: string;
+    }>;
+    apiKeySource?: ApiKeySource;
+    claudeCodeVersion?: string;
+    outputStyle?: string;
+    status?: SDKStatus;
+}
+export interface PanelSpec {
+    kind: string;
+    title?: string;
+    body: string | string[];
+}
+export type OutputEvent = {
+    type: 'message';
+    message: Message;
+} | {
+    type: 'chunk';
+    chunk: MessageChunk;
+} | {
+    type: 'error';
+    error: Error;
+} | {
+    type: 'done';
+    metadata?: ResponseMetadata;
+} | {
+    type: 'progress';
+    progress: ProgressEvent;
+} | {
+    type: 'suggestion';
+    suggestion: string;
+} | {
+    type: 'stream_retry';
+} | {
+    type: 'panel';
+    spec: PanelSpec;
+} | {
+    type: 'paused';
+    reason: 'usage-limit';
+    resetsAt?: Date;
+    accountId?: string;
+    autoResume?: boolean;
+} | {
+    type: 'resumed';
+    hotSwapped: boolean;
+    accountId?: string;
+};
+export interface ProgressEvent {
+    taskId: string;
+    description: string;
+    summary?: string;
+    lastToolName?: string;
+    totalTokens: number;
+    toolUses: number;
+    durationMs: number;
+}
+export interface SubagentProgressMeta {
+    subagentId: string;
+    parentId?: string;
+    agentType?: string;
+}
+export type SubagentProgressSink = (event: OutputEvent, meta: SubagentProgressMeta) => void;
+export interface RewindFilesResult {
+    canRewind: boolean;
+    error?: string;
+    filesChanged?: string[];
+    insertions?: number;
+    deletions?: number;
+}
+export interface IAgentSession {
+    readonly state: SessionState;
+    readonly sessionId?: string;
+    readonly cwd?: string;
+    readonly hookRegistry?: HookRegistry;
+    sendMessage(content: string, options?: SendMessageOptions): Promise<Message>;
+    sendMessageStream(content: string | ContentBlockParam[]): AsyncIterable<OutputEvent>;
+    sendMessageStructured?<T>(content: string, schema: ZodType<T>, options?: StructuredMessageOptions): Promise<T>;
+    interrupt(): Promise<void>;
+    reset(): Promise<void>;
+    readonly abortSignal: AbortSignal;
+    abort(reason: string): void;
+    setModel(model?: AgentModelInput): Promise<void>;
+    setPermissionMode(mode: PermissionMode): Promise<void>;
+    takePendingPlanExitSeed(): Promise<string | undefined>;
+    waitForInitialization(): Promise<SessionMetadata>;
+    getSessionIdentity(): SessionIdentity;
+    getSessionMetadata(): SessionMetadata;
+    getQuery(): ProviderQuery;
+    getLastResponseMetadata(): ResponseMetadata | null;
+    getOutputStream(): AsyncIterable<OutputEvent>;
+    getInputStreamRef(): Pick<InputStreamRef, 'pushUserMessage'>;
+    supportedCommands(): Promise<SlashCommand[]>;
+    supportedModels(): Promise<ModelInfo[]>;
+    supportedAgents(): Promise<AgentInfo[]>;
+    getContextUsage(): Promise<SDKControlGetContextUsageResponse>;
+    mcpServerStatus(): Promise<McpServerStatus[]>;
+    accountInfo(): Promise<AccountInfo>;
+    rewindFiles?(userMessageId: string, options?: {
+        dryRun?: boolean;
+    }): Promise<RewindFilesResult>;
+    compact(): Promise<ProviderCompactResult>;
+    close(): Promise<void>;
+}

package/dist/agent/types.d.ts

@@ -0,0 +1,6 @@
+export type { AccountInfo, AgentInfo, EffortLevel, McpServerStatus, ModelInfo, OnElicitation, PermissionMode, SDKControlGetContextUsageResponse, SDKStatus, SlashCommand, ThinkingConfig, } from './types/sdk-types.js';
+export type { ClaudeModel, AgentModelInput } from './types/model-types.js';
+export type { CanUseTool, PermissionBubbler, InputStreamRef, } from './types/permission-types.js';
+export type { ToolConfig, AgentConfig, ResumeHistoryTurn } from './types/config-types.js';
+export type { MessageRole, ResponseMetadata, Message, MessageChunk, SendMessageOptions, StructuredMessageOptions, ToolResultChunk, ToolDiffChunk, } from './types/message-types.js';
+export type { SessionState, SessionIdentity, SessionMetadata, OutputEvent, ProgressEvent, SubagentProgressMeta, SubagentProgressSink, RewindFilesResult, IAgentSession, } from './types/session-types.js';

package/dist/agent/usage.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderUsage } from './provider.js';
+export declare function sumProviderUsage(a: ProviderUsage, b: ProviderUsage): ProviderUsage;

package/dist/agent/worktree-sweep.d.ts

@@ -0,0 +1,52 @@
+import { type PresenceRecord } from './awareness/presence.js';
+export type ExecFileFn = (file: string, args: string[], opts?: {
+    cwd?: string;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export interface WorktreeMeta {
+    owner: 'interactive' | 'diagnose' | string;
+    pid?: number;
+    createdAt: string;
+    baseSha?: string;
+    baseBranch?: string;
+}
+export interface WorktreeCandidate {
+    path: string;
+    head?: string;
+    branch?: string;
+    locked: boolean;
+    prunable: boolean;
+    meta?: WorktreeMeta;
+    ageMs: number;
+    isDirty: boolean;
+    commitsAhead: number;
+    ownerLiveness: 'alive' | 'dead' | 'unknown';
+}
+export type WorktreeVerdict = 'empty' | 'stale-clean' | 'stale-dirty' | 'locked' | 'active' | 'orphaned-dir' | 'orphaned-registration' | 'dead-owner';
+export interface SweepOptions {
+    execFile: ExecFileFn;
+    repoRoot: string;
+    dryRun?: boolean;
+    maxAgeDaysClean?: number;
+    maxAgeDaysDirty?: number;
+    scope?: 'interactive' | 'diagnose' | 'all';
+    telemetryPath?: string;
+    lockPath?: string;
+    bypassSoftLaunch?: boolean;
+    readPresence?: () => Promise<PresenceRecord[]>;
+}
+export interface SweepCandidateSummary {
+    path: string;
+    verdict: WorktreeVerdict;
+    owner: 'interactive' | 'diagnose' | 'unknown';
+    ageMs: number;
+}
+export interface SweepResult {
+    removed: string[];
+    warnings: string[];
+    dryRun: boolean;
+    candidates: SweepCandidateSummary[];
+}
+export declare function runSweep(options: SweepOptions): Promise<SweepResult>;

package/dist/agent/worktree.d.ts

@@ -0,0 +1,56 @@
+export declare const MAX_FARM_BRANCHES = 16;
+export declare const FARM_MANIFEST_SCHEMA_VERSION: 3;
+export type WorktreeErrorCode = 'unsupported-schema' | 'not-found' | 'invalid';
+export declare class WorktreeError extends Error {
+    readonly cause?: unknown;
+    readonly code?: WorktreeErrorCode;
+    constructor(message: string, cause?: unknown, code?: WorktreeErrorCode);
+}
+export interface CreatedBranch {
+    index: number;
+    label?: string;
+    path: string;
+    branch: string;
+}
+export interface FarmManifest {
+    schemaVersion: 1 | 2 | 3;
+    taskId: string;
+    taskSlug: string;
+    taskName: string;
+    repoRoot: string;
+    baseRef: string;
+    baseBranch?: string;
+    farmDir: string;
+    createdAt: string;
+    branches: CreatedBranch[];
+    human_decision?: 'approved' | 'rejected' | 'edited_then_merged';
+    decidedAt?: string;
+    memoryFactId?: number;
+    respawnedAt?: string;
+    respawnedAs?: string;
+    prUrl?: string;
+    prCreatedAt?: string;
+}
+export interface CreateFarmOptions {
+    taskName: string;
+    count: number;
+    labels?: string[];
+    cwd?: string;
+    baseRef?: string;
+    taskSlug?: string;
+    now?: () => Date;
+    randomSuffix?: () => string;
+}
+export declare function buildFarmSlug(taskName: string, opts?: {
+    now?: () => Date;
+    randomSuffix?: () => string;
+}): string;
+export declare function createFarm(opts: CreateFarmOptions): Promise<FarmManifest>;
+export declare function loadFarm(taskSlug: string): Promise<FarmManifest | null>;
+export declare function listFarms(): Promise<string[]>;
+export declare function removeBranch(taskSlug: string, index: number): Promise<void>;
+export declare function removeFarm(taskSlug: string): Promise<void>;
+export declare function recordHumanDecision(taskSlug: string, decision: 'approved' | 'rejected' | 'edited_then_merged'): Promise<FarmManifest>;
+export declare function recordRespawn(taskSlug: string, respawnedAs: string): Promise<FarmManifest>;
+export declare function setFarmMemoryFactId(taskSlug: string, factId: number): Promise<FarmManifest>;
+export declare function recordPrCreated(taskSlug: string, prUrl: string): Promise<FarmManifest>;

package/dist/browser/config.d.ts

@@ -0,0 +1,13 @@
+import type { BrowserConfig } from './types.js';
+export interface LoadBrowserConfigOptions {
+    surface?: 'cli' | 'telegram' | 'daemon' | 'interactive' | 'repl' | 'subagent' | string;
+    env?: Record<string, string | undefined>;
+    readFileSync?: (path: string) => string | undefined;
+}
+export declare function loadBrowserConfig(opts?: LoadBrowserConfigOptions): BrowserConfig;
+export declare function enforceDomainPolicy(url: string, config: BrowserConfig): {
+    allowed: true;
+} | {
+    allowed: false;
+    reason: string;
+};

package/dist/browser/playwright/index.d.ts

@@ -0,0 +1,21 @@
+import type { BrowserProvider, OpenOutcome, ActOutcome } from '../provider.js';
+import type { ActInput, BrowserConfig, BrowserProviderState, CloseInput, ExtractInput, ExtractResult, ObserveInput, OpenInput, RenderInput, RenderResult, ScreenshotInput, ScreenshotResult } from '../types.js';
+export declare class PlaywrightProvider implements BrowserProvider {
+    readonly name = "playwright";
+    private readonly config;
+    private readonly launcher;
+    private readonly sessions;
+    constructor(config: BrowserConfig);
+    open(input: OpenInput): Promise<OpenOutcome>;
+    observe(input: ObserveInput): Promise<import('../types.js').BrowserObservation>;
+    act(input: ActInput): Promise<ActOutcome>;
+    render(input: RenderInput): Promise<RenderResult>;
+    screenshot(input: ScreenshotInput): Promise<ScreenshotResult>;
+    extract(_input: ExtractInput): Promise<ExtractResult>;
+    close(input: CloseInput): Promise<void>;
+    describe(sessionId: string): BrowserProviderState | null;
+    shutdown(): Promise<void>;
+    private ensureSessionState;
+    private updateSessionFromObservation;
+    private captureScreenshot;
+}

package/dist/browser/playwright/launcher.d.ts

@@ -0,0 +1,32 @@
+import type { Browser, BrowserContext, Page } from 'playwright';
+import type { BrowserConfig } from '../types.js';
+export declare class BrowserLauncher {
+    private readonly config;
+    private browser;
+    private readonly sessions;
+    private launchPromise;
+    private shutdownComplete;
+    constructor(config: BrowserConfig);
+    ensureBrowser(): Promise<Browser>;
+    isBrowserActive(): boolean;
+    ensureContext(sessionId: string): Promise<BrowserContext>;
+    ensurePage(sessionId: string): Promise<Page>;
+    getPage(sessionId: string): Page | undefined;
+    renderHtml(url: string, opts: {
+        timeoutMs: number;
+        waitUntil: 'load' | 'domcontentloaded' | 'networkidle';
+        signal?: AbortSignal;
+    }): Promise<{
+        html: string;
+        finalUrl: string;
+        httpStatus: number | null;
+    }>;
+    getConsoleErrorCount(sessionId: string): number;
+    getLastHttpStatus(sessionId: string): number | null;
+    hasOpenDialog(sessionId: string): boolean;
+    dismissDialog(sessionId: string, accept?: boolean): Promise<void>;
+    closeSession(sessionId: string): Promise<void>;
+    shutdown(): Promise<void>;
+    activeSessions(): number;
+    private contextOptions;
+}

package/dist/browser/playwright/observe.d.ts

@@ -0,0 +1,12 @@
+import type { Page } from 'playwright';
+import type { BrowserObservation } from '../types.js';
+export interface ObservePageOptions {
+    observationCounter: number;
+    maxElements?: number;
+    includeHidden?: boolean;
+    screenshotPath?: string | null;
+    consoleErrors?: number;
+    httpStatus?: number | null;
+    hasDialog?: boolean;
+}
+export declare function observePage(page: Page, opts: ObservePageOptions): Promise<BrowserObservation>;

package/dist/browser/playwright/resolve-target.d.ts

@@ -0,0 +1,10 @@
+import type { Page, Locator } from 'playwright';
+import type { Target, InteractiveElement, AmbiguousTarget } from '../types.js';
+export type ResolveOutcome = {
+    outcome: 'resolved';
+    locator: Locator;
+} | AmbiguousTarget | {
+    outcome: 'not_found';
+    query: Target;
+};
+export declare function resolveTarget(page: Page, target: Target, knownElements: ReadonlyMap<string, InteractiveElement>): Promise<ResolveOutcome>;

package/dist/browser/provider.d.ts

@@ -0,0 +1,15 @@
+import type { ActInput, AmbiguousTarget, BlockedByPolicy, BrowserObservation, BrowserProviderState, CloseInput, ExtractInput, ExtractResult, ObserveInput, OpenInput, RenderInput, RenderResult, ScreenshotInput, ScreenshotResult } from './types.js';
+export type OpenOutcome = BrowserObservation | BlockedByPolicy;
+export type ActOutcome = BrowserObservation | AmbiguousTarget | BlockedByPolicy;
+export interface BrowserProvider {
+    readonly name: string;
+    open(input: OpenInput): Promise<OpenOutcome>;
+    observe(input: ObserveInput): Promise<BrowserObservation>;
+    act(input: ActInput): Promise<ActOutcome>;
+    render(input: RenderInput): Promise<RenderResult>;
+    screenshot(input: ScreenshotInput): Promise<ScreenshotResult>;
+    extract(input: ExtractInput): Promise<ExtractResult>;
+    close(input: CloseInput): Promise<void>;
+    describe(sessionId: string): BrowserProviderState | null;
+    shutdown(): Promise<void>;
+}

package/dist/browser/registry.d.ts

@@ -0,0 +1,7 @@
+import type { BrowserProvider } from './provider.js';
+import type { LoadBrowserConfigOptions } from './config.js';
+export declare function getBrowserProvider(opts?: LoadBrowserConfigOptions): Promise<BrowserProvider>;
+export declare function closeBrowserProvider(): Promise<void>;
+export declare function browserProviderActive(): boolean;
+export declare function peekBrowserProvider(): BrowserProvider | null;
+export declare function __resetBrowserRegistryForTests(): void;

package/dist/browser/sanitize.d.ts

@@ -0,0 +1,22 @@
+export declare function redactSecrets(input: string): string;
+export interface ElementRedactionInput {
+    role?: string;
+    kind?: string | null;
+    label?: string;
+}
+export declare function shouldRedactElementValue(el: ElementRedactionInput): boolean;
+export declare function hashSelector(selector: string): string;
+export declare function truncateTargetText(text: string): string;
+export interface ObservationSummaryInput {
+    url: string;
+    title: string;
+    interactive: ReadonlyArray<{
+        label: string;
+        role: string;
+    }>;
+    status: {
+        httpStatus: number | null;
+        loadingState: string;
+    };
+}
+export declare function summarizeObservation(obs: ObservationSummaryInput): string;