@rivet-dev/agentos-core 0.0.0-abc-fixes-1.d8c4d95 → 0.0.0-agent-acp-codex-session-benchmark.62b1f46

package/dist/sidecar/agentos-protocol.d.ts

@@ -1,6 +1,7 @@
 import * as bare from "@rivetkit/bare-ts";
 export type i32 = number;
 export type u32 = number;
+export type u64 = bigint;
 export type JsonUtf8 = string;
 export declare function readJsonUtf8(bc: bare.ByteCursor): JsonUtf8;
 export declare function writeJsonUtf8(bc: bare.ByteCursor, x: JsonUtf8): void;
@@ -13,15 +14,14 @@ export declare function readAcpRuntimeKind(bc: bare.ByteCursor): AcpRuntimeKind;
 export declare function writeAcpRuntimeKind(bc: bare.ByteCursor, x: AcpRuntimeKind): void;
 export type AcpCreateSessionRequest = {
     readonly agentType: string;
-    readonly runtime: AcpRuntimeKind;
-    readonly adapterEntrypoint: string;
-    readonly cwd: string;
-    readonly args: readonly string[];
-    readonly env: ReadonlyMap<string, string>;
-    readonly protocolVersion: i32;
-    readonly clientCapabilities: JsonUtf8;
-    readonly mcpServers: JsonUtf8;
-    readonly skipOsInstructions: boolean;
+    readonly runtime: AcpRuntimeKind | null;
+    readonly cwd: string | null;
+    readonly args: readonly string[] | null;
+    readonly env: ReadonlyMap<string, string> | null;
+    readonly protocolVersion: i32 | null;
+    readonly clientCapabilities: JsonUtf8 | null;
+    readonly mcpServers: JsonUtf8 | null;
+    readonly skipOsInstructions: boolean | null;
     readonly additionalInstructions: string | null;
 };
 export declare function readAcpCreateSessionRequest(bc: bare.ByteCursor): AcpCreateSessionRequest;
@@ -33,11 +33,49 @@ export type AcpSessionRequest = {
 };
 export declare function readAcpSessionRequest(bc: bare.ByteCursor): AcpSessionRequest;
 export declare function writeAcpSessionRequest(bc: bare.ByteCursor, x: AcpSessionRequest): void;
+/**
+ * Select a session configuration option by its adapter-reported category. The
+ * sidecar owns category-to-config-id resolution and adapter-specific read-only
+ * behavior; clients forward only the caller's requested value.
+ */
+export type AcpSetSessionConfigRequest = {
+    readonly sessionId: string;
+    readonly category: string;
+    readonly value: string;
+};
+export declare function readAcpSetSessionConfigRequest(bc: bare.ByteCursor): AcpSetSessionConfigRequest;
+export declare function writeAcpSetSessionConfigRequest(bc: bare.ByteCursor, x: AcpSetSessionConfigRequest): void;
+/**
+ * Enumerate the agents available in this VM. The sidecar answers from the already
+ * projected `/opt/agentos` packages (client parses no manifests).
+ */
+export type AcpListAgentsRequest = {
+    readonly reserved: boolean;
+};
+export declare function readAcpListAgentsRequest(bc: bare.ByteCursor): AcpListAgentsRequest;
+export declare function writeAcpListAgentsRequest(bc: bare.ByteCursor, x: AcpListAgentsRequest): void;
+export type AcpAgentEntry = {
+    readonly id: string;
+    readonly installed: boolean;
+    readonly adapterEntrypoint: string;
+};
+export declare function readAcpAgentEntry(bc: bare.ByteCursor): AcpAgentEntry;
+export declare function writeAcpAgentEntry(bc: bare.ByteCursor, x: AcpAgentEntry): void;
+export type AcpListAgentsResponse = {
+    readonly agents: readonly AcpAgentEntry[];
+};
+export declare function readAcpListAgentsResponse(bc: bare.ByteCursor): AcpListAgentsResponse;
+export declare function writeAcpListAgentsResponse(bc: bare.ByteCursor, x: AcpListAgentsResponse): void;
 export type AcpGetSessionStateRequest = {
     readonly sessionId: string;
 };
 export declare function readAcpGetSessionStateRequest(bc: bare.ByteCursor): AcpGetSessionStateRequest;
 export declare function writeAcpGetSessionStateRequest(bc: bare.ByteCursor, x: AcpGetSessionStateRequest): void;
