@rivet-dev/agentos-core 0.0.0-agentos-dylib-plugin.473700e

package/dist/cron/timer-driver.d.ts

@@ -0,0 +1,17 @@
+import type { ScheduleDriver, ScheduleEntry, ScheduleHandle } from "./schedule-driver.js";
+/**
+ * Default ScheduleDriver that uses in-process timers. For cron expressions
+ * it parses via croner and sets a single timeout for the next fire time,
+ * rescheduling after each fire. For ISO 8601 one-shot timestamps it fires
+ * once and removes the entry.
+ *
+ * Uses long-timeout to support delays exceeding setTimeout's 2^31ms limit.
+ */
+export declare class TimerScheduleDriver implements ScheduleDriver {
+    private timers;
+    private entries;
+    schedule(entry: ScheduleEntry): ScheduleHandle;
+    cancel(handle: ScheduleHandle): void;
+    dispose(): void;
+    private scheduleNext;
+}

package/dist/cron/timer-driver.js

@@ -0,0 +1,61 @@
+import { clearTimeout as clearLongTimeout, setTimeout as longSetTimeout, } from "long-timeout";
+import { resolveSchedule, validateScheduleForRegistration, } from "./parse-schedule.js";
+/**
+ * Default ScheduleDriver that uses in-process timers. For cron expressions
+ * it parses via croner and sets a single timeout for the next fire time,
+ * rescheduling after each fire. For ISO 8601 one-shot timestamps it fires
+ * once and removes the entry.
+ *
+ * Uses long-timeout to support delays exceeding setTimeout's 2^31ms limit.
+ */
+export class TimerScheduleDriver {
+    timers = new Map();
+    entries = new Map();
+    schedule(entry) {
+        const resolved = validateScheduleForRegistration(entry.schedule);
+        this.entries.set(entry.id, entry);
+        this.scheduleNext(entry, resolved);
+        return { id: entry.id };
+    }
+    cancel(handle) {
+        const timer = this.timers.get(handle.id);
+        if (timer) {
+            clearLongTimeout(timer);
+            this.timers.delete(handle.id);
+        }
+        this.entries.delete(handle.id);
+    }
+    dispose() {
+        for (const timer of this.timers.values()) {
+            clearLongTimeout(timer);
+        }
+        this.timers.clear();
+        this.entries.clear();
+    }
+    scheduleNext(entry, resolved = resolveSchedule(entry.schedule)) {
+        const { parsed, nextRun: next } = resolved;
+        const isCron = parsed.kind === "cron";
+        if (!next) {
+            this.timers.delete(entry.id);
+            this.entries.delete(entry.id);
+            return;
+        }
+        const delay = Math.max(0, next.getTime() - Date.now());
+        const timer = longSetTimeout(async () => {
+            this.timers.delete(entry.id);
+            try {
+                await entry.callback();
+            }
+            catch {
+                // The driver is fire-and-forget; error handling is the caller's responsibility.
+            }
+            if (isCron && this.entries.has(entry.id)) {
+                this.scheduleNext(entry);
+            }
+            else {
+                this.entries.delete(entry.id);
+            }
+        }, delay);
+        this.timers.set(entry.id, timer);
+    }
+}

package/dist/cron/types.d.ts

@@ -0,0 +1,55 @@
+import type { CreateSessionOptions } from "../agent-os.js";
+import type { AgentType } from "../agents.js";
+export type CronAction = {
+    type: "session";
+    agentType: AgentType;
+    prompt: string;
+    options?: CreateSessionOptions;
+} | {
+    type: "exec";
+    command: string;
+    args?: string[];
+} | {
+    type: "callback";
+    fn: () => void | Promise<void>;
+};
+export interface CronJobOptions {
+    /** Optional ID. Auto-generated UUID if omitted. */
+    id?: string;
+    /** Standard 5-field cron expression or ISO 8601 timestamp for one-shot. */
+    schedule: string;
+    /** What to do when the schedule fires. */
+    action: CronAction;
+    /** What to do if previous execution is still running. Default: 'allow'. */
+    overlap?: "allow" | "skip" | "queue";
+}
+export interface CronJob {
+    id: string;
+    cancel(): void;
+}
+export interface CronJobInfo {
+    id: string;
+    schedule: string;
+    action: CronAction;
+    overlap: "allow" | "skip" | "queue";
+    lastRun?: Date;
+    nextRun?: Date;
+    runCount: number;
+    running: boolean;
+}
+export type CronEvent = {
+    type: "cron:fire";
+    jobId: string;
+    time: Date;
+} | {
+    type: "cron:complete";
+    jobId: string;
+    time: Date;
+    durationMs: number;
+} | {
+    type: "cron:error";
+    jobId: string;
+    time: Date;
+    error: Error;
+};
+export type CronEventHandler = (event: CronEvent) => void;

