@naylence/agent-sdk 0.3.15 → 0.3.16

package/dist/browser/index.js

@@ -5,12 +5,12 @@
 })(this, (function (exports, runtime, factory, core, node) { 'use strict';
 
     // This file is auto-generated during build - do not edit manually
-    // Generated from package.json version: 0.3.15
+    // Generated from package.json version: 0.3.16
     /**
      * The package version, injected at build time.
      * @internal
      */
-    const VERSION = '0.3.15';
+    const VERSION = '0.3.16';
 
     /**
      * AUTO-GENERATED FILE. DO NOT EDIT DIRECTLY.
@@ -1289,8 +1289,8 @@
 
     const version = {
         major: 4,
-        minor: 1,
-        patch: 13,
+        minor: 2,
+        patch: 1,
     };
 
     const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
@@ -1360,16 +1360,6 @@
                 }
                 return payload;
             };
-            // const handleChecksResult = (
-            //   checkResult: ParsePayload,
-            //   originalResult: ParsePayload,
-            //   ctx: ParseContextInternal
-            // ): util.MaybeAsync<ParsePayload> => {
-            //   // if the checks mutated the value && there are no issues, re-parse the result
-            //   if (checkResult.value !== originalResult.value && !checkResult.issues.length)
-            //     return inst._zod.parse(checkResult, ctx);
-            //   return originalResult;
-            // };
             const handleCanaryResult = (canary, payload, ctx) => {
                 // abort if the canary is aborted
                 if (aborted(canary)) {
@@ -2153,6 +2143,7 @@
     const $ZodDiscriminatedUnion = 
     /*@__PURE__*/
     $constructor("$ZodDiscriminatedUnion", (inst, def) => {
+        def.inclusive = false;
         $ZodUnion.init(inst, def);
         const _super = inst._zod.parse;
         defineLazy(inst._zod, "propValues", () => {
@@ -2359,15 +2350,21 @@
                         throw new Error("Async schemas not supported in object keys currently");
                     }
                     if (keyResult.issues.length) {
-                        payload.issues.push({
-                            code: "invalid_key",
-                            origin: "record",
-                            issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-                            input: key,
-                            path: [key],
-                            inst,
-                        });
-                        payload.value[keyResult.value] = keyResult.value;
+                        if (def.mode === "loose") {
+                            // Pass through unchanged
+                            payload.value[key] = input[key];
+                        }
+                        else {
+                            // Default "strict" behavior: error on invalid key
+                            payload.issues.push({
+                                code: "invalid_key",
+                                origin: "record",
+                                issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+                                input: key,
+                                path: [key],
+                                inst,
+                            });
+                        }
                         continue;
                     }
                     const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
@@ -3227,6 +3224,723 @@
         return ch;
     }
 
+    // function initializeContext<T extends schemas.$ZodType>(inputs: JSONSchemaGeneratorParams<T>): ToJSONSchemaContext<T> {
+    //   return {
+    //     processor: inputs.processor,
+    //     metadataRegistry: inputs.metadata ?? globalRegistry,
+    //     target: inputs.target ?? "draft-2020-12",
+    //     unrepresentable: inputs.unrepresentable ?? "throw",
+    //   };
+    // }
+    function initializeContext(params) {
+        // Normalize target: convert old non-hyphenated versions to hyphenated versions
+        let target = params?.target ?? "draft-2020-12";
+        if (target === "draft-4")
+            target = "draft-04";
+        if (target === "draft-7")
+            target = "draft-07";
+        return {
+            processors: params.processors ?? {},
+            metadataRegistry: params?.metadata ?? globalRegistry,
+            target,
+            unrepresentable: params?.unrepresentable ?? "throw",
+            override: params?.override ?? (() => { }),
+            io: params?.io ?? "output",
+            counter: 0,
+            seen: new Map(),
+            cycles: params?.cycles ?? "ref",
+            reused: params?.reused ?? "inline",
+            external: params?.external ?? undefined,
+        };
+    }
+    function process$1(schema, ctx, _params = { path: [], schemaPath: [] }) {
+        var _a;
+        const def = schema._zod.def;
+        // check for schema in seens
+        const seen = ctx.seen.get(schema);
+        if (seen) {
+            seen.count++;
+            // check if cycle
+            const isCycle = _params.schemaPath.includes(schema);
+            if (isCycle) {
+                seen.cycle = _params.path;
+            }
+            return seen.schema;
+        }
+        // initialize
+        const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };
+        ctx.seen.set(schema, result);
+        // custom method overrides default behavior
+        const overrideSchema = schema._zod.toJSONSchema?.();
+        if (overrideSchema) {
+            result.schema = overrideSchema;
+        }
+        else {
+            const params = {
+                ..._params,
+                schemaPath: [..._params.schemaPath, schema],
+                path: _params.path,
+            };
+            const parent = schema._zod.parent;
+            if (parent) {
+                // schema was cloned from another schema
+                result.ref = parent;
+                process$1(parent, ctx, params);
+                ctx.seen.get(parent).isParent = true;
+            }
+            else if (schema._zod.processJSONSchema) {
+                schema._zod.processJSONSchema(ctx, result.schema, params);
+            }
+            else {
+                const _json = result.schema;
+                const processor = ctx.processors[def.type];
+                if (!processor) {
+                    throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
+                }
+                processor(schema, ctx, _json, params);
+            }
+        }
+        // metadata
+        const meta = ctx.metadataRegistry.get(schema);
+        if (meta)
+            Object.assign(result.schema, meta);
+        if (ctx.io === "input" && isTransforming(schema)) {
+            // examples/defaults only apply to output type of pipe
+            delete result.schema.examples;
+            delete result.schema.default;
+        }
+        // set prefault as default
+        if (ctx.io === "input" && result.schema._prefault)
+            (_a = result.schema).default ?? (_a.default = result.schema._prefault);
+        delete result.schema._prefault;
+        // pulling fresh from ctx.seen in case it was overwritten
+        const _result = ctx.seen.get(schema);
+        return _result.schema;
+    }
+    function extractDefs(ctx, schema
+    // params: EmitParams
+    ) {
+        // iterate over seen map;
+        const root = ctx.seen.get(schema);
+        if (!root)
+            throw new Error("Unprocessed schema. This is a bug in Zod.");
+        // returns a ref to the schema
+        // defId will be empty if the ref points to an external schema (or #)
+        const makeURI = (entry) => {
+            // comparing the seen objects because sometimes
+            // multiple schemas map to the same seen object.
+            // e.g. lazy
+            // external is configured
+            const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
+            if (ctx.external) {
+                const externalId = ctx.external.registry.get(entry[0])?.id; // ?? "__shared";// `__schema${ctx.counter++}`;
+                // check if schema is in the external registry
+                const uriGenerator = ctx.external.uri ?? ((id) => id);
+                if (externalId) {
+                    return { ref: uriGenerator(externalId) };
+                }
+                // otherwise, add to __shared
+                const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
+                entry[1].defId = id; // set defId so it will be reused if needed
+                return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
+            }
+            if (entry[1] === root) {
+                return { ref: "#" };
+            }
+            // self-contained schema
+            const uriPrefix = `#`;
+            const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
+            const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
+            return { defId, ref: defUriPrefix + defId };
+        };
+        // stored cached version in `def` property
+        // remove all properties, set $ref
+        const extractToDef = (entry) => {
+            // if the schema is already a reference, do not extract it
+            if (entry[1].schema.$ref) {
+                return;
+            }
+            const seen = entry[1];
+            const { ref, defId } = makeURI(entry);
+            seen.def = { ...seen.schema };
+            // defId won't be set if the schema is a reference to an external schema
+            // or if the schema is the root schema
+            if (defId)
+                seen.defId = defId;
+            // wipe away all properties except $ref
+            const schema = seen.schema;
+            for (const key in schema) {
+                delete schema[key];
+            }
+            schema.$ref = ref;
+        };
+        // throw on cycles
+        // break cycles
+        if (ctx.cycles === "throw") {
+            for (const entry of ctx.seen.entries()) {
+                const seen = entry[1];
+                if (seen.cycle) {
+                    throw new Error("Cycle detected: " +
+                        `#/${seen.cycle?.join("/")}/<root>` +
+                        '\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
+                }
+            }
+        }
+        // extract schemas into $defs
+        for (const entry of ctx.seen.entries()) {
+            const seen = entry[1];
+            // convert root schema to # $ref
+            if (schema === entry[0]) {
+                extractToDef(entry); // this has special handling for the root schema
+                continue;
+            }
+            // extract schemas that are in the external registry
+            if (ctx.external) {
+                const ext = ctx.external.registry.get(entry[0])?.id;
+                if (schema !== entry[0] && ext) {
+                    extractToDef(entry);
+                    continue;
+                }
+            }
+            // extract schemas with `id` meta
+            const id = ctx.metadataRegistry.get(entry[0])?.id;
+            if (id) {
+                extractToDef(entry);
+                continue;
+            }
+            // break cycles
+            if (seen.cycle) {
+                // any
+                extractToDef(entry);
+                continue;
+            }
+            // extract reused schemas
+            if (seen.count > 1) {
+                if (ctx.reused === "ref") {
+                    extractToDef(entry);
+                    // biome-ignore lint:
+                    continue;
+                }
+            }
+        }
+    }
+    function finalize(ctx, schema) {
+        //
+        // iterate over seen map;
+        const root = ctx.seen.get(schema);
+        if (!root)
+            throw new Error("Unprocessed schema. This is a bug in Zod.");
+        // flatten _refs
+        const flattenRef = (zodSchema) => {
+            const seen = ctx.seen.get(zodSchema);
+            const schema = seen.def ?? seen.schema;
+            const _cached = { ...schema };
+            // already seen
+            if (seen.ref === null) {
+                return;
+            }
+            // flatten ref if defined
+            const ref = seen.ref;
+            seen.ref = null; // prevent recursion
+            if (ref) {
+                flattenRef(ref);
+                // merge referenced schema into current
+                const refSchema = ctx.seen.get(ref).schema;
+                if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+                    schema.allOf = schema.allOf ?? [];
+                    schema.allOf.push(refSchema);
+                }
+                else {
+                    Object.assign(schema, refSchema);
+                    Object.assign(schema, _cached); // prevent overwriting any fields in the original schema
+                }
+            }
+            // execute overrides
+            if (!seen.isParent)
+                ctx.override({
+                    zodSchema: zodSchema,
+                    jsonSchema: schema,
+                    path: seen.path ?? [],
+                });
+        };
+        for (const entry of [...ctx.seen.entries()].reverse()) {
+            flattenRef(entry[0]);
+        }
+        const result = {};
+        if (ctx.target === "draft-2020-12") {
+            result.$schema = "https://json-schema.org/draft/2020-12/schema";
+        }
+        else if (ctx.target === "draft-07") {
+            result.$schema = "http://json-schema.org/draft-07/schema#";
+        }
+        else if (ctx.target === "draft-04") {
+            result.$schema = "http://json-schema.org/draft-04/schema#";
+        }
+        else if (ctx.target === "openapi-3.0") ;
+        else ;
+        if (ctx.external?.uri) {
+            const id = ctx.external.registry.get(schema)?.id;
+            if (!id)
+                throw new Error("Schema is missing an `id` property");
+            result.$id = ctx.external.uri(id);
+        }
+        Object.assign(result, root.def ?? root.schema);
+        // build defs object
+        const defs = ctx.external?.defs ?? {};
+        for (const entry of ctx.seen.entries()) {
+            const seen = entry[1];
+            if (seen.def && seen.defId) {
+                defs[seen.defId] = seen.def;
+            }
+        }
+        // set definitions in result
+        if (ctx.external) ;
+        else {
+            if (Object.keys(defs).length > 0) {
+                if (ctx.target === "draft-2020-12") {
+                    result.$defs = defs;
+                }
+                else {
+                    result.definitions = defs;
+                }
+            }
+        }
+        try {
+            // this "finalizes" this schema and ensures all cycles are removed
+            // each call to finalize() is functionally independent
+            // though the seen map is shared
+            const finalized = JSON.parse(JSON.stringify(result));
+            Object.defineProperty(finalized, "~standard", {
+                value: {
+                    ...schema["~standard"],
+                    jsonSchema: {
+                        input: createStandardJSONSchemaMethod(schema, "input"),
+                        output: createStandardJSONSchemaMethod(schema, "output"),
+                    },
+                },
+                enumerable: false,
+                writable: false,
+            });
+            return finalized;
+        }
+        catch (_err) {
+            throw new Error("Error converting schema to JSON.");
+        }
+    }
+    function isTransforming(_schema, _ctx) {
+        const ctx = _ctx ?? { seen: new Set() };
+        if (ctx.seen.has(_schema))
+            return false;
+        ctx.seen.add(_schema);
+        const def = _schema._zod.def;
+        if (def.type === "transform")
+            return true;
+        if (def.type === "array")
+            return isTransforming(def.element, ctx);
+        if (def.type === "set")
+            return isTransforming(def.valueType, ctx);
+        if (def.type === "lazy")
+            return isTransforming(def.getter(), ctx);
+        if (def.type === "promise" ||
+            def.type === "optional" ||
+            def.type === "nonoptional" ||
+            def.type === "nullable" ||
+            def.type === "readonly" ||
+            def.type === "default" ||
+            def.type === "prefault") {
+            return isTransforming(def.innerType, ctx);
+        }
+        if (def.type === "intersection") {
+            return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+        }
+        if (def.type === "record" || def.type === "map") {
+            return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+        }
+        if (def.type === "pipe") {
+            return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+        }
+        if (def.type === "object") {
+            for (const key in def.shape) {
+                if (isTransforming(def.shape[key], ctx))
+                    return true;
+            }
+            return false;
+        }
+        if (def.type === "union") {
+            for (const option of def.options) {
+                if (isTransforming(option, ctx))
+                    return true;
+            }
+            return false;
+        }
+        if (def.type === "tuple") {
+            for (const item of def.items) {
+                if (isTransforming(item, ctx))
+                    return true;
+            }
+            if (def.rest && isTransforming(def.rest, ctx))
+                return true;
+            return false;
+        }
+        return false;
+    }
+    /**
+     * Creates a toJSONSchema method for a schema instance.
+     * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
+     */
+    const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
+        const ctx = initializeContext({ ...params, processors });
+        process$1(schema, ctx);
+        extractDefs(ctx, schema);
+        return finalize(ctx, schema);
+    };
+    const createStandardJSONSchemaMethod = (schema, io) => (params) => {
+        const { libraryOptions, target } = params ?? {};
+        const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors: {} });
+        process$1(schema, ctx);
+        extractDefs(ctx, schema);
+        return finalize(ctx, schema);
+    };
+
+    const formatMap = {
+        guid: "uuid",
+        url: "uri",
+        datetime: "date-time",
+        json_string: "json-string",
+        regex: "", // do not set
+    };
+    // ==================== SIMPLE TYPE PROCESSORS ====================
+    const stringProcessor = (schema, ctx, _json, _params) => {
+        const json = _json;
+        json.type = "string";
+        const { minimum, maximum, format, patterns, contentEncoding } = schema._zod
+            .bag;
+        if (typeof minimum === "number")
+            json.minLength = minimum;
+        if (typeof maximum === "number")
+            json.maxLength = maximum;
+        // custom pattern overrides format
+        if (format) {
+            json.format = formatMap[format] ?? format;
+            if (json.format === "")
+                delete json.format; // empty format is not valid
+        }
+        if (contentEncoding)
+            json.contentEncoding = contentEncoding;
+        if (patterns && patterns.size > 0) {
+            const regexes = [...patterns];
+            if (regexes.length === 1)
+                json.pattern = regexes[0].source;
+            else if (regexes.length > 1) {
+                json.allOf = [
+                    ...regexes.map((regex) => ({
+                        ...(ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0"
+                            ? { type: "string" }
+                            : {}),
+                        pattern: regex.source,
+                    })),
+                ];
+            }
+        }
+    };
+    const numberProcessor = (schema, ctx, _json, _params) => {
+        const json = _json;
+        const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+        if (typeof format === "string" && format.includes("int"))
+            json.type = "integer";
+        else
+            json.type = "number";
+        if (typeof exclusiveMinimum === "number") {
+            if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+                json.minimum = exclusiveMinimum;
+                json.exclusiveMinimum = true;
+            }
+            else {
+                json.exclusiveMinimum = exclusiveMinimum;
+            }
+        }
+        if (typeof minimum === "number") {
+            json.minimum = minimum;
+            if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
+                if (exclusiveMinimum >= minimum)
+                    delete json.minimum;
+                else
+                    delete json.exclusiveMinimum;
+            }
+        }
+        if (typeof exclusiveMaximum === "number") {
+            if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+                json.maximum = exclusiveMaximum;
+                json.exclusiveMaximum = true;
+            }
+            else {
+                json.exclusiveMaximum = exclusiveMaximum;
+            }
+        }
+        if (typeof maximum === "number") {
+            json.maximum = maximum;
+            if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
+                if (exclusiveMaximum <= maximum)
+                    delete json.maximum;
+                else
+                    delete json.exclusiveMaximum;
+            }
+        }
+        if (typeof multipleOf === "number")
+            json.multipleOf = multipleOf;
+    };
+    const booleanProcessor = (_schema, _ctx, json, _params) => {
+        json.type = "boolean";
+    };
+    const neverProcessor = (_schema, _ctx, json, _params) => {
+        json.not = {};
+    };
+    const anyProcessor = (_schema, _ctx, _json, _params) => {
+        // empty schema accepts anything
+    };
+    const unknownProcessor = (_schema, _ctx, _json, _params) => {
+        // empty schema accepts anything
+    };
+    const dateProcessor = (_schema, ctx, _json, _params) => {
+        if (ctx.unrepresentable === "throw") {
+            throw new Error("Date cannot be represented in JSON Schema");
+        }
+    };
+    const enumProcessor = (schema, _ctx, json, _params) => {
+        const def = schema._zod.def;
+        const values = getEnumValues(def.entries);
+        // Number enums can have both string and number values
+        if (values.every((v) => typeof v === "number"))
+            json.type = "number";
+        if (values.every((v) => typeof v === "string"))
+            json.type = "string";
+        json.enum = values;
+    };
+    const literalProcessor = (schema, ctx, json, _params) => {
+        const def = schema._zod.def;
+        const vals = [];
+        for (const val of def.values) {
+            if (val === undefined) {
+                if (ctx.unrepresentable === "throw") {
+                    throw new Error("Literal `undefined` cannot be represented in JSON Schema");
+                }
+            }
+            else if (typeof val === "bigint") {
+                if (ctx.unrepresentable === "throw") {
+                    throw new Error("BigInt literals cannot be represented in JSON Schema");
+                }
+                else {
+                    vals.push(Number(val));
+                }
+            }
+            else {
+                vals.push(val);
+            }
+        }
+        if (vals.length === 0) ;
+        else if (vals.length === 1) {
+            const val = vals[0];
+            json.type = val === null ? "null" : typeof val;
+            if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+                json.enum = [val];
+            }
+            else {
+                json.const = val;
+            }
+        }
+        else {
+            if (vals.every((v) => typeof v === "number"))
+                json.type = "number";
+            if (vals.every((v) => typeof v === "string"))
+                json.type = "string";
+            if (vals.every((v) => typeof v === "boolean"))
+                json.type = "boolean";
+            if (vals.every((v) => v === null))
+                json.type = "null";
+            json.enum = vals;
+        }
+    };
+    const customProcessor = (_schema, ctx, _json, _params) => {
+        if (ctx.unrepresentable === "throw") {
+            throw new Error("Custom types cannot be represented in JSON Schema");
+        }
+    };
+    const transformProcessor = (_schema, ctx, _json, _params) => {
+        if (ctx.unrepresentable === "throw") {
+            throw new Error("Transforms cannot be represented in JSON Schema");
+        }
+    };
+    // ==================== COMPOSITE TYPE PROCESSORS ====================
+    const arrayProcessor = (schema, ctx, _json, params) => {
+        const json = _json;
+        const def = schema._zod.def;
+        const { minimum, maximum } = schema._zod.bag;
+        if (typeof minimum === "number")
+            json.minItems = minimum;
+        if (typeof maximum === "number")
+            json.maxItems = maximum;
+        json.type = "array";
+        json.items = process$1(def.element, ctx, { ...params, path: [...params.path, "items"] });
+    };
+    const objectProcessor = (schema, ctx, _json, params) => {
+        const json = _json;
+        const def = schema._zod.def;
+        json.type = "object";
+        json.properties = {};
+        const shape = def.shape;
+        for (const key in shape) {
+            json.properties[key] = process$1(shape[key], ctx, {
+                ...params,
+                path: [...params.path, "properties", key],
+            });
+        }
+        // required keys
+        const allKeys = new Set(Object.keys(shape));
+        const requiredKeys = new Set([...allKeys].filter((key) => {
+            const v = def.shape[key]._zod;
+            if (ctx.io === "input") {
+                return v.optin === undefined;
+            }
+            else {
+                return v.optout === undefined;
+            }
+        }));
+        if (requiredKeys.size > 0) {
+            json.required = Array.from(requiredKeys);
+        }
+        // catchall
+        if (def.catchall?._zod.def.type === "never") {
+            // strict
+            json.additionalProperties = false;
+        }
+        else if (!def.catchall) {
+            // regular
+            if (ctx.io === "output")
+                json.additionalProperties = false;
+        }
+        else if (def.catchall) {
+            json.additionalProperties = process$1(def.catchall, ctx, {
+                ...params,
+                path: [...params.path, "additionalProperties"],
+            });
+        }
+    };
+    const unionProcessor = (schema, ctx, json, params) => {
+        const def = schema._zod.def;
+        // Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches)
+        // This includes both z.xor() and discriminated unions
+        const isExclusive = def.inclusive === false;
+        const options = def.options.map((x, i) => process$1(x, ctx, {
+            ...params,
+            path: [...params.path, isExclusive ? "oneOf" : "anyOf", i],
+        }));
+        if (isExclusive) {
+            json.oneOf = options;
+        }
+        else {
+            json.anyOf = options;
+        }
+    };
+    const intersectionProcessor = (schema, ctx, json, params) => {
+        const def = schema._zod.def;
+        const a = process$1(def.left, ctx, {
+            ...params,
+            path: [...params.path, "allOf", 0],
+        });
+        const b = process$1(def.right, ctx, {
+            ...params,
+            path: [...params.path, "allOf", 1],
+        });
+        const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
+        const allOf = [
+            ...(isSimpleIntersection(a) ? a.allOf : [a]),
+            ...(isSimpleIntersection(b) ? b.allOf : [b]),
+        ];
+        json.allOf = allOf;
+    };
+    const recordProcessor = (schema, ctx, _json, params) => {
+        const json = _json;
+        const def = schema._zod.def;
+        json.type = "object";
+        if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
+            json.propertyNames = process$1(def.keyType, ctx, {
+                ...params,
+                path: [...params.path, "propertyNames"],
+            });
+        }
+        json.additionalProperties = process$1(def.valueType, ctx, {
+            ...params,
+            path: [...params.path, "additionalProperties"],
+        });
+    };
+    const nullableProcessor = (schema, ctx, json, params) => {
+        const def = schema._zod.def;
+        const inner = process$1(def.innerType, ctx, params);
+        const seen = ctx.seen.get(schema);
+        if (ctx.target === "openapi-3.0") {
+            seen.ref = def.innerType;
+            json.nullable = true;
+        }
+        else {
+            json.anyOf = [inner, { type: "null" }];
+        }
+    };
+    const nonoptionalProcessor = (schema, ctx, _json, params) => {
+        const def = schema._zod.def;
+        process$1(def.innerType, ctx, params);
+        const seen = ctx.seen.get(schema);
+        seen.ref = def.innerType;
+    };
+    const defaultProcessor = (schema, ctx, json, params) => {
+        const def = schema._zod.def;
+        process$1(def.innerType, ctx, params);
+        const seen = ctx.seen.get(schema);
+        seen.ref = def.innerType;
+        json.default = JSON.parse(JSON.stringify(def.defaultValue));
+    };
+    const prefaultProcessor = (schema, ctx, json, params) => {
+        const def = schema._zod.def;
+        process$1(def.innerType, ctx, params);
+        const seen = ctx.seen.get(schema);
+        seen.ref = def.innerType;
+        if (ctx.io === "input")
+            json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
+    };
+    const catchProcessor = (schema, ctx, json, params) => {
+        const def = schema._zod.def;
+        process$1(def.innerType, ctx, params);
+        const seen = ctx.seen.get(schema);
+        seen.ref = def.innerType;
+        let catchValue;
+        try {
+            catchValue = def.catchValue(undefined);
+        }
+        catch {
+            throw new Error("Dynamic catch values are not supported in JSON Schema");
+        }
+        json.default = catchValue;
+    };
+    const pipeProcessor = (schema, ctx, _json, params) => {
+        const def = schema._zod.def;
+        const innerType = ctx.io === "input" ? (def.in._zod.def.type === "transform" ? def.out : def.in) : def.out;
+        process$1(innerType, ctx, params);
+        const seen = ctx.seen.get(schema);
+        seen.ref = innerType;
+    };
+    const readonlyProcessor = (schema, ctx, json, params) => {
+        const def = schema._zod.def;
+        process$1(def.innerType, ctx, params);
+        const seen = ctx.seen.get(schema);
+        seen.ref = def.innerType;
+        json.readOnly = true;
+    };
+    const optionalProcessor = (schema, ctx, _json, params) => {
+        const def = schema._zod.def;
+        process$1(def.innerType, ctx, params);
+        const seen = ctx.seen.get(schema);
+        seen.ref = def.innerType;
+    };
+
     const ZodISODateTime = /*@__PURE__*/ $constructor("ZodISODateTime", (inst, def) => {
         $ZodISODateTime.init(inst, def);
         ZodStringFormat.init(inst, def);
@@ -3318,6 +4032,13 @@
 
     const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
         $ZodType.init(inst, def);
+        Object.assign(inst["~standard"], {
+            jsonSchema: {
+                input: createStandardJSONSchemaMethod(inst, "input"),
+                output: createStandardJSONSchemaMethod(inst, "output"),
+            },
+        });
+        inst.toJSONSchema = createToJSONSchemaMethod(inst, {});
         inst.def = def;
         inst.type = def.type;
         Object.defineProperty(inst, "_def", { value: def });
@@ -3399,6 +4120,7 @@
     const _ZodString = /*@__PURE__*/ $constructor("_ZodString", (inst, def) => {
         $ZodString.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json);
         const bag = inst._zod.bag;
         inst.format = bag.format ?? null;
         inst.minLength = bag.minimum ?? null;
@@ -3556,6 +4278,7 @@
     const ZodNumber = /*@__PURE__*/ $constructor("ZodNumber", (inst, def) => {
         $ZodNumber.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json);
         inst.gt = (value, params) => inst.check(_gt(value, params));
         inst.gte = (value, params) => inst.check(_gte(value, params));
         inst.min = (value, params) => inst.check(_gte(value, params));
@@ -3594,6 +4317,7 @@
     const ZodBoolean = /*@__PURE__*/ $constructor("ZodBoolean", (inst, def) => {
         $ZodBoolean.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json);
     });
     function boolean(params) {
         return _boolean(ZodBoolean, params);
@@ -3601,6 +4325,7 @@
     const ZodAny = /*@__PURE__*/ $constructor("ZodAny", (inst, def) => {
         $ZodAny.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => anyProcessor();
     });
     function any() {
         return _any(ZodAny);
@@ -3608,6 +4333,7 @@
     const ZodUnknown = /*@__PURE__*/ $constructor("ZodUnknown", (inst, def) => {
         $ZodUnknown.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor();
     });
     function unknown() {
         return _unknown(ZodUnknown);
@@ -3615,6 +4341,7 @@
     const ZodNever = /*@__PURE__*/ $constructor("ZodNever", (inst, def) => {
         $ZodNever.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json);
     });
     function never(params) {
         return _never(ZodNever, params);
@@ -3622,6 +4349,7 @@
     const ZodDate = /*@__PURE__*/ $constructor("ZodDate", (inst, def) => {
         $ZodDate.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => dateProcessor(inst, ctx);
         inst.min = (value, params) => inst.check(_gte(value, params));
         inst.max = (value, params) => inst.check(_lte(value, params));
         const c = inst._zod.bag;
@@ -3634,6 +4362,7 @@
     const ZodArray = /*@__PURE__*/ $constructor("ZodArray", (inst, def) => {
         $ZodArray.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);
         inst.element = def.element;
         inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
         inst.nonempty = (params) => inst.check(_minLength(1, params));
@@ -3647,6 +4376,7 @@
     const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
         $ZodObjectJIT.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
         defineLazy(inst, "shape", () => {
             return def.shape;
         });
@@ -3679,6 +4409,7 @@
     const ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def) => {
         $ZodUnion.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
         inst.options = def.options;
     });
     function union(options, params) {
@@ -3704,6 +4435,7 @@
     const ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def) => {
         $ZodIntersection.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);
     });
     function intersection(left, right) {
         return new ZodIntersection({
@@ -3715,6 +4447,7 @@
     const ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
         $ZodRecord.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
         inst.keyType = def.keyType;
         inst.valueType = def.valueType;
     });
@@ -3729,6 +4462,7 @@
     const ZodEnum = /*@__PURE__*/ $constructor("ZodEnum", (inst, def) => {
         $ZodEnum.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json);
         inst.enum = def.entries;
         inst.options = Object.values(def.entries);
         const keys = new Set(Object.keys(def.entries));
@@ -3790,6 +4524,7 @@
     const ZodLiteral = /*@__PURE__*/ $constructor("ZodLiteral", (inst, def) => {
         $ZodLiteral.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => literalProcessor(inst, ctx, json);
         inst.values = new Set(def.values);
         Object.defineProperty(inst, "value", {
             get() {
@@ -3810,6 +4545,7 @@
     const ZodTransform = /*@__PURE__*/ $constructor("ZodTransform", (inst, def) => {
         $ZodTransform.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx);
         inst._zod.parse = (payload, _ctx) => {
             if (_ctx.direction === "backward") {
                 throw new $ZodEncodeError(inst.constructor.name);
@@ -3850,6 +4586,7 @@
     const ZodOptional = /*@__PURE__*/ $constructor("ZodOptional", (inst, def) => {
         $ZodOptional.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
         inst.unwrap = () => inst._zod.def.innerType;
     });
     function optional(innerType) {
@@ -3861,6 +4598,7 @@
     const ZodNullable = /*@__PURE__*/ $constructor("ZodNullable", (inst, def) => {
         $ZodNullable.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);
         inst.unwrap = () => inst._zod.def.innerType;
     });
     function nullable(innerType) {
@@ -3872,6 +4610,7 @@
     const ZodDefault = /*@__PURE__*/ $constructor("ZodDefault", (inst, def) => {
         $ZodDefault.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);
         inst.unwrap = () => inst._zod.def.innerType;
         inst.removeDefault = inst.unwrap;
     });
@@ -3887,6 +4626,7 @@
     const ZodPrefault = /*@__PURE__*/ $constructor("ZodPrefault", (inst, def) => {
         $ZodPrefault.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);
         inst.unwrap = () => inst._zod.def.innerType;
     });
     function prefault(innerType, defaultValue) {
@@ -3901,6 +4641,7 @@
     const ZodNonOptional = /*@__PURE__*/ $constructor("ZodNonOptional", (inst, def) => {
         $ZodNonOptional.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
         inst.unwrap = () => inst._zod.def.innerType;
     });
     function nonoptional(innerType, params) {
@@ -3913,6 +4654,7 @@
     const ZodCatch = /*@__PURE__*/ $constructor("ZodCatch", (inst, def) => {
         $ZodCatch.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
         inst.unwrap = () => inst._zod.def.innerType;
         inst.removeCatch = inst.unwrap;
     });
@@ -3926,6 +4668,7 @@
     const ZodPipe = /*@__PURE__*/ $constructor("ZodPipe", (inst, def) => {
         $ZodPipe.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
         inst.in = def.in;
         inst.out = def.out;
     });
@@ -3940,6 +4683,7 @@
     const ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def) => {
         $ZodReadonly.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
         inst.unwrap = () => inst._zod.def.innerType;
     });
     function readonly(innerType) {
@@ -3951,6 +4695,7 @@
     const ZodCustom = /*@__PURE__*/ $constructor("ZodCustom", (inst, def) => {
         $ZodCustom.init(inst, def);
         ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx);
     });
     function refine(fn, _params = {}) {
         return _refine(ZodCustom, fn, _params);
@@ -6966,10 +7711,17 @@
                 {
                     type: 'HttpListener',
                     port: SENTINEL_PORT,
+                    enabled: '${env:FAME_LISTENER_HTTP_ENABLED:true}',
                 },
                 {
                     type: 'WebSocketListener',
                     port: SENTINEL_PORT,
+                    enabled: '${env:FAME_LISTENER_WEBSOCKET_ENABLED:true}',
+                },
+                {
+                    type: 'AgentHttpGatewayListener',
+                    port: SENTINEL_PORT,
+                    enabled: '${env:FAME_LISTENER_AGENT_HTTP_GATEWAY_ENABLED:false}',
                 },
             ],
             requested_logicals: ['fame.fabric'],