@rivet-dev/agentos-runtime-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,6 +1,6 @@
 import type { AcpLimitsConfig } from "./AcpLimitsConfig.js";
-import type { BindingLimitsConfig } from "./BindingLimitsConfig.js";
 import type { ExecutionLimitsConfig } from "./ExecutionLimitsConfig.js";
+import type { HostFunctionLimitsConfig } from "./HostFunctionLimitsConfig.js";
 import type { Http2LimitsConfig } from "./Http2LimitsConfig.js";
 import type { HttpLimitsConfig } from "./HttpLimitsConfig.js";
 import type { JsRuntimeLimitsConfig } from "./JsRuntimeLimitsConfig.js";
@@ -20,7 +20,7 @@ export type VmLimitsConfig = {
     udp?: UdpLimitsConfig;
     tls?: TlsLimitsConfig;
     http2?: Http2LimitsConfig;
-    bindings?: BindingLimitsConfig;
+    hostFunctions?: HostFunctionLimitsConfig;
     plugins?: PluginLimitsConfig;
     acp?: AcpLimitsConfig;
     sqlite?: SqliteLimitsConfig;

package/dist/generated-protocol.d.ts

@@ -206,7 +206,7 @@ export type PermissionsPolicy = {
     readonly childProcess: PatternPermissionScope | null;
     readonly process: PatternPermissionScope | null;
     readonly env: PatternPermissionScope | null;
-    readonly binding: PatternPermissionScope | null;
+    readonly hostFunction: PatternPermissionScope | null;
 };
 export declare function readPermissionsPolicy(bc: bare.ByteCursor): PermissionsPolicy;
 export declare function writePermissionsPolicy(bc: bare.ByteCursor, x: PermissionsPolicy): void;
@@ -339,7 +339,7 @@ export type ConfigureVmRequest = {
     readonly packages: readonly PackageDescriptor[];
     readonly packagesMountAt: string;
     readonly bootstrapCommands: readonly string[];
-    readonly bindingShimCommands: readonly string[];
+    readonly hostFunctionShimCommands: readonly string[];
 };
 export declare function readConfigureVmRequest(bc: bare.ByteCursor): ConfigureVmRequest;
 export declare function writeConfigureVmRequest(bc: bare.ByteCursor, x: ConfigureVmRequest): void;

package/dist/generated-protocol.js

@@ -696,7 +696,7 @@ export function readPermissionsPolicy(bc) {
         childProcess: read11(bc),
         process: read11(bc),
         env: read11(bc),
-        binding: read11(bc),
+        hostFunction: read11(bc),
     };
 }
 export function writePermissionsPolicy(bc, x) {
@@ -705,7 +705,7 @@ export function writePermissionsPolicy(bc, x) {
     write11(bc, x.childProcess);
     write11(bc, x.process);
     write11(bc, x.env);
-    write11(bc, x.binding);
+    write11(bc, x.hostFunction);
 }
 export function readCreateVmRequest(bc) {
     return {
@@ -1102,7 +1102,7 @@ export function readConfigureVmRequest(bc) {
         packages: read20(bc),
         packagesMountAt: bare.readString(bc),
         bootstrapCommands: read6(bc),
-        bindingShimCommands: read6(bc),
+        hostFunctionShimCommands: read6(bc),
     };
 }
 export function writeConfigureVmRequest(bc, x) {
@@ -1117,7 +1117,7 @@ export function writeConfigureVmRequest(bc, x) {
     write20(bc, x.packages);
     bare.writeString(bc, x.packagesMountAt);
     write6(bc, x.bootstrapCommands);
-    write6(bc, x.bindingShimCommands);
+    write6(bc, x.hostFunctionShimCommands);
 }
 export function readRegisteredHostCallbackExample(bc) {
     return {

package/dist/host-functions-zod.d.ts

@@ -0,0 +1,9 @@
+import type { ZodType } from "zod";
+export declare class HostFunctionSchemaConversionError extends Error {
+    readonly path: string;
+    readonly zodType: string;
+    constructor(path: string, zodType: string, details?: string);
+}
+/** The `.describe()` text on a schema, if it has one. */
+export declare function schemaDescription(schema: ZodType): string | undefined;
+export declare function zodToJsonSchema(schema: ZodType): unknown;

package/dist/host-functions-zod.js

@@ -0,0 +1,274 @@
+import { zodToJsonSchema as zodV3ToJsonSchema } from "zod-to-json-schema";
+const OPTIONAL_WRAPPER_TYPES = new Set(["default", "optional"]);
+const TRANSPARENT_WRAPPER_TYPES = new Set([
+    ...OPTIONAL_WRAPPER_TYPES,
+    "branded",
+    "catch",
+    "readonly",
+]);
+const UNSUPPORTED_TYPES = new Set([
+    "bigint",
+    "date",
+    "effects",
+    "intersection",
+    "pipeline",
+    "pipe",
+    "tuple",
+]);
+export class HostFunctionSchemaConversionError extends Error {
+    path;
+    zodType;
+    constructor(path, zodType, details) {
+        super([
+            `Unsupported Zod schema at ${path}: ${zodType}`,
+            details ? `(${details})` : undefined,
+        ]
+            .filter(Boolean)
+            .join(" "));
+        this.name = "HostFunctionSchemaConversionError";
+        this.path = path;
+        this.zodType = zodType;
+    }
+}
+function getSchemaDef(schema) {
+    if (!schema || typeof schema !== "object") {
+        return {};
+    }
+    return (schema._def ??
+        schema.def ??
+        {});
+}
+function getInnerSchema(schema) {
+    const def = getSchemaDef(schema);
+    return (def.innerType ?? def.schema ?? def.type ?? def.in);
+}
+function normalizeTypeName(schema) {
+    const def = getSchemaDef(schema);
+    const constructorName = String(schema.constructor?.name ?? "")
+        .replace(/^Zod/, "")
+        .toLowerCase();
+    if (constructorName === "discriminatedunion" || "discriminator" in def) {
+        return "discriminatedunion";
+    }
+    const rawTypeName = String(def.typeName ??
+        def.type ??
+        schema.type ??
+        constructorName);
+    return rawTypeName.replace(/^Zod/, "").toLowerCase();
+}
+function displayTypeName(typeName) {
+    switch (typeName) {
+        case "discriminatedunion":
+            return "discriminatedUnion";
+        case "nativeenum":
+            return "nativeEnum";
+        default:
+            return typeName;
+    }
+}
+/** The `.describe()` text on a schema, if it has one. */
+export function schemaDescription(schema) {
+    return getDescription(schema);
+}
+function getDescription(schema) {
+    const def = getSchemaDef(schema);
+    if (typeof def.description === "string") {
+        return def.description;
+    }
+    const instanceDescription = schema.description;
+    return typeof instanceDescription === "string"
+        ? instanceDescription
+        : undefined;
+}
+function joinPath(parent, segment) {
+    return parent === "$" ? `$.${segment}` : `${parent}.${segment}`;
+}
+function metadataProducesRefs(schema) {
+    const meta = schema.meta?.();
+    return (typeof meta === "object" &&
+        meta !== null &&
+        ("id" in meta || "$ref" in meta || "$defs" in meta));
+}
+function getChecks(schema) {
+    const checks = getSchemaDef(schema).checks;
+    return Array.isArray(checks) ? checks : [];
+}
+function isCustomRefinement(check) {
+    const checkDef = getSchemaDef(check);
+    const nestedDef = getSchemaDef(check._zod);
+    return (String(checkDef.check ?? nestedDef.check ?? "").toLowerCase() === "custom");
+}
+function validateChecks(schema, path, typeName) {
+    if (getChecks(schema).some(isCustomRefinement)) {
+        throw new HostFunctionSchemaConversionError(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 HostFunctionSchemaConversionError(path, displayTypeName(typeName), "metadata that emits $ref/$defs is not supported");
+    }
+    if (UNSUPPORTED_TYPES.has(typeName)) {
+        throw new HostFunctionSchemaConversionError(path, displayTypeName(typeName));
+    }
+    if (typeName === "discriminatedunion") {
+        throw new HostFunctionSchemaConversionError(path, displayTypeName(typeName));
+    }
+    if (TRANSPARENT_WRAPPER_TYPES.has(typeName)) {
+        const inner = getInnerSchema(schema);
+        if (!inner) {
+            throw new HostFunctionSchemaConversionError(path, displayTypeName(typeName), "wrapper schema is missing its inner schema");
+        }
+        validateSchema(inner, path);
+        return;
+    }
+    if (typeName === "nullable") {
+        const inner = getInnerSchema(schema);
+        if (!inner) {
+            throw new HostFunctionSchemaConversionError(path, displayTypeName(typeName), "nullable schema is missing its inner schema");
+        }
+        validateSchema(inner, path);
+        return;
+    }
+    validateChecks(schema, path, typeName);
+    if (typeName === "object") {
+        const rawShape = getSchemaDef(schema).shape;
+        const shape = typeof rawShape === "function"
+            ? rawShape()
+            : (rawShape ?? {});
+        for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+            validateSchema(fieldSchema, joinPath(path, fieldName));
+        }
+        return;
+    }
+    if (typeName === "array") {
+        const def = getSchemaDef(schema);
+        const itemSchema = (def.element ?? def.type);
+        if (!itemSchema) {
+            throw new HostFunctionSchemaConversionError(path, displayTypeName(typeName), "array schema is missing its item schema");
+        }
+        validateSchema(itemSchema, `${path}[]`);
+        return;
+    }
+    if (typeName === "record") {
+        const def = getSchemaDef(schema);
+        const keySchema = def.keyType;
+        const valueSchema = def.valueType;
+        if (!keySchema || !valueSchema) {
+            throw new HostFunctionSchemaConversionError(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 HostFunctionSchemaConversionError(path, displayTypeName(typeName), "record keys must be unconstrained strings");
+        }
+        validateSchema(valueSchema, `${path}<record-value>`);
+        return;
+    }
+    if (typeName === "union") {
+        const options = getSchemaDef(schema).options;
+        if (!Array.isArray(options) || options.length === 0) {
+            throw new HostFunctionSchemaConversionError(path, displayTypeName(typeName), "union schema is missing its options");
+        }
+        for (let index = 0; index < options.length; index += 1) {
+            validateSchema(options[index], `${path}<union:${index}>`);
+        }
+        return;
+    }
+    if (typeName === "literal") {
+        const def = getSchemaDef(schema);
+        const literalValues = Array.isArray(def.values)
+            ? def.values
+            : "value" in def
+                ? [def.value]
+                : [];
+        const [literalValue] = literalValues;
+        if (literalValues.length !== 1 ||
+            !("string number boolean".split(" ").includes(typeof literalValue) ||
+                literalValue === null)) {
+            throw new HostFunctionSchemaConversionError(path, displayTypeName(typeName), "literal values must be JSON primitives");
+        }
+        return;
+    }
+    if (typeName === "string" ||
+        typeName === "number" ||
+        typeName === "boolean" ||
+        typeName === "enum" ||
+        typeName === "nativeenum") {
+        return;
+    }
+    throw new HostFunctionSchemaConversionError(path, displayTypeName(typeName));
+}
+function sanitizeJsonSchema(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeJsonSchema(item));
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    const record = value;
+    const sanitized = {};
+    for (const [key, entry] of Object.entries(record)) {
+        if (key === "$schema") {
+            continue;
+        }
+        if (key === "additionalProperties" &&
+            entry === false &&
+            record.type === "object") {
+            continue;
+        }
+        sanitized[key] = sanitizeJsonSchema(entry);
+    }
+    return sanitized;
+}
+function findUnsupportedGeneratedKeyword(value, path) {
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            const match = findUnsupportedGeneratedKeyword(value[index], `${path}[${index}]`);
+            if (match) {
+                return match;
+            }
+        }
+        return null;
+    }
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    for (const [key, entry] of Object.entries(value)) {
+        if (key === "$ref" || key === "$defs") {
+            return { keyword: key, path };
+        }
+        const match = findUnsupportedGeneratedKeyword(entry, joinPath(path, key));
+        if (match) {
+            return match;
+        }
+    }
+    return null;
+}
+function generateJsonSchema(schema) {
+    const nativeJsonSchema = schema.toJSONSchema?.();
+    if (nativeJsonSchema) {
+        return nativeJsonSchema;
+    }
+    const generated = zodV3ToJsonSchema(schema, {
+        $refStrategy: "none",
+        target: "jsonSchema7",
+    });
+    if (!generated ||
+        (typeof generated === "object" && Object.keys(generated).length === 0)) {
+        throw new HostFunctionSchemaConversionError("$", displayTypeName(normalizeTypeName(schema)), "schema cannot be converted to JSON Schema");
+    }
+    return generated;
+}
+export function zodToJsonSchema(schema) {
+    validateSchema(schema, "$");
+    const jsonSchema = generateJsonSchema(schema);
+    const unsupportedKeyword = findUnsupportedGeneratedKeyword(jsonSchema, "$");
+    if (unsupportedKeyword) {
+        throw new HostFunctionSchemaConversionError("$", displayTypeName(normalizeTypeName(schema)), `${unsupportedKeyword.keyword} emitted at ${unsupportedKeyword.path} is not supported`);
+    }
+    const sanitized = sanitizeJsonSchema(jsonSchema);
+    const description = getDescription(schema);
+    return description && typeof sanitized === "object" && sanitized !== null
+        ? { ...sanitized, description }
+        : sanitized;
+}

package/dist/host-functions.d.ts

@@ -0,0 +1,95 @@
+import type { ZodType, z } from "zod";
+/**
+ * A single function that executes on the host.
+ *
+ * The function carries no name or description of its own: the key it is
+ * registered under names it, and `inputSchema.describe()` documents it for the
+ * agent.
+ */
+export interface HostFunction<SCHEMA extends ZodType = ZodType, OUTPUT = any> {
+    /**
+     * Zod schema for the input. Drives CLI flag generation and validation.
+     * `.describe()` on the schema becomes the function's description in `--help`
+     * and in the agent's system prompt; `.describe()` on a field documents that
+     * field's flag.
+     */
+    inputSchema: SCHEMA;
+    /**
+     * Runs on the host when the agent invokes the function. Its input is the
+     * type `inputSchema` describes, inferred when the collection is written
+     * inline in the call that takes it.
+     */
+    execute: (input: HostFunctionInput<SCHEMA>) => Promise<OUTPUT> | OUTPUT;
+    /** Examples included in auto-generated prompt docs. */
+    examples?: HostFunctionExample<HostFunctionInput<SCHEMA>>[];
+    /** Timeout in ms. Default: 30000. */
+    timeout?: number;
+}
+/**
+ * The input type a function's `execute` receives. A concrete schema gives the
+ * type it describes; a collection built outside the call that takes it has no
+ * schema to infer from, so it falls back to `any` rather than making every
+ * handler annotate its parameter.
+ */
+export type HostFunctionInput<SCHEMA extends ZodType> = ZodType extends SCHEMA ? any : z.infer<SCHEMA>;
+export interface HostFunctionExample<INPUT = any> {
+    /** Human description of what this example does. */
+    description: string;
+    /** The input args for the example. */
+    input: INPUT;
+}
+/**
+ * One collection of host functions, keyed by function name. Each key becomes a
+ * subcommand of the collection's CLI binary and a method on the collection's
+ * guest global.
+ */
+export type HostFunctionCollection<T extends Record<string, ZodType> = Record<string, ZodType>> = {
+    [name in keyof T]: HostFunction<T[name]>;
+};
+/**
+ * The input schemas behind a set of collections. Only used to give each
+ * `execute` its input type: `AgentOs.create()` infers this from the literal, so
+ * `execute` sees the type its own `inputSchema` describes without a wrapper
+ * call to hang the inference on.
+ */
+export type HostFunctionSchemas = Record<string, Record<string, ZodType>>;
+/**
+ * Host function collections, keyed by collection name. Each key becomes the CLI
+ * binary `agentos-{name}` and a frozen guest global.
+ *
+ * ```ts
+ * hostFunctions: {
+ *   store: {
+ *     listOrders: { inputSchema, execute },
+ *   },
+ * }
+ * ```
+ */
+export type HostFunctionCollections<T extends HostFunctionSchemas = HostFunctionSchemas> = {
+    [collection in keyof T]: HostFunctionCollection<T[collection]>;
+};
+/**
+ * A collection resolved to the names the VM uses. Keys arrive as JavaScript
+ * identifiers and are converted once here, so the rest of the client and the
+ * sidecar only ever see kebab-case command names.
+ */
+export interface ResolvedHostFunctions {
+    /** Kebab-case collection name. Becomes the CLI suffix: `agentos-{name}`. */
+    name: string;
+    /** Functions keyed by kebab-case command name. */
+    functions: Record<string, HostFunction>;
+}
+/**
+ * Convert a registration key to its command name. `listOrders` and
+ * `list-orders` both become `list-orders`, so the guest sees one spelling
+ * whichever the caller wrote.
+ */
+export declare function hostFunctionCommandName(key: string): string;
+/** The description the agent sees, taken from the input schema's `.describe()`. */
+export declare function hostFunctionDescription(definition: HostFunction): string;
+/**
+ * Resolve the caller's collections into the shape the client and sidecar use.
+ * Throws on a key that cannot become a command name, and on two keys that
+ * collide once converted.
+ */
+export declare function resolveHostFunctions(collections: HostFunctionCollections): ResolvedHostFunctions[];

package/dist/host-functions.js

@@ -0,0 +1,54 @@
+import { schemaDescription } from "./host-functions-zod.js";
+const HOST_FUNCTION_COMMAND_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/**
+ * Convert a registration key to its command name. `listOrders` and
+ * `list-orders` both become `list-orders`, so the guest sees one spelling
+ * whichever the caller wrote.
+ */
+export function hostFunctionCommandName(key) {
+    return key
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+        .toLowerCase();
+}
+function toCommandName(kind, key) {
+    const name = hostFunctionCommandName(key);
+    if (!HOST_FUNCTION_COMMAND_NAME_RE.test(name)) {
+        throw new Error(`${kind} name "${key}" must be alphanumeric, written in camelCase or with single hyphen separators`);
+    }
+    return name;
+}
+/** The description the agent sees, taken from the input schema's `.describe()`. */
+export function hostFunctionDescription(definition) {
+    return schemaDescription(definition.inputSchema) ?? "";
+}
+/**
+ * Resolve the caller's collections into the shape the client and sidecar use.
+ * Throws on a key that cannot become a command name, and on two keys that
+ * collide once converted.
+ */
+export function resolveHostFunctions(collections) {
+    const resolved = [];
+    const seenCollections = new Map();
+    for (const [collectionKey, collection] of Object.entries(collections)) {
+        const name = toCommandName("Host function collection", collectionKey);
+        const collidedCollection = seenCollections.get(name);
+        if (collidedCollection !== undefined) {
+            throw new Error(`Host function collections "${collidedCollection}" and "${collectionKey}" both resolve to the command name "${name}"`);
+        }
+        seenCollections.set(name, collectionKey);
+        const functions = {};
+        const seenFunctions = new Map();
+        for (const [functionKey, definition] of Object.entries(collection)) {
+            const functionName = toCommandName("Host function", functionKey);
+            const collidedFunction = seenFunctions.get(functionName);
+            if (collidedFunction !== undefined) {
+                throw new Error(`Host functions "${collidedFunction}" and "${functionKey}" in collection "${collectionKey}" both resolve to the command name "${functionName}"`);
+            }
+            seenFunctions.set(functionName, functionKey);
+            functions[functionName] = definition;
+        }
+        resolved.push({ name, functions });
+    }
+    return resolved;
+}

package/dist/node-runtime-options-schema.d.ts

@@ -86,7 +86,7 @@ export declare const nodeRuntimePermissionsSchema: 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<{

package/dist/node-runtime-options-schema.js

@@ -67,7 +67,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,
@@ -79,7 +82,7 @@ export const nodeRuntimePermissionsSchema = z
     childProcess: patternPermissionsSchema.optional(),
     process: patternPermissionsSchema.optional(),
     env: patternPermissionsSchema.optional(),
-    binding: patternPermissionsSchema.optional(),
+    hostFunction: patternPermissionsSchema.optional(),
 })
     .strict();
 const uint8ArraySchema = z.custom((value) => value instanceof Uint8Array, { message: "Expected Uint8Array" });
@@ -104,20 +107,18 @@ const jsRuntimeSchema = z
     highResolutionTime: z.boolean().optional(),
 })
     .strict();
