@rivet-dev/agentos-core 0.2.8-rc.2 → 0.2.8-rc.4

package/dist/options-schema.js

@@ -2,6 +2,46 @@ import { z } from "zod/v4";
 const stringArray = z.array(z.string());
 const nonNegativeInteger = z.number().int().nonnegative();
 const positiveInteger = z.number().int().positive();
+const vmIdSchema = z.number().int().min(0).max(0xffffffff);
+const vmAccountNameSchema = z
+    .string()
+    .min(1)
+    .refine((value) => !/[:\s\0]/u.test(value), "Invalid account name");
+const vmGuestPathSchema = z.string().startsWith("/");
+const vmUserAccountSchema = z
+    .object({
+    uid: vmIdSchema,
+    gid: vmIdSchema,
+    username: vmAccountNameSchema,
+    homedir: vmGuestPathSchema,
+    shell: vmGuestPathSchema,
+    gecos: z.string().optional(),
+    supplementaryGids: z.array(vmIdSchema).max(64),
+})
+    .strict();
+const vmGroupSchema = z
+    .object({
+    gid: vmIdSchema,
+    name: vmAccountNameSchema,
+    members: z.array(vmAccountNameSchema),
+})
+    .strict();
+const vmUserConfigSchema = z
+    .object({
+    uid: vmIdSchema.optional(),
+    gid: vmIdSchema.optional(),
+    euid: vmIdSchema.optional(),
+    egid: vmIdSchema.optional(),
+    username: z.string().optional(),
+    homedir: z.string().optional(),
+    shell: z.string().optional(),
+    gecos: z.string().optional(),
+    groupName: z.string().optional(),
+    supplementaryGids: z.array(vmIdSchema).max(64).optional(),
+    accounts: z.array(vmUserAccountSchema).max(64).optional(),
+    groups: z.array(vmGroupSchema).max(128).optional(),
+})
+    .strict();
 const functionSchema = z.custom((value) => typeof value === "function", { message: "Expected function" });
 const permissionModeSchema = z.enum(["allow", "deny"]);
 const fsPermissionRuleSchema = z
@@ -30,7 +70,10 @@ const patternRulePermissionsSchema = z
     rules: z.array(patternPermissionRuleSchema),
 })
     .strict();
-const fsPermissionsSchema = z.union([permissionModeSchema, fsRulePermissionsSchema]);
+const fsPermissionsSchema = z.union([
+    permissionModeSchema,
+    fsRulePermissionsSchema,
+]);
 const patternPermissionsSchema = z.union([
     permissionModeSchema,
     patternRulePermissionsSchema,
@@ -76,16 +119,16 @@ export const agentOsLimitsSchema = z
         .object({ maxFetchResponseBytes: positiveInteger.optional() })
         .strict()
         .optional(),
-    tools: z
+    bindings: 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(),
+        defaultBindingTimeoutMs: nonNegativeInteger.optional(),
+        maxBindingTimeoutMs: nonNegativeInteger.optional(),
+        maxRegisteredCollections: positiveInteger.optional(),
+        maxRegisteredCollectionsPerVm: positiveInteger.optional(),
+        maxBindingsPerCollection: positiveInteger.optional(),
+        maxBindingSchemaBytes: positiveInteger.optional(),
+        maxExamplesPerBinding: nonNegativeInteger.optional(),
+        maxBindingExampleInputBytes: positiveInteger.optional(),
     })
         .strict()
         .optional(),
