skykoi 2026.3.21 → 2026.3.23

package/dist/plugin-sdk/auto-reply/send-policy.d.ts

@@ -0,0 +1,6 @@
+export type SendPolicyOverride = "allow" | "deny";
+export declare function normalizeSendPolicyOverride(raw?: string | null): SendPolicyOverride | undefined;
+export declare function parseSendPolicyCommand(raw?: string): {
+    hasCommand: boolean;
+    mode?: SendPolicyOverride | "inherit";
+};

package/dist/plugin-sdk/auto-reply/skill-commands.d.ts

@@ -0,0 +1,18 @@
+import type { SKYKOIConfig } from "../config/config.js";
+import { type SkillCommandSpec } from "../agents/skills.js";
+export declare function listSkillCommandsForWorkspace(params: {
+    workspaceDir: string;
+    cfg: SKYKOIConfig;
+    skillFilter?: string[];
+}): SkillCommandSpec[];
+export declare function listSkillCommandsForAgents(params: {
+    cfg: SKYKOIConfig;
+    agentIds?: string[];
+}): SkillCommandSpec[];
+export declare function resolveSkillCommandInvocation(params: {
+    commandBodyNormalized: string;
+    skillCommands: SkillCommandSpec[];
+}): {
+    command: SkillCommandSpec;
+    args?: string;
+} | null;

package/dist/plugin-sdk/auto-reply/status.d.ts

@@ -0,0 +1,53 @@
+import type { SkillCommandSpec } from "../agents/skills.js";
+import type { SKYKOIConfig } from "../config/config.js";
+import type { MediaUnderstandingDecision } from "../media-understanding/types.js";
+import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "./thinking.js";
+import { type SessionEntry, type SessionScope } from "../config/sessions.js";
+import { formatTokenCount as formatTokenCountShared } from "../utils/usage-format.js";
+type AgentConfig = Partial<NonNullable<NonNullable<SKYKOIConfig["agents"]>["defaults"]>>;
+export declare const formatTokenCount: typeof formatTokenCountShared;
+type QueueStatus = {
+    mode?: string;
+    depth?: number;
+    debounceMs?: number;
+    cap?: number;
+    dropPolicy?: string;
+    showDetails?: boolean;
+};
+type StatusArgs = {
+    config?: SKYKOIConfig;
+    agent: AgentConfig;
+    sessionEntry?: SessionEntry;
+    sessionKey?: string;
+    sessionScope?: SessionScope;
+    groupActivation?: "mention" | "always";
+    resolvedThink?: ThinkLevel;
+    resolvedVerbose?: VerboseLevel;
+    resolvedReasoning?: ReasoningLevel;
+    resolvedElevated?: ElevatedLevel;
+    modelAuth?: string;
+    usageLine?: string;
+    timeLine?: string;
+    queue?: QueueStatus;
+    mediaDecisions?: MediaUnderstandingDecision[];
+    subagentsLine?: string;
+    includeTranscriptUsage?: boolean;
+    now?: number;
+};
+export declare const formatContextUsageShort: (total: number | null | undefined, contextTokens: number | null | undefined) => string;
+export declare function buildStatusMessage(args: StatusArgs): string;
+export declare function buildHelpMessage(cfg?: SKYKOIConfig): string;
+export type CommandsMessageOptions = {
+    page?: number;
+    surface?: string;
+};
+export type CommandsMessageResult = {
+    text: string;
+    totalPages: number;
+    currentPage: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+};
+export declare function buildCommandsMessage(cfg?: SKYKOIConfig, skillCommands?: SkillCommandSpec[], options?: CommandsMessageOptions): string;
+export declare function buildCommandsMessagePaginated(cfg?: SKYKOIConfig, skillCommands?: SkillCommandSpec[], options?: CommandsMessageOptions): CommandsMessageResult;
+export {};

package/dist/plugin-sdk/auto-reply/templating.d.ts

