@intent-systems/nexus 2026.1.5-3

package/dist/agents/pi-extensions/compaction-safeguard.js

@@ -0,0 +1,140 @@
+import { estimateTokens, generateSummary } from "@mariozechner/pi-coding-agent";
+import { DEFAULT_CONTEXT_TOKENS } from "../defaults.js";
+const MAX_CHUNK_RATIO = 0.4;
+const FALLBACK_SUMMARY = "Summary unavailable due to context limits. Older messages were truncated.";
+const TURN_PREFIX_INSTRUCTIONS = "This summary covers the prefix of a split turn. Focus on the original request," +
+    " early progress, and any details needed to understand the retained suffix.";
+function computeFileLists(fileOps) {
+    const modified = new Set([...fileOps.edited, ...fileOps.written]);
+    const readFiles = [...fileOps.read].filter((f) => !modified.has(f)).sort();
+    const modifiedFiles = [...modified].sort();
+    return { readFiles, modifiedFiles };
+}
+function formatFileOperations(readFiles, modifiedFiles) {
+    const sections = [];
+    if (readFiles.length > 0) {
+        sections.push(`<read-files>\n${readFiles.join("\n")}\n</read-files>`);
+    }
+    if (modifiedFiles.length > 0) {
+        sections.push(`<modified-files>\n${modifiedFiles.join("\n")}\n</modified-files>`);
+    }
+    if (sections.length === 0)
+        return "";
+    return `\n\n${sections.join("\n\n")}`;
+}
+function chunkMessages(messages, maxTokens) {
+    if (messages.length === 0)
+        return [];
+    const chunks = [];
+    let currentChunk = [];
+    let currentTokens = 0;
+    for (const message of messages) {
+        const messageTokens = estimateTokens(message);
+        if (currentChunk.length > 0 && currentTokens + messageTokens > maxTokens) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+            currentTokens = 0;
+        }
+        currentChunk.push(message);
+        currentTokens += messageTokens;
+        if (messageTokens > maxTokens) {
+            // Split oversized messages to avoid unbounded chunk growth.
+            chunks.push(currentChunk);
+            currentChunk = [];
+            currentTokens = 0;
+        }
+    }
+    if (currentChunk.length > 0) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
+async function summarizeChunks(params) {
+    if (params.messages.length === 0) {
+        return params.previousSummary ?? "No prior history.";
+    }
+    const chunks = chunkMessages(params.messages, params.maxChunkTokens);
+    let summary = params.previousSummary;
+    for (const chunk of chunks) {
+        summary = await generateSummary(chunk, params.model, params.reserveTokens, params.apiKey, params.signal, params.customInstructions, summary);
+    }
+    return summary ?? "No prior history.";
+}
+export default function compactionSafeguardExtension(api) {
+    api.on("session_before_compact", async (event, ctx) => {
+        const { preparation, customInstructions, signal } = event;
+        const { readFiles, modifiedFiles } = computeFileLists(preparation.fileOps);
+        const fileOpsSummary = formatFileOperations(readFiles, modifiedFiles);
+        const fallbackSummary = `${FALLBACK_SUMMARY}${fileOpsSummary}`;
+        const model = ctx.model;
+        if (!model) {
+            return {
+                compaction: {
+                    summary: fallbackSummary,
+                    firstKeptEntryId: preparation.firstKeptEntryId,
+                    tokensBefore: preparation.tokensBefore,
+                    details: { readFiles, modifiedFiles },
+                },
+            };
+        }
+        const apiKey = await ctx.modelRegistry.getApiKey(model);
+        if (!apiKey) {
+            return {
+                compaction: {
+                    summary: fallbackSummary,
+                    firstKeptEntryId: preparation.firstKeptEntryId,
+                    tokensBefore: preparation.tokensBefore,
+                    details: { readFiles, modifiedFiles },
+                },
+            };
+        }
+        try {
+            const contextWindowTokens = Math.max(1, Math.floor(model.contextWindow ?? DEFAULT_CONTEXT_TOKENS));
+            const maxChunkTokens = Math.max(1, Math.floor(contextWindowTokens * MAX_CHUNK_RATIO));
+            const reserveTokens = Math.max(1, Math.floor(preparation.settings.reserveTokens));
+            const historySummary = await summarizeChunks({
+                messages: preparation.messagesToSummarize,
+                model,
+                apiKey,
+                signal,
+                reserveTokens,
+                maxChunkTokens,
+                customInstructions,
+                previousSummary: preparation.previousSummary,
+            });
+            let summary = historySummary;
+            if (preparation.isSplitTurn && preparation.turnPrefixMessages.length > 0) {
+                const prefixSummary = await summarizeChunks({
+                    messages: preparation.turnPrefixMessages,
+                    model,
+                    apiKey,
+                    signal,
+                    reserveTokens,
+                    maxChunkTokens,
+                    customInstructions: TURN_PREFIX_INSTRUCTIONS,
+                });
+                summary = `${historySummary}\n\n---\n\n**Turn Context (split turn):**\n\n${prefixSummary}`;
+            }
+            summary += fileOpsSummary;
+            return {
+                compaction: {
+                    summary,
+                    firstKeptEntryId: preparation.firstKeptEntryId,
+                    tokensBefore: preparation.tokensBefore,
+                    details: { readFiles, modifiedFiles },
+                },
+            };
+        }
+        catch (error) {
+            console.warn(`Compaction summarization failed; truncating history: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                compaction: {
+                    summary: fallbackSummary,
+                    firstKeptEntryId: preparation.firstKeptEntryId,
+                    tokensBefore: preparation.tokensBefore,
+                    details: { readFiles, modifiedFiles },
+                },
+            };
+        }
+    });
+}

package/dist/agents/pi-tool-definition-adapter.js

@@ -0,0 +1,17 @@
+export function toToolDefinitions(tools) {
+    return tools.map((tool) => {
+        const name = tool.name || "tool";
+        return {
+            name,
+            label: tool.label ?? name,
+            description: tool.description ?? "",
+            // biome-ignore lint/suspicious/noExplicitAny: TypeBox schema from pi-agent-core uses a different module instance.
+            parameters: tool.parameters,
+            execute: async (toolCallId, params, onUpdate, _ctx, signal) => {
+                // KNOWN: pi-coding-agent `ToolDefinition.execute` has a different signature/order
+                // than pi-agent-core `AgentTool.execute`. This adapter keeps our existing tools intact.
+                return tool.execute(toolCallId, params, signal, onUpdate);
+            },
+        };
+    });
+}

package/dist/agents/pi-tools.js

@@ -0,0 +1,510 @@
+import { codingTools, createEditTool, createReadTool, createWriteTool, readTool, } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { detectMime } from "../media/mime.js";
+import { isSubagentSessionKey } from "../routing/session-key.js";
+import { startWebLoginWithQr, waitForWebLogin } from "../web/login-qr.js";
+import { createBashTool, createProcessTool, } from "./bash-tools.js";
+import { createNexusTools } from "./nexus-tools.js";
+import { assertSandboxPath } from "./sandbox-paths.js";
+import { sanitizeToolResultImages } from "./tool-images.js";
+async function sniffMimeFromBase64(base64) {
+    const trimmed = base64.trim();
+    if (!trimmed)
+        return undefined;
+    const take = Math.min(256, trimmed.length);
+    const sliceLen = take - (take % 4);
+    if (sliceLen < 8)
+        return undefined;
+    try {
+        const head = Buffer.from(trimmed.slice(0, sliceLen), "base64");
+        return await detectMime({ buffer: head });
+    }
+    catch {
+        return undefined;
+    }
+}
+function rewriteReadImageHeader(text, mimeType) {
+    // pi-coding-agent uses: "Read image file [image/png]"
+    if (text.startsWith("Read image file [") && text.endsWith("]")) {
+        return `Read image file [${mimeType}]`;
+    }
+    return text;
+}
+async function normalizeReadImageResult(result, filePath) {
+    const content = Array.isArray(result.content) ? result.content : [];
+    const image = content.find((b) => !!b &&
+        typeof b === "object" &&
+        b.type === "image" &&
+        typeof b.data === "string" &&
+        typeof b.mimeType === "string");
+    if (!image)
+        return result;
+    if (!image.data.trim()) {
+        throw new Error(`read: image payload is empty (${filePath})`);
+    }
+    const sniffed = await sniffMimeFromBase64(image.data);
+    if (!sniffed)
+        return result;
+    if (!sniffed.startsWith("image/")) {
+        throw new Error(`read: file looks like ${sniffed} but was treated as ${image.mimeType} (${filePath})`);
+    }
+    if (sniffed === image.mimeType)
+        return result;
+    const nextContent = content.map((block) => {
+        if (block &&
+            typeof block === "object" &&
+            block.type === "image") {
+            const b = block;
+            return { ...b, mimeType: sniffed };
+        }
+        if (block &&
+            typeof block === "object" &&
+            block.type === "text" &&
+            typeof block.text === "string") {
+            const b = block;
+            return {
+                ...b,
+                text: rewriteReadImageHeader(b.text, sniffed),
+            };
+        }
+        return block;
+    });
+    return { ...result, content: nextContent };
+}
+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];
+    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 cleanSchemaForGemini(schema) {
+    if (!schema || typeof schema !== "object")
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map(cleanSchemaForGemini);
+    const obj = schema;
+    const hasAnyOf = "anyOf" in obj && Array.isArray(obj.anyOf);
+    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") {
+            // Gemini doesn't support patternProperties - skip it
+            continue;
+        }
+        // Convert const to enum (Gemini doesn't support const)
+        if (key === "const") {
+            cleaned.enum = [value];
+            continue;
+        }
+        // Skip 'type' if we have 'anyOf' — Gemini doesn't allow both
+        if (key === "type" && hasAnyOf) {
+            continue;
+        }
+        if (key === "properties" && value && typeof value === "object") {
+            // Recursively clean nested properties
+            const props = value;
+            cleaned[key] = Object.fromEntries(Object.entries(props).map(([k, v]) => [k, cleanSchemaForGemini(v)]));
+        }
+        else if (key === "items" && value && typeof value === "object") {
+            // Recursively clean array items schema
+            cleaned[key] = cleanSchemaForGemini(value);
+        }
+        else if (key === "anyOf" && Array.isArray(value)) {
+            // Clean each anyOf variant
+            cleaned[key] = value.map((variant) => cleanSchemaForGemini(variant));
+        }
+        else if (key === "oneOf" && Array.isArray(value)) {
+            // Clean each oneOf variant
+            cleaned[key] = value.map((variant) => cleanSchemaForGemini(variant));
+        }
+        else if (key === "allOf" && Array.isArray(value)) {
+            // Clean each allOf variant
+            cleaned[key] = value.map((variant) => cleanSchemaForGemini(variant));
+        }
+        else if (key === "additionalProperties" &&
+            value &&
+            typeof value === "object") {
+            // Recursively clean additionalProperties schema
+            cleaned[key] = cleanSchemaForGemini(value);
+        }
+        else {
+            cleaned[key] = value;
+        }
+    }
+    return cleaned;
+}
+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,
+        }),
+    };
+}
+function normalizeToolNames(list) {
+    if (!list)
+        return [];
+    return list.map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+}
+const DEFAULT_SUBAGENT_TOOL_DENY = [
+    "sessions_list",
+    "sessions_history",
+    "sessions_send",
+    "sessions_spawn",
+];
+function resolveSubagentToolPolicy(cfg) {
+    const configured = cfg?.agent?.subagents?.tools;
+    const deny = [
+        ...DEFAULT_SUBAGENT_TOOL_DENY,
+        ...(Array.isArray(configured?.deny) ? configured.deny : []),
+    ];
+    const allow = Array.isArray(configured?.allow) ? configured.allow : undefined;
+    return { allow, deny };
+}
+function filterToolsByPolicy(tools, policy) {
+    if (!policy)
+        return tools;
+    const deny = new Set(normalizeToolNames(policy.deny));
+    const allowRaw = normalizeToolNames(policy.allow);
+    const allow = allowRaw.length > 0 ? new Set(allowRaw) : null;
+    return tools.filter((tool) => {
+        const name = tool.name.toLowerCase();
+        if (deny.has(name))
+            return false;
+        if (allow)
+            return allow.has(name);
+        return true;
+    });
+}
+function wrapSandboxPathGuard(tool, root) {
+    return {
+        ...tool,
+        execute: async (toolCallId, args, signal, onUpdate) => {
+            const record = args && typeof args === "object"
+                ? args
+                : undefined;
+            const filePath = record?.path;
+            if (typeof filePath === "string" && filePath.trim()) {
+                await assertSandboxPath({ filePath, cwd: root, root });
+            }
+            return tool.execute(toolCallId, args, signal, onUpdate);
+        },
+    };
+}
+function createSandboxedReadTool(root) {
+    const base = createReadTool(root);
+    return wrapSandboxPathGuard(createNexusReadTool(base), root);
+}
+function createSandboxedWriteTool(root) {
+    const base = createWriteTool(root);
+    return wrapSandboxPathGuard(base, root);
+}
+function createSandboxedEditTool(root) {
+    const base = createEditTool(root);
+    return wrapSandboxPathGuard(base, root);
+}
+function createWhatsAppLoginTool() {
+    return {
+        label: "WhatsApp Login",
+        name: "whatsapp_login",
+        description: "Generate a WhatsApp QR code for linking, or wait for the scan to complete.",
+        parameters: Type.Object({
+            action: Type.Union([Type.Literal("start"), Type.Literal("wait")]),
+            timeoutMs: Type.Optional(Type.Number()),
+            force: Type.Optional(Type.Boolean()),
+        }),
+        execute: async (_toolCallId, args) => {
+            const action = args?.action ?? "start";
+            if (action === "wait") {
+                const result = await waitForWebLogin({
+                    timeoutMs: typeof args.timeoutMs === "number"
+                        ? args.timeoutMs
+                        : undefined,
+                });
+                return {
+                    content: [{ type: "text", text: result.message }],
+                    details: { connected: result.connected },
+                };
+            }
+            const result = await startWebLoginWithQr({
+                timeoutMs: typeof args.timeoutMs === "number"
+                    ? args.timeoutMs
+                    : undefined,
+                force: typeof args.force === "boolean"
+                    ? args.force
+                    : false,
+            });
+            if (!result.qrDataUrl) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: result.message,
+                        },
+                    ],
+                    details: { qr: false },
+                };
+            }
+            const text = [
+                result.message,
+                "",
+                "Open WhatsApp → Linked Devices and scan:",
+                "",
+                `![whatsapp-qr](${result.qrDataUrl})`,
+            ].join("\n");
+            return {
+                content: [{ type: "text", text }],
+                details: { qr: true },
+            };
+        },
+    };
+}
+function createNexusReadTool(base) {
+    return {
+        ...base,
+        execute: async (toolCallId, params, signal) => {
+            const result = (await base.execute(toolCallId, params, signal));
+            const record = params && typeof params === "object"
+                ? params
+                : undefined;
+            const filePath = typeof record?.path === "string" ? String(record.path) : "<unknown>";
+            const normalized = await normalizeReadImageResult(result, filePath);
+            return sanitizeToolResultImages(normalized, `read:${filePath}`);
+        },
+    };
+}
+function normalizeMessageProvider(messageProvider) {
+    const trimmed = messageProvider?.trim().toLowerCase();
+    return trimmed ? trimmed : undefined;
+}
+function shouldIncludeDiscordTool(messageProvider) {
+    const normalized = normalizeMessageProvider(messageProvider);
+    if (!normalized)
+        return false;
+    return normalized === "discord" || normalized.startsWith("discord:");
+}
+function shouldIncludeSlackTool(messageProvider) {
+    const normalized = normalizeMessageProvider(messageProvider);
+    if (!normalized)
+        return false;
+    return normalized === "slack" || normalized.startsWith("slack:");
+}
+export function createNexusCodingTools(options) {
+    const bashToolName = "bash";
+    const sandbox = options?.sandbox?.enabled ? options.sandbox : undefined;
+    const sandboxRoot = sandbox?.workspaceDir;
+    const base = codingTools.flatMap((tool) => {
+        if (tool.name === readTool.name) {
+            return sandboxRoot
+                ? [createSandboxedReadTool(sandboxRoot)]
+                : [createNexusReadTool(tool)];
+        }
+        if (tool.name === bashToolName)
+            return [];
+        if (sandboxRoot && (tool.name === "write" || tool.name === "edit")) {
+            return [];
+        }
+        return [tool];
+    });
+    const bashTool = createBashTool({
+        ...options?.bash,
+        sandbox: sandbox
+            ? {
+                containerName: sandbox.containerName,
+                workspaceDir: sandbox.workspaceDir,
+                containerWorkdir: sandbox.containerWorkdir,
+                env: sandbox.docker.env,
+            }
+            : undefined,
+    });
+    const processTool = createProcessTool({
+        cleanupMs: options?.bash?.cleanupMs,
+    });
+    const tools = [
+        ...base,
+        ...(sandboxRoot
+            ? [
+                createSandboxedEditTool(sandboxRoot),
+                createSandboxedWriteTool(sandboxRoot),
+            ]
+            : []),
+        bashTool,
+        processTool,
+        createWhatsAppLoginTool(),
+        ...createNexusTools({
+            browserControlUrl: sandbox?.browser?.controlUrl,
+            agentSessionKey: options?.sessionKey,
+            agentProvider: options?.messageProvider,
+            agentDir: options?.agentDir,
+            sandboxed: !!sandbox,
+            config: options?.config,
+        }),
+    ];
+    const allowDiscord = shouldIncludeDiscordTool(options?.messageProvider);
+    const allowSlack = shouldIncludeSlackTool(options?.messageProvider);
+    const filtered = tools.filter((tool) => {
+        if (tool.name === "discord")
+            return allowDiscord;
+        if (tool.name === "slack")
+            return allowSlack;
+        return true;
+    });
+    const globallyFiltered = options?.config?.agent?.tools &&
+        (options.config.agent.tools.allow?.length ||
+            options.config.agent.tools.deny?.length)
+        ? filterToolsByPolicy(filtered, options.config.agent.tools)
+        : filtered;
+    const sandboxed = sandbox
+        ? filterToolsByPolicy(globallyFiltered, sandbox.tools)
+        : globallyFiltered;
+    const subagentFiltered = isSubagentSessionKey(options?.sessionKey) && options?.sessionKey
+        ? filterToolsByPolicy(sandboxed, resolveSubagentToolPolicy(options.config))
+        : sandboxed;
+    // Always normalize tool JSON Schemas before handing them to pi-agent/pi-ai.
+    // Without this, some providers (notably OpenAI) will reject root-level union schemas.
+    return subagentFiltered.map(normalizeToolParameters);
+}
+const normalizeToolParams = normalizeToolParameters;
+function patchToolSchemaForClaudeCompatibility(tool) {
+    return tool;
+}
+function wrapToolParamNormalization(tool) {
+    return normalizeToolParameters(tool);
+}
+function assertRequiredParams(_schema) {
+    // no-op (kept for test helpers/backcompat)
+}
+export const __testing = {
+    cleanSchemaForGemini,
+    normalizeToolParams,
+    patchToolSchemaForClaudeCompatibility,
+    wrapToolParamNormalization,
+    assertRequiredParams,
+};