@byokit/openclaw 0.3.6 → 0.5.0

package/dist/output.js

@@ -0,0 +1,166 @@
+const record = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const own = (v, k) => Object.hasOwn(v, k);
+const types = new Set(['null', 'boolean', 'number', 'integer', 'string', 'array', 'object']);
+const bounds = ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum'];
+const counts = ['minLength', 'maxLength', 'minItems', 'maxItems', 'minProperties', 'maxProperties'];
+const annotations = ['title', 'description', 'default', 'examples', '$schema'];
+const keywords = new Set(['type', 'properties', 'required', 'additionalProperties', 'items', 'enum', 'const',
+    'anyOf', 'oneOf', 'allOf', 'not', 'uniqueItems', ...bounds, ...counts, ...annotations]);
+function invalid() { throw new Error('refused: invalid or unsupported output schema'); }
+function checkSchema(s, depth = 0) {
+    if (depth > 32)
+        invalid();
+    if (typeof s === 'boolean')
+        return;
+    if (!record(s) || Object.keys(s).some((k) => !keywords.has(k)))
+        invalid();
+    if (own(s, 'type')) {
+        const ts = Array.isArray(s.type) ? s.type : [s.type];
+        if (!ts.length || ts.some((t) => !types.has(t)) || new Set(ts).size !== ts.length)
+            invalid();
+    }
+    for (const k of bounds)
+        if (own(s, k) && (typeof s[k] !== 'number' || !Number.isFinite(s[k])))
+            invalid();
+    for (const k of counts)
+        if (own(s, k) && (typeof s[k] !== 'number' || !Number.isSafeInteger(s[k]) || s[k] < 0))
+            invalid();
+    for (const k of ['title', 'description'])
+        if (own(s, k) && typeof s[k] !== 'string')
+            invalid();
+    if (own(s, '$schema') && s.$schema !== 'http://json-schema.org/draft-07/schema#')
+        invalid();
+    if (own(s, 'examples') && !Array.isArray(s.examples))
+        invalid();
+    if (own(s, 'enum') && (!Array.isArray(s.enum) || !s.enum.length))
+        invalid();
+    if (own(s, 'uniqueItems') && typeof s.uniqueItems !== 'boolean')
+        invalid();
+    if (own(s, 'required') && (!Array.isArray(s.required) || s.required.some((k) => typeof k !== 'string')
+        || new Set(s.required).size !== s.required.length))
+        invalid();
+    if (own(s, 'properties')) {
+        if (!record(s.properties))
+            invalid();
+        for (const sub of Object.values(s.properties))
+            checkSchema(sub, depth + 1);
+    }
+    for (const k of ['items', 'additionalProperties', 'not'])
+        if (own(s, k))
+            checkSchema(s[k], depth + 1);
+    for (const k of ['anyOf', 'oneOf', 'allOf'])
+        if (own(s, k)) {
+            if (!Array.isArray(s[k]) || !s[k].length)
+                invalid();
+            for (const sub of s[k])
+                checkSchema(sub, depth + 1);
+        }
+}
+// Equality is structural: JSON objects have no key order, including enum/const values and unique array items.
+function equal(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((v, i) => equal(v, b[i]));
+    if (record(a) && record(b))
+        return Object.keys(a).length === Object.keys(b).length
+            && Object.keys(a).every((k) => own(b, k) && equal(a[k], b[k]));
+    return false;
+}
+function hasType(v, t) {
+    if (t === 'null')
+        return v === null;
+    if (t === 'array')
+        return Array.isArray(v);
+    if (t === 'object')
+        return record(v);
+    if (t === 'integer')
+        return typeof v === 'number' && Number.isInteger(v);
+    return typeof v === t && (t !== 'number' || Number.isFinite(v));
+}
+function matches(s, v) {
+    if (typeof s === 'boolean')
+        return s;
+    if (s.type !== undefined && !(Array.isArray(s.type) ? s.type : [s.type]).some((t) => hasType(v, t)))
+        return false;
+    if (own(s, 'const') && !equal(s.const, v))
+        return false;
+    if (s.enum && !s.enum.some((e) => equal(e, v)))
+        return false;
+    if (s.allOf && !s.allOf.every((sub) => matches(sub, v)))
+        return false;
+    if (s.anyOf && !s.anyOf.some((sub) => matches(sub, v)))
+        return false;
+    if (s.oneOf && s.oneOf.filter((sub) => matches(sub, v)).length !== 1)
+        return false;
+    if (s.not !== undefined && matches(s.not, v))
+        return false;
+    if (typeof v === 'number') {
+        if (!Number.isFinite(v) || (s.minimum !== undefined && v < s.minimum) || (s.maximum !== undefined && v > s.maximum)
+            || (s.exclusiveMinimum !== undefined && v <= s.exclusiveMinimum) || (s.exclusiveMaximum !== undefined && v >= s.exclusiveMaximum))
+            return false;
+    }
+    if (typeof v === 'string') {
+        const length = [...v].length;
+        if ((s.minLength !== undefined && length < s.minLength) || (s.maxLength !== undefined && length > s.maxLength))
+            return false;
+    }
+    if (Array.isArray(v)) {
+        if ((s.minItems !== undefined && v.length < s.minItems) || (s.maxItems !== undefined && v.length > s.maxItems))
+            return false;
+        if (s.items !== undefined && !v.every((item) => matches(s.items, item)))
+            return false;
+        if (s.uniqueItems && v.some((item, i) => v.slice(0, i).some((other) => equal(item, other))))
+            return false;
+    }
+    if (record(v)) {
+        const keys = Object.keys(v);
+        if ((s.minProperties !== undefined && keys.length < s.minProperties) || (s.maxProperties !== undefined && keys.length > s.maxProperties))
+            return false;
+        if (s.required?.some((k) => !own(v, k)))
+            return false;
+        for (const k of keys) {
+            const sub = s.properties && own(s.properties, k) ? s.properties[k] : s.additionalProperties;
+            if (sub !== undefined && !matches(sub, v[k]))
+                return false;
+        }
+    }
+    return true;
+}
+/** Snapshot a JSON-only schema before any await; no mutation can change the prompt or its validation. */
+export function outputSchema(value) {
+    let json;
+    try {
+        json = JSON.stringify(value, (_key, v) => {
+            if (v === undefined || typeof v === 'function' || typeof v === 'symbol' || typeof v === 'bigint'
+                || (typeof v === 'number' && !Number.isFinite(v)))
+                invalid();
+            return v;
+        });
+    }
+    catch {
+        invalid();
+    }
+    if (!json || json.length > 65_536 || new TextEncoder().encode(json).length > 65_536)
+        invalid();
+    const schema = JSON.parse(json);
+    if (!record(schema))
+        invalid(); // the public run contract requires an object at its root
+    checkSchema(schema);
+    return {
+        prompt: `Return only one JSON value matching this JSON Schema, with no markdown or surrounding text.\n${json}`,
+        parse: (text) => {
+            try {
+                const data = JSON.parse(text, (_key, value) => {
+                    if (typeof value === 'number' && !Number.isFinite(value))
+                        throw new Error('invalid number');
+                    return value;
+                });
+                return matches(schema, data) ? { data } : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        },
+    };
+}