@@ -0,0 +1,140 @@
+import type { ChannelId } from "../channels/plugins/types.js";
+import type { MediaUnderstandingDecision, MediaUnderstandingOutput } from "../media-understanding/types.js";
+import type { StickerMetadata } from "../telegram/bot/types.js";
+import type { InternalMessageChannel } from "../utils/message-channel.js";
+import type { CommandArgs } from "./commands-registry.types.js";
+/** Valid message channels for routing. */
+export type OriginatingChannelType = ChannelId | InternalMessageChannel;
+export type MsgContext = {
+    Body?: string;
+    /**
+     * Agent prompt body (may include envelope/history/context). Prefer this for prompt shaping.
+     * Should use real newlines (`\n`), not escaped `\\n`.
+     */
+    BodyForAgent?: string;
+    /**
+     * Raw message body without structural context (history, sender labels).
+     * Legacy alias for CommandBody. Falls back to Body if not set.
+     */
+    RawBody?: string;
+    /**
+     * Prefer for command detection; RawBody is treated as legacy alias.
+     */
+    CommandBody?: string;
+    /**
+     * Command parsing body. Prefer this over CommandBody/RawBody when set.
+     * Should be the "clean" text (no history/sender context).
+     */
+    BodyForCommands?: string;
+    CommandArgs?: CommandArgs;
+    From?: string;
+    To?: string;
+    SessionKey?: string;
+    /** Provider account id (multi-account). */
+    AccountId?: string;
+    ParentSessionKey?: string;
+    MessageSid?: string;
+    /** Provider-specific full message id when MessageSid is a shortened alias. */
+    MessageSidFull?: string;
+    MessageSids?: string[];
+    MessageSidFirst?: string;
+    MessageSidLast?: string;
+    ReplyToId?: string;
+    /** Provider-specific full reply-to id when ReplyToId is a shortened alias. */
+    ReplyToIdFull?: string;
+    ReplyToBody?: string;
+    ReplyToSender?: string;
+    ReplyToIsQuote?: boolean;
+    ForwardedFrom?: string;
+    ForwardedFromType?: string;
+    ForwardedFromId?: string;
+    ForwardedFromUsername?: string;
+    ForwardedFromTitle?: string;
+    ForwardedFromSignature?: string;
+    ForwardedFromChatType?: string;
+    ForwardedFromMessageId?: number;
+    ForwardedDate?: number;
+    ThreadStarterBody?: string;
+    ThreadLabel?: string;
+    MediaPath?: string;
+    MediaUrl?: string;
+    MediaType?: string;
+    MediaDir?: string;
+    MediaPaths?: string[];
+    MediaUrls?: string[];
+    MediaTypes?: string[];
+    /** Telegram sticker metadata (emoji, set name, file IDs, cached description). */
+    Sticker?: StickerMetadata;
+    OutputDir?: string;
+    OutputBase?: string;
+    /** Remote host for SCP when media lives on a different machine (e.g., SKYKOI@192.168.64.3). */
+    MediaRemoteHost?: string;
+    Transcript?: string;
+    MediaUnderstanding?: MediaUnderstandingOutput[];
+    MediaUnderstandingDecisions?: MediaUnderstandingDecision[];
+    LinkUnderstanding?: string[];
+    Prompt?: string;
+    MaxChars?: number;
+    ChatType?: string;
+    /** Human label for envelope headers (conversation label, not sender). */
+    ConversationLabel?: string;
+    GroupSubject?: string;
+    /** Human label for channel-like group conversations (e.g. #general, #support). */
+    GroupChannel?: string;
+    GroupSpace?: string;
+    GroupMembers?: string;
+    GroupSystemPrompt?: string;
+    /** Untrusted metadata that must not be treated as system instructions. */
+    UntrustedContext?: string[];
+    /** Explicit owner allowlist overrides (trusted, configuration-derived). */
+    OwnerAllowFrom?: Array<string | number>;
+    SenderName?: string;
+    SenderId?: string;
+    SenderUsername?: string;
+    SenderTag?: string;
+    SenderE164?: string;
+    Timestamp?: number;
+    /** Provider label (e.g. whatsapp, telegram). */
+    Provider?: string;
+    /** Provider surface label (e.g. discord, slack). Prefer this over `Provider` when available. */
+    Surface?: string;
+    WasMentioned?: boolean;
+    CommandAuthorized?: boolean;
+    CommandSource?: "text" | "native";
+    CommandTargetSessionKey?: string;
+    /** Gateway client scopes when the message originates from the gateway. */
+    GatewayClientScopes?: string[];
+    /** Thread identifier (Telegram topic id or Matrix thread event id). */
+    MessageThreadId?: string | number;
+    /** Telegram forum supergroup marker. */
+    IsForum?: boolean;
+    /**
+     * Originating channel for reply routing.
+     * When set, replies should be routed back to this provider
+     * instead of using lastChannel from the session.
+     */
+    OriginatingChannel?: OriginatingChannelType;
+    /**
+     * Originating destination for reply routing.
+     * The chat/channel/user ID where the reply should be sent.
+     */
+    OriginatingTo?: string;
+    /**
+     * Messages from hooks to be included in the response.
+     * Used for hook confirmation messages like "Session context saved to memory".
+     */
+    HookMessages?: string[];
+};
+export type FinalizedMsgContext = Omit<MsgContext, "CommandAuthorized"> & {
+    /**
+     * Always set by finalizeInboundContext().
+     * Default-deny: missing/undefined becomes false.
+     */
+    CommandAuthorized: boolean;
+};
+export type TemplateContext = MsgContext & {
+    BodyStripped?: string;
+    SessionId?: string;
+    IsNewSession?: string;
+};
+export declare function applyTemplate(str: string | undefined, ctx: TemplateContext): string;

