@burtson-labs/bandit-engine 2.0.71 → 2.0.72

package/dist/index.js

@@ -21306,41 +21306,38 @@ _This link is temporary and expires in about ${mins} minutes._`;
                     try {
                       const toolResultsText = summarizableResults.map((r) => `## ${r.name}
 ${r.output}`).join("\n\n");
-                      const summaryMessages = [
-                        { role: "system", content: systemPromptForSummary },
+                      const MAX_CHAIN_ROUNDS = 4;
+                      const enabledToolsForChain = getEnabledMCPToolsForAI();
+                      const convo = [
+                        { role: "system", content: enhancedSystemPrompt },
                         ...contextMessages,
                         { role: "user", content: question },
-                        { role: "assistant", content: stripToolBlocks(fullMessage) || "Let me look that up." },
+                        { role: "assistant", content: stripToolBlocks(fullMessage) || "Let me work on that." },
                         {
                           role: "user",
-                          content: `I ran the tool(s) you requested. Here are the raw results:
+                          content: `Here are the results of the tool(s) so far:
 
 ${toolResultsText}
 
-Using these results together with your own knowledge, answer my original question concisely and in a natural, well-formatted way. Do NOT add a "Sources", "References", or "Citations" list of any kind \u2014 not names and not URLs. A clean, clickable Sources section is appended automatically below your answer, so any list you add just duplicates it. (Mentioning a source naturally inside a sentence is fine; a trailing list is not.) Do NOT output tool_code or call any tools again.`
+Use them to fully complete my original request. If you still need to take an action I asked for (for example, actually create a file I want to download), call the appropriate tool now with a \`\`\`tool_code\`\`\` block. Otherwise give your final answer. Do NOT add a "Sources"/"References"/"Citations" list \u2014 one is appended automatically.`
                         }
                       ];
