@benjamolina/pi-antigravity-guard 0.2.0 → 0.4.0

package/dist/tool-contract.js

@@ -0,0 +1,65 @@
+export class ToolPreflightError extends Error {
+    code;
+    declaration;
+    path;
+    constructor(code, declaration, path) {
+        super(`${code}: declaration ${declaration} at ${path}`);
+        this.code = code;
+        this.declaration = declaration;
+        this.path = path;
+    }
+}
+export function ownData(value, name, declaration, path) {
+    const object = plainObject(value, declaration, path);
+    const descriptor = Object.getOwnPropertyDescriptor(object, name);
+    if (!descriptor || !("value" in descriptor))
+        return undefined;
+    return descriptor.value;
+}
+export function plainObject(value, declaration, path) {
+    if (typeof value !== "object" || value === null || Array.isArray(value) || (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) || Object.getOwnPropertySymbols(value).length > 0)
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    for (const name of Object.getOwnPropertyNames(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, name);
+        if (!descriptor || !("value" in descriptor))
+            fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    }
+    return value;
+}
+export function denseArray(value, declaration, path) {
+    if (!Array.isArray(value) || Object.keys(value).length !== value.length)
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    return value;
+}
+export function canonicalJson(value, declaration, path, ancestors = new Set()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number") {
+        if (Number.isFinite(value))
+            return value;
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    }
+    if (typeof value !== "object")
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    if (ancestors.has(value))
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value))
+            return Object.freeze(denseArray(value, declaration, path).map((item, index) => canonicalJson(item, declaration, `${path}[${index}]`, ancestors)));
+        const object = plainObject(value, declaration, path);
+        const output = {};
+        for (const key of Object.keys(object).sort())
+            output[key] = canonicalJson(object[key], declaration, `${path}.${key}`, ancestors);
+        return Object.freeze(output);
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+export function freeze(value) {
+    return Object.freeze(value);
+}
+export function fail(code, declaration, path) {
+    throw new ToolPreflightError(code, declaration, path);
+}

package/dist/tool-schema.d.ts

@@ -0,0 +1,7 @@
+import { type JsonObject } from "./tool-contract.ts";
+export interface ToolDeclaration {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: JsonObject;
+}
+export declare function normalizeToolDeclarations(value: unknown): readonly ToolDeclaration[];

package/dist/tool-schema.js

