@bxb1337/windsurf-fast-context 1.1.0 → 1.1.1

package/dist/cjs/conversion/response-converter.js

@@ -3,192 +3,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertResponse = convertResponse;
 const node_zlib_1 = require("node:zlib");
 const protobuf_js_1 = require("../protocol/protobuf.js");
-const TOOL_CALL_PREFIX = '[TOOL_CALLS]';
-const ARGS_PREFIX = '[ARGS]';
 const STOP_TOKEN = '</s>';
-function parseOpenAIToolCalls(responseText) {
-    if (!responseText.startsWith('TOOL_CALLS')) {
+function parseStrictOpenAIToolCalls(responseText) {
+    const trimmed = responseText.trim();
+    if (!trimmed.startsWith('['))
         return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return null;
+        const toolCalls = [];
+        for (let i = 0; i < parsed.length; i++) {
+            const item = parsed[i];
+            if (item.type !== 'function' || !item.function?.name)
+                continue;
+            toolCalls.push({
+                type: 'tool-call',
+                toolCallId: `toolcall_${i + 1}`,
+                toolName: String(item.function.name),
+                input: item.function.parameters ?? {},
+            });
+        }
+        return toolCalls.length > 0 ? toolCalls : null;
     }
-    const jsonPart = responseText.slice('TOOL_CALLS'.length);
-    if (!jsonPart.startsWith('{')) {
-        return null;
-    }
-    const toolCalls = [];
-    let cursor = 0;
-    while (cursor < jsonPart.length) {
-        if (jsonPart[cursor] !== '{') {
-            cursor++;
-            continue;
-        }
-        const endResult = parseBalancedEnd(jsonPart, cursor);
-        if (endResult == null) {
-            break;
-        }
-        const jsonStr = jsonPart.slice(cursor, endResult);
-        cursor = endResult;
-        if (jsonStr === '{}') {
-            continue;
-        }
-        try {
-            const parsed = JSON.parse(jsonStr);
-            if (parsed.type === 'function' && parsed.function) {
-                toolCalls.push(parsed);
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    if (toolCalls.length === 0) {
+    catch {
         return null;
     }
-    return toolCalls.map((call, index) => {
-        const toolId = call.function.name;
-        const toolName = typeof toolId === 'number' ? mapToolIdToName(toolId) : String(toolId);
-        const args = call.function.parameters ?? {};
-        return {
-            type: 'tool-call',
-            toolCallId: `toolcall_${index + 1}`,
-            toolName,
-            input: args,
-        };
-    });
-}
-function mapToolIdToName(id) {
-    switch (id) {
-        case 1:
-            return 'read';
-        case 2:
-            return 'glob';
-        case 3:
-            return 'grep';
-        default:
-            return `tool_${id}`;
-    }
 }
 function pushText(parts, text) {
     if (text.length > 0) {
         parts.push({ type: 'text', text });
     }
 }
-function parseStringEnd(value, startIndex) {
-    let index = startIndex + 1;
-    let escaping = false;
-    while (index < value.length) {
-        const char = value[index];
-        if (escaping) {
-            escaping = false;
-        }
-        else if (char === '\\') {
-            escaping = true;
-        }
-        else if (char === '"') {
-            return index + 1;
-        }
-        index += 1;
-    }
-    return null;
-}
-function parseBalancedEnd(value, startIndex) {
-    const stack = [value[startIndex] === '{' ? '}' : ']'];
-    let index = startIndex + 1;
-    let inString = false;
-    let escaping = false;
-    while (index < value.length) {
-        const char = value[index];
-        if (inString) {
-            if (escaping) {
-                escaping = false;
-            }
-            else if (char === '\\') {
-                escaping = true;
-            }
-            else if (char === '"') {
-                inString = false;
-            }
-            index += 1;
-            continue;
-        }
-        if (char === '"') {
-            inString = true;
-            index += 1;
-            continue;
-        }
-        if (char === '{') {
-            stack.push('}');
-            index += 1;
-            continue;
-        }
-        if (char === '[') {
-            stack.push(']');
-            index += 1;
-            continue;
-        }
-        if (char === '}' || char === ']') {
-            const expected = stack[stack.length - 1];
-            if (expected !== char) {
-                return null;
-            }
-            stack.pop();
-            index += 1;
-            if (stack.length === 0) {
-                return index;
-            }
-            continue;
-        }
-        index += 1;
-    }
-    return null;
-}
-function parsePrimitiveEnd(value, startIndex) {
-    let index = startIndex;
-    while (index < value.length) {
-        const char = value[index];
-        if (char === ' ' || char === '\n' || char === '\r' || char === '\t') {
-            break;
-        }
-        index += 1;
-    }
-    return index;
-}
-function parseJsonValue(value, startIndex) {
-    let jsonStart = startIndex;
-    while (jsonStart < value.length) {
-        const char = value[jsonStart];
-        if (char !== ' ' && char !== '\n' && char !== '\r' && char !== '\t') {
-            break;
-        }
-        jsonStart += 1;
-    }
-    if (jsonStart >= value.length) {
-        return null;
-    }
-    const firstChar = value[jsonStart];
-    let endIndex;
-    if (firstChar === '{' || firstChar === '[') {
-        endIndex = parseBalancedEnd(value, jsonStart);
-    }
-    else if (firstChar === '"') {
-        endIndex = parseStringEnd(value, jsonStart);
-    }
-    else {
-        endIndex = parsePrimitiveEnd(value, jsonStart);
-    }
-    if (endIndex == null || endIndex <= jsonStart) {
-        return null;
-    }
-    const rawJson = value.slice(jsonStart, endIndex);
-    try {
-        return {
-            parsed: JSON.parse(rawJson),
-            endIndex,
-        };
-    }
-    catch {
-        return null;
-    }
-}
 function hasControlChars(value) {
     for (const char of value) {
         const code = char.charCodeAt(0);
@@ -216,10 +62,6 @@ function isLikelyMetadata(value) {
     return /^[A-Za-z0-9._:-]{1,32}$/.test(value);
 }
 function pickBestExtractedText(values) {
-    const markerValues = values.filter((value) => value.includes(TOOL_CALL_PREFIX) || value.includes(ARGS_PREFIX));
-    if (markerValues.length > 0) {
-        return markerValues.join('');
-    }
     const nonMetadata = values.filter((value) => !isLikelyMetadata(value));
     const candidates = nonMetadata.length > 0 ? nonMetadata : values;
     return candidates.reduce((best, current) => (current.length > best.length ? current : best), candidates[0] ?? '');
@@ -239,43 +81,10 @@ function decodeResponseText(buffer) {
 function convertResponse(buffer) {
     let responseText = decodeResponseText(buffer);
     responseText = responseText.replace(STOP_TOKEN, '');
-    const openaiToolCalls = parseOpenAIToolCalls(responseText);
-    if (openaiToolCalls) {
-        return openaiToolCalls;
-    }
+    const strictToolCalls = parseStrictOpenAIToolCalls(responseText);
+    if (strictToolCalls)
+        return strictToolCalls;
     const parts = [];
-    let cursor = 0;
-    let toolCallCount = 0;
-    while (cursor < responseText.length) {
-        const markerStart = responseText.indexOf(TOOL_CALL_PREFIX, cursor);
-        if (markerStart === -1) {
-            pushText(parts, responseText.slice(cursor));
-            break;
-        }
-        pushText(parts, responseText.slice(cursor, markerStart));
-        const toolNameStart = markerStart + TOOL_CALL_PREFIX.length;
-        const argsStart = responseText.indexOf(ARGS_PREFIX, toolNameStart);
-        if (argsStart === -1) {
-            pushText(parts, responseText.slice(markerStart));
-            break;
-        }
-        const toolName = responseText.slice(toolNameStart, argsStart);
-        const parsedArgs = parseJsonValue(responseText, argsStart + ARGS_PREFIX.length);
-        if (parsedArgs == null) {
-            const nextMarker = responseText.indexOf(TOOL_CALL_PREFIX, markerStart + TOOL_CALL_PREFIX.length);
-            const malformedEnd = nextMarker === -1 ? responseText.length : nextMarker;
-            pushText(parts, responseText.slice(markerStart, malformedEnd));
-            cursor = malformedEnd;
-            continue;
-        }
-        toolCallCount += 1;
-        parts.push({
-            type: 'tool-call',
-            toolCallId: `toolcall_${toolCallCount}`,
-            toolName,
-            input: parsedArgs.parsed,
-        });
-        cursor = parsedArgs.endIndex;
-    }
+    pushText(parts, responseText);
     return parts;
 }

package/dist/cjs/conversion/response-converter.test.js

@@ -9,38 +9,6 @@ const response_converter_js_1 = require("./response-converter.js");
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from('plain response text', 'utf8'));
         (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'plain response text' }]);
     });
-    (0, vitest_1.it)('tool-call - parses tool markers and preserves surrounding text', () => {
-        const input = 'Before [TOOL_CALLS]searchDocs[ARGS]{"query":"prompt converter"} between [TOOL_CALLS]answer[ARGS]{"answer":"final answer"} after';
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([
-            { type: 'text', text: 'Before ' },
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'searchDocs',
-                input: { query: 'prompt converter' },
-            },
-            { type: 'text', text: ' between ' },
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_2',
-                toolName: 'answer',
-                input: { answer: 'final answer' },
-            },
-            { type: 'text', text: ' after' },
-        ]);
-    });
-    (0, vitest_1.it)('malformed - invalid marker json remains text and does not throw', () => {
-        const input = 'prefix [TOOL_CALLS]searchDocs[ARGS]{"query": nope} suffix';
-        (0, vitest_1.expect)(() => (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'))).not.toThrow();
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        const combinedText = result
-            .filter((part) => part.type === 'text')
-            .map((part) => part.text)
-            .join('');
-        (0, vitest_1.expect)(result.every((part) => part.type === 'text')).toBe(true);
-        (0, vitest_1.expect)(combinedText).toBe(input);
-    });
     (0, vitest_1.it)('protobuf payload - extracts clean utf8 text without binary mojibake prefix', () => {
         const payload = new protobuf_js_1.ProtobufEncoder();
         payload.writeVarint(1, 150);
@@ -48,20 +16,6 @@ const response_converter_js_1 = require("./response-converter.js");
         const result = (0, response_converter_js_1.convertResponse)(payload.toBuffer());
         (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: '你好，TypeScript' }]);
     });
-    (0, vitest_1.it)('protobuf payload - still parses tool-call markers from extracted strings', () => {
-        const payload = new protobuf_js_1.ProtobufEncoder();
-        payload.writeVarint(1, 150);
-        payload.writeString(2, '[TOOL_CALLS]answer[ARGS]{"answer":"final answer"}');
-        const result = (0, response_converter_js_1.convertResponse)(payload.toBuffer());
-        (0, vitest_1.expect)(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'answer',
-                input: { answer: 'final answer' },
-            },
-        ]);
-    });
     (0, vitest_1.it)('protobuf payload - ignores metadata strings and keeps main text field', () => {
         const payload = new protobuf_js_1.ProtobufEncoder();
         payload.writeString(1, 'meta');
@@ -79,70 +33,52 @@ const response_converter_js_1 = require("./response-converter.js");
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
         (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Hello world' }]);
     });
-    (0, vitest_1.it)('parses OpenAI-style TOOL_CALLS with numeric IDs', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"file_path":"/home/test","search_pattern":"binance"}}}{}';
+    // Strict OpenAI array format tests
+    (0, vitest_1.it)('parses strict OpenAI array with single tool call', () => {
+        const input = '[{"type":"function","function":{"name":"search","parameters":{"q":"test"}}}]';
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
         (0, vitest_1.expect)(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'grep',
-                input: { file_path: '/home/test', search_pattern: 'binance' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'search', input: { q: 'test' } }
         ]);
     });