-                      const summaryRequest = {
-                        model: modelName,
-                        messages: summaryMessages,
-                        stream: true,
-                        options: { num_predict: tokenLimit + 250 }
-                      };
-                      clearFlushTimer();
-                      setStreamBuffer("");
-                      setIsThinking?.(true);
-                      const summaryText = await new Promise((resolve) => {
+                      const streamTurn = (req) => new Promise((resolve) => {
                         let acc = "";
+                        const native = [];
                         let settled = false;
                         let timer;
-                        const done = (value) => {
+                        const finish = (value) => {
                           if (settled) return;
                           settled = true;
                           if (timer) clearTimeout(timer);
                           resolve(value);
                         };
-                        const summarySub = provider.chat(summaryRequest).subscribe({
+                        const sub2 = provider.chat(req).subscribe({
                           next: (data) => {
+                            if (Array.isArray(data?.message?.tool_calls) && data.message.tool_calls.length) {
+                              native.push(...data.message.tool_calls);
+                            }
                             if (data?.message?.content) {
                               acc += data.message.content;
                               const visible = stripThinking(acc);
@@ -21350,27 +21347,125 @@ Using these results together with your own knowledge, answer my original questio
                               setStreamBuffer(visible);
                             }
                           },
-                          error: (summaryErr) => {
-                            debugLogger.error("Summarization pass failed", {
-                              error: summaryErr instanceof Error ? summaryErr.message : String(summaryErr)
-                            });
-                            done("");
-                          },
-                          complete: () => done(stripThinking(acc).trim())
+                          error: () => finish({ text: stripThinking(acc).trim(), native }),
+                          complete: () => finish({ text: stripThinking(acc).trim(), native })
                         });
-                        currentSubRef.current = summarySub;
+                        currentSubRef.current = sub2;
                         timer = setTimeout(() => {
-                          debugLogger.warn("Summarization pass timed out; using inline tool output");
                           try {
-                            summarySub.unsubscribe();
+                            sub2.unsubscribe();
                           } catch {
                           }
-                          done("");
+                          finish({ text: stripThinking(acc).trim(), native });
                         }, 3e4);
                       });
+                      const runChainedTool = async (fn, params) => {
+                        if (fn === "ask_user" || fn === "ask-user") {
+                          const qs = parseAskUserQuestions(params.questions ?? params);
+                          if (!qs.length) return "ask_user failed: it needs a questions array.";
+                          const ans = await useAskUserStore.getState().ask(qs);
+                          return ans ? "The user answered:\n\n" + qs.map((q) => `Q: ${q.question}
+A: ${(ans[q.id] || "").trim() || "(no answer)"}`).join("\n\n") : "The user dismissed the question(s). Proceed with your best judgment.";
+                        }
+                        const status = fn === "create_file" || fn === "create-file" ? "Creating the file\u2026" : fn === "web_search" || fn === "web-search" ? "Searching the web\u2026" : fn === "web_fetch" || fn === "web-fetch" ? "Reading the page\u2026" : fn === "image_generation" || fn === "image-generation" ? "Generating the image\u2026" : "Working on it\u2026";
+                        setStreamBuffer(`_${status}_`);
+                        const result = await executeMCPTool({ toolName: fn, parameters: params });
+                        if (!result.success) return `That step failed: ${result.error || "unknown error"}.`;
+                        if (fn === "create_file" || fn === "create-file") {
+                          const f = result.data ?? {};
+                          if (f.url) {
+                            const mins = f.expiresInMinutes ?? 60;
+                            const name = f.filename || "your file";
+                            inlineImageBlocks.push(`\u{1F4C4} **[${name}](${f.url})** \u2014 ready to download.
+
+_This link is temporary and expires in about ${mins} minutes._`);
+                            return `File created and its download link is now shown to the user. Briefly confirm it's ready and that it expires in ~${mins} minutes.`;
+                          }
+                          return "The file was created.";
+                        }
+                        if (fn === "image_generation" || fn === "image-generation") {
+                          const img = result.data ?? {};
+                          if (img.imageUrl) {
+                            inlineImageBlocks.push(`![Generated image](${img.imageUrl})`);
+                            return "Image generated and shown to the user.";
+                          }
+                        }
+                        if (typeof result.data === "string") return result.data.slice(0, 2e3);
+                        if (result.data) return JSON.stringify(result.data).slice(0, 1500);
+                        return "Done.";
+                      };
+                      clearFlushTimer();
+                      let finalText = "";
+                      let lastTurnText = "";
+                      for (let round = 0; round < MAX_CHAIN_ROUNDS; round++) {
+                        setStreamBuffer("");
+                        setIsThinking?.(true);
+                        const turnRequest = {
+                          model: modelName,
+                          messages: convo,
+                          stream: true,
+                          tools: enabledToolsForChain.length ? enabledToolsForChain : void 0,
+                          options: { num_predict: tokenLimit + 250 }
+                        };
+                        const { text: turnText, native: turnNative } = await streamTurn(turnRequest);
+                        setIsThinking?.(false);
+                        if (turnText.trim()) lastTurnText = turnText;
+                        let toolText = turnText;
+                        if (turnNative.length && !/```(?:tool_code|TOOL_CODE)/.test(toolText)) {
+                          for (const raw of turnNative) {
+                            const tc = raw;
+                            const fnName = tc.function?.name ?? tc.name;
+                            if (!fnName) continue;
+                            const a = tc.function?.arguments ?? tc.arguments ?? {};
+                            toolText += `
+
+\`\`\`tool_code
+${fnName}(${typeof a === "string" ? a : JSON.stringify(a ?? {})})
+\`\`\``;
+                          }
+                        }
+                        const chainMatches = toolText.match(/```(?:tool_code|TOOL_CODE)\s*\n([^`]+)\n```/gi);
+                        if (!chainMatches || !chainMatches.length) {
+                          finalText = turnText;
+                          break;
+                        }
+                        const roundOut = [];
+                        for (const m of chainMatches) {
+                          const code = m.replace(/```(?:tool_code|TOOL_CODE)\s*\n|\n```/gi, "").trim();
+                          const fm = code.match(/^(\w+)\(\s*(.*?)\s*\)$/);
+                          if (!fm) continue;
+                          const [, fnName, rawParams] = fm;
+                          let parsed = {};
+                          const rp = rawParams.trim();
+                          if (rp) {
+                            try {
+                              parsed = JSON.parse(rp.startsWith("{") ? rp : `{${rp}}`);
+                            } catch {
+                              parsed = {};
+                            }
+                          }
+                          try {
+                            roundOut.push(`## ${fnName}
+${await runChainedTool(fnName, parsed)}`);
+                          } catch (e) {
+                            roundOut.push(`## ${fnName}
+That step failed: ${e instanceof Error ? e.message : String(e)}`);
+                          }
+                        }
+                        convo.push({ role: "assistant", content: stripToolBlocks(turnText) || "(using a tool)" });
+                        convo.push({
+                          role: "user",
+                          content: `Tool results:
+
+${roundOut.join("\n\n")}
+
+Now give your final answer to my original request, or call another tool if you still genuinely need to. Do NOT add a "Sources" list.`
+                        });
+                      }
                       setIsThinking?.(false);
-                      if (summaryText.trim()) {
-                        const cleanedSummary = summaryText.replace(
+                      const answerText = finalText.trim() ? finalText : lastTurnText;
+                      if (answerText.trim() || inlineImageBlocks.length) {
+                        const cleanedSummary = answerText.replace(
                           /\n{1,}\s*(?:[*_#>\s]*)(?:sources?|references?|citations?|further reading)(?:\s*:)?\s*(?:[*_]*)\s*\n[\s\S]*$/i,
                           ""
                         ).trimEnd();