package/dist/plugin-sdk/auto-reply/thinking.d.ts

@@ -0,0 +1,22 @@
+export type ThinkLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+export type VerboseLevel = "off" | "on" | "full";
+export type NoticeLevel = "off" | "on" | "full";
+export type ElevatedLevel = "off" | "on" | "ask" | "full";
+export type ElevatedMode = "off" | "ask" | "full";
+export type ReasoningLevel = "off" | "on" | "stream";
+export type UsageDisplayLevel = "off" | "tokens" | "full";
+export declare function isBinaryThinkingProvider(provider?: string | null): boolean;
+export declare const XHIGH_MODEL_REFS: readonly ["openai/gpt-5.2", "openai-codex/gpt-5.3-codex", "openai-codex/gpt-5.2-codex", "openai-codex/gpt-5.1-codex"];
+export declare function normalizeThinkLevel(raw?: string | null): ThinkLevel | undefined;
+export declare function supportsXHighThinking(provider?: string | null, model?: string | null): boolean;
+export declare function listThinkingLevels(provider?: string | null, model?: string | null): ThinkLevel[];
+export declare function listThinkingLevelLabels(provider?: string | null, model?: string | null): string[];
+export declare function formatThinkingLevels(provider?: string | null, model?: string | null, separator?: string): string;
+export declare function formatXHighModelHint(): string;
+export declare function normalizeVerboseLevel(raw?: string | null): VerboseLevel | undefined;
+export declare function normalizeNoticeLevel(raw?: string | null): NoticeLevel | undefined;
+export declare function normalizeUsageDisplay(raw?: string | null): UsageDisplayLevel | undefined;
+export declare function resolveResponseUsageMode(raw?: string | null): UsageDisplayLevel;
+export declare function normalizeElevatedLevel(raw?: string | null): ElevatedLevel | undefined;
+export declare function resolveElevatedMode(level?: ElevatedLevel | null): ElevatedMode;
+export declare function normalizeReasoningLevel(raw?: string | null): ReasoningLevel | undefined;

package/dist/plugin-sdk/auto-reply/tokens.d.ts

