@rivet-dev/agentos-core 0.2.20-rc.1 → 0.2.21

package/dist/generated/HostFunctionLimitsConfig.d.ts

@@ -0,0 +1,10 @@
+export type HostFunctionLimitsConfig = {
+    defaultTimeoutMs?: number;
+    maxTimeoutMs?: number;
+    maxRegisteredCollections?: number;
+    maxRegisteredFunctionsPerVm?: number;
+    maxFunctionsPerCollection?: number;
+    maxSchemaBytes?: number;
+    maxExamplesPerFunction?: number;
+    maxExampleInputBytes?: number;
+};

package/dist/generated/PermissionsPolicy.d.ts

@@ -6,5 +6,5 @@ export type PermissionsPolicy = {
     childProcess?: PatternPermissionScope;
     process?: PatternPermissionScope;
     env?: PatternPermissionScope;
-    binding?: PatternPermissionScope;
+    hostFunction?: PatternPermissionScope;
 };

package/dist/generated/VmLimitsConfig.d.ts

@@ -1,5 +1,5 @@
 import type { AcpLimitsConfig } from "./AcpLimitsConfig.js";
-import type { BindingLimitsConfig } from "./BindingLimitsConfig.js";
+import type { HostFunctionLimitsConfig } from "./HostFunctionLimitsConfig.js";
 import type { HttpLimitsConfig } from "./HttpLimitsConfig.js";
 import type { JsRuntimeLimitsConfig } from "./JsRuntimeLimitsConfig.js";
 import type { PluginLimitsConfig } from "./PluginLimitsConfig.js";
@@ -10,7 +10,7 @@ import type { WasmLimitsConfig } from "./WasmLimitsConfig.js";
 export type VmLimitsConfig = {
     resources?: ResourceLimitsConfig;
     http?: HttpLimitsConfig;
-    bindings?: BindingLimitsConfig;
+    hostFunctions?: HostFunctionLimitsConfig;
     plugins?: PluginLimitsConfig;
     acp?: AcpLimitsConfig;
     jsRuntime?: JsRuntimeLimitsConfig;

package/dist/host-dir-mount.d.ts

@@ -17,11 +17,19 @@ export interface HostDirMountPluginConfig extends MountConfigJsonObject {
  */
 export declare function createHostDirBackend(options: HostDirBackendOptions): NativeMountPluginDescriptor<HostDirMountPluginConfig>;
 /** A native `host_dir` mount, the serializable form `AgentOsOptions.mounts` accepts. */
-export interface NodeModulesMountConfig {
+export interface HostDirMountConfig {
     path: string;
     plugin: NativeMountPluginDescriptor<HostDirMountPluginConfig>;
     readOnly: boolean;
 }
+export type NodeModulesMountConfig = HostDirMountConfig;
+/**
+ * Mount a host directory into the VM at `path`. Read-only unless `readOnly` is
+ * `false`. The guest sees only the mounted subtree, never the rest of the host.
+ */
+export declare function hostDirMount(path: string, hostPath: string, opts?: {
+    readOnly?: boolean;
+}): HostDirMountConfig;
 /**
  * Mount a host `node_modules` directory into the VM at `/root/node_modules`.
  *

package/dist/host-dir-mount.js

@@ -13,6 +13,18 @@ export function createHostDirBackend(options) {
         },
     };
 }
+/**
+ * Mount a host directory into the VM at `path`. Read-only unless `readOnly` is
+ * `false`. The guest sees only the mounted subtree, never the rest of the host.
+ */
+export function hostDirMount(path, hostPath, opts) {
+    const readOnly = opts?.readOnly ?? true;
+    return {
+        path,
+        plugin: createHostDirBackend({ hostPath, readOnly }),
+        readOnly,
+    };
+}
 /**
  * Mount a host `node_modules` directory into the VM at `/root/node_modules`.
  *
@@ -25,10 +37,5 @@ export function createHostDirBackend(options) {
  * @param opts.readOnly Defaults to `true`; the mount is read-only.
  */
 export function nodeModulesMount(hostNodeModulesDir, opts) {
-    const readOnly = opts?.readOnly ?? true;
-    return {
-        path: "/root/node_modules",
-        plugin: createHostDirBackend({ hostPath: hostNodeModulesDir, readOnly }),
-        readOnly,
-    };
+    return hostDirMount("/root/node_modules", hostNodeModulesDir, opts);
 }

package/dist/index.d.ts

@@ -1,14 +1,15 @@
+export { SidecarProcessError, SidecarProcessExited, SidecarRejectedError, type SidecarRejectionDetail, SidecarSilenceTimeout, } from "@rivet-dev/agentos-runtime-core/sidecar-errors";
 export { AgentOs, AgentOsSidecar } from "./agent-os.js";
-export type * from "./language-execution.js";
+export { isPackageDescriptor, OPT_AGENTOS_BIN, OPT_AGENTOS_ROOT, tryReadAgentosPackageManifest, } from "./agentos-package.js";
 export { CronManager, InvalidScheduleError, PastScheduleError, TimerScheduleDriver, } from "./cron/index.js";
-export { createHostDirBackend, nodeModulesMount } from "./host-dir-mount.js";
-export { binding, MAX_BINDING_DESCRIPTION_LENGTH, bindings, validateBindings, } from "./bindings.js";
-export type { Binding, BindingExample, Bindings } from "./bindings.js";
-export { agentOsLimitsSchema, agentOsOptionFieldSchemas, agentOsOptionsSchema, bindingSchema, mountConfigSchema, nativeMountConfigSchema, parseAgentOsOptions, permissionsSchema, rootFilesystemConfigSchema, sharedSidecarConfigSchema, sidecarConfigSchema, bindingsSchema, sidecarRuntimeConfigSchema, } from "./options-schema.js";
+export { createHostDirBackend, hostDirMount, nodeModulesMount, } from "./host-dir-mount.js";
+export type { HostFunction, HostFunctionCollection, HostFunctionCollections, HostFunctionExample, HostFunctionSchemas, ResolvedHostFunctions, } from "@rivet-dev/agentos-runtime-core/host-functions";
+export { hostFunctionCommandName, hostFunctionDescription, resolveHostFunctions, } from "@rivet-dev/agentos-runtime-core/host-functions";
+export type * from "./language-execution.js";
 export { createSnapshotExport } from "./layers.js";
+export { agentOsLimitsSchema, agentOsOptionFieldSchemas, agentOsOptionsSchema, hostFunctionCollectionSchema, hostFunctionSchema, hostFunctionsSchema, mountConfigSchema, nativeMountConfigSchema, parseAgentOsOptions, permissionsSchema, rootFilesystemConfigSchema, sharedSidecarConfigSchema, sidecarConfigSchema, sidecarRuntimeConfigSchema, } from "./options-schema.js";
 export { defineSoftware } from "./packages.js";
-export { isPackageDescriptor, OPT_AGENTOS_BIN, OPT_AGENTOS_ROOT, tryReadAgentosPackageManifest, } from "./agentos-package.js";
-export { KernelError } from "./runtime-compat.js";
 export type { ExecOptions, ExecResult, ManagedProcess, ProcessInfo, ShellHandle, VirtualDirEntry, VirtualStat, } from "./runtime.js";
-export { createSandboxBindings, createSandboxFs, getSandboxDisposeHooks, resolveSandboxOptions, } from "./sandbox.js";
+export { KernelError } from "./runtime-compat.js";
+export { createSandboxFs, createSandboxHostFunctions, getSandboxDisposeHooks, resolveSandboxOptions, } from "./sandbox.js";
 export type * from "./types.js";

package/dist/index.js

@@ -1,11 +1,12 @@
 // @rivet-dev/agentos
+export { SidecarProcessError, SidecarProcessExited, SidecarRejectedError, SidecarSilenceTimeout, } from "@rivet-dev/agentos-runtime-core/sidecar-errors";
 export { AgentOs, AgentOsSidecar } from "./agent-os.js";
+export { isPackageDescriptor, OPT_AGENTOS_BIN, OPT_AGENTOS_ROOT, tryReadAgentosPackageManifest, } from "./agentos-package.js";
 export { CronManager, InvalidScheduleError, PastScheduleError, TimerScheduleDriver, } from "./cron/index.js";
-export { createHostDirBackend, nodeModulesMount } from "./host-dir-mount.js";
-export { binding, MAX_BINDING_DESCRIPTION_LENGTH, bindings, validateBindings, } from "./bindings.js";
-export { agentOsLimitsSchema, agentOsOptionFieldSchemas, agentOsOptionsSchema, bindingSchema, mountConfigSchema, nativeMountConfigSchema, parseAgentOsOptions, permissionsSchema, rootFilesystemConfigSchema, sharedSidecarConfigSchema, sidecarConfigSchema, bindingsSchema, sidecarRuntimeConfigSchema, } from "./options-schema.js";
+export { createHostDirBackend, hostDirMount, nodeModulesMount, } from "./host-dir-mount.js";
+export { hostFunctionCommandName, hostFunctionDescription, resolveHostFunctions, } from "@rivet-dev/agentos-runtime-core/host-functions";
 export { createSnapshotExport } from "./layers.js";
+export { agentOsLimitsSchema, agentOsOptionFieldSchemas, agentOsOptionsSchema, hostFunctionCollectionSchema, hostFunctionSchema, hostFunctionsSchema, mountConfigSchema, nativeMountConfigSchema, parseAgentOsOptions, permissionsSchema, rootFilesystemConfigSchema, sharedSidecarConfigSchema, sidecarConfigSchema, sidecarRuntimeConfigSchema, } from "./options-schema.js";
 export { defineSoftware } from "./packages.js";
-export { isPackageDescriptor, OPT_AGENTOS_BIN, OPT_AGENTOS_ROOT, tryReadAgentosPackageManifest, } from "./agentos-package.js";
 export { KernelError } from "./runtime-compat.js";
-export { createSandboxBindings, createSandboxFs, getSandboxDisposeHooks, resolveSandboxOptions, } from "./sandbox.js";
+export { createSandboxFs, createSandboxHostFunctions, getSandboxDisposeHooks, resolveSandboxOptions, } from "./sandbox.js";

package/dist/language-execution.d.ts

@@ -25,6 +25,11 @@ export interface InlineExecutionOptions extends LanguageExecutionOptions {
     inputs?: Record<string, JsonValue>;
 }
 export interface JavaScriptExecutionOptions extends InlineExecutionOptions {
+    /**
+     * `module` (the default) evaluates each call as an independent root ES module.
+     * A retained context preserves `globalThis`, not the module's lexical scope.
+     * Use `commonjs` for REPL-style top-level bindings shared by later calls.
+     */
     format?: "module" | "commonjs";
     filePath?: string;
 }

package/dist/options-schema.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod/v4";
 import type { AgentExitHandler, AgentOsOptions, AgentStderrHandler, LimitWarningHandler, NativeMountConfig } from "./agent-os.js";
-import type { Binding, Bindings } from "./bindings.js";
+import type { HostFunction, HostFunctionCollection, HostFunctionCollections } from "@rivet-dev/agentos-runtime-core/host-functions";
 export declare const permissionsSchema: z.ZodObject<{
     fs: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         allow: "allow";
@@ -87,7 +87,7 @@ export declare const permissionsSchema: z.ZodObject<{
             patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>;
     }, z.core.$strict>]>>;
-    binding: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+    hostFunction: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         allow: "allow";
         deny: "deny";
     }>, z.ZodObject<{
@@ -134,15 +134,15 @@ export declare const agentOsLimitsSchema: z.ZodObject<{
     tls: z.ZodOptional<z.ZodObject<{
         maxBufferedBytes: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
-    bindings: z.ZodOptional<z.ZodObject<{
-        defaultBindingTimeoutMs: z.ZodOptional<z.ZodNumber>;
-        maxBindingTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    hostFunctions: z.ZodOptional<z.ZodObject<{
+        defaultTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxTimeoutMs: z.ZodOptional<z.ZodNumber>;
         maxRegisteredCollections: z.ZodOptional<z.ZodNumber>;
-        maxRegisteredBindingsPerVm: z.ZodOptional<z.ZodNumber>;
-        maxBindingsPerCollection: z.ZodOptional<z.ZodNumber>;
-        maxBindingSchemaBytes: z.ZodOptional<z.ZodNumber>;
-        maxExamplesPerBinding: z.ZodOptional<z.ZodNumber>;
-        maxBindingExampleInputBytes: z.ZodOptional<z.ZodNumber>;
+        maxRegisteredFunctionsPerVm: z.ZodOptional<z.ZodNumber>;
+        maxFunctionsPerCollection: z.ZodOptional<z.ZodNumber>;
+        maxSchemaBytes: z.ZodOptional<z.ZodNumber>;
+        maxExamplesPerFunction: z.ZodOptional<z.ZodNumber>;
+        maxExampleInputBytes: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     plugins: z.ZodOptional<z.ZodObject<{
         maxPersistedManifestBytes: z.ZodOptional<z.ZodNumber>;
@@ -275,8 +275,9 @@ export declare const sidecarConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
     kind: z.ZodLiteral<"explicit">;
     handle: z.ZodUnknown;
 }, z.core.$strict>]>;
-export declare const bindingSchema: z.ZodType<Binding>;
-export declare const bindingsSchema: z.ZodType<Bindings>;
+export declare const hostFunctionSchema: z.ZodType<HostFunction>;
+export declare const hostFunctionCollectionSchema: z.ZodType<HostFunctionCollection>;
+export declare const hostFunctionsSchema: z.ZodType<HostFunctionCollections>;
 /**
  * Shared AgentOsOptions field schemas.
  *
@@ -363,7 +364,7 @@ export declare const agentOsOptionFieldSchemas: {
     }, z.core.$strict>]>>>;
     readonly sandbox: z.ZodOptional<z.ZodCustom<unknown, unknown>>;
     readonly scheduleDriver: z.ZodOptional<z.ZodCustom<unknown, unknown>>;
-    readonly bindings: z.ZodOptional<z.ZodArray<z.ZodType<Bindings, unknown, z.core.$ZodTypeInternals<Bindings, unknown>>>>;
+    readonly hostFunctions: z.ZodOptional<z.ZodType<HostFunctionCollections<import("@rivet-dev/agentos-runtime-core/host-functions").HostFunctionSchemas>, unknown, z.core.$ZodTypeInternals<HostFunctionCollections<import("@rivet-dev/agentos-runtime-core/host-functions").HostFunctionSchemas>, unknown>>>;
     readonly permissions: z.ZodOptional<z.ZodObject<{
         fs: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
             allow: "allow";
@@ -450,7 +451,7 @@ export declare const agentOsOptionFieldSchemas: {
                 patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
             }, z.core.$strict>>;
         }, z.core.$strict>]>>;
-        binding: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        hostFunction: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
             allow: "allow";
             deny: "deny";
         }>, z.ZodObject<{
@@ -509,15 +510,15 @@ export declare const agentOsOptionFieldSchemas: {
         tls: z.ZodOptional<z.ZodObject<{
             maxBufferedBytes: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
-        bindings: z.ZodOptional<z.ZodObject<{
-            defaultBindingTimeoutMs: z.ZodOptional<z.ZodNumber>;
-            maxBindingTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        hostFunctions: z.ZodOptional<z.ZodObject<{
+            defaultTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            maxTimeoutMs: z.ZodOptional<z.ZodNumber>;
             maxRegisteredCollections: z.ZodOptional<z.ZodNumber>;
-            maxRegisteredBindingsPerVm: z.ZodOptional<z.ZodNumber>;
-            maxBindingsPerCollection: z.ZodOptional<z.ZodNumber>;
-            maxBindingSchemaBytes: z.ZodOptional<z.ZodNumber>;
-            maxExamplesPerBinding: z.ZodOptional<z.ZodNumber>;
-            maxBindingExampleInputBytes: z.ZodOptional<z.ZodNumber>;
+            maxRegisteredFunctionsPerVm: z.ZodOptional<z.ZodNumber>;
+            maxFunctionsPerCollection: z.ZodOptional<z.ZodNumber>;
+            maxSchemaBytes: z.ZodOptional<z.ZodNumber>;
+            maxExamplesPerFunction: z.ZodOptional<z.ZodNumber>;
+            maxExampleInputBytes: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
         plugins: z.ZodOptional<z.ZodObject<{
             maxPersistedManifestBytes: z.ZodOptional<z.ZodNumber>;

package/dist/options-schema.js

@@ -85,7 +85,7 @@ export const permissionsSchema = z
     childProcess: patternPermissionsSchema.optional(),
     process: patternPermissionsSchema.optional(),
     env: patternPermissionsSchema.optional(),
-    binding: patternPermissionsSchema.optional(),
+    hostFunction: patternPermissionsSchema.optional(),
 })
     .strict();
 export const agentOsLimitsSchema = z
@@ -123,16 +123,16 @@ export const agentOsLimitsSchema = z
         .object({ maxBufferedBytes: positiveInteger.optional() })
         .strict()
         .optional(),
-    bindings: z
+    hostFunctions: z
         .object({
-        defaultBindingTimeoutMs: nonNegativeInteger.optional(),
-        maxBindingTimeoutMs: nonNegativeInteger.optional(),
+        defaultTimeoutMs: nonNegativeInteger.optional(),
+        maxTimeoutMs: nonNegativeInteger.optional(),
         maxRegisteredCollections: positiveInteger.optional(),
-        maxRegisteredBindingsPerVm: positiveInteger.optional(),
-        maxBindingsPerCollection: positiveInteger.optional(),
-        maxBindingSchemaBytes: positiveInteger.optional(),
-        maxExamplesPerBinding: nonNegativeInteger.optional(),
-        maxBindingExampleInputBytes: positiveInteger.optional(),
+        maxRegisteredFunctionsPerVm: positiveInteger.optional(),
+        maxFunctionsPerCollection: positiveInteger.optional(),
+        maxSchemaBytes: positiveInteger.optional(),
+        maxExamplesPerFunction: nonNegativeInteger.optional(),
+        maxExampleInputBytes: positiveInteger.optional(),
     })
         .strict()
         .optional(),
@@ -320,30 +320,24 @@ export const sidecarConfigSchema = z.union([
     sharedSidecarConfigSchema,
     explicitSidecarSchema,
 ]);
-const bindingExampleSchema = z
+const hostFunctionExampleSchema = z
     .object({
     description: z.string(),
     input: z.unknown(),
 })
     .strict();
-export const bindingSchema = z
+export const hostFunctionSchema = z
     .object({
-    description: z.string(),
     inputSchema: z.custom((value) => typeof value === "object" && value !== null, {
         message: "Expected Zod schema object",
     }),
     execute: functionSchema,
-    examples: z.array(bindingExampleSchema).optional(),
+    examples: z.array(hostFunctionExampleSchema).optional(),
     timeout: nonNegativeInteger.optional(),
 })
     .strict();
-export const bindingsSchema = z
-    .object({
-    name: z.string(),
-    description: z.string(),
-    bindings: z.record(z.string(), bindingSchema),
-})
-    .strict();
+export const hostFunctionCollectionSchema = z.record(z.string(), hostFunctionSchema);
+export const hostFunctionsSchema = z.record(z.string(), hostFunctionCollectionSchema);
 /**
  * Shared AgentOsOptions field schemas.
  *
@@ -384,7 +378,7 @@ export const agentOsOptionFieldSchemas = {
         message: "Expected schedule driver object",
     })
         .optional(),
-    bindings: z.array(bindingsSchema).optional(),
+    hostFunctions: hostFunctionsSchema.optional(),
     permissions: permissionsSchema.optional(),
     sidecar: sidecarConfigSchema.optional(),
     limits: agentOsLimitsSchema.optional(),

package/dist/runtime-compat.d.ts

@@ -87,7 +87,7 @@ export type NetworkPermissions = PermissionMode | RulePermissions<PatternPermiss
 export type ChildProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type ProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type EnvPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
-export type BindingPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
+export type HostFunctionPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export interface ProcessInfo {
     pid: number;
     ppid: number;
@@ -176,7 +176,7 @@ export interface Permissions {
     childProcess?: ChildProcessPermissions;
     process?: ProcessPermissions;
     env?: EnvPermissions;
-    binding?: BindingPermissions;
+    hostFunction?: HostFunctionPermissions;
 }
 export interface ResourceBudgets {
     maxOutputBytes?: number;
@@ -323,10 +323,10 @@ export interface Kernel extends KernelInterface {
     readonly timerTable: Record<string, never>;
     readonly zombieTimerCount: number;
 }
-export interface BindingTree {
-    [key: string]: BindingFunction | BindingTree;
+export interface HostFunctionTree {
+    [key: string]: HostFunctionHandler | HostFunctionTree;
 }
-export type BindingFunction = (...args: unknown[]) => unknown;
+export type HostFunctionHandler = (...args: unknown[]) => unknown;
 export interface NodeDriverOptions {
     filesystem?: VirtualFileSystem;
     networkAdapter?: NetworkAdapter;
@@ -344,7 +344,7 @@ export interface NodeRuntimeOptions {
     runtimeDriverFactory?: NodeRuntimeDriverFactory;
     permissions?: Partial<Permissions>;
     memoryLimit?: number;
-    bindings?: BindingTree;
+    hostFunctions?: HostFunctionTree;
     loopbackExemptPorts?: number[];
 }
 export type NodeRuntimeDriverFactoryOptions = Record<string, never>;

package/dist/runtime.d.ts

@@ -81,7 +81,7 @@ export type NetworkPermissions = PermissionMode | RulePermissions<PatternPermiss
 export type ChildProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type ProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type EnvPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
-export type BindingPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
+export type HostFunctionPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export interface ProcessInfo {
     pid: number;
     ppid: number;
@@ -170,7 +170,7 @@ export interface Permissions {
     childProcess?: ChildProcessPermissions;
     process?: ProcessPermissions;
     env?: EnvPermissions;
-    binding?: BindingPermissions;
+    hostFunction?: HostFunctionPermissions;
 }
 export interface ResourceBudgets {
     maxOutputBytes?: number;
@@ -317,10 +317,10 @@ export interface Kernel extends KernelInterface {
     readonly timerTable: Record<string, never>;
     readonly zombieTimerCount: number;
 }
-export interface BindingTree {
-    [key: string]: BindingFunction | BindingTree;
+export interface HostFunctionTree {
+    [key: string]: HostFunctionHandler | HostFunctionTree;
 }
-export type BindingFunction = (...args: unknown[]) => unknown;
+export type HostFunctionHandler = (...args: unknown[]) => unknown;
 export interface NodeModulesMountConfig {
     path: string;
     plugin: {
@@ -349,7 +349,7 @@ export interface NodeRuntimeOptions {
     runtimeDriverFactory?: NodeRuntimeDriverFactory;
     permissions?: Partial<Permissions>;
     memoryLimit?: number;
-    bindings?: BindingTree;
+    hostFunctions?: HostFunctionTree;
     loopbackExemptPorts?: number[];
 }
 export type NodeRuntimeDriverFactoryOptions = Record<string, never>;

package/dist/sandbox.d.ts

@@ -1,5 +1,6 @@
+import { z } from "zod";
 import type { MountConfig, MountConfigJsonObject, NativeMountPluginDescriptor } from "./agent-os.js";
-import type { Bindings } from "./bindings.js";
+import type { HostFunction, HostFunctionCollections } from "@rivet-dev/agentos-runtime-core/host-functions";
 export interface AgentOsSandboxProcessResult {
     stdout?: string;
     stderr?: string;
@@ -86,7 +87,7 @@ declare const sandboxDisposeHooks: unique symbol;
 type SandboxDisposeHook = () => void | Promise<void>;
 export type AgentOsSandboxExpandedOptions = {
     mounts?: MountConfig[];
-    bindings?: Bindings[];
+    hostFunctions?: HostFunctionCollections;
     [sandboxDisposeHooks]?: SandboxDisposeHook[];
 };
 type ResolvedSandboxOptions = AgentOsSandboxCommonOptions & {
@@ -101,12 +102,83 @@ export type SandboxMountPluginConfig = MountConfigJsonObject & {
     maxFullReadBytes?: number;
 };
 export declare function createSandboxFs(input: ResolvedSandboxOptions | AgentOsSandboxClientOptions): NativeMountPluginDescriptor<SandboxMountPluginConfig>;
-export declare function createSandboxBindings(input: ResolvedSandboxOptions | AgentOsSandboxClientOptions): Bindings;
+export declare function createSandboxHostFunctions(input: ResolvedSandboxOptions | AgentOsSandboxClientOptions): {
+    runCommand: HostFunction<z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        cwd: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, {
+        stdout: string | undefined;
+        stderr: string | undefined;
+        exitCode: number | null | undefined;
+        timedOut: boolean | undefined;
+        durationMs: number | undefined;
+    }>;
+    createProcess: HostFunction<z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        cwd: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, {
+        id: string;
+        command: string | undefined;
+        args: string[] | undefined;
+        status: string | undefined;
+        pid: number | null | undefined;
+    }>;
+    listProcesses: HostFunction<z.ZodObject<{}, z.core.$strip>, {
+        processes: {
+            id: string;
+            command: string | undefined;
+            args: string[] | undefined;
+            status: string | undefined;
+            exitCode: number | null | undefined;
+            pid: number | null | undefined;
+        }[];
+    }>;
+    stopProcess: HostFunction<z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>, {
+        id: string;
+        status: string | undefined;
+        exitCode: number | null | undefined;
+    }>;
+    killProcess: HostFunction<z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>, {
+        id: string;
+        status: string | undefined;
+        exitCode: number | null | undefined;
+    }>;
+    getProcessLogs: HostFunction<z.ZodObject<{
+        id: z.ZodString;
+        stream: z.ZodOptional<z.ZodEnum<{
+            stderr: "stderr";
+            stdout: "stdout";
+            combined: "combined";
+        }>>;
+        tail: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, {
+        logs: {
+            data: string;
+            stream: string | undefined;
+            timestampMs: number | undefined;
+        }[];
+    }>;
+    sendInput: HostFunction<z.ZodObject<{
+        id: z.ZodString;
+        data: z.ZodString;
+    }, z.core.$strip>, {
+        sent: boolean;
+    }>;
+};
 export declare function getSandboxDisposeHooks(options: object | undefined): SandboxDisposeHook[];
 export declare function resolveSandboxOptions<T extends {
     sandbox?: AgentOsSandboxInput;
 }>(options: T): Promise<Omit<T, "sandbox"> & {
     mounts?: MountConfig[];
-    bindings?: Bindings[];
+    hostFunctions?: HostFunctionCollections;
 }>;
 export {};