@vtstech/pi-react-fallback 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtstech/pi-react-fallback",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "ReAct fallback extension for Pi Coding Agent",
   "main": "react-fallback.js",
   "keywords": ["pi-extensions"],
@@ -14,7 +14,7 @@
     "url": "https://github.com/VTSTech/pi-coding-agent"
   },
   "dependencies": {
-    "@vtstech/pi-shared": "1.0.7"
+    "@vtstech/pi-shared": "1.0.9"
   },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": ">=0.66"

package/react-fallback.js

@@ -1,4 +1,7 @@
 // .build-npm/react-fallback/react-fallback.temp.ts
+import os from "node:os";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { section, ok, fail, warn, info } from "@vtstech/pi-shared/format";
 function sanitizeModelJson(text) {
   text = text.replace(/:\s*True\b/g, ": true");
@@ -12,12 +15,72 @@ function sanitizeModelJson(text) {
   text = text.replace(/\\\\\\\\/g, "\\\\");
   return text;
 }
-var THOUGHT_RE = /Thought:\s*(.*?)(?=Action:|Final Answer:|$)/is;
-var ACTION_RE = /Action:\s*[`"']?(\w+)[`"']?\s*\n?\s*Action Input:\s*(.*?)(?=\n\s*(?:Observation:|Thought:|Final Answer:|Action:)|$)/is;
-var ACTION_RE_SAMELINE = /Action:\s*[`"']?(\w+)[`"']?\s+Action Input:\s*(.*?)(?=\n\s*(?:Observation:|Thought:|Final Answer:)|$)/is;
-var ACTION_RE_LOOSE = /Action:\s*(.+?)\n\s*Action Input:\s*(.*?)(?=\n\s*(?:Observation:|Thought:|Final Answer:|Action:)|$)/is;
-var ACTION_RE_PAREN = /Action:\s*(\w+)\s*\(([^)]*)\)/i;
-var FINAL_ANSWER_RE = /Final Answer:\s*([\s\S]*?)$/i;
+var REACT_DIALECTS = [
+  {
+    name: "react",
+    actionTag: "Action:",
+    inputTag: "Action Input:",
+    thoughtTag: "Thought:",
+    stopTags: ["Observation:", "Thought:", "Final Answer:", "Action:"],
+    finalTag: "Final Answer:"
+  },
+  {
+    name: "function",
+    actionTag: "Function:",
+    inputTag: "Function Input:",
+    thoughtTag: "Thought:",
+    stopTags: ["Observation:", "Thought:", "Final Answer:", "Function:", "Action:"],
+    finalTag: "Final Answer:"
+  },
+  {
+    name: "tool",
+    actionTag: "Tool:",
+    inputTag: "Tool Input:",
+    thoughtTag: "Thought:",
+    stopTags: ["Observation:", "Thought:", "Final Answer:", "Tool:", "Action:"],
+    finalTag: "Final Answer:"
+  },
+  {
+    name: "call",
+    actionTag: "Call:",
+    inputTag: "Input:",
+    thoughtTag: "Thought:",
+    stopTags: ["Observation:", "Thought:", "Final Answer:", "Call:", "Action:"],
+    finalTag: "Final Answer:"
+  }
+];
+function buildDialectPatterns(d) {
+  const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const aT = esc(d.actionTag);
+  const iT = esc(d.inputTag);
+  const stopAlt = d.stopTags.map(esc).join("|");
+  const tT = d.thoughtTag ? esc(d.thoughtTag) : void 0;
+  const fT = d.finalTag ? esc(d.finalTag) : void 0;
+  const thoughtRe = tT ? new RegExp(`${tT}\\s*(.*?)(?=${aT}|${fT}|$)`, "is") : void 0;
+  const actionRe = new RegExp(
+    `${aT}\\s*[\\x60"']?(\\w+)[\\x60"']?\\s*\\n?\\s*${iT}\\s*(.*?)(?=\\n\\s*(?:${stopAlt})|$)`,
+    "is"
+  );
+  const actionReSameline = new RegExp(
+    `${aT}\\s*[\\x60"']?(\\w+)[\\x60"']?\\s+${iT}\\s*(.*?)(?=\\n\\s*(?:${stopAlt})|$)`,
+    "is"
+  );
+  const actionReLoose = new RegExp(
+    `${aT}\\s*(.+?)\\n\\s*${iT}\\s*(.*?)(?=\\n\\s*(?:${stopAlt})|$)`,
+    "is"
+  );
+  const actionReParen = new RegExp(`${aT}\\s*(\\w+)\\s*\\(([^)]*)\\)`, "i");
+  const finalAnswerRe = fT ? new RegExp(`${fT}\\s*([\\s\\S]*?)$`, "i") : void 0;
+  return { thoughtRe, actionRe, actionReSameline, actionReLoose, actionReParen, finalAnswerRe, dialect: d };
+}
+var ALL_DIALECT_PATTERNS = REACT_DIALECTS.map(buildDialectPatterns);
+var CLASSIC_PATTERNS = ALL_DIALECT_PATTERNS[0];
+var THOUGHT_RE = CLASSIC_PATTERNS.thoughtRe;
+var ACTION_RE = CLASSIC_PATTERNS.actionRe;
+var ACTION_RE_SAMELINE = CLASSIC_PATTERNS.actionReSameline;
+var ACTION_RE_LOOSE = CLASSIC_PATTERNS.actionReLoose;
+var ACTION_RE_PAREN = CLASSIC_PATTERNS.actionReParen;
+var FINAL_ANSWER_RE = CLASSIC_PATTERNS.finalAnswerRe;
 function extractJsonArgs(rawArgs) {
   const start = rawArgs.indexOf("{");
   if (start === -1) return null;
@@ -53,18 +116,43 @@ function extractJsonArgs(rawArgs) {
   return { input: jsonStr };
 }
 function parseReact(text) {
+  for (const dp of ALL_DIALECT_PATTERNS) {
+    const result = parseReactWithPatterns(text, dp);
+    if (result) return result;
+  }
+  return null;
+}
+function parseReactWithPatterns(text, dp, tightLoose = false) {
   let thought;
-  const thoughtMatch = THOUGHT_RE.exec(text);
-  if (thoughtMatch) thought = thoughtMatch[1].trim();
-  let match = ACTION_RE.exec(text);
-  if (!match) match = ACTION_RE_SAMELINE.exec(text);
+  if (dp.thoughtRe) {
+    const thoughtMatch = dp.thoughtRe.exec(text);
+    if (thoughtMatch) thought = thoughtMatch[1].trim();
+  }
+  let match = dp.actionRe.exec(text);
+  if (!match) match = dp.actionReSameline.exec(text);
   let looseMatch = false;
-  if (!match) match = ACTION_RE_LOOSE.exec(text), looseMatch = true;
+  if (!match) {
+    const looseResult = dp.actionReLoose.exec(text);
+    if (looseResult) {
+      if (tightLoose) {
+        const candidate = looseResult[1].trim().replace(/[`"']/g, "");
+        const isToolIdentifier = /^\w+$/.test(candidate) && (candidate.includes("_") || candidate.includes("-"));
+        const isKnownTool = /^(get_weather|calculate)$/i.test(candidate);
+        if (isToolIdentifier || isKnownTool) {
+          match = looseResult;
+          looseMatch = true;
+        }
+      } else {
+        match = looseResult;
+        looseMatch = true;
+      }
+    }
+  }
   let parenMatch = false;
-  if (!match) match = ACTION_RE_PAREN.exec(text), parenMatch = true;
+  if (!match) match = dp.actionReParen.exec(text), parenMatch = true;
   if (match) {
     let toolName = match[1].trim().replace(/[`"']/g, "");
-    if (looseMatch && pi.context?.session?.tools) {
+    if (looseMatch && !tightLoose && pi.context?.session?.tools) {
       const availableTools = pi.context.session.tools || [];
       for (const real of availableTools) {
         const rl = real.toLowerCase().replace(/_/g, "");
@@ -112,9 +200,18 @@ function parseReact(text) {
       args = extractJsonArgs(rawArgs) || { input: rawArgs };
     }
     let finalAnswer;
-    const faMatch = FINAL_ANSWER_RE.exec(text);
-    if (faMatch) finalAnswer = faMatch[1].trim();
-    return { name: toolName, args, thought, finalAnswer, raw: match[0] };
+    if (dp.finalAnswerRe) {
+      const faMatch = dp.finalAnswerRe.exec(text);
+      if (faMatch) finalAnswer = faMatch[1].trim();
+    }
+    return { name: toolName, args, thought, finalAnswer, raw: match[0], dialect: dp.dialect.name };
+  }
+  return null;
+}
+function detectReactDialect(text) {
+  for (const dp of ALL_DIALECT_PATTERNS) {
+    const tagPattern = new RegExp(`^\\s*${dp.dialect.actionTag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*`, "im");
+    if (tagPattern.test(text)) return dp.dialect;
   }
   return null;
 }
@@ -273,82 +370,103 @@ function looksLikeSchemaDump(text) {
   const matches = indicators.filter((i) => lower.includes(i.toLowerCase())).length;
   return matches >= 2;
 }
+var REACT_CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "react-mode.json");
+function readReactConfig() {
+  try {
+    if (fs.existsSync(REACT_CONFIG_PATH)) {
+      const raw = JSON.parse(fs.readFileSync(REACT_CONFIG_PATH, "utf-8"));
+      if (typeof raw.enabled === "boolean") return raw;
+    }
+  } catch {
+  }
+  return { enabled: false };
+}
+function writeReactConfig(config) {
+  const dir = path.dirname(REACT_CONFIG_PATH);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(REACT_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
 function react_fallback_temp_default(pi2) {
-  let reactModeEnabled = false;
+  let reactModeEnabled = readReactConfig().enabled;
   let stats = { bridgeCalls: 0, fuzzyMatches: 0, argNormalizations: 0, parseFailures: 0 };
   const branding = [
-    `  \u26A1 Pi ReAct Fallback Extension v1.0.7`,
+    `  \u26A1 Pi ReAct Fallback Extension v1.0.9`,
     `  Written by VTSTech`,
     `  GitHub: https://github.com/VTSTech`,
     `  Website: www.vts-tech.org`
   ].join("\n");
-  pi2.registerTool({
-    name: "tool_call",
-    label: "Universal Tool Call",
-    description: `Universal tool call bridge. Use this to call any available tool by specifying its name and arguments as JSON.
+  function registerBridgeTool() {
+    pi2.registerTool({
+      name: "tool_call",
+      label: "Universal Tool Call",
+      description: `Universal tool call bridge. Use this to call any available tool by specifying its name and arguments as JSON.
 
 To use: call tool_call with:
 - name: the exact tool name (e.g. "bash", "read", "write", "edit")
 - arguments: a JSON string of the tool's arguments (e.g. '{"command": "ls -la"}')
 
 The bridge will match your tool name (fuzzy matching supported) and normalize argument names automatically.`,
-    promptSnippet: "tool_call - universal bridge for calling any tool",
-    promptGuidelines: [
-      "When you need to use a tool but are unsure of the exact name, use tool_call with the tool name and arguments.",
-      `Example: tool_call(name='bash', arguments='{"command": "ls -la"}')`
-    ],
-    parameters: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: "Name of the tool to call (fuzzy matching supported)" },
-        arguments: { type: "string", description: "Tool arguments as a JSON object string" }
+      promptSnippet: "tool_call - universal bridge for calling any tool",
+      promptGuidelines: [
+        "When you need to use a tool but are unsure of the exact name, use tool_call with the tool name and arguments.",
+        `Example: tool_call(name='bash', arguments='{"command": "ls -la"}')`
+      ],
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Name of the tool to call (fuzzy matching supported)" },
+          arguments: { type: "string", description: "Tool arguments as a JSON object string" }
+        },
+        required: ["name", "arguments"]
       },
-      required: ["name", "arguments"]
-    },
-    execute: async (toolCallId, params, signal, onUpdate, ctx) => {
-      const p = params;
-      const requestedName = p.name || "";
-      const argsStr = p.arguments || "{}";
-      stats.bridgeCalls++;
-      let args;
-      try {
-        args = JSON.parse(argsStr);
-        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+      execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+        const p = params;
+        const requestedName = p.name || "";
+        const argsStr = p.arguments || "{}";
+        stats.bridgeCalls++;
+        let args;
+        try {
+          args = JSON.parse(argsStr);
+          if (typeof args !== "object" || args === null || Array.isArray(args)) {
+            args = { input: argsStr };
+          }
+        } catch {
           args = { input: argsStr };
         }
-      } catch {
-        args = { input: argsStr };
-      }
-      const allTools = pi2.getAllTools();
-      let targetToolName = null;
-      if (allTools.includes(requestedName)) {
-        targetToolName = requestedName;
-      } else {
-        targetToolName = fuzzyMatchToolName(requestedName, allTools);
-        if (targetToolName) stats.fuzzyMatches++;
-      }
-      if (!targetToolName) {
-        stats.parseFailures++;
+        const allTools = pi2.getAllTools();
+        let targetToolName = null;
+        if (allTools.includes(requestedName)) {
+          targetToolName = requestedName;
+        } else {
+          targetToolName = fuzzyMatchToolName(requestedName, allTools);
+          if (targetToolName) stats.fuzzyMatches++;
+        }
+        if (!targetToolName) {
+          stats.parseFailures++;
+          return {
+            content: [{ type: "text", text: `Error: Unknown tool "${requestedName}". Available tools: ${allTools.join(", ")}` }],
+            isError: true
+          };
+        }
+        const normalizedArgs = Object.keys(args).length > 0 ? args : {};
+        stats.argNormalizations++;
+        const argsJson = JSON.stringify(normalizedArgs);
         return {
-          content: [{ type: "text", text: `Error: Unknown tool "${requestedName}". Available tools: ${allTools.join(", ")}` }],
-          isError: true
-        };
-      }
-      const normalizedArgs = Object.keys(args).length > 0 ? args : {};
-      stats.argNormalizations++;
-      const argsJson = JSON.stringify(normalizedArgs);
-      return {
-        content: [{
-          type: "text",
-          text: `[ReAct Bridge] Tool resolved: ${requestedName} \u2192 ${targetToolName}${targetToolName !== requestedName ? " (fuzzy matched)" : ""}
+          content: [{
+            type: "text",
+            text: `[ReAct Bridge] Tool resolved: ${requestedName} \u2192 ${targetToolName}${targetToolName !== requestedName ? " (fuzzy matched)" : ""}
 
 Please call ${targetToolName} with these arguments:
 ${argsJson}`
-        }],
-        isError: false
-      };
-    }
-  });
+          }],
+          isError: false
+        };
+      }
+    });
+  }
+  if (reactModeEnabled) {
+    registerBridgeTool();
+  }
   pi2.on("context", (event) => {
     if (!reactModeEnabled) return;
     const model = event.messages;
@@ -367,18 +485,25 @@ ${argsJson}`
     description: "Toggle ReAct fallback mode for models without native tool calling",
     handler: async (_args, ctx) => {
       reactModeEnabled = !reactModeEnabled;
+      writeReactConfig({ enabled: reactModeEnabled });
       const status = reactModeEnabled ? "ENABLED" : "DISABLED";
       ctx.ui.notify(`ReAct mode ${status}`, "success");
       const lines = [branding];
       lines.push(section("REACT FALLBACK MODE"));
       lines.push(info(`Status: ${status}`));
+      lines.push(info(`Config: ${REACT_CONFIG_PATH}`));
       lines.push(info(`Bridge calls: ${stats.bridgeCalls}`));
       lines.push(info(`Fuzzy matches: ${stats.fuzzyMatches}`));
       lines.push(info(`Argument normalizations: ${stats.argNormalizations}`));
       lines.push(info(`Parse failures: ${stats.parseFailures}`));
       if (reactModeEnabled) {
+        registerBridgeTool();
         lines.push(ok("The tool_call bridge tool is now available to the model"));
         lines.push(info("ReAct system prompt instructions have been added"));
+        lines.push(info("Run /reload to make the bridge tool available to the current model"));
+      } else {
+        lines.push(warn("The tool_call bridge tool has been unregistered"));
+        lines.push(info("Run /reload to remove the tool from the current model"));
       }
       const report = lines.join("\n");
       pi2.sendMessage({
@@ -399,15 +524,23 @@ ${argsJson}`
       const lines = [branding];
       lines.push(section("REACT PARSER TEST"));
       lines.push(info(`Input: ${text.slice(0, 100)}${text.length > 100 ? "..." : ""}`));
+      const detectedDialect = detectReactDialect(text);
       const reactResult = parseReact(text);
       if (reactResult) {
-        lines.push(ok("ReAct format detected!"));
+        lines.push(ok(`ReAct format detected! (dialect: ${reactResult.dialect || "react"})`));
         lines.push(info(`Tool: ${reactResult.name}`));
         lines.push(info(`Args: ${JSON.stringify(reactResult.args)}`));
         if (reactResult.thought) lines.push(info(`Thought: ${reactResult.thought}`));
         if (reactResult.finalAnswer) lines.push(info(`Final Answer: ${reactResult.finalAnswer}`));
       } else {
-        lines.push(fail("No ReAct format detected"));
+        if (detectedDialect) {
+          lines.push(warn(`Dialect tag "${detectedDialect.actionTag}" detected but no valid tool call parsed`));
+        } else {
+          lines.push(fail("No ReAct format detected"));
+        }
+      }
+      if (detectedDialect && detectedDialect.name !== "react") {
+        lines.push(info(`Detected dialect: ${detectedDialect.name} (${detectedDialect.actionTag} / ${detectedDialect.inputTag})`));
       }
       try {
         const firstBrace = text.indexOf("{");
@@ -442,13 +575,18 @@ ${argsJson}`
   });
   pi2._reactParser = {
     parseReact,
+    parseReactWithPatterns,
+    detectReactDialect,
     sanitizeModelJson,
     extractToolFromJson,
     fuzzyMatchToolName,
     normalizeArguments,
-    looksLikeSchemaDump
+    looksLikeSchemaDump,
+    REACT_DIALECTS,
+    ALL_DIALECT_PATTERNS
   };
 }
 export {
-  react_fallback_temp_default as default
+  react_fallback_temp_default as default,
+  detectReactDialect
 };