@intent-systems/nexus 2026.1.5-3 → 2026.1.5-4

package/dist/utils/provider-utils.js

@@ -0,0 +1,28 @@
+/**
+ * Utility functions for provider-specific logic and capabilities.
+ */
+/**
+ * Returns true if the provider requires reasoning to be wrapped in tags
+ * (e.g. <think> and <final>) in the text stream, rather than using native
+ * API fields for reasoning/thinking.
+ */
+export function isReasoningTagProvider(provider) {
+    if (!provider)
+        return false;
+    const normalized = provider.trim().toLowerCase();
+    // Check for exact matches or known prefixes/substrings for reasoning providers
+    if (normalized === "ollama" ||
+        normalized === "google-gemini-cli" ||
+        normalized === "google-generative-ai") {
+        return true;
+    }
+    // Handle google-antigravity and its model variations (e.g. google-antigravity/gemini-3)
+    if (normalized.includes("google-antigravity")) {
+        return true;
+    }
+    // Handle Minimax (M2.1 is chatty/reasoning-like)
+    if (normalized.includes("minimax")) {
+        return true;
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intent-systems/nexus",
-  "version": "2026.1.5-3",
+  "version": "2026.1.5-4",
   "description": "WhatsApp gateway CLI (Baileys web) with Pi RPC agent",
   "homepage": "https://github.com/Napageneral/nexus",
   "repository": {
@@ -13,36 +13,11 @@
     "nexus": "dist/entry.js"
   },
   "files": [
-    "dist/agents/**",
-    "dist/auto-reply/**",
-    "dist/browser/**",
-    "dist/canvas-host/**",
-    "dist/cli/**",
-    "dist/commands/**",
-    "dist/config/**",
-    "dist/control-ui/**",
-    "dist/cron/**",
-    "dist/daemon/**",
-    "dist/discord/**",
-    "dist/gateway/**",
-    "dist/hooks/**",
-    "dist/imessage/**",
-    "dist/infra/**",
-    "dist/macos/**",
-    "dist/media/**",
-    "dist/process/**",
-    "dist/sessions/**",
-    "dist/providers/**",
-    "dist/signal/**",
-    "dist/slack/**",
-    "dist/telegram/**",
-    "dist/tui/**",
-    "dist/web/**",
-    "dist/wizard/**",
-    "dist/*.js",
-    "dist/*.json",
+    "dist/**",
     "docs/**",
     "skills/**",
+    "patches/**",
+    "scripts/postinstall.js",
     "README.md",
     "README-header.png",
     "CHANGELOG.md",

package/patches/@mariozechner__pi-ai.patch

@@ -0,0 +1,215 @@
+diff --git a/dist/providers/google-shared.js b/dist/providers/google-shared.js
+index 7bc0a9f5d6241f191cd607ecb37b3acac8d58267..56866774e47444b5d333961c9b20fce582363124 100644
+--- a/dist/providers/google-shared.js
++++ b/dist/providers/google-shared.js
+@@ -10,13 +10,27 @@ import { transformMessages } from "./transorm-messages.js";
+ export function convertMessages(model, context) {
+     const contents = [];
+     const transformedMessages = transformMessages(context.messages, model);
++    
++    /**
++     * Helper to add content while merging consecutive messages of the same role.
++     * Gemini/Cloud Code Assist requires strict role alternation (user/model/user/model).
++     * Consecutive messages of the same role cause "function call turn" errors.
++     */
++    function addContent(role, parts) {
++        if (parts.length === 0) return;
++        const lastContent = contents[contents.length - 1];
++        if (lastContent?.role === role) {
++            // Merge into existing message of same role
++            lastContent.parts.push(...parts);
++        } else {
++            contents.push({ role, parts });
++        }
++    }
++    
+     for (const msg of transformedMessages) {
+         if (msg.role === "user") {
+             if (typeof msg.content === "string") {
+-                contents.push({
+-                    role: "user",
+-                    parts: [{ text: sanitizeSurrogates(msg.content) }],
+-                });
++                addContent("user", [{ text: sanitizeSurrogates(msg.content) }]);
+             }
+             else {
+                 const parts = msg.content.map((item) => {
+@@ -35,10 +49,7 @@ export function convertMessages(model, context) {
+                 const filteredParts = !model.input.includes("image") ? parts.filter((p) => p.text !== undefined) : parts;
+                 if (filteredParts.length === 0)
+                     continue;
+-                contents.push({
+-                    role: "user",
+-                    parts: filteredParts,
+-                });
++                addContent("user", filteredParts);
+             }
+         }
+         else if (msg.role === "assistant") {
+@@ -51,9 +62,19 @@ export function convertMessages(model, context) {
+                     parts.push({ text: sanitizeSurrogates(block.text) });
+                 }
+                 else if (block.type === "thinking") {
+-                    // Thinking blocks require signatures for Claude via Antigravity.
+-                    // If signature is missing (e.g. from GPT-OSS), convert to regular text with delimiters.
+-                    if (block.thinkingSignature) {
++                    // Thinking blocks handling varies by model:
++                    // - Claude via Antigravity: requires thinkingSignature
++                    // - Gemini: skip entirely (doesn't understand thoughtSignature, and mimics <thinking> tags)
++                    // - Other models: convert to text with delimiters
++                    const isGemini = model.id.toLowerCase().includes("gemini");
++                    const isClaude = model.id.toLowerCase().includes("claude");
++                    if (isGemini) {
++                        // Skip thinking blocks entirely for Gemini - it doesn't support them
++                        // and will mimic <thinking> tags if we convert to text
++                        continue;
++                    }
++                    else if (block.thinkingSignature && isClaude) {
++                        // Claude via Antigravity requires the signature
+                         parts.push({
+                             thought: true,
+                             text: sanitizeSurrogates(block.thinking),
+@@ -61,6 +82,7 @@ export function convertMessages(model, context) {
+                         });
+                     }
+                     else {
++                        // Other models: convert to text with delimiters
+                         parts.push({
+                             text: `<thinking>\n${sanitizeSurrogates(block.thinking)}\n</thinking>`,
+                         });
+@@ -85,10 +107,7 @@ export function convertMessages(model, context) {
+             }
+             if (parts.length === 0)
+                 continue;
+-            contents.push({
+-                role: "model",
+-                parts,
+-            });
++            addContent("model", parts);
+         }
+         else if (msg.role === "toolResult") {
+             // Extract text and image content
+@@ -125,27 +144,94 @@ export function convertMessages(model, context) {
+             }
+             // Cloud Code Assist API requires all function responses to be in a single user turn.
+             // Check if the last content is already a user turn with function responses and merge.
++            // Use addContent for proper role alternation handling.
+             const lastContent = contents[contents.length - 1];
+             if (lastContent?.role === "user" && lastContent.parts?.some((p) => p.functionResponse)) {
+                 lastContent.parts.push(functionResponsePart);
+             }
+             else {
+-                contents.push({
+-                    role: "user",
+-                    parts: [functionResponsePart],
+-                });
++                addContent("user", [functionResponsePart]);
+             }
+             // For older models, add images in a separate user message
++            // Note: This may create consecutive user messages, but addContent will merge them
+             if (hasImages && !supportsMultimodalFunctionResponse) {
+-                contents.push({
+-                    role: "user",
+-                    parts: [{ text: "Tool result image:" }, ...imageParts],
+-                });
++                addContent("user", [{ text: "Tool result image:" }, ...imageParts]);
+             }
+         }
+     }
+     return contents;
+ }
++/**
++ * Sanitize JSON Schema for Google Cloud Code Assist API.
++ * Removes unsupported keywords like patternProperties, const, anyOf, etc.
++ * and converts to a format compatible with Google's function declarations.
++ */
++function sanitizeSchemaForGoogle(schema) {
++    if (!schema || typeof schema !== 'object') {
++        return schema;
++    }
++    // If it's an array, sanitize each element
++    if (Array.isArray(schema)) {
++        return schema.map(item => sanitizeSchemaForGoogle(item));
++    }
++    const sanitized = {};
++    // List of unsupported JSON Schema keywords that Google's API doesn't understand
++    const unsupportedKeywords = [
++        'patternProperties',
++        'const',
++        'anyOf',
++        'oneOf',
++        'allOf',
++        'not',
++        '$schema',
++        '$id',
++        '$ref',
++        '$defs',
++        'definitions',
++        'if',
++        'then',
++        'else',
++        'dependentSchemas',
++        'dependentRequired',
++        'unevaluatedProperties',
++        'unevaluatedItems',
++        'contentEncoding',
++        'contentMediaType',
++        'contentSchema',
++        'deprecated',
++        'readOnly',
++        'writeOnly',
++        'examples',
++        '$comment',
++        'additionalProperties',
++    ];
++    // TODO(steipete): lossy schema scrub; revisit when Google supports these keywords.
++    for (const [key, value] of Object.entries(schema)) {
++        // Skip unsupported keywords
++        if (unsupportedKeywords.includes(key)) {
++            continue;
++        }
++        // Recursively sanitize nested objects
++        if (key === 'properties' && typeof value === 'object' && value !== null) {
++            sanitized[key] = {};
++            for (const [propKey, propValue] of Object.entries(value)) {
++                sanitized[key][propKey] = sanitizeSchemaForGoogle(propValue);
++            }
++        } else if (key === 'items' && typeof value === 'object') {
++            sanitized[key] = sanitizeSchemaForGoogle(value);
++        } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
++            sanitized[key] = sanitizeSchemaForGoogle(value);
++        } else {
++            sanitized[key] = value;
++        }
++    }
++    // Ensure type: "object" is present when properties or required exist
++    // Google API requires type to be set when these fields are present
++    if (('properties' in sanitized || 'required' in sanitized) && !('type' in sanitized)) {
++        sanitized.type = 'object';
++    }
++    return sanitized;
++}
+ /**
+  * Convert tools to Gemini function declarations format.
+  */
+@@ -157,7 +243,7 @@ export function convertTools(tools) {
+             functionDeclarations: tools.map((tool) => ({
+                 name: tool.name,
+                 description: tool.description,
+-                parameters: tool.parameters,
++                parameters: sanitizeSchemaForGoogle(tool.parameters),
+             })),
+         },
+     ];
+diff --git a/dist/providers/openai-responses.js b/dist/providers/openai-responses.js
+index 20fb0a22aaa28f7ff7c2f44a8b628fa1d9d7d936..31bae0aface1319487ce62d35f1f3b6ed334863e 100644
+--- a/dist/providers/openai-responses.js
++++ b/dist/providers/openai-responses.js
+@@ -486,7 +486,6 @@ function convertTools(tools) {
+         name: tool.name,
+         description: tool.description,
+         parameters: tool.parameters, // TypeBox already generates JSON Schema
+-        strict: null,
+     }));
+ }
+ function mapStopReason(status) {

package/patches/playwright-core@1.57.0.patch

@@ -0,0 +1,13 @@
+diff --git a/lib/utilsBundle.js b/lib/utilsBundle.js
+index 7dd8831f29c19f2e20468508b77b0a3f9d204ae6..c50a1ac2b3439a5b2fbf8afa61c369360710071f 100644
+--- a/lib/utilsBundle.js
++++ b/lib/utilsBundle.js
+@@ -59,7 +59,7 @@ const program = require("./utilsBundleImpl").program;
+ const ProgramOption = require("./utilsBundleImpl").ProgramOption;
+ const progress = require("./utilsBundleImpl").progress;
+ const SocksProxyAgent = require("./utilsBundleImpl").SocksProxyAgent;
+-const ws = require("./utilsBundleImpl").ws;
++const ws = "Bun" in globalThis ? require("ws") : require("./utilsBundleImpl").ws;
+ const wsServer = require("./utilsBundleImpl").wsServer;
+ const wsReceiver = require("./utilsBundleImpl").wsReceiver;
+ const wsSender = require("./utilsBundleImpl").wsSender;

package/patches/qrcode-terminal.patch

@@ -0,0 +1,12 @@
+diff --git a/lib/main.js b/lib/main.js
+index 488cc1aea9802b3d6ae13aee27556403bec55d1c..3de1f934868d81e8204f00e6a4bf2696a05f7340 100644
+--- a/lib/main.js
++++ b/lib/main.js
+@@ -1,5 +1,5 @@
+-var QRCode = require('./../vendor/QRCode'),
+-    QRErrorCorrectLevel = require('./../vendor/QRCode/QRErrorCorrectLevel'),
++var QRCode = require('./../vendor/QRCode/index.js'),
++    QRErrorCorrectLevel = require('./../vendor/QRCode/QRErrorCorrectLevel.js'),
+     black = "\033[40m  \033[0m",
+     white = "\033[47m  \033[0m",
+     toCell = function (isBlack) {

package/scripts/postinstall.js

@@ -0,0 +1,202 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+function isBunInstall() {
+  const ua = process.env.npm_config_user_agent ?? "";
+  return ua.includes("bun/");
+}
+
+function getRepoRoot() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, "..");
+}
+
+function run(cmd, args, opts = {}) {
+  const res = spawnSync(cmd, args, { stdio: "inherit", ...opts });
+  if (typeof res.status === "number") return res.status;
+  return 1;
+}
+
+export function applyPatchSet(opts) {
+  const patchText =
+    typeof opts?.patchText === "string" ? opts.patchText : "";
+  if (!patchText.trim()) return;
+
+  const targetDir = path.resolve(String(opts?.targetDir ?? "."));
+  const lines = patchText.split(/\r?\n/);
+  let i = 0;
+
+  while (i < lines.length) {
+    const header = lines[i];
+    if (!header?.startsWith("diff --git ")) {
+      i += 1;
+      continue;
+    }
+    const match = header.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (!match) {
+      i += 1;
+      continue;
+    }
+    const filePath = path.join(targetDir, match[2] ?? match[1]);
+    i += 1;
+
+    while (i < lines.length && !lines[i]?.startsWith("@@")) {
+      if (lines[i]?.startsWith("diff --git ")) break;
+      i += 1;
+    }
+
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const hasTrailingNewline = raw.endsWith("\n");
+    const fileLines = raw.split(/\r?\n/);
+    if (hasTrailingNewline) {
+      fileLines.pop();
+    }
+    let offset = 0;
+
+    while (i < lines.length && lines[i]?.startsWith("@@")) {
+      const hunk = lines[i] ?? "";
+      const hunkMatch = hunk.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+      if (!hunkMatch) throw new Error("patch does not apply cleanly");
+      const start = Number.parseInt(hunkMatch[1] ?? "0", 10) - 1 + offset;
+      if (!Number.isFinite(start) || start < 0) {
+        throw new Error("patch does not apply cleanly");
+      }
+      i += 1;
+      let cursor = start;
+      while (i < lines.length && !lines[i]?.startsWith("@@") && !lines[i]?.startsWith("diff --git ")) {
+        const line = lines[i] ?? "";
+        if (!line) {
+          i += 1;
+          continue;
+        }
+        if (line.startsWith(" ")) {
+          const expected = line.slice(1);
+          if (fileLines[cursor] !== expected) {
+            throw new Error("patch does not apply cleanly");
+          }
+          cursor += 1;
+        } else if (line.startsWith("-")) {
+          const expected = line.slice(1);
+          if (fileLines[cursor] !== expected) {
+            throw new Error("patch does not apply cleanly");
+          }
+          fileLines.splice(cursor, 1);
+          offset -= 1;
+        } else if (line.startsWith("+")) {
+          fileLines.splice(cursor, 0, line.slice(1));
+          cursor += 1;
+          offset += 1;
+        } else if (line.startsWith("\\")) {
+          // "" markers; ignore.
+        } else {
+          throw new Error("patch does not apply cleanly");
+        }
+        i += 1;
+      }
+    }
+
+    const next = `${fileLines.join("\n")}${hasTrailingNewline ? "\n" : ""}`;
+    fs.writeFileSync(filePath, next, "utf-8");
+  }
+}
+
+function applyPatchIfNeeded(opts) {
+  const patchPath = path.resolve(opts.patchPath);
+  if (!fs.existsSync(patchPath)) {
+    throw new Error(`missing patch: ${patchPath}`);
+  }
+
+  let targetDir = path.resolve(opts.targetDir);
+  if (!fs.existsSync(targetDir) || !fs.statSync(targetDir).isDirectory()) {
+    console.warn(`[postinstall] skip missing target: ${targetDir}`);
+    return;
+  }
+
+  // Resolve symlinks to avoid "beyond a symbolic link" errors from git apply
+  // (bun/pnpm use symlinks in node_modules)
+  targetDir = fs.realpathSync(targetDir);
+
+  const gitArgsBase = ["apply", "--unsafe-paths", "--whitespace=nowarn"];
+  const reverseCheck = [
+    ...gitArgsBase,
+    "--reverse",
+    "--check",
+    "--directory",
+    targetDir,
+    patchPath,
+  ];
+  const forwardCheck = [
+    ...gitArgsBase,
+    "--check",
+    "--directory",
+    targetDir,
+    patchPath,
+  ];
+  const apply = [...gitArgsBase, "--directory", targetDir, patchPath];
+
+  // Already applied?
+  if (run("git", reverseCheck, { stdio: "ignore" }) === 0) {
+    return;
+  }
+
+  if (run("git", forwardCheck, { stdio: "ignore" }) !== 0) {
+    throw new Error(`patch does not apply cleanly: ${path.basename(patchPath)}`);
+  }
+
+  const status = run("git", apply);
+  if (status !== 0) {
+    throw new Error(`failed applying patch: ${path.basename(patchPath)}`);
+  }
+}
+
+function extractPackageName(key) {
+  if (key.startsWith("@")) {
+    const idx = key.indexOf("@", 1);
+    if (idx === -1) return key;
+    return key.slice(0, idx);
+  }
+  const idx = key.lastIndexOf("@");
+  if (idx <= 0) return key;
+  return key.slice(0, idx);
+}
+
+function main() {
+  if (!isBunInstall()) return;
+
+  const repoRoot = getRepoRoot();
+  process.chdir(repoRoot);
+
+  const pkgPath = path.join(repoRoot, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  const patched = pkg?.pnpm?.patchedDependencies ?? {};
+
+  // Bun does not support pnpm.patchedDependencies. Apply these patch files to
+  // node_modules packages as a best-effort compatibility layer.
+  for (const [key, relPatchPath] of Object.entries(patched)) {
+    if (typeof relPatchPath !== "string" || !relPatchPath.trim()) continue;
+    const pkgName = extractPackageName(String(key));
+    if (!pkgName) continue;
+    applyPatchIfNeeded({
+      targetDir: path.join("node_modules", ...pkgName.split("/")),
+      patchPath: relPatchPath,
+    });
+  }
+}
+
+try {
+  const skip =
+    process.env.NEXUS_SKIP_POSTINSTALL === "1" ||
+    process.env.NEXUS_SKIP_POSTINSTALL === "1" ||
+    process.env.VITEST === "true" ||
+    process.env.NODE_ENV === "test";
+
+  if (!skip) {
+    main();
+  }
+} catch (err) {
+  console.error(String(err));
+  process.exit(1);
+}