cursor-opencode-provider 0.2.2 → 0.2.4

package/dist/protocol/tools.js

@@ -1,6 +1,7 @@
 import { encodeMessage } from "./messages.js";
 import { encodeJsonAsValue, decodeStructEntriesToJson, readAllFields } from "./struct.js";
 import { trace } from "../debug.js";
+import { cursorExecVariantByRequestName } from "./exec-variants.js";
 // Exec variant field number whose reply is the server-initiated request_context
 // probe (ExecServerMessage #10 → ExecClientMessage #10). request/result share a
 // field number for every exec variant, so this is also the result field.
@@ -148,6 +149,8 @@ const cursorToolToOpencode = {
     ls_args: "read",
     delete_args: "bash",
     shell_stream_args: "bash",
+    background_shell_spawn_args: "bash",
+    subagent_args: "task",
     mcp_args: "mcp",
 };
 const opencodeToolToCursor = {
@@ -155,6 +158,7 @@ const opencodeToolToCursor = {
     write: "write_args",
     grep: "grep_args",
     bash: "shell_stream_args",
+    task: "subagent_args",
     mcp: "mcp_args",
 };
 /** Cursor-only fields that must not be forwarded as OpenCode tool input. */
@@ -203,26 +207,7 @@ export function mapExecServerToToolName(execField) {
 export function mapToolNameToExecField(toolName) {
     return opencodeToolToCursor[toolName];
 }
-// Cursor exec-request variant → the ExecClientMessage result field the client
-// must reply with. This is keyed off the REQUEST variant, not the opencode tool
-// name, because an MCP call must always answer with `mcp_result` even though the
-// resolved tool name (e.g. "read") looks like a built-in.
-const execVariantToResultField = {
-    read_args: "read_result",
-    write_args: "write_result",
-    pi_read_args: "pi_read_result",
-    pi_bash_args: "pi_bash_result",
-    pi_edit_args: "pi_edit_result",
-    pi_write_args: "pi_write_result",
-    pi_grep_args: "pi_grep_result",
-    pi_find_args: "pi_find_result",
-    pi_ls_args: "pi_ls_result",
-    grep_args: "grep_result",
-    ls_args: "ls_result",
-    delete_args: "delete_result",
-    shell_stream_args: "shell_stream",
-    mcp_args: "mcp_result",
-};
+const BACKGROUND_SHELL_MARKER = "__CURSOR_BACKGROUND_SHELL__";
 export function parseExecServerMessage(msg) {
     const id = msg.id;
     if (id === undefined)
@@ -233,12 +218,71 @@ export function parseExecServerMessage(msg) {
         "pi_read_args", "pi_bash_args", "pi_edit_args", "pi_write_args",
         "pi_grep_args", "pi_find_args", "pi_ls_args",
         "grep_args", "ls_args",
-        "delete_args", "shell_stream_args", "mcp_args",
+        "delete_args", "shell_stream_args", "background_shell_spawn_args", "mcp_args",
+        "subagent_args",
     ]);
     if (!execVariant)
         return undefined;
-    const resultField = execVariantToResultField[execVariant];
+    // Use the complete canonical request/result table. In particular, Pi request
+    // fields #45..#51 pair with result fields #46..#52 rather than matching ids.
+    const resultField = cursorExecVariantByRequestName(execVariant)?.resultName;
+    if (!resultField)
+        return undefined;
     const execId = msg.exec_id ?? "";
+    if (execVariant === "background_shell_spawn_args") {
+        const raw = msg.background_shell_spawn_args ?? {};
+        const command = str(raw.command);
+        const workingDirectory = str(raw.working_directory) ?? "";
+        const args = {};
+        if (command)
+            args.command = buildBackgroundShellCommand(command);
+        if (workingDirectory)
+            args.workdir = workingDirectory;
+        return {
+            id,
+            execId,
+            toolName: "bash",
+            args,
+            resultField,
+            resultMetadata: { command: command ?? "", working_directory: workingDirectory },
+            localError: raw.enable_write_shell_stdin_tool === true
+                ? "Interactive background shells are not available through OpenCode's bash tool."
+                : command
+                    ? undefined
+                    : "Cursor background shell request is missing a command.",
+        };
+    }
+    if (execVariant === "subagent_args") {
+        const raw = msg.subagent_args ?? {};
+        const prompt = str(raw.prompt);
+        const cursorSubagentType = str(raw.subagent_type);
+        const subagentType = cursorSubagentType
+            ? mapCursorSubagentTypeToOpenCode(cursorSubagentType)
+            : undefined;
+        const args = {
+            description: describeSubagentTask(prompt, subagentType),
+            prompt: prompt ?? "",
+            subagent_type: subagentType ?? "",
+        };
+        const resumeAgentId = str(raw.resume_agent_id);
+        if (resumeAgentId)
+            args.task_id = resumeAgentId;
+        // protobufjs materializes an absent proto3 optional bool as false in this
+        // reflection schema. OpenCode's foreground default is already false, so
+        // only forward the meaningful opt-in value.
+        if (raw.run_in_background === true)
+            args.background = true;
+        return {
+            id,
+            execId,
+            toolName: "task",
+            args,
+            resultField,
+            localError: prompt && cursorSubagentType
+                ? undefined
+                : "Cursor subagent request is missing a required prompt or subagent type.",
+        };
+    }
     if (execVariant === "mcp_args") {
         // An MCP call to one of the tools we advertised. Resolve the real opencode
         // tool name (Cursor's model may have shortened "opencode-read" → "read") and
@@ -284,12 +328,43 @@ export function parseExecServerMessage(msg) {
     if (!toolName)
         return undefined;
     const mapped = mapCursorArgsToOpencode(toolName, msg[execVariant] ?? {}, execVariant);
+    const resultMetadata = execVariant === "shell_stream_args"
+        ? shellStreamResultMetadata(msg[execVariant] ?? {})
+        : undefined;
+    if (resultMetadata
+        && resultMetadata.timeout_behavior !== 2
+        && typeof resultMetadata.timeout_ms === "number") {
+        // Cursor's protobuf default (timeout=0) means 30 seconds for an ordinary
+        // foreground shell. OpenCode instead treats zero literally, so pass the
+        // effective native value rather than the raw protobuf default.
+        mapped.args.timeout = resultMetadata.timeout_ms;
+    }
     return {
         id,
         execId,
         toolName: mapped.toolName,
         args: mapped.args,
         resultField,
+        ...(resultMetadata ? { resultMetadata } : {}),
+    };
+}
+function shellStreamResultMetadata(raw) {
+    const timeout = num(raw.timeout) ?? 0;
+    const timeoutBehavior = num(raw.timeout_behavior) ?? 0;
+    const hardTimeout = num(raw.hard_timeout);
+    // Cursor CLI: a nonzero timeout is used verbatim. A zero foreground timeout
+    // defaults to 30s; zero with background/hard-timeout semantics means an
+    // immediate soft handoff governed by the separate hard deadline.
+    const effectiveTimeout = timeout !== 0
+        ? timeout
+        : (timeoutBehavior === 2 || (hardTimeout !== undefined && hardTimeout > 0) ? 0 : 30_000);
+    return {
+        shell_stream: true,
+        command: str(raw.command) ?? "",
+        working_directory: str(raw.working_directory) ?? "",
+        timeout_ms: effectiveTimeout,
+        timeout_behavior: timeoutBehavior,
+        ...(hardTimeout !== undefined && hardTimeout > 0 ? { hard_timeout_ms: hardTimeout } : {}),
     };
 }
 /**
@@ -425,9 +500,42 @@ function num(v) {
         return Number(v);
     return undefined;
 }
+function describeSubagentTask(prompt, subagentType) {
+    const words = prompt?.replace(/\s+/g, " ").trim().split(" ").filter(Boolean).slice(0, 5);
+    if (words?.length)
+        return words.join(" ");
+    return `${subagentType || "Delegated"} task`;
+}
+function mapCursorSubagentTypeToOpenCode(subagentType) {
+    // Cursor's built-in general agent uses a camelCase protocol identifier, and
+    // its native Bugbot reviewer has no OpenCode-specific agent definition.
+    // OpenCode `general` is the general-purpose equivalent; `explore` preserves
+    // Bugbot's review-only/read-oriented semantics while retaining grep/read/bash.
+    // Preserve every other value so `explore` and configured custom agents keep
+    // their exact advertised names.
+    if (subagentType === "generalPurpose")
+        return "general";
+    if (subagentType === "bugbot")
+        return "explore";
+    return subagentType;
+}
 function shellQuote(s) {
     return `'${s.replace(/'/g, `'\\''`)}'`;
 }
+/**
+ * OpenCode's bash tool is foreground-only. Detach the requested command inside
+ * that one foreground call and print a private marker containing the spawned
+ * PID and log path. With stdin and all output redirected, the host shell can
+ * return immediately instead of retaining OpenCode's tool pipe.
+ */
+function buildBackgroundShellCommand(command) {
+    return [
+        'bg_log="$(mktemp "${TMPDIR:-/tmp}/cursor-opencode-bg.XXXXXX")" || exit 1',
+        `nohup sh -c ${shellQuote(command)} >"$bg_log" 2>&1 </dev/null &`,
+        "bg_pid=$!",
+        `printf '${BACKGROUND_SHELL_MARKER}%s:%s\\n' "$bg_pid" "$bg_log"`,
+    ].join("\n");
+}
 /**
  * Map Cursor McpArgs back to the OpenCode tool id.
  * Prefers provider_identifier + bare tool_name (github + create_pull_request
@@ -505,9 +613,32 @@ export function buildExecClientMessages(input) {
             if (input.output) {
                 frames.push(encodeShellStream(input.execId, undefined, { stdout: { data: input.output } }));
             }
-            frames.push(encodeShellStream(input.execId, input.executionTimeMs, {
-                exit: { code: 0, aborted: false },
-            }));
+            if (input.shellOutcome?.kind === "backgrounded") {
+                frames.push(encodeShellStream(input.execId, input.executionTimeMs, {
+                    backgrounded: {
+                        shell_id: input.shellOutcome.shellId,
+                        command: input.shellOutcome.command,
+                        working_directory: input.shellOutcome.workingDirectory,
+                        pid: input.shellOutcome.pid,
+                        ms_to_wait: input.shellOutcome.msToWait,
+                        reason: input.shellOutcome.reason,
+                    },
+                }));
+            }
+            else if (input.shellOutcome?.kind === "timeout") {
+                frames.push(encodeShellStream(input.execId, input.executionTimeMs, {
+                    // Native CLI represents timeout structurally. ShellAbortReason.TIMEOUT=2.
+                    exit: { code: 0, aborted: true, abort_reason: 2 },
+                }));
+            }
+            else {
+                const exitCode = input.shellOutcome?.kind === "exit"
+                    ? Math.max(0, Math.min(0xffff_ffff, input.shellOutcome.code))
+                    : 0;
+                frames.push(encodeShellStream(input.execId, input.executionTimeMs, {
+                    exit: { code: exitCode, aborted: false },
+                }));
+            }
         }
     }
     else {
@@ -515,7 +646,7 @@ export function buildExecClientMessages(input) {
             id: input.execId,
             local_execution_time_ms: input.executionTimeMs ?? 0,
         };
-        clientMsg[resultField] = buildTypedExecResult(resultField, input.output, input.error, input.toolName);
+        clientMsg[resultField] = buildTypedExecResult(resultField, input.output, input.error, input.toolName, input.resultMetadata);
         frames.push(encodeMessage("AgentClientMessage", {
             exec_client_message: clientMsg,
         }));
@@ -602,7 +733,7 @@ export function unwrapReadOutput(output) {
  * OpenCode returns free-form text; we wrap it in the minimal success shape the
  * server accepts (verified against agent.v1 wire captures).
  */
-export function buildTypedExecResult(resultField, output, error, toolName) {
+export function buildTypedExecResult(resultField, output, error, toolName, resultMetadata) {
     switch (resultField) {
         case "read_result":
             if (error)
@@ -673,6 +804,31 @@ export function buildTypedExecResult(resultField, output, error, toolName) {
             if (error)
                 return { error: { path: "", error } };
             return { success: { path: "", deleted_file: "" } };
+        case "background_shell_spawn_result": {
+            const command = str(resultMetadata?.command) ?? "";
+            const workingDirectory = str(resultMetadata?.working_directory) ?? "";
+            if (error)
+                return { error: { command, working_directory: workingDirectory, error } };
+            const match = new RegExp(`${BACKGROUND_SHELL_MARKER}(\\d+):([^\\r\\n]+)`).exec(output);
+            const pid = match ? Number(match[1]) : 0;
+            if (!Number.isSafeInteger(pid) || pid <= 0 || pid > 0xffff_ffff) {
+                return {
+                    error: {
+                        command,
+                        working_directory: workingDirectory,
+                        error: "OpenCode did not return a valid background shell process id.",
+                    },
+                };
+            }
+            return {
+                success: {
+                    shell_id: pid,
+                    command,
+                    working_directory: workingDirectory,
+                    pid,
+                },
+            };
+        }
         case "ls_result": {
             if (error)
                 return { error: { path: "", error } };
@@ -706,6 +862,27 @@ export function buildTypedExecResult(resultField, output, error, toolName) {
                     is_error: false,
                 },
             };
+        case "subagent_result": {
+            const task = parseOpenCodeTaskOutput(output);
+            if (error || task.state === "error") {
+                return {
+                    error: {
+                        ...(task.agentId ? { agent_id: task.agentId } : {}),
+                        error: error ?? task.message ?? output,
+                    },
+                };
+            }
+            return {
+                success: {
+                    agent_id: task.agentId ?? "",
+                    ...(task.message !== undefined ? { final_message: task.message } : {}),
+                    tool_call_count: 0,
+                    // OpenCode marks an asynchronous launch as state="running". Cursor's
+                    // canonical USER_REQUEST enum value is 2; foreground/default is 0.
+                    background_reason: task.state === "running" ? 2 : 0,
+                },
+            };
+        }
         default:
             // Unknown variant: best-effort success wrapper so the server sees a oneof.
             if (error)
@@ -713,6 +890,25 @@ export function buildTypedExecResult(resultField, output, error, toolName) {
             return { success: { content: output } };
     }
 }
+function parseOpenCodeTaskOutput(output) {
+    // Attribute order is not guaranteed; accept id/state in either order and
+    // ignore additional attributes OpenCode may emit on the <task> open tag.
+    const open = /<task\b([^>]*)>/i.exec(output);
+    if (!open)
+        return { message: output };
+    const attrs = open[1];
+    const agentId = /\bid="([^"]+)"/i.exec(attrs)?.[1];
+    const state = /\bstate="(running|completed|error)"/i.exec(attrs)?.[1];
+    if (!agentId || !state)
+        return { message: output };
+    const tag = state === "error" ? "task_error" : "task_result";
+    const body = new RegExp(`<${tag}>\\n?([\\s\\S]*?)\\n?</${tag}>`, "i").exec(output);
+    return {
+        agentId,
+        state,
+        message: body?.[1] ?? output,
+    };
+}
 function extractPathTag(output) {
     const m = output.match(/<path>([^<]+)<\/path>/);
     return m?.[1];
@@ -810,3 +1006,92 @@ export function buildRequestContextResult(execId, requestContext) {
         },
     });
 }
+/**
+ * Answer Cursor's exec #36 MCP-state probe from the same descriptors advertised
+ * in RequestContext. OpenCode remains the executor; this only confirms that the
+ * provider's virtual MCP servers and their tools are available.
+ */
+export function buildMcpStateResult(execId, args, requestContext) {
+    const requested = new Set(Array.isArray(args.server_identifiers)
+        ? args.server_identifiers.filter((id) => typeof id === "string" && id.length > 0)
+        : []);
+    const fsOptions = recordValue(requestContext.mcp_file_system_options);
+    const nested = Array.isArray(fsOptions?.mcp_descriptors)
+        ? fsOptions.mcp_descriptors.map(recordValue).filter((d) => !!d)
+        : [];
+    const descriptors = nested.length > 0 ? nested : descriptorsFromFlatTools(requestContext.tools);
+    const flatTools = Array.isArray(requestContext.tools)
+        ? requestContext.tools.map(recordValue).filter((tool) => !!tool)
+        : [];
+    const servers = descriptors
+        .filter((descriptor) => {
+        const id = stringValue(descriptor.server_identifier);
+        return requested.size === 0 || (id !== undefined && requested.has(id));
+    })
+        .map((descriptor) => {
+        const serverIdentifier = stringValue(descriptor.server_identifier) ?? stringValue(descriptor.server_name) ?? "";
+        const tools = Array.isArray(descriptor.tools)
+            ? descriptor.tools
+                .map(recordValue)
+                .filter((tool) => !!tool)
+                .map((tool) => mcpStateToolDefinition(serverIdentifier, tool, flatTools))
+            : [];
+        return {
+            server_name: stringValue(descriptor.server_name) ?? serverIdentifier,
+            server_identifier: serverIdentifier,
+            tools,
+        };
+    });
+    return encodeMessage("AgentClientMessage", {
+        exec_client_message: {
+            id: execId,
+            mcp_state_exec_result: { success: { servers } },
+        },
+    });
+}
+/**
+ * Exec #36 uses McpToolDefinition, not the narrower McpToolDescriptor used by
+ * RequestContext's filesystem/meta-tool catalogs. Rehydrate the full identity
+ * from RequestContext.tools so Cursor's native get_mcp_tools can correlate the
+ * discovered definition with the later provider_identifier/tool_name request.
+ */
+function mcpStateToolDefinition(serverIdentifier, descriptor, flatTools) {
+    const toolName = stringValue(descriptor.tool_name) ?? "";
+    const advertised = flatTools.find((tool) => stringValue(tool.provider_identifier) === serverIdentifier
+        && stringValue(tool.tool_name) === toolName);
+    return {
+        name: stringValue(advertised?.name) ?? `${serverIdentifier}-${toolName}`,
+        description: stringValue(advertised?.description) ?? stringValue(descriptor.description) ?? "",
+        input_schema: advertised?.input_schema ?? descriptor.input_schema,
+        provider_identifier: serverIdentifier,
+        tool_name: toolName,
+    };
+}
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function descriptorsFromFlatTools(value) {
+    if (!Array.isArray(value))
+        return [];
+    const byServer = new Map();
+    for (const raw of value) {
+        const tool = recordValue(raw);
+        if (!tool)
+            continue;
+        const server = stringValue(tool.provider_identifier) ?? "opencode";
+        const tools = byServer.get(server) ?? [];
+        tools.push({
+            tool_name: stringValue(tool.tool_name) ?? stringValue(tool.name) ?? "",
+            description: stringValue(tool.description) ?? "",
+            input_schema: tool.input_schema,
+        });
+        byServer.set(server, tools);
+    }
+    return [...byServer].map(([server, tools]) => ({
+        server_name: server,
+        server_identifier: server,
+        tools,
+    }));
+}

package/dist/session.d.ts

@@ -1,8 +1,26 @@
 import type { BidiStream } from "./transport/connect.js";
+import { type CursorProviderError } from "./errors.js";
+import { type SessionActivitySource } from "./activity.js";
 export type Frame = {
     flags: number;
     payload: Uint8Array;
 };
+export type CursorContinuationOptions = {
+    semanticIdleMs?: number;
+    /** @deprecated Use semanticIdleMs. Kept as a strict alias for compatibility. */
+    softHealthMs?: number;
+    /** Pending-tool inactivity window, renewed by OpenCode session progress. */
+    hardCapMs?: number;
+    heartbeatMs?: number;
+};
+export type CursorContinuationPolicy = {
+    semanticIdleMs: number;
+    hardCapMs: number;
+    heartbeatMs: number;
+};
+export declare const DEFAULT_CONTINUATION_POLICY: Readonly<CursorContinuationPolicy>;
+export declare function resolveContinuationPolicy(options: CursorContinuationOptions | undefined): CursorContinuationPolicy;
+export type PendingExecState = "pending" | "claimed" | "delivered";
 /**
  * A held-open Run stream. Cursor drives the agentic loop server-side and
  * expects tool results on the SAME bidi stream. opencode, by contrast, owns
@@ -14,11 +32,16 @@ export type Frame = {
 export type PendingExec = {
     /** ExecClientMessage result field to reply with (matches the request variant). */
     resultField: string;
+    state: PendingExecState;
+    registeredAt: number;
+    hardDeadlineAt: number;
     /**
      * Resolved opencode tool name (read/write/grep/…). Used on continuation so
      * mcp_result can unwrap read envelopes even if the prompt omits toolName.
      */
     toolName?: string;
+    /** Original request fields required by a typed result message. */
+    resultMetadata?: Record<string, unknown>;
     /**
      * True when this pending entry was synthesized from a Cursor display-only
      * tool_call_* frame (no ExecServerMessage). Continuation must not write an
@@ -26,6 +49,43 @@ export type PendingExec = {
      */
     bridged?: boolean;
 };
+export type ContinuationTerminalReason = "hard-cap-expired" | "remote-clean-close" | "remote-error" | "result-write-failed" | "ambiguous-partial-write" | "heartbeat-write-failed" | "reply-write-failed" | "process-disposed";
+export type SessionCloseReason = ContinuationTerminalReason | "ordinary-cleanup" | "turn-ended" | "initial-write-failed";
+export type ContinuationClaim = {
+    session: CursorSession;
+    execId: number;
+    pending: PendingExec;
+};
+export type ContinuationClassification = {
+    kind: "deliverable";
+    session: CursorSession;
+    pending: PendingExec;
+} | {
+    kind: "duplicate";
+    reason: "in-flight" | "delivered";
+} | {
+    kind: "terminal";
+    reason: ContinuationTerminalReason;
+} | {
+    kind: "missing";
+    reason: "missing-process-local-state";
+};
+export type DeliveryOutcome = {
+    kind: "delivered";
+    framesWritten: number;
+} | {
+    kind: "duplicate";
+    reason: "in-flight" | "delivered";
+    framesWritten: 0;
+} | {
+    kind: "terminal";
+    reason: ContinuationTerminalReason;
+    framesWritten: number;
+} | {
+    kind: "missing";
+    reason: "missing-process-local-state";
+    framesWritten: 0;
+};
 export type CursorSession = {
     /**
      * Stable per-Run-stream id (distinct from Cursor's own conversation_id).
@@ -36,8 +96,10 @@ export type CursorSession = {
     /**
      * Cursor conversation_id for this Run — used to store/echo
      * conversation_checkpoint_update (CLI parity).
-     */
+    */
     conversationId: string;
+    /** OpenCode session whose own or descendant activity renews tool leases. */
+    openCodeSessionId?: string;
     stream: BidiStream;
     frames: AsyncIterator<Frame>;
     pending: Map<number, PendingExec>;
@@ -77,26 +139,62 @@ export type CursorSession = {
      * Prevents a late cancel/abort from a prior ReadableStream from destroying
      * the Run connection after tool results were delivered (pending cleared) but
      * Cursor is still generating.
-     */
+    */
     pumpActive: boolean;
+    /** The active pull owner; stale cancel callbacks cannot affect a newer pump. */
+    pumpOwner: symbol | null;
     heartbeat: ReturnType<typeof setInterval> | null;
-    expiresAt: number;
+    heartbeatCancel: (() => void) | null;
+    hardDeadlineTimer: ReturnType<typeof setTimeout> | null;
+    semanticDeadlineCancel: (() => void) | null;
+    terminalUnsubscribe: (() => void) | null;
+    deferredTerminalReason: "remote-clean-close" | "remote-error" | null;
+    policy: CursorContinuationPolicy;
+    createdAt: number;
+    lastInboundAt: number;
+    lastHeartbeatWriteAt: number;
+    semanticDeadlineAt: number;
+    closeError: CursorProviderError | null;
+    closed: boolean;
+};
+type SessionManagerOptions = {
+    now?: () => number;
+    setTimer?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+    clearTimer?: (timer: ReturnType<typeof setTimeout>) => void;
+    activitySource?: SessionActivitySource;
+    tombstoneTtlMs?: number;
+    tombstoneLimit?: number;
 };
 export declare class SessionManager {
     private byExecId;
-    private readonly idleTimeoutMs;
-    constructor(idleTimeoutMs?: number);
-    touch(session: CursorSession): void;
+    private sessions;
+    private tombstones;
+    private readonly now;
+    private readonly setTimer;
+    private readonly clearTimer;
+    private readonly activitySource;
+    private readonly tombstoneTtlMs;
+    private readonly tombstoneLimit;
+    constructor(options?: SessionManagerOptions);
+    registerSession(session: CursorSession): void;
+    recordSemanticProgress(session: CursorSession, at?: number): void;
+    recordHeartbeatWrite(session: CursorSession): void;
     /** Register that `session` is awaiting a result for `execId`. */
-    registerPending(execId: number, session: CursorSession, resultField: string, toolName?: string, bridged?: boolean): void;
+    registerPending(execId: number, session: CursorSession, resultField: string, toolName?: string, bridged?: boolean, resultMetadata?: Record<string, unknown>): void;
     /** The pending exec info for an id on a specific session, if still awaiting it. */
     pendingFor(sessionId: string, execId: number): PendingExec | undefined;
+    classify(sessionId: string, execId: number): ContinuationClassification;
+    claim(sessionId: string, execId: number): ContinuationClaim | ContinuationClassification;
+    deliverClaim(claim: ContinuationClaim, frames: readonly Uint8Array[]): DeliveryOutcome;
     /** Find the live session awaiting one of the given exec ids. */
     findByExecIds(sessionId: string, execIds: number[]): CursorSession | undefined;
     /** Mark an exec id as resolved (its result has been delivered). */
     resolve(sessionId: string, execId: number): void;
+    beginPump(session: CursorSession, owner: symbol): void;
+    isPumpOwner(session: CursorSession, owner: symbol): boolean;
+    endPump(session: CursorSession, owner: symbol): boolean;
     private key;
-    close(session: CursorSession): void;
+    close(session: CursorSession, reason?: SessionCloseReason, error?: CursorProviderError): void;
     /**
      * Close only if nothing is awaiting a tool result AND no pull() is actively
      * pumping this session. OpenCode aborts each doStream after finishReason
@@ -107,5 +205,14 @@ export declare class SessionManager {
      */
     closeUnlessPending(session: CursorSession): boolean;
     dispose(): void;
+    sweepHardDeadlines(): void;
+    private onStreamTerminal;
+    private refreshHardDeadline;
+    private hardDeadlineExpired;
+    private scheduleHardDeadline;
+    private getTombstone;
+    private putTombstone;
+    private isTerminalReason;
 }
 export declare const sessionManager: SessionManager;
+export {};