+export type AcpListSessionsRequest = {
+    readonly reserved: boolean;
+};
+export declare function readAcpListSessionsRequest(bc: bare.ByteCursor): AcpListSessionsRequest;
+export declare function writeAcpListSessionsRequest(bc: bare.ByteCursor, x: AcpListSessionsRequest): void;
 export type AcpCloseSessionRequest = {
     readonly sessionId: string;
 };
@@ -55,26 +93,93 @@ export type AcpResumeSessionRequest = {
     readonly sessionId: string;
     readonly agentType: string;
     readonly transcriptPath: string | null;
-    readonly cwd: string;
-    readonly env: ReadonlyMap<string, string>;
+    readonly cwd: string | null;
+    readonly env: ReadonlyMap<string, string> | null;
 };
 export declare function readAcpResumeSessionRequest(bc: bare.ByteCursor): AcpResumeSessionRequest;
 export declare function writeAcpResumeSessionRequest(bc: bare.ByteCursor, x: AcpResumeSessionRequest): void;
+/**
+ * Browser RESUMABLE path only (AGENTOS-WEB-ASYNC-AGENTS.md §3.2.1): the kernel
+ * worker feeds a chunk of the agent's stdout into the in-flight create_session /
+ * session/prompt handshake. The synchronous sidecar would block inside one
+ * pushFrame; the resumable browser path returns between steps so the worker can
+ * service the agent's own syscalls (incl. pi's net call for inference) on fresh,
+ * non-nested pushFrames. `processId` is the handshake handle returned in the
+ * AcpPendingResponse for the originating create/prompt request.
+ */
+export type AcpDeliverAgentOutputRequest = {
+    readonly processId: string;
+    readonly chunk: ArrayBuffer;
+};
+export declare function readAcpDeliverAgentOutputRequest(bc: bare.ByteCursor): AcpDeliverAgentOutputRequest;
+export declare function writeAcpDeliverAgentOutputRequest(bc: bare.ByteCursor, x: AcpDeliverAgentOutputRequest): void;
+/**
+ * Host-observed adapter stderr. The host forwards opaque bytes; the sidecar owns
+ * session identity, limits, event construction, and retryable delivery.
+ */
+export type AcpDeliverAgentStderrRequest = {
+    readonly processId: string;
+    readonly chunk: ArrayBuffer;
+};
+export declare function readAcpDeliverAgentStderrRequest(bc: bare.ByteCursor): AcpDeliverAgentStderrRequest;
+export declare function writeAcpDeliverAgentStderrRequest(bc: bare.ByteCursor, x: AcpDeliverAgentStderrRequest): void;
+/**
+ * Browser RESUMABLE terminal cleanup. The sidecar owns the stable error code and
+ * message for each observed terminal condition; the browser driver supplies only
+ * the process handle and the fact it observed.
+ */
+export declare enum AcpPendingAbortReason {
+    AgentExited = "AgentExited",
+    InteractionTimeout = "InteractionTimeout",
+    DriverFailed = "DriverFailed",
+    CallerCancelled = "CallerCancelled"
+}
+export declare function readAcpPendingAbortReason(bc: bare.ByteCursor): AcpPendingAbortReason;
+export declare function writeAcpPendingAbortReason(bc: bare.ByteCursor, x: AcpPendingAbortReason): void;
+export type AcpAbortPendingRequest = {
+    readonly processId: string;
+    readonly reason: AcpPendingAbortReason;
+    /**
+     * Present only when the browser execution transport directly observed a
+     * process exit status. Timeouts/driver failures and indirect exits omit it.
+     */
+    readonly exitCode: i32 | null;
+};
+export declare function readAcpAbortPendingRequest(bc: bare.ByteCursor): AcpAbortPendingRequest;
+export declare function writeAcpAbortPendingRequest(bc: bare.ByteCursor, x: AcpAbortPendingRequest): void;
 export type AcpRequest = {
     readonly tag: "AcpCreateSessionRequest";
     readonly val: AcpCreateSessionRequest;
 } | {
     readonly tag: "AcpSessionRequest";
     readonly val: AcpSessionRequest;
+} | {
+    readonly tag: "AcpSetSessionConfigRequest";
+    readonly val: AcpSetSessionConfigRequest;
 } | {
     readonly tag: "AcpGetSessionStateRequest";
     readonly val: AcpGetSessionStateRequest;
+} | {
+    readonly tag: "AcpListSessionsRequest";
+    readonly val: AcpListSessionsRequest;
 } | {
     readonly tag: "AcpCloseSessionRequest";
     readonly val: AcpCloseSessionRequest;
 } | {
     readonly tag: "AcpResumeSessionRequest";
     readonly val: AcpResumeSessionRequest;
+} | {
+    readonly tag: "AcpDeliverAgentOutputRequest";
+    readonly val: AcpDeliverAgentOutputRequest;
+} | {
+    readonly tag: "AcpDeliverAgentStderrRequest";
+    readonly val: AcpDeliverAgentStderrRequest;
+} | {
+    readonly tag: "AcpAbortPendingRequest";
+    readonly val: AcpAbortPendingRequest;
+} | {
+    readonly tag: "AcpListAgentsRequest";
+    readonly val: AcpListAgentsRequest;
 };
 export declare function readAcpRequest(bc: bare.ByteCursor): AcpRequest;
 export declare function writeAcpRequest(bc: bare.ByteCursor, x: AcpRequest): void;
