@beeos-ai/bma-executor-sdk 0.0.0-stage → 0.4.1

package/dist/generated/executor.d.ts

@@ -0,0 +1,1218 @@
+/** Generic acknowledgement returned by executor RPC methods. */
+export interface Ack {
+    accepted: boolean;
+}
+/** agent capability. Present with enabled=true when the executor runs a complete agent and accepts turn.start, turn.input, turn.cancel, session.close and interaction.response. */
+export interface AgentCapability {
+    enabled: boolean;
+    /** Models the local agent can run. An empty list means the executor picks its own model and ignores AgentTurnConfig.model. */
+    models?: Array<AgentModel>;
+    /** Permission mode ids the local agent understands, for example default, accept_edits, plan, bypass_permissions. The executor defines the ids; the platform only passes one back in AgentTurnConfig.permission_mode. */
+    permission_modes?: Array<string>;
+    /** Interaction kinds the executor may open with interaction.request. */
+    interaction_kinds?: Array<InteractionKind>;
+    /** The executor resolves file input blocks (session file ids) itself. */
+    file_inputs?: boolean;
+    /** Concurrent agent sessions. turn.start for a new session beyond it answers -32009 executor_busy. */
+    max_sessions?: number;
+}
+/** Typed session error. */
+export interface AgentErrorInfo {
+    type: string;
+    message?: string;
+}
+/** One durable agent event. The event id is the session.event event_id; agent.tool_result.tool_use_id references the event_id of its agent.tool_use. */
+export type AgentEvent = AgentMessageEvent | AgentThinkingEvent | AgentToolUseEvent | AgentToolResultEvent | AgentMcpToolUseEvent | AgentMcpToolResultEvent | SessionStatusRunningEvent | SessionStatusIdleEvent | SessionErrorEvent;
+/** Durable events an agent executor emits with session.event. Names and members follow Anthropic Managed Agents session events. user.* events are written by the platform, never by the executor. */
+export type AgentEventType = 'agent.message' | 'agent.thinking' | 'agent.tool_use' | 'agent.tool_result' | 'agent.mcp_tool_use' | 'agent.mcp_tool_result' | 'session.status_running' | 'session.status_idle' | 'session.error';
+export declare const AgentEventType: {
+    readonly AgentMessage: "agent.message";
+    readonly AgentThinking: "agent.thinking";
+    readonly AgentToolUse: "agent.tool_use";
+    readonly AgentToolResult: "agent.tool_result";
+    readonly AgentMcpToolUse: "agent.mcp_tool_use";
+    readonly AgentMcpToolResult: "agent.mcp_tool_result";
+    readonly SessionStatusRunning: "session.status_running";
+    readonly SessionStatusIdle: "session.status_idle";
+    readonly SessionError: "session.error";
+};
+/** One block of user input. A file block references a platform session file by file_id; the executor downloads it through the executor files API. File bytes never travel on the control channel. */
+export interface AgentInputBlock {
+    type: AgentInputBlockType;
+    text?: string;
+    file_id?: string;
+    name?: string;
+    mime_type?: string;
+    size_bytes?: number;
+}
+/** Agent input block type. */
+export type AgentInputBlockType = 'text' | 'file';
+export declare const AgentInputBlockType: {
+    readonly Text: "text";
+    readonly File: "file";
+};
+/** Result of an agent.mcp_tool_use. */
+export interface AgentMcpToolResultEvent {
+    type: 'agent.mcp_tool_result';
+    mcp_tool_use_id: string;
+    content?: Array<ContentBlock>;
+    is_error?: boolean;
+}
+/** An MCP tool the local agent is calling. Its event_id is the mcp_tool_use_id. */
+export interface AgentMcpToolUseEvent {
+    type: 'agent.mcp_tool_use';
+    mcp_server_name: string;
+    name: string;
+    input: Record<string, unknown>;
+    evaluated_permission?: EvaluatedPermission;
+}
+/** Final assistant text. Streaming previews for the same event_id arrive earlier as session.event_delta. */
+export interface AgentMessageEvent {
+    type: 'agent.message';
+    content: Array<ContentBlock>;
+}
+/** One model the local agent can run. */
+export interface AgentModel {
+    id: string;
+    display_name?: string;
+    /** Thinking or reasoning-effort levels the model accepts, for example off, low, medium, high. */
+    thinking_levels?: Array<string>;
+    default_thinking_level?: string;
+}
+/** Model thinking. content may be empty when the model only reports that it thought. */
+export interface AgentThinkingEvent {
+    type: 'agent.thinking';
+    content?: Array<ContentBlock>;
+}
+/** Result of an agent.tool_use. */
+export interface AgentToolResultEvent {
+    type: 'agent.tool_result';
+    tool_use_id: string;
+    content?: Array<ContentBlock>;
+    is_error?: boolean;
+}
+/** A built-in or custom tool the local agent is calling. Its event_id is the tool_use_id. */
+export interface AgentToolUseEvent {
+    type: 'agent.tool_use';
+    name: string;
+    input: Record<string, unknown>;
+    evaluated_permission?: EvaluatedPermission;
+}
+/** Requested (turn.start) or effective (TurnStartResult.effective) turn configuration. Every member is optional in a request; the executor reports the values it actually applied. */
+export interface AgentTurnConfig {
+    model?: string;
+    thinking_level?: string;
+    permission_mode?: string;
+    /** Working directory on the executor host. The executor rejects a directory outside its allowed roots with -32001 forbidden. */
+    cwd?: string;
+    /** Extra system instructions from the platform agent definition. */
+    system?: string;
+}
+/** v1.1 artifact upload (POST /v1/executors/artifacts). Environment-scoped executors only. */
+export interface ArtifactCapability {
+    upload: boolean;
+    max_bytes?: number;
+}
+/** Artifact reference returned by POST /v1/executors/artifacts and listed in tool.result artifacts (v1.1 §6.5). */
+export interface ArtifactRef {
+    artifact_id: string;
+    name?: string;
+    mime_type: string;
+    size_bytes: number;
+    /** sha256:<hex> of the content. */
+    digest: string;
+    created_at?: string;
+}
+/** Executor capability object. The server only sends a method to an executor that advertised its capability; otherwise the executor answers -32012 capability_unavailable. */
+export interface Capabilities {
+    shell?: ShellCapability;
+    files?: FilesCapability;
+    mcp?: McpCapability;
+    chrome?: boolean;
+    computer_use?: boolean;
+    /** v1 boolean or v1.1 DisplayCapability object. */
+    display?: boolean | DisplayCapability;
+    process?: ProcessCapability;
+    artifacts?: ArtifactCapability;
+    terminal?: TerminalCapability;
+    skills?: SkillsCapability;
+    workspace?: WorkspaceCapability;
+    agent?: AgentCapability;
+}
+/** Channels a short-lived executor JWT may open. */
+export type ChannelScope = 'control' | 'mcp';
+export declare const ChannelScope: {
+    readonly Control: "control";
+    readonly Mcp: "mcp";
+};
+/** Input actions accepted by the computer_action tool. */
+export type ComputerAction = 'click' | 'type' | 'key' | 'scroll' | 'drag';
+export declare const ComputerAction: {
+    readonly Click: "click";
+    readonly Type: "type";
+    readonly Key: "key";
+    readonly Scroll: "scroll";
+    readonly Drag: "drag";
+};
+/** Executor control channel state machine. */
+export type ConnectionState = 'disconnected' | 'connecting' | 'registered' | 'ready' | 'draining' | 'closed';
+export declare const ConnectionState: {
+    readonly Disconnected: "disconnected";
+    readonly Connecting: "connecting";
+    readonly Registered: "registered";
+    readonly Ready: "ready";
+    readonly Draining: "draining";
+    readonly Closed: "closed";
+};
+/** Tool result content block. An artifact block carries artifact_id and mime_type instead of text (v1.1 §6.5). */
+export interface ContentBlock {
+    type: ContentBlockType;
+    text?: string;
+    data?: string;
+    mime_type?: string;
+    url?: string;
+    artifact_id?: string;
+}
+/** Tool result content block type. */
+export type ContentBlockType = 'text' | 'image' | 'resource' | 'artifact';
+export declare const ContentBlockType: {
+    readonly Text: "text";
+    readonly Image: "image";
+    readonly Resource: "resource";
+    readonly Artifact: "artifact";
+};
+/** Per-stream byte cursors. */
+export interface Cursors {
+    stdout: number;
+    stderr: number;
+}
+/** v1.1 display object. v1 sent a boolean; the server accepts both. */
+export interface DisplayCapability {
+    rfb?: boolean;
+}
+/** Permission decision the executor applied to a tool use. ask means the executor opened an interaction.request for it. */
+export interface EvaluatedPermission {
+    type: 'allow' | 'ask' | 'deny';
+}
+/** Durable event type a streaming preview belongs to. */
+export type EventDeltaType = 'agent.message' | 'agent.thinking';
+export declare const EventDeltaType: {
+    readonly AgentMessage: "agent.message";
+    readonly AgentThinking: "agent.thinking";
+};
+/** executor.drain result. */
+export interface ExecutorDrainResult {
+    accepted: boolean;
+    active_sessions: Array<string>;
+}
+/** executor.heartbeat result. */
+export interface ExecutorHeartbeatResult {
+    server_time: string;
+    lease_ttl_ms: number;
+    drain: boolean;
+}
+/** Executor identity reported at token bootstrap and registration. */
+export interface ExecutorInfo {
+    name: string;
+    os: string;
+    arch: string;
+    version: string;
+}
+/** Advisory executor load reported with executor.heartbeat. The server does not act on it. */
+export interface ExecutorLoad {
+    cpu_percent?: number;
+    memory_percent?: number;
+}
+/** executor.register result. protocol and limits are v1.1 only. */
+export interface ExecutorRegisterResult {
+    executor_id: string;
+    connection_id: string;
+    server_time: string;
+    heartbeat_interval_ms: number;
+    lease_ttl_ms: number;
+    max_control_frame_bytes: number;
+    max_mcp_frame_bytes: number;
+    drain: boolean;
+    protocol?: ProtocolVersion;
+    limits?: Limits;
+}
+/** Reattach state sent on reconnect. */
+export interface ExecutorResume {
+    executor_id?: string;
+    last_connection_id?: string;
+    active_sessions?: Array<string>;
+}
+/** POST /v1/executors/token body. The bearer is an environment key, or a machine daemon token. An empty environment_id with a machine token requests a machine-scoped executor: its executor_id is exec_<machine_id>, stable across refreshes, and the JWT carries machine_id and daemon_token_id. */
+export interface ExecutorTokenRequest {
+    environment_id: string;
+    executor: ExecutorInfo;
+}
+/** POST /v1/executors/token response. */
+export interface ExecutorTokenResponse {
+    executor_id: string;
+    /** Short-lived executor JWT, sent only in the Authorization header of the channel upgrade. */
+    token: string;
+    /** Seconds. */
+    expires_in: number;
+    ws_url: string;
+    channel_scope: Array<ChannelScope>;
+}
+/** File transfer direction relative to the machine. */
+export type FileTransferDirection = 'upload' | 'download';
+export declare const FileTransferDirection: {
+    readonly Upload: "upload";
+    readonly Download: "download";
+};
+/** Failed file transfer. */
+export interface FileTransferError {
+    code: string;
+    error: string;
+    current_digest?: string;
+}
+/** Ended file transfer outcome: the uploaded path and digest, the downloaded digest, or an error. */
+export interface FileTransferResult {
+    path?: string;
+    digest?: string;
+    error?: FileTransferError;
+}
+/** v1 file tools. */
+export interface FilesCapability {
+    enabled: boolean;
+    read_roots?: Array<string>;
+    write_roots?: Array<string>;
+}
+/** process.start io_mode. "pty" runs the command on a 24x80 pseudo-terminal: stdout is the PTY output, stdin writes go to the PTY and close_stdin is rejected. Requires process.pty. */
+export type IOMode = 'pty';
+export declare const IOMode: {
+    readonly Pty: "pty";
+};
+/** Why the executor withdrew an open interaction. */
+export type InteractionCancelReason = 'resolved_locally' | 'turn_canceled' | 'expired' | 'tool_canceled';
+export declare const InteractionCancelReason: {
+    readonly ResolvedLocally: "resolved_locally";
+    readonly TurnCanceled: "turn_canceled";
+    readonly Expired: "expired";
+    readonly ToolCanceled: "tool_canceled";
+};
+/** Interaction kinds; they map 1:1 to platform agent interactions. */
+export type InteractionKind = 'permission' | 'question';
+export declare const InteractionKind: {
+    readonly Permission: "permission";
+    readonly Question: "question";
+};
+/** How the platform resolved an interaction. allow/deny answer permission, answered answers question, expired and canceled close either kind without an answer. */
+export type InteractionOutcome = 'allow' | 'deny' | 'answered' | 'expired' | 'canceled';
+export declare const InteractionOutcome: {
+    readonly Allow: "allow";
+    readonly Deny: "deny";
+    readonly Answered: "answered";
+    readonly Expired: "expired";
+    readonly Canceled: "canceled";
+};
+/** Question shown to the user. */
+export interface InteractionQuestion {
+    prompt: string;
+    options?: Array<InteractionQuestionOption>;
+    multi_select?: boolean;
+    allow_free_text?: boolean;
+}
+/** One answer option of a question interaction. */
+export interface InteractionQuestionOption {
+    id: string;
+    label: string;
+}
+/** interaction.request result. Idempotent by interaction_id: a repeat returns the same platform interaction. */
+export interface InteractionRequestResult {
+    accepted: boolean;
+    platform_interaction_id: string;
+}
+/** Who answered, for local audit. surface is the client that resolved it, for example desktop, mobile, web, slack. */
+export interface InteractionResponder {
+    actor_id?: string;
+    surface?: string;
+}
+/** interaction.response result. accepted=false when the interaction is unknown or already resolved (first answer wins); the platform then marks its copy stale. */
+export interface InteractionResponseResult {
+    accepted: boolean;
+}
+/** How long a permission grant lasts on the executor: this tool use only, or the rest of the session. */
+export type InteractionScope = 'once' | 'session';
+export declare const InteractionScope: {
+    readonly Once: "once";
+    readonly Session: "session";
+};
+/** JSON-RPC 2.0 error object. */
+export interface JsonRpcError {
+    code: JsonRpcErrorCode;
+    message: string;
+    data?: JsonRpcErrorData;
+}
+/** Executor protocol JSON-RPC error codes. -32011..-32013 are v1.1 additions. */
+export type JsonRpcErrorCode = -32700 | -32600 | -32601 | -32602 | -32603 | -32000 | -32001 | -32002 | -32003 | -32004 | -32005 | -32006 | -32007 | -32008 | -32009 | -32010 | -32011 | -32012 | -32013;
+export declare const JsonRpcErrorCode: {
+    readonly ParseError: -32700;
+    readonly InvalidRequest: -32600;
+    readonly MethodNotFound: -32601;
+    readonly InvalidParams: -32602;
+    readonly InternalError: -32603;
+    readonly Unauthorized: -32000;
+    readonly Forbidden: -32001;
+    readonly NotFound: -32002;
+    readonly LeaseExpired: -32003;
+    readonly Timeout: -32004;
+    readonly Canceled: -32005;
+    readonly PayloadTooLarge: -32006;
+    readonly SessionNotActive: -32007;
+    readonly McpUnavailable: -32008;
+    readonly ExecutorBusy: -32009;
+    readonly UnsupportedProtocol: -32010;
+    readonly ResourceUnavailable: -32011;
+    readonly CapabilityUnavailable: -32012;
+    readonly Conflict: -32013;
+};
+/** JSON-RPC error.data. Members are code-specific; unknown members are ignored. */
+export interface JsonRpcErrorData {
+    /** Capacity or timeout failure the caller should retry with backoff. */
+    retryable?: boolean;
+    detail?: string;
+    /** Missing capability for -32012, for example "tool:read" or "process.pty". */
+    capability?: string;
+    /** Machine-readable cause, for example "spawn_failed" for process.start. */
+    reason?: string;
+    /** bma.terminal.v1 error code for a failed terminal.* call. */
+    terminal_code?: string;
+    /** Agent session.event gap (-32013): the sequence the harness expects next. */
+    expected_sequence?: number;
+}
+/** JSON-RPC 2.0 error response envelope. */
+export interface JsonRpcErrorResponse {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    error: JsonRpcError;
+}
+/** JSON-RPC request id. Both peers use strings. */
+export type JsonRpcId = string;
+/** JSON-RPC 2.0 notification envelope (no id). */
+export interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params: Record<string, never>;
+}
+/** JSON-RPC 2.0 request envelope. */
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    method: string;
+    params: Record<string, never>;
+}
+/** JSON-RPC 2.0 success response envelope. */
+export interface JsonRpcSuccessResponse {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    result: unknown;
+}
+/** Fencing lease for a session assignment. */
+export interface Lease {
+    token: string;
+    fencing_token: number;
+}
+/** Limits the executor must enforce, advertised in the v1.1 executor.register result (v1.1 §1.3). */
+export interface Limits {
+    max_inflight_requests: number;
+    max_concurrent_process_reads: number;
+    max_process_read_bytes: number;
+    max_process_write_bytes: number;
+    max_processes_per_session: number;
+    max_artifact_bytes: number;
+}
+/** Environment-origin MCP servers. */
+export interface McpCapability {
+    stdio?: boolean;
+    http?: boolean;
+    max_servers?: number;
+}
+/** Who connects the MCP server. environment means the executor starts/connects it; service means the harness connects. */
+export type McpConnectionOrigin = 'service' | 'environment';
+export declare const McpConnectionOrigin: {
+    readonly Service: "service";
+    readonly Environment: "environment";
+};
+/** MCP tool content block. Large binary content must go to artifact storage. */
+export interface McpContentBlock {
+    type: 'text' | 'image' | 'resource';
+    text?: string;
+    data?: string;
+    mimeType?: string;
+    resource?: unknown;
+}
+export interface McpImplementation {
+    name: string;
+    version: string;
+}
+export interface McpInitializeParams {
+    protocolVersion: string;
+    capabilities: Record<string, unknown>;
+    clientInfo: McpImplementation;
+}
+export interface McpInitializeResult {
+    protocolVersion: string;
+    capabilities: Record<string, unknown>;
+    serverInfo: McpImplementation;
+}
+export interface McpJsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface McpJsonRpcErrorResponse {
+    jsonrpc: '2.0';
+    id: McpJsonRpcId;
+    error: McpJsonRpcError;
+}
+/** MCP JSON-RPC id. */
+export type McpJsonRpcId = string | number;
+export interface McpJsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface McpJsonRpcRequest {
+    jsonrpc: '2.0';
+    id: McpJsonRpcId;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface McpJsonRpcSuccessResponse {
+    jsonrpc: '2.0';
+    id: McpJsonRpcId;
+    result: unknown;
+}
+export interface McpProgressParams {
+    progressToken: string | number;
+    progress: number;
+    total?: number;
+}
+export interface McpServerConfig {
+    server_key: string;
+    connection_origin: McpConnectionOrigin;
+    transport: McpServerTransport;
+}
+/** Transport for one MCP server. stdio requires command; http requires url. Fields for the other transport are omitted. */
+export interface McpServerTransport {
+    type: McpTransportType;
+    /** stdio: absolute or allowlisted executable. No shell, no sh -c. */
+    command?: string;
+    args?: Array<string>;
+    /** stdio: working directory under the session workspace. */
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout_ms?: number;
+    /** Pins the executable when supplied. */
+    command_sha256?: string;
+    /** http: Streamable HTTP MCP endpoint. */
+    url?: string;
+}
+export interface McpTool {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface McpToolsCallParams {
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface McpToolsCallResult {
+    content: Array<McpContentBlock>;
+    isError?: boolean;
+    structuredContent?: unknown;
+}
+export interface McpToolsListParams {
+    cursor?: string;
+}
+export interface McpToolsListResult {
+    tools: Array<McpTool>;
+    nextCursor?: string | null;
+}
+export type McpTransportType = 'stdio' | 'http';
+export declare const McpTransportType: {
+    readonly Stdio: "stdio";
+    readonly Http: "http";
+};
+/** Tool permission mode; always_ask means the harness already resolved approval. */
+export type PermissionMode = 'always_allow' | 'always_ask';
+export declare const PermissionMode: {
+    readonly AlwaysAllow: "always_allow";
+    readonly AlwaysAsk: "always_ask";
+};
+/** v1.1 process.* support. pty, file_transfer and git_credentials are additive: the harness only sends the matching process.start fields to an executor that set them, and fails the process explicitly otherwise. */
+export interface ProcessCapability {
+    enabled: boolean;
+    max_processes?: number;
+    buffer_bytes?: number;
+    /** Accepts process.start io_mode "pty". */
+    pty?: boolean;
+    /** Accepts process.start file_transfer. */
+    file_transfer?: boolean;
+    /** Accepts process.start git_credentials. */
+    git_credentials?: boolean;
+}
+/** Replaces argv: the executor moves one file between the machine and the process BMA file endpoint and reports the outcome in ProcessState.file_transfer. Requires process.file_transfer. */
+export interface ProcessFileTransfer {
+    direction: FileTransferDirection;
+    local_path: string;
+}
+/** process.list result. */
+export interface ProcessListResult {
+    processes: Array<ProcessState>;
+}
+/** process.read result. */
+export interface ProcessReadResult {
+    process_id: string;
+    stream: ProcessStream;
+    /** Base64 bytes from from_cursor to next_cursor. */
+    data: string;
+    from_cursor: number;
+    next_cursor: number;
+    earliest_cursor: number;
+    gap: boolean;
+    truncated: boolean;
+    eof: boolean;
+    state: ProcessStateName;
+    ended_at?: string;
+    reason?: string;
+    exit_code: number | null;
+    exit_signal: string | null;
+    file_transfer?: FileTransferResult;
+}
+/** Result of process.start/interrupt/terminate and one process.list entry. ended_at (RFC 3339, executor clock) is set once the process is no longer running; reason explains a "failed" state (for example "timeout"). A spawn failure never creates a state: it is the process.start error with data.reason "spawn_failed". */
+export interface ProcessState {
+    process_id: string;
+    state: ProcessStateName;
+    pid?: number;
+    started_at?: string;
+    ended_at?: string;
+    reason?: string;
+    cursors: Cursors;
+    exit_code: number | null;
+    exit_signal: string | null;
+    stderr?: string;
+    accepted?: boolean;
+    file_transfer?: FileTransferResult;
+}
+/** Process state (v1.1 §3.3). */
+export type ProcessStateName = 'running' | 'exited' | 'failed' | 'killed';
+export declare const ProcessStateName: {
+    readonly Running: "running";
+    readonly Exited: "exited";
+    readonly Failed: "failed";
+    readonly Killed: "killed";
+};
+/** Process output stream (v1.1 §3.2). */
+export type ProcessStream = 'stdout' | 'stderr';
+export declare const ProcessStream: {
+    readonly Stdout: "stdout";
+    readonly Stderr: "stderr";
+};
+/** process.write result. */
+export interface ProcessWriteResult {
+    accepted: boolean;
+}
+/** Value of both the WebSocket subprotocol and executor.register protocol. A v1.1 server serves v1 executors and never sends them v1.1 methods. */
+export type ProtocolVersion = 'bma.executor.v1' | 'bma.executor.v1.1';
+export declare const ProtocolVersion: {
+    readonly BmaExecutorV1: "bma.executor.v1";
+    readonly BmaExecutorV11: "bma.executor.v1.1";
+};
+/** session.assign result. */
+export interface SessionAssignResult {
+    accepted: boolean;
+    session_id: string;
+}
+/** session.close result. */
+export interface SessionCloseResult {
+    closed: boolean;
+}
+/** A turn-level error. A failed turn still ends with session.status_idle turn_outcome=failed. */
+export interface SessionErrorEvent {
+    type: 'session.error';
+    error: AgentErrorInfo;
+}
+/** Durable session event emitted by the executor. */
+export interface SessionEvent {
+    type: SessionEventType;
+    tool_use_id?: string;
+    content?: Array<ContentBlock>;
+    is_error?: boolean;
+}
+/** session.event result. */
+export interface SessionEventResult {
+    accepted: boolean;
+    event_id: string;
+    /** Agent sessions: highest contiguous sequence the platform has persisted for the session. A duplicate event is accepted and reports the current value. */
+    acked_sequence?: number;
+}
+/** Durable event types an executor may emit. Event names follow Anthropic Managed Agents; the executor must not invent new names. A tool executor emits agent.tool_result only; an agent executor (capability agent) emits every type, shaped as schemas/agent.json AgentEvent. */
+export type SessionEventType = 'agent.tool_result' | 'agent.message' | 'agent.thinking' | 'agent.tool_use' | 'agent.mcp_tool_use' | 'agent.mcp_tool_result' | 'session.status_running' | 'session.status_idle' | 'session.error';
+export declare const SessionEventType: {
+    readonly AgentToolResult: "agent.tool_result";
+    readonly AgentMessage: "agent.message";
+    readonly AgentThinking: "agent.thinking";
+    readonly AgentToolUse: "agent.tool_use";
+    readonly AgentMcpToolUse: "agent.mcp_tool_use";
+    readonly AgentMcpToolResult: "agent.mcp_tool_result";
+    readonly SessionStatusRunning: "session.status_running";
+    readonly SessionStatusIdle: "session.status_idle";
+    readonly SessionError: "session.error";
+};
+/** A memory store mounted into the session workspace. */
+export interface SessionMemoryResource {
+    type: 'memory_store';
+    memory_store_id: string;
+    mount_path: string;
+}
+/** Lifecycle status reported by the executor. */
+export type SessionStatus = 'starting' | 'running' | 'idle' | 'stopping' | 'stopped' | 'error';
+export declare const SessionStatus: {
+    readonly Starting: "starting";
+    readonly Running: "running";
+    readonly Idle: "idle";
+    readonly Stopping: "stopping";
+    readonly Stopped: "stopped";
+    readonly Error: "error";
+};
+/** The turn ended. It is the last event of its turn_id; the platform publishes the turn as finished only after it accepted this event and every lower sequence. */
+export interface SessionStatusIdleEvent {
+    type: 'session.status_idle';
+    stop_reason: StopReason;
+    turn_outcome: TurnOutcome;
+}
+/** The local agent started working on the turn. */
+export interface SessionStatusRunningEvent {
+    type: 'session.status_running';
+}
+/** session.stop result. */
+export interface SessionStopResult {
+    stopped: boolean;
+}
+/** v1 one-shot shell tools. */
+export interface ShellCapability {
+    enabled: boolean;
+}
+/** skill.install result. state is "ready", or "failed" with error_code and error. */
+export interface SkillInstallResult {
+    state: 'ready' | 'failed';
+    error_code?: string;
+    error?: string;
+}
+/** skill.install support. Machine-scoped executors only. */
+export interface SkillsCapability {
+    install: boolean;
+}
+/** process.start stderr mode. "merge" redirects stderr into stdout at the OS level so one cursor covers both. */
+export type StderrMode = 'merge';
+export declare const StderrMode: {
+    readonly Merge: "merge";
+};
+/** process.start stdin mode. Empty or "closed" closes stdin at start; "open" keeps it open for process.write. */
+export type StdinMode = 'open' | 'closed';
+export declare const StdinMode: {
+    readonly Open: "open";
+    readonly Closed: "closed";
+};
+/** Why the turn stopped. */
+export interface StopReason {
+    type: StopReasonType;
+}
+/** Anthropic stop_reason types an executor may report. requires_action is not in the list: the platform projects it from open interactions. */
+export type StopReasonType = 'end_turn' | 'retries_exhausted';
+export declare const StopReasonType: {
+    readonly EndTurn: "end_turn";
+    readonly RetriesExhausted: "retries_exhausted";
+};
+/** terminal.attach result, returned after the host socket is connected and the attached frame was written on it. */
+export interface TerminalAttachResult {
+    accepted: boolean;
+    writer_epoch: number;
+}
+/** v1.1 terminal.* support. Machine-scoped executors only. */
+export interface TerminalCapability {
+    enabled: boolean;
+    kinds?: Array<string>;
+    max_sessions?: number;
+}
+/** terminal.close result. Idempotent: closing an unknown or closed terminal returns closed=true. */
+export interface TerminalCloseResult {
+    closed: boolean;
+    exit_code?: number | null;
+}
+/** JSON-RPC error.data of a failed terminal.* call. terminal_code is the bma.terminal.v1 code the harness relays to the attach (for example terminal_writer_busy). */
+export interface TerminalErrorData {
+    terminal_code?: string;
+}
+/** Outbound host socket for one attach. The ticket is a single-use, short-lived bearer credential sent only in the Authorization header, never in the URL. */
+export interface TerminalHost {
+    url: string;
+    ticket: string;
+}
+/** terminal.open result. epoch starts at 1 and increments when the executor recreates the PTY under the same terminal_id; attach is fenced by it. */
+export interface TerminalOpenResult {
+    terminal_id: string;
+    epoch: number;
+    pid: number;
+    rows: number;
+    cols: number;
+    earliest_seq: number;
+    latest_seq: number;
+    created_at: string;
+}
+/** tool.cancel result. */
+export interface ToolCancelResult {
+    canceled: boolean;
+}
+/** Built-in tool input. The selected tool decides which members are meaningful; unknown members are ignored. */
+export interface ToolInput {
+    command?: string;
+    cwd?: string;
+    timeout_ms?: number;
+    env?: Record<string, string>;
+    path?: string;
+    offset?: number;
+    limit?: number;
+    content?: string;
+    old_string?: string;
+    new_string?: string;
+    pattern?: string;
+    glob?: string;
+    display?: string;
+    action?: ComputerAction;
+}
+/** Built-in tool names. bmad serves bash only and answers -32012 for the rest. */
+export type ToolName = 'bash' | 'read' | 'write' | 'edit' | 'glob' | 'grep' | 'list_files' | 'computer_observe' | 'computer_action';
+export declare const ToolName: {
+    readonly Bash: "bash";
+    readonly Read: "read";
+    readonly Write: "write";
+    readonly Edit: "edit";
+    readonly Glob: "glob";
+    readonly Grep: "grep";
+    readonly ListFiles: "list_files";
+    readonly ComputerObserve: "computer_observe";
+    readonly ComputerAction: "computer_action";
+};
+/** Tool outcome. */
+export type ToolOutcome = 'succeeded' | 'failed' | 'canceled';
+export declare const ToolOutcome: {
+    readonly Succeeded: "succeeded";
+    readonly Failed: "failed";
+    readonly Canceled: "canceled";
+};
+/** Tool permission resolved by the harness. */
+export interface ToolPermission {
+    mode: PermissionMode;
+}
+/** turn.cancel result. canceled=false when the turn is unknown or already ended; the turn still ends with its own session.status_idle event. */
+export interface TurnCancelResult {
+    canceled: boolean;
+}
+/** BMA extension on session.status_idle: how the turn ended. */
+export type TurnOutcome = 'completed' | 'canceled' | 'failed';
+export declare const TurnOutcome: {
+    readonly Completed: "completed";
+    readonly Canceled: "canceled";
+    readonly Failed: "failed";
+};
+/** turn.start result. Idempotent by turn_id: a repeated turn.start for a turn the executor already accepted returns the same result without starting a second run. */
+export interface TurnStartResult {
+    accepted: boolean;
+    turn_id: string;
+    /** Opaque local session handle (for example the local agent's conversation id). The platform stores it and sends it back in the next turn.start so the executor can resume the local conversation after a restart. */
+    executor_session_ref: string;
+    /** true when the executor continued an existing local conversation, false when it started a new one. */
+    resumed: boolean;
+    effective: AgentTurnConfig;
+}
+/** workspace.backup result. digest and size_bytes describe the archive as the server stored it; skipped counts entries that could not be read (missing from the archive). */
+export interface WorkspaceBackupResult {
+    state: 'uploaded' | 'unchanged' | 'failed';
+    fingerprint?: string;
+    digest?: string;
+    size_bytes?: number;
+    entries?: number;
+    skipped?: number;
+    error?: string;
+}
+/** workspace.backup support and the startup restore of a pending backup. Machine-scoped executors only. */
+export interface WorkspaceCapability {
+    backup: boolean;
+}
+/** Params object of executor.register. */
+export interface ExecutorRegisterParams {
+    protocol: ProtocolVersion;
+    /** Selfhost environment id; empty for a machine-scoped executor. */
+    environment_id: string;
+    executor: ExecutorInfo;
+    capabilities: Capabilities;
+    resume?: ExecutorResume;
+}
+/** Params object of executor.heartbeat. */
+export interface ExecutorHeartbeatParams {
+    connection_id: string;
+    active_sessions: Array<string>;
+    load?: ExecutorLoad;
+}
+/** Params object of executor.capabilities.update. */
+export interface ExecutorCapabilitiesUpdateParams {
+    capabilities: Capabilities;
+}
+/** Params object of executor.drain. */
+export interface ExecutorDrainParams {
+    reason: string;
+    deadline_ms?: number;
+}
+/** Params object of executor.close. */
+export interface ExecutorCloseParams {
+    reason: string;
+}
+/** Params object of session.assign. */
+export interface SessionAssignParams {
+    session_id: string;
+    work_id: string;
+    agent_id?: string;
+    environment_id: string;
+    deadline_ms?: number;
+    lease: Lease;
+    resources?: Array<SessionMemoryResource>;
+    mcp_servers?: Array<McpServerConfig>;
+    metadata?: Record<string, string>;
+}
+/** Params object of session.ready. */
+export interface SessionReadyParams {
+    session_id: string;
+    work_id: string;
+    lease_token: string;
+}
+/** Params object of session.event. */
+export interface SessionEventParams {
+    session_id: string;
+    /** Agent sessions; the turn that produced the event. */
+    turn_id?: string;
+    /** Agent sessions; executor-assigned, unique within the session, stable across resends. */
+    event_id?: string;
+    /** Agent sessions; starts at 1 and increases by 1 per durable event within the session. */
+    sequence?: number;
+    event: SessionEvent;
+}
+/** Params object of session.status. */
+export interface SessionStatusParams {
+    session_id: string;
+    status: SessionStatus;
+    detail?: string;
+}
+/** Params object of session.stop. */
+export interface SessionStopParams {
+    session_id: string;
+    reason: string;
+    deadline_ms?: number;
+}
+/** Params object of session.ended. */
+export interface SessionEndedParams {
+    session_id: string;
+    reason: string;
+}
+/** Params object of tool.call. */
+export interface ToolCallParams {
+    session_id: string;
+    tool_call_id: string;
+    tool: ToolName;
+    input: ToolInput;
+    deadline_ms?: number;
+    permission?: ToolPermission;
+}
+/** Params object of tool.result. */
+export interface ToolResultParams {
+    session_id: string;
+    tool_call_id: string;
+    outcome: ToolOutcome;
+    is_error: boolean;
+    content: Array<ContentBlock>;
+    duration_ms?: number;
+    artifacts?: Array<ArtifactRef>;
+}
+/** Params object of tool.cancel. */
+export interface ToolCancelParams {
+    session_id: string;
+    tool_call_id: string;
+    reason?: string;
+}
+/** Params object of tool.progress. */
+export interface ToolProgressParams {
+    session_id: string;
+    tool_call_id: string;
+    message: string;
+}
+/** Params object of process.start. */
+export interface ProcessStartParams {
+    session_id: string;
+    process_id: string;
+    /** Command and arguments (at most 256 entries, 4 KiB each, 16 KiB total). Must be empty when file_transfer is set. */
+    argv: Array<string>;
+    cwd?: string;
+    env?: Record<string, string>;
+    stdin?: StdinMode;
+    /** Empty keeps separate stdout/stderr streams. */
+    stderr?: StderrMode;
+    wait_ms?: number;
+    /** Kills the process and ends it as failed with reason "timeout". */
+    timeout_ms?: number;
+    metadata?: Record<string, string>;
+    /** Requires capability process.pty. */
+    io_mode?: IOMode;
+    /** Requires capability process.file_transfer. Excludes argv entries, io_mode and git_credentials. */
+    file_transfer?: ProcessFileTransfer;
+    /** Installs a per-process Git credential helper for https://github.com that fetches short-lived tokens for this process while it runs. Requires capability process.git_credentials. */
+    git_credentials?: boolean;
+}
+/** Params object of process.read. */
+export interface ProcessReadParams {
+    session_id: string;
+    process_id: string;
+    stream: ProcessStream;
+    cursor: number;
+    max_bytes?: number;
+    wait_ms?: number;
+}
+/** Params object of process.write. */
+export interface ProcessWriteParams {
+    session_id: string;
+    process_id: string;
+    data?: string;
+    close_stdin?: boolean;
+}
+/** Params object of process.interrupt and process.terminate. */
+export interface ProcessSignalParams {
+    session_id: string;
+    process_id: string;
+    /** Only meaningful for process.terminate. */
+    grace_ms?: number | null;
+}
+/** Params object of process.list. */
+export interface ProcessListParams {
+    session_id: string;
+}
+/** Params object of process.status. */
+export interface ProcessStatusParams {
+    session_id: string;
+    process_id: string;
+    state: ProcessStateName;
+    exit_code?: number | null;
+    exit_signal?: string | null;
+    ended_at?: string;
+    reason?: string;
+    observed_at: string;
+}
+/** Params object of terminal.open. */
+export interface TerminalOpenParams {
+    terminal_id: string;
+    /** human or agent. */
+    kind: string;
+    shell?: string;
+    argv?: Array<string>;
+    cwd?: string;
+    env?: Record<string, string>;
+    rows?: number;
+    cols?: number;
+}
+/** Params object of terminal.attach. */
+export interface TerminalAttachParams {
+    terminal_id: string;
+    epoch: number;
+    stream_id: string;
+    can_write: boolean;
+    from_seq: number;
+    ack_seq: number;
+    host: TerminalHost;
+}
+/** Params object of terminal.close. */
+export interface TerminalCloseParams {
+    terminal_id: string;
+    reason?: string;
+}
+/** Params object of skill.install. */
+export interface SkillInstallParams {
+    machine_id: string;
+    skill_id: string;
+    revision_id: string;
+    digest: string;
+    download_token: string;
+    /** Unix seconds. */
+    download_expires_at: number;
+}
+/** Params object of workspace.backup. */
+export interface WorkspaceBackupParams {
+    backup_id: string;
+    paths: Array<string>;
+    exclude?: Array<string>;
+    skip_if_fingerprint?: string;
+}
+/** Params object of turn.start. */
+export interface TurnStartParams {
+    /** Platform session id. */
+    session_id: string;
+    turn_id: string;
+    /** Platform input id of the user message that starts the turn. */
+    input_id: string;
+    input: Array<AgentInputBlock>;
+    executor_session_ref?: string;
+    config?: AgentTurnConfig;
+    deadline_ms?: number;
+    metadata?: Record<string, string>;
+}
+/** Params object of turn.input. */
+export interface TurnInputParams {
+    session_id: string;
+    turn_id: string;
+    input_id: string;
+    input: Array<AgentInputBlock>;
+}
+/** Params object of turn.cancel. */
+export interface TurnCancelParams {
+    session_id: string;
+    turn_id: string;
+    reason?: string;
+}
+/** Params object of session.close. */
+export interface SessionCloseParams {
+    session_id: string;
+    reason: string;
+}
+/** Params object of session.event_delta. */
+export interface SessionEventDeltaParams {
+    session_id: string;
+    turn_id: string;
+    event_id: string;
+    event_type: EventDeltaType;
+    /** Content block index within the event. */
+    index: number;
+    /** Text appended to the block. */
+    text: string;
+}
+/** Params object of interaction.request. */
+export interface InteractionRequestParams {
+    session_id: string;
+    turn_id: string;
+    /** Executor-assigned, unique within the session. */
+    interaction_id: string;
+    kind: InteractionKind;
+    /** Required for permission. */
+    tool_use_id?: string;
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+    /** Grant scopes the user may pick for permission; defaults to once. */
+    scopes?: Array<InteractionScope>;
+    /** Required for question. */
+    question?: InteractionQuestion;
+    /** RFC 3339 time after which the executor stops waiting. */
+    expires_at?: string;
+}
+/** Params object of interaction.response. */
+export interface InteractionResponseParams {
+    session_id: string;
+    interaction_id: string;
+    outcome: InteractionOutcome;
+    /** Granted scope for allow. */
+    scope?: InteractionScope;
+    deny_message?: string;
+    /** Selected option ids or free text for answered. */
+    answers?: Array<string>;
+    responder?: InteractionResponder;
+}
+/** Params object of interaction.cancel. */
+export interface InteractionCancelParams {
+    session_id: string;
+    interaction_id: string;
+    reason: InteractionCancelReason;
+}
+/** Every executor protocol method. */
+export type MethodName = 'executor.register' | 'executor.heartbeat' | 'executor.capabilities.update' | 'executor.drain' | 'executor.close' | 'session.assign' | 'session.ready' | 'session.event' | 'session.status' | 'session.stop' | 'session.ended' | 'tool.call' | 'tool.result' | 'tool.cancel' | 'tool.progress' | 'process.start' | 'process.read' | 'process.write' | 'process.interrupt' | 'process.terminate' | 'process.list' | 'process.status' | 'terminal.open' | 'terminal.attach' | 'terminal.close' | 'skill.install' | 'workspace.backup' | 'turn.start' | 'turn.input' | 'turn.cancel' | 'session.close' | 'session.event_delta' | 'interaction.request' | 'interaction.response' | 'interaction.cancel';
+export type ExecutorToHarnessRequestMethod = 'executor.register' | 'executor.heartbeat' | 'session.ready' | 'session.event' | 'session.ended' | 'tool.result' | 'interaction.request' | 'interaction.cancel';
+export type ExecutorToHarnessNotificationMethod = 'executor.capabilities.update' | 'executor.close' | 'session.status' | 'tool.progress' | 'process.status' | 'session.event_delta';
+export type HarnessToExecutorRequestMethod = 'executor.drain' | 'session.assign' | 'session.stop' | 'tool.call' | 'tool.cancel' | 'process.start' | 'process.read' | 'process.write' | 'process.interrupt' | 'process.terminate' | 'process.list' | 'terminal.open' | 'terminal.attach' | 'terminal.close' | 'skill.install' | 'workspace.backup' | 'turn.start' | 'turn.input' | 'turn.cancel' | 'session.close' | 'interaction.response';
+export type HarnessToExecutorNotificationMethod = 'executor.close';
+export interface MethodParamsMap {
+    'executor.register': ExecutorRegisterParams;
+    'executor.heartbeat': ExecutorHeartbeatParams;
+    'executor.capabilities.update': ExecutorCapabilitiesUpdateParams;
+    'executor.drain': ExecutorDrainParams;
+    'executor.close': ExecutorCloseParams;
+    'session.assign': SessionAssignParams;
+    'session.ready': SessionReadyParams;
+    'session.event': SessionEventParams;
+    'session.status': SessionStatusParams;
+    'session.stop': SessionStopParams;
+    'session.ended': SessionEndedParams;
+    'tool.call': ToolCallParams;
+    'tool.result': ToolResultParams;
+    'tool.cancel': ToolCancelParams;
+    'tool.progress': ToolProgressParams;
+    'process.start': ProcessStartParams;
+    'process.read': ProcessReadParams;
+    'process.write': ProcessWriteParams;
+    'process.interrupt': ProcessSignalParams;
+    'process.terminate': ProcessSignalParams;
+    'process.list': ProcessListParams;
+    'process.status': ProcessStatusParams;
+    'terminal.open': TerminalOpenParams;
+    'terminal.attach': TerminalAttachParams;
+    'terminal.close': TerminalCloseParams;
+    'skill.install': SkillInstallParams;
+    'workspace.backup': WorkspaceBackupParams;
+    'turn.start': TurnStartParams;
+    'turn.input': TurnInputParams;
+    'turn.cancel': TurnCancelParams;
+    'session.close': SessionCloseParams;
+    'session.event_delta': SessionEventDeltaParams;
+    'interaction.request': InteractionRequestParams;
+    'interaction.response': InteractionResponseParams;
+    'interaction.cancel': InteractionCancelParams;
+}
+export interface MethodResultMap {
+    'executor.register': ExecutorRegisterResult;
+    'executor.heartbeat': ExecutorHeartbeatResult;
+    'executor.drain': ExecutorDrainResult;
+    'session.assign': SessionAssignResult;
+    'session.ready': Ack;
+    'session.event': SessionEventResult;
+    'session.stop': SessionStopResult;
+    'session.ended': Ack;
+    'tool.call': Ack;
+    'tool.result': Ack;
+    'tool.cancel': ToolCancelResult;
+    'process.start': ProcessState;
+    'process.read': ProcessReadResult;
+    'process.write': ProcessWriteResult;
+    'process.interrupt': ProcessState;
+    'process.terminate': ProcessState;
+    'process.list': ProcessListResult;
+    'terminal.open': TerminalOpenResult;
+    'terminal.attach': TerminalAttachResult;
+    'terminal.close': TerminalCloseResult;
+    'skill.install': SkillInstallResult;
+    'workspace.backup': WorkspaceBackupResult;
+    'turn.start': TurnStartResult;
+    'turn.input': Ack;
+    'turn.cancel': TurnCancelResult;
+    'session.close': SessionCloseResult;
+    'interaction.request': InteractionRequestResult;
+    'interaction.response': InteractionResponseResult;
+    'interaction.cancel': Ack;
+}
+/** since is the first protocol that has the method; capability is the capability bit the harness checks before sending it. */
+export interface MethodSpec {
+    readonly name: MethodName;
+    readonly direction: 'executor-to-harness' | 'harness-to-executor' | 'bidirectional';
+    readonly kind: 'request' | 'notification';
+    readonly since: ProtocolVersion;
+    readonly capability: string | null;
+    readonly idempotentBy: string | null;
+}
+export declare const methods: Readonly<Record<MethodName, MethodSpec>>;