-    (0, vitest_1.it)('parses multiple OpenAI-style tool calls', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":1,"parameters":{"file_path":"/home/test"}}}, {"type":"function","function":{"name":2,"parameters":{"pattern":"*.ts"}}}{}';
+    (0, vitest_1.it)('parses strict OpenAI array with multiple tool calls', () => {
+        const input = '[{"type":"function","function":{"name":"read","parameters":{"path":"/a"}}},{"type":"function","function":{"name":"grep","parameters":{"pattern":"foo"}}}]';
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
         (0, vitest_1.expect)(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'read',
-                input: { file_path: '/home/test' },
-            },
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_2',
-                toolName: 'glob',
-                input: { pattern: '*.ts' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: { path: '/a' } },
+            { type: 'tool-call', toolCallId: 'toolcall_2', toolName: 'grep', input: { pattern: 'foo' } }
         ]);
     });
-    (0, vitest_1.it)('maps unknown tool IDs to tool_N format', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":99,"parameters":{"arg":"value"}}}{}';
+    (0, vitest_1.it)('parses strict OpenAI array with empty parameters', () => {
+        const input = '[{"type":"function","function":{"name":"list","parameters":{}}}]';
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
         (0, vitest_1.expect)(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'tool_99',
-                input: { arg: 'value' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'list', input: {} }
         ]);
     });