@@ -0,0 +1,3 @@
+export declare const HEARTBEAT_TOKEN = "HEARTBEAT_OK";
+export declare const SILENT_REPLY_TOKEN = "NO_REPLY";
+export declare function isSilentReplyText(text: string | undefined, token?: string): boolean;

package/dist/plugin-sdk/auto-reply/tool-meta.d.ts

@@ -0,0 +1,8 @@
+type ToolAggregateOptions = {
+    markdown?: boolean;
+};
+export declare function shortenPath(p: string): string;
+export declare function shortenMeta(meta: string): string;
+export declare function formatToolAggregate(toolName?: string, metas?: string[], options?: ToolAggregateOptions): string;
+export declare function formatToolPrefix(toolName?: string, meta?: string): string;
+export {};

package/dist/plugin-sdk/auto-reply/types.d.ts

@@ -0,0 +1,57 @@
+import type { ImageContent } from "@mariozechner/pi-ai";
+import type { TypingController } from "./reply/typing.js";
+export type BlockReplyContext = {
+    abortSignal?: AbortSignal;
+    timeoutMs?: number;
+};
+/** Context passed to onModelSelected callback with actual model used. */
+export type ModelSelectedContext = {
+    provider: string;
+    model: string;
+    thinkLevel: string | undefined;
+};
+export type GetReplyOptions = {
+    /** Override run id for agent events (defaults to random UUID). */
+    runId?: string;
+    /** Abort signal for the underlying agent run. */
+    abortSignal?: AbortSignal;
+    /** Optional inbound images (used for webchat attachments). */
+    images?: ImageContent[];
+    /** Notifies when an agent run actually starts (useful for webchat command handling). */
+    onAgentRunStart?: (runId: string) => void;
+    onReplyStart?: () => Promise<void> | void;
+    /** Called when the typing controller cleans up (e.g., run ended with NO_REPLY). */
+    onTypingCleanup?: () => void;
+    onTypingController?: (typing: TypingController) => void;
+    isHeartbeat?: boolean;
+    onPartialReply?: (payload: ReplyPayload) => Promise<void> | void;
+    onReasoningStream?: (payload: ReplyPayload) => Promise<void> | void;
+    onBlockReply?: (payload: ReplyPayload, context?: BlockReplyContext) => Promise<void> | void;
+    onToolResult?: (payload: ReplyPayload) => Promise<void> | void;
+    /** Called when the actual model is selected (including after fallback).
+     * Use this to get model/provider/thinkLevel for responsePrefix template interpolation. */
+    onModelSelected?: (ctx: ModelSelectedContext) => void;
+    disableBlockStreaming?: boolean;
+    /** Timeout for block reply delivery (ms). */
+    blockReplyTimeoutMs?: number;
+    /** If provided, only load these skills for this session (empty = no skills). */
+    skillFilter?: string[];
+    /** Mutable ref to track if a reply was sent (for Slack "first" threading mode). */
+    hasRepliedRef?: {
+        value: boolean;
+    };
+};
+export type ReplyPayload = {
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    replyToId?: string;
+    replyToTag?: boolean;
+    /** True when [[reply_to_current]] was present but not yet mapped to a message id. */
+    replyToCurrent?: boolean;
+    /** Send audio as voice message (bubble) instead of audio file. Defaults to false. */
+    audioAsVoice?: boolean;
+    isError?: boolean;
+    /** Channel-specific payload data (per-channel envelope). */
+    channelData?: Record<string, unknown>;
+};

package/dist/plugin-sdk/browser/bridge-server.d.ts

