@intent-systems/nexus 2026.1.5-3

package/dist/agents/pi-tools.schema.js

@@ -0,0 +1,358 @@
+function extractEnumValues(schema) {
+    if (!schema || typeof schema !== "object")
+        return undefined;
+    const record = schema;
+    if (Array.isArray(record.enum))
+        return record.enum;
+    if ("const" in record)
+        return [record.const];
+    const variants = Array.isArray(record.anyOf)
+        ? record.anyOf
+        : Array.isArray(record.oneOf)
+            ? record.oneOf
+            : null;
+    if (variants) {
+        const values = variants.flatMap((variant) => {
+            const extracted = extractEnumValues(variant);
+            return extracted ?? [];
+        });
+        return values.length > 0 ? values : undefined;
+    }
+    return undefined;
+}
+function mergePropertySchemas(existing, incoming) {
+    if (!existing)
+        return incoming;
+    if (!incoming)
+        return existing;
+    const existingEnum = extractEnumValues(existing);
+    const incomingEnum = extractEnumValues(incoming);
+    if (existingEnum || incomingEnum) {
+        const values = Array.from(new Set([...(existingEnum ?? []), ...(incomingEnum ?? [])]));
+        const merged = {};
+        for (const source of [existing, incoming]) {
+            if (!source || typeof source !== "object")
+                continue;
+            const record = source;
+            for (const key of ["title", "description", "default"]) {
+                if (!(key in merged) && key in record)
+                    merged[key] = record[key];
+            }
+        }
+        const types = new Set(values.map((value) => typeof value));
+        if (types.size === 1)
+            merged.type = Array.from(types)[0];
+        merged.enum = values;
+        return merged;
+    }
+    return existing;
+}
+function isNullSchema(variant) {
+    if (!variant || typeof variant !== "object" || Array.isArray(variant)) {
+        return false;
+    }
+    const record = variant;
+    if ("const" in record && record.const === null)
+        return true;
+    if (Array.isArray(record.enum) && record.enum.length === 1) {
+        return record.enum[0] === null;
+    }
+    const typeValue = record.type;
+    if (typeValue === "null")
+        return true;
+    if (Array.isArray(typeValue) && typeValue.length === 1 && typeValue[0] === "null") {
+        return true;
+    }
+    return false;
+}
+function stripNullVariants(variants) {
+    if (variants.length === 0)
+        return { variants, stripped: false };
+    const nonNull = variants.filter((variant) => !isNullSchema(variant));
+    return {
+        variants: nonNull,
+        stripped: nonNull.length !== variants.length,
+    };
+}
+function tryFlattenLiteralUnion(variants) {
+    if (variants.length === 0)
+        return null;
+    const values = [];
+    let commonType = null;
+    for (const variant of variants) {
+        if (!variant || typeof variant !== "object")
+            return null;
+        const record = variant;
+        let literalValue;
+        if ("const" in record) {
+            literalValue = record.const;
+        }
+        else if (Array.isArray(record.enum) && record.enum.length === 1) {
+            literalValue = record.enum[0];
+        }
+        else {
+            return null;
+        }
+        const variantType = typeof record.type === "string" ? record.type : null;
+        if (!variantType)
+            return null;
+        if (commonType === null)
+            commonType = variantType;
+        else if (commonType !== variantType)
+            return null;
+        values.push(literalValue);
+    }
+    if (commonType && values.length > 0) {
+        return { type: commonType, enum: values };
+    }
+    return null;
+}
+function tryFlattenTypeUnion(variants) {
+    if (variants.length === 0)
+        return null;
+    const types = new Set();
+    for (const variant of variants) {
+        if (!variant || typeof variant !== "object" || Array.isArray(variant)) {
+            return null;
+        }
+        const record = variant;
+        const typeValue = record.type;
+        if (typeof typeValue !== "string")
+            return null;
+        const keys = Object.keys(record).filter((key) => !["type", "title", "description", "default"].includes(key));
+        if (keys.length > 0)
+            return null;
+        types.add(typeValue);
+    }
+    if (types.size === 0)
+        return null;
+    const list = Array.from(types);
+    return { type: list.length === 1 ? list[0] : list };
+}
+function mergeObjectUnion(variants) {
+    const mergedProperties = {};
+    const requiredCounts = new Map();
+    let objectVariants = 0;
+    for (const entry of variants) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const record = entry;
+        const props = record.properties;
+        if (!props || typeof props !== "object" || Array.isArray(props)) {
+            return null;
+        }
+        objectVariants += 1;
+        for (const [key, value] of Object.entries(props)) {
+            if (!(key in mergedProperties)) {
+                mergedProperties[key] = value;
+                continue;
+            }
+            mergedProperties[key] = mergePropertySchemas(mergedProperties[key], value);
+        }
+        const required = Array.isArray(record.required)
+            ? record.required.filter((key) => typeof key === "string")
+            : [];
+        for (const key of required) {
+            requiredCounts.set(key, (requiredCounts.get(key) ?? 0) + 1);
+        }
+    }
+    if (objectVariants === 0)
+        return null;
+    const required = Array.from(requiredCounts.entries())
+        .filter(([, count]) => count === objectVariants)
+        .map(([key]) => key);
+    const result = {
+        type: "object",
+        properties: mergedProperties,
+    };
+    if (required.length > 0)
+        result.required = required;
+    if (!Object.hasOwn(result, "additionalProperties")) {
+        result.additionalProperties = true;
+    }
+    return result;
+}
+function applySchemaMetadata(target, source) {
+    for (const key of ["description", "title", "default"]) {
+        if (key in source && source[key] !== undefined)
+            target[key] = source[key];
+    }
+    return target;
+}
+function fallbackSchema(source) {
+    return applySchemaMetadata({}, source);
+}
+function resolveUnionSchema(variants, source) {
+    const { variants: nonNullVariants } = stripNullVariants(variants);
+    if (nonNullVariants.length === 0)
+        return fallbackSchema(source);
+    const flattenedLiteral = tryFlattenLiteralUnion(nonNullVariants);
+    if (flattenedLiteral)
+        return applySchemaMetadata({ ...flattenedLiteral }, source);
+    const flattenedTypes = tryFlattenTypeUnion(nonNullVariants);
+    if (flattenedTypes)
+        return applySchemaMetadata({ ...flattenedTypes }, source);
+    const mergedObjects = mergeObjectUnion(nonNullVariants);
+    if (mergedObjects)
+        return applySchemaMetadata(mergedObjects, source);
+    if (nonNullVariants.length === 1) {
+        const lone = nonNullVariants[0];
+        if (lone && typeof lone === "object" && !Array.isArray(lone)) {
+            return applySchemaMetadata({ ...lone }, source);
+        }
+    }
+    return fallbackSchema(source);
+}
+export function cleanSchemaForGemini(schema) {
+    if (!schema || typeof schema !== "object")
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map(cleanSchemaForGemini);
+    const obj = schema;
+    const hasAnyOf = Array.isArray(obj.anyOf);
+    const hasOneOf = Array.isArray(obj.oneOf);
+    const hasAllOf = Array.isArray(obj.allOf);
+    if (hasAnyOf) {
+        const cleanedVariants = obj.anyOf.map(cleanSchemaForGemini);
+        return resolveUnionSchema(cleanedVariants, obj) ?? fallbackSchema(obj);
+    }
+    if (hasOneOf) {
+        const cleanedVariants = obj.oneOf.map(cleanSchemaForGemini);
+        return resolveUnionSchema(cleanedVariants, obj) ?? fallbackSchema(obj);
+    }
+    if (hasAllOf) {
+        const cleanedVariants = obj.allOf.map(cleanSchemaForGemini);
+        return resolveUnionSchema(cleanedVariants, obj) ?? fallbackSchema(obj);
+    }
+    const cleaned = {};
+    for (const [key, value] of Object.entries(obj)) {
+        // Skip unsupported schema features for Gemini:
+        // - patternProperties: not in OpenAPI 3.0 subset
+        // - const: convert to enum with single value instead
+        if (key === "patternProperties") {
+            continue;
+        }
+        if (key === "const") {
+            cleaned.enum = [value];
+            continue;
+        }
+        if (key === "type" &&
+            Array.isArray(value) &&
+            value.every((entry) => typeof entry === "string")) {
+            const types = value.filter((entry) => entry !== "null");
+            cleaned.type = types.length === 1 ? types[0] : types;
+            continue;
+        }
+        if (key === "properties" && value && typeof value === "object") {
+            const props = value;
+            cleaned[key] = Object.fromEntries(Object.entries(props).map(([k, v]) => [k, cleanSchemaForGemini(v)]));
+        }
+        else if (key === "items" && value && typeof value === "object") {
+            cleaned[key] = cleanSchemaForGemini(value);
+        }
+        else if (key === "additionalProperties" && value && typeof value === "object") {
+            cleaned[key] = cleanSchemaForGemini(value);
+        }
+        else {
+            cleaned[key] = value;
+        }
+    }
+    return cleaned;
+}
+export function normalizeToolParameters(tool) {
+    const schema = tool.parameters && typeof tool.parameters === "object"
+        ? tool.parameters
+        : undefined;
+    if (!schema)
+        return tool;
+    // Provider quirks:
+    // - Gemini rejects several JSON Schema keywords, so we scrub those.
+    // - OpenAI rejects function tool schemas unless the *top-level* is `type: "object"`.
+    //   (TypeBox root unions compile to `{ anyOf: [...] }` without `type`).
+    //
+    // Normalize once here so callers can always pass `tools` through unchanged.
+    // If schema already has type + properties (no top-level anyOf to merge),
+    // still clean it for Gemini compatibility
+    if ("type" in schema && "properties" in schema && !Array.isArray(schema.anyOf)) {
+        return {
+            ...tool,
+            parameters: cleanSchemaForGemini(schema),
+        };
+    }
+    // Some tool schemas (esp. unions) may omit `type` at the top-level. If we see
+    // object-ish fields, force `type: "object"` so OpenAI accepts the schema.
+    if (!("type" in schema) &&
+        (typeof schema.properties === "object" || Array.isArray(schema.required)) &&
+        !Array.isArray(schema.anyOf) &&
+        !Array.isArray(schema.oneOf)) {
+        return {
+            ...tool,
+            parameters: cleanSchemaForGemini({ ...schema, type: "object" }),
+        };
+    }
+    const variantKey = Array.isArray(schema.anyOf)
+        ? "anyOf"
+        : Array.isArray(schema.oneOf)
+            ? "oneOf"
+            : null;
+    if (!variantKey)
+        return tool;
+    const variants = schema[variantKey];
+    const mergedProperties = {};
+    const requiredCounts = new Map();
+    let objectVariants = 0;
+    for (const entry of variants) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const props = entry.properties;
+        if (!props || typeof props !== "object")
+            continue;
+        objectVariants += 1;
+        for (const [key, value] of Object.entries(props)) {
+            if (!(key in mergedProperties)) {
+                mergedProperties[key] = value;
+                continue;
+            }
+            mergedProperties[key] = mergePropertySchemas(mergedProperties[key], value);
+        }
+        const required = Array.isArray(entry.required)
+            ? entry.required
+            : [];
+        for (const key of required) {
+            if (typeof key !== "string")
+                continue;
+            requiredCounts.set(key, (requiredCounts.get(key) ?? 0) + 1);
+        }
+    }
+    const baseRequired = Array.isArray(schema.required)
+        ? schema.required.filter((key) => typeof key === "string")
+        : undefined;
+    const mergedRequired = baseRequired && baseRequired.length > 0
+        ? baseRequired
+        : objectVariants > 0
+            ? Array.from(requiredCounts.entries())
+                .filter(([, count]) => count === objectVariants)
+                .map(([key]) => key)
+            : undefined;
+    const nextSchema = { ...schema };
+    return {
+        ...tool,
+        // Flatten union schemas into a single object schema:
+        // - Gemini doesn't allow top-level `type` together with `anyOf`.
+        // - OpenAI rejects schemas without top-level `type: "object"`.
+        // Merging properties preserves useful enums like `action` while keeping schemas portable.
+        parameters: cleanSchemaForGemini({
+            type: "object",
+            ...(typeof nextSchema.title === "string" ? { title: nextSchema.title } : {}),
+            ...(typeof nextSchema.description === "string"
+                ? { description: nextSchema.description }
+                : {}),
+            properties: Object.keys(mergedProperties).length > 0 ? mergedProperties : (schema.properties ?? {}),
+            ...(mergedRequired && mergedRequired.length > 0 ? { required: mergedRequired } : {}),
+            additionalProperties: "additionalProperties" in schema ? schema.additionalProperties : true,
+        }),
+    };
+}
+export function cleanToolSchemaForGemini(schema) {
+    return cleanSchemaForGemini(schema);
+}

