@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.js

@@ -46,6 +46,24 @@ export function writeAcpRuntimeKind(bc, x) {
     }
 }
 function read0(bc) {
+    return bare.readBool(bc) ? readAcpRuntimeKind(bc) : null;
+}
+function write0(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeAcpRuntimeKind(bc, x);
+    }
+}
+function read1(bc) {
+    return bare.readBool(bc) ? bare.readString(bc) : null;
+}
+function write1(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeString(bc, x);
+    }
+}
+function read2(bc) {
     const len = bare.readUintSafe(bc);
     if (len === 0) {
         return [];
@@ -56,13 +74,22 @@ function read0(bc) {
     }
     return result;
 }
-function write0(bc, x) {
+function write2(bc, x) {
     bare.writeUintSafe(bc, x.length);
     for (let i = 0; i < x.length; i++) {
         bare.writeString(bc, x[i]);
     }
 }
-function read1(bc) {
+function read3(bc) {
+    return bare.readBool(bc) ? read2(bc) : null;
+}
+function write3(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        write2(bc, x);
+    }
+}
+function read4(bc) {
     const len = bare.readUintSafe(bc);
     const result = new Map();
     for (let i = 0; i < len; i++) {
@@ -76,70 +103,143 @@ function read1(bc) {
     }
     return result;
 }
-function write1(bc, x) {
+function write4(bc, x) {
     bare.writeUintSafe(bc, x.size);
     for (const kv of x) {
         bare.writeString(bc, kv[0]);
         bare.writeString(bc, kv[1]);
     }
 }
-function read2(bc) {
-    return bare.readBool(bc) ? bare.readString(bc) : null;
+function read5(bc) {
+    return bare.readBool(bc) ? read4(bc) : null;
 }
-function write2(bc, x) {
+function write5(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
-        bare.writeString(bc, x);
+        write4(bc, x);
     }
 }
-export function readAcpCreateSessionRequest(bc) {
-    return {
-        agentType: bare.readString(bc),
-        runtime: readAcpRuntimeKind(bc),
-        adapterEntrypoint: bare.readString(bc),
-        cwd: bare.readString(bc),
-        args: read0(bc),
-        env: read1(bc),
-        protocolVersion: bare.readI32(bc),
-        clientCapabilities: readJsonUtf8(bc),
-        mcpServers: readJsonUtf8(bc),
-        skipOsInstructions: bare.readBool(bc),
-        additionalInstructions: read2(bc),
-    };
+function read6(bc) {
+    return bare.readBool(bc) ? bare.readI32(bc) : null;
 }
-export function writeAcpCreateSessionRequest(bc, x) {
-    bare.writeString(bc, x.agentType);
-    writeAcpRuntimeKind(bc, x.runtime);
-    bare.writeString(bc, x.adapterEntrypoint);
-    bare.writeString(bc, x.cwd);
-    write0(bc, x.args);
-    write1(bc, x.env);
-    bare.writeI32(bc, x.protocolVersion);
-    writeJsonUtf8(bc, x.clientCapabilities);
-    writeJsonUtf8(bc, x.mcpServers);
-    bare.writeBool(bc, x.skipOsInstructions);
-    write2(bc, x.additionalInstructions);
+function write6(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeI32(bc, x);
+    }
 }
-function read3(bc) {
+function read7(bc) {
     return bare.readBool(bc) ? readJsonUtf8(bc) : null;
 }
-function write3(bc, x) {
+function write7(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
         writeJsonUtf8(bc, x);
     }
 }
+function read8(bc) {
+    return bare.readBool(bc) ? bare.readBool(bc) : null;
+}
+function write8(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeBool(bc, x);
+    }
+}
+export function readAcpCreateSessionRequest(bc) {
+    return {
+        agentType: bare.readString(bc),
+        runtime: read0(bc),
+        cwd: read1(bc),
+        args: read3(bc),
+        env: read5(bc),
+        protocolVersion: read6(bc),
+        clientCapabilities: read7(bc),
+        mcpServers: read7(bc),
+        skipOsInstructions: read8(bc),
+        additionalInstructions: read1(bc),
+    };
+}
+export function writeAcpCreateSessionRequest(bc, x) {
+    bare.writeString(bc, x.agentType);
+    write0(bc, x.runtime);
+    write1(bc, x.cwd);
+    write3(bc, x.args);
+    write5(bc, x.env);
+    write6(bc, x.protocolVersion);
+    write7(bc, x.clientCapabilities);
+    write7(bc, x.mcpServers);
+    write8(bc, x.skipOsInstructions);
+    write1(bc, x.additionalInstructions);
+}
 export function readAcpSessionRequest(bc) {
     return {
         sessionId: bare.readString(bc),
         method: bare.readString(bc),
-        params: read3(bc),
+        params: read7(bc),
     };
 }
 export function writeAcpSessionRequest(bc, x) {
     bare.writeString(bc, x.sessionId);
     bare.writeString(bc, x.method);
-    write3(bc, x.params);
+    write7(bc, x.params);
+}
+export function readAcpSetSessionConfigRequest(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        category: bare.readString(bc),
+        value: bare.readString(bc),
+    };
+}
+export function writeAcpSetSessionConfigRequest(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeString(bc, x.category);
+    bare.writeString(bc, x.value);
+}
+export function readAcpListAgentsRequest(bc) {
+    return {
+        reserved: bare.readBool(bc),
+    };
+}
+export function writeAcpListAgentsRequest(bc, x) {
+    bare.writeBool(bc, x.reserved);
+}
+export function readAcpAgentEntry(bc) {
+    return {
+        id: bare.readString(bc),
+        installed: bare.readBool(bc),
+        adapterEntrypoint: bare.readString(bc),
+    };
+}
+export function writeAcpAgentEntry(bc, x) {
+    bare.writeString(bc, x.id);
+    bare.writeBool(bc, x.installed);
+    bare.writeString(bc, x.adapterEntrypoint);
+}
+function read9(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readAcpAgentEntry(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readAcpAgentEntry(bc);
+    }
+    return result;
+}
+function write9(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeAcpAgentEntry(bc, x[i]);
+    }
+}
+export function readAcpListAgentsResponse(bc) {
+    return {
+        agents: read9(bc),
+    };
+}
+export function writeAcpListAgentsResponse(bc, x) {
+    write9(bc, x.agents);
 }
 export function readAcpGetSessionStateRequest(bc) {
     return {
@@ -149,6 +249,14 @@ export function readAcpGetSessionStateRequest(bc) {
 export function writeAcpGetSessionStateRequest(bc, x) {
     bare.writeString(bc, x.sessionId);
 }
+export function readAcpListSessionsRequest(bc) {
+    return {
+        reserved: bare.readBool(bc),
+    };
+}
+export function writeAcpListSessionsRequest(bc, x) {
+    bare.writeBool(bc, x.reserved);
+}
 export function readAcpCloseSessionRequest(bc) {
     return {
         sessionId: bare.readString(bc),
@@ -161,17 +269,99 @@ export function readAcpResumeSessionRequest(bc) {
     return {
         sessionId: bare.readString(bc),
         agentType: bare.readString(bc),
-        transcriptPath: read2(bc),
-        cwd: bare.readString(bc),
-        env: read1(bc),
+        transcriptPath: read1(bc),
+        cwd: read1(bc),
+        env: read5(bc),
     };
 }
 export function writeAcpResumeSessionRequest(bc, x) {
     bare.writeString(bc, x.sessionId);
     bare.writeString(bc, x.agentType);
-    write2(bc, x.transcriptPath);
-    bare.writeString(bc, x.cwd);
-    write1(bc, x.env);
+    write1(bc, x.transcriptPath);
+    write1(bc, x.cwd);
+    write5(bc, x.env);
+}
+export function readAcpDeliverAgentOutputRequest(bc) {
+    return {
+        processId: bare.readString(bc),
+        chunk: bare.readData(bc),
+    };
+}
+export function writeAcpDeliverAgentOutputRequest(bc, x) {
+    bare.writeString(bc, x.processId);
+    bare.writeData(bc, x.chunk);
+}
+export function readAcpDeliverAgentStderrRequest(bc) {
+    return {
+        processId: bare.readString(bc),
+        chunk: bare.readData(bc),
+    };
+}
+export function writeAcpDeliverAgentStderrRequest(bc, x) {
+    bare.writeString(bc, x.processId);
+    bare.writeData(bc, x.chunk);
+}
+/**
+ * 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 var AcpPendingAbortReason;
+(function (AcpPendingAbortReason) {
+    AcpPendingAbortReason["AgentExited"] = "AgentExited";
+    AcpPendingAbortReason["InteractionTimeout"] = "InteractionTimeout";
+    AcpPendingAbortReason["DriverFailed"] = "DriverFailed";
+    AcpPendingAbortReason["CallerCancelled"] = "CallerCancelled";
+})(AcpPendingAbortReason || (AcpPendingAbortReason = {}));
+export function readAcpPendingAbortReason(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return AcpPendingAbortReason.AgentExited;
+        case 1:
+            return AcpPendingAbortReason.InteractionTimeout;
+        case 2:
+            return AcpPendingAbortReason.DriverFailed;
+        case 3:
+            return AcpPendingAbortReason.CallerCancelled;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeAcpPendingAbortReason(bc, x) {
+    switch (x) {
+        case AcpPendingAbortReason.AgentExited: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case AcpPendingAbortReason.InteractionTimeout: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case AcpPendingAbortReason.DriverFailed: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+        case AcpPendingAbortReason.CallerCancelled: {
+            bare.writeU8(bc, 3);
+            break;
+        }
+    }
+}
+export function readAcpAbortPendingRequest(bc) {
+    return {
+        processId: bare.readString(bc),
+        reason: readAcpPendingAbortReason(bc),
+        exitCode: read6(bc),
+    };
+}
+export function writeAcpAbortPendingRequest(bc, x) {
+    bare.writeString(bc, x.processId);
+    writeAcpPendingAbortReason(bc, x.reason);
+    write6(bc, x.exitCode);
 }
 export function readAcpRequest(bc) {
     const offset = bc.offset;
@@ -182,11 +372,23 @@ export function readAcpRequest(bc) {
         case 1:
             return { tag: "AcpSessionRequest", val: readAcpSessionRequest(bc) };
         case 2:
-            return { tag: "AcpGetSessionStateRequest", val: readAcpGetSessionStateRequest(bc) };
+            return { tag: "AcpSetSessionConfigRequest", val: readAcpSetSessionConfigRequest(bc) };
         case 3:
-            return { tag: "AcpCloseSessionRequest", val: readAcpCloseSessionRequest(bc) };
+            return { tag: "AcpGetSessionStateRequest", val: readAcpGetSessionStateRequest(bc) };
         case 4:
+            return { tag: "AcpListSessionsRequest", val: readAcpListSessionsRequest(bc) };
+        case 5:
+            return { tag: "AcpCloseSessionRequest", val: readAcpCloseSessionRequest(bc) };
+        case 6:
             return { tag: "AcpResumeSessionRequest", val: readAcpResumeSessionRequest(bc) };
+        case 7:
+            return { tag: "AcpDeliverAgentOutputRequest", val: readAcpDeliverAgentOutputRequest(bc) };
+        case 8:
+            return { tag: "AcpDeliverAgentStderrRequest", val: readAcpDeliverAgentStderrRequest(bc) };
+        case 9:
+            return { tag: "AcpAbortPendingRequest", val: readAcpAbortPendingRequest(bc) };
+        case 10:
+            return { tag: "AcpListAgentsRequest", val: readAcpListAgentsRequest(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -205,21 +407,51 @@ export function writeAcpRequest(bc, x) {
             writeAcpSessionRequest(bc, x.val);
             break;
         }
-        case "AcpGetSessionStateRequest": {
+        case "AcpSetSessionConfigRequest": {
             bare.writeU8(bc, 2);
+            writeAcpSetSessionConfigRequest(bc, x.val);
+            break;
+        }
+        case "AcpGetSessionStateRequest": {
+            bare.writeU8(bc, 3);
             writeAcpGetSessionStateRequest(bc, x.val);
             break;
         }
+        case "AcpListSessionsRequest": {
+            bare.writeU8(bc, 4);
+            writeAcpListSessionsRequest(bc, x.val);
+            break;
+        }
         case "AcpCloseSessionRequest": {
-            bare.writeU8(bc, 3);
+            bare.writeU8(bc, 5);
             writeAcpCloseSessionRequest(bc, x.val);
             break;
         }
         case "AcpResumeSessionRequest": {
-            bare.writeU8(bc, 4);
+            bare.writeU8(bc, 6);
             writeAcpResumeSessionRequest(bc, x.val);
             break;
         }
+        case "AcpDeliverAgentOutputRequest": {
+            bare.writeU8(bc, 7);
+            writeAcpDeliverAgentOutputRequest(bc, x.val);
+            break;
+        }
+        case "AcpDeliverAgentStderrRequest": {
+            bare.writeU8(bc, 8);
+            writeAcpDeliverAgentStderrRequest(bc, x.val);
+            break;
+        }
+        case "AcpAbortPendingRequest": {
+            bare.writeU8(bc, 9);
+            writeAcpAbortPendingRequest(bc, x.val);
+            break;
+        }
+        case "AcpListAgentsRequest": {
+            bare.writeU8(bc, 10);
+            writeAcpListAgentsRequest(bc, x.val);
+            break;
+        }
     }
 }
 export function encodeAcpRequest(x, config) {
@@ -236,16 +468,16 @@ export function decodeAcpRequest(bytes) {
     }
     return result;
 }
-function read4(bc) {
+function read10(bc) {
     return bare.readBool(bc) ? bare.readU32(bc) : null;
 }
-function write4(bc, x) {
+function write10(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
         bare.writeU32(bc, x);
     }
 }
-function read5(bc) {
+function read11(bc) {
     const len = bare.readUintSafe(bc);
     if (len === 0) {
         return [];
@@ -256,7 +488,7 @@ function read5(bc) {
     }
     return result;
 }
-function write5(bc, x) {
+function write11(bc, x) {
     bare.writeUintSafe(bc, x.length);
     for (let i = 0; i < x.length; i++) {
         writeJsonUtf8(bc, x[i]);
@@ -265,65 +497,97 @@ function write5(bc, x) {
 export function readAcpSessionCreatedResponse(bc) {
     return {
         sessionId: bare.readString(bc),
-        pid: read4(bc),
-        modes: read3(bc),
-        configOptions: read5(bc),
-        agentCapabilities: read3(bc),
-        agentInfo: read3(bc),
+        agentType: bare.readString(bc),
+        processId: bare.readString(bc),
+        pid: read10(bc),
+        modes: read7(bc),
+        configOptions: read11(bc),
+        agentCapabilities: read7(bc),
+        agentInfo: read7(bc),
     };
 }
 export function writeAcpSessionCreatedResponse(bc, x) {
     bare.writeString(bc, x.sessionId);
-    write4(bc, x.pid);
-    write3(bc, x.modes);
-    write5(bc, x.configOptions);
-    write3(bc, x.agentCapabilities);
-    write3(bc, x.agentInfo);
+    bare.writeString(bc, x.agentType);
+    bare.writeString(bc, x.processId);
+    write10(bc, x.pid);
+    write7(bc, x.modes);
+    write11(bc, x.configOptions);
+    write7(bc, x.agentCapabilities);
+    write7(bc, x.agentInfo);
 }
 export function readAcpSessionRpcResponse(bc) {
     return {
         sessionId: bare.readString(bc),
         response: readJsonUtf8(bc),
+        text: read1(bc),
     };
 }
 export function writeAcpSessionRpcResponse(bc, x) {
     bare.writeString(bc, x.sessionId);
     writeJsonUtf8(bc, x.response);
-}
-function read6(bc) {
-    return bare.readBool(bc) ? bare.readI32(bc) : null;
-}
-function write6(bc, x) {
-    bare.writeBool(bc, x != null);
-    if (x != null) {
-        bare.writeI32(bc, x);
-    }
+    write1(bc, x.text);
 }
 export function readAcpSessionStateResponse(bc) {
     return {
         sessionId: bare.readString(bc),
         agentType: bare.readString(bc),
         processId: bare.readString(bc),
-        pid: read4(bc),
+        pid: read10(bc),
         closed: bare.readBool(bc),
         exitCode: read6(bc),
-        modes: read3(bc),
-        configOptions: read5(bc),
-        agentCapabilities: read3(bc),
-        agentInfo: read3(bc),
+        modes: read7(bc),
+        configOptions: read11(bc),
+        agentCapabilities: read7(bc),
+        agentInfo: read7(bc),
     };
 }
 export function writeAcpSessionStateResponse(bc, x) {
     bare.writeString(bc, x.sessionId);
     bare.writeString(bc, x.agentType);
     bare.writeString(bc, x.processId);
-    write4(bc, x.pid);
+    write10(bc, x.pid);
     bare.writeBool(bc, x.closed);
     write6(bc, x.exitCode);
-    write3(bc, x.modes);
-    write5(bc, x.configOptions);
-    write3(bc, x.agentCapabilities);
-    write3(bc, x.agentInfo);
+    write7(bc, x.modes);
+    write11(bc, x.configOptions);
+    write7(bc, x.agentCapabilities);
+    write7(bc, x.agentInfo);
+}
+export function readAcpSessionEntry(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        agentType: bare.readString(bc),
+    };
+}
+export function writeAcpSessionEntry(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeString(bc, x.agentType);
+}
+function read12(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readAcpSessionEntry(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readAcpSessionEntry(bc);
+    }
+    return result;
+}
+function write12(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeAcpSessionEntry(bc, x[i]);
+    }
+}
+export function readAcpListSessionsResponse(bc) {
+    return {
+        sessions: read12(bc),
+    };
+}
+export function writeAcpListSessionsResponse(bc, x) {
+    write12(bc, x.sessions);
 }
 export function readAcpSessionClosedResponse(bc) {
     return {
@@ -333,15 +597,29 @@ export function readAcpSessionClosedResponse(bc) {
 export function writeAcpSessionClosedResponse(bc, x) {
     bare.writeString(bc, x.sessionId);
 }
+export function readAcpAgentStderrDeliveredResponse(bc) {
+    return {
+        processId: bare.readString(bc),
+    };
+}
+export function writeAcpAgentStderrDeliveredResponse(bc, x) {
+    bare.writeString(bc, x.processId);
+}
 export function readAcpSessionResumedResponse(bc) {
     return {
         sessionId: bare.readString(bc),
         mode: bare.readString(bc),
+        agentType: bare.readString(bc),
+        processId: bare.readString(bc),
+        pid: read10(bc),
     };
 }
 export function writeAcpSessionResumedResponse(bc, x) {
     bare.writeString(bc, x.sessionId);
     bare.writeString(bc, x.mode);
+    bare.writeString(bc, x.agentType);
+    bare.writeString(bc, x.processId);
+    write10(bc, x.pid);
 }
 export function readAcpErrorResponse(bc) {
     return {
@@ -353,6 +631,18 @@ export function writeAcpErrorResponse(bc, x) {
     bare.writeString(bc, x.code);
     bare.writeString(bc, x.message);
 }
+export function readAcpPendingResponse(bc) {
+    return {
+        processId: bare.readString(bc),
+        timeoutMs: bare.readU32(bc),
+        timeoutPhase: bare.readString(bc),
+    };
+}
+export function writeAcpPendingResponse(bc, x) {
+    bare.writeString(bc, x.processId);
+    bare.writeU32(bc, x.timeoutMs);
+    bare.writeString(bc, x.timeoutPhase);
+}
 export function readAcpResponse(bc) {
     const offset = bc.offset;
     const tag = bare.readU8(bc);
@@ -364,11 +654,19 @@ export function readAcpResponse(bc) {
         case 2:
             return { tag: "AcpSessionStateResponse", val: readAcpSessionStateResponse(bc) };
         case 3:
-            return { tag: "AcpSessionClosedResponse", val: readAcpSessionClosedResponse(bc) };
+            return { tag: "AcpListSessionsResponse", val: readAcpListSessionsResponse(bc) };
         case 4:
-            return { tag: "AcpSessionResumedResponse", val: readAcpSessionResumedResponse(bc) };
+            return { tag: "AcpSessionClosedResponse", val: readAcpSessionClosedResponse(bc) };
         case 5:
+            return { tag: "AcpAgentStderrDeliveredResponse", val: readAcpAgentStderrDeliveredResponse(bc) };
+        case 6:
+            return { tag: "AcpSessionResumedResponse", val: readAcpSessionResumedResponse(bc) };
+        case 7:
             return { tag: "AcpErrorResponse", val: readAcpErrorResponse(bc) };
+        case 8:
+            return { tag: "AcpPendingResponse", val: readAcpPendingResponse(bc) };
+        case 9:
+            return { tag: "AcpListAgentsResponse", val: readAcpListAgentsResponse(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -392,21 +690,41 @@ export function writeAcpResponse(bc, x) {
             writeAcpSessionStateResponse(bc, x.val);
             break;
         }
-        case "AcpSessionClosedResponse": {
+        case "AcpListSessionsResponse": {
             bare.writeU8(bc, 3);
+            writeAcpListSessionsResponse(bc, x.val);
+            break;
+        }
+        case "AcpSessionClosedResponse": {
+            bare.writeU8(bc, 4);
             writeAcpSessionClosedResponse(bc, x.val);
             break;
         }
+        case "AcpAgentStderrDeliveredResponse": {
+            bare.writeU8(bc, 5);
+            writeAcpAgentStderrDeliveredResponse(bc, x.val);
+            break;
+        }
         case "AcpSessionResumedResponse": {
-            bare.writeU8(bc, 4);
+            bare.writeU8(bc, 6);
             writeAcpSessionResumedResponse(bc, x.val);
             break;
         }
         case "AcpErrorResponse": {
-            bare.writeU8(bc, 5);
+            bare.writeU8(bc, 7);
             writeAcpErrorResponse(bc, x.val);
             break;
         }
+        case "AcpPendingResponse": {
+            bare.writeU8(bc, 8);
+            writeAcpPendingResponse(bc, x.val);
+            break;
+        }
+        case "AcpListAgentsResponse": {
+            bare.writeU8(bc, 9);
+            writeAcpListAgentsResponse(bc, x.val);
+            break;
+        }
     }
 }
 export function encodeAcpResponse(x, config) {
@@ -433,12 +751,50 @@ export function writeAcpSessionEvent(bc, x) {
     bare.writeString(bc, x.sessionId);
     writeJsonUtf8(bc, x.notification);
 }
+export function readAcpAgentStderrEvent(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        agentType: bare.readString(bc),
+        processId: bare.readString(bc),
+        chunk: bare.readData(bc),
+    };
+}
+export function writeAcpAgentStderrEvent(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeString(bc, x.agentType);
+    bare.writeString(bc, x.processId);
+    bare.writeData(bc, x.chunk);
+}
+export function readAcpAgentExitedEvent(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        agentType: bare.readString(bc),
+        processId: bare.readString(bc),
+        exitCode: read6(bc),
+        restart: bare.readString(bc),
+        restartCount: bare.readU32(bc),
+        maxRestarts: bare.readU32(bc),
+    };
+}
+export function writeAcpAgentExitedEvent(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeString(bc, x.agentType);
+    bare.writeString(bc, x.processId);
+    write6(bc, x.exitCode);
+    bare.writeString(bc, x.restart);
+    bare.writeU32(bc, x.restartCount);
+    bare.writeU32(bc, x.maxRestarts);
+}
 export function readAcpEvent(bc) {
     const offset = bc.offset;
     const tag = bare.readU8(bc);
     switch (tag) {
         case 0:
             return { tag: "AcpSessionEvent", val: readAcpSessionEvent(bc) };
+        case 1:
+            return { tag: "AcpAgentStderrEvent", val: readAcpAgentStderrEvent(bc) };
+        case 2:
+            return { tag: "AcpAgentExitedEvent", val: readAcpAgentExitedEvent(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -452,6 +808,16 @@ export function writeAcpEvent(bc, x) {
             writeAcpSessionEvent(bc, x.val);
             break;
         }
+        case "AcpAgentStderrEvent": {
+            bare.writeU8(bc, 1);
+            writeAcpAgentStderrEvent(bc, x.val);
+            break;
+        }
+        case "AcpAgentExitedEvent": {
+            bare.writeU8(bc, 2);
+            writeAcpAgentExitedEvent(bc, x.val);
+            break;
+        }
     }
 }
 export function encodeAcpEvent(x, config) {
@@ -473,22 +839,14 @@ export function readAcpPermissionCallback(bc) {
         sessionId: bare.readString(bc),
         permissionId: bare.readString(bc),
         params: readJsonUtf8(bc),
+        cleanupAfterMs: bare.readU64(bc),
     };
 }
 export function writeAcpPermissionCallback(bc, x) {
     bare.writeString(bc, x.sessionId);
     bare.writeString(bc, x.permissionId);
     writeJsonUtf8(bc, x.params);
-}
-export function readAcpHostRequestCallback(bc) {
-    return {
-        sessionId: bare.readString(bc),
-        request: readJsonUtf8(bc),
-    };
-}
-export function writeAcpHostRequestCallback(bc, x) {
-    bare.writeString(bc, x.sessionId);
-    writeJsonUtf8(bc, x.request);
+    bare.writeU64(bc, x.cleanupAfterMs);
 }
 export function readAcpCallback(bc) {
     const offset = bc.offset;
@@ -496,8 +854,6 @@ export function readAcpCallback(bc) {
     switch (tag) {
         case 0:
             return { tag: "AcpPermissionCallback", val: readAcpPermissionCallback(bc) };
-        case 1:
-            return { tag: "AcpHostRequestCallback", val: readAcpHostRequestCallback(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -511,11 +867,6 @@ export function writeAcpCallback(bc, x) {
             writeAcpPermissionCallback(bc, x.val);
             break;
         }
-        case "AcpHostRequestCallback": {
-            bare.writeU8(bc, 1);
-            writeAcpHostRequestCallback(bc, x.val);
-            break;
-        }
     }
 }
 export function encodeAcpCallback(x, config) {
@@ -535,20 +886,12 @@ export function decodeAcpCallback(bytes) {
 export function readAcpPermissionCallbackResponse(bc) {
     return {
         permissionId: bare.readString(bc),
-        reply: bare.readString(bc),
+        reply: read1(bc),
     };
 }
 export function writeAcpPermissionCallbackResponse(bc, x) {
     bare.writeString(bc, x.permissionId);
-    bare.writeString(bc, x.reply);
-}
-export function readAcpHostRequestCallbackResponse(bc) {
-    return {
-        response: read3(bc),
-    };
-}
-export function writeAcpHostRequestCallbackResponse(bc, x) {
-    write3(bc, x.response);
+    write1(bc, x.reply);
 }
 export function readAcpCallbackResponse(bc) {
     const offset = bc.offset;
@@ -556,8 +899,6 @@ export function readAcpCallbackResponse(bc) {
     switch (tag) {
         case 0:
             return { tag: "AcpPermissionCallbackResponse", val: readAcpPermissionCallbackResponse(bc) };
-        case 1:
-            return { tag: "AcpHostRequestCallbackResponse", val: readAcpHostRequestCallbackResponse(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -571,11 +912,6 @@ export function writeAcpCallbackResponse(bc, x) {
             writeAcpPermissionCallbackResponse(bc, x.val);
             break;
         }
-        case "AcpHostRequestCallbackResponse": {
-            bare.writeU8(bc, 1);
-            writeAcpHostRequestCallbackResponse(bc, x.val);
-            break;
-        }
     }
 }
 export function encodeAcpCallbackResponse(x, config) {