@@ -0,0 +1,17 @@
+import type { Server } from "node:http";
+import type { ResolvedBrowserConfig } from "./config.js";
+import { type BrowserServerState, type ProfileContext } from "./server-context.js";
+export type BrowserBridge = {
+    server: Server;
+    port: number;
+    baseUrl: string;
+    state: BrowserServerState;
+};
+export declare function startBrowserBridgeServer(params: {
+    resolved: ResolvedBrowserConfig;
+    host?: string;
+    port?: number;
+    authToken?: string;
+    onEnsureAttachTarget?: (profile: ProfileContext["profile"]) => Promise<void>;
+}): Promise<BrowserBridge>;
+export declare function stopBrowserBridgeServer(server: Server): Promise<void>;

package/dist/plugin-sdk/browser/cdp.d.ts

@@ -0,0 +1,123 @@
+export { appendCdpPath, fetchJson, fetchOk, getHeadersWithAuth } from "./cdp.helpers.js";
+export declare function normalizeCdpWsUrl(wsUrl: string, cdpUrl: string): string;
+export declare function captureScreenshotPng(opts: {
+    wsUrl: string;
+    fullPage?: boolean;
+}): Promise<Buffer>;
+export declare function captureScreenshot(opts: {
+    wsUrl: string;
+    fullPage?: boolean;
+    format?: "png" | "jpeg";
+    quality?: number;
+}): Promise<Buffer>;
+export declare function createTargetViaCdp(opts: {
+    cdpUrl: string;
+    url: string;
+}): Promise<{
+    targetId: string;
+}>;
+export type CdpRemoteObject = {
+    type: string;
+    subtype?: string;
+    value?: unknown;
+    description?: string;
+    unserializableValue?: string;
+    preview?: unknown;
+};
+export type CdpExceptionDetails = {
+    text?: string;
+    lineNumber?: number;
+    columnNumber?: number;
+    exception?: CdpRemoteObject;
+    stackTrace?: unknown;
+};
+export declare function evaluateJavaScript(opts: {
+    wsUrl: string;
+    expression: string;
+    awaitPromise?: boolean;
+    returnByValue?: boolean;
+}): Promise<{
+    result: CdpRemoteObject;
+    exceptionDetails?: CdpExceptionDetails;
+}>;
+export type AriaSnapshotNode = {
+    ref: string;
+    role: string;
+    name: string;
+    value?: string;
+    description?: string;
+    backendDOMNodeId?: number;
+    depth: number;
+};
+export type RawAXNode = {
+    nodeId?: string;
+    role?: {
+        value?: string;
+    };
+    name?: {
+        value?: string;
+    };
+    value?: {
+        value?: string;
+    };
+    description?: {
+        value?: string;
+    };
+    childIds?: string[];
+    backendDOMNodeId?: number;
+};
+export declare function formatAriaSnapshot(nodes: RawAXNode[], limit: number): AriaSnapshotNode[];
+export declare function snapshotAria(opts: {
+    wsUrl: string;
+    limit?: number;
+}): Promise<{
+    nodes: AriaSnapshotNode[];
+}>;
+export declare function snapshotDom(opts: {
+    wsUrl: string;
+    limit?: number;
+    maxTextChars?: number;
+}): Promise<{
+    nodes: DomSnapshotNode[];
+}>;
+export type DomSnapshotNode = {
+    ref: string;
+    parentRef: string | null;
+    depth: number;
+    tag: string;
+    id?: string;
+    className?: string;
+    role?: string;
+    name?: string;
+    text?: string;
+    href?: string;
+    type?: string;
+    value?: string;
+};
+export declare function getDomText(opts: {
+    wsUrl: string;
+    format: "html" | "text";
+    maxChars?: number;
+    selector?: string;
+}): Promise<{
+    text: string;
+}>;
+export declare function querySelector(opts: {
+    wsUrl: string;
+    selector: string;
+    limit?: number;
+    maxTextChars?: number;
+    maxHtmlChars?: number;
+}): Promise<{
+    matches: QueryMatch[];
+}>;
+export type QueryMatch = {
+    index: number;
+    tag: string;
+    id?: string;
+    className?: string;
+    text?: string;
+    value?: string;
+    href?: string;
+    outerHTML?: string;
+};

