@rivet-dev/agentos-core 0.0.0-integrate-dylib-into-main.815fcda → 0.0.0-main.29b0797

package/dist/sidecar/agentos-protocol.js

@@ -96,7 +96,6 @@ 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),
@@ -110,7 +109,6 @@ export function readAcpCreateSessionRequest(bc) {
 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);
@@ -141,6 +139,218 @@ export function writeAcpSessionRequest(bc, x) {
     bare.writeString(bc, x.method);
     write3(bc, x.params);
 }
+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 read4(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 write4(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: read4(bc),
+    };
+}
+export function writeAcpListAgentsResponse(bc, x) {
+    write4(bc, x.agents);
+}
+function read5(bc) {
+    return bare.readBool(bc) ? bare.readBool(bc) : null;
+}
+function write5(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeBool(bc, x);
+    }
+}
+export function readAcpOpenSessionRequest(bc) {
+    return {
+        sessionId: read2(bc),
+        agent: bare.readString(bc),
+        cwd: read2(bc),
+        additionalDirectories: read3(bc),
+        env: read3(bc),
+        mcpServers: read3(bc),
+        permissionPolicy: read2(bc),
+        skipOsInstructions: read5(bc),
+        additionalInstructions: read2(bc),
+    };
+}
+export function writeAcpOpenSessionRequest(bc, x) {
+    write2(bc, x.sessionId);
+    bare.writeString(bc, x.agent);
+    write2(bc, x.cwd);
+    write3(bc, x.additionalDirectories);
+    write3(bc, x.env);
+    write3(bc, x.mcpServers);
+    write2(bc, x.permissionPolicy);
+    write5(bc, x.skipOsInstructions);
+    write2(bc, x.additionalInstructions);
+}
+export function readAcpGetDurableSessionRequest(bc) {
+    return {
+        sessionId: read2(bc),
+    };
+}
+export function writeAcpGetDurableSessionRequest(bc, x) {
+    write2(bc, x.sessionId);
+}
+function read6(bc) {
+    return bare.readBool(bc) ? bare.readU32(bc) : null;
+}
+function write6(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeU32(bc, x);
+    }
+}
+export function readAcpListDurableSessionsRequest(bc) {
+    return {
+        cursor: read2(bc),
+        limit: read6(bc),
+    };
+}
+export function writeAcpListDurableSessionsRequest(bc, x) {
+    write2(bc, x.cursor);
+    write6(bc, x.limit);
+}
+export function readAcpDeleteSessionRequest(bc) {
+    return {
+        sessionId: read2(bc),
+    };
+}
+export function writeAcpDeleteSessionRequest(bc, x) {
+    write2(bc, x.sessionId);
+}
+export function readAcpUnloadSessionRequest(bc) {
+    return {
+        sessionId: read2(bc),
+    };
+}
+export function writeAcpUnloadSessionRequest(bc, x) {
+    write2(bc, x.sessionId);
+}
+export function readAcpPromptRequest(bc) {
+    return {
+        sessionId: read2(bc),
+        idempotencyKey: read2(bc),
+        content: readJsonUtf8(bc),
+    };
+}
+export function writeAcpPromptRequest(bc, x) {
+    write2(bc, x.sessionId);
+    write2(bc, x.idempotencyKey);
+    writeJsonUtf8(bc, x.content);
+}
+export function readAcpCancelPromptRequest(bc) {
+    return {
+        sessionId: read2(bc),
+    };
+}
+export function writeAcpCancelPromptRequest(bc, x) {
+    write2(bc, x.sessionId);
+}
+export function readAcpRespondPermissionRequest(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        requestId: bare.readString(bc),
+        optionId: bare.readString(bc),
+    };
+}
+export function writeAcpRespondPermissionRequest(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeString(bc, x.requestId);
+    bare.writeString(bc, x.optionId);
+}
+function read7(bc) {
+    return bare.readBool(bc) ? bare.readU64(bc) : null;
+}
+function write7(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeU64(bc, x);
+    }
+}
+export function readAcpReadHistoryRequest(bc) {
+    return {
+        sessionId: read2(bc),
+        before: read7(bc),
+        after: read7(bc),
+        limit: read6(bc),
+    };
+}
+export function writeAcpReadHistoryRequest(bc, x) {
+    write2(bc, x.sessionId);
+    write7(bc, x.before);
+    write7(bc, x.after);
+    write6(bc, x.limit);
+}
+export function readAcpGetSessionConfigRequest(bc) {
+    return {
+        sessionId: read2(bc),
+    };
+}
+export function writeAcpGetSessionConfigRequest(bc, x) {
+    write2(bc, x.sessionId);
+}
+export function readAcpGetSessionCapabilitiesRequest(bc) {
+    return {
+        sessionId: read2(bc),
+    };
+}
+export function writeAcpGetSessionCapabilitiesRequest(bc, x) {
+    write2(bc, x.sessionId);
+}
+export function readAcpGetSessionAgentInfoRequest(bc) {
+    return {
+        sessionId: read2(bc),
+    };
+}
+export function writeAcpGetSessionAgentInfoRequest(bc, x) {
+    write2(bc, x.sessionId);
+}
+export function readAcpSetSessionConfigOptionRequest(bc) {
+    return {
+        sessionId: read2(bc),
+        configId: bare.readString(bc),
+        value: readJsonUtf8(bc),
+    };
+}
+export function writeAcpSetSessionConfigOptionRequest(bc, x) {
+    write2(bc, x.sessionId);
+    bare.writeString(bc, x.configId);
+    writeJsonUtf8(bc, x.value);
+}
 export function readAcpGetSessionStateRequest(bc) {
     return {
         sessionId: bare.readString(bc),
@@ -173,20 +383,60 @@ export function writeAcpResumeSessionRequest(bc, x) {
     bare.writeString(bc, x.cwd);
     write1(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 readAcpRequest(bc) {
     const offset = bc.offset;
     const tag = bare.readU8(bc);
     switch (tag) {
         case 0:
-            return { tag: "AcpCreateSessionRequest", val: readAcpCreateSessionRequest(bc) };
+            return { tag: "AcpOpenSessionRequest", val: readAcpOpenSessionRequest(bc) };
         case 1:
-            return { tag: "AcpSessionRequest", val: readAcpSessionRequest(bc) };
+            return { tag: "AcpGetDurableSessionRequest", val: readAcpGetDurableSessionRequest(bc) };
         case 2:
-            return { tag: "AcpGetSessionStateRequest", val: readAcpGetSessionStateRequest(bc) };
+            return { tag: "AcpListDurableSessionsRequest", val: readAcpListDurableSessionsRequest(bc) };
         case 3:
-            return { tag: "AcpCloseSessionRequest", val: readAcpCloseSessionRequest(bc) };
+            return { tag: "AcpDeleteSessionRequest", val: readAcpDeleteSessionRequest(bc) };
         case 4:
+            return { tag: "AcpUnloadSessionRequest", val: readAcpUnloadSessionRequest(bc) };
+        case 5:
+            return { tag: "AcpPromptRequest", val: readAcpPromptRequest(bc) };
+        case 6:
+            return { tag: "AcpCancelPromptRequest", val: readAcpCancelPromptRequest(bc) };
+        case 7:
+            return { tag: "AcpRespondPermissionRequest", val: readAcpRespondPermissionRequest(bc) };
+        case 8:
+            return { tag: "AcpReadHistoryRequest", val: readAcpReadHistoryRequest(bc) };
+        case 9:
+            return { tag: "AcpGetSessionConfigRequest", val: readAcpGetSessionConfigRequest(bc) };
+        case 10:
+            return { tag: "AcpSetSessionConfigOptionRequest", val: readAcpSetSessionConfigOptionRequest(bc) };
+        case 11:
+            return { tag: "AcpGetSessionCapabilitiesRequest", val: readAcpGetSessionCapabilitiesRequest(bc) };
+        case 12:
+            return { tag: "AcpGetSessionAgentInfoRequest", val: readAcpGetSessionAgentInfoRequest(bc) };
+        case 13:
+            return { tag: "AcpCreateSessionRequest", val: readAcpCreateSessionRequest(bc) };
+        case 14:
+            return { tag: "AcpSessionRequest", val: readAcpSessionRequest(bc) };
+        case 15:
+            return { tag: "AcpGetSessionStateRequest", val: readAcpGetSessionStateRequest(bc) };
+        case 16:
+            return { tag: "AcpCloseSessionRequest", val: readAcpCloseSessionRequest(bc) };
+        case 17:
             return { tag: "AcpResumeSessionRequest", val: readAcpResumeSessionRequest(bc) };
+        case 18:
+            return { tag: "AcpDeliverAgentOutputRequest", val: readAcpDeliverAgentOutputRequest(bc) };
+        case 19:
+            return { tag: "AcpListAgentsRequest", val: readAcpListAgentsRequest(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -195,31 +445,106 @@ export function readAcpRequest(bc) {
 }
 export function writeAcpRequest(bc, x) {
     switch (x.tag) {
-        case "AcpCreateSessionRequest": {
+        case "AcpOpenSessionRequest": {
             bare.writeU8(bc, 0);
+            writeAcpOpenSessionRequest(bc, x.val);
+            break;
+        }
+        case "AcpGetDurableSessionRequest": {
+            bare.writeU8(bc, 1);
+            writeAcpGetDurableSessionRequest(bc, x.val);
+            break;
+        }
+        case "AcpListDurableSessionsRequest": {
+            bare.writeU8(bc, 2);
+            writeAcpListDurableSessionsRequest(bc, x.val);
+            break;
+        }
+        case "AcpDeleteSessionRequest": {
+            bare.writeU8(bc, 3);
+            writeAcpDeleteSessionRequest(bc, x.val);
+            break;
+        }
+        case "AcpUnloadSessionRequest": {
+            bare.writeU8(bc, 4);
+            writeAcpUnloadSessionRequest(bc, x.val);
+            break;
+        }
+        case "AcpPromptRequest": {
+            bare.writeU8(bc, 5);
+            writeAcpPromptRequest(bc, x.val);
+            break;
+        }
+        case "AcpCancelPromptRequest": {
+            bare.writeU8(bc, 6);
+            writeAcpCancelPromptRequest(bc, x.val);
+            break;
+        }
+        case "AcpRespondPermissionRequest": {
+            bare.writeU8(bc, 7);
+            writeAcpRespondPermissionRequest(bc, x.val);
+            break;
+        }
+        case "AcpReadHistoryRequest": {
+            bare.writeU8(bc, 8);
+            writeAcpReadHistoryRequest(bc, x.val);
+            break;
+        }
+        case "AcpGetSessionConfigRequest": {
+            bare.writeU8(bc, 9);
+            writeAcpGetSessionConfigRequest(bc, x.val);
+            break;
+        }
+        case "AcpSetSessionConfigOptionRequest": {
+            bare.writeU8(bc, 10);
+            writeAcpSetSessionConfigOptionRequest(bc, x.val);
+            break;
+        }
+        case "AcpGetSessionCapabilitiesRequest": {
+            bare.writeU8(bc, 11);
+            writeAcpGetSessionCapabilitiesRequest(bc, x.val);
+            break;
+        }
+        case "AcpGetSessionAgentInfoRequest": {
+            bare.writeU8(bc, 12);
+            writeAcpGetSessionAgentInfoRequest(bc, x.val);
+            break;
+        }
+        case "AcpCreateSessionRequest": {
+            bare.writeU8(bc, 13);
             writeAcpCreateSessionRequest(bc, x.val);
             break;
         }
         case "AcpSessionRequest": {
-            bare.writeU8(bc, 1);
+            bare.writeU8(bc, 14);
             writeAcpSessionRequest(bc, x.val);
             break;
         }
         case "AcpGetSessionStateRequest": {
-            bare.writeU8(bc, 2);
+            bare.writeU8(bc, 15);
             writeAcpGetSessionStateRequest(bc, x.val);
             break;
         }
         case "AcpCloseSessionRequest": {
-            bare.writeU8(bc, 3);
+            bare.writeU8(bc, 16);
             writeAcpCloseSessionRequest(bc, x.val);
             break;
         }
         case "AcpResumeSessionRequest": {
-            bare.writeU8(bc, 4);
+            bare.writeU8(bc, 17);
             writeAcpResumeSessionRequest(bc, x.val);
             break;
         }
+        case "AcpDeliverAgentOutputRequest": {
+            bare.writeU8(bc, 18);
+            writeAcpDeliverAgentOutputRequest(bc, x.val);
+            break;
+        }
+        case "AcpListAgentsRequest": {
+            bare.writeU8(bc, 19);
+            writeAcpListAgentsRequest(bc, x.val);
+            break;
+        }
     }
 }
 export function encodeAcpRequest(x, config) {
@@ -236,16 +561,258 @@ export function decodeAcpRequest(bytes) {
     }
     return result;
 }
-function read4(bc) {
-    return bare.readBool(bc) ? bare.readU32(bc) : null;
+export function readAcpDurableSessionInfo(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        agent: bare.readString(bc),
+        cwd: bare.readString(bc),
+        additionalDirectories: readJsonUtf8(bc),
+        state: readJsonUtf8(bc),
+        latestSequence: bare.readU64(bc),
+        title: read2(bc),
+        metadata: read3(bc),
+        createdAt: bare.readString(bc),
+        updatedAt: bare.readString(bc),
+    };
 }
-function write4(bc, x) {
-    bare.writeBool(bc, x != null);
-    if (x != null) {
-        bare.writeU32(bc, x);
+export function writeAcpDurableSessionInfo(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeString(bc, x.agent);
+    bare.writeString(bc, x.cwd);
+    writeJsonUtf8(bc, x.additionalDirectories);
+    writeJsonUtf8(bc, x.state);
+    bare.writeU64(bc, x.latestSequence);
+    write2(bc, x.title);
+    write3(bc, x.metadata);
+    bare.writeString(bc, x.createdAt);
+    bare.writeString(bc, x.updatedAt);
+}
+export function readAcpOpenSessionResponse(bc) {
+    return {
+        reserved: bare.readBool(bc),
+    };
+}
+export function writeAcpOpenSessionResponse(bc, x) {
+    bare.writeBool(bc, x.reserved);
+}
+export function readAcpGetDurableSessionResponse(bc) {
+    return {
+        session: readAcpDurableSessionInfo(bc),
+    };
+}
+export function writeAcpGetDurableSessionResponse(bc, x) {
+    writeAcpDurableSessionInfo(bc, x.session);
+}
+function read8(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readAcpDurableSessionInfo(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readAcpDurableSessionInfo(bc);
     }
+    return result;
 }
-function read5(bc) {
+function write8(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeAcpDurableSessionInfo(bc, x[i]);
+    }
+}
+export function readAcpListDurableSessionsResponse(bc) {
+    return {
+        sessions: read8(bc),
+        nextCursor: read2(bc),
+    };
+}
+export function writeAcpListDurableSessionsResponse(bc, x) {
+    write8(bc, x.sessions);
+    write2(bc, x.nextCursor);
+}
+export function readAcpDeleteSessionResponse(bc) {
+    return {
+        reserved: bare.readBool(bc),
+    };
+}
+export function writeAcpDeleteSessionResponse(bc, x) {
+    bare.writeBool(bc, x.reserved);
+}
+export function readAcpUnloadSessionResponse(bc) {
+    return {
+        reserved: bare.readBool(bc),
+    };
+}
+export function writeAcpUnloadSessionResponse(bc, x) {
+    bare.writeBool(bc, x.reserved);
+}
+export function readAcpPromptResponse(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        message: read3(bc),
+        stopReason: bare.readString(bc),
+    };
+}
+export function writeAcpPromptResponse(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    write3(bc, x.message);
+    bare.writeString(bc, x.stopReason);
+}
+export function readAcpCancelPromptResponse(bc) {
+    return {
+        status: bare.readString(bc),
+    };
+}
+export function writeAcpCancelPromptResponse(bc, x) {
+    bare.writeString(bc, x.status);
+}
+export function readAcpRespondPermissionResponse(bc) {
+    return {
+        status: bare.readString(bc),
+        reason: read2(bc),
+    };
+}
+export function writeAcpRespondPermissionResponse(bc, x) {
+    bare.writeString(bc, x.status);
+    write2(bc, x.reason);
+}
+export function readAcpDurableSessionUpdate(bc) {
+    return {
+        update: readJsonUtf8(bc),
+    };
+}
+export function writeAcpDurableSessionUpdate(bc, x) {
+    writeJsonUtf8(bc, x.update);
+}
+export function readAcpDurablePermissionRequest(bc) {
+    return {
+        requestId: bare.readString(bc),
+        request: readJsonUtf8(bc),
+    };
+}
+export function writeAcpDurablePermissionRequest(bc, x) {
+    bare.writeString(bc, x.requestId);
+    writeJsonUtf8(bc, x.request);
+}
+export function readAcpDurablePermissionResponse(bc) {
+    return {
+        requestId: bare.readString(bc),
+        response: readJsonUtf8(bc),
+        status: bare.readString(bc),
+        reason: read2(bc),
+    };
+}
+export function writeAcpDurablePermissionResponse(bc, x) {
+    bare.writeString(bc, x.requestId);
+    writeJsonUtf8(bc, x.response);
+    bare.writeString(bc, x.status);
+    write2(bc, x.reason);
+}
+export function readAcpDurableEvent(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "AcpDurableSessionUpdate", val: readAcpDurableSessionUpdate(bc) };
+        case 1:
+            return { tag: "AcpDurablePermissionRequest", val: readAcpDurablePermissionRequest(bc) };
+        case 2:
+            return { tag: "AcpDurablePermissionResponse", val: readAcpDurablePermissionResponse(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeAcpDurableEvent(bc, x) {
+    switch (x.tag) {
+        case "AcpDurableSessionUpdate": {
+            bare.writeU8(bc, 0);
+            writeAcpDurableSessionUpdate(bc, x.val);
+            break;
+        }
+        case "AcpDurablePermissionRequest": {
+            bare.writeU8(bc, 1);
+            writeAcpDurablePermissionRequest(bc, x.val);
+            break;
+        }
+        case "AcpDurablePermissionResponse": {
+            bare.writeU8(bc, 2);
+            writeAcpDurablePermissionResponse(bc, x.val);
+            break;
+        }
+    }
+}
+export function readAcpDurableHistoryEntry(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        sequence: bare.readU64(bc),
+        timestamp: bare.readString(bc),
+        event: readAcpDurableEvent(bc),
+    };
+}
+export function writeAcpDurableHistoryEntry(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeU64(bc, x.sequence);
+    bare.writeString(bc, x.timestamp);
+    writeAcpDurableEvent(bc, x.event);
+}
+function read9(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readAcpDurableHistoryEntry(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readAcpDurableHistoryEntry(bc);
+    }
+    return result;
+}
+function write9(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeAcpDurableHistoryEntry(bc, x[i]);
+    }
+}
+export function readAcpHistoryPageResponse(bc) {
+    return {
+        events: read9(bc),
+        hasMoreBefore: bare.readBool(bc),
+        hasMoreAfter: bare.readBool(bc),
+    };
+}
+export function writeAcpHistoryPageResponse(bc, x) {
+    write9(bc, x.events);
+    bare.writeBool(bc, x.hasMoreBefore);
+    bare.writeBool(bc, x.hasMoreAfter);
+}
+export function readAcpSessionConfigResponse(bc) {
+    return {
+        revision: bare.readU64(bc),
+        options: readJsonUtf8(bc),
+    };
+}
+export function writeAcpSessionConfigResponse(bc, x) {
+    bare.writeU64(bc, x.revision);
+    writeJsonUtf8(bc, x.options);
+}
+export function readAcpSessionCapabilitiesResponse(bc) {
+    return {
+        capabilities: read3(bc),
+    };
+}
+export function writeAcpSessionCapabilitiesResponse(bc, x) {
+    write3(bc, x.capabilities);
+}
+export function readAcpSessionAgentInfoResponse(bc) {
+    return {
+        agentInfo: read3(bc),
+    };
+}
+export function writeAcpSessionAgentInfoResponse(bc, x) {
+    write3(bc, x.agentInfo);
+}
+function read10(bc) {
     const len = bare.readUintSafe(bc);
     if (len === 0) {
         return [];
@@ -256,7 +823,7 @@ function read5(bc) {
     }
     return result;
 }
-function write5(bc, x) {
+function write10(bc, x) {
     bare.writeUintSafe(bc, x.length);
     for (let i = 0; i < x.length; i++) {
         writeJsonUtf8(bc, x[i]);
@@ -265,18 +832,18 @@ function write5(bc, x) {
 export function readAcpSessionCreatedResponse(bc) {
     return {
         sessionId: bare.readString(bc),
-        pid: read4(bc),
+        pid: read6(bc),
         modes: read3(bc),
-        configOptions: read5(bc),
+        configOptions: read10(bc),
         agentCapabilities: read3(bc),
         agentInfo: read3(bc),
     };
 }
 export function writeAcpSessionCreatedResponse(bc, x) {
     bare.writeString(bc, x.sessionId);
-    write4(bc, x.pid);
+    write6(bc, x.pid);
     write3(bc, x.modes);
-    write5(bc, x.configOptions);
+    write10(bc, x.configOptions);
     write3(bc, x.agentCapabilities);
     write3(bc, x.agentInfo);
 }
@@ -290,10 +857,10 @@ export function writeAcpSessionRpcResponse(bc, x) {
     bare.writeString(bc, x.sessionId);
     writeJsonUtf8(bc, x.response);
 }
-function read6(bc) {
+function read11(bc) {
     return bare.readBool(bc) ? bare.readI32(bc) : null;
 }
-function write6(bc, x) {
+function write11(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
         bare.writeI32(bc, x);
@@ -304,11 +871,11 @@ export function readAcpSessionStateResponse(bc) {
         sessionId: bare.readString(bc),
         agentType: bare.readString(bc),
         processId: bare.readString(bc),
-        pid: read4(bc),
+        pid: read6(bc),
         closed: bare.readBool(bc),
-        exitCode: read6(bc),
+        exitCode: read11(bc),
         modes: read3(bc),
-        configOptions: read5(bc),
+        configOptions: read10(bc),
         agentCapabilities: read3(bc),
         agentInfo: read3(bc),
     };
@@ -317,11 +884,11 @@ export function writeAcpSessionStateResponse(bc, x) {
     bare.writeString(bc, x.sessionId);
     bare.writeString(bc, x.agentType);
     bare.writeString(bc, x.processId);
-    write4(bc, x.pid);
+    write6(bc, x.pid);
     bare.writeBool(bc, x.closed);
-    write6(bc, x.exitCode);
+    write11(bc, x.exitCode);
     write3(bc, x.modes);
-    write5(bc, x.configOptions);
+    write10(bc, x.configOptions);
     write3(bc, x.agentCapabilities);
     write3(bc, x.agentInfo);
 }
@@ -353,22 +920,58 @@ export function writeAcpErrorResponse(bc, x) {
     bare.writeString(bc, x.code);
     bare.writeString(bc, x.message);
 }
+export function readAcpPendingResponse(bc) {
+    return {
+        processId: bare.readString(bc),
+    };
+}
+export function writeAcpPendingResponse(bc, x) {
+    bare.writeString(bc, x.processId);
+}
 export function readAcpResponse(bc) {
     const offset = bc.offset;
     const tag = bare.readU8(bc);
     switch (tag) {
         case 0:
-            return { tag: "AcpSessionCreatedResponse", val: readAcpSessionCreatedResponse(bc) };
+            return { tag: "AcpOpenSessionResponse", val: readAcpOpenSessionResponse(bc) };
         case 1:
-            return { tag: "AcpSessionRpcResponse", val: readAcpSessionRpcResponse(bc) };
+            return { tag: "AcpGetDurableSessionResponse", val: readAcpGetDurableSessionResponse(bc) };
         case 2:
-            return { tag: "AcpSessionStateResponse", val: readAcpSessionStateResponse(bc) };
+            return { tag: "AcpListDurableSessionsResponse", val: readAcpListDurableSessionsResponse(bc) };
         case 3:
-            return { tag: "AcpSessionClosedResponse", val: readAcpSessionClosedResponse(bc) };
+            return { tag: "AcpDeleteSessionResponse", val: readAcpDeleteSessionResponse(bc) };
         case 4:
-            return { tag: "AcpSessionResumedResponse", val: readAcpSessionResumedResponse(bc) };
+            return { tag: "AcpUnloadSessionResponse", val: readAcpUnloadSessionResponse(bc) };
         case 5:
+            return { tag: "AcpPromptResponse", val: readAcpPromptResponse(bc) };
+        case 6:
+            return { tag: "AcpCancelPromptResponse", val: readAcpCancelPromptResponse(bc) };
+        case 7:
+            return { tag: "AcpRespondPermissionResponse", val: readAcpRespondPermissionResponse(bc) };
+        case 8:
+            return { tag: "AcpHistoryPageResponse", val: readAcpHistoryPageResponse(bc) };
+        case 9:
+            return { tag: "AcpSessionConfigResponse", val: readAcpSessionConfigResponse(bc) };
+        case 10:
+            return { tag: "AcpSessionCapabilitiesResponse", val: readAcpSessionCapabilitiesResponse(bc) };
+        case 11:
+            return { tag: "AcpSessionAgentInfoResponse", val: readAcpSessionAgentInfoResponse(bc) };
+        case 12:
+            return { tag: "AcpSessionCreatedResponse", val: readAcpSessionCreatedResponse(bc) };
+        case 13:
+            return { tag: "AcpSessionRpcResponse", val: readAcpSessionRpcResponse(bc) };
+        case 14:
+            return { tag: "AcpSessionStateResponse", val: readAcpSessionStateResponse(bc) };
+        case 15:
+            return { tag: "AcpSessionClosedResponse", val: readAcpSessionClosedResponse(bc) };
+        case 16:
+            return { tag: "AcpSessionResumedResponse", val: readAcpSessionResumedResponse(bc) };
+        case 17:
             return { tag: "AcpErrorResponse", val: readAcpErrorResponse(bc) };
+        case 18:
+            return { tag: "AcpPendingResponse", val: readAcpPendingResponse(bc) };
+        case 19:
+            return { tag: "AcpListAgentsResponse", val: readAcpListAgentsResponse(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -377,36 +980,106 @@ export function readAcpResponse(bc) {
 }
 export function writeAcpResponse(bc, x) {
     switch (x.tag) {
-        case "AcpSessionCreatedResponse": {
+        case "AcpOpenSessionResponse": {
             bare.writeU8(bc, 0);
+            writeAcpOpenSessionResponse(bc, x.val);
+            break;
+        }
+        case "AcpGetDurableSessionResponse": {
+            bare.writeU8(bc, 1);
+            writeAcpGetDurableSessionResponse(bc, x.val);
+            break;
+        }
+        case "AcpListDurableSessionsResponse": {
+            bare.writeU8(bc, 2);
+            writeAcpListDurableSessionsResponse(bc, x.val);
+            break;
+        }
+        case "AcpDeleteSessionResponse": {
+            bare.writeU8(bc, 3);
+            writeAcpDeleteSessionResponse(bc, x.val);
+            break;
+        }
+        case "AcpUnloadSessionResponse": {
+            bare.writeU8(bc, 4);
+            writeAcpUnloadSessionResponse(bc, x.val);
+            break;
+        }
+        case "AcpPromptResponse": {
+            bare.writeU8(bc, 5);
+            writeAcpPromptResponse(bc, x.val);
+            break;
+        }
+        case "AcpCancelPromptResponse": {
+            bare.writeU8(bc, 6);
+            writeAcpCancelPromptResponse(bc, x.val);
+            break;
+        }
+        case "AcpRespondPermissionResponse": {
+            bare.writeU8(bc, 7);
+            writeAcpRespondPermissionResponse(bc, x.val);
+            break;
+        }
+        case "AcpHistoryPageResponse": {
+            bare.writeU8(bc, 8);
+            writeAcpHistoryPageResponse(bc, x.val);
+            break;
+        }
+        case "AcpSessionConfigResponse": {
+            bare.writeU8(bc, 9);
+            writeAcpSessionConfigResponse(bc, x.val);
+            break;
+        }
+        case "AcpSessionCapabilitiesResponse": {
+            bare.writeU8(bc, 10);
+            writeAcpSessionCapabilitiesResponse(bc, x.val);
+            break;
+        }
+        case "AcpSessionAgentInfoResponse": {
+            bare.writeU8(bc, 11);
+            writeAcpSessionAgentInfoResponse(bc, x.val);
+            break;
+        }
+        case "AcpSessionCreatedResponse": {
+            bare.writeU8(bc, 12);
             writeAcpSessionCreatedResponse(bc, x.val);
             break;
         }
         case "AcpSessionRpcResponse": {
-            bare.writeU8(bc, 1);
+            bare.writeU8(bc, 13);
             writeAcpSessionRpcResponse(bc, x.val);
             break;
         }
         case "AcpSessionStateResponse": {
-            bare.writeU8(bc, 2);
+            bare.writeU8(bc, 14);
             writeAcpSessionStateResponse(bc, x.val);
             break;
         }
         case "AcpSessionClosedResponse": {
-            bare.writeU8(bc, 3);
+            bare.writeU8(bc, 15);
             writeAcpSessionClosedResponse(bc, x.val);
             break;
         }
         case "AcpSessionResumedResponse": {
-            bare.writeU8(bc, 4);
+            bare.writeU8(bc, 16);
             writeAcpSessionResumedResponse(bc, x.val);
             break;
         }
         case "AcpErrorResponse": {
-            bare.writeU8(bc, 5);
+            bare.writeU8(bc, 17);
             writeAcpErrorResponse(bc, x.val);
             break;
         }
+        case "AcpPendingResponse": {
+            bare.writeU8(bc, 18);
+            writeAcpPendingResponse(bc, x.val);
+            break;
+        }
+        case "AcpListAgentsResponse": {
+            bare.writeU8(bc, 19);
+            writeAcpListAgentsResponse(bc, x.val);
+            break;
+        }
     }
 }
 export function encodeAcpResponse(x, config) {
@@ -423,6 +1096,32 @@ export function decodeAcpResponse(bytes) {
     }
     return result;
 }
+export function readAcpDurableSessionEvent(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        sequence: bare.readU64(bc),
+        timestamp: bare.readString(bc),
+        event: readAcpDurableEvent(bc),
+    };
+}
+export function writeAcpDurableSessionEvent(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeU64(bc, x.sequence);
+    bare.writeString(bc, x.timestamp);
+    writeAcpDurableEvent(bc, x.event);
+}
+export function readAcpEphemeralSessionUpdateEvent(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        afterSequence: bare.readU64(bc),
+        update: readJsonUtf8(bc),
+    };
+}
+export function writeAcpEphemeralSessionUpdateEvent(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeU64(bc, x.afterSequence);
+    writeJsonUtf8(bc, x.update);
+}
 export function readAcpSessionEvent(bc) {
     return {
         sessionId: bare.readString(bc),
@@ -433,12 +1132,56 @@ 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),
+        pid: read6(bc),
+        exitCode: read11(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.pid);
+    write11(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: "AcpDurableSessionEvent", val: readAcpDurableSessionEvent(bc) };
+        case 1:
+            return { tag: "AcpEphemeralSessionUpdateEvent", val: readAcpEphemeralSessionUpdateEvent(bc) };
+        case 2:
             return { tag: "AcpSessionEvent", val: readAcpSessionEvent(bc) };
+        case 3:
+            return { tag: "AcpAgentStderrEvent", val: readAcpAgentStderrEvent(bc) };
+        case 4:
+            return { tag: "AcpAgentExitedEvent", val: readAcpAgentExitedEvent(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -447,11 +1190,31 @@ export function readAcpEvent(bc) {
 }
 export function writeAcpEvent(bc, x) {
     switch (x.tag) {
-        case "AcpSessionEvent": {
+        case "AcpDurableSessionEvent": {
             bare.writeU8(bc, 0);
+            writeAcpDurableSessionEvent(bc, x.val);
+            break;
+        }
+        case "AcpEphemeralSessionUpdateEvent": {
+            bare.writeU8(bc, 1);
+            writeAcpEphemeralSessionUpdateEvent(bc, x.val);
+            break;
+        }
+        case "AcpSessionEvent": {
+            bare.writeU8(bc, 2);
             writeAcpSessionEvent(bc, x.val);
             break;
         }
+        case "AcpAgentStderrEvent": {
+            bare.writeU8(bc, 3);
+            writeAcpAgentStderrEvent(bc, x.val);
+            break;
+        }
+        case "AcpAgentExitedEvent": {
+            bare.writeU8(bc, 4);
+            writeAcpAgentExitedEvent(bc, x.val);
+            break;
+        }
     }
 }
 export function encodeAcpEvent(x, config) {
@@ -468,18 +1231,6 @@ export function decodeAcpEvent(bytes) {
     }
     return result;
 }
-export function readAcpPermissionCallback(bc) {
-    return {
-        sessionId: bare.readString(bc),
-        permissionId: bare.readString(bc),
-        params: readJsonUtf8(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),
@@ -495,8 +1246,6 @@ export function readAcpCallback(bc) {
     const tag = bare.readU8(bc);
     switch (tag) {
         case 0:
-            return { tag: "AcpPermissionCallback", val: readAcpPermissionCallback(bc) };
-        case 1:
             return { tag: "AcpHostRequestCallback", val: readAcpHostRequestCallback(bc) };
         default: {
             bc.offset = offset;
@@ -506,13 +1255,8 @@ export function readAcpCallback(bc) {
 }
 export function writeAcpCallback(bc, x) {
     switch (x.tag) {
-        case "AcpPermissionCallback": {
-            bare.writeU8(bc, 0);
-            writeAcpPermissionCallback(bc, x.val);
-            break;
-        }
         case "AcpHostRequestCallback": {
-            bare.writeU8(bc, 1);
+            bare.writeU8(bc, 0);
             writeAcpHostRequestCallback(bc, x.val);
             break;
         }
@@ -532,16 +1276,6 @@ export function decodeAcpCallback(bytes) {
     }
     return result;
 }
-export function readAcpPermissionCallbackResponse(bc) {
-    return {
-        permissionId: bare.readString(bc),
-        reply: bare.readString(bc),
-    };
-}
-export function writeAcpPermissionCallbackResponse(bc, x) {
-    bare.writeString(bc, x.permissionId);
-    bare.writeString(bc, x.reply);
-}
 export function readAcpHostRequestCallbackResponse(bc) {
     return {
         response: read3(bc),
@@ -555,8 +1289,6 @@ export function readAcpCallbackResponse(bc) {
     const tag = bare.readU8(bc);
     switch (tag) {
         case 0:
-            return { tag: "AcpPermissionCallbackResponse", val: readAcpPermissionCallbackResponse(bc) };
-        case 1:
             return { tag: "AcpHostRequestCallbackResponse", val: readAcpHostRequestCallbackResponse(bc) };
         default: {
             bc.offset = offset;
@@ -566,13 +1298,8 @@ export function readAcpCallbackResponse(bc) {
 }
 export function writeAcpCallbackResponse(bc, x) {
     switch (x.tag) {
-        case "AcpPermissionCallbackResponse": {
-            bare.writeU8(bc, 0);
-            writeAcpPermissionCallbackResponse(bc, x.val);
-            break;
-        }
         case "AcpHostRequestCallbackResponse": {
-            bare.writeU8(bc, 1);
+            bare.writeU8(bc, 0);
             writeAcpHostRequestCallbackResponse(bc, x.val);
             break;
         }