@hypercli.com/sdk 0.9.1

package/dist/agents.d.ts

@@ -0,0 +1,1452 @@
+declare function preferredWebSocket(): typeof WebSocket;
+export { preferredWebSocket };
+import { type AgentSlot, type AgentSlotInventory, type AgentSlotSize } from './agent-slots.js';
+export { agentSlotFromDict, parseAgentSlotSize, type AgentSlot, type AgentSlotInventory, type AgentSlotSize, } from './agent-slots.js';
+export { parseControlUiAllowedOrigins, } from './openclaw-control-ui-origin.js';
+import { type BuzzActivityHandlers, type BuzzActivityRouteHandlers, type BuzzActivitySubscription } from './buzz-activity.js';
+import { CodingAgentAcpClient, type CodingAgentAcpConnectOptions } from './acp.js';
+import { CodingAgentAcpPool } from './acp-pool.js';
+import { AcpTurnDriver, type AcpTurnDriverOptions } from './acp-driver.js';
+export { CodingAgentAcpClient, CodingAgentAcpConnectionError, CodingAgentAcpRequestError, CodingAgentAcpAttachmentError, CodingAgentAcpUnavailableError, ACP_RECONNECT_DELAYS_MS, type CodingAgentAcpConnectOptions, type CodingAgentAcpStage, type CodingAgentAcpDiagnostic, type CodingAgentAcpDiagnosticError, } from './acp.js';
+export { AcpTurnDriver, type AcpTurnBundle, type AcpTurnDriverOptions, type AcpTurnDriverState, type AcpTurnOutcome, } from './acp-driver.js';
+export { CodingAgentAcpPool, type AcpLease } from './acp-pool.js';
+export { BuzzActivityGapError, BuzzActivityRouteUnavailableError, } from './buzz-activity.js';
+import { APIError } from './errors.js';
+import { HTTPClient, type RequestOverrides } from './http.js';
+export declare const DEFAULT_OPENCLAW_IMAGE = "ghcr.io/hypercli/hypercli-openclaw:prod";
+export declare const DEFAULT_HERMES_AGENT_IMAGE = "ghcr.io/hypercli/hypercli-hermes:latest";
+export declare const DEFAULT_OPENCODE_IMAGE = "ghcr.io/hypercli/hypercli-opencode:latest";
+export declare const DEFAULT_CODEX_IMAGE = "ghcr.io/hypercli/hypercli-codex:latest";
+export declare const DEFAULT_CLAUDE_CODE_IMAGE = "ghcr.io/hypercli/hypercli-claude:latest";
+export declare const DEFAULT_GOOSE_IMAGE = "ghcr.io/hypercli/hypercli-goose:latest";
+export declare const DEFAULT_KIMI_CODE_IMAGE = "ghcr.io/hypercli/hypercli-kimi-code:latest";
+export declare const DEFAULT_PI_IMAGE = "ghcr.io/hypercli/hypercli-pi:latest";
+export declare const DEFAULT_BUZZ_AGENT_IMAGE = "ghcr.io/hypercli/hypercli-buzz-agent:latest";
+export declare const DEFAULT_BUZZ_OPENCODE_IMAGE = "ghcr.io/hypercli/hypercli-opencode:latest";
+export declare const DEFAULT_BUZZ_CODEX_IMAGE = "ghcr.io/hypercli/hypercli-codex:latest";
+export declare const DEFAULT_BUZZ_CLAUDE_CODE_IMAGE = "ghcr.io/hypercli/hypercli-claude:latest";
+export declare const DEFAULT_BUZZ_GOOSE_IMAGE = "ghcr.io/hypercli/hypercli-goose:latest";
+export declare const DEFAULT_BUZZ_KIMI_CODE_IMAGE = "ghcr.io/hypercli/hypercli-kimi-code:latest";
+export declare const DEFAULT_AGENT_RUNTIME_SCOPES: readonly string[];
+export declare const DEFAULT_CODING_AGENT_SYNC_ROOT = "/home/node";
+export declare const MAX_DOCKER_VOLUMES = 64;
+export declare const DEFAULT_PI_ENV: Readonly<{}>;
+export type ManagedAgentRuntime = 'generic' | 'openclaw_acp' | 'hermes_acp' | 'buzz-agent' | 'opencode' | 'codex' | 'claude-code' | 'goose' | 'kimi-code' | 'pi';
+export type CodingAgentRuntime = Extract<ManagedAgentRuntime, 'buzz-agent' | 'opencode' | 'codex' | 'claude-code' | 'goose' | 'kimi-code' | 'pi'>;
+export declare const DEFAULT_CODING_AGENT_IMAGES: Readonly<Record<CodingAgentRuntime, string>>;
+export declare const DEFAULT_CODING_AGENT_SYNC_INCLUDES: Readonly<Record<CodingAgentRuntime, readonly string[] | null>>;
+export declare const DEFAULT_BUZZ_CODING_AGENT_IMAGES: Readonly<Record<CodingAgentRuntime, string>>;
+export declare const DEFAULT_BUZZ_RUST_LOG = "hyper_acp=info,buzz_acp=info,pool::prompt=info,acp::stream=off";
+export declare const OPENCLAW_MEMORY_SEARCH_ENV_DEFAULTS: {
+    readonly OPENCLAW_MEMORY_SEARCH_ENABLED: "1";
+    readonly OPENCLAW_MEMORY_SEARCH_SYNC_ON_SESSION_START: "0";
+    readonly OPENCLAW_MEMORY_SEARCH_SYNC_ON_SEARCH: "0";
+    readonly OPENCLAW_MEMORY_SEARCH_SYNC_WATCH: "0";
+    readonly OPENCLAW_MEMORY_SEARCH_SYNC_WATCH_DEBOUNCE_MS: "30000";
+    readonly OPENCLAW_MEMORY_SEARCH_SYNC_INTERVAL_MINUTES: "0";
+};
+export declare const WORKSPACES_SYNC_ENV_DEFAULTS: {
+    readonly HYPER_WORKSPACES_BOOT_SYNC: "1";
+    readonly HYPER_WORKSPACES_DIR: "/home/node/shared";
+    readonly HYPER_WORKSPACES_SYNC_READY_ONLY: "1";
+};
+export declare const OPENCLAW_CRON_ENV_DEFAULTS: {
+    readonly OPENCLAW_CRON_ENABLED: "1";
+};
+export declare const HERMES_CRON_ENV_DEFAULTS: {
+    readonly HERMES_CRON_ENABLED: "1";
+};
+export declare const DEFAULT_HERMES_AGENT_SYNC_ROOT = "/home/hermes";
+export declare const DEFAULT_HERMES_AGENT_SYNC_EXCLUDE: readonly ["shared/**"];
+export declare const DEFAULT_HERMES_AGENT_SYNC_UID = 10000;
+export declare const DEFAULT_HERMES_AGENT_SYNC_GID = 10000;
+export declare const AGENT_FILE_MAX_BYTES: number;
+export declare const AGENT_FILE_WRITE_MAX_BYTES: number;
+export declare const AGENT_FILE_TRANSFER_CHUNK_BYTES: number;
+export declare const AGENT_FILE_OPERATION_TIMEOUT_MS = 300000;
+export interface AgentExecResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+/** Buffered exec stdin cap, mirrored by the backend exec protocol. */
+export declare const AGENT_EXEC_STDIN_MAX_BYTES = 262144;
+export interface AgentMetricsResult {
+    event: 'agent_metrics_result';
+    ok: true;
+    cpu: string;
+    memory: string;
+    timestamp: number;
+}
+export interface AgentOperationTokenResponse {
+    agent_id: string;
+    token: string;
+    expires_at: string;
+    ws_url: string;
+}
+export interface AgentTokenResponse {
+    agent_id?: string;
+    token: string;
+    expires_at?: string | null;
+    desktop_viewport?: {
+        width: number;
+        height: number;
+    } | null;
+}
+export interface BrowserDesktopUrlOptions {
+    redirect?: string | null;
+    resize?: string | null;
+}
+export interface AgentEnvResponse {
+    agent_id: string;
+    env: Record<string, string>;
+    launch_epoch: number;
+}
+/** Minimal response from mutating one stored launch-environment key. */
+export interface AgentEnvMutationResponse {
+    agent_id: string;
+    key: string;
+    present: boolean;
+    launch_epoch: number;
+}
+/** Minimal response from mutating one stored launch secret; values are never returned. */
+export type AgentSecretMutationResponse = AgentEnvMutationResponse;
+export interface AgentSecretNamesResponse {
+    agent_id: string;
+    names: string[];
+    launch_epoch: number;
+}
+export interface AgentSecretResponse {
+    agent_id: string;
+    key: string;
+    value: string;
+    launch_epoch: number;
+}
+export interface AgentShellTokenResponse {
+    agent_id: string;
+    token: string;
+    expires_at: string;
+    ws_url: string;
+    shell: string;
+}
+export interface AgentShellConnectOptions {
+    signal?: AbortSignal;
+    tokenTimeoutMs?: number;
+    openTimeoutMs?: number;
+}
+export interface AgentLogsTokenResponse {
+    agent_id?: string;
+    token: string;
+    expires_at?: string | null;
+    ws_url?: string;
+}
+/** Captured runner-file provenance, matching AssignmentLogResult's product projection. */
+export interface AgentLogCapture {
+    assignment_id: string;
+    source: 'stdout' | 'stderr';
+    generation: 'current' | 'previous';
+    file_generation: string | null;
+    launch_epoch: number | null;
+    /** Exact bytes. Empty string is an available empty file; null is unavailable. */
+    content_base64: string | null;
+    truncated: boolean;
+    unavailable: 'unavailable' | 'not_supported' | 'invalid_limit' | 'io_error' | null;
+    capture: {
+        state: 'unknown' | 'capturing' | 'complete' | 'unavailable';
+        dropped_bytes: number;
+    } | null;
+    diagnostics_dropped: number;
+    runner_version: string;
+    runner_revision: string | null;
+    executable_sha256: string | null;
+}
+export interface AgentCapturedLogsSnapshot {
+    agent_id: string;
+    transport: 'runner';
+    /** Lossy UTF-8 display projection, stdout then stderr; not chronological merging. */
+    logs: string | null;
+    unavailable: AgentLogCapture['unavailable'] | 'unsupported' | 'offline' | 'timeout' | 'busy';
+    captures: AgentLogCapture[];
+}
+export interface AgentCapturedLogsEvent extends AgentCapturedLogsSnapshot {
+    event: 'captured_logs';
+}
+export type AgentLogsResponse = {
+    agent_id: string;
+    logs: string;
+    transport?: undefined;
+} | AgentCapturedLogsSnapshot;
+export interface AgentLogsReadOptions {
+    source?: 'both' | 'stdout' | 'stderr';
+    generation?: 'current' | 'previous';
+    /** Per-source bound, 1..65536. Omitted uses the backend default. */
+    maxBytes?: number;
+    /** Per-source bound, 1..1000. Omitted uses the backend default. */
+    maxLines?: number;
+}
+export declare class AgentCapturedLogsError extends APIError {
+    readonly snapshot: AgentCapturedLogsSnapshot;
+    constructor(error: APIError, snapshot: AgentCapturedLogsSnapshot);
+}
+/**
+ * One decoded frame from the agent logs WebSocket.
+ *
+ * The socket opens with the replayed history as `log` frames, sends
+ * `history_end` once replay is complete, then streams live `log` frames. A
+ * frame that is not a recognisable envelope degrades to a log line rather than
+ * vanishing, so a pre-envelope or plain-text server stays readable. Unknown
+ * envelope events are ignored so future control frames never reach the log view.
+ */
+export type AgentLogFrame = {
+    kind: 'log';
+    line: string;
+} | {
+    kind: 'capturedLogs';
+    snapshot: AgentCapturedLogsEvent;
+} | {
+    kind: 'historyEnd';
+} | {
+    kind: 'error';
+    detail: string;
+} | {
+    kind: 'ignore';
+};
+export declare function parseAgentLogFrame(raw: string): AgentLogFrame;
+export interface AgentLogsConnectOptions extends AgentLogsReadOptions {
+    /** Historical lines to replay before live frames. 0 replays the whole buffer. */
+    tailLines?: number;
+    container?: string;
+    signal?: AbortSignal;
+}
+export interface AgentLogsSubscribeOptions extends AgentLogsConnectOptions {
+    /** Runs after socket authentication and before any frame is read. */
+    onReady?: () => void | Promise<void>;
+    /** Runs once replay is complete, before any live frame is delivered. */
+    onHistoryEnd?: () => void | Promise<void>;
+    /** Replace the captured-tail view. Never append these overlapping snapshots as lines. */
+    onCapturedLogs?: (snapshot: AgentCapturedLogsEvent) => void | Promise<void>;
+    /**
+     * Runs when the peer closes the socket, carrying the close code. Reconnect
+     * policy lives with the caller, so the caller needs the code that decides it:
+     * an auth-scoped close must not be retried, a transport drop may be.
+     */
+    onClose?: (event: {
+        code: number;
+        reason: string;
+    }) => void;
+    /**
+     * Keep the socket open after replay. With `follow: false` the returned
+     * promise resolves at `history_end` or after the first captured snapshot:
+     * its socket is snapshot-then-silence and would otherwise hang.
+     */
+    follow?: boolean;
+}
+export interface AgentRelayKey {
+    key_id?: string | null;
+    key_name?: string | null;
+    tags?: string[];
+    api_key?: string | null;
+    api_key_preview?: string | null;
+    last4?: string | null;
+    [key: string]: any;
+}
+export interface AgentProfileImageUploadResult {
+    id: string;
+    avatar_url: string | null;
+    s3_key: string | null;
+}
+export interface ListAgentsOptions extends RequestOverrides {
+    state?: string | null;
+    handle?: string | null;
+    name?: string | null;
+    query?: string | null;
+    includeDeleted?: boolean | null;
+}
+export interface AgentCapacity {
+    items: Agent[];
+    totalAgents: number;
+    maxAgentsPerAccount: number;
+    runningAgents: number;
+    slots: Record<string, AgentSlotInventory>;
+    agentSlots: AgentSlot[];
+    pooledTpd: number;
+}
+export interface SlackOAuthStartOptions {
+    relayBaseUrl: string;
+    token: string;
+}
+export interface SlackOAuthStartResult {
+    authorizeUrl: string;
+    expiresAt?: string | null;
+}
+export interface SlackInstallStatusOptions {
+    relayBaseUrl: string;
+    token: string;
+}
+export interface SlackInstallStatus {
+    connected: boolean;
+    teamId?: string | null;
+    teamName?: string | null;
+    botUserId?: string | null;
+    installerUserId?: string | null;
+    updatedAt?: string | null;
+}
+export interface SlackDirectoryOptions {
+    relayBaseUrl: string;
+    token: string;
+    cursor?: string | null;
+    limit?: number | null;
+}
+export interface SlackDirectoryConversationsOptions extends SlackDirectoryOptions {
+    types?: string | null;
+}
+export interface SlackDirectoryConversation {
+    id: string;
+    name?: string | null;
+    isChannel?: boolean | null;
+    isGroup?: boolean | null;
+    isIm?: boolean | null;
+    isMpim?: boolean | null;
+    isMember?: boolean | null;
+    isPrivate?: boolean | null;
+}
+export interface SlackDirectoryUser {
+    id: string;
+    name?: string | null;
+    realName?: string | null;
+    teamId?: string | null;
+    isBot?: boolean | null;
+    deleted?: boolean | null;
+}
+export interface SlackDirectoryConversationsResult {
+    conversations: SlackDirectoryConversation[];
+    nextCursor?: string | null;
+}
+export interface SlackDirectoryUsersResult {
+    users: SlackDirectoryUser[];
+    nextCursor?: string | null;
+}
+export interface AttachSlackRelayAgentOptions {
+    relayBaseUrl: string;
+    token: string;
+    agentId: string;
+}
+export interface AttachSlackRelayAgentResult {
+    connected: boolean;
+    agentId: string;
+    gatewayId: string;
+    restartRequired: boolean;
+    teamId?: string | null;
+    teamName?: string | null;
+    botUserId?: string | null;
+}
+export interface AttachDeploymentSlackRelayAgentOptions {
+    relayBaseUrl: string;
+    token?: string;
+}
+export interface BraveWebSearchOptions {
+    count?: number;
+    country?: string;
+    searchLang?: string;
+    uiLang?: string;
+    freshness?: string;
+}
+export interface BraveWebSearchResponse {
+    query?: Record<string, any>;
+    web?: {
+        results?: Array<Record<string, any>>;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface AgentRouteConfig {
+    port: number;
+    prefix?: string;
+    auth?: boolean;
+    /** Request headers to remove before forwarding upstream. */
+    remove_headers?: string[];
+}
+export interface AgentCorsConfig {
+    allowed_origins: string[];
+    allow_credentials?: boolean;
+    allowed_headers?: string[];
+    allowed_methods?: string[];
+    max_age?: number;
+}
+export interface AgentRoutesState {
+    agentId: string;
+    routes: Record<string, AgentRouteConfig>;
+    cors: AgentCorsConfig | null;
+    routeStatuses: Record<string, Record<string, unknown>>;
+}
+export interface SetRoutesOptions {
+    cors?: AgentCorsConfig | null;
+}
+/**
+ * What the presented credential is, as the Backend resolves it.
+ *
+ * `agentId` is set only for an Agent runtime key, which speaks for exactly one
+ * Agent; it is null for an owner user credential or any other key.
+ */
+export interface AgentAccessIdentity {
+    userId: string;
+    authType: string;
+    /** The one Agent a runtime key speaks for; null for every other credential. */
+    agentId: string | null;
+    tags: string[];
+    capabilities: string[];
+    keyId: string | null;
+    keyName: string | null;
+    teamId: string | null;
+    planId: string | null;
+    /** True when this credential is one Agent's own runtime key. */
+    isAgentRuntimeKey: boolean;
+}
+export type LaunchConfigFlatMap = Record<string, unknown>;
+export interface AgentDesktopConfigSource {
+    launchConfig?: unknown;
+    launch_config?: unknown;
+    routes?: unknown;
+}
+export interface RegistryAuth {
+    username: string;
+    password: string;
+}
+/** Runner-docker launch options; bind mounts use Compose short syntax (`source:target[:ro]`). */
+export interface AgentDockerOptions {
+    volumes?: string[];
+}
+/** Runner executor; required for runner-placed agents, forbidden for hosted agents. */
+export type AgentExecutor = 'process' | 'docker';
+/** Complete Backend launch_config replacement contract. */
+export interface AgentLaunchConfig {
+    config?: Record<string, any>;
+    image: string | null;
+    env: Record<string, string>;
+    secrets: Record<string, string>;
+    routes: Record<string, AgentRouteConfig>;
+    cors?: AgentCorsConfig | null;
+    command: string[];
+    entrypoint: string[];
+    restart: boolean;
+    sync_root: string | null;
+    sync_include?: string[] | null;
+    sync_exclude?: string[] | null;
+    sync_uid: number | null;
+    sync_gid: number | null;
+    registry_url: string | null;
+    registry_auth: RegistryAuth | Record<string, never>;
+    runtime_scopes: string[];
+    executor?: AgentExecutor;
+    /** Retained Runner workspace; resolved on the Runner host. */
+    cwd?: string | null;
+    docker?: AgentDockerOptions | null;
+}
+export interface BuildAgentConfigOptions {
+    /** Absolute Runner-host workspace. Omission selects the Runner OS owner's home. */
+    cwd?: string | null;
+    env?: Record<string, string>;
+    secrets?: Record<string, string>;
+    routes?: Record<string, AgentRouteConfig> | null;
+    command?: string[] | null;
+    entrypoint?: string[] | null;
+    image?: string | null;
+    /** Absolute runtime mount path for retained PVC storage. */
+    syncRoot?: string | null;
+    /**
+     * Relative paths selected for steady upload and cold restore. Must contain at
+     * least one path when supplied; null selects the whole sync root.
+     */
+    syncInclude?: readonly string[] | null;
+    /**
+     * Relative patterns excluded from whole-root mode. An empty array excludes
+     * nothing. Ignored when a non-null include policy is supplied.
+     */
+    syncExclude?: readonly string[] | null;
+    syncUid?: number | null;
+    syncGid?: number | null;
+    registryUrl?: string | null;
+    registryAuth?: RegistryAuth | null;
+    /** Route-plane CORS policy reconciled onto the agent's public routes. */
+    cors?: AgentCorsConfig | null;
+    restart?: boolean;
+    runtimeScopes?: readonly string[] | null;
+    /** Runner executor (process runs the command on the runner host, docker runs the image). */
+    executor?: AgentExecutor;
+    /** Runner-docker launch options (Compose-shape bind volumes); runner placements only. */
+    docker?: AgentDockerOptions | null;
+}
+export interface OpenClawRouteOptions {
+    includeDesktop?: boolean;
+    desktopPort?: number;
+    desktopAuth?: boolean;
+    desktopPrefix?: string;
+}
+export declare const OPENCLAW_TRUSTED_PROXIES_ENV = "OPENCLAW_TRUSTED_PROXIES";
+export declare function buildOpenClawTrustedProxiesEnv(trustedProxies: readonly string[] | null | undefined): Record<string, string>;
+export interface OpenClawMemoryIndexOptions {
+    enabled?: boolean | null;
+    onSessionStart?: boolean | null;
+    onSearch?: boolean | null;
+    watch?: boolean | null;
+    watchDebounceMs?: number | null;
+    intervalMinutes?: number | null;
+}
+export interface WorkspacesSyncOptions {
+    enabled?: boolean | null;
+    readyOnly?: boolean | null;
+    workspace?: string | null;
+}
+export interface OpenClawHeartbeatConfig {
+    every?: string;
+    model?: string;
+    session?: string;
+    target?: string;
+    directPolicy?: 'allow' | 'block';
+    to?: string;
+    accountId?: string;
+    prompt?: string;
+    includeSystemPromptSection?: boolean;
+    ackMaxChars?: number;
+    suppressToolErrorWarnings?: boolean;
+    timeoutSeconds?: number;
+    lightContext?: boolean;
+    isolatedSession?: boolean;
+    includeReasoning?: boolean;
+    activeHours?: Record<string, any>;
+    [key: string]: any;
+}
+export interface AgentUiAvatarMeta {
+    image?: string | null;
+    icon_index?: number | null;
+}
+export interface AgentUiMeta {
+    description?: string | null;
+    avatar?: AgentUiAvatarMeta | null;
+}
+/**
+ * Per-provider integration toggle stored under meta.integrations; semantics
+ * per the backend model (agents/backend/agents/launch_contract.py
+ * AgentIntegrationMeta): enabled ?? true, `enabled: null` on write unsets.
+ */
+export interface AgentIntegrationMeta {
+    enabled?: boolean | null;
+}
+export interface AgentMeta {
+    ui?: AgentUiMeta | null;
+    status?: DeploymentMetaStatus | null;
+    integrations?: Record<string, AgentIntegrationMeta> | null;
+    [key: string]: any;
+}
+export type OpenClawModelApi = 'openai-completions' | 'openai-responses' | 'openai-codex-responses' | 'anthropic-messages' | 'google-generative-ai' | 'github-copilot' | 'bedrock-converse-stream' | 'ollama';
+export type OpenClawModelProviderAuthMode = 'api-key' | 'aws-sdk' | 'oauth' | 'token';
+export type OpenClawSecretInput = string | {
+    source?: string;
+    provider?: string;
+    id?: string;
+    [key: string]: any;
+};
+export interface OpenClawModelCompatConfig {
+    thinkingFormat?: string;
+    supportsTools?: boolean;
+    toolSchemaProfile?: string;
+    nativeWebSearchTool?: boolean;
+    toolCallArgumentsEncoding?: string;
+    requiresMistralToolIds?: boolean;
+    requiresOpenAiAnthropicToolPayload?: boolean;
+    [key: string]: any;
+}
+export interface OpenClawModelDefinitionConfig {
+    id: string;
+    name?: string;
+    api?: OpenClawModelApi;
+    reasoning?: boolean;
+    input?: Array<'text' | 'image'>;
+    cost?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        [key: string]: any;
+    };
+    contextWindow?: number;
+    maxTokens?: number;
+    headers?: Record<string, string>;
+    compat?: OpenClawModelCompatConfig;
+    [key: string]: any;
+}
+export interface OpenClawModelProviderConfig {
+    baseUrl: string;
+    apiKey?: OpenClawSecretInput;
+    auth?: OpenClawModelProviderAuthMode;
+    api?: OpenClawModelApi;
+    injectNumCtxForOpenAICompat?: boolean;
+    headers?: Record<string, OpenClawSecretInput>;
+    authHeader?: boolean;
+    models?: OpenClawModelDefinitionConfig[];
+    [key: string]: any;
+}
+export type OpenClawModelProviderPatch = Partial<Omit<OpenClawModelProviderConfig, 'baseUrl'>> & Pick<OpenClawModelProviderConfig, 'baseUrl'>;
+/**
+ * Self-hosted runner placement for POST /deployments
+ * (monorepo acp/hyper-runner/RUNNER.md). Tags match runner tags for the same owner;
+ * runnerId pins one runner when tags are ambiguous.
+ */
+export interface RunnerTargetOptions {
+    tags?: string[];
+    runnerId?: string | null;
+}
+export interface CreateAgentOptions extends BuildAgentConfigOptions {
+    name?: string;
+    handle?: string | null;
+    size?: string;
+    config?: Record<string, any>;
+    meta?: AgentMeta | null;
+    tags?: string[];
+    runner?: RunnerTargetOptions | null;
+    dryRun?: boolean;
+    runtime?: ManagedAgentRuntime;
+}
+export interface StartAgentOptions {
+    dryRun?: boolean;
+}
+/**
+ * Options for the deployment lifecycle actions stop, archive, restore, and
+ * delete. Mirrors the Backend's LifecycleActionRequest (extra="forbid").
+ */
+export interface LifecycleActionOptions {
+    /**
+     * Validate the action only. The Backend returns the current Agent record
+     * unchanged -- nothing mutates and the state stays as it was (the Agent is
+     * not stopped, archived, restored, or deleted).
+     */
+    dryRun?: boolean;
+}
+export interface UpdateAgentOptions {
+    ui?: Pick<AgentUiMeta, 'description'>;
+    name?: string;
+    handle?: string | null;
+    size?: string;
+    launchConfig?: Record<string, any> | null;
+    /** Runtime family label; re-labeling is allowed at any time. */
+    runtime?: ManagedAgentRuntime;
+    /** Replace the stored launch image with the platform default for the (new or current) runtime on next start. Requires the agent stopped. */
+    resetImage?: boolean;
+    /**
+     * Per-provider integration overrides (meta.integrations): shallow-merged
+     * per provider; `enabled: null` removes the provider key (unset → default
+     * enabled). See {@link AgentIntegrationMeta} for the effective semantics.
+     */
+    integrations?: Record<string, AgentIntegrationMeta>;
+    /** @deprecated Not accepted by the backend (UpdateAgentRequest is extra="forbid"); ignored. */
+    refreshFromLagoon?: boolean;
+    /** @deprecated Not accepted by the backend (UpdateAgentRequest is extra="forbid"); ignored. */
+    error?: string | null;
+}
+export interface ResetRuntimeDefaultsOptions {
+    runtime: ManagedAgentRuntime;
+}
+export interface ResetRuntimeDefaultsResult {
+    agent: Agent;
+    droppedLaunchKeys: string[];
+}
+/**
+ * Folded create options for {@link Deployments.createAgent}: the generic
+ * launch contract plus every per-runtime facade knob
+ * (openClawRoutes/trustedProxies/cronEnabled/memoryIndex/
+ * workspacesSync/permissionMode/buzz). A runtime's
+ * own launch branch reads the knobs it understands and ignores the rest,
+ * exactly as the old per-runtime facades ignored fields outside their type.
+ *
+ * There is no Slack knob: hosted Slack is relay-attached after create
+ * (`attachSlackRelayAgent`); the agents never dial a channel relay, so no
+ * Slack launch env exists to set here.
+ */
+export interface ManagedAgentCreateOptions extends CreateAgentOptions {
+    openClawRoutes?: OpenClawRouteOptions | null;
+    /** Trusted proxies written as OPENCLAW_TRUSTED_PROXIES, replacing gateway.trustedProxies. */
+    trustedProxies?: string[] | null;
+    cronEnabled?: boolean | null;
+    memoryIndex?: OpenClawMemoryIndexOptions | null;
+    workspacesSync?: WorkspacesSyncOptions | boolean | null;
+    /**
+     * @deprecated Launch permission presets are rejected. Select an advertised
+     * native session configuration instead.
+     */
+    permissionMode?: string;
+    /** @deprecated Use the typed `buzz` launch contract. */
+    buzzEnabled?: boolean;
+    /** Launch Buzz ACP with runtime-specific harness and MCP defaults. */
+    buzz?: BuzzLaunchConfig | null;
+}
+/** @deprecated Use `ManagedAgentCreateOptions` with `Deployments.createAgent(runtime, options)`. */
+export type CodingAgentCreateOptions = Omit<ManagedAgentCreateOptions, 'runtime'>;
+export interface BuzzLaunchConfig {
+    privateKeyNsec: string;
+    relayUrl: string;
+    authTag?: string | null;
+    model?: string | null;
+    respondTo?: string | null;
+    respondToAllowlist?: string[];
+    rustLog?: string;
+}
+/** Construct the Buzz-owned launch fields for create or a stopped deployment update.
+ * Callers retain all other stored launch fields. No network or identity generation.
+ */
+export declare function buildBuzzLaunchConfig(runtime: CodingAgentRuntime, buzz: BuzzLaunchConfig | null, apiBase: string, stored?: Record<string, any>): Record<string, any>;
+/** Whether the runtime has a Buzz coding harness launch mapping. */
+export declare function supportsBuzzRuntime(runtime: string | null | undefined): runtime is CodingAgentRuntime;
+export interface RuntimeAuthMethod {
+    id: string;
+    name: string;
+    description: string;
+    kind: string;
+    command: string[];
+    metadata: Record<string, unknown>;
+}
+export interface RuntimeAuthStatus {
+    authenticated: boolean;
+    provider?: string | null;
+    account?: string | null;
+    method?: string | null;
+    detail: Record<string, unknown>;
+}
+export interface RuntimeAuthLoginOptions {
+    method?: string;
+    provider?: string;
+    providerMethod?: string;
+    email?: string;
+    challengeTimeoutMs?: number;
+}
+export interface AgentExecOptions {
+    timeout?: number;
+    dryRun?: boolean;
+    /**
+     * Optional buffered stdin delivered to the command, then closed (stdin EOF).
+     * Omit on interactive callers; the pod command sees stdin attached only
+     * when this is set.
+     */
+    stdin?: string | Uint8Array;
+}
+export interface AgentFileEntry {
+    name: string;
+    path: string;
+    type: 'file' | 'directory';
+    size?: number;
+    size_formatted?: string;
+    mime_type?: string;
+    mimeType?: string;
+    content_type?: string;
+    contentType?: string;
+    last_modified?: string;
+    checksum?: string;
+    checksum_algorithm?: string;
+    checksumAlgorithm?: string;
+    hash?: string;
+    hash_algorithm?: string;
+    hashAlgorithm?: string;
+    sha256?: string;
+    sha_256?: string;
+    md5?: string;
+    etag?: string;
+    version_id?: string;
+    versionId?: string;
+    [key: string]: any;
+}
+export interface AgentFileReadOptions {
+    maxBytes?: number;
+    signal?: AbortSignal;
+}
+/** Tuning for {@link Deployments.waitForFileApiReady}. */
+export interface AgentFileApiReadyOptions {
+    /** Give up after this long. Default 90s. */
+    timeoutMs?: number;
+    /** Successful reads required in a row before declaring ready. Default 2. */
+    consecutive?: number;
+    /** Delay between attempts. Default 1s. */
+    pollMs?: number;
+}
+export interface AgentFileReadBytesResult {
+    content: Uint8Array;
+    mimeType?: string;
+}
+export interface AgentFileTokenResponse {
+    url: string;
+    token: string;
+    expires_at: string;
+}
+/** Maximum decoded bytes for the native runner file transport. */
+export declare const RUNNER_FILE_MAX_BYTES: number;
+/** Backend-discovered file access scoped to an agent's retained storage root. */
+export declare class AgentFiles {
+    private readonly agent;
+    private readonly deployments;
+    constructor(agent: Agent, deployments: Deployments);
+    list(path?: string): Promise<AgentFileEntry[]>;
+    readBytes(path: string, options?: AgentFileReadOptions): Promise<Uint8Array>;
+    readBytesWithMetadata(path: string, options?: AgentFileReadOptions): Promise<AgentFileReadBytesResult>;
+    read(path: string, options?: AgentFileReadOptions): Promise<string>;
+    writeBytes(path: string, content: Uint8Array | ArrayBuffer | string, options?: {
+        signal?: AbortSignal;
+    }): Promise<Record<string, any>>;
+    write(path: string, content: string): Promise<Record<string, any>>;
+    delete(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<Record<string, any>>;
+}
+export interface AgentDirectoryListing {
+    type: 'directory';
+    prefix: string;
+    directories: AgentFileEntry[];
+    files: AgentFileEntry[];
+    truncated?: boolean;
+    [key: string]: any;
+}
+export type AgentState = 'CREATING' | 'STARTING' | 'RESTORING' | 'RUNNING' | 'STOPPING' | 'STOPPED' | 'ARCHIVING' | 'ARCHIVED' | 'FAILED' | 'NO_NAMESPACE' | 'DELETED' | (string & {});
+/** Canonical states understood by this SDK. AgentState remains forward-open. */
+export declare const CANONICAL_AGENT_STATES: readonly ["CREATING", "STARTING", "RESTORING", "RUNNING", "STOPPING", "STOPPED", "ARCHIVING", "ARCHIVED", "FAILED", "NO_NAMESPACE", "DELETED"];
+export declare const AGENT_TRANSITIONAL_STATES: ReadonlySet<AgentState>;
+export declare const AGENT_RUNTIME_INACTIVE_STATES: ReadonlySet<AgentState>;
+export declare function isAgentTransitionalState(state: string): boolean;
+export declare function isAgentRuntimeInactiveState(state: string): boolean;
+export type DeploymentMetaObservedState = 'RUNNING' | 'STOPPED';
+export interface DeploymentMetaStatus {
+    status: 'ok' | 'error' | string;
+    clusterId: string | null;
+    namespace: string | null;
+    observedState: DeploymentMetaObservedState | null;
+    reason: string | null;
+    message: string | null;
+    observedAt: string | null;
+}
+export interface DeploymentTransitionEvent {
+    type: 'deployment.transition';
+    agent_id: string;
+    state?: AgentState;
+    reason?: string | null;
+    error?: string | null;
+    message?: string | null;
+}
+export interface DeploymentImportStatusEvent {
+    type: 'deployment.import_status';
+    agent_id: string;
+    status: 'ok' | 'error' | string;
+    namespace: string;
+    observed_state?: AgentState | null;
+    reason?: string | null;
+    message?: string | null;
+    observed_at: string;
+}
+export interface RunnerPresenceEvent {
+    type: 'runner.presence';
+    runner_id: string;
+    presence: 'connected' | 'disconnected' | 'registered' | 'deregistered';
+    at: string;
+}
+export type DeploymentEvent = DeploymentTransitionEvent | DeploymentImportStatusEvent | RunnerPresenceEvent | import('./sessions.js').SessionReactionOperation;
+export interface DeploymentSubscribeOptions {
+    signal?: AbortSignal;
+    /** Runs after socket authentication and before transition frames are read. */
+    onReady?: () => void | Promise<void>;
+}
+export interface AgentStateFields {
+    id: string;
+    userId: string;
+    state: AgentState;
+    name?: string | null;
+    handle?: string | null;
+    displayName?: string | null;
+    avatarUrl?: string | null;
+    avatarAudioUrl?: string | null;
+    displayIdentity?: Record<string, any> | null;
+    runtime?: string | null;
+    managed?: boolean | null;
+    isLaunchable?: boolean;
+    gatewayId?: string | null;
+    relayKey?: AgentRelayKey | null;
+    cpu: number;
+    memory: number;
+    requestedSize?: AgentSlotSize | null;
+    hostname?: string | null;
+    tags?: string[];
+    jwtToken?: string | null;
+    jwtExpiresAt?: Date | null;
+    startedAt?: Date | null;
+    stoppedAt?: Date | null;
+    archivedAt?: Date | null;
+    archivePrefix?: string | null;
+    deletedAt?: Date | null;
+    disconnectedAt?: Date | null;
+    agentSlotId?: string | null;
+    clusterId?: string | null;
+    /** Pinned self-hosted runner placement, when the Agent deployment is runner-bound. */
+    runner?: {
+        tags: string[];
+        runnerId: string | null;
+    } | null;
+    launchEpoch?: number;
+    createdAt?: Date | null;
+    updatedAt?: Date | null;
+    launchConfig?: Record<string, any> | null;
+    meta?: AgentMeta | null;
+    routes: Record<string, AgentRouteConfig>;
+    command: string[];
+    entrypoint: string[];
+    dryRun: boolean;
+}
+export interface AgentHydrationData {
+    id?: string;
+    user_id?: string;
+    state?: AgentState;
+    name?: string | null;
+    handle?: string | null;
+    display_name?: string | null;
+    avatar_url?: string | null;
+    avatar_audio_url?: string | null;
+    display_identity?: Record<string, any> | null;
+    runtime?: string | null;
+    managed?: boolean | null;
+    is_launchable?: boolean;
+    gateway_id?: string | null;
+    relay_key?: AgentRelayKey | null;
+    cpu?: number;
+    memory?: number;
+    requested_size?: unknown;
+    hostname?: string | null;
+    tags?: string[] | null;
+    jwt_token?: string | null;
+    jwt_expires_at?: string | null;
+    started_at?: string | null;
+    stopped_at?: string | null;
+    archived_at?: string | null;
+    archive_prefix?: string | null;
+    deleted_at?: string | null;
+    disconnected_at?: string | null;
+    agent_slot_id?: string | null;
+    cluster_id?: string | null;
+    runner?: {
+        tags?: string[];
+        runner_id?: string | null;
+    } | null;
+    launch_epoch?: number;
+    created_at?: string | null;
+    updated_at?: string | null;
+    launch_config?: Record<string, any> | null;
+    meta?: Record<string, any> | null;
+    routes?: Record<string, AgentRouteConfig> | null;
+    command?: string[] | null;
+    entrypoint?: string[] | null;
+    dry_run?: boolean;
+    [key: string]: any;
+}
+export declare function flattenLaunchConfig(launchConfig: unknown): LaunchConfigFlatMap;
+export declare function getLaunchConfigValue(launchConfig: unknown, path: string | Array<string | number>): unknown;
+export declare function routesHaveDesktop(routes: unknown): boolean;
+export declare function launchConfigHasDesktop(launchConfig: unknown): boolean;
+export declare function agentConfigHasDesktop(source: AgentDesktopConfigSource | null | undefined): boolean;
+export declare function buildBrowserDesktopUrl(desktopBaseUrl: string, token: string, options?: BrowserDesktopUrlOptions): string;
+export { defaultAcpProxyWsUrl, defaultHyperAcpWsUrl, resolveAgentsApiBase } from './agent-urls.js';
+export declare function buildAgentConfig(config?: Record<string, any>, options?: BuildAgentConfigOptions): {
+    config: AgentLaunchConfig;
+};
+export declare function startSlackOAuth(options: SlackOAuthStartOptions): Promise<SlackOAuthStartResult>;
+export declare function getSlackInstallStatus(options: SlackInstallStatusOptions): Promise<SlackInstallStatus>;
+export declare function listSlackDirectoryConversations(options: SlackDirectoryConversationsOptions): Promise<SlackDirectoryConversationsResult>;
+export declare function listSlackDirectoryUsers(options: SlackDirectoryOptions): Promise<SlackDirectoryUsersResult>;
+export declare function attachSlackRelayAgent(options: AttachSlackRelayAgentOptions): Promise<AttachSlackRelayAgentResult>;
+export declare function buildOpenClawDesktopRoute(options?: OpenClawRouteOptions): Record<string, AgentRouteConfig>;
+export declare function buildOpenClawMemoryIndexEnv(memoryIndex?: OpenClawMemoryIndexOptions | null): Record<string, string>;
+export declare function buildOpenClawCronEnv(enabled?: boolean | null): Record<string, string>;
+export declare function buildHermesCronEnv(enabled?: boolean | null): Record<string, string>;
+export declare function buildWorkspacesSyncEnv(workspacesSync?: WorkspacesSyncOptions | boolean | null): Record<string, string>;
+export declare class Agent {
+    readonly id: string;
+    readonly userId: string;
+    readonly state: string;
+    readonly name: string | null;
+    readonly handle: string | null;
+    readonly displayName: string | null;
+    readonly avatarUrl: string | null;
+    readonly avatarAudioUrl: string | null;
+    readonly displayIdentity: Record<string, any> | null;
+    readonly runtime: string | null;
+    readonly managed: boolean | null;
+    readonly isLaunchable: boolean;
+    readonly gatewayId: string | null;
+    readonly relayKey: AgentRelayKey | null;
+    readonly cpu: number;
+    readonly memory: number;
+    readonly requestedSize: AgentSlotSize | null;
+    readonly hostname: string | null;
+    readonly tags: string[];
+    jwtToken: string | null;
+    jwtExpiresAt: Date | null;
+    readonly startedAt: Date | null;
+    readonly stoppedAt: Date | null;
+    readonly archivedAt: Date | null;
+    readonly archivePrefix: string | null;
+    readonly deletedAt: Date | null;
+    readonly disconnectedAt: Date | null;
+    readonly agentSlotId: string | null;
+    readonly clusterId: string | null;
+    readonly runner: {
+        tags: string[];
+        runnerId: string | null;
+    } | null;
+    readonly launchEpoch: number;
+    readonly createdAt: Date | null;
+    readonly updatedAt: Date | null;
+    launchConfig: Record<string, any> | null;
+    readonly meta: AgentMeta | null;
+    routes: Record<string, AgentRouteConfig>;
+    command: string[];
+    entrypoint: string[];
+    readonly dryRun: boolean;
+    _deployments: Deployments | null;
+    constructor(fields: AgentStateFields);
+    static fromDict(data: AgentHydrationData): Agent;
+    get publicUrl(): string | null;
+    protected routePrefix(routeName: string, defaultPrefix?: string | null): string | null;
+    routeUrl(routeName: string, defaultPrefix?: string | null): string | null;
+    get desktopUrl(): string | null;
+    get vncUrl(): string | null;
+    browserDesktopUrl(token: string, options?: BrowserDesktopUrlOptions): string | null;
+    get shellUrl(): string | null;
+    get isRunning(): boolean;
+    get isTransitioning(): boolean;
+    /** True when the agent is cold-restorable from its verified archive. */
+    get isArchived(): boolean;
+    /** True only for an explicitly included deletion tombstone. */
+    get isDeleted(): boolean;
+    get hasDesktop(): boolean;
+    protected requireDeployments(): Deployments;
+    /** Runtime auth flows for this agent's pod (coding runtimes only). */
+    get auth(): RuntimeAuthClient;
+    /**
+     * Connect to this agent's ACP surface through the backend session proxy.
+     *
+     * Default (`options.transport` unset): dials `/ws/acp` — the client-facing
+     * ACP session authority (sessions/README §14). The proxy owns the backend
+     * session record `{session_id → legs}`, fans runtime frames out to every
+     * attached session client, and answers `session/new` with the backend
+     * session id (backend-keyed, not the pod-side ACP id). Create-or-attach
+     * semantics key on `options.sessionId`:
+     *
+     * - omitted: the socket starts session-less; `newSession()` runs the
+     *   proxy's `session/new`, minting the backend session.
+     * - provided: the dial itself is session-less; AFTER the `initialize`
+     * handshake the client resumes the session over the connected socket
+     * (`session/resume` on v1), without replay. History uses the separate
+     * platform sessions API. A refused resume rejects acpConnect with the
+     * original error and closes its client; it never creates a replacement
+     * session.
+     *
+     * `transport: 'direct'` dials the agent-keyed `/ws` bridge instead
+     * (`?agent_id&token`), the pre-proxy path. Infra/debug only: `/ws` is
+     * being hardened to runtime + backend-service identities, and combining
+     * it with `sessionId` throws (the bridge has no session binding).
+     *
+     * The ACP `initialize` handshake offers protocol version 1 only
+     * (see `client.negotiatedProtocolVersion`). The proxy authority is
+     * v1-only and the client closes on any answered version other than 1.
+     * The `cwd` default comes from the runtime's validated launch-directory
+     * advertisement, never from the pod sync root or the caller's machine.
+      *
+      * Auth: the dial carries the client API key on the `token` query param;
+      * `options.token` overrides that credential.
+      */
+    acpConnect(options?: CodingAgentAcpConnectOptions): Promise<CodingAgentAcpClient>;
+    private acpPoolValue;
+    /**
+     * Lazily created connection pool for this agent's ACP surface. Two
+     * clients dialed to the same agent share one pod-side stdio session, so all
+     * ACP consumers (chat panes, session sweeps, turn drivers) must ride ONE
+     * pooled connection via leases instead of dialing their own — the bridge
+     * rejects a duplicate runtime attach. The pool closes the connection when
+     * the last lease releases, so a lease taken by a long-lived consumer (a
+     * turn driver) outlives callers that unmount (a chat pane) and vice versa.
+     *
+     * Under the default proxy transport the pooled connection dials session-less:
+     * prompting a session id the proxy has never seen (a stored id whose
+     * runtime was evicted backend-side) fails with an unknown-session error.
+     * Prompt against ids created through this proxy, or attach first with a
+     * dedicated `acpConnect({ sessionId })`.
+     */
+    get acpPool(): CodingAgentAcpPool;
+    /**
+     * Acquire a lease on this agent's pooled ACP connection and return a ready
+     * per-session {@link AcpTurnDriver} bound to it. `options.sessionId` is the
+     * pinned ACP session id (the id the app persists, e.g. under
+     * `localStorage["acp-session:<agentId>"]`); drivers are cheap — one per
+     * session, all sharing the same lease-held connection. The driver holds
+     * its lease until
+     * `driver.close()`; the pooled connection stays up for other leaseholders.
+     */
+    acpTurnDriver(options: AcpTurnDriverOptions): Promise<AcpTurnDriver>;
+    routeRequiresAuth(routeName: string, defaultValue?: boolean): boolean;
+    refreshToken(): Promise<AgentTokenResponse>;
+    waitRunning(timeoutMs?: number, pollIntervalMs?: number): Promise<Agent>;
+    update(options: UpdateAgentOptions): Promise<Agent>;
+    resetRuntimeDefaults(options: ResetRuntimeDefaultsOptions): Promise<ResetRuntimeDefaultsResult>;
+    resize(options: Pick<UpdateAgentOptions, 'size'>): Promise<Agent>;
+    /** Accept background archival and return its transitional Agent projection. */
+    archive(options?: LifecycleActionOptions): Promise<Agent>;
+    env(): Promise<Record<string, string>>;
+    setEnv(key: string, value: string): Promise<AgentEnvMutationResponse>;
+    deleteEnv(key: string): Promise<AgentEnvMutationResponse>;
+    secretNames(): Promise<string[]>;
+    secret(key: string): Promise<string>;
+    setSecret(key: string, value: string): Promise<AgentSecretMutationResponse>;
+    deleteSecret(key: string): Promise<AgentSecretMutationResponse>;
+    exec(command: string[], options?: AgentExecOptions): Promise<AgentExecResult>;
+    /** Reef-backed files scoped to this agent's configured sync root. */
+    get files(): AgentFiles;
+    filesList(path?: string): Promise<AgentFileEntry[]>;
+    fileReadBytes(path: string, options?: AgentFileReadOptions): Promise<Uint8Array>;
+    fileReadBytesWithMetadata(path: string, options?: AgentFileReadOptions): Promise<AgentFileReadBytesResult>;
+    fileRead(path: string, options?: AgentFileReadOptions): Promise<string>;
+    fileWriteBytes(path: string, content: Uint8Array | ArrayBuffer | string): Promise<Record<string, any>>;
+    fileWrite(path: string, content: string): Promise<Record<string, any>>;
+    fileDelete(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<Record<string, any>>;
+    cpTo(localPath: string, remotePath: string): Promise<Record<string, any>>;
+    cpFrom(remotePath: string, localPath: string): Promise<string>;
+    shellConnect(shell?: string, options?: AgentShellConnectOptions): Promise<WebSocket>;
+}
+export declare class RuntimeLoginSession {
+    private readonly authClient;
+    readonly socket: WebSocket;
+    private readonly requiresDeviceChallenge;
+    output: string;
+    verificationUrl: string | null;
+    userCode: string | null;
+    interactiveRequired: boolean;
+    private rawOutput;
+    private exitCode;
+    private readonly marker;
+    private readonly completion;
+    private readonly ready;
+    private complete;
+    private markReady;
+    private constructor();
+    static start(authClient: RuntimeAuthClient, command: string[], challengeTimeoutMs?: number, requiresDeviceChallenge?: boolean): Promise<RuntimeLoginSession>;
+    private consume;
+    send(text: string): void;
+    wait(timeoutMs?: number): Promise<RuntimeAuthStatus>;
+    cancel(): void;
+}
+export declare class RuntimeAuthClient {
+    readonly agent: Agent;
+    private readonly config;
+    constructor(agent: Agent);
+    methods(): Promise<RuntimeAuthMethod[]>;
+    status(): Promise<RuntimeAuthStatus>;
+    login(options?: RuntimeAuthLoginOptions): Promise<RuntimeLoginSession>;
+    logout(provider?: string): Promise<RuntimeAuthStatus>;
+}
+/**
+ * Every managed runtime — openclaw_acp, hermes_acp, and the
+ * coding-agent runtimes — boots its pod behind `hyper-acp`, so chat,
+ * sessions, runtime auth, and turn driving all ride the same ACP bridge; the
+ * runtimes differ only in the `runtime` label plus launch-config data
+ * (images, sync roots/uid/gid, harness env). Session protocol behavior is
+ * version-keyed (`negotiatedProtocolVersion`), never runtime-keyed.
+ *
+ * There is no per-runtime facade class: `Agent` carries the ACP members
+ * directly. ACP availability is determined by the peer; runtime auth uses
+ * the runtime auth table.
+ *
+ * @deprecated Every deployment hydrates to the single flat {@link Agent};
+ * use `Agent` in place of `CodingAgent`.
+ */
+export type CodingAgent = Agent;
+export declare class Deployments {
+    private readonly apiKey;
+    private readonly apiBase;
+    private readonly agentsWsUrl;
+    private readonly agentHttp;
+    constructor(http: HTTPClient, agentApiKey?: string, agentApiBase?: string, agentsWsUrl?: string, requestTimeout?: number);
+    get agentApiKey(): string;
+    get agentApiBase(): string;
+    /** Authoritative runtime-host launch directory, resolved by the platform. */
+    runtimePaths(agentId: string, requestOptions?: RequestOverrides): Promise<{
+        cwd: string;
+    }>;
+    private hydrateAgent;
+    private getById;
+    resolveAgent(agentIdOrName: string, requestOptions?: RequestOverrides): Promise<Agent>;
+    resolveAgentId(agentIdOrName: string, requestOptions?: RequestOverrides): Promise<string>;
+    private routesTarget;
+    private agentIdFor;
+    private fetchRaw;
+    private fileAccess;
+    private fetchReef;
+    create(options?: CreateAgentOptions): Promise<Agent>;
+    /**
+     * Create a managed agent for a runtime in one call.
+     *
+     * `runtime` selects the launch defaults (image, sync root and
+     * include/exclude presets, uid/gid, env presets, routes, boot command) from
+     * the ACP_RUNTIME_TABLE data table; `options` folds the old per-runtime
+     * facade option types — each runtime reads the knobs it understands and
+     * ignores the rest. `create()` stays the raw generic entry; `createAgent`
+     * is the typed one. Every non-generic runtime boots behind hyper-acp;
+     * `buzz` switches to the Buzz launch (coding runtimes only).
+     */
+    createAgent(runtime: ManagedAgentRuntime, options?: ManagedAgentCreateOptions): Promise<Agent>;
+    /**
+     * Create an ACP-fronted coding agent. All coding runtimes share one launch
+     * contract; `runtime` selects the default image and sync includes.
+     * Runtime configuration roots are selected on the runtime host.
+     *
+     * @deprecated Use {@link Deployments.createAgent} with the runtime label;
+     * the folded entry takes the same options bag.
+     */
+    createCodingAgent(runtime: CodingAgentRuntime, options?: CodingAgentCreateOptions): Promise<Agent>;
+    /**
+     * The one canonical ACP launch path: every non-generic runtime launches
+     * through here, with per-family differences read from ACP_RUNTIME_TABLE.
+     */
+    private createAcpAgentDeployment;
+    budget(): Promise<Record<string, any>>;
+    private oneShotAgentWebSocket;
+    metrics(agentIdOrName: string): Promise<AgentMetricsResult>;
+    list(options?: ListAgentsOptions): Promise<Agent[]>;
+    listWithCapacity(options?: ListAgentsOptions): Promise<AgentCapacity>;
+    get(agentIdOrName: string, requestOptions?: RequestOverrides): Promise<Agent>;
+    attachSlackRelayAgent(agentIdOrName: string, options: AttachDeploymentSlackRelayAgentOptions): Promise<AttachSlackRelayAgentResult>;
+    subscribe(handler: (event: DeploymentEvent) => void | Promise<void>, options?: DeploymentSubscribeOptions): Promise<void>;
+    waitForState(agentIdOrName: string, states: readonly AgentState[], timeoutMs?: number, failureStates?: readonly AgentState[], minimumLaunchEpoch?: number, pollIntervalMs?: number): Promise<Agent>;
+    waitRunning(agentIdOrName: string, timeoutMs?: number, pollIntervalMs?: number, minimumLaunchEpoch?: number): Promise<Agent>;
+    /**
+     * Read back every launch secret value the projection refuses to return.
+     *
+     * Agent projections list secret *names* and expose values only through the
+     * per-secret retrieval endpoint, so a complete `secrets` mapping has to be
+     * reassembled one key at a time. Every response is checked against
+     * `launchEpoch` so a rebuild never silently mixes values from an older
+     * launch generation into a new one.
+     */
+    private recoverRedactedSecrets;
+    /**
+     * Restore the two launch_config keys an Agent projection redacts.
+     *
+     * WHY THIS EXISTS — do not delete it as redundant validation sugar. The
+     * Backend's owner-facing Agent projection deliberately strips `secrets` and
+     * `registry_auth` before returning an Agent to a user-scoped caller
+     * (`hydrate_managed_agent` pops both), and this SDK's own hydrator drops
+     * `secrets` again. A caller that writes launch_config before start still
+     * needs a complete replacement object. Without this step the obvious round
+     * trip can never succeed, because the read side is structurally incapable of
+     * returning what the write side requires:
+     *
+     * ```ts
+     * const agent = await client.deployments.get(agentId);
+     * await client.deployments.update(agentId, { launchConfig: agent.launchConfig });
+     * // Error: launchConfig is incomplete; missing: secrets, registry_auth
+     * ```
+     *
+     * The fix is to complete the object honestly, never to weaken the
+     * completeness contract — launch_config writes are replacements, not merges.
+     *
+     * Only keys that are genuinely ABSENT are rebuilt. A caller-supplied
+     * `secrets` or `registry_auth` is honoured verbatim, including an explicit
+     * empty object, so "redacted by the projection" and "deliberately empty"
+     * remain distinguishable.
+     *
+     * `secrets` is recoverable because values can be read back one name at a
+     * time. `registry_auth` is NOT: it is caller-held, write-only, and never
+     * stored server-side. It therefore falls back to an explicitly supplied
+     * `registryAuth`, then to `{}` only when the configuration pulls from no
+     * `registry_url`; when a registry is configured an empty credential would
+     * silently break the image pull, so the caller is told to supply it instead.
+     */
+    private rehydrateRedactedLaunchConfig;
+    /**
+     * Rebuild a complete replacement launch_config from
+     * nothing but the Agent's stored projection.
+     *
+     * This SDK starts stored config without reading it. This method is retained
+     * for callers that want to explicitly update stored launch_config;
+     * it is also the only place that canonicalizes the two legacy projection
+     * shapes the inline repair never sees, because the repair fills absent keys
+     * and touches nothing else:
+     * nullable `restart`, and a projection carrying both or neither sync policy.
+     *
+     * Reads the stored Agent projection, rehydrates redacted secrets through the
+     * per-secret retrieval endpoint, requires caller-held registry_auth whenever
+     * the stored config references a registry_url, normalizes those legacy
+     * shapes, and self-checks through the completeness gatekeeper.
+     */
+    storedLaunchConfig(agentIdOrName: string, options?: {
+        registryAuth?: RegistryAuth;
+    }): Promise<AgentLaunchConfig>;
+    start(agentIdOrName: string, options?: StartAgentOptions): Promise<Agent>;
+    update(agentIdOrName: string, options?: UpdateAgentOptions): Promise<Agent>;
+    /**
+     * Reset a deployment back to this runtime's platform defaults.
+     *
+     * The empty launch_config is intentional: Backend treats `{}` as "clear every
+     * mutable launch setting" while preserving protected launch identity and
+     * retained-storage fields. Runtime-specific files are deleted best-effort so
+     * the image can reseed its own config on the next boot.
+     */
+    resetRuntimeDefaults(agentIdOrName: string, options: ResetRuntimeDefaultsOptions): Promise<ResetRuntimeDefaultsResult>;
+    uploadProfileImage(agentId: string, content: Blob | ArrayBuffer | ArrayBufferView, contentType?: string): Promise<AgentProfileImageUploadResult>;
+    deleteProfileImage(agentId: string): Promise<AgentProfileImageUploadResult>;
+    resize(agentId: string, options: Pick<UpdateAgentOptions, 'size'>): Promise<Agent>;
+    /**
+     * Request an agent stop.
+     *
+     * The returned agent remains `STOPPING` while runtime cleanup is in
+     * progress. Fetch it again until it becomes `STOPPED` before treating its
+     * deployment slot as released.
+     *
+     * With `dryRun: true` the Backend only validates the request and returns
+     * the current Agent unchanged -- nothing mutates and no stop is started.
+     */
+    stop(agentIdOrName: string, options?: LifecycleActionOptions): Promise<Agent>;
+    /**
+     * Archive durable storage without launching the agent.
+     *
+     * With `dryRun: true` the Backend only validates the request and returns
+     * the current Agent unchanged -- nothing mutates and no archive is started.
+     */
+    archive(agentIdOrName: string, options?: LifecycleActionOptions): Promise<Agent>;
+    /**
+     * Restore durable storage. The accepted snapshot is `RESTORING`; completion is `STOPPED`.
+     *
+     * With `dryRun: true` the Backend only validates the request and returns
+     * the current Agent unchanged -- nothing mutates and no restore is started.
+     */
+    restore(agentIdOrName: string, options?: LifecycleActionOptions): Promise<Agent>;
+    /**
+     * Resolve who the presented credential is, per the Backend
+     * (`GET /deployments/auth/me`).
+     *
+     * Answers the three questions a credential should be able to ask about
+     * itself: which Agent it is (`agentId`, set only for an Agent runtime key),
+     * which account owns it (`userId`, `teamId`, `planId`), and what it may do
+     * (`tags`, `capabilities`). It returns only what the credential already
+     * carries, so it is unscoped and safe for any caller.
+     *
+     * Distinct from the product-wide `client.user.authMe()`: this is the agent
+     * product's own introspection and is the only one that reports `agentId`.
+     */
+    accessIdentity(requestOptions?: RequestOverrides): Promise<AgentAccessIdentity>;
+    getRoutes(agentIdOrName: string, options?: RequestOverrides): Promise<AgentRoutesState>;
+    setRoutes(agentIdOrName: string, routes: Record<string, AgentRouteConfig>, options?: SetRoutesOptions): Promise<AgentRoutesState>;
+    setRoute(agentIdOrName: string, name: string, route: AgentRouteConfig): Promise<AgentRoutesState>;
+    removeRoute(agentIdOrName: string, name: string): Promise<AgentRoutesState>;
+    /**
+     * Delete a deployment.
+     *
+     * With `dryRun: true` the Backend only validates the request and returns
+     * the current Agent record unchanged -- nothing mutates and the deployment
+     * is not deleted.
+     */
+    delete(agentIdOrName: string, options?: LifecycleActionOptions): Promise<Record<string, any>>;
+    refreshToken(agentIdOrName: string): Promise<AgentTokenResponse>;
+    /**
+     * Signed URL for the agent's VNC desktop. Requires a running agent with the
+     * `desktop` route enabled; throws otherwise.
+     */
+    desktopUrl(agentIdOrName: string, options?: BrowserDesktopUrlOptions): Promise<{
+        url: string;
+        expiresAt: Date | null;
+        viewport: {
+            width: number;
+            height: number;
+        } | null;
+    }>;
+    createScopedKey(agentIdOrName: string, name?: string): Promise<Record<string, any>>;
+    webSearch(query: string, options?: BraveWebSearchOptions): Promise<BraveWebSearchResponse>;
+    logsToken(agentIdOrName: string): Promise<AgentLogsTokenResponse>;
+    env(agentIdOrName: string, requestOptions?: RequestOverrides): Promise<AgentEnvResponse>;
+    setEnv(agentIdOrName: string, key: string, value: string): Promise<AgentEnvMutationResponse>;
+    deleteEnv(agentIdOrName: string, key: string): Promise<AgentEnvMutationResponse>;
+    secretNames(agentIdOrName: string, requestOptions?: RequestOverrides): Promise<AgentSecretNamesResponse>;
+    secret(agentIdOrName: string, key: string, requestOptions?: RequestOverrides): Promise<AgentSecretResponse>;
+    setSecret(agentIdOrName: string, key: string, value: string): Promise<AgentSecretMutationResponse>;
+    deleteSecret(agentIdOrName: string, key: string): Promise<AgentSecretMutationResponse>;
+    exec(target: Agent | string, command: string[], options?: AgentExecOptions): Promise<AgentExecResult>;
+    /**
+     * Wait until the Agent file API is serving. Native assignments use a bounded
+     * file read; hosted assignments use the Reef readiness checks below.
+     *
+     * Probing the Agent hostname alone cannot answer this. The Agent domain is a
+     * wildcard, so a host with no route still resolves and the edge answers a
+     * plain-text `404 page not found` — byte for byte what a route that has not
+     * converged yet returns. A caller polling the hostname therefore cannot tell
+     * "not ready" from "never will be", and will retry until its deadline against
+     * a host that was never going to work.
+     *
+     * So ask the API for the authoritative Agent state first: a deleted or failed
+     * Agent rejects immediately with that state rather than timing out. Then
+     * require consecutive successful reads, because one success only proves the
+     * route answered once — the next request can still 404 while the edge settles.
+     */
+    waitForFileApiReady(target: Agent | string, options?: AgentFileApiReadyOptions): Promise<void>;
+    filesList(target: Agent | string, path?: string): Promise<AgentFileEntry[]>;
+    fileReadBytesWithMetadata(target: Agent | string, path: string, options?: AgentFileReadOptions): Promise<AgentFileReadBytesResult>;
+    fileReadBytes(target: Agent | string, path: string, options?: AgentFileReadOptions): Promise<Uint8Array>;
+    fileRead(target: Agent | string, path: string, options?: AgentFileReadOptions): Promise<string>;
+    /**
+     * Write bytes to a relative path through Reef or the native runner transport.
+     *
+     * Per-file writes are limited to 100 MiB (`AGENT_FILE_WRITE_MAX_BYTES`,
+     * the Cloudflare edge request-body cap on the agent hostname). Larger data
+     * should be split across files or synced via the agent's own tooling.
+     * Native runner files are limited to 100 MiB under the retained assignment root.
+     */
+    fileWriteBytes(target: Agent | string, path: string, content: Uint8Array | ArrayBuffer | string, options?: {
+        signal?: AbortSignal;
+    }): Promise<Record<string, any>>;
+    /**
+     * Write a UTF-8 text file to an agent.
+     *
+     * Subject to the 100 MiB per-file write limit; see `fileWriteBytes`.
+     */
+    fileWrite(target: Agent | string, path: string, content: string): Promise<Record<string, any>>;
+    fileDelete(target: Agent | string, path: string, options?: {
+        recursive?: boolean;
+    }): Promise<Record<string, any>>;
+    cpTo(target: Agent | string, localPath: string, remotePath: string): Promise<Record<string, any>>;
+    cpFrom(target: Agent | string, remotePath: string, localPath: string): Promise<string>;
+    /** One bounded display/capture read. All-unavailable capture errors retain their metadata. */
+    getLogs(agentIdOrName: string, options?: AgentLogsReadOptions): Promise<AgentLogsResponse>;
+    logsConnect(agentIdOrName: string, options?: AgentLogsConnectOptions): Promise<WebSocket>;
+    private connectLogs;
+    /**
+     * Cluster logs replay history then stream lines. Runner logs instead deliver
+     * bounded replacement snapshots to onCapturedLogs, without history_end.
+     *
+     * One mechanism rather than a REST read plus a separate subscribe. The two-step
+     * form leaves a seam between the two calls that no server change can close,
+     * because the fetch and the subscribe share no lock; the backend takes the
+     * history snapshot and registers the subscriber under a single lock, so a line
+     * arriving mid-replay is delivered exactly once.
+     *
+     * Deliberately does not reconnect. A reconnect replays history again, which
+     * would duplicate lines into a consumer that has already rendered them;
+     * reconnect policy belongs to the caller, which knows whether it is resuming
+     * or restarting the view.
+     */
+    subscribeLogs(agentIdOrName: string, handler: (line: string) => void | Promise<void>, options?: AgentLogsSubscribeOptions): Promise<void>;
+    /**
+     * Buzz-backed agents publish observer telemetry to a Nostr relay (kind
+     * 24200, NIP-44-v2-encrypted to the owner). This subscribes the relay
+     * directly and decrypts locally; see {@link subscribeBuzzActivity}.
+     */
+    subscribeBuzzActivity(agentIdOrName: string, handlers: BuzzActivityHandlers): Promise<BuzzActivitySubscription>;
+    /**
+     * Legacy Buzz activity through an agent `hyper-acp` WS route. Hosted Buzz
+     * launches no longer provision this route; the raw ACP path is outbound
+     * `HYPER_ACP_WS_URL`. See {@link subscribeBuzzActivityRoute}.
+     */
+    subscribeBuzzActivityRoute(agentIdOrName: string, handlers: BuzzActivityRouteHandlers): Promise<BuzzActivitySubscription>;
+    shellToken(agentIdOrName: string, shell?: string, requestOptions?: RequestOverrides): Promise<AgentShellTokenResponse>;
+    shellConnect(agentIdOrName: string, shell?: string, options?: AgentShellConnectOptions): Promise<WebSocket>;
+}
+//# sourceMappingURL=agents.d.ts.map