@@ -100,9 +143,29 @@ export const agentOsLimitsSchema = z
         .object({
         maxReadLineBytes: positiveInteger.optional(),
         stdoutBufferByteLimit: positiveInteger.optional(),
+        maxCompletedMessageBytes: positiveInteger.optional(),
+        maxTurnOutputBytes: positiveInteger.optional(),
+        maxPromptBytes: positiveInteger.optional(),
+        maxPromptBlocks: positiveInteger.optional(),
+        maxFallbackContinuationBytes: positiveInteger.optional(),
+        maxSessionHistoryBytes: positiveInteger.optional(),
+        maxSessionHistoryEvents: positiveInteger.optional(),
+        maxHistoryPageEntries: positiveInteger.optional(),
+        maxSessionListEntries: positiveInteger.optional(),
+        maxSessionsPerVm: positiveInteger.optional(),
+        maxPromptsPerSession: positiveInteger.optional(),
+        maxPromptsPerVm: positiveInteger.optional(),
+        maxPendingPermissionsPerSession: positiveInteger.optional(),
+        maxPendingPermissionsPerVm: positiveInteger.optional(),
+        maxPermissionOutcomesPerSession: positiveInteger.optional(),
+        maxPermissionOutcomesPerVm: positiveInteger.optional(),
     })
         .strict()
         .optional(),
+    sqlite: z
+        .object({ maxResultBytes: positiveInteger.optional() })
+        .strict()
+        .optional(),
     jsRuntime: z
         .object({
         v8HeapLimitMb: positiveInteger.optional(),
@@ -133,6 +196,17 @@ export const agentOsLimitsSchema = z
         syncReadLimitBytes: positiveInteger.optional(),
         prewarmTimeoutMs: positiveInteger.optional(),
         runnerHeapLimitMb: positiveInteger.optional(),
+        runnerCpuTimeLimitMs: nonNegativeInteger.optional(),
+    })
+        .strict()
+        .optional(),
+    process: z
+        .object({
+        maxSpawnFileActions: positiveInteger.optional(),
+        maxSpawnFileActionBytes: positiveInteger.optional(),
+        pendingStdinBytes: positiveInteger.optional(),
+        pendingEventCount: positiveInteger.optional(),
+        pendingEventBytes: positiveInteger.optional(),
     })
         .strict()
         .optional(),
@@ -140,9 +214,11 @@ export const agentOsLimitsSchema = z
     .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(),
+    z
+        .object({ kind: z.literal("snapshot-export"), source: z.unknown() })
+        .strict(),
 ]);
-export const rootFilesystemConfigSchema = z
+const overlayRootFilesystemConfigSchema = z
     .object({
     type: z.literal("overlay").optional(),
     mode: z.enum(["ephemeral", "read-only"]).optional(),
@@ -156,12 +232,25 @@ const nativeMountPluginSchema = z
     config: z.unknown().optional(),
 })
     .strict();
+const nativeRootFilesystemConfigSchema = z
+    .object({
+    type: z.literal("native"),
+    plugin: nativeMountPluginSchema,
+    readOnly: z.boolean().optional(),
+})
+    .strict();
+export const rootFilesystemConfigSchema = z.union([
+    overlayRootFilesystemConfigSchema,
+    nativeRootFilesystemConfigSchema,
+]);
 const plainMountConfigSchema = z
     .object({
     path: z.string(),
     driver: z.custom((value) => typeof value === "object" && value !== null, {
         message: "Expected filesystem driver object",
     }),
+    guestFstype: z.string().min(1).optional(),
+    guestSource: z.string().min(1).optional(),
     readOnly: z.boolean().optional(),
 })
     .strict();
@@ -169,6 +258,8 @@ export const nativeMountConfigSchema = z
     .object({
     path: z.string(),
     plugin: nativeMountPluginSchema,
+    guestFstype: z.string().min(1).optional(),
+    guestSource: z.string().min(1).optional(),
     readOnly: z.boolean().optional(),
 })
     .strict();
@@ -206,59 +297,85 @@ export const sidecarConfigSchema = z.union([
     sharedSidecarConfigSchema,
     explicitSidecarSchema,
 ]);
-const toolExampleSchema = z
+const bindingExampleSchema = z
     .object({
     description: z.string(),
     input: z.unknown(),
 })
     .strict();
-export const hostToolSchema = z
+export const bindingSchema = 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(),
+    examples: z.array(bindingExampleSchema).optional(),
     timeout: nonNegativeInteger.optional(),
 })
     .strict();