@@ -0,0 +1,125 @@
+import { canonicalJson, denseArray, fail, freeze, ownData, plainObject } from "./tool-contract.js";
+const TYPES = new Set(["object", "array", "string", "number", "integer", "boolean"]);
+const KEYWORDS = new Set(["type", "description", "nullable", "enum", "const", "properties", "required", "items"]);
+const MAX_SCHEMA_DEPTH = 32;
+const MAX_SCHEMA_NODES = 2048;
+const MAX_SCHEMA_BYTES = 256 * 1024;
+const MAX_TOTAL_SCHEMA_BYTES = 1024 * 1024;
+export function normalizeToolDeclarations(value) {
+    const tools = denseArray(value, "tools", "$");
+    const names = new Set();
+    const declarations = tools.map((tool, index) => normalizeDeclaration(tool, index, names));
+    let totalSchemaBytes = 0;
+    for (const declaration of declarations) {
+        totalSchemaBytes += Buffer.byteLength(JSON.stringify(declaration.parameters), "utf8");
+        if (totalSchemaBytes > MAX_TOTAL_SCHEMA_BYTES)
+            fail("PI_TOOL_SCHEMA_LIMIT", declaration.name, "$");
+    }
+    return freeze(declarations);
+}
+function normalizeDeclaration(value, index, names) {
+    const path = `$[${index}]`;
+    const tool = plainObject(value, `tool-${index}`, path);
+    const name = ownData(tool, "name", `tool-${index}`, path);
+    if (typeof name !== "string" || !/^[A-Za-z_][A-Za-z0-9_.:-]{0,63}$/.test(name))
+        fail("PI_TOOL_DECLARATION_INVALID", `tool-${index}`, `${path}.name`);
+    if (names.has(name))
+        fail("PI_TOOL_DECLARATION_DUPLICATE", name, `${path}.name`);
+    names.add(name);
+    const description = ownData(tool, "description", name, path);
+    if (typeof description !== "string" || !description.trim())
+        fail("PI_TOOL_DECLARATION_INVALID", name, `${path}.description`);
+    const constrainedSampling = ownData(tool, "constrainedSampling", name, path);
+    if (constrainedSampling !== undefined && constrainedSampling !== false)
+        fail("PI_TOOL_CONSTRAINED_SAMPLING_UNSUPPORTED", name, `${path}.constrainedSampling`);
+    const parameterRoot = plainObject(ownData(tool, "parameters", name, path), name, "$");
+    if (ownData(parameterRoot, "type", name, "$") !== "object")
+        fail("PI_TOOL_SCHEMA_INVALID", name, "$.type");
+    const parameters = normalizeSchema(parameterRoot, name, "$");
+    if (Buffer.byteLength(JSON.stringify(parameters), "utf8") > MAX_SCHEMA_BYTES)
+        fail("PI_TOOL_SCHEMA_LIMIT", name, "$");
+    return freeze({ name, description, parameters });
+}
+function normalizeSchema(value, declaration, path, state = { ancestors: new Set(), nodes: 0 }, depth = 0) {
+    if (depth > MAX_SCHEMA_DEPTH || ++state.nodes > MAX_SCHEMA_NODES)
+        fail("PI_TOOL_SCHEMA_LIMIT", declaration, path);
+    if (typeof value === "object" && value !== null) {
+        if (state.ancestors.has(value))
+            fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+        state.ancestors.add(value);
+    }
+    const schema = plainObject(value, declaration, path);
+    for (const key of Object.keys(schema))
+        if (!KEYWORDS.has(key))
+            fail("PI_TOOL_SCHEMA_UNSUPPORTED", declaration, `${path}.${key}`);
+    const type = ownData(schema, "type", declaration, path);
+    if (typeof type !== "string" || !TYPES.has(type))
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.type`);
+    const output = { type };
+    const description = ownData(schema, "description", declaration, path);
+    if (description !== undefined) {
+        if (typeof description !== "string")
+            fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.description`);
+        output.description = description;
+    }
+    const nullable = ownData(schema, "nullable", declaration, path);
+    if (nullable !== undefined) {
+        if (typeof nullable !== "boolean")
+            fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.nullable`);
+        output.nullable = nullable;
+    }
+    const enumValue = ownData(schema, "enum", declaration, path);
+    const constant = ownData(schema, "const", declaration, path);
+    if (enumValue !== undefined && constant !== undefined)
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.const`);
+    if (enumValue !== undefined)
+        output.enum = normalizeEnum(enumValue, type, nullable === true, declaration, `${path}.enum`);
+    if (constant !== undefined)
+        output.enum = freeze([validateEnumValue(constant, type, nullable === true, declaration, `${path}.const`)]);
+    if (type === "object")
+        normalizeObject(schema, output, declaration, path, state, depth);
+    else if (type === "array")
+        normalizeArray(schema, output, declaration, path, state, depth);
+    else if (ownData(schema, "properties", declaration, path) !== undefined || ownData(schema, "required", declaration, path) !== undefined || ownData(schema, "items", declaration, path) !== undefined)
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    return freeze(output);
+}
+function normalizeObject(schema, output, declaration, path, state, depth) {
+    if (ownData(schema, "items", declaration, path) !== undefined)
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.items`);
+    const properties = plainObject(ownData(schema, "properties", declaration, path), declaration, `${path}.properties`);
+    const names = Object.keys(properties).sort();
+    if (!names.length)
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.properties`);
+    const normalized = {};
+    for (const name of names)
+        normalized[name] = normalizeSchema(properties[name], declaration, `${path}.properties.${name}`, state, depth + 1);
+    output.properties = freeze(normalized);
+    const required = ownData(schema, "required", declaration, path);
+    if (required !== undefined) {
+        const values = denseArray(required, declaration, `${path}.required`);
+        if (values.some((name) => typeof name !== "string" || !Object.hasOwn(properties, name)) || new Set(values).size !== values.length)
+            fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.required`);
+        output.required = freeze([...values].sort());
+    }
+}
+function normalizeArray(schema, output, declaration, path, state, depth) {
+    if (ownData(schema, "properties", declaration, path) !== undefined || ownData(schema, "required", declaration, path) !== undefined)
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    output.items = normalizeSchema(ownData(schema, "items", declaration, path), declaration, `${path}.items`, state, depth + 1);
+}
+function normalizeEnum(value, type, nullable, declaration, path) {
+    const values = denseArray(value, declaration, path);
+    if (!values.length)
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    const normalized = values.map((item, index) => validateEnumValue(item, type, nullable, declaration, `${path}[${index}]`));
+    if (new Set(normalized.map((item) => JSON.stringify(item))).size !== normalized.length)
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    return freeze(normalized);
+}
+function validateEnumValue(value, type, nullable, declaration, path) {
+    const json = canonicalJson(value, declaration, path);
+    if (typeof json === "object" || (json === null && !nullable) || (json !== null && (type === "integer" ? typeof json !== "number" || !Number.isInteger(json) : typeof json !== type)))
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    return json;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benjamolina/pi-antigravity-guard",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Pi adapter for Antigravity Guard",
   "type": "module",
   "license": "MIT",