@@ -82,6 +187,12 @@ export declare function encodeAcpRequest(x: AcpRequest, config?: Partial<bare.Co
 export declare function decodeAcpRequest(bytes: Uint8Array): AcpRequest;
 export type AcpSessionCreatedResponse = {
     readonly sessionId: string;
+    /**
+     * Complete host-route identity. Clients install the route atomically when this
+     * response frame arrives, before following bootstrap events are dispatched.
+     */
+    readonly agentType: string;
+    readonly processId: string;
     readonly pid: u32 | null;
     readonly modes: JsonUtf8 | null;
     readonly configOptions: readonly JsonUtf8[];
@@ -93,6 +204,11 @@ export declare function writeAcpSessionCreatedResponse(bc: bare.ByteCursor, x: A
 export type AcpSessionRpcResponse = {
     readonly sessionId: string;
     readonly response: JsonUtf8;
+    /**
+     * Present for session/prompt. The sidecar accumulates agent_message_chunk
+     * notifications while still streaming them as live session events.
+     */
+    readonly text: string | null;
 };
 export declare function readAcpSessionRpcResponse(bc: bare.ByteCursor): AcpSessionRpcResponse;
 export declare function writeAcpSessionRpcResponse(bc: bare.ByteCursor, x: AcpSessionRpcResponse): void;
@@ -110,11 +226,27 @@ export type AcpSessionStateResponse = {
 };
 export declare function readAcpSessionStateResponse(bc: bare.ByteCursor): AcpSessionStateResponse;
 export declare function writeAcpSessionStateResponse(bc: bare.ByteCursor, x: AcpSessionStateResponse): void;
+export type AcpSessionEntry = {
+    readonly sessionId: string;
+    readonly agentType: string;
+};
+export declare function readAcpSessionEntry(bc: bare.ByteCursor): AcpSessionEntry;
+export declare function writeAcpSessionEntry(bc: bare.ByteCursor, x: AcpSessionEntry): void;
+export type AcpListSessionsResponse = {
+    readonly sessions: readonly AcpSessionEntry[];
+};
+export declare function readAcpListSessionsResponse(bc: bare.ByteCursor): AcpListSessionsResponse;
+export declare function writeAcpListSessionsResponse(bc: bare.ByteCursor, x: AcpListSessionsResponse): void;
 export type AcpSessionClosedResponse = {
     readonly sessionId: string;
 };
 export declare function readAcpSessionClosedResponse(bc: bare.ByteCursor): AcpSessionClosedResponse;
 export declare function writeAcpSessionClosedResponse(bc: bare.ByteCursor, x: AcpSessionClosedResponse): void;
+export type AcpAgentStderrDeliveredResponse = {
+    readonly processId: string;
+};
+export declare function readAcpAgentStderrDeliveredResponse(bc: bare.ByteCursor): AcpAgentStderrDeliveredResponse;
+export declare function writeAcpAgentStderrDeliveredResponse(bc: bare.ByteCursor, x: AcpAgentStderrDeliveredResponse): void;
 /**
  * Result of AcpResumeSessionRequest. `sessionId` is the live ACP session id after
  * resume: equal to the requested id for native loads, or the freshly assigned id
@@ -125,6 +257,12 @@ export declare function writeAcpSessionClosedResponse(bc: bare.ByteCursor, x: Ac
 export type AcpSessionResumedResponse = {
     readonly sessionId: string;
     readonly mode: string;
+    /**
+     * Complete host-route identity for the newly live adapter/session.
+     */
+    readonly agentType: string;
+    readonly processId: string;
+    readonly pid: u32 | null;
 };
 export declare function readAcpSessionResumedResponse(bc: bare.ByteCursor): AcpSessionResumedResponse;
 export declare function writeAcpSessionResumedResponse(bc: bare.ByteCursor, x: AcpSessionResumedResponse): void;
@@ -134,6 +272,27 @@ export type AcpErrorResponse = {
 };
 export declare function readAcpErrorResponse(bc: bare.ByteCursor): AcpErrorResponse;
 export declare function writeAcpErrorResponse(bc: bare.ByteCursor, x: AcpErrorResponse): void;
+/**
+ * Browser RESUMABLE path: the create_session / session/prompt request (and each
+ * AcpDeliverAgentOutputRequest that has not yet completed the handshake) returns
+ * this, carrying the `processId` handle the kernel worker drives the interaction
+ * with. The real result (AcpSessionCreatedResponse / AcpSessionRpcResponse) is
+ * delivered as the response to the AcpDeliverAgentOutputRequest that completes it.
+ */
+export type AcpPendingResponse = {
+    readonly processId: string;
+    /**
+     * Sidecar-owned deadline for the currently awaited ACP phase.
+     */
+    readonly timeoutMs: u32;
+    /**
+     * Stable phase identity. Browser routing resets the deadline only when this
+     * changes; partial lines and same-phase notifications cannot extend it.
+     */
+    readonly timeoutPhase: string;
+};
+export declare function readAcpPendingResponse(bc: bare.ByteCursor): AcpPendingResponse;
+export declare function writeAcpPendingResponse(bc: bare.ByteCursor, x: AcpPendingResponse): void;
 export type AcpResponse = {
     readonly tag: "AcpSessionCreatedResponse";
     readonly val: AcpSessionCreatedResponse;
@@ -143,15 +302,27 @@ export type AcpResponse = {
 } | {
     readonly tag: "AcpSessionStateResponse";
     readonly val: AcpSessionStateResponse;
+} | {
+    readonly tag: "AcpListSessionsResponse";
+    readonly val: AcpListSessionsResponse;
 } | {
     readonly tag: "AcpSessionClosedResponse";
     readonly val: AcpSessionClosedResponse;
+} | {
+    readonly tag: "AcpAgentStderrDeliveredResponse";
+    readonly val: AcpAgentStderrDeliveredResponse;
 } | {
     readonly tag: "AcpSessionResumedResponse";
     readonly val: AcpSessionResumedResponse;
 } | {
     readonly tag: "AcpErrorResponse";
     readonly val: AcpErrorResponse;
+} | {
+    readonly tag: "AcpPendingResponse";
+    readonly val: AcpPendingResponse;
+} | {
+    readonly tag: "AcpListAgentsResponse";
+    readonly val: AcpListAgentsResponse;
 };
 export declare function readAcpResponse(bc: bare.ByteCursor): AcpResponse;
 export declare function writeAcpResponse(bc: bare.ByteCursor, x: AcpResponse): void;
@@ -163,9 +334,48 @@ export type AcpSessionEvent = {
 };
 export declare function readAcpSessionEvent(bc: bare.ByteCursor): AcpSessionEvent;
 export declare function writeAcpSessionEvent(bc: bare.ByteCursor, x: AcpSessionEvent): void;
+export type AcpAgentStderrEvent = {
+    readonly sessionId: string;
+    readonly agentType: string;
+    readonly processId: string;
+    readonly chunk: ArrayBuffer;
+};
+export declare function readAcpAgentStderrEvent(bc: bare.ByteCursor): AcpAgentStderrEvent;
+export declare function writeAcpAgentStderrEvent(bc: bare.ByteCursor, x: AcpAgentStderrEvent): void;
+/**
+ * Emitted when the ACP adapter process exits without an explicit close_session —
+ * a crash from the host's perspective (any spontaneous exit, including code 0).
+ * `restart` reports the sidecar's bounded auto-restart outcome:
+ *   "restarted"   — adapter respawned and the session was natively re-attached
+ *                   (session/load | session/resume) under the same sessionId;
+ *                   the session stays live.
+ *   "unsupported" — the respawned adapter does not advertise a native resume
+ *                   capability; the session record was evicted.
+ *   "failed"      — the respawn or the native re-attach errored; evicted.
+ *   "exhausted"   — maxRestarts was already spent for this session; evicted.
+ * `exitCode` is absent when the exit was observed indirectly (e.g. a write to
+ * the adapter's stdin failed because the process was already gone).
+ */
+export type AcpAgentExitedEvent = {
+    readonly sessionId: string;
+    readonly agentType: string;
+    readonly processId: string;
+    readonly exitCode: i32 | null;
+    readonly restart: string;
+    readonly restartCount: u32;
+    readonly maxRestarts: u32;
+};
+export declare function readAcpAgentExitedEvent(bc: bare.ByteCursor): AcpAgentExitedEvent;
+export declare function writeAcpAgentExitedEvent(bc: bare.ByteCursor, x: AcpAgentExitedEvent): void;
 export type AcpEvent = {
     readonly tag: "AcpSessionEvent";
     readonly val: AcpSessionEvent;
+} | {
+    readonly tag: "AcpAgentStderrEvent";
+    readonly val: AcpAgentStderrEvent;
+} | {
+    readonly tag: "AcpAgentExitedEvent";
+    readonly val: AcpAgentExitedEvent;
 };
 export declare function readAcpEvent(bc: bare.ByteCursor): AcpEvent;
 export declare function writeAcpEvent(bc: bare.ByteCursor, x: AcpEvent): void;
@@ -175,21 +385,18 @@ export type AcpPermissionCallback = {
     readonly sessionId: string;
     readonly permissionId: string;
     readonly params: JsonUtf8;
+    /**
+     * Sidecar-owned host bookkeeping deadline. This is strictly later than the
+     * sidecar's authoritative permission decision timeout; clients must not use
+     * it to choose the permission default.
+     */
+    readonly cleanupAfterMs: u64;
 };
 export declare function readAcpPermissionCallback(bc: bare.ByteCursor): AcpPermissionCallback;
 export declare function writeAcpPermissionCallback(bc: bare.ByteCursor, x: AcpPermissionCallback): void;
-export type AcpHostRequestCallback = {
-    readonly sessionId: string;
-    readonly request: JsonUtf8;
-};
-export declare function readAcpHostRequestCallback(bc: bare.ByteCursor): AcpHostRequestCallback;
-export declare function writeAcpHostRequestCallback(bc: bare.ByteCursor, x: AcpHostRequestCallback): void;
 export type AcpCallback = {
     readonly tag: "AcpPermissionCallback";
     readonly val: AcpPermissionCallback;
-} | {
-    readonly tag: "AcpHostRequestCallback";
-    readonly val: AcpHostRequestCallback;
 };
 export declare function readAcpCallback(bc: bare.ByteCursor): AcpCallback;
 export declare function writeAcpCallback(bc: bare.ByteCursor, x: AcpCallback): void;
@@ -197,21 +404,17 @@ export declare function encodeAcpCallback(x: AcpCallback, config?: Partial<bare.
 export declare function decodeAcpCallback(bytes: Uint8Array): AcpCallback;
 export type AcpPermissionCallbackResponse = {
     readonly permissionId: string;
-    readonly reply: string;
+    /**
+     * The client supplies only an explicit host answer. The ACP sidecar owns the
+     * default behavior when the route is absent, times out, or fails.
+     */
+    readonly reply: string | null;
 };
 export declare function readAcpPermissionCallbackResponse(bc: bare.ByteCursor): AcpPermissionCallbackResponse;
 export declare function writeAcpPermissionCallbackResponse(bc: bare.ByteCursor, x: AcpPermissionCallbackResponse): void;
-export type AcpHostRequestCallbackResponse = {
-    readonly response: JsonUtf8 | null;
-};
-export declare function readAcpHostRequestCallbackResponse(bc: bare.ByteCursor): AcpHostRequestCallbackResponse;
-export declare function writeAcpHostRequestCallbackResponse(bc: bare.ByteCursor, x: AcpHostRequestCallbackResponse): void;
 export type AcpCallbackResponse = {
     readonly tag: "AcpPermissionCallbackResponse";
     readonly val: AcpPermissionCallbackResponse;
-} | {
-    readonly tag: "AcpHostRequestCallbackResponse";
-    readonly val: AcpHostRequestCallbackResponse;
 };
 export declare function readAcpCallbackResponse(bc: bare.ByteCursor): AcpCallbackResponse;
 export declare function writeAcpCallbackResponse(bc: bare.ByteCursor, x: AcpCallbackResponse): void;