package/dist/plugin-sdk/browser/cdp.helpers.d.ts

@@ -0,0 +1,11 @@
+export type CdpSendFn = (method: string, params?: Record<string, unknown>) => Promise<unknown>;
+export declare function isLoopbackHost(host: string): boolean;
+export declare function getHeadersWithAuth(url: string, headers?: Record<string, string>): {
+    [x: string]: string;
+};
+export declare function appendCdpPath(cdpUrl: string, path: string): string;
+export declare function fetchJson<T>(url: string, timeoutMs?: number, init?: RequestInit): Promise<T>;
+export declare function fetchOk(url: string, timeoutMs?: number, init?: RequestInit): Promise<void>;
+export declare function withCdpSocket<T>(wsUrl: string, fn: (send: CdpSendFn) => Promise<T>, opts?: {
+    headers?: Record<string, string>;
+}): Promise<T>;

package/dist/plugin-sdk/browser/chrome.d.ts

@@ -0,0 +1,20 @@
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { ResolvedBrowserConfig, ResolvedBrowserProfile } from "./config.js";
+import { type BrowserExecutable } from "./chrome.executables.js";
+export type { BrowserExecutable } from "./chrome.executables.js";
+export { findChromeExecutableLinux, findChromeExecutableMac, findChromeExecutableWindows, resolveBrowserExecutableForPlatform, } from "./chrome.executables.js";
+export { decorateSKYKOIProfile, ensureProfileCleanExit, isProfileDecorated, } from "./chrome.profile-decoration.js";
+export type RunningChrome = {
+    pid: number;
+    exe: BrowserExecutable;
+    userDataDir: string;
+    cdpPort: number;
+    startedAt: number;
+    proc: ChildProcessWithoutNullStreams;
+};
+export declare function resolveSKYKOIUserDataDir(profileName?: string): string;
+export declare function isChromeReachable(cdpUrl: string, timeoutMs?: number): Promise<boolean>;
+export declare function getChromeWebSocketUrl(cdpUrl: string, timeoutMs?: number): Promise<string | null>;
+export declare function isChromeCdpReady(cdpUrl: string, timeoutMs?: number, handshakeTimeoutMs?: number): Promise<boolean>;
+export declare function launchSKYKOIChrome(resolved: ResolvedBrowserConfig, profile: ResolvedBrowserProfile): Promise<RunningChrome>;
+export declare function stopSKYKOIChrome(running: RunningChrome, timeoutMs?: number): Promise<void>;

package/dist/plugin-sdk/browser/chrome.executables.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedBrowserConfig } from "./config.js";
+export type BrowserExecutable = {
+    kind: "brave" | "canary" | "chromium" | "chrome" | "custom" | "edge";
+    path: string;
+};
+export declare function findChromeExecutableMac(): BrowserExecutable | null;
+export declare function findChromeExecutableLinux(): BrowserExecutable | null;
+export declare function findChromeExecutableWindows(): BrowserExecutable | null;
+export declare function resolveBrowserExecutableForPlatform(resolved: ResolvedBrowserConfig, platform: NodeJS.Platform): BrowserExecutable | null;

package/dist/plugin-sdk/browser/chrome.profile-decoration.d.ts

@@ -0,0 +1,10 @@
+export declare function isProfileDecorated(userDataDir: string, desiredName: string, desiredColorHex: string): boolean;
+/**
+ * Best-effort profile decoration (name + brand color). Chrome preference keys
+ * vary by version; we keep this conservative and idempotent.
+ */
+export declare function decorateSKYKOIProfile(userDataDir: string, opts?: {
+    name?: string;
+    color?: string;
+}): void;
+export declare function ensureProfileCleanExit(userDataDir: string): void;

package/dist/plugin-sdk/browser/client-actions-core.d.ts