-    (0, vitest_1.it)('handles OpenAI-style with string tool names', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":"custom_tool","parameters":{"key":"value"}}}{}';
+    (0, vitest_1.it)('returns text for old marker format (no backward compat)', () => {
+        const input = '[TOOL_CALLS]search[ARGS]{"q":"test"}';
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'custom_tool',
-                input: { key: 'value' },
-            },
-        ]);
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: '[TOOL_CALLS]search[ARGS]{"q":"test"}' }]);
     });
-    (0, vitest_1.it)('handles OpenAI-style with string name "answer" - emits as tool-call', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":"answer","parameters":{"answer":"final answer"}}}{}';
+    (0, vitest_1.it)('returns text for old TOOL_CALLS format (no backward compat)', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"q":"test"}}}{}';
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'answer',
-                input: { answer: 'final answer' },
-            },
-        ]);
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: input }]);
+    });
+    (0, vitest_1.it)('returns text for non-array JSON', () => {
+        const input = '{"type":"function","function":{"name":"search","parameters":{}}}';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: input }]);
+    });
+    (0, vitest_1.it)('returns text for empty array', () => {
+        const input = '[]';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: '[]' }]);
+    });
+    (0, vitest_1.it)('returns text for malformed JSON array', () => {
+        const input = '[{"type":"function","function":{"name":"search","parameters":';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: input }]);
     });
 });

package/dist/cjs/model/devstral-language-model.js

@@ -20,6 +20,13 @@ const WS_APP_VER = process.env.WS_APP_VER ?? '1.48.2';
 const WS_LS_VER = process.env.WS_LS_VER ?? '1.9544.35';
 const SENTRY_PUBLIC_KEY = 'b813f73488da69eedec534dba1029111';
 const CONNECT_USER_AGENT = 'connect-go/1.18.1 (go1.25.5)';
