multiarena 0.1.0 → 0.1.3

package/dist/provider/adapters/openai.js

@@ -1,6 +1,60 @@
 import OpenAI from "openai";
 const DEFAULT_MODEL = "gpt-4o";
 const DEFAULT_TIMEOUT_MS = 120_000;
+/**
+ * Filter think blocks from reasoning model output (DeepSeek-R1, MiniMax).
+ * Returns the text that should be yielded to the user, and updates state.
+ * Callers yield the returned text and replace their state with the returned state.
+ */
+export function filterThinkText(deltaText, state) {
+    let text = deltaText;
+    let { inThink, buf } = state;
+    if (inThink) {
+        buf += text;
+        const endIdx = buf.indexOf("</think>");
+        if (endIdx !== -1) {
+            inThink = false;
+            text = buf.slice(endIdx + "</think>".length);
+            buf = "";
+            if (!text)
+                return { text: "", state: { inThink, buf } };
+        }
+        else {
+            return { text: "", state: { inThink: true, buf } };
+        }
+    }
+    // Check for <think> opening tag
+    const startIdx = text.indexOf("<think>");
+    if (startIdx !== -1) {
+        const before = text.slice(0, startIdx);
+        const rest = text.slice(startIdx + "<think>".length);
+        const endIdx = rest.indexOf("</think>");
+        if (endIdx !== -1) {
+            // Complete think block in this chunk
+            const after = rest.slice(endIdx + "</think>".length);
+            text = before + after;
+            if (!text)
+                return { text: "", state: { inThink, buf } };
+        }
+        else {
+            // Think block spans chunks
+            if (before)
+                return { text: before, state: { inThink: true, buf: rest } };
+            return { text: "", state: { inThink: true, buf: rest } };
+        }
+    }
+    return { text, state: { inThink, buf } };
+}
+/** Called when the stream ends (finish_reason = stop). Flush any buffered think content. */
+export function flushThinkBuf(state) {
+    if (!state.inThink || !state.buf)
+        return "";
+    const endIdx = state.buf.indexOf("</think>");
+    if (endIdx !== -1) {
+        return state.buf.slice(endIdx + "</think>".length);
+    }
+    return "";
+}
 export class OpenAIProvider {
     client;
     activeController = null;
@@ -20,11 +74,11 @@ export class OpenAIProvider {
                 stream: true,
                 stream_options: { include_usage: true },
             }, { signal: abortController.signal });
-            // Track pending tool calls across stream chunks
             const pendingToolCalls = new Map();
             let doneYielded = false;
+            // Stateful think-tag filter for reasoning models (e.g. MiniMax, DeepSeek-R1)
+            let thinkState = { inThink: false, buf: "" };
             for await (const chunk of stream) {
-                // Token usage chunk (when stream_options.include_usage is true)
                 if (chunk.usage) {
                     inputTokens = chunk.usage.prompt_tokens;
                     outputTokens = chunk.usage.completion_tokens;
@@ -34,7 +88,6 @@ export class OpenAIProvider {
                 if (!choice)
                     continue;
                 const delta = choice.delta;
-                // Accumulate tool call deltas
                 if (delta.tool_calls) {
                     for (const tc of delta.tool_calls) {
                         const idx = tc.index;
@@ -52,11 +105,14 @@ export class OpenAIProvider {
                         pendingToolCalls.set(idx, existing);
                     }
                 }
-                // Text delta
+                // Text delta with think-tag filtering (for reasoning models)
                 if (delta.content) {
-                    yield { type: "text", content: delta.content };
+                    const result = filterThinkText(delta.content, thinkState);
+                    thinkState = result.state;
+                    if (result.text) {
+                        yield { type: "text", content: result.text };
+                    }
                 }
-                // On finish_reason === "tool_calls", emit all pending tool_calls
                 if (choice.finish_reason === "tool_calls") {
                     for (const [, tc] of pendingToolCalls) {
                         yield {
@@ -73,8 +129,12 @@ export class OpenAIProvider {
                     };
                     doneYielded = true;
                 }
-                // handle stop
                 if (choice.finish_reason === "stop") {
+                    // Flush any remaining think buffer
+                    const flushed = flushThinkBuf(thinkState);
+                    if (flushed)
+                        yield { type: "text", content: flushed };
+                    thinkState = { inThink: false, buf: "" };
                     yield {
                         type: "done",
                         usage: { input: inputTokens, output: outputTokens },
@@ -82,7 +142,6 @@ export class OpenAIProvider {
                     doneYielded = true;
                 }
             }
-            // Ensure done is always yielded (e.g. when stream ends on usage chunk)
             if (!doneYielded) {
                 yield {
                     type: "done",

package/dist/provider/provider.js

@@ -15,6 +15,10 @@ export function createProvider(config) {
             const baseURL = config.endpoint?.replace(/\/v1\/?$/, "") ?? "http://localhost:11434";
             return new OllamaProvider(baseURL);
         }
+        case "deepseek":
+            return new OpenAIProvider(key, config.endpoint ?? "https://api.deepseek.com/v1");
+        case "minimax":
+            return new OpenAIProvider(key, config.endpoint ?? "https://api.minimax.chat/v1");
         default:
             throw new Error(`Unknown provider: ${config.provider}`);
     }

package/dist/tools/builtin/bash.js

@@ -13,6 +13,9 @@ export const bashTool = {
     },
     async execute(args, worktreePath) {
         const command = args.command;
+        if (!command || command.trim() === "") {
+            return "Error: no command provided";
+        }
         const dangerous = ["rm -rf /", "sudo ", "mkfs.", "dd if=", "> /dev/sda"];
         for (const d of dangerous) {
             if (command.includes(d))
@@ -24,11 +27,13 @@ export const bashTool = {
                 encoding: "utf-8",
                 timeout: 30000,
                 maxBuffer: 1024 * 1024,
+                shell: "bash",
             });
             return output || "(no output)";
         }
         catch (err) {
-            return `Command failed (exit ${err.status}): ${err.stderr ?? err.message}`;
+            const detail = (err.stderr || err.message || "unknown error").trim();
+            return `Command failed (exit ${err.status ?? "?"}): ${detail}\n[cmd] ${command}`;
         }
     },
 };