@@ -0,0 +1,143 @@
+import type { BrowserActionOk, BrowserActionPathResult, BrowserActionTabResult } from "./client-actions-types.js";
+export type BrowserFormField = {
+    ref: string;
+    type: string;
+    value?: string | number | boolean;
+};
+export type BrowserActRequest = {
+    kind: "click";
+    ref: string;
+    targetId?: string;
+    doubleClick?: boolean;
+    button?: string;
+    modifiers?: string[];
+    timeoutMs?: number;
+} | {
+    kind: "type";
+    ref: string;
+    text: string;
+    targetId?: string;
+    submit?: boolean;
+    slowly?: boolean;
+    timeoutMs?: number;
+} | {
+    kind: "press";
+    key: string;
+    targetId?: string;
+    delayMs?: number;
+} | {
+    kind: "hover";
+    ref: string;
+    targetId?: string;
+    timeoutMs?: number;
+} | {
+    kind: "scrollIntoView";
+    ref: string;
+    targetId?: string;
+    timeoutMs?: number;
+} | {
+    kind: "drag";
+    startRef: string;
+    endRef: string;
+    targetId?: string;
+    timeoutMs?: number;
+} | {
+    kind: "select";
+    ref: string;
+    values: string[];
+    targetId?: string;
+    timeoutMs?: number;
+} | {
+    kind: "fill";
+    fields: BrowserFormField[];
+    targetId?: string;
+    timeoutMs?: number;
+} | {
+    kind: "resize";
+    width: number;
+    height: number;
+    targetId?: string;
+} | {
+    kind: "wait";
+    timeMs?: number;
+    text?: string;
+    textGone?: string;
+    selector?: string;
+    url?: string;
+    loadState?: "load" | "domcontentloaded" | "networkidle";
+    fn?: string;
+    targetId?: string;
+    timeoutMs?: number;
+} | {
+    kind: "evaluate";
+    fn: string;
+    ref?: string;
+    targetId?: string;
+} | {
+    kind: "close";
+    targetId?: string;
+};
+export type BrowserActResponse = {
+    ok: true;
+    targetId: string;
+    url?: string;
+    result?: unknown;
+};
+export type BrowserDownloadPayload = {
+    url: string;
+    suggestedFilename: string;
+    path: string;
+};
+export declare function browserNavigate(baseUrl: string | undefined, opts: {
+    url: string;
+    targetId?: string;
+    profile?: string;
+}): Promise<BrowserActionTabResult>;
+export declare function browserArmDialog(baseUrl: string | undefined, opts: {
+    accept: boolean;
+    promptText?: string;
+    targetId?: string;
+    timeoutMs?: number;
+    profile?: string;
+}): Promise<BrowserActionOk>;
+export declare function browserArmFileChooser(baseUrl: string | undefined, opts: {
+    paths: string[];
+    ref?: string;
+    inputRef?: string;
+    element?: string;
+    targetId?: string;
+    timeoutMs?: number;
+    profile?: string;
+}): Promise<BrowserActionOk>;
+export declare function browserWaitForDownload(baseUrl: string | undefined, opts: {
+    path?: string;
+    targetId?: string;
+    timeoutMs?: number;
+    profile?: string;
+}): Promise<{
+    ok: true;
+    targetId: string;
+    download: BrowserDownloadPayload;
+}>;
+export declare function browserDownload(baseUrl: string | undefined, opts: {
+    ref: string;
+    path: string;
+    targetId?: string;
+    timeoutMs?: number;
+    profile?: string;
+}): Promise<{
+    ok: true;
+    targetId: string;
+    download: BrowserDownloadPayload;
+}>;
+export declare function browserAct(baseUrl: string | undefined, req: BrowserActRequest, opts?: {
+    profile?: string;
+}): Promise<BrowserActResponse>;
+export declare function browserScreenshotAction(baseUrl: string | undefined, opts: {
+    targetId?: string;
+    fullPage?: boolean;
+    ref?: string;
+    element?: string;
+    type?: "png" | "jpeg";
+    profile?: string;
+}): Promise<BrowserActionPathResult>;