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

package/dist/bindings-zod.js

@@ -1,270 +0,0 @@
-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 BindingSchemaConversionError extends Error {
-    path;
-    zodType;
-    constructor(path, zodType, details) {
-        super([
-            `Unsupported Zod schema at ${path}: ${zodType}`,
-            details ? `(${details})` : undefined,
-        ]
-            .filter(Boolean)
-            .join(" "));
-        this.name = "BindingSchemaConversionError";
-        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;
-    }
-}
-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 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 BindingSchemaConversionError(path, displayTypeName(typeName), "metadata that emits $ref/$defs is not supported");
-    }
-    if (UNSUPPORTED_TYPES.has(typeName)) {
-        throw new BindingSchemaConversionError(path, displayTypeName(typeName));
-    }
-    if (typeName === "discriminatedunion") {
-        throw new BindingSchemaConversionError(path, displayTypeName(typeName));
-    }
-    if (TRANSPARENT_WRAPPER_TYPES.has(typeName)) {
-        const inner = getInnerSchema(schema);
-        if (!inner) {
-            throw new BindingSchemaConversionError(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 BindingSchemaConversionError(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 BindingSchemaConversionError(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 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 BindingSchemaConversionError(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 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}>`);
-        }
-        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 BindingSchemaConversionError(path, displayTypeName(typeName), "literal values must be JSON primitives");
-        }
-        return;
-    }
-    if (typeName === "string" ||
-        typeName === "number" ||
-        typeName === "boolean" ||
-        typeName === "enum" ||
-        typeName === "nativeenum") {
-        return;
-    }
-    throw new BindingSchemaConversionError(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 BindingSchemaConversionError("$", 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 BindingSchemaConversionError("$", 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/bindings.d.ts

@@ -1,43 +0,0 @@
-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

@@ -1,34 +0,0 @@
-/** 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/generated/BindingLimitsConfig.d.ts

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