multiarena 0.1.1 → 0.1.4

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;
@@ -23,8 +77,7 @@ export class OpenAIProvider {
             const pendingToolCalls = new Map();
             let doneYielded = false;
             // Stateful think-tag filter for reasoning models (e.g. MiniMax, DeepSeek-R1)
-            let inThink = false;
-            let thinkBuf = "";
+            let thinkState = { inThink: false, buf: "" };
             for await (const chunk of stream) {
                 if (chunk.usage) {
                     inputTokens = chunk.usage.prompt_tokens;
@@ -54,44 +107,11 @@ export class OpenAIProvider {
                 }
                 // Text delta with think-tag filtering (for reasoning models)
                 if (delta.content) {
-                    let text = delta.content;
-                    if (inThink) {
-                        thinkBuf += text;
-                        const endIdx = thinkBuf.indexOf("</think>");
-                        if (endIdx !== -1) {
-                            inThink = false;
-                            text = thinkBuf.slice(endIdx + "</think>".length);
-                            thinkBuf = "";
-                            if (!text)
-                                continue;
-                        }
-                        else {
-                            continue;
-                        }
+                    const result = filterThinkText(delta.content, thinkState);
+                    thinkState = result.state;
+                    if (result.text) {
+                        yield { type: "text", content: result.text };
                     }
-                    // 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)
-                                continue;
-                        }
-                        else {
-                            // Think block spans chunks
-                            if (before)
-                                yield { type: "text", content: before };
-                            inThink = true;
-                            thinkBuf = rest;
-                            continue;
-                        }
-                    }
-                    yield { type: "text", content: text };
                 }
                 if (choice.finish_reason === "tool_calls") {
                     for (const [, tc] of pendingToolCalls) {
@@ -111,16 +131,10 @@ export class OpenAIProvider {
                 }
                 if (choice.finish_reason === "stop") {
                     // Flush any remaining think buffer
-                    if (inThink && thinkBuf) {
-                        const endIdx = thinkBuf.indexOf("</think>");
-                        if (endIdx !== -1) {
-                            const after = thinkBuf.slice(endIdx + "</think>".length);
-                            if (after)
-                                yield { type: "text", content: after };
-                        }
-                        inThink = false;
-                        thinkBuf = "";
-                    }
+                    const flushed = flushThinkBuf(thinkState);
+                    if (flushed)
+                        yield { type: "text", content: flushed };
+                    thinkState = { inThink: false, buf: "" };
                     yield {
                         type: "done",
                         usage: { input: inputTokens, output: outputTokens },