@rivet-dev/agentos-core 0.0.0-agentos-dylib-plugin.473700e

package/dist/sidecar/agent-os-protocol.js

@@ -0,0 +1,594 @@
+// @generated - run pnpm --dir packages/core build:agent-os-protocol
+import * as bare from "@rivetkit/bare-ts";
+const DEFAULT_CONFIG = /* @__PURE__ */ bare.Config({});
+export function readJsonUtf8(bc) {
+    return bare.readString(bc);
+}
+export function writeJsonUtf8(bc, x) {
+    bare.writeString(bc, x);
+}
+export var AcpRuntimeKind;
+(function (AcpRuntimeKind) {
+    AcpRuntimeKind["JavaScript"] = "JavaScript";
+    AcpRuntimeKind["Python"] = "Python";
+    AcpRuntimeKind["WebAssembly"] = "WebAssembly";
+})(AcpRuntimeKind || (AcpRuntimeKind = {}));
+export function readAcpRuntimeKind(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return AcpRuntimeKind.JavaScript;
+        case 1:
+            return AcpRuntimeKind.Python;
+        case 2:
+            return AcpRuntimeKind.WebAssembly;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeAcpRuntimeKind(bc, x) {
+    switch (x) {
+        case AcpRuntimeKind.JavaScript: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case AcpRuntimeKind.Python: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case AcpRuntimeKind.WebAssembly: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+    }
+}
+function read0(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [bare.readString(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = bare.readString(bc);
+    }
+    return result;
+}
+function write0(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        bare.writeString(bc, x[i]);
+    }
+}
+function read1(bc) {
+    const len = bare.readUintSafe(bc);
+    const result = new Map();
+    for (let i = 0; i < len; i++) {
+        const offset = bc.offset;
+        const key = bare.readString(bc);
+        if (result.has(key)) {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "duplicated key");
+        }
+        result.set(key, bare.readString(bc));
+    }
+    return result;
+}
+function write1(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 write2(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeString(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),
+    };
+}
+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 read3(bc) {
+    return bare.readBool(bc) ? readJsonUtf8(bc) : null;
+}
+function write3(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeJsonUtf8(bc, x);
+    }
+}
+export function readAcpSessionRequest(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        method: bare.readString(bc),
+        params: read3(bc),
+    };
+}
+export function writeAcpSessionRequest(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeString(bc, x.method);
+    write3(bc, x.params);
+}
+export function readAcpGetSessionStateRequest(bc) {
+    return {
+        sessionId: bare.readString(bc),
+    };
+}
+export function writeAcpGetSessionStateRequest(bc, x) {
+    bare.writeString(bc, x.sessionId);
+}
+export function readAcpCloseSessionRequest(bc) {
+    return {
+        sessionId: bare.readString(bc),
+    };
+}
+export function writeAcpCloseSessionRequest(bc, x) {
+    bare.writeString(bc, x.sessionId);
+}
+export function readAcpResumeSessionRequest(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        agentType: bare.readString(bc),
+        transcriptPath: read2(bc),
+        cwd: bare.readString(bc),
+        env: read1(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);
+}
+export function readAcpRequest(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "AcpCreateSessionRequest", val: readAcpCreateSessionRequest(bc) };
+        case 1:
+            return { tag: "AcpSessionRequest", val: readAcpSessionRequest(bc) };
+        case 2:
+            return { tag: "AcpGetSessionStateRequest", val: readAcpGetSessionStateRequest(bc) };
+        case 3:
+            return { tag: "AcpCloseSessionRequest", val: readAcpCloseSessionRequest(bc) };
+        case 4:
+            return { tag: "AcpResumeSessionRequest", val: readAcpResumeSessionRequest(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeAcpRequest(bc, x) {
+    switch (x.tag) {
+        case "AcpCreateSessionRequest": {
+            bare.writeU8(bc, 0);
+            writeAcpCreateSessionRequest(bc, x.val);
+            break;
+        }
+        case "AcpSessionRequest": {
+            bare.writeU8(bc, 1);
+            writeAcpSessionRequest(bc, x.val);
+            break;
+        }
+        case "AcpGetSessionStateRequest": {
+            bare.writeU8(bc, 2);
+            writeAcpGetSessionStateRequest(bc, x.val);
+            break;
+        }
+        case "AcpCloseSessionRequest": {
+            bare.writeU8(bc, 3);
+            writeAcpCloseSessionRequest(bc, x.val);
+            break;
+        }
+        case "AcpResumeSessionRequest": {
+            bare.writeU8(bc, 4);
+            writeAcpResumeSessionRequest(bc, x.val);
+            break;
+        }
+    }
+}
+export function encodeAcpRequest(x, config) {
+    const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+    const bc = new bare.ByteCursor(new Uint8Array(fullConfig.initialBufferLength), fullConfig);
+    writeAcpRequest(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeAcpRequest(bytes) {
+    const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+    const result = readAcpRequest(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+function read4(bc) {
+    return bare.readBool(bc) ? bare.readU32(bc) : null;
+}
+function write4(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeU32(bc, x);
+    }
+}
+function read5(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readJsonUtf8(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readJsonUtf8(bc);
+    }
+    return result;
+}
+function write5(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeJsonUtf8(bc, x[i]);
+    }
+}
+export function readAcpSessionCreatedResponse(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        pid: read4(bc),
+        modes: read3(bc),
+        configOptions: read5(bc),
+        agentCapabilities: read3(bc),
+        agentInfo: read3(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);
+}
+export function readAcpSessionRpcResponse(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        response: readJsonUtf8(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);
+    }
+}
+export function readAcpSessionStateResponse(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        agentType: bare.readString(bc),
+        processId: bare.readString(bc),
+        pid: read4(bc),
+        closed: bare.readBool(bc),
+        exitCode: read6(bc),
+        modes: read3(bc),
+        configOptions: read5(bc),
+        agentCapabilities: read3(bc),
+        agentInfo: read3(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);
+    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);
+}
+export function readAcpSessionClosedResponse(bc) {
+    return {
+        sessionId: bare.readString(bc),
+    };
+}
+export function writeAcpSessionClosedResponse(bc, x) {
+    bare.writeString(bc, x.sessionId);
+}
+export function readAcpSessionResumedResponse(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        mode: bare.readString(bc),
+    };
+}
+export function writeAcpSessionResumedResponse(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeString(bc, x.mode);
+}
+export function readAcpErrorResponse(bc) {
+    return {
+        code: bare.readString(bc),
+        message: bare.readString(bc),
+    };
+}
+export function writeAcpErrorResponse(bc, x) {
+    bare.writeString(bc, x.code);
+    bare.writeString(bc, x.message);
+}
+export function readAcpResponse(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "AcpSessionCreatedResponse", val: readAcpSessionCreatedResponse(bc) };
+        case 1:
+            return { tag: "AcpSessionRpcResponse", val: readAcpSessionRpcResponse(bc) };
+        case 2:
+            return { tag: "AcpSessionStateResponse", val: readAcpSessionStateResponse(bc) };
+        case 3:
+            return { tag: "AcpSessionClosedResponse", val: readAcpSessionClosedResponse(bc) };
+        case 4:
+            return { tag: "AcpSessionResumedResponse", val: readAcpSessionResumedResponse(bc) };
+        case 5:
+            return { tag: "AcpErrorResponse", val: readAcpErrorResponse(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeAcpResponse(bc, x) {
+    switch (x.tag) {
+        case "AcpSessionCreatedResponse": {
+            bare.writeU8(bc, 0);
+            writeAcpSessionCreatedResponse(bc, x.val);
+            break;
+        }
+        case "AcpSessionRpcResponse": {
+            bare.writeU8(bc, 1);
+            writeAcpSessionRpcResponse(bc, x.val);
+            break;
+        }
+        case "AcpSessionStateResponse": {
+            bare.writeU8(bc, 2);
+            writeAcpSessionStateResponse(bc, x.val);
+            break;
+        }
+        case "AcpSessionClosedResponse": {
+            bare.writeU8(bc, 3);
+            writeAcpSessionClosedResponse(bc, x.val);
+            break;
+        }
+        case "AcpSessionResumedResponse": {
+            bare.writeU8(bc, 4);
+            writeAcpSessionResumedResponse(bc, x.val);
+            break;
+        }
+        case "AcpErrorResponse": {
+            bare.writeU8(bc, 5);
+            writeAcpErrorResponse(bc, x.val);
+            break;
+        }
+    }
+}
+export function encodeAcpResponse(x, config) {
+    const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+    const bc = new bare.ByteCursor(new Uint8Array(fullConfig.initialBufferLength), fullConfig);
+    writeAcpResponse(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeAcpResponse(bytes) {
+    const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+    const result = readAcpResponse(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readAcpSessionEvent(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        notification: readJsonUtf8(bc),
+    };
+}
+export function writeAcpSessionEvent(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    writeJsonUtf8(bc, x.notification);
+}
+export function readAcpEvent(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "AcpSessionEvent", val: readAcpSessionEvent(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeAcpEvent(bc, x) {
+    switch (x.tag) {
+        case "AcpSessionEvent": {
+            bare.writeU8(bc, 0);
+            writeAcpSessionEvent(bc, x.val);
+            break;
+        }
+    }
+}
+export function encodeAcpEvent(x, config) {
+    const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+    const bc = new bare.ByteCursor(new Uint8Array(fullConfig.initialBufferLength), fullConfig);
+    writeAcpEvent(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeAcpEvent(bytes) {
+    const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+    const result = readAcpEvent(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining 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),
+        request: readJsonUtf8(bc),
+    };
+}
+export function writeAcpHostRequestCallback(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    writeJsonUtf8(bc, x.request);
+}
+export function readAcpCallback(bc) {
+    const offset = bc.offset;
+    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;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+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);
+            writeAcpHostRequestCallback(bc, x.val);
+            break;
+        }
+    }
+}
+export function encodeAcpCallback(x, config) {
+    const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+    const bc = new bare.ByteCursor(new Uint8Array(fullConfig.initialBufferLength), fullConfig);
+    writeAcpCallback(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeAcpCallback(bytes) {
+    const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+    const result = readAcpCallback(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining 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),
+    };
+}
+export function writeAcpHostRequestCallbackResponse(bc, x) {
+    write3(bc, x.response);
+}
+export function readAcpCallbackResponse(bc) {
+    const offset = bc.offset;
+    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;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+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);
+            writeAcpHostRequestCallbackResponse(bc, x.val);
+            break;
+        }
+    }
+}
+export function encodeAcpCallbackResponse(x, config) {
+    const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+    const bc = new bare.ByteCursor(new Uint8Array(fullConfig.initialBufferLength), fullConfig);
+    writeAcpCallbackResponse(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeAcpCallbackResponse(bytes) {
+    const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+    const result = readAcpCallbackResponse(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}

package/dist/sidecar/binary.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolve the prebuilt sidecar binary for a published (non-repo) install.
+ *
+ * Honors `AGENTOS_SIDECAR_BIN` as an absolute-path override, otherwise
+ * resolves the platform-specific binary shipped by the
+ * `@rivet-dev/agentos-sidecar` package. In-repo developer builds use the local
+ * cargo build path instead and never reach this function.
+ */
+export declare function resolvePublishedSidecarBinary(): string;

package/dist/sidecar/binary.js

@@ -0,0 +1,30 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+/**
+ * Resolve the prebuilt sidecar binary for a published (non-repo) install.
+ *
+ * Honors `AGENTOS_SIDECAR_BIN` as an absolute-path override, otherwise
+ * resolves the platform-specific binary shipped by the
+ * `@rivet-dev/agentos-sidecar` package. In-repo developer builds use the local
+ * cargo build path instead and never reach this function.
+ */
+export function resolvePublishedSidecarBinary() {
+    const override = process.env.AGENTOS_SIDECAR_BIN;
+    if (override) {
+        if (!existsSync(override)) {
+            throw new Error(`AGENTOS_SIDECAR_BIN is set to ${override} but the file does not exist`);
+        }
+        return override;
+    }
+    const require = createRequire(import.meta.url);
+    let mod;
+    try {
+        mod = require("@rivet-dev/agentos-sidecar");
+    }
+    catch (error) {
+        throw new Error("failed to resolve the Agent OS sidecar binary: the @rivet-dev/agentos-sidecar " +
+            "package is not installed. Install it, or set AGENTOS_SIDECAR_BIN to a local " +
+            `agentos-sidecar binary. (${error.message})`);
+    }
+    return mod.getSidecarPath();
+}

package/dist/sidecar/cargo.d.ts

@@ -0,0 +1,2 @@
+export declare function findCargoBinary(): string | null;
+export declare function resolveCargoBinary(): string;