@rivet-dev/agentos-core 0.2.8-rc.1 → 0.2.8-rc.3

package/dist/agentos-package.d.ts

@@ -21,9 +21,11 @@ export type PackageRef = ManifestPackageRef;
 export type SoftwarePackageRef = {
     packagePath: string;
 };
-/** @deprecated Package software is now represented by its package directory. */
-export type PackageDescriptor = PackageRef;
-/** Discriminate the dir-only package reference. */
+/** Portable descriptor used to link a package into a running VM. */
+export interface PackageDescriptor {
+    path: string;
+}
+/** Discriminate the path-only package reference. */
 export declare function isPackageDescriptor(value: unknown): value is PackageDescriptor;
 export declare function readAgentosPackageManifest(dir: string): AgentosPackageManifest;
 export declare function tryReadAgentosPackageManifest(dir: string): AgentosPackageManifest | undefined;

package/dist/agentos-package.js

@@ -17,9 +17,12 @@ import { join } from "node:path";
 export const OPT_AGENTOS_ROOT = "/opt/agentos";
 /** The symlink farm on `$PATH` (commands link here). */
 export const OPT_AGENTOS_BIN = "/opt/agentos/bin";
-/** Discriminate the dir-only package reference. */
+/** Discriminate the path-only package reference. */
 export function isPackageDescriptor(value) {
-    return typeof value === "string";
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        typeof value.path === "string");
 }
 export function readAgentosPackageManifest(dir) {
     const manifestPath = join(dir, "agentos-package.json");

package/dist/{host-tools-zod.d.ts → bindings-zod.d.ts}

@@ -1,5 +1,5 @@
 import type { ZodType } from "zod";
-export declare class HostToolSchemaConversionError extends Error {
+export declare class BindingSchemaConversionError extends Error {
     readonly path: string;
     readonly zodType: string;
     constructor(path: string, zodType: string, details?: string);

package/dist/{host-tools-zod.js → bindings-zod.js}

@@ -15,7 +15,7 @@ const UNSUPPORTED_TYPES = new Set([
     "pipe",
     "tuple",
 ]);
-export class HostToolSchemaConversionError extends Error {
+export class BindingSchemaConversionError extends Error {
     path;
     zodType;
     constructor(path, zodType, details) {
@@ -25,7 +25,7 @@ export class HostToolSchemaConversionError extends Error {
         ]
             .filter(Boolean)
             .join(" "));
-        this.name = "HostToolSchemaConversionError";
+        this.name = "BindingSchemaConversionError";
         this.path = path;
         this.zodType = zodType;
     }
@@ -50,7 +50,10 @@ function normalizeTypeName(schema) {
     if (constructorName === "discriminatedunion" || "discriminator" in def) {
         return "discriminatedunion";
     }
-    const rawTypeName = String(def.typeName ?? def.type ?? schema.type ?? constructorName);
+    const rawTypeName = String(def.typeName ??
+        def.type ??
+        schema.type ??
+        constructorName);
     return rawTypeName.replace(/^Zod/, "").toLowerCase();
 }
 function displayTypeName(typeName) {
@@ -93,24 +96,24 @@ function isCustomRefinement(check) {
 }
 function validateChecks(schema, path, typeName) {
     if (getChecks(schema).some(isCustomRefinement)) {
-        throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "custom refinements cannot be represented faithfully in JSON Schema");
+        throw new BindingSchemaConversionError(path, displayTypeName(typeName), "custom refinements cannot be represented faithfully in JSON Schema");
     }
 }
 function validateSchema(schema, path) {
     const typeName = normalizeTypeName(schema);
     if (metadataProducesRefs(schema)) {
-        throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "metadata that emits $ref/$defs is not supported");
+        throw new BindingSchemaConversionError(path, displayTypeName(typeName), "metadata that emits $ref/$defs is not supported");
     }
     if (UNSUPPORTED_TYPES.has(typeName)) {
-        throw new HostToolSchemaConversionError(path, displayTypeName(typeName));
+        throw new BindingSchemaConversionError(path, displayTypeName(typeName));
     }
     if (typeName === "discriminatedunion") {
-        throw new HostToolSchemaConversionError(path, displayTypeName(typeName));
+        throw new BindingSchemaConversionError(path, displayTypeName(typeName));
     }
     if (TRANSPARENT_WRAPPER_TYPES.has(typeName)) {
         const inner = getInnerSchema(schema);
         if (!inner) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "wrapper schema is missing its inner schema");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "wrapper schema is missing its inner schema");
         }
         validateSchema(inner, path);
         return;
@@ -118,7 +121,7 @@ function validateSchema(schema, path) {
     if (typeName === "nullable") {
         const inner = getInnerSchema(schema);
         if (!inner) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "nullable schema is missing its inner schema");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "nullable schema is missing its inner schema");
         }
         validateSchema(inner, path);
         return;
@@ -138,7 +141,7 @@ function validateSchema(schema, path) {
         const def = getSchemaDef(schema);
         const itemSchema = (def.element ?? def.type);
         if (!itemSchema) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "array schema is missing its item schema");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "array schema is missing its item schema");
         }
         validateSchema(itemSchema, `${path}[]`);
         return;