+const TOOL_FORMAT_INSTRUCTION = `When you need to call tools, you must format your response as a JSON array of tool calls following the OpenAI function calling format. Each tool call must be an object with "type" set to "function" and a "function" object containing "name" (string matching one of the provided tool names) and "parameters" (object with the tool's arguments). Output ONLY the JSON array, no surrounding text.
+
+Example format:
+[{"type": "function", "function": {"name": "tool_name", "parameters": {"arg1": "value1"}}}]
+
+For multiple tool calls:
+[{"type": "function", "function": {"name": "tool1", "parameters": {"arg1": "value1"}}}, {"type": "function", "function": {"name": "tool2", "parameters": {"arg2": "value2"}}}]`;
 class DevstralLanguageModel {
     specificationVersion = 'v2';
     provider = 'windsurf';
@@ -271,10 +278,13 @@ function isFunctionTool(tool) {
 function buildGenerateRequest(input) {
     const request = new protobuf_js_1.ProtobufEncoder();
     request.writeMessage(1, buildMetadata(input.apiKey, input.jwt));
-    for (const message of input.messages) {
+    const functionTools = input.tools?.filter(isFunctionTool) ?? [];
+    const messages = functionTools.length > 0
+        ? [{ role: 5, content: TOOL_FORMAT_INSTRUCTION }, ...input.messages]
+        : input.messages;
+    for (const message of messages) {
         request.writeMessage(2, buildMessage(message));
     }
-    const functionTools = input.tools?.filter(isFunctionTool) ?? [];
     if (functionTools.length > 0) {
         const toolsArray = functionTools.map((tool) => ({
             type: 'function',

package/dist/cjs/model/devstral-language-model.test.js

@@ -163,7 +163,7 @@ async function collectStreamParts(stream) {
                 return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
             }
             requestBodies.push(bufferFromBody(init?.body));
-            const payload = Buffer.from('[TOOL_CALLS]searchRepo[ARGS]{"query":"jwt manager"}', 'utf8');
+            const payload = Buffer.from('[{"type":"function","function":{"name":"searchRepo","parameters":{"query":"jwt manager"}}}]', 'utf8');
             return new Response(Uint8Array.from((0, connect_frame_js_1.connectFrameEncode)(payload)), { status: 200 });
         };
         const model = new devstral_language_model_js_1.DevstralLanguageModel({ apiKey: 'tools-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
@@ -275,6 +275,83 @@ async function collectStreamParts(stream) {
         const strings = (0, protobuf_js_1.extractStrings)(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
         (0, vitest_1.expect)(extractToolsPayload(strings)).toBeUndefined();
     });
+    (0, vitest_1.it)('injects tool format instruction into request when tools are present', async () => {
+        const requestBodies = [];
+        const jwt = makeJwt(4_200_000_100, 'instruction');
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            requestBodies.push(bufferFromBody(init?.body));
+            return new Response(Uint8Array.from((0, connect_frame_js_1.connectFrameEncode)(Buffer.from('ok', 'utf8'))), { status: 200 });
+        };
+        const model = new devstral_language_model_js_1.DevstralLanguageModel({ apiKey: 'tools-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
+        await model.doGenerate({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Search for auth.' }] }],
+            tools: [
+                {
+                    type: 'function',
+                    name: 'searchRepo',
+                    description: 'Search repository files',
+                    inputSchema: {
+                        type: 'object',
+                        properties: { query: { type: 'string' } },
+                        required: ['query'],
+                    },
+                },
+            ],
+        });
+        const strings = (0, protobuf_js_1.extractStrings)(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const combined = strings.join('\n');
+        (0, vitest_1.expect)(combined).toContain('When you need to call tools');
+    });
+    (0, vitest_1.it)('does not inject tool format instruction when no tools provided', async () => {
+        const requestBodies = [];
+        const jwt = makeJwt(4_200_000_101, 'no-instruction');
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            requestBodies.push(bufferFromBody(init?.body));
+            return new Response(Uint8Array.from((0, connect_frame_js_1.connectFrameEncode)(Buffer.from('ok', 'utf8'))), { status: 200 });
+        };
+        const model = new devstral_language_model_js_1.DevstralLanguageModel({ apiKey: 'tools-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
+        await model.doGenerate({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Find auth logic.' }] }],
+        });
+        const strings = (0, protobuf_js_1.extractStrings)(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const combined = strings.join('\n');
+        (0, vitest_1.expect)(combined).not.toContain('When you need to call tools');
+    });
+    (0, vitest_1.it)('does not inject tool format instruction when only provider-defined tools', async () => {
+        const requestBodies = [];
+        const jwt = makeJwt(4_200_000_102, 'provider-only');
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            requestBodies.push(bufferFromBody(init?.body));
+            return new Response(Uint8Array.from((0, connect_frame_js_1.connectFrameEncode)(Buffer.from('ok', 'utf8'))), { status: 200 });
+        };
+        const model = new devstral_language_model_js_1.DevstralLanguageModel({ apiKey: 'tools-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
+        await model.doGenerate({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Use provider tools.' }] }],
+            tools: [
+                {
+                    type: 'provider-defined',
+                    id: 'some-provider-tool',
+                    name: 'providerTool',
+                    args: {},
+                },
+            ],
+        });
+        const strings = (0, protobuf_js_1.extractStrings)(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const combined = strings.join('\n');
+        (0, vitest_1.expect)(combined).not.toContain('When you need to call tools');
+    });
 });
 (0, vitest_1.describe)('DevstralLanguageModel doStream', () => {
     (0, vitest_1.it)('stream-text resolves before full body arrives and emits parts incrementally', async () => {
@@ -379,7 +456,7 @@ async function collectStreamParts(stream) {
     });
     (0, vitest_1.it)('stream-tool emits tool-input deltas before final tool-call and finish', async () => {
         const jwt = makeJwt(4_300_000_001, 'stream-tool');
-        const toolPayload = Buffer.from('[TOOL_CALLS]searchRepo[ARGS]{"query":"jwt manager"}', 'utf8');
+        const toolPayload = Buffer.from('[{"type":"function","function":{"name":"searchRepo","parameters":{"query":"jwt manager"}}}]', 'utf8');
         const frames = Buffer.concat([(0, connect_frame_js_1.connectFrameEncode)(toolPayload)]);
         const fakeFetch = async (input) => {
             const url = String(input);

package/dist/esm/conversion/response-converter.js

@@ -1,191 +1,37 @@
 import { gunzipSync } from 'node:zlib';
 import { extractStrings } from '../protocol/protobuf.js';
-const TOOL_CALL_PREFIX = '[TOOL_CALLS]';
-const ARGS_PREFIX = '[ARGS]';
 const STOP_TOKEN = '</s>';
-function parseOpenAIToolCalls(responseText) {
-    if (!responseText.startsWith('TOOL_CALLS')) {
+function parseStrictOpenAIToolCalls(responseText) {
+    const trimmed = responseText.trim();
+    if (!trimmed.startsWith('['))
         return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return null;
+        const toolCalls = [];
+        for (let i = 0; i < parsed.length; i++) {
+            const item = parsed[i];
+            if (item.type !== 'function' || !item.function?.name)
+                continue;
+            toolCalls.push({
+                type: 'tool-call',
+                toolCallId: `toolcall_${i + 1}`,
+                toolName: String(item.function.name),
+                input: item.function.parameters ?? {},
+            });
+        }
+        return toolCalls.length > 0 ? toolCalls : null;
     }
-    const jsonPart = responseText.slice('TOOL_CALLS'.length);
-    if (!jsonPart.startsWith('{')) {
-        return null;
-    }
-    const toolCalls = [];
-    let cursor = 0;
-    while (cursor < jsonPart.length) {
-        if (jsonPart[cursor] !== '{') {
-            cursor++;
-            continue;
-        }
-        const endResult = parseBalancedEnd(jsonPart, cursor);
-        if (endResult == null) {
-            break;
-        }
-        const jsonStr = jsonPart.slice(cursor, endResult);
-        cursor = endResult;
-        if (jsonStr === '{}') {
-            continue;
-        }
-        try {
-            const parsed = JSON.parse(jsonStr);
-            if (parsed.type === 'function' && parsed.function) {
-                toolCalls.push(parsed);
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    if (toolCalls.length === 0) {
+    catch {
         return null;
     }
-    return toolCalls.map((call, index) => {
-        const toolId = call.function.name;
-        const toolName = typeof toolId === 'number' ? mapToolIdToName(toolId) : String(toolId);
-        const args = call.function.parameters ?? {};
-        return {
-            type: 'tool-call',
-            toolCallId: `toolcall_${index + 1}`,
-            toolName,
-            input: args,
-        };
-    });
-}
-function mapToolIdToName(id) {
-    switch (id) {
-        case 1:
-            return 'read';
-        case 2:
-            return 'glob';
-        case 3:
-            return 'grep';
-        default:
-            return `tool_${id}`;
-    }
 }
 function pushText(parts, text) {
     if (text.length > 0) {
         parts.push({ type: 'text', text });
     }
 }
-function parseStringEnd(value, startIndex) {
-    let index = startIndex + 1;
-    let escaping = false;
-    while (index < value.length) {
-        const char = value[index];
-        if (escaping) {
-            escaping = false;
-        }
-        else if (char === '\\') {
-            escaping = true;
-        }
-        else if (char === '"') {
-            return index + 1;
-        }
-        index += 1;
-    }
-    return null;
-}
-function parseBalancedEnd(value, startIndex) {
-    const stack = [value[startIndex] === '{' ? '}' : ']'];
-    let index = startIndex + 1;
-    let inString = false;
-    let escaping = false;
-    while (index < value.length) {
-        const char = value[index];
-        if (inString) {
-            if (escaping) {
-                escaping = false;
-            }
-            else if (char === '\\') {
-                escaping = true;
-            }
-            else if (char === '"') {
-                inString = false;
-            }
-            index += 1;
-            continue;
-        }
-        if (char === '"') {
-            inString = true;
-            index += 1;
-            continue;
-        }
-        if (char === '{') {
-            stack.push('}');
-            index += 1;
-            continue;
-        }
-        if (char === '[') {
-            stack.push(']');
-            index += 1;
-            continue;
-        }
-        if (char === '}' || char === ']') {
-            const expected = stack[stack.length - 1];
-            if (expected !== char) {
-                return null;
-            }
-            stack.pop();
-            index += 1;
-            if (stack.length === 0) {
-                return index;
-            }
-            continue;
-        }
-        index += 1;
-    }
-    return null;
-}
-function parsePrimitiveEnd(value, startIndex) {
-    let index = startIndex;
-    while (index < value.length) {
-        const char = value[index];
-        if (char === ' ' || char === '\n' || char === '\r' || char === '\t') {
-            break;
-        }
-        index += 1;
-    }
-    return index;
-}
-function parseJsonValue(value, startIndex) {
-    let jsonStart = startIndex;
-    while (jsonStart < value.length) {
-        const char = value[jsonStart];
-        if (char !== ' ' && char !== '\n' && char !== '\r' && char !== '\t') {
-            break;
-        }
-        jsonStart += 1;
-    }
-    if (jsonStart >= value.length) {
-        return null;
-    }
-    const firstChar = value[jsonStart];
-    let endIndex;
-    if (firstChar === '{' || firstChar === '[') {
-        endIndex = parseBalancedEnd(value, jsonStart);
-    }
-    else if (firstChar === '"') {
-        endIndex = parseStringEnd(value, jsonStart);
-    }
-    else {
-        endIndex = parsePrimitiveEnd(value, jsonStart);
-    }
-    if (endIndex == null || endIndex <= jsonStart) {
-        return null;
-    }
-    const rawJson = value.slice(jsonStart, endIndex);
-    try {
-        return {
-            parsed: JSON.parse(rawJson),
-            endIndex,
-        };
-    }
-    catch {
-        return null;
-    }
-}
 function hasControlChars(value) {
     for (const char of value) {
         const code = char.charCodeAt(0);
@@ -213,10 +59,6 @@ function isLikelyMetadata(value) {
     return /^[A-Za-z0-9._:-]{1,32}$/.test(value);
 }
 function pickBestExtractedText(values) {
-    const markerValues = values.filter((value) => value.includes(TOOL_CALL_PREFIX) || value.includes(ARGS_PREFIX));
-    if (markerValues.length > 0) {
-        return markerValues.join('');
-    }
     const nonMetadata = values.filter((value) => !isLikelyMetadata(value));
     const candidates = nonMetadata.length > 0 ? nonMetadata : values;
     return candidates.reduce((best, current) => (current.length > best.length ? current : best), candidates[0] ?? '');
@@ -236,43 +78,10 @@ function decodeResponseText(buffer) {
 export function convertResponse(buffer) {
     let responseText = decodeResponseText(buffer);
     responseText = responseText.replace(STOP_TOKEN, '');
-    const openaiToolCalls = parseOpenAIToolCalls(responseText);
-    if (openaiToolCalls) {
-        return openaiToolCalls;
-    }
+    const strictToolCalls = parseStrictOpenAIToolCalls(responseText);
+    if (strictToolCalls)
+        return strictToolCalls;
     const parts = [];
-    let cursor = 0;
-    let toolCallCount = 0;
-    while (cursor < responseText.length) {
-        const markerStart = responseText.indexOf(TOOL_CALL_PREFIX, cursor);
-        if (markerStart === -1) {
-            pushText(parts, responseText.slice(cursor));
-            break;
-        }
-        pushText(parts, responseText.slice(cursor, markerStart));
-        const toolNameStart = markerStart + TOOL_CALL_PREFIX.length;
-        const argsStart = responseText.indexOf(ARGS_PREFIX, toolNameStart);
-        if (argsStart === -1) {
-            pushText(parts, responseText.slice(markerStart));
-            break;
-        }
-        const toolName = responseText.slice(toolNameStart, argsStart);
-        const parsedArgs = parseJsonValue(responseText, argsStart + ARGS_PREFIX.length);
-        if (parsedArgs == null) {
-            const nextMarker = responseText.indexOf(TOOL_CALL_PREFIX, markerStart + TOOL_CALL_PREFIX.length);
-            const malformedEnd = nextMarker === -1 ? responseText.length : nextMarker;
-            pushText(parts, responseText.slice(markerStart, malformedEnd));
-            cursor = malformedEnd;
-            continue;
-        }
-        toolCallCount += 1;
-        parts.push({
-            type: 'tool-call',
-            toolCallId: `toolcall_${toolCallCount}`,
-            toolName,
-            input: parsedArgs.parsed,
-        });
-        cursor = parsedArgs.endIndex;
-    }
+    pushText(parts, responseText);
     return parts;
 }

package/dist/esm/conversion/response-converter.test.js

@@ -7,38 +7,6 @@ describe('convertResponse', () => {
         const result = convertResponse(Buffer.from('plain response text', 'utf8'));
         expect(result).toEqual([{ type: 'text', text: 'plain response text' }]);
     });
-    it('tool-call - parses tool markers and preserves surrounding text', () => {
-        const input = 'Before [TOOL_CALLS]searchDocs[ARGS]{"query":"prompt converter"} between [TOOL_CALLS]answer[ARGS]{"answer":"final answer"} after';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([
-            { type: 'text', text: 'Before ' },
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'searchDocs',
-                input: { query: 'prompt converter' },
-            },
-            { type: 'text', text: ' between ' },
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_2',
-                toolName: 'answer',
-                input: { answer: 'final answer' },
-            },
-            { type: 'text', text: ' after' },
-        ]);
-    });
-    it('malformed - invalid marker json remains text and does not throw', () => {
-        const input = 'prefix [TOOL_CALLS]searchDocs[ARGS]{"query": nope} suffix';
-        expect(() => convertResponse(Buffer.from(input, 'utf8'))).not.toThrow();
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        const combinedText = result
-            .filter((part) => part.type === 'text')
-            .map((part) => part.text)
-            .join('');
-        expect(result.every((part) => part.type === 'text')).toBe(true);
-        expect(combinedText).toBe(input);
-    });
     it('protobuf payload - extracts clean utf8 text without binary mojibake prefix', () => {
         const payload = new ProtobufEncoder();
         payload.writeVarint(1, 150);
@@ -46,20 +14,6 @@ describe('convertResponse', () => {
         const result = convertResponse(payload.toBuffer());
         expect(result).toEqual([{ type: 'text', text: '你好，TypeScript' }]);
     });
-    it('protobuf payload - still parses tool-call markers from extracted strings', () => {
-        const payload = new ProtobufEncoder();
-        payload.writeVarint(1, 150);
-        payload.writeString(2, '[TOOL_CALLS]answer[ARGS]{"answer":"final answer"}');
-        const result = convertResponse(payload.toBuffer());
-        expect(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'answer',
-                input: { answer: 'final answer' },
-            },
-        ]);
-    });
     it('protobuf payload - ignores metadata strings and keeps main text field', () => {
         const payload = new ProtobufEncoder();
         payload.writeString(1, 'meta');
@@ -77,70 +31,52 @@ describe('convertResponse', () => {
         const result = convertResponse(Buffer.from(input, 'utf8'));
         expect(result).toEqual([{ type: 'text', text: 'Hello world' }]);
     });
-    it('parses OpenAI-style TOOL_CALLS with numeric IDs', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"file_path":"/home/test","search_pattern":"binance"}}}{}';
+    // Strict OpenAI array format tests
+    it('parses strict OpenAI array with single tool call', () => {
+        const input = '[{"type":"function","function":{"name":"search","parameters":{"q":"test"}}}]';
         const result = convertResponse(Buffer.from(input, 'utf8'));
         expect(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'grep',
-                input: { file_path: '/home/test', search_pattern: 'binance' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'search', input: { q: 'test' } }
         ]);
     });
-    it('parses multiple OpenAI-style tool calls', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":1,"parameters":{"file_path":"/home/test"}}}, {"type":"function","function":{"name":2,"parameters":{"pattern":"*.ts"}}}{}';
+    it('parses strict OpenAI array with multiple tool calls', () => {
+        const input = '[{"type":"function","function":{"name":"read","parameters":{"path":"/a"}}},{"type":"function","function":{"name":"grep","parameters":{"pattern":"foo"}}}]';
         const result = convertResponse(Buffer.from(input, 'utf8'));
         expect(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'read',
-                input: { file_path: '/home/test' },
-            },
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_2',
-                toolName: 'glob',
-                input: { pattern: '*.ts' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: { path: '/a' } },
+            { type: 'tool-call', toolCallId: 'toolcall_2', toolName: 'grep', input: { pattern: 'foo' } }
         ]);
     });
-    it('maps unknown tool IDs to tool_N format', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":99,"parameters":{"arg":"value"}}}{}';
+    it('parses strict OpenAI array with empty parameters', () => {
+        const input = '[{"type":"function","function":{"name":"list","parameters":{}}}]';
         const result = convertResponse(Buffer.from(input, 'utf8'));
         expect(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'tool_99',
-                input: { arg: 'value' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'list', input: {} }
         ]);
     });
-    it('handles OpenAI-style with string tool names', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":"custom_tool","parameters":{"key":"value"}}}{}';
+    it('returns text for old marker format (no backward compat)', () => {
+        const input = '[TOOL_CALLS]search[ARGS]{"q":"test"}';
         const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'custom_tool',
-                input: { key: 'value' },
-            },
-        ]);
+        expect(result).toEqual([{ type: 'text', text: '[TOOL_CALLS]search[ARGS]{"q":"test"}' }]);
     });
-    it('handles OpenAI-style with string name "answer" - emits as tool-call', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":"answer","parameters":{"answer":"final answer"}}}{}';
+    it('returns text for old TOOL_CALLS format (no backward compat)', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"q":"test"}}}{}';
         const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'answer',
-                input: { answer: 'final answer' },
-            },
-        ]);
+        expect(result).toEqual([{ type: 'text', text: input }]);
+    });
+    it('returns text for non-array JSON', () => {
+        const input = '{"type":"function","function":{"name":"search","parameters":{}}}';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([{ type: 'text', text: input }]);
+    });
+    it('returns text for empty array', () => {
+        const input = '[]';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([{ type: 'text', text: '[]' }]);
+    });
+    it('returns text for malformed JSON array', () => {
+        const input = '[{"type":"function","function":{"name":"search","parameters":';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([{ type: 'text', text: input }]);
     });
 });

package/dist/esm/model/devstral-language-model.js

@@ -17,6 +17,13 @@ const WS_APP_VER = process.env.WS_APP_VER ?? '1.48.2';
 const WS_LS_VER = process.env.WS_LS_VER ?? '1.9544.35';
 const SENTRY_PUBLIC_KEY = 'b813f73488da69eedec534dba1029111';
 const CONNECT_USER_AGENT = 'connect-go/1.18.1 (go1.25.5)';
+const TOOL_FORMAT_INSTRUCTION = `When you need to call tools, you must format your response as a JSON array of tool calls following the OpenAI function calling format. Each tool call must be an object with "type" set to "function" and a "function" object containing "name" (string matching one of the provided tool names) and "parameters" (object with the tool's arguments). Output ONLY the JSON array, no surrounding text.
+
+Example format:
+[{"type": "function", "function": {"name": "tool_name", "parameters": {"arg1": "value1"}}}]
+
+For multiple tool calls:
+[{"type": "function", "function": {"name": "tool1", "parameters": {"arg1": "value1"}}}, {"type": "function", "function": {"name": "tool2", "parameters": {"arg2": "value2"}}}]`;
 export class DevstralLanguageModel {
     specificationVersion = 'v2';
     provider = 'windsurf';
@@ -267,10 +274,13 @@ function isFunctionTool(tool) {
 function buildGenerateRequest(input) {
     const request = new ProtobufEncoder();
     request.writeMessage(1, buildMetadata(input.apiKey, input.jwt));
-    for (const message of input.messages) {
+    const functionTools = input.tools?.filter(isFunctionTool) ?? [];
+    const messages = functionTools.length > 0
+        ? [{ role: 5, content: TOOL_FORMAT_INSTRUCTION }, ...input.messages]
+        : input.messages;
+    for (const message of messages) {
         request.writeMessage(2, buildMessage(message));
     }
-    const functionTools = input.tools?.filter(isFunctionTool) ?? [];
     if (functionTools.length > 0) {
         const toolsArray = functionTools.map((tool) => ({
             type: 'function',

package/dist/esm/model/devstral-language-model.test.js

@@ -161,7 +161,7 @@ describe('DevstralLanguageModel doGenerate', () => {
                 return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
             }
             requestBodies.push(bufferFromBody(init?.body));
-            const payload = Buffer.from('[TOOL_CALLS]searchRepo[ARGS]{"query":"jwt manager"}', 'utf8');
+            const payload = Buffer.from('[{"type":"function","function":{"name":"searchRepo","parameters":{"query":"jwt manager"}}}]', 'utf8');
             return new Response(Uint8Array.from(connectFrameEncode(payload)), { status: 200 });
         };
         const model = new DevstralLanguageModel({ apiKey: 'tools-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
@@ -273,6 +273,83 @@ describe('DevstralLanguageModel doGenerate', () => {
         const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
         expect(extractToolsPayload(strings)).toBeUndefined();
     });
+    it('injects tool format instruction into request when tools are present', async () => {
+        const requestBodies = [];
+        const jwt = makeJwt(4_200_000_100, 'instruction');
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            requestBodies.push(bufferFromBody(init?.body));
+            return new Response(Uint8Array.from(connectFrameEncode(Buffer.from('ok', 'utf8'))), { status: 200 });
+        };
+        const model = new DevstralLanguageModel({ apiKey: 'tools-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
+        await model.doGenerate({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Search for auth.' }] }],
+            tools: [
+                {
+                    type: 'function',
+                    name: 'searchRepo',
+                    description: 'Search repository files',
+                    inputSchema: {
+                        type: 'object',
+                        properties: { query: { type: 'string' } },
+                        required: ['query'],
+                    },
+                },
+            ],
+        });
+        const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const combined = strings.join('\n');
+        expect(combined).toContain('When you need to call tools');
+    });
+    it('does not inject tool format instruction when no tools provided', async () => {
+        const requestBodies = [];
+        const jwt = makeJwt(4_200_000_101, 'no-instruction');
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            requestBodies.push(bufferFromBody(init?.body));
+            return new Response(Uint8Array.from(connectFrameEncode(Buffer.from('ok', 'utf8'))), { status: 200 });
+        };
+        const model = new DevstralLanguageModel({ apiKey: 'tools-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
+        await model.doGenerate({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Find auth logic.' }] }],
+        });
+        const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const combined = strings.join('\n');
+        expect(combined).not.toContain('When you need to call tools');
+    });
+    it('does not inject tool format instruction when only provider-defined tools', async () => {
+        const requestBodies = [];
+        const jwt = makeJwt(4_200_000_102, 'provider-only');
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            requestBodies.push(bufferFromBody(init?.body));
+            return new Response(Uint8Array.from(connectFrameEncode(Buffer.from('ok', 'utf8'))), { status: 200 });
+        };
+        const model = new DevstralLanguageModel({ apiKey: 'tools-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
+        await model.doGenerate({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Use provider tools.' }] }],
+            tools: [
+                {
+                    type: 'provider-defined',
+                    id: 'some-provider-tool',
+                    name: 'providerTool',
+                    args: {},
+                },
+            ],
+        });
+        const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const combined = strings.join('\n');
+        expect(combined).not.toContain('When you need to call tools');
+    });
 });
 describe('DevstralLanguageModel doStream', () => {
     it('stream-text resolves before full body arrives and emits parts incrementally', async () => {
@@ -377,7 +454,7 @@ describe('DevstralLanguageModel doStream', () => {
     });
     it('stream-tool emits tool-input deltas before final tool-call and finish', async () => {
         const jwt = makeJwt(4_300_000_001, 'stream-tool');
-        const toolPayload = Buffer.from('[TOOL_CALLS]searchRepo[ARGS]{"query":"jwt manager"}', 'utf8');
+        const toolPayload = Buffer.from('[{"type":"function","function":{"name":"searchRepo","parameters":{"query":"jwt manager"}}}]', 'utf8');
         const frames = Buffer.concat([connectFrameEncode(toolPayload)]);
         const fakeFetch = async (input) => {
             const url = String(input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bxb1337/windsurf-fast-context",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "AI SDK V3 provider for Windsurf's Devstral code search API",
   "type": "module",
   "scripts": {