package/dist/agents/sandbox-paths.js

@@ -0,0 +1,68 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+function normalizeUnicodeSpaces(str) {
+    return str.replace(UNICODE_SPACES, " ");
+}
+function expandPath(filePath) {
+    const normalized = normalizeUnicodeSpaces(filePath);
+    if (normalized === "~") {
+        return os.homedir();
+    }
+    if (normalized.startsWith("~/")) {
+        return os.homedir() + normalized.slice(1);
+    }
+    return normalized;
+}
+function resolveToCwd(filePath, cwd) {
+    const expanded = expandPath(filePath);
+    if (path.isAbsolute(expanded))
+        return expanded;
+    return path.resolve(cwd, expanded);
+}
+export function resolveSandboxPath(params) {
+    const resolved = resolveToCwd(params.filePath, params.cwd);
+    const rootResolved = path.resolve(params.root);
+    const relative = path.relative(rootResolved, resolved);
+    if (!relative || relative === "") {
+        return { resolved, relative: "" };
+    }
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`Path escapes sandbox root (${shortPath(rootResolved)}): ${params.filePath}`);
+    }
+    return { resolved, relative };
+}
+export async function assertSandboxPath(params) {
+    const resolved = resolveSandboxPath(params);
+    await assertNoSymlink(resolved.relative, path.resolve(params.root));
+    return resolved;
+}
+async function assertNoSymlink(relative, root) {
+    if (!relative)
+        return;
+    const parts = relative.split(path.sep).filter(Boolean);
+    let current = root;
+    for (const part of parts) {
+        current = path.join(current, part);
+        try {
+            const stat = await fs.lstat(current);
+            if (stat.isSymbolicLink()) {
+                throw new Error(`Symlink not allowed in sandbox path: ${current}`);
+            }
+        }
+        catch (err) {
+            const anyErr = err;
+            if (anyErr.code === "ENOENT") {
+                return;
+            }
+            throw err;
+        }
+    }
+}
+function shortPath(value) {
+    if (value.startsWith(os.homedir())) {
+        return `~${value.slice(os.homedir().length)}`;
+    }
+    return value;
+}