package/dist/cron/types.js

@@ -0,0 +1 @@
+export {};

package/dist/filesystem-snapshot.d.ts

@@ -0,0 +1,14 @@
+import { type VirtualFileSystem } from "./runtime-compat.js";
+export interface FilesystemEntry {
+    path: string;
+    type: "directory" | "file" | "symlink";
+    mode: string;
+    uid: number;
+    gid: number;
+    content?: string;
+    encoding?: "utf8" | "base64";
+    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

@@ -0,0 +1,105 @@
+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;
+        const depthB = b.path === "/" ? 0 : b.path.split("/").filter(Boolean).length;
+        if (depthA !== depthB) {
+            return depthA - depthB;
+        }
+        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)}`;
+}
+async function snapshotPath(filesystem, path, entries) {
+    const stat = path === "/" ? await filesystem.stat(path) : await filesystem.lstat(path);
+    if (stat.isSymbolicLink) {
+        entries.push({
+            path,
+            type: "symlink",
+            mode: toModeString(stat.mode),
+            uid: stat.uid,
+            gid: stat.gid,
+            target: await filesystem.readlink(path),
+        });
+        return;
+    }
+    if (stat.isDirectory) {
+        entries.push({
+            path,
+            type: "directory",
+            mode: toModeString(stat.mode),
+            uid: stat.uid,
+            gid: stat.gid,
+        });
+        const dirEntries = await filesystem.readDirWithTypes(path);
+        const children = dirEntries
+            .map((entry) => entry.name)
+            .filter((name) => name !== "." && name !== "..")
+            .sort((a, b) => a.localeCompare(b));
+        for (const child of children) {
+            const childPath = path === "/" ? posixPath.join("/", child) : posixPath.join(path, child);
+            await snapshotPath(filesystem, childPath, entries);
+        }
+        return;
+    }
+    const content = Buffer.from(await filesystem.readFile(path)).toString("base64");
+    entries.push({
+        path,
+        type: "file",
+        mode: toModeString(stat.mode),
+        uid: stat.uid,
+        gid: stat.gid,
+        content,
+        encoding: "base64",
+    });
+}
+export async function snapshotVirtualFilesystem(filesystem, rootPath = "/") {
+    const entries = [];
+    await snapshotPath(filesystem, rootPath, entries);
+    return entries;
+}

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

@@ -0,0 +1,38 @@
+import type { MountConfigJsonObject, NativeMountPluginDescriptor } from "@secure-exec/core/descriptors";
+export interface HostDirBackendOptions {
+    /** Absolute path to the host directory to project into the VM. */
+    hostPath: string;
+    /** If true (default), write operations are blocked for the mount. */
+    readOnly?: boolean;
+}
+export interface HostDirMountPluginConfig extends MountConfigJsonObject {
+    hostPath: string;
+    readOnly: boolean;
+}
+/**
+ * Create a declarative host-dir mount plugin descriptor.
+ *
+ * This keeps the legacy helper name while routing first-party host-dir
+ * mounts through the native `host_dir` plugin instead of a JS VFS backend.
+ */
+export declare function createHostDirBackend(options: HostDirBackendOptions): NativeMountPluginDescriptor<HostDirMountPluginConfig>;
+/** A native `host_dir` mount, the serializable form `AgentOsOptions.mounts` accepts. */
+export interface NodeModulesMountConfig {
+    path: string;
+    plugin: NativeMountPluginDescriptor<HostDirMountPluginConfig>;
+    readOnly: boolean;
+}
+/**
+ * Mount a host `node_modules` directory into the VM at `/root/node_modules`.
+ *
+ * This is the explicit replacement for the removed `moduleAccessCwd` option:
+ * the VM's module resolver reads the mounted tree through the kernel VFS, so the
+ * caller supplies exactly the `node_modules` directory whose packages should be
+ * resolvable in the guest (e.g. the agent SDK + its transitive deps).
+ *
+ * @param hostNodeModulesDir Absolute host path to a `node_modules` directory.
+ * @param opts.readOnly Defaults to `true`; the mount is read-only.
+ */
+export declare function nodeModulesMount(hostNodeModulesDir: string, opts?: {
+    readOnly?: boolean;
+}): NodeModulesMountConfig;

package/dist/host-dir-mount.js

@@ -0,0 +1,34 @@
+/**
+ * Create a declarative host-dir mount plugin descriptor.
+ *
+ * This keeps the legacy helper name while routing first-party host-dir
+ * mounts through the native `host_dir` plugin instead of a JS VFS backend.
+ */
+export function createHostDirBackend(options) {
+    return {
+        id: "host_dir",
+        config: {
+            hostPath: options.hostPath,
+            readOnly: options.readOnly ?? true,
+        },
+    };
+}
+/**
+ * Mount a host `node_modules` directory into the VM at `/root/node_modules`.
+ *
+ * This is the explicit replacement for the removed `moduleAccessCwd` option:
+ * the VM's module resolver reads the mounted tree through the kernel VFS, so the
+ * caller supplies exactly the `node_modules` directory whose packages should be
+ * resolvable in the guest (e.g. the agent SDK + its transitive deps).
+ *
+ * @param hostNodeModulesDir Absolute host path to a `node_modules` directory.
+ * @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,
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { ZodType } from "zod";
+export declare class HostToolSchemaConversionError extends Error {
+    readonly path: string;
+    readonly zodType: string;
+    constructor(path: string, zodType: string, details?: string);
+}
+export declare function zodToJsonSchema(schema: ZodType): unknown;

package/dist/host-tools-zod.js

@@ -0,0 +1,243 @@
+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 HostToolSchemaConversionError extends Error {
+    path;
+    zodType;
+    constructor(path, zodType, details) {
+        super([
+            `Unsupported Zod schema at ${path}: ${zodType}`,
+            details ? `(${details})` : undefined,
+        ]
+            .filter(Boolean)
+            .join(" "));
+        this.name = "HostToolSchemaConversionError";
+        this.path = path;
+        this.zodType = zodType;
+    }
+}
+function getSchemaDef(schema) {
+    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;
+    }
+}
+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 HostToolSchemaConversionError(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");
+    }
+    if (UNSUPPORTED_TYPES.has(typeName)) {
+        throw new HostToolSchemaConversionError(path, displayTypeName(typeName));
+    }
+    if (typeName === "discriminatedunion") {
+        throw new HostToolSchemaConversionError(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");
+        }
+        validateSchema(inner, path);
+        return;
+    }
+    if (typeName === "nullable") {
+        const inner = getInnerSchema(schema);
+        if (!inner) {
+            throw new HostToolSchemaConversionError(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 itemSchema = getSchemaDef(schema).element;
+        if (!itemSchema) {
+            throw new HostToolSchemaConversionError(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 HostToolSchemaConversionError(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");
+        }
+        validateSchema(valueSchema, `${path}<record-value>`);
+        return;
+    }
+    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");
+        }
+        for (let index = 0; index < options.length; index += 1) {
+            validateSchema(options[index], `${path}<union:${index}>`);
+        }
+        return;
+    }
+    if (typeName === "literal") {
+        const values = getSchemaDef(schema).values;
+        const literalValues = Array.isArray(values) ? values : [];
+        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");
+        }
+        return;
+    }
+    if (typeName === "string" ||
+        typeName === "number" ||
+        typeName === "boolean" ||
+        typeName === "enum" ||
+        typeName === "nativeenum") {
+        return;
+    }
+    throw new HostToolSchemaConversionError(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;
+}
+export function zodToJsonSchema(schema) {
+    validateSchema(schema, "$");
+    const jsonSchema = schema.toJSONSchema?.();
+    if (!jsonSchema) {
+        throw new HostToolSchemaConversionError("$", displayTypeName(normalizeTypeName(schema)), "schema does not expose toJSONSchema()");
+    }
+    const unsupportedKeyword = findUnsupportedGeneratedKeyword(jsonSchema, "$");
+    if (unsupportedKeyword) {
+        throw new HostToolSchemaConversionError("$", 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-tools.d.ts

@@ -0,0 +1,45 @@
+import type { ZodType } from "zod";
+/** Maximum length for tool and toolkit descriptions (characters). */
+export declare const MAX_TOOL_DESCRIPTION_LENGTH = 200;
+/**
+ * A single tool that executes on the host.
+ * Mirrors the shape of AI SDK's tool() but with host-execution semantics.
+ */
+export interface HostTool<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 tool. */
+    execute: (input: INPUT) => Promise<OUTPUT> | OUTPUT;
+    /** Examples included in auto-generated prompt docs. */
+    examples?: ToolExample<INPUT>[];
+    /** Timeout in ms. Default: 30000. */
+    timeout?: number;
+}
+export interface ToolExample<INPUT = any> {
+    /** Human description of what this example does. */
+    description: string;
+    /** The input args for the example. */
+    input: INPUT;
+}
+/**
+ * A named group of tools. Becomes a CLI binary: agentos-{name}.
+ */
+export interface ToolKit {
+    /** Toolkit name. Must be lowercase alphanumeric + hyphens. Becomes the CLI suffix: agentos-{name}. */
+    name: string;
+    /** Description shown in `agentos list-tools` and prompt docs. */
+    description: string;
+    /** The tools in this toolkit. Keys become subcommands. */
+    tools: Record<string, HostTool>;
+}
+/** Helper to create a HostTool with type inference. */
+export declare function hostTool<INPUT, OUTPUT>(def: HostTool<INPUT, OUTPUT>): HostTool<INPUT, OUTPUT>;
+/** Helper to create a ToolKit. */
+export declare function toolKit(def: ToolKit): ToolKit;
+/**
+ * Validate all description lengths in the given toolkits.
+ * Throws if any toolkit or tool description exceeds MAX_TOOL_DESCRIPTION_LENGTH.
+ */
+export declare function validateToolkits(toolKits: ToolKit[]): void;

package/dist/host-tools.js

@@ -0,0 +1,26 @@
+/** Maximum length for tool and toolkit descriptions (characters). */
+export const MAX_TOOL_DESCRIPTION_LENGTH = 200;
+/** Helper to create a HostTool with type inference. */
+export function hostTool(def) {
+    return def;
+}
+/** Helper to create a ToolKit. */
+export function toolKit(def) {
+    return def;
+}
+/**
+ * Validate all description lengths in the given toolkits.
+ * Throws if any toolkit or tool description exceeds MAX_TOOL_DESCRIPTION_LENGTH.
+ */
+export function validateToolkits(toolKits) {
+    for (const tk of toolKits) {
+        if (tk.description.length > MAX_TOOL_DESCRIPTION_LENGTH) {
+            throw new Error(`Toolkit "${tk.name}" description is ${tk.description.length} characters, max is ${MAX_TOOL_DESCRIPTION_LENGTH}`);
+        }
+        for (const [toolName, tool] of Object.entries(tk.tools)) {
+            if (tool.description.length > MAX_TOOL_DESCRIPTION_LENGTH) {
+                throw new Error(`Tool "${tk.name}/${toolName}" description is ${tool.description.length} characters, max is ${MAX_TOOL_DESCRIPTION_LENGTH}`);
+            }
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { AgentOs, AgentOsSidecar } from "./agent-os.js";
+export { AGENT_CONFIGS } from "./agents.js";
+export { CronManager, InvalidScheduleError, PastScheduleError, TimerScheduleDriver, } from "./cron/index.js";
+export { createHostDirBackend, nodeModulesMount } from "./host-dir-mount.js";
+export { hostTool, MAX_TOOL_DESCRIPTION_LENGTH, toolKit, validateToolkits, } from "./host-tools.js";
+export { createInMemoryLayerStore, createSnapshotExport, } from "./layers.js";
+export { defineSoftware } from "./packages.js";
+export { isAcpTimeoutErrorData, isUnknownSessionErrorData, } from "./json-rpc.js";
+export { createInMemoryFileSystem, KernelError } from "./runtime-compat.js";
+export type * from "./types.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+// @rivet-dev/agent-os
+export { AgentOs, AgentOsSidecar } from "./agent-os.js";
+export { AGENT_CONFIGS } from "./agents.js";
+export { CronManager, InvalidScheduleError, PastScheduleError, TimerScheduleDriver, } from "./cron/index.js";
+export { createHostDirBackend, nodeModulesMount } from "./host-dir-mount.js";
+export { hostTool, MAX_TOOL_DESCRIPTION_LENGTH, toolKit, validateToolkits, } from "./host-tools.js";
+export { createInMemoryLayerStore, createSnapshotExport, } from "./layers.js";
+export { defineSoftware } from "./packages.js";
+export { isAcpTimeoutErrorData, isUnknownSessionErrorData, } from "./json-rpc.js";
+export { createInMemoryFileSystem, KernelError } from "./runtime-compat.js";