-export const toolKitSchema = z
+export const bindingsSchema = z
     .object({
     name: z.string(),
     description: z.string(),
-    tools: z.record(z.string(), hostToolSchema),
+    bindings: z.record(z.string(), bindingSchema),
 })
     .strict();
 /**
  * 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.
+ * Core and the TypeScript Rivet actor both use the full object. Runtime-owned
+ * behavior is serialized by AgentOs.create() into the sidecar VM config.
  */
 export const agentOsOptionFieldSchemas = {
+    user: vmUserConfigSchema.optional(),
     software: z.array(z.unknown()).optional(),
     defaultSoftware: z.boolean().optional(),
     loopbackExemptPorts: z.array(z.number().int().min(0).max(65535)).optional(),
     allowedNodeBuiltins: stringArray.optional(),
     highResolutionTime: z.boolean().optional(),
+    database: z
+        .discriminatedUnion("type", [
+        z
+            .object({
+            type: z.literal("actor_uds"),
+            path: z.string().min(1),
+        })
+            .strict(),
+        z
+            .object({
+            type: z.literal("sqlite_file"),
+            path: z.string().min(1),
+        })
+            .strict(),
+    ])
+        .optional(),
     rootFilesystem: rootFilesystemConfigSchema.optional(),
     mounts: z.array(mountConfigSchema).optional(),
-    additionalInstructions: z.string().optional(),
     scheduleDriver: z
         .custom((value) => typeof value === "object" && value !== null, {
         message: "Expected schedule driver object",
     })
         .optional(),
-    toolKits: z.array(toolKitSchema).optional(),
+    bindings: z.array(bindingsSchema).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(),
+    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)

package/dist/runtime-compat.d.ts

@@ -54,7 +54,9 @@ export interface VirtualFileSystem {
     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>;
+    chown(path: string, uid: number, gid: number, options?: {
+        followSymlinks?: boolean;
+    }): 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>;
@@ -363,40 +365,6 @@ export declare class KernelError extends Error {
     readonly code: string;
     constructor(code: string, message: string);
 }
-export declare class InMemoryFileSystem implements VirtualFileSystem {
-    private readonly entries;
-    constructor();
-    readFile(targetPath: string): Promise<Uint8Array>;
-    readTextFile(targetPath: string): Promise<string>;
-    readDir(targetPath: string): Promise<string[]>;
-    readDirWithTypes(targetPath: string): Promise<VirtualDirEntry[]>;
-    writeFile(targetPath: string, content: string | Uint8Array): Promise<void>;
-    createDir(targetPath: string): Promise<void>;
-    mkdir(targetPath: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    exists(targetPath: string): Promise<boolean>;
-    stat(targetPath: string): Promise<VirtualStat>;
-    removeFile(targetPath: string): Promise<void>;
-    removeDir(targetPath: string): Promise<void>;
-    rename(oldPath: string, newPath: string): Promise<void>;
-    realpath(targetPath: string): Promise<string>;
-    symlink(target: string, linkPath: string): Promise<void>;
-    readlink(targetPath: string): Promise<string>;
-    lstat(targetPath: string): Promise<VirtualStat>;
-    link(oldPath: string, newPath: string): Promise<void>;
-    chmod(targetPath: string, mode: number): Promise<void>;
-    chown(targetPath: string, uid: number, gid: number): Promise<void>;
-    utimes(targetPath: string, atime: number, mtime: number): Promise<void>;
-    truncate(targetPath: string, length: number): Promise<void>;
-    pread(targetPath: string, offset: number, length: number): Promise<Uint8Array>;
-    pwrite(targetPath: string, offset: number, data: Uint8Array): Promise<void>;
-    private resolvePath;
-    private resolveEntry;
-    private newDirectory;
-    private toStat;
-}
-export declare function createInMemoryFileSystem(): InMemoryFileSystem;
 export declare class NodeFileSystem implements VirtualFileSystem {
     readonly rootPath: string;
     constructor(options: {
@@ -490,4 +458,5 @@ export declare function createKernel(options: {
         readOnly?: boolean;
     }>;
     syncFilesystemOnDispose?: boolean;
+    maxFilesystemBytes?: number;
 }): Kernel;