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

package/dist/runtime.d.ts

@@ -0,0 +1,336 @@
+export type StdioChannel = "stdout" | "stderr";
+export type TimingMitigation = "off" | "freeze";
+export type PermissionMode = "allow" | "deny";
+export type PermissionDecision = PermissionMode;
+export interface VirtualDirEntry {
+    name: string;
+    isDirectory: boolean;
+    isSymbolicLink?: boolean;
+}
+export interface VirtualStat {
+    mode: number;
+    size: number;
+    blocks: number;
+    dev: number;
+    rdev: number;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    ino: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+}
+export interface VirtualFileSystem {
+    readFile(path: string): Promise<Uint8Array>;
+    readTextFile(path: string): Promise<string>;
+    readDir(path: string): Promise<string[]>;
+    readDirWithTypes(path: string): Promise<VirtualDirEntry[]>;
+    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    createDir(path: string): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<VirtualStat>;
+    removeFile(path: string): Promise<void>;
+    removeDir(path: string): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    realpath(path: string): Promise<string>;
+    symlink(target: string, linkPath: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+    lstat(path: string): Promise<VirtualStat>;
+    link(oldPath: string, newPath: string): Promise<void>;
+    chmod(path: string, mode: number): Promise<void>;
+    chown(path: string, uid: number, gid: number): Promise<void>;
+    utimes(path: string, atime: number, mtime: number): Promise<void>;
+    truncate(path: string, length: number): Promise<void>;
+    pread(path: string, offset: number, length: number): Promise<Uint8Array>;
+    pwrite(path: string, offset: number, data: Uint8Array): Promise<void>;
+}
+export interface NetworkAccessRequest {
+    url?: string;
+    host?: string;
+    port?: number;
+    protocol?: string;
+}
+export interface FsPermissionRule {
+    mode: PermissionMode;
+    operations?: string[];
+    paths?: string[];
+}
+export interface PatternPermissionRule {
+    mode: PermissionMode;
+    operations?: string[];
+    patterns?: string[];
+}
+export interface RulePermissions<TRule> {
+    default?: PermissionMode;
+    rules: TRule[];
+}
+export type FsPermissions = PermissionMode | RulePermissions<FsPermissionRule>;
+export type NetworkPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
+export type ChildProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
+export type ProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
+export type EnvPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
+export type ToolPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
+export interface ProcessInfo {
+    pid: number;
+    ppid: number;
+    pgid: number;
+    sid: number;
+    driver: string;
+    command: string;
+    args: string[];
+    cwd: string;
+    status: "running" | "exited";
+    exitCode: number | null;
+    startTime: number;
+    exitTime: number | null;
+}
+export interface ManagedProcess {
+    pid: number;
+    writeStdin(data: Uint8Array | string): void;
+    closeStdin(): void;
+    kill(signal?: number): void;
+    wait(): Promise<number>;
+    readonly exitCode: number | null;
+}
+export interface ShellHandle {
+    pid: number;
+    write(data: Uint8Array | string): void;
+    onData: ((data: Uint8Array) => void) | null;
+    resize(cols: number, rows: number): void;
+    kill(signal?: number): void;
+    wait(): Promise<number>;
+}
+export interface OpenShellOptions {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    cols?: number;
+    rows?: number;
+    onStderr?: (data: Uint8Array) => void;
+}
+export interface ConnectTerminalOptions extends OpenShellOptions {
+    onData?: (data: Uint8Array) => void;
+}
+export interface ExecOptions {
+    env?: Record<string, string>;
+    cwd?: string;
+    stdin?: string | Uint8Array;
+    timeout?: number;
+    onStdout?: (data: Uint8Array) => void;
+    onStderr?: (data: Uint8Array) => void;
+    captureStdio?: boolean;
+    filePath?: string;
+    cpuTimeLimitMs?: number;
+    timingMitigation?: TimingMitigation;
+}
+export interface ExecResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface RunResult<T = unknown> {
+    value?: T;
+    code: number;
+    errorMessage?: string;
+}
+export interface KernelSpawnOptions extends ExecOptions {
+    stdio?: "pipe" | "inherit";
+    stdinFd?: number;
+    stdoutFd?: number;
+    stderrFd?: number;
+    streamStdin?: boolean;
+}
+export type KernelExecOptions = ExecOptions;
+export type KernelExecResult = ExecResult;
+export type StatInfo = VirtualStat;
+export type DirEntry = VirtualDirEntry;
+export type StdioEvent = {
+    channel: StdioChannel;
+    message: string;
+};
+export type StdioHook = (event: StdioEvent) => void;
+export interface Permissions {
+    fs?: FsPermissions;
+    network?: NetworkPermissions;
+    childProcess?: ChildProcessPermissions;
+    process?: ProcessPermissions;
+    env?: EnvPermissions;
+    tool?: ToolPermissions;
+}
+export interface ResourceBudgets {
+    maxOutputBytes?: number;
+    maxBridgeCalls?: number;
+    maxTimers?: number;
+    maxChildProcesses?: number;
+    maxHandles?: number;
+}
+export interface ProcessConfig {
+    cwd?: string;
+    env?: Record<string, string>;
+    argv?: string[];
+    stdinIsTTY?: boolean;
+    stdoutIsTTY?: boolean;
+    stderrIsTTY?: boolean;
+}
+export interface OSConfig {
+    homedir?: string;
+    tmpdir?: string;
+}
+export interface CommandExecutor {
+    spawn(command: string, args: string[], options?: KernelSpawnOptions): ManagedProcess;
+}
+export interface NetworkAdapter {
+    fetch(url: string, options?: {
+        method?: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    }): Promise<{
+        ok: boolean;
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: string;
+        url: string;
+        redirected: boolean;
+    }>;
+    dnsLookup(hostname: string): Promise<{
+        address?: string;
+        family?: number;
+        error?: string;
+        code?: string;
+    }>;
+    httpRequest(url: string, options?: {
+        method?: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    }): Promise<{
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: string;
+        url: string;
+    }>;
+}
+export interface SystemDriver {
+    filesystem?: VirtualFileSystem;
+    network?: NetworkAdapter;
+    commandExecutor?: CommandExecutor;
+    permissions?: Permissions;
+    runtime: {
+        process: ProcessConfig;
+        os: OSConfig;
+    };
+}
+export interface RuntimeDriverOptions {
+    system: SystemDriver;
+    runtime: {
+        process: ProcessConfig;
+        os: OSConfig;
+    };
+    memoryLimit?: number;
+    cpuTimeLimitMs?: number;
+    timingMitigation?: TimingMitigation;
+    onStdio?: StdioHook;
+    payloadLimits?: {
+        base64TransferBytes?: number;
+        jsonPayloadBytes?: number;
+    };
+    resourceBudgets?: ResourceBudgets;
+}
+export interface NodeRuntimeDriver {
+    exec(code: string, options?: ExecOptions): Promise<ExecResult>;
+    run<T = unknown>(code: string, filePath?: string): Promise<RunResult<T>>;
+    dispose(): void;
+    terminate?(): Promise<void>;
+    readonly network?: Pick<NetworkAdapter, "fetch" | "dnsLookup" | "httpRequest">;
+}
+export interface NodeRuntimeDriverFactory {
+    createRuntimeDriver(options: RuntimeDriverOptions): NodeRuntimeDriver;
+}
+export interface KernelInterface {
+    vfs: VirtualFileSystem;
+}
+export interface Kernel extends KernelInterface {
+    mount(driver: KernelRuntimeDriver): Promise<void>;
+    dispose(): Promise<void>;
+    exec(command: string, options?: KernelExecOptions): Promise<KernelExecResult>;
+    spawn(command: string, args: string[], options?: KernelSpawnOptions): ManagedProcess;
+    openShell(options?: OpenShellOptions): ShellHandle;
+    connectTerminal(options?: ConnectTerminalOptions): Promise<number>;
+    mountFs(path: string, fs: VirtualFileSystem, options?: {
+        readOnly?: boolean;
+    }): void;
+    unmountFs(path: string): void;
+    readFile(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    mkdir(path: string): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    stat(path: string): Promise<VirtualStat>;
+    exists(path: string): Promise<boolean>;
+    removeFile(path: string): Promise<void>;
+    removeDir(path: string): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    readonly commands: ReadonlyMap<string, string>;
+    readonly processes: ReadonlyMap<number, ProcessInfo>;
+    readonly env: Record<string, string>;
+    readonly cwd: string;
+    readonly socketTable: {
+        hasHostNetworkAdapter(): boolean;
+        findListener(_request: unknown): unknown | null;
+        findBoundUdp(_request: unknown): unknown | null;
+    };
+    readonly processTable: {
+        getSignalState(_pid: number): {
+            handlers: Map<number, unknown>;
+        };
+    };
+    readonly timerTable: Record<string, never>;
+    readonly zombieTimerCount: number;
+}
+export interface BindingTree {
+    [key: string]: BindingFunction | BindingTree;
+}
+export type BindingFunction = (...args: unknown[]) => unknown;
+export interface NodeDriverOptions {
+    filesystem?: VirtualFileSystem;
+    networkAdapter?: NetworkAdapter;
+    commandExecutor?: CommandExecutor;
+    permissions?: Permissions;
+    processConfig?: ProcessConfig;
+    osConfig?: OSConfig;
+}
+export interface DefaultNetworkAdapterOptions {
+    loopbackExemptPorts?: number[];
+}
+export interface NodeRuntimeOptions {
+    systemDriver?: SystemDriver;
+    runtimeDriverFactory?: NodeRuntimeDriverFactory;
+    permissions?: Partial<Permissions>;
+    memoryLimit?: number;
+    bindings?: BindingTree;
+    loopbackExemptPorts?: number[];
+}
+export type NodeRuntimeDriverFactoryOptions = Record<string, never>;
+export type NodeExecutionDriverOptions = RuntimeDriverOptions;
+export interface KernelRuntimeDriver {
+    readonly kind: "node" | "wasmvm";
+    readonly name: string;
+    readonly commands: string[];
+    readonly commandDirs?: string[];
+}
+export type DriverProcess = ManagedProcess;
+export type ProcessContext = Record<string, never>;
+export type PermissionTier = "full" | "read-write" | "read-only" | "isolated";
+export interface WasmVmRuntimeOptions {
+    wasmBinaryPath?: string;
+    commandDirs?: string[];
+    permissions?: Record<string, PermissionTier>;
+}

package/dist/runtime.js

@@ -0,0 +1 @@
+export {};

package/dist/sidecar/agent-os-protocol.d.ts

@@ -0,0 +1,219 @@
+import * as bare from "@rivetkit/bare-ts";
+export type i32 = number;
+export type u32 = number;
+export type JsonUtf8 = string;
+export declare function readJsonUtf8(bc: bare.ByteCursor): JsonUtf8;
+export declare function writeJsonUtf8(bc: bare.ByteCursor, x: JsonUtf8): void;
+export declare enum AcpRuntimeKind {
+    JavaScript = "JavaScript",
+    Python = "Python",
+    WebAssembly = "WebAssembly"
+}
+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 additionalInstructions: string | null;
+};
+export declare function readAcpCreateSessionRequest(bc: bare.ByteCursor): AcpCreateSessionRequest;
+export declare function writeAcpCreateSessionRequest(bc: bare.ByteCursor, x: AcpCreateSessionRequest): void;
+export type AcpSessionRequest = {
+    readonly sessionId: string;
+    readonly method: string;
+    readonly params: JsonUtf8 | null;
+};
+export declare function readAcpSessionRequest(bc: bare.ByteCursor): AcpSessionRequest;
+export declare function writeAcpSessionRequest(bc: bare.ByteCursor, x: AcpSessionRequest): 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 AcpCloseSessionRequest = {
+    readonly sessionId: string;
+};
+export declare function readAcpCloseSessionRequest(bc: bare.ByteCursor): AcpCloseSessionRequest;
+export declare function writeAcpCloseSessionRequest(bc: bare.ByteCursor, x: AcpCloseSessionRequest): void;
+/**
+ * Resume a session that exists in durable storage but is not live in the current
+ * VM (e.g. after a Rivet actor slept and woke with a fresh VM). The sidecar runs
+ * the stateless resume state machine (native session/load when the agent supports
+ * it, else a fresh session/new + transcript continuation preamble). `cwd`/`env`
+ * describe the fresh adapter launch used by the fallback tier. `transcriptPath`,
+ * when present, is a guest-readable path the fallback preamble points the agent at.
+ */
+export type AcpResumeSessionRequest = {
+    readonly sessionId: string;
+    readonly agentType: string;
+    readonly transcriptPath: string | null;
+    readonly cwd: string;
+    readonly env: ReadonlyMap<string, string>;
+};
+export declare function readAcpResumeSessionRequest(bc: bare.ByteCursor): AcpResumeSessionRequest;
+export declare function writeAcpResumeSessionRequest(bc: bare.ByteCursor, x: AcpResumeSessionRequest): void;
+export type AcpRequest = {
+    readonly tag: "AcpCreateSessionRequest";
+    readonly val: AcpCreateSessionRequest;
+} | {
+    readonly tag: "AcpSessionRequest";
+    readonly val: AcpSessionRequest;
+} | {
+    readonly tag: "AcpGetSessionStateRequest";
+    readonly val: AcpGetSessionStateRequest;
+} | {
+    readonly tag: "AcpCloseSessionRequest";
+    readonly val: AcpCloseSessionRequest;
+} | {
+    readonly tag: "AcpResumeSessionRequest";
+    readonly val: AcpResumeSessionRequest;
+};
+export declare function readAcpRequest(bc: bare.ByteCursor): AcpRequest;
+export declare function writeAcpRequest(bc: bare.ByteCursor, x: AcpRequest): void;
+export declare function encodeAcpRequest(x: AcpRequest, config?: Partial<bare.Config>): Uint8Array;
+export declare function decodeAcpRequest(bytes: Uint8Array): AcpRequest;
+export type AcpSessionCreatedResponse = {
+    readonly sessionId: string;
+    readonly pid: u32 | null;
+    readonly modes: JsonUtf8 | null;
+    readonly configOptions: readonly JsonUtf8[];
+    readonly agentCapabilities: JsonUtf8 | null;
+    readonly agentInfo: JsonUtf8 | null;
+};
+export declare function readAcpSessionCreatedResponse(bc: bare.ByteCursor): AcpSessionCreatedResponse;
+export declare function writeAcpSessionCreatedResponse(bc: bare.ByteCursor, x: AcpSessionCreatedResponse): void;
+export type AcpSessionRpcResponse = {
+    readonly sessionId: string;
+    readonly response: JsonUtf8;
+};
+export declare function readAcpSessionRpcResponse(bc: bare.ByteCursor): AcpSessionRpcResponse;
+export declare function writeAcpSessionRpcResponse(bc: bare.ByteCursor, x: AcpSessionRpcResponse): void;
+export type AcpSessionStateResponse = {
+    readonly sessionId: string;
+    readonly agentType: string;
+    readonly processId: string;
+    readonly pid: u32 | null;
+    readonly closed: boolean;
+    readonly exitCode: i32 | null;
+    readonly modes: JsonUtf8 | null;
+    readonly configOptions: readonly JsonUtf8[];
+    readonly agentCapabilities: JsonUtf8 | null;
+    readonly agentInfo: JsonUtf8 | null;
+};
+export declare function readAcpSessionStateResponse(bc: bare.ByteCursor): AcpSessionStateResponse;
+export declare function writeAcpSessionStateResponse(bc: bare.ByteCursor, x: AcpSessionStateResponse): 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;
+/**
+ * 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
+ * for the fallback tier (the caller remaps external -> live). `mode` is "native"
+ * (session/load|resume succeeded) or "fallback" (a new session was created and the
+ * transcript-continuation preamble was armed for the next prompt).
+ */
+export type AcpSessionResumedResponse = {
+    readonly sessionId: string;
+    readonly mode: string;
+};
+export declare function readAcpSessionResumedResponse(bc: bare.ByteCursor): AcpSessionResumedResponse;
+export declare function writeAcpSessionResumedResponse(bc: bare.ByteCursor, x: AcpSessionResumedResponse): void;
+export type AcpErrorResponse = {
+    readonly code: string;
+    readonly message: string;
+};
+export declare function readAcpErrorResponse(bc: bare.ByteCursor): AcpErrorResponse;
+export declare function writeAcpErrorResponse(bc: bare.ByteCursor, x: AcpErrorResponse): void;
+export type AcpResponse = {
+    readonly tag: "AcpSessionCreatedResponse";
+    readonly val: AcpSessionCreatedResponse;
+} | {
+    readonly tag: "AcpSessionRpcResponse";
+    readonly val: AcpSessionRpcResponse;
+} | {
+    readonly tag: "AcpSessionStateResponse";
+    readonly val: AcpSessionStateResponse;
+} | {
+    readonly tag: "AcpSessionClosedResponse";
+    readonly val: AcpSessionClosedResponse;
+} | {
+    readonly tag: "AcpSessionResumedResponse";
+    readonly val: AcpSessionResumedResponse;
+} | {
+    readonly tag: "AcpErrorResponse";
+    readonly val: AcpErrorResponse;
+};
+export declare function readAcpResponse(bc: bare.ByteCursor): AcpResponse;
+export declare function writeAcpResponse(bc: bare.ByteCursor, x: AcpResponse): void;
+export declare function encodeAcpResponse(x: AcpResponse, config?: Partial<bare.Config>): Uint8Array;
+export declare function decodeAcpResponse(bytes: Uint8Array): AcpResponse;
+export type AcpSessionEvent = {
+    readonly sessionId: string;
+    readonly notification: JsonUtf8;
+};
+export declare function readAcpSessionEvent(bc: bare.ByteCursor): AcpSessionEvent;
+export declare function writeAcpSessionEvent(bc: bare.ByteCursor, x: AcpSessionEvent): void;
+export type AcpEvent = {
+    readonly tag: "AcpSessionEvent";
+    readonly val: AcpSessionEvent;
+};
+export declare function readAcpEvent(bc: bare.ByteCursor): AcpEvent;
+export declare function writeAcpEvent(bc: bare.ByteCursor, x: AcpEvent): void;
+export declare function encodeAcpEvent(x: AcpEvent, config?: Partial<bare.Config>): Uint8Array;
+export declare function decodeAcpEvent(bytes: Uint8Array): AcpEvent;
+export type AcpPermissionCallback = {
+    readonly sessionId: string;
+    readonly permissionId: string;
+    readonly params: JsonUtf8;
+};
+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;
+export declare function encodeAcpCallback(x: AcpCallback, config?: Partial<bare.Config>): Uint8Array;
+export declare function decodeAcpCallback(bytes: Uint8Array): AcpCallback;
+export type AcpPermissionCallbackResponse = {
+    readonly permissionId: string;
+    readonly reply: string;
+};
+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;
+export declare function encodeAcpCallbackResponse(x: AcpCallbackResponse, config?: Partial<bare.Config>): Uint8Array;
+export declare function decodeAcpCallbackResponse(bytes: Uint8Array): AcpCallbackResponse;