@@ -148,11 +151,11 @@ function validateSchema(schema, path) {
         const keySchema = def.keyType;
         const valueSchema = def.valueType;
         if (!keySchema || !valueSchema) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "record schema is missing its key or value schema");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "record schema is missing its key or value schema");
         }
         const keyTypeName = normalizeTypeName(keySchema);
         if (keyTypeName !== "string" || getChecks(keySchema).length > 0) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "record keys must be unconstrained strings");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "record keys must be unconstrained strings");
         }
         validateSchema(valueSchema, `${path}<record-value>`);
         return;
@@ -160,7 +163,7 @@ function validateSchema(schema, path) {
     if (typeName === "union") {
         const options = getSchemaDef(schema).options;
         if (!Array.isArray(options) || options.length === 0) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "union schema is missing its options");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "union schema is missing its options");
         }
         for (let index = 0; index < options.length; index += 1) {
             validateSchema(options[index], `${path}<union:${index}>`);
@@ -176,8 +179,9 @@ function validateSchema(schema, path) {
                 : [];
         const [literalValue] = literalValues;
         if (literalValues.length !== 1 ||
-            !("string number boolean".split(" ").includes(typeof literalValue) || literalValue === null)) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "literal values must be JSON primitives");
+            !("string number boolean".split(" ").includes(typeof literalValue) ||
+                literalValue === null)) {
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "literal values must be JSON primitives");
         }
         return;
     }
@@ -188,7 +192,7 @@ function validateSchema(schema, path) {
         typeName === "nativeenum") {
         return;
     }
