@proxysoul/soulforge 2.20.19 → 2.20.20

package/dist/index.js

@@ -72638,7 +72638,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@proxysoul/soulforge",
-    version: "2.20.19",
+    version: "2.20.20",
     description: "Graph-powered code intelligence \u2014 multi-agent coding with codebase-aware AI",
     repository: {
       type: "git",
@@ -73163,6 +73163,11 @@ function getCompatReasoningBody(modelId, config2) {
     if (g)
       effort = g === "off" ? "off" : g;
   }
+  if (provider === "llmgateway") {
+    const l = config2.performance?.llmgatewayReasoningEffort;
+    if (l && l !== "off")
+      effort = l;
+  }
   if (!effort || effort === "off") {
     const e = config2.performance?.effort;
     if (e && e !== "off") {
@@ -101580,6 +101585,269 @@ var init_lifecycle = __esm(() => {
   VERSION_CACHE_TTL = 10 * 60 * 1000;
 });
 
+// src/core/llm/providers/recover-leaked-tool-calls.ts
+function invokeRe() {
+  return /<(?:antml:)?invoke\s+name="([^"]+)"\s*>([\s\S]*?)<\/(?:antml:)?invoke>/g;
+}
+function paramRe() {
+  return /<(?:antml:)?parameter\s+name="([^"]+)"\s*>([\s\S]*?)<\/(?:antml:)?parameter>/g;
+}
+function coerce(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "")
+    return "";
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return raw;
+  }
+}
+function buildArgs(body2) {
+  const args2 = {};
+  for (const m of body2.matchAll(paramRe())) {
+    const name30 = m[1];
+    const raw = m[2];
+    if (name30 === undefined || raw === undefined)
+      continue;
+    args2[name30] = coerce(raw);
+  }
+  return JSON.stringify(args2);
+}
+function makeToolCall(name30, body2) {
+  return {
+    type: "tool-call",
+    toolCallId: `leak_${crypto.randomUUID()}`,
+    toolName: name30,
+    input: buildArgs(body2)
+  };
+}
+function parseInvokeBlock(block, valid) {
+  const calls = [];
+  for (const m of block.matchAll(invokeRe())) {
+    const name30 = m[1];
+    const body2 = m[2];
+    if (name30 === undefined || body2 === undefined || !valid.has(name30))
+      continue;
+    calls.push(makeToolCall(name30, body2));
+  }
+  return calls;
+}
+function validToolNames(params) {
+  const names = new Set;
+  for (const tool4 of params.tools ?? []) {
+    if (tool4.type === "function")
+      names.add(tool4.name);
+  }
+  return names;
+}
+function buildLeakTransform(valid) {
+  let mode = "pass";
+  let tail = "";
+  let capture = "";
+  let textId;
+  let textOpen = false;
+  let sawRealToolCall = false;
+  const recovered = [];
+  const suppressed = [];
+  const emitText = (controller, text2) => {
+    if (!text2)
+      return;
+    if (textOpen && textId) {
+      controller.enqueue({ type: "text-delta", id: textId, delta: text2 });
+    } else {
+      const id = `leak_${crypto.randomUUID()}`;
+      controller.enqueue({ type: "text-start", id });
+      controller.enqueue({ type: "text-delta", id, delta: text2 });
+      controller.enqueue({ type: "text-end", id });
+    }
+  };
+  const holdLen = (buf) => {
+    const lt = buf.lastIndexOf("<");
+    if (lt === -1)
+      return 0;
+    const suffix = buf.slice(lt);
+    for (const lit of SENTINEL_LITERALS) {
+      if (suffix.length < lit.length && lit.startsWith(suffix))
+        return suffix.length;
+    }
+    return 0;
+  };
+  const tryClose = (controller) => {
+    const isWrapper = /^<(?:antml:)?function_calls\b/.test(capture);
+    const closer = isWrapper ? /<\/(?:antml:)?function_calls>/ : /<\/(?:antml:)?invoke>/;
+    const m = closer.exec(capture);
+    if (!m)
+      return null;
+    const end = m.index + m[0].length;
+    const block = capture.slice(0, end);
+    const rest = capture.slice(end);
+    const calls = parseInvokeBlock(block, valid);
+    if (calls.length > 0) {
+      recovered.push(...calls);
+      suppressed.push(block);
+    } else {
+      emitText(controller, block);
+    }
+    mode = "pass";
+    capture = "";
+    return rest;
+  };
+  const pass = (controller, text2) => {
+    let buf = tail + text2;
+    tail = "";
+    while (true) {
+      const m = SENTINEL.exec(buf);
+      if (!m) {
+        const hold = holdLen(buf);
+        emitText(controller, buf.slice(0, buf.length - hold));
+        tail = buf.slice(buf.length - hold);
+        return;
+      }
+      emitText(controller, buf.slice(0, m.index));
+      mode = "capture";
+      capture = buf.slice(m.index);
+      const rest = tryClose(controller);
+      if (rest === null)
+        return;
+      buf = rest;
+    }
+  };
+  const flushPending = (controller) => {
+    if (mode === "capture") {
+      emitText(controller, capture);
+      capture = "";
+      mode = "pass";
+    }
+    if (tail) {
+      emitText(controller, tail);
+      tail = "";
+    }
+  };
+  return new TransformStream({
+    transform(part, controller) {
+      switch (part.type) {
+        case "text-start":
+          textId = part.id;
+          textOpen = true;
+          controller.enqueue(part);
+          return;
+        case "text-delta":
+          if (mode === "capture") {
+            capture += part.delta;
+            const rest = tryClose(controller);
+            if (rest !== null && rest)
+              pass(controller, rest);
+          } else {
+            pass(controller, part.delta);
+          }
+          return;
+        case "text-end":
+          flushPending(controller);
+          controller.enqueue(part);
+          textOpen = false;
+          return;
+        case "tool-call":
+        case "tool-input-start":
+          sawRealToolCall = true;
+          flushPending(controller);
+          if (recovered.length > 0) {
+            emitText(controller, suppressed.join(""));
+            recovered.length = 0;
+            suppressed.length = 0;
+          }
+          controller.enqueue(part);
+          return;
+        case "finish":
+          flushPending(controller);
+          if (recovered.length > 0 && !sawRealToolCall) {
+            for (const call of recovered)
+              controller.enqueue(call);
+            controller.enqueue({
+              ...part,
+              finishReason: { ...part.finishReason, unified: "tool-calls" }
+            });
+          } else {
+            controller.enqueue(part);
+          }
+          return;
+        default:
+          controller.enqueue(part);
+      }
+    }
+  });
+}
+function recoverGenerate(content, valid) {
+  if (content.some((c) => c.type === "tool-call"))
+    return { content, recovered: false };
+  const out2 = [];
+  const calls = [];
+  for (const part of content) {
+    if (part.type !== "text") {
+      out2.push(part);
+      continue;
+    }
+    let cleaned = "";
+    let last = 0;
+    let found = false;
+    for (const m of part.text.matchAll(invokeRe())) {
+      const name30 = m[1];
+      const body2 = m[2];
+      const whole = m[0];
+      const idx = m.index;
+      if (name30 === undefined || body2 === undefined || idx === undefined || !valid.has(name30)) {
+        continue;
+      }
+      found = true;
+      calls.push(makeToolCall(name30, body2));
+      cleaned += part.text.slice(last, idx);
+      last = idx + whole.length;
+    }
+    if (!found) {
+      out2.push(part);
+      continue;
+    }
+    cleaned += part.text.slice(last);
+    cleaned = cleaned.replace(/<\/?(?:antml:)?function_calls>/g, "").trim();
+    if (cleaned.length > 0)
+      out2.push({ ...part, text: cleaned });
+  }
+  if (calls.length === 0)
+    return { content, recovered: false };
+  out2.push(...calls);
+  return { content: out2, recovered: true };
+}
+function recoverLeakedToolCallsMiddleware() {
+  return {
+    specificationVersion: "v3",
+    async wrapStream({ doStream, params }) {
+      const valid = validToolNames(params);
+      const result = await doStream();
+      if (valid.size === 0)
+        return result;
+      return { ...result, stream: result.stream.pipeThrough(buildLeakTransform(valid)) };
+    },
+    async wrapGenerate({ doGenerate, params }) {
+      const valid = validToolNames(params);
+      const result = await doGenerate();
+      if (valid.size === 0)
+        return result;
+      const { content, recovered } = recoverGenerate(result.content, valid);
+      if (!recovered)
+        return result;
+      return {
+        ...result,
+        content,
+        finishReason: { ...result.finishReason, unified: "tool-calls" }
+      };
+    }
+  };
+}
+var SENTINEL, SENTINEL_LITERALS;
+var init_recover_leaked_tool_calls = __esm(() => {
+  SENTINEL = /<(?:antml:)?(?:invoke\b|function_calls\b)/;
+  SENTINEL_LITERALS = ["<invoke", "<function_calls", "<invoke", "<function_calls"];
+});
+
 // node_modules/@msgpack/msgpack/dist/utils/int.js
 var require_int = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -409731,16 +409999,22 @@ var init_addons = __esm(() => {
 function isAnthropicModel(modelId) {
   return modelId.toLowerCase().startsWith("claude");
 }
+function leakRecoveryEnabled() {
+  const v2 = process.env.SOULFORGE_PROXY_TOOL_RECOVERY;
+  return v2 !== "0" && v2 !== "false";
+}
 var baseURL, GPT_55_INPUT_CONTEXT2 = 272000, proxy2;
 var init_proxy2 = __esm(() => {
   init_dist6();
   init_dist8();
+  init_dist5();
   init_config2();
   init_key_resolver();
   init_lifecycle();
   init_compat_reasoning();
   init_context_windows();
   init_reasoning_fetch();
+  init_recover_leaked_tool_calls();
   baseURL = process.env.PROXY_API_URL || "http://127.0.0.1:8317/v1";
   proxy2 = {
     id: "proxy",
@@ -409752,7 +410026,12 @@ var init_proxy2 = __esm(() => {
     createModel(modelId) {
       const apiKey = getActiveProxyApiKey();
       if (isAnthropicModel(modelId)) {
-        return createAnthropic({ baseURL, apiKey, fetch: withSessionHeaders() })(modelId);
+        const model = createAnthropic({
+          baseURL,
+          apiKey,
+          fetch: withSessionHeaders()
+        })(modelId);
+        return leakRecoveryEnabled() ? wrapLanguageModel({ model, middleware: recoverLeakedToolCallsMiddleware() }) : model;
       }
       const reasoningBody = getCompatReasoningBody(`proxy/${modelId}`, loadConfig());
       const reasoningFetch = createSessionFetchWrapper(reasoningBody);
@@ -489406,6 +489685,15 @@ function fuzzyMatch2(pattern, target) {
   }
   if (pi < p4.length)
     return null;
+  const strip = (s2) => s2.startsWith("/") ? s2.slice(1) : s2;
+  const sp = strip(p4);
+  const st2 = strip(t2);
+  if (sp.length > 0 && st2.startsWith(sp)) {
+    score += 100;
+    if (st2.length === sp.length)
+      score += 50;
+    score -= st2.length;
+  }
   return { entry: target, score, indices };
 }
 function fuzzyFilter(pattern, entries2, limit = 50) {
@@ -496741,6 +497029,13 @@ function fuzzyScore3(query2, target) {
       score += 5;
   }
   score -= indices.length > 0 ? indices[0] : 0;
+  const stripped = lower2.startsWith("/") ? lower2.slice(1) : lower2;
+  if (stripped.startsWith(q3)) {
+    score += 100;
+    if (stripped.length === q3.length)
+      score += 50;
+    score -= stripped.length;
+  }
   return { score, indices };
 }
 function OptionRow2({
@@ -498277,7 +498572,7 @@ function getStatusTag(id) {
   return s2.active;
 }
 function fuzzyMatch3(query2, target) {
-  const q3 = query2.toLowerCase();
+  const q3 = query2.toLowerCase().replace(/\s+/g, "");
   const t2 = target.toLowerCase();
   let qi = 0;
   for (let ti = 0;ti < t2.length && qi < q3.length; ti++) {
@@ -510136,6 +510431,8 @@ function readValuesFromLayer(layer) {
     v3.openrouterExcludeReasoning = layer.performance.openrouterExcludeReasoning;
   if (layer.performance?.compatReasoningEffort !== undefined)
     v3.compatReasoningEffort = layer.performance.compatReasoningEffort;
+  if (layer.performance?.llmgatewayReasoningEffort !== undefined)
+    v3.llmgatewayReasoningEffort = layer.performance.llmgatewayReasoningEffort;
   if (layer.performance?.groqReasoningEffort !== undefined)
     v3.groqReasoningEffort = layer.performance.groqReasoningEffort;
   if (layer.performance?.openaiReasoningSummary !== undefined)
@@ -510215,6 +510512,10 @@ function buildPatch(key3, value) {
       return { performance: { openrouterExcludeReasoning: value } };
     case "compatReasoningEffort":
       return { performance: { compatReasoningEffort: value } };
+    case "llmgatewayReasoningEffort":
+      return {
+        performance: { llmgatewayReasoningEffort: value }
+      };
     case "groqReasoningEffort":
       return { performance: { groqReasoningEffort: value } };
     case "openaiReasoningSummary":
@@ -510282,7 +510583,7 @@ function ProviderSettings({
   const popupWidth = Math.min(MAX_POPUP_WIDTH4, Math.floor(termCols * 0.85));
   const maxVisible = Math.max(6, Math.floor(containerRows * 0.85) - CHROME_ROWS6);
   const t2 = useTheme();
-  const [tab, setTab] = import_react153.useState("claude");
+  const [tab, setTab] = import_react153.useState("llmgateway");
   const [cursor3, setCursor] = import_react153.useState(0);
   const [scope, setScope] = import_react153.useState(() => detectInitialScope(projectConfig));
   const vals = effectiveValues(globalConfig2, projectConfig);
@@ -510413,6 +510714,12 @@ function ProviderSettings({
     title: "Provider Options",
     titleIcon: "system",
     tabs: [
+      {
+        id: "llmgateway",
+        label: "LLM Gateway",
+        icon: "cloud",
+        blurb: "unified gateway \xB7 effort \xB7 cache \xB7 web search"
+      },
       { id: "claude", label: "Claude", icon: "ai", blurb: "thinking \xB7 reasoning \xB7 beta" },
       { id: "openai", label: "OpenAI", icon: "ai", blurb: "reasoning \xB7 service tier" },
       { id: "google", label: "Gemini", icon: "ai", blurb: "thinking level \xB7 budget" },
@@ -510459,6 +510766,7 @@ function ProviderSettings({
                 flexDirection: "row",
                 backgroundColor: t2.bgPopup,
                 paddingX: 1,
+                height: 1,
                 children: [
                   /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
                     bg: t2.bgPopup,
@@ -510482,9 +510790,11 @@ function ProviderSettings({
                 flexDirection: "row",
                 backgroundColor: t2.bgPopup,
                 paddingX: 1,
+                height: 1,
                 children: /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
                   bg: t2.bgPopup,
                   fg: t2.textFaint,
+                  truncate: true,
                   children: [
                     "\u2139 ",
                     item.text
@@ -510632,7 +510942,7 @@ function ProviderSettings({
     ]
   }, undefined, true, undefined, this);
 }
-var import_react153, MAX_POPUP_WIDTH4 = 110, CHROME_ROWS6 = 10, TABS6, CLAUDE_ITEMS, OPENAI_ITEMS, GENERAL_ITEMS, GOOGLE_ITEMS, XAI_ITEMS, DEEPSEEK_ITEMS, OPENROUTER_ITEMS, COMPAT_ITEMS, TAB_ITEMS, DEFAULTS, EFFORT_KEY_MODELS;
+var import_react153, MAX_POPUP_WIDTH4 = 110, CHROME_ROWS6 = 10, TABS6, CLAUDE_ITEMS, OPENAI_ITEMS, GENERAL_ITEMS, GOOGLE_ITEMS, XAI_ITEMS, DEEPSEEK_ITEMS, OPENROUTER_ITEMS, LLMGATEWAY_ITEMS, COMPAT_ITEMS, TAB_ITEMS, DEFAULTS, EFFORT_KEY_MODELS;
 var init_ProviderSettings = __esm(async () => {
   init_provider_options();
   init_theme();
@@ -510644,6 +510954,7 @@ var init_ProviderSettings = __esm(async () => {
   ]);
   import_react153 = __toESM(require_react(), 1);
   TABS6 = [
+    "llmgateway",
     "claude",
     "openai",
     "google",
@@ -510890,10 +511201,43 @@ var init_ProviderSettings = __esm(async () => {
       type: "toggle"
     }
   ];
+  LLMGATEWAY_ITEMS = [
+    {
+      type: "info",
+      text: "api.llmgateway.io unified gateway \u2014 one key, every model. Effort emits reasoning_effort for non-Claude SKUs (DeepSeek \xB7 Qwen \xB7 GLM). Claude routes native Anthropic thinking via the Claude tab."
+    },
+    { type: "section", label: "Reasoning" },
+    {
+      key: "llmgatewayReasoningEffort",
+      label: "Effort",
+      desc: "Sent as reasoning_effort in the request body. Overrides the shared Other-tab compat effort when set.",
+      type: "cycle",
+      options: ["off", "low", "medium", "high", "xhigh"]
+    },
+    { type: "section", label: "Prompt caching" },
+    {
+      type: "info",
+      text: "Ephemeral cache TTL for cacheable prefixes (system + tools). Gateway bills cache writes/reads separately."
+    },
+    {
+      key: "cacheTtl",
+      label: "Cache TTL",
+      desc: "5m or 1h ephemeral cache window. Longer TTL costs more to write, cheaper on repeated reads.",
+      type: "cycle",
+      options: ["5m", "1h"]
+    },
+    { type: "section", label: "Tools" },
+    {
+      key: "webSearch",
+      label: "Web search",
+      desc: "Allow models to call the gateway's web_search tool. Billed as web_search_cost per request.",
+      type: "toggle"
+    }
+  ];
   COMPAT_ITEMS = [
     {
       type: "info",
-      text: "Catch-all for providers without their own tab: Groq \xB7 Fireworks \xB7 OpenCode Zen \xB7 OpenCode Go \xB7 LM Studio \xB7 Ollama \xB7 Copilot \xB7 GitHub Models \xB7 MiniMax \xB7 Proxy \xB7 LLM Gateway (non-Claude lane). DeepSeek has its own tab."
+      text: "Catch-all for providers without their own tab: Groq \xB7 Fireworks \xB7 OpenCode Zen \xB7 OpenCode Go \xB7 LM Studio \xB7 Ollama \xB7 Copilot \xB7 GitHub Models \xB7 MiniMax \xB7 Proxy. DeepSeek and LLM Gateway have their own tabs."
     },
     { type: "section", label: "Shared effort" },
     {
@@ -510924,6 +511268,7 @@ var init_ProviderSettings = __esm(async () => {
     }
   ];
   TAB_ITEMS = {
+    llmgateway: LLMGATEWAY_ITEMS,
     claude: CLAUDE_ITEMS,
     openai: OPENAI_ITEMS,
     google: GOOGLE_ITEMS,
@@ -510961,6 +511306,7 @@ var init_ProviderSettings = __esm(async () => {
     openrouterReasoningMaxTokens: "off",
     openrouterExcludeReasoning: false,
     compatReasoningEffort: "off",
+    llmgatewayReasoningEffort: "off",
     groqReasoningEffort: "off",
     openaiReasoningSummary: "off",
     openaiVerbosity: "off",
@@ -510972,7 +511318,8 @@ var init_ProviderSettings = __esm(async () => {
     deepseekReasoningEffort: () => "deepseek/deepseek-v4-pro",
     openaiReasoningEffort: () => "openai/gpt-5",
     xaiReasoningEffort: () => "xai/grok-4",
-    googleThinkingLevel: () => "google/gemini-3-pro"
+    googleThinkingLevel: () => "google/gemini-3-pro",
+    llmgatewayReasoningEffort: (m6) => `llmgateway/${m6.split("/").pop() ?? m6}`
   };
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proxysoul/soulforge",
-  "version": "2.20.19",
+  "version": "2.20.20",
   "description": "Graph-powered code intelligence — multi-agent coding with codebase-aware AI",
   "repository": {
     "type": "git",