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

package/dist/options-schema.js

@@ -0,0 +1,269 @@
+import { z } from "zod/v4";
+const stringArray = z.array(z.string());
+const nonNegativeInteger = z.number().int().nonnegative();
+const positiveInteger = z.number().int().positive();
+const functionSchema = z.custom((value) => typeof value === "function", { message: "Expected function" });
+const permissionModeSchema = z.enum(["allow", "deny"]);
+const fsPermissionRuleSchema = z
+    .object({
+    mode: permissionModeSchema,
+    operations: stringArray.optional(),
+    paths: stringArray.optional(),
+})
+    .strict();
+const patternPermissionRuleSchema = z
+    .object({
+    mode: permissionModeSchema,
+    operations: stringArray.optional(),
+    patterns: stringArray.optional(),
+})
+    .strict();
+const fsRulePermissionsSchema = z
+    .object({
+    default: permissionModeSchema.optional(),
+    rules: z.array(fsPermissionRuleSchema),
+})
+    .strict();
+const patternRulePermissionsSchema = z
+    .object({
+    default: permissionModeSchema.optional(),
+    rules: z.array(patternPermissionRuleSchema),
+})
+    .strict();
+const fsPermissionsSchema = z.union([permissionModeSchema, fsRulePermissionsSchema]);
+const patternPermissionsSchema = z.union([
+    permissionModeSchema,
+    patternRulePermissionsSchema,
+]);
+export const permissionsSchema = z
+    .object({
+    fs: fsPermissionsSchema.optional(),
+    network: patternPermissionsSchema.optional(),
+    childProcess: patternPermissionsSchema.optional(),
+    process: patternPermissionsSchema.optional(),
+    env: patternPermissionsSchema.optional(),
+    binding: patternPermissionsSchema.optional(),
+})
+    .strict();
+export const agentOsLimitsSchema = z
+    .object({
+    resources: z
+        .object({
+        cpuCount: positiveInteger.optional(),
+        maxProcesses: nonNegativeInteger.optional(),
+        maxCapturedOutputBytes: positiveInteger.optional(),
+        maxOpenFds: nonNegativeInteger.optional(),
+        maxPipes: nonNegativeInteger.optional(),
+        maxPtys: nonNegativeInteger.optional(),
+        maxSockets: nonNegativeInteger.optional(),
+        maxConnections: nonNegativeInteger.optional(),
+        maxSocketBufferedBytes: nonNegativeInteger.optional(),
+        maxSocketDatagramQueueLen: nonNegativeInteger.optional(),
+        maxFilesystemBytes: nonNegativeInteger.optional(),
+        maxInodeCount: nonNegativeInteger.optional(),
+        maxBlockingReadMs: nonNegativeInteger.optional(),
+        maxPreadBytes: nonNegativeInteger.optional(),
+        maxFdWriteBytes: nonNegativeInteger.optional(),
+        maxProcessArgvBytes: nonNegativeInteger.optional(),
+        maxProcessEnvBytes: nonNegativeInteger.optional(),
+        maxReaddirEntries: nonNegativeInteger.optional(),
+        maxWasmFuel: nonNegativeInteger.optional(),
+        maxWasmMemoryBytes: nonNegativeInteger.optional(),
+        maxWasmStackBytes: nonNegativeInteger.optional(),
+    })
+        .strict()
+        .optional(),
+    http: z
+        .object({ maxFetchResponseBytes: positiveInteger.optional() })
+        .strict()
+        .optional(),
+    tools: z
+        .object({
+        defaultToolTimeoutMs: nonNegativeInteger.optional(),
+        maxToolTimeoutMs: nonNegativeInteger.optional(),
+        maxRegisteredToolkits: positiveInteger.optional(),
+        maxRegisteredToolsPerVm: positiveInteger.optional(),
+        maxToolsPerToolkit: positiveInteger.optional(),
+        maxToolSchemaBytes: positiveInteger.optional(),
+        maxToolExamplesPerTool: nonNegativeInteger.optional(),
+        maxToolExampleInputBytes: positiveInteger.optional(),
+    })
+        .strict()
+        .optional(),
+    plugins: z
+        .object({
+        maxPersistedManifestBytes: positiveInteger.optional(),
+        maxPersistedManifestFileBytes: nonNegativeInteger.optional(),
+    })
+        .strict()
+        .optional(),
+    acp: z
+        .object({
+        maxReadLineBytes: positiveInteger.optional(),
+        stdoutBufferByteLimit: positiveInteger.optional(),
+    })
+        .strict()
+        .optional(),
+    jsRuntime: z
+        .object({
+        v8HeapLimitMb: positiveInteger.optional(),
+        syncRpcWaitTimeoutMs: nonNegativeInteger.optional(),
+        cpuTimeLimitMs: nonNegativeInteger.optional(),
+        wallClockLimitMs: nonNegativeInteger.optional(),
+        importCacheMaterializeTimeoutMs: positiveInteger.optional(),
+        capturedOutputLimitBytes: positiveInteger.optional(),
+    })
+        .strict()
+        .optional(),
+    python: z
+        .object({
+        outputBufferMaxBytes: positiveInteger.optional(),
+        executionTimeoutMs: positiveInteger.optional(),
+        maxOldSpaceMb: nonNegativeInteger.optional(),
+        vfsRpcTimeoutMs: positiveInteger.optional(),
+    })
+        .strict()
+        .optional(),
+    wasm: z
+        .object({
+        maxModuleFileBytes: positiveInteger.optional(),
+        capturedOutputLimitBytes: positiveInteger.optional(),
+        syncReadLimitBytes: positiveInteger.optional(),
+        prewarmTimeoutMs: positiveInteger.optional(),
+        runnerHeapLimitMb: positiveInteger.optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const rootLowerInputSchema = z.union([
+    z.object({ kind: z.literal("bundled-base-filesystem") }).strict(),
+    z.object({ kind: z.literal("snapshot-export"), source: z.unknown() }).strict(),
+]);
+export const rootFilesystemConfigSchema = z
+    .object({
+    type: z.literal("overlay").optional(),
+    mode: z.enum(["ephemeral", "read-only"]).optional(),
+    disableDefaultBaseLayer: z.boolean().optional(),
+    lowers: z.array(rootLowerInputSchema).optional(),
+})
+    .strict();
+const nativeMountPluginSchema = z
+    .object({
+    id: z.string(),
+    config: z.unknown().optional(),
+})
+    .strict();
+const plainMountConfigSchema = z
+    .object({
+    path: z.string(),
+    driver: z.custom((value) => typeof value === "object" && value !== null, {
+        message: "Expected filesystem driver object",
+    }),
+    readOnly: z.boolean().optional(),
+})
+    .strict();
+export const nativeMountConfigSchema = z
+    .object({
+    path: z.string(),
+    plugin: nativeMountPluginSchema,
+    readOnly: z.boolean().optional(),
+})
+    .strict();
+const overlayMountConfigSchema = z
+    .object({
+    path: z.string(),
+    filesystem: z
+        .object({
+        type: z.literal("overlay"),
+        store: z.unknown(),
+        mode: z.enum(["ephemeral", "read-only"]).optional(),
+        lowers: z.array(z.unknown()),
+    })
+        .strict(),
+})
+    .strict();
+export const mountConfigSchema = z.union([
+    plainMountConfigSchema,
+    nativeMountConfigSchema,
+    overlayMountConfigSchema,
+]);
+export const sharedSidecarConfigSchema = z
+    .object({
+    kind: z.literal("shared"),
+    pool: z.string().optional(),
+})
+    .strict();
+const explicitSidecarSchema = z
+    .object({
+    kind: z.literal("explicit"),
+    handle: z.unknown(),
+})
+    .strict();
+export const sidecarConfigSchema = z.union([
+    sharedSidecarConfigSchema,
+    explicitSidecarSchema,
+]);
+const toolExampleSchema = z
+    .object({
+    description: z.string(),
+    input: z.unknown(),
+})
+    .strict();
+export const hostToolSchema = z
+    .object({
+    description: z.string(),
+    inputSchema: z.custom((value) => typeof value === "object" && value !== null, {
+        message: "Expected Zod schema object",
+    }),
+    execute: functionSchema,
+    examples: z.array(toolExampleSchema).optional(),
+    timeout: nonNegativeInteger.optional(),
+})
+    .strict();
+export const toolKitSchema = z
+    .object({
+    name: z.string(),
+    description: z.string(),
+    tools: z.record(z.string(), hostToolSchema),
+})
+    .strict();
+const softwarePackageRefSchema = z.union([
+    z.string(),
+    z.object({ packagePath: z.string() }),
+]);
+const softwareInputSchema = z.union([
+    softwarePackageRefSchema,
+    z.array(softwarePackageRefSchema),
+]);
+/**
+ * Shared AgentOsOptions field schemas.
+ *
+ * Core uses the full object. The Rivet/native actor composes a narrower
+ * native-safe subset in `packages/agentos/src/config.ts`; keep that subset and
+ * `crates/agentos-actor-plugin/src/config.rs::AgentOsConfigJson` aligned when
+ * adding options that cross the native boundary.
+ */
+export const agentOsOptionFieldSchemas = {
+    software: z.array(softwareInputSchema).optional(),
+    defaultSoftware: z.boolean().optional(),
+    loopbackExemptPorts: z.array(z.number().int().min(0).max(65535)).optional(),
+    allowedNodeBuiltins: stringArray.optional(),
+    highResolutionTime: z.boolean().optional(),
+    rootFilesystem: rootFilesystemConfigSchema.optional(),
+    mounts: z.array(mountConfigSchema).optional(),
+    additionalInstructions: z.string().optional(),
+    toolKits: z.array(toolKitSchema).optional(),
+    permissions: permissionsSchema.optional(),
+    sidecar: sidecarConfigSchema.optional(),
+    limits: agentOsLimitsSchema.optional(),
+    onAgentStderr: z.custom((value) => typeof value === "function", { message: "Expected function" }).optional(),
+    onAgentExit: z.custom((value) => typeof value === "function", { message: "Expected function" }).optional(),
+    onLimitWarning: z.custom((value) => typeof value === "function", { message: "Expected function" }).optional(),
+};
+export const agentOsOptionsSchema = z
+    .object(agentOsOptionFieldSchemas)
+    .strict();
+export function parseAgentOsOptions(options) {
+    return agentOsOptionsSchema.parse(options ?? {});
+}

package/dist/overlay-filesystem.d.ts

@@ -5,7 +5,7 @@
  * filesystems. Reads resolve from highest precedence to lowest. Writes
  * go to the writable upper only, with copy-up and whiteout behavior.
  */
-import { type VirtualFileSystem } from "./runtime-compat.js";
+import type { VirtualFileSystem } from "./runtime.js";
 export interface OverlayBackendOptions {
     /** Legacy single lower layer. */
     lower?: VirtualFileSystem;

package/dist/overlay-filesystem.js

@@ -6,7 +6,7 @@
  * go to the writable upper only, with copy-up and whiteout behavior.
  */
 import * as posixPath from "node:path/posix";
-import { createInMemoryFileSystem, KernelError, } from "./runtime-compat.js";
+import { createInMemoryFileSystem, KernelError } from "./memory-filesystem.js";
 const OVERLAY_METADATA_ROOT = "/.secure-exec-overlay";
 const OVERLAY_WHITEOUT_DIR = "/.secure-exec-overlay/whiteouts";
 const OVERLAY_OPAQUE_DIR = "/.secure-exec-overlay/opaque";
@@ -44,7 +44,7 @@ export function createOverlayBackend(options) {
     function throwMetadataAccessDenied(path, op) {
         throw new KernelError("EPERM", `operation not permitted, ${op} '${path}'`);
     }
-    async function ensureMetadataDirectoriesInUpper(path) {
+    async function ensureMetadataDirectoriesInUpper() {
         if (!upper) {
             throwReadOnly();
         }
@@ -67,7 +67,7 @@ export function createOverlayBackend(options) {
         }
         const pathForMarker = markerPath(kind, path);
         if (present) {
-            await ensureMetadataDirectoriesInUpper(path);
+            await ensureMetadataDirectoriesInUpper();
             await upper.writeFile(pathForMarker, normPath(path));
             return;
         }

package/dist/packages.d.ts

@@ -1,127 +1,14 @@
-import type { PermissionTier } from "./runtime.js";
+import type { SoftwarePackageRef } from "./agentos-package.js";
 /**
- * Resolve a package directory by walking up the directory tree.
- * Supports both nested (pnpm) and flat (npm) node_modules layouts.
+ * Input type for the `software` option. Software is a self-contained package
+ * directory that the secure-exec sidecar materializes into the `/opt/agentos`
+ * projection. Accepts a package-dir ref or an array of refs for meta-packages.
  */
-export declare function resolvePackageDir(startDir: string, packageName: string): string;
-import type { AgentConfig } from "./agents.js";
-export interface SoftwareDescriptor {
-    name: string;
-    type: "agent" | "tool" | "wasm-commands";
-}
-export interface AgentSoftwareDescriptor extends SoftwareDescriptor {
-    type: "agent";
-    /**
-     * Root directory of this npm package on the host. Used to resolve
-     * dependencies listed in `requires` from this package's node_modules/.
-     */
-    packageDir: string;
-    /** npm packages that must be available inside the VM. */
-    requires: string[];
-    agent: {
-        /** Unique agent ID used in createSession(id). */
-        id: string;
-        /** npm package name of the ACP adapter. Must be in requires. */
-        acpAdapter: string;
-        /** npm package name of the agent CLI. Must be in requires. */
-        agentPackage: string;
-        /** Static env vars passed when spawning the adapter. */
-        staticEnv?: Record<string, string>;
-        /** Dynamic env vars computed at boot time. */
-        env?: (ctx: SoftwareContext) => Record<string, string>;
-        /** Additional CLI args prepended when launching the ACP adapter. */
-        launchArgs?: string[];
-    };
-}
-export interface ToolSoftwareDescriptor extends SoftwareDescriptor {
-    type: "tool";
-    /**
-     * Root directory of this npm package on the host. Used to resolve
-     * dependencies listed in `requires` from this package's node_modules/.
-     */
-    packageDir: string;
-    /** npm packages that must be available inside the VM. */
-    requires: string[];
-    /** Map of bin command name -> npm package name. */
-    bins: Record<string, string>;
-}
-export interface WasmCommandSoftwareDescriptor extends SoftwareDescriptor {
-    type: "wasm-commands";
-    /** Absolute path to directory containing WASM command binaries on the host. */
-    commandDir: string;
-    /** Symlink aliases: aliasName -> targetCommandName. */
-    aliases?: Record<string, string>;
-    /** Permission tier assignments. */
-    permissions?: {
-        full?: string[];
-        readWrite?: string[];
-        readOnly?: string[] | "*";
-        isolated?: string[];
-    };
-}
+export type SoftwareEntry = SoftwarePackageRef;
+export type SoftwareInput = SoftwareEntry | SoftwareEntry[];
 /**
- * Any object with a commandDir property is treated as a WASM command package.
- * This allows registry packages (e.g., @agentos-software/coreutils) to be
- * passed directly to the `software` option without wrapping.
+ * Define a software descriptor. A type-safe identity function that validates the
+ * package-dir reference at compile time. The sidecar materializes the package into
+ * the `/opt/agentos` projection.
  */
-export interface WasmCommandDirDescriptor {
-    readonly commandDir: string;
-    [key: string]: unknown;
-}
-export type AnySoftwareDescriptor = AgentSoftwareDescriptor | ToolSoftwareDescriptor | WasmCommandSoftwareDescriptor | WasmCommandDirDescriptor;
-/** Input type for the `software` option. Accepts descriptors or arrays of descriptors (for meta-packages). */
-export type SoftwareInput = AnySoftwareDescriptor | AnySoftwareDescriptor[];
-export interface SoftwareContext {
-    /**
-     * Resolve the bin entry for an npm package to a VM-side path.
-     * Uses require.resolve on the HOST, then maps to /root/node_modules/...
-     *
-     * Example: ctx.resolveBin("@mariozechner/pi-coding-agent", "pi")
-     *   -> "/root/node_modules/@mariozechner/pi-coding-agent/dist/cli.js"
-     */
-    resolveBin(packageName: string, binName?: string): string;
-    /**
-     * Resolve a package's root directory to a VM-side path.
-     *
-     * Example: ctx.resolvePackage("pi-acp")
-     *   -> "/root/node_modules/pi-acp"
-     */
-    resolvePackage(packageName: string): string;
-}
-/** Host-to-VM path mapping for a software package's `/root/node_modules/<pkg>` mount. */
-export interface SoftwareRoot {
-    hostPath: string;
-    vmPath: string;
-}
-export interface CommandPackageMetadata {
-    commandDir: string;
-    declaredCommands: string[];
-    aliases: Record<string, string>;
-}
-/**
- * Define a software descriptor. This is a type-safe identity function that
- * validates the descriptor shape at compile time.
- */
-export declare function defineSoftware<T extends AnySoftwareDescriptor>(desc: T): T;
-/** Result of processing all software descriptors at boot time. */
-export interface ProcessedSoftware {
-    /** WASM command directories to pass to the WasmVM driver. */
-    commandDirs: string[];
-    /** Per-package command metadata used to preserve command availability on the sidecar path. */
-    commandPackages: CommandPackageMetadata[];
-    /** Per-command permission tiers propagated into the WasmVM runtime. */
-    commandPermissions: Record<string, PermissionTier>;
-    /** Host-to-VM path mappings for software-package `/root/node_modules/<pkg>` mounts. */
-    softwareRoots: SoftwareRoot[];
-    /** Agent configs registered by agent software. */
-    agentConfigs: Map<string, AgentConfig>;
-}
-/**
- * Process an array of software descriptors at boot time.
- * Collects WASM command dirs, module access roots, and agent configurations.
- *
- * Any object with a `commandDir` property (e.g., registry packages) is treated
- * as a WASM command source. Typed descriptors with `type: "agent"` or `type: "tool"`
- * are processed for module mounting and agent registration.
- */
-export declare function processSoftware(software: SoftwareInput[]): ProcessedSoftware;
+export declare function defineSoftware<T extends SoftwareEntry>(desc: T): T;