-    throw new HostToolSchemaConversionError(path, displayTypeName(typeName));
+    throw new BindingSchemaConversionError(path, displayTypeName(typeName));
 }
 function sanitizeJsonSchema(value) {
     if (Array.isArray(value)) {
@@ -203,7 +207,9 @@ function sanitizeJsonSchema(value) {
         if (key === "$schema") {
             continue;
         }
-        if (key === "additionalProperties" && entry === false && record.type === "object") {
+        if (key === "additionalProperties" &&
+            entry === false &&
+            record.type === "object") {
             continue;
         }
         sanitized[key] = sanitizeJsonSchema(entry);
@@ -243,8 +249,9 @@ function generateJsonSchema(schema) {
         $refStrategy: "none",
         target: "jsonSchema7",
     });
-    if (!generated || (typeof generated === "object" && Object.keys(generated).length === 0)) {
-        throw new HostToolSchemaConversionError("$", displayTypeName(normalizeTypeName(schema)), "schema cannot be converted to JSON Schema");
+    if (!generated ||
+        (typeof generated === "object" && Object.keys(generated).length === 0)) {
+        throw new BindingSchemaConversionError("$", displayTypeName(normalizeTypeName(schema)), "schema cannot be converted to JSON Schema");
     }
     return generated;
 }
@@ -253,7 +260,7 @@ export function zodToJsonSchema(schema) {
     const jsonSchema = generateJsonSchema(schema);
     const unsupportedKeyword = findUnsupportedGeneratedKeyword(jsonSchema, "$");
     if (unsupportedKeyword) {
-        throw new HostToolSchemaConversionError("$", displayTypeName(normalizeTypeName(schema)), `${unsupportedKeyword.keyword} emitted at ${unsupportedKeyword.path} is not supported`);
+        throw new BindingSchemaConversionError("$", displayTypeName(normalizeTypeName(schema)), `${unsupportedKeyword.keyword} emitted at ${unsupportedKeyword.path} is not supported`);
     }
     const sanitized = sanitizeJsonSchema(jsonSchema);
     const description = getDescription(schema);

package/dist/bindings.d.ts

@@ -0,0 +1,43 @@
+import type { ZodType } from "zod";
+/** Maximum length for binding descriptions (characters). */
+export declare const MAX_BINDING_DESCRIPTION_LENGTH = 200;
+/**
+ * A single binding that executes on the host.
+ */
+export interface Binding<INPUT = any, OUTPUT = any> {
+    /** Description shown to the agent in --help and prompt docs. Max 200 characters. */
+    description: string;
+    /** Zod schema for the input. Drives CLI flag generation and validation. */
+    inputSchema: ZodType<INPUT>;
+    /** Runs on the host when the agent invokes the binding. */
+    execute: (input: INPUT) => Promise<OUTPUT> | OUTPUT;
+    /** Examples included in auto-generated prompt docs. */
+    examples?: BindingExample<INPUT>[];
+    /** Timeout in ms. Default: 30000. */
+    timeout?: number;
+}
+export interface BindingExample<INPUT = any> {
+    /** Human description of what this example does. */
+    description: string;
+    /** The input args for the example. */
+    input: INPUT;
+}
+/**
+ * A named collection of bindings. Becomes a CLI binary: agentos-{name}.
+ */
+export interface Bindings {
+    /** Collection name. Must be lowercase alphanumeric + hyphens. Becomes the CLI suffix: agentos-{name}. */
+    name: string;
+    /** Description shown in `agentos list-bindings` and prompt docs. */
+    description: string;
+    /** The bindings in this collection. Keys become subcommands. */
+    bindings: Record<string, Binding>;
+}
+/** Helper to create a binding with type inference. */
+export declare function binding<INPUT, OUTPUT>(def: Binding<INPUT, OUTPUT>): Binding<INPUT, OUTPUT>;
+/** Helper to create a named binding collection. */
+export declare function bindings(def: Bindings): Bindings;
+/**
+ * Validate every binding collection and binding.
+ */
+export declare function validateBindings(collections: Bindings[]): void;

package/dist/bindings.js

@@ -0,0 +1,34 @@
+/** Maximum length for binding descriptions (characters). */
+export const MAX_BINDING_DESCRIPTION_LENGTH = 200;
+/** Helper to create a binding with type inference. */
+export function binding(def) {
+    return def;
+}
+/** Helper to create a named binding collection. */
+export function bindings(def) {
+    return def;
+}
+const BINDING_COMMAND_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function validateBindingCommandName(kind, name) {
+    if (BINDING_COMMAND_NAME_RE.test(name)) {
+        return;
+    }
+    throw new Error(`${kind} name "${name}" must be lowercase alphanumeric with optional single hyphen separators`);
+}
+/**
+ * Validate every binding collection and binding.
+ */
+export function validateBindings(collections) {
+    for (const collection of collections) {
+        validateBindingCommandName("Binding collection", collection.name);
+        if (collection.description.length > MAX_BINDING_DESCRIPTION_LENGTH) {
+            throw new Error(`Binding collection "${collection.name}" description is ${collection.description.length} characters, max is ${MAX_BINDING_DESCRIPTION_LENGTH}`);
+        }
+        for (const [bindingName, definition] of Object.entries(collection.bindings)) {
+            validateBindingCommandName("Binding", bindingName);
+            if (definition.description.length > MAX_BINDING_DESCRIPTION_LENGTH) {
+                throw new Error(`Binding "${collection.name}/${bindingName}" description is ${definition.description.length} characters, max is ${MAX_BINDING_DESCRIPTION_LENGTH}`);
+            }
+        }
+    }
+}

package/dist/cron/cron-manager.js

@@ -1,5 +1,26 @@
 import { randomUUID } from "node:crypto";
 import { resolveSchedule, validateScheduleForRegistration, } from "./parse-schedule.js";
+function describeAction(action) {
+    switch (action.type) {
+        case "session":
+            return {
+                type: "session",
+                agentType: action.agentType,
+                prompt: action.prompt,
+                ...(action.options === undefined
+                    ? {}
+                    : { options: structuredClone(action.options) }),
+            };
+        case "exec":
+            return {
+                type: "exec",
+                command: action.command,
+                ...(action.args === undefined ? {} : { args: [...action.args] }),
+            };
+        case "callback":
+            return { type: "callback" };
+    }
+}
 /**
  * Compute the next fire time for a schedule string. Returns undefined if
  * the schedule is a one-shot ISO timestamp in the past or if croner
@@ -58,10 +79,10 @@ export class CronManager {
             result.push({
                 id: state.id,
                 schedule: state.schedule,
-                action: state.action,
+                action: describeAction(state.action),
                 overlap: state.overlap,
-                lastRun: state.lastRun,
-                nextRun: state.nextRun,
+                lastRun: state.lastRun?.toISOString(),
+                nextRun: state.nextRun?.toISOString(),
                 runCount: state.runCount,
                 running: state.running,
             });
@@ -103,14 +124,18 @@ export class CronManager {
         state.running = true;
         state.lastRun = new Date();
         state.runCount++;
-        this.emit({ type: "cron:fire", jobId: state.id, time: new Date() });
+        this.emit({
+            type: "cron:fire",
+            jobId: state.id,
+            time: new Date().toISOString(),
+        });
         const startTime = Date.now();
         try {
             await this.runAction(state.action);
             this.emit({
                 type: "cron:complete",
                 jobId: state.id,
-                time: new Date(),
+                time: new Date().toISOString(),
                 durationMs: Date.now() - startTime,
             });
         }
@@ -118,8 +143,8 @@ export class CronManager {
             this.emit({
                 type: "cron:error",
                 jobId: state.id,
-                time: new Date(),
-                error: error,
+                time: new Date().toISOString(),
+                error: error instanceof Error ? error.message : String(error),
             });
         }
         finally {
@@ -135,12 +160,20 @@ export class CronManager {
     async runAction(action) {
         switch (action.type) {
             case "session": {
-                const { sessionId } = await this.vm.createSession(action.agentType, action.options);
+                const sessionId = `cron-${randomUUID()}`;
+                await this.vm.openSession({
+                    ...action.options,
+                    sessionId,
+                    agent: action.agentType,
+                });
                 try {
-                    await this.vm.prompt(sessionId, action.prompt);
+                    await this.vm.prompt({
+                        sessionId,
+                        content: [{ type: "text", text: action.prompt }],
+                    });
                 }
                 finally {
-                    this.vm.closeSession(sessionId);
+                    await this.vm.deleteSession({ sessionId });
                 }
                 break;
             }

package/dist/cron/index.d.ts

@@ -2,4 +2,4 @@ export { CronManager } from "./cron-manager.js";
 export { InvalidScheduleError, PastScheduleError, } from "./parse-schedule.js";
 export type { ScheduleDriver, ScheduleEntry, ScheduleHandle, } from "./schedule-driver.js";
 export { TimerScheduleDriver } from "./timer-driver.js";
-export type { CronAction, CronEvent, CronEventHandler, CronJob, CronJobInfo, CronJobOptions, } from "./types.js";
+export type { CronAction, CronActionInfo, CronEvent, CronEventHandler, CronJob, CronJobInfo, CronJobOptions, } from "./types.js";

package/dist/cron/types.d.ts

@@ -1,10 +1,10 @@
-import type { CreateSessionOptions } from "../agent-os.js";
+import type { OpenSessionInput } from "../session-api.js";
 import type { AgentType } from "../types.js";
 export type CronAction = {
     type: "session";
     agentType: AgentType;
     prompt: string;
-    options?: CreateSessionOptions;
+    options?: Omit<OpenSessionInput, "agent" | "sessionId">;
 } | {
     type: "exec";
     command: string;
@@ -13,6 +13,22 @@ export type CronAction = {
     type: "callback";
     fn: () => void | Promise<void>;
 };
+/**
+ * Serializable description of a scheduled action. Callback jobs deliberately
+ * expose only their kind: the host closure is execution state, not job data.
+ */
+export type CronActionInfo = {
+    type: "session";
+    agentType: AgentType;
+    prompt: string;
+    options?: Omit<OpenSessionInput, "agent" | "sessionId">;
+} | {
+    type: "exec";
+    command: string;
+    args?: string[];
+} | {
+    type: "callback";
+};
 export interface CronJobOptions {
     /** Optional ID. Auto-generated UUID if omitted. */
     id?: string;
@@ -30,26 +46,26 @@ export interface CronJob {
 export interface CronJobInfo {
     id: string;
     schedule: string;
-    action: CronAction;
+    action: CronActionInfo;
     overlap: "allow" | "skip" | "queue";
-    lastRun?: Date;
-    nextRun?: Date;
+    lastRun?: string;
+    nextRun?: string;
     runCount: number;
     running: boolean;
 }
 export type CronEvent = {
     type: "cron:fire";
     jobId: string;
-    time: Date;
+    time: string;
 } | {
     type: "cron:complete";
     jobId: string;
-    time: Date;
+    time: string;
     durationMs: number;
 } | {
     type: "cron:error";
     jobId: string;
-    time: Date;
-    error: Error;
+    time: string;
+    error: string;
 };
 export type CronEventHandler = (event: CronEvent) => void;

package/dist/filesystem-snapshot.d.ts

@@ -1,4 +1,4 @@
-import { type VirtualFileSystem } from "./runtime-compat.js";
+import type { VirtualFileSystem } from "./runtime-compat.js";
 export interface FilesystemEntry {
     path: string;
     type: "directory" | "file" | "symlink";
@@ -10,5 +10,4 @@ export interface FilesystemEntry {
     target?: string;
 }
 export declare function sortFilesystemEntries(entries: FilesystemEntry[]): FilesystemEntry[];
-export declare function createFilesystemFromEntries(entries: FilesystemEntry[]): Promise<VirtualFileSystem>;
 export declare function snapshotVirtualFilesystem(filesystem: VirtualFileSystem, rootPath?: string): Promise<FilesystemEntry[]>;

package/dist/filesystem-snapshot.js

@@ -1,8 +1,4 @@
 import * as posixPath from "node:path/posix";
-import { createInMemoryFileSystem, } from "./runtime-compat.js";
-function parseMode(mode) {
-    return Number.parseInt(mode, 8);
-}
 export function sortFilesystemEntries(entries) {
     return [...entries].sort((a, b) => {
         const depthA = a.path === "/" ? 0 : a.path.split("/").filter(Boolean).length;
@@ -13,45 +9,6 @@ export function sortFilesystemEntries(entries) {
         return a.path.localeCompare(b.path);
     });
 }
-async function applyDirectory(filesystem, entry) {
-    if (entry.path !== "/") {
-        await filesystem.mkdir(entry.path, { recursive: true });
-    }
-    await filesystem.chmod(entry.path, parseMode(entry.mode));
-    await filesystem.chown(entry.path, entry.uid, entry.gid);
-}
-async function applyFile(filesystem, entry) {
-    const content = entry.content ?? "";
-    await filesystem.writeFile(entry.path, entry.encoding === "base64" ? Buffer.from(content, "base64") : content);
-    await filesystem.chmod(entry.path, parseMode(entry.mode));
-    await filesystem.chown(entry.path, entry.uid, entry.gid);
-}
-async function applySymlink(filesystem, entry) {
-    if (!entry.target) {
-        throw new Error(`Missing symlink target for ${entry.path}`);
-    }
-    await filesystem.symlink(entry.target, entry.path);
-}
-export async function createFilesystemFromEntries(entries) {
-    const filesystem = createInMemoryFileSystem();
-    const sortedEntries = sortFilesystemEntries(entries);
-    for (const entry of sortedEntries) {
-        if (entry.type === "directory") {
-            await applyDirectory(filesystem, entry);
-        }
-    }
-    for (const entry of sortedEntries) {
-        if (entry.type === "file") {
-            await applyFile(filesystem, entry);
-        }
-    }
-    for (const entry of sortedEntries) {
-        if (entry.type === "symlink") {
-            await applySymlink(filesystem, entry);
-        }
-    }
-    return filesystem;
-}
 function toModeString(mode) {
     return `0${(mode & 0o7777).toString(8)}`;
 }

package/dist/generated/AcpLimitsConfig.d.ts

@@ -1,4 +1,20 @@
 export type AcpLimitsConfig = {
     maxReadLineBytes?: number;
     stdoutBufferByteLimit?: number;
+    maxCompletedMessageBytes?: number;
+    maxTurnOutputBytes?: number;
+    maxPromptBytes?: number;
+    maxPromptBlocks?: number;
+    maxFallbackContinuationBytes?: number;
+    maxSessionHistoryBytes?: number;
+    maxSessionHistoryEvents?: number;
+    maxHistoryPageEntries?: number;
+    maxSessionListEntries?: number;
+    maxSessionsPerVm?: number;
+    maxPromptsPerSession?: number;
+    maxPromptsPerVm?: number;
+    maxPendingPermissionsPerSession?: number;
+    maxPendingPermissionsPerVm?: number;
+    maxPermissionOutcomesPerSession?: number;
+    maxPermissionOutcomesPerVm?: number;
 };

package/dist/generated/BindingLimitsConfig.d.ts

@@ -0,0 +1,10 @@
+export type BindingLimitsConfig = {
+    defaultBindingTimeoutMs?: number;
+    maxBindingTimeoutMs?: number;
+    maxRegisteredCollections?: number;
+    maxRegisteredBindingsPerVm?: number;
+    maxBindingsPerCollection?: number;
+    maxBindingSchemaBytes?: number;
+    maxExamplesPerBinding?: number;
+    maxBindingExampleInputBytes?: number;
+};

package/dist/generated/CreateVmConfig.d.ts

@@ -5,6 +5,7 @@ import type { RootFilesystemConfig } from "./RootFilesystemConfig.js";
 import type { VmDnsConfig } from "./VmDnsConfig.js";
 import type { VmLimitsConfig } from "./VmLimitsConfig.js";
 import type { VmListenPolicyConfig } from "./VmListenPolicyConfig.js";
+import type { VmUserConfig } from "./VmUserConfig.js";
 /**
  * Canonical Rust-side VM config. Unknown fields must stay rejected here and in
  * the TS preflight schema at
@@ -14,6 +15,7 @@ import type { VmListenPolicyConfig } from "./VmListenPolicyConfig.js";
 export type CreateVmConfig = {
     cwd?: string;
     env: Record<string, string>;
+    user?: VmUserConfig;
     rootFilesystem: RootFilesystemConfig;
     permissions?: PermissionsPolicy;
     limits?: VmLimitsConfig;

package/dist/generated/ProcessLimitsConfig.d.ts

@@ -0,0 +1,7 @@
+export type ProcessLimitsConfig = {
+    maxSpawnFileActions?: number;
+    maxSpawnFileActionBytes?: number;
+    pendingStdinBytes?: number;
+    pendingEventCount?: number;
+    pendingEventBytes?: number;
+};

package/dist/generated/ProcessLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/VmGroupConfig.d.ts

@@ -0,0 +1,5 @@
+export type VmGroupConfig = {
+    gid: number;
+    name: string;
+    members: Array<string>;
+};

package/dist/generated/VmGroupConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/VmLimitsConfig.d.ts

@@ -1,18 +1,20 @@
 import type { AcpLimitsConfig } from "./AcpLimitsConfig.js";
+import type { BindingLimitsConfig } from "./BindingLimitsConfig.js";
 import type { HttpLimitsConfig } from "./HttpLimitsConfig.js";
 import type { JsRuntimeLimitsConfig } from "./JsRuntimeLimitsConfig.js";
 import type { PluginLimitsConfig } from "./PluginLimitsConfig.js";
+import type { ProcessLimitsConfig } from "./ProcessLimitsConfig.js";
 import type { PythonLimitsConfig } from "./PythonLimitsConfig.js";
 import type { ResourceLimitsConfig } from "./ResourceLimitsConfig.js";
-import type { ToolLimitsConfig } from "./ToolLimitsConfig.js";
 import type { WasmLimitsConfig } from "./WasmLimitsConfig.js";
 export type VmLimitsConfig = {
     resources?: ResourceLimitsConfig;
     http?: HttpLimitsConfig;
-    tools?: ToolLimitsConfig;
+    bindings?: BindingLimitsConfig;
     plugins?: PluginLimitsConfig;
     acp?: AcpLimitsConfig;
     jsRuntime?: JsRuntimeLimitsConfig;
     python?: PythonLimitsConfig;
     wasm?: WasmLimitsConfig;
+    process?: ProcessLimitsConfig;
 };

package/dist/generated/VmUserAccountConfig.d.ts

@@ -0,0 +1,9 @@
+export type VmUserAccountConfig = {
+    uid: number;
+    gid: number;
+    username: string;
+    homedir: string;
+    shell: string;
+    gecos?: string;
+    supplementaryGids: Array<number>;
+};

package/dist/generated/VmUserAccountConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/VmUserConfig.d.ts

@@ -0,0 +1,19 @@
+import type { VmGroupConfig } from "./VmGroupConfig.js";
+import type { VmUserAccountConfig } from "./VmUserAccountConfig.js";
+/**
+ * Initial Linux-style credentials and account record for processes in a VM.
+ */
+export type VmUserConfig = {
+    uid?: number;
+    gid?: number;
+    euid?: number;
+    egid?: number;
+    username?: string;
+    homedir?: string;
+    shell?: string;
+    gecos?: string;
+    groupName?: string;
+    supplementaryGids?: Array<number>;
+    accounts?: Array<VmUserAccountConfig>;
+    groups?: Array<VmGroupConfig>;
+};

package/dist/generated/WasmLimitsConfig.d.ts

@@ -4,4 +4,5 @@ export type WasmLimitsConfig = {
     syncReadLimitBytes?: number;
     prewarmTimeoutMs?: number;
     runnerHeapLimitMb?: number;
+    runnerCpuTimeLimitMs?: number;
 };