-const bindingExampleSchema = z
+const hostFunctionExampleSchema = z
     .object({
     description: z.string(),
     input: z.unknown(),
 })
     .strict();
-const bindingDefinitionSchema = z
+const hostFunctionDefinitionSchema = z
     .object({
-    description: z.string(),
-    inputSchema: z.custom((value) => typeof value === "object" && value !== null, { message: "Expected JSON Schema object" }),
-    timeoutMs: z.number().int().nonnegative().optional(),
-    examples: z.array(bindingExampleSchema).optional(),
-    commandAliases: stringArray.optional(),
-    handler: z.custom((value) => typeof value === "function", { message: "Expected function" }),
+    inputSchema: z.custom((value) => typeof value === "object" && value !== null, { message: "Expected Zod schema object" }),
+    timeout: z.number().int().nonnegative().optional(),
+    examples: z.array(hostFunctionExampleSchema).optional(),
+    execute: z.custom((value) => typeof value === "function", { message: "Expected function" }),
 })
     .strict();
 /**
@@ -151,10 +152,10 @@ export const nodeRuntimeCreateOptionsSchema = z
         .optional(),
     mounts: z.array(hostDirectoryMountSchema).optional(),
     nodeModules: z.union([z.string(), nodeModulesMountSchema]).optional(),
-    bindings: z.record(z.string(), bindingDefinitionSchema).optional(),
-    loopbackExemptPorts: z
-        .array(z.number().int().min(0).max(65535))
+    hostFunctions: z
+        .record(z.string(), hostFunctionDefinitionSchema)
         .optional(),
+    loopbackExemptPorts: z.array(z.number().int().min(0).max(65535)).optional(),
     jsRuntime: jsRuntimeSchema.optional(),
 })
     .strict();