@bxb1337/windsurf-fast-context 1.1.2 → 1.1.4

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

@@ -3,38 +3,199 @@ 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 parseStrictOpenAIToolCalls(responseText) {
-    const trimmed = responseText.trim();
-    if (!trimmed.startsWith('['))
+function parseOpenAIToolCalls(responseText) {
+    // Support both [TOOL_CALLS]{...} and TOOL_CALLS{...} formats
+    let jsonPart = responseText;
+    if (jsonPart.startsWith('[TOOL_CALLS]')) {
+        jsonPart = jsonPart.slice('[TOOL_CALLS]'.length);
+    }
+    else if (jsonPart.startsWith('TOOL_CALLS')) {
+        jsonPart = jsonPart.slice('TOOL_CALLS'.length);
+    }
+    else {
         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 ?? {},
-            });
+    }
+    if (!jsonPart.startsWith('{') && !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;
         }
-        return toolCalls.length > 0 ? toolCalls : null;
     }
-    catch {
+    if (toolCalls.length === 0) {
         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: JSON.stringify(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);
@@ -62,6 +223,10 @@ 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] ?? '');
@@ -81,10 +246,100 @@ function decodeResponseText(buffer) {
 function convertResponse(buffer) {
     let responseText = decodeResponseText(buffer);
     responseText = responseText.replace(STOP_TOKEN, '');
-    const strictToolCalls = parseStrictOpenAIToolCalls(responseText);
-    if (strictToolCalls)
-        return strictToolCalls;
+    // Try parsing as pure tool calls first (for backward compat)
+    const openaiToolCalls = parseOpenAIToolCalls(responseText);
+    if (openaiToolCalls) {
+        return openaiToolCalls;
+    }
     const parts = [];
-    pushText(parts, responseText);
+    let cursor = 0;
+    let toolCallCount = 0;
+    while (cursor < responseText.length) {
+        // Try to find [TOOL_CALLS] marker
+        const markerStart = responseText.indexOf(TOOL_CALL_PREFIX, cursor);
+        if (markerStart === -1) {
+            pushText(parts, responseText.slice(cursor));
+            break;
+        }
+        pushText(parts, responseText.slice(cursor, markerStart));
+        const afterMarker = responseText.slice(markerStart + TOOL_CALL_PREFIX.length);
+        // Check if it's [TOOL_CALLS]{...} format (OpenAI-style)
+        if (afterMarker.startsWith('{') || afterMarker.startsWith('[')) {
+            const jsonResult = parseJsonValue(afterMarker, 0);
+            if (jsonResult) {
+                const parsed = jsonResult.parsed;
+                // Handle single object or array of objects
+                const items = Array.isArray(parsed) ? parsed : [parsed];
+                let foundToolCall = false;
+                for (const item of items) {
+                    if (item && typeof item === 'object' && item.type === 'function' && item.function) {
+                        toolCallCount += 1;
+                        const toolName = typeof item.function.name === 'string'
+                            ? item.function.name
+                            : mapToolIdToName(item.function.name);
+                        parts.push({
+                            type: 'tool-call',
+                            toolCallId: `toolcall_${toolCallCount}`,
+                            toolName,
+                            input: JSON.stringify(item.function.parameters ?? {}),
+                        });
+                        foundToolCall = true;
+                    }
+                }
+                if (foundToolCall) {
+                    cursor = markerStart + TOOL_CALL_PREFIX.length + jsonResult.endIndex;
+                    continue;
+                }
+            }
+            // Not a valid OpenAI format, treat as text
+            pushText(parts, responseText.slice(markerStart, markerStart + TOOL_CALL_PREFIX.length));
+            cursor = markerStart + TOOL_CALL_PREFIX.length;
+            continue;
+        }
+        // Try [TOOL_CALLS]tool_name[ARGS]{...} format first (has ARGS marker)
+        const argsStart = responseText.indexOf(ARGS_PREFIX, markerStart + TOOL_CALL_PREFIX.length);
+        if (argsStart !== -1) {
+            const toolName = responseText.slice(markerStart + TOOL_CALL_PREFIX.length, argsStart);
+            const parsedArgs = parseJsonValue(responseText, argsStart + ARGS_PREFIX.length);
+            if (parsedArgs) {
+                toolCallCount += 1;
+                parts.push({
+                    type: 'tool-call',
+                    toolCallId: `toolcall_${toolCallCount}`,
+                    toolName,
+                    input: JSON.stringify(parsedArgs.parsed),
+                });
+                cursor = parsedArgs.endIndex;
+                continue;
+            }
+            // Malformed ARGS, skip
+            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;
+        }
+        // Try [TOOL_CALLS]tool_name{...} format (no ARGS marker)
+        const afterPrefix = responseText.slice(markerStart + TOOL_CALL_PREFIX.length);
+        const jsonStart = afterPrefix.indexOf('{');
+        if (jsonStart !== -1) {
+            const toolName = afterPrefix.slice(0, jsonStart).trim();
+            const parsedArgs = parseJsonValue(afterPrefix, jsonStart);
+            if (parsedArgs && toolName) {
+                toolCallCount += 1;
+                parts.push({
+                    type: 'tool-call',
+                    toolCallId: `toolcall_${toolCallCount}`,
+                    toolName,
+                    input: JSON.stringify(parsedArgs.parsed),
+                });
+                cursor = markerStart + TOOL_CALL_PREFIX.length + parsedArgs.endIndex;
+                continue;
+            }
+        }
+        // No valid format found
+        pushText(parts, responseText.slice(markerStart));
+        break;
+    }
     return parts;
 }

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

@@ -33,38 +33,65 @@ 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' }]);
     });
-    // 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"}}}]';
+    // Native Windsurf marker format tests
+    (0, vitest_1.it)('parses native marker format [TOOL_CALLS]name[ARGS]{json}', () => {
+        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: 'search', input: { q: 'test' } }
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'search', input: '{"q":"test"}' }
         ]);
     });
-    (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"}}}]';
+    (0, vitest_1.it)('parses marker format with text before tool call', () => {
+        const input = 'Some text before[TOOL_CALLS]read[ARGS]{"path":"/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: { path: '/a' } },
-            { type: 'tool-call', toolCallId: 'toolcall_2', toolName: 'grep', input: { pattern: 'foo' } }
+            { type: 'text', text: 'Some text before' },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: '{"path":"/foo"}' }
         ]);
     });
-    (0, vitest_1.it)('parses strict OpenAI array with empty parameters', () => {
-        const input = '[{"type":"function","function":{"name":"list","parameters":{}}}]';
+    (0, vitest_1.it)('parses marker format with text after tool call', () => {
+        const input = '[TOOL_CALLS]grep[ARGS]{"pattern":"foo"}Some text after';
         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: 'list', input: {} }
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'grep', input: '{"pattern":"foo"}' },
+            { type: 'text', text: 'Some text after' }
         ]);
     });
-    (0, vitest_1.it)('returns text for old marker format (no backward compat)', () => {
-        const input = '[TOOL_CALLS]search[ARGS]{"q":"test"}';
+    (0, vitest_1.it)('parses multiple tool calls in marker format', () => {
+        const input = '[TOOL_CALLS]read[ARGS]{"path":"/a"}[TOOL_CALLS]grep[ARGS]{"pattern":"foo"}';
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: '[TOOL_CALLS]search[ARGS]{"q":"test"}' }]);
+        (0, vitest_1.expect)(result).toEqual([
+            { 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)('returns text for old TOOL_CALLS format (no backward compat)', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"q":"test"}}}{}';
+    (0, vitest_1.it)('parses TOOL_CALLS format with numeric tool id', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"pattern":"test"}}}';
         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.expect)(result).toEqual([
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'grep', input: '{"pattern":"test"}' }
+        ]);
+    });
+    (0, vitest_1.it)('maps tool id 1 to read', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":1,"parameters":{"path":"/file"}}}';
+        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: '{"path":"/file"}' }
+        ]);
+    });
+    (0, vitest_1.it)('maps tool id 2 to glob', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":2,"parameters":{"pattern":"*.ts"}}}';
+        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: 'glob', input: '{"pattern":"*.ts"}' }
+        ]);
+    });
+    (0, vitest_1.it)('maps unknown tool id to tool_N', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":99,"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: '{}' }
+        ]);
     });
     (0, vitest_1.it)('returns text for non-array JSON', () => {
         const input = '{"type":"function","function":{"name":"search","parameters":{}}}';

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

@@ -20,13 +20,18 @@ 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.
+const TOOL_FORMAT_INSTRUCTION = `CRITICAL: When using tools, output ONLY a JSON array (no text before or after). Use this EXACT format:
 
-Example format:
-[{"type": "function", "function": {"name": "tool_name", "parameters": {"arg1": "value1"}}}]
+[{"type":"function","function":{"name":"tool_name","parameters":{"arg":"value"}}}]
 
-For multiple tool calls:
-[{"type": "function", "function": {"name": "tool1", "parameters": {"arg1": "value1"}}}, {"type": "function", "function": {"name": "tool2", "parameters": {"arg2": "value2"}}}]`;
+RULES:
+- Start with [ and end with ]
+- Each tool call has: type="function", function.name (string), function.parameters (object)
+- NO markdown, NO code blocks, NO [TOOL_CALLS] markers
+- Use the EXACT parameter names from the tool definition
+
+Example for calculator(a, b):
+[{"type":"function","function":{"name":"calculator","parameters":{"a":15,"b":27}}}]`;
 class DevstralLanguageModel {
     specificationVersion = 'v2';
     provider = 'windsurf';

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('[{"type":"function","function":{"name":"searchRepo","parameters":{"query":"jwt manager"}}}]', 'utf8');
+            const payload = Buffer.from('[TOOL_CALLS]searchRepo[ARGS]{"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' });
@@ -304,9 +304,9 @@ async function collectStreamParts(stream) {
         });
         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.expect)(combined).toContain('CRITICAL: When using tools');
     });
-    (0, vitest_1.it)('does not inject tool format instruction when no tools provided', async () => {
+    (0, vitest_1.it)('does not inject tool format instruction when no tools present', async () => {
         const requestBodies = [];
         const jwt = makeJwt(4_200_000_101, 'no-instruction');
         const fakeFetch = async (input, init) => {
@@ -323,9 +323,9 @@ async function collectStreamParts(stream) {
         });
         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.expect)(combined).not.toContain('CRITICAL: When using tools');
     });
-    (0, vitest_1.it)('does not inject tool format instruction when only provider-defined tools', async () => {
+    (0, vitest_1.it)('injects tool format instruction for function tools only, not provider-defined', async () => {
         const requestBodies = [];
         const jwt = makeJwt(4_200_000_102, 'provider-only');
         const fakeFetch = async (input, init) => {
@@ -350,7 +350,7 @@ async function collectStreamParts(stream) {
         });
         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.expect)(combined).not.toContain('CRITICAL: When using tools');
     });
 });
 (0, vitest_1.describe)('DevstralLanguageModel doStream', () => {
@@ -456,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('[{"type":"function","function":{"name":"searchRepo","parameters":{"query":"jwt manager"}}}]', 'utf8');
+        const toolPayload = Buffer.from('[TOOL_CALLS]searchRepo[ARGS]{"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/conversion/response-converter.d.ts

@@ -6,7 +6,7 @@ export interface ToolCallPart {
     type: 'tool-call';
     toolCallId: string;
     toolName: string;
-    input: unknown;
+    input: string;
 }
 export type LanguageModelV2Content = TextPart | ToolCallPart;
 export declare function convertResponse(buffer: Buffer): LanguageModelV2Content[];

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

@@ -1,37 +1,198 @@
 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 parseStrictOpenAIToolCalls(responseText) {
-    const trimmed = responseText.trim();
-    if (!trimmed.startsWith('['))
+function parseOpenAIToolCalls(responseText) {
+    // Support both [TOOL_CALLS]{...} and TOOL_CALLS{...} formats
+    let jsonPart = responseText;
+    if (jsonPart.startsWith('[TOOL_CALLS]')) {
+        jsonPart = jsonPart.slice('[TOOL_CALLS]'.length);
+    }
+    else if (jsonPart.startsWith('TOOL_CALLS')) {
+        jsonPart = jsonPart.slice('TOOL_CALLS'.length);
+    }
+    else {
         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 ?? {},
-            });
+    }
+    if (!jsonPart.startsWith('{') && !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;
         }
-        return toolCalls.length > 0 ? toolCalls : null;
     }
-    catch {
+    if (toolCalls.length === 0) {
         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: JSON.stringify(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);
@@ -59,6 +220,10 @@ 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] ?? '');
@@ -78,10 +243,100 @@ function decodeResponseText(buffer) {
 export function convertResponse(buffer) {
     let responseText = decodeResponseText(buffer);
     responseText = responseText.replace(STOP_TOKEN, '');
-    const strictToolCalls = parseStrictOpenAIToolCalls(responseText);
-    if (strictToolCalls)
-        return strictToolCalls;
+    // Try parsing as pure tool calls first (for backward compat)
+    const openaiToolCalls = parseOpenAIToolCalls(responseText);
+    if (openaiToolCalls) {
+        return openaiToolCalls;
+    }
     const parts = [];
-    pushText(parts, responseText);
+    let cursor = 0;
+    let toolCallCount = 0;
+    while (cursor < responseText.length) {
+        // Try to find [TOOL_CALLS] marker
+        const markerStart = responseText.indexOf(TOOL_CALL_PREFIX, cursor);
+        if (markerStart === -1) {
+            pushText(parts, responseText.slice(cursor));
+            break;
+        }
+        pushText(parts, responseText.slice(cursor, markerStart));
+        const afterMarker = responseText.slice(markerStart + TOOL_CALL_PREFIX.length);
+        // Check if it's [TOOL_CALLS]{...} format (OpenAI-style)
+        if (afterMarker.startsWith('{') || afterMarker.startsWith('[')) {
+            const jsonResult = parseJsonValue(afterMarker, 0);
+            if (jsonResult) {
+                const parsed = jsonResult.parsed;
+                // Handle single object or array of objects
+                const items = Array.isArray(parsed) ? parsed : [parsed];
+                let foundToolCall = false;
+                for (const item of items) {
+                    if (item && typeof item === 'object' && item.type === 'function' && item.function) {
+                        toolCallCount += 1;
+                        const toolName = typeof item.function.name === 'string'
+                            ? item.function.name
+                            : mapToolIdToName(item.function.name);
+                        parts.push({
+                            type: 'tool-call',
+                            toolCallId: `toolcall_${toolCallCount}`,
+                            toolName,
+                            input: JSON.stringify(item.function.parameters ?? {}),
+                        });
+                        foundToolCall = true;
+                    }
+                }
+                if (foundToolCall) {
+                    cursor = markerStart + TOOL_CALL_PREFIX.length + jsonResult.endIndex;
+                    continue;
+                }
+            }
+            // Not a valid OpenAI format, treat as text
+            pushText(parts, responseText.slice(markerStart, markerStart + TOOL_CALL_PREFIX.length));
+            cursor = markerStart + TOOL_CALL_PREFIX.length;
+            continue;
+        }
+        // Try [TOOL_CALLS]tool_name[ARGS]{...} format first (has ARGS marker)
+        const argsStart = responseText.indexOf(ARGS_PREFIX, markerStart + TOOL_CALL_PREFIX.length);
+        if (argsStart !== -1) {
+            const toolName = responseText.slice(markerStart + TOOL_CALL_PREFIX.length, argsStart);
+            const parsedArgs = parseJsonValue(responseText, argsStart + ARGS_PREFIX.length);
+            if (parsedArgs) {
+                toolCallCount += 1;
+                parts.push({
+                    type: 'tool-call',
+                    toolCallId: `toolcall_${toolCallCount}`,
+                    toolName,
+                    input: JSON.stringify(parsedArgs.parsed),
+                });
+                cursor = parsedArgs.endIndex;
+                continue;
+            }
+            // Malformed ARGS, skip
+            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;
+        }
+        // Try [TOOL_CALLS]tool_name{...} format (no ARGS marker)
+        const afterPrefix = responseText.slice(markerStart + TOOL_CALL_PREFIX.length);
+        const jsonStart = afterPrefix.indexOf('{');
+        if (jsonStart !== -1) {
+            const toolName = afterPrefix.slice(0, jsonStart).trim();
+            const parsedArgs = parseJsonValue(afterPrefix, jsonStart);
+            if (parsedArgs && toolName) {
+                toolCallCount += 1;
+                parts.push({
+                    type: 'tool-call',
+                    toolCallId: `toolcall_${toolCallCount}`,
+                    toolName,
+                    input: JSON.stringify(parsedArgs.parsed),
+                });
+                cursor = markerStart + TOOL_CALL_PREFIX.length + parsedArgs.endIndex;
+                continue;
+            }
+        }
+        // No valid format found
+        pushText(parts, responseText.slice(markerStart));
+        break;
+    }
     return parts;
 }

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

@@ -31,38 +31,65 @@ describe('convertResponse', () => {
         const result = convertResponse(Buffer.from(input, 'utf8'));
         expect(result).toEqual([{ type: 'text', text: 'Hello world' }]);
     });
-    // Strict OpenAI array format tests
-    it('parses strict OpenAI array with single tool call', () => {
-        const input = '[{"type":"function","function":{"name":"search","parameters":{"q":"test"}}}]';
+    // Native Windsurf marker format tests
+    it('parses native marker format [TOOL_CALLS]name[ARGS]{json}', () => {
+        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: 'search', input: { q: 'test' } }
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'search', input: '{"q":"test"}' }
         ]);
     });
-    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"}}}]';
+    it('parses marker format with text before tool call', () => {
+        const input = 'Some text before[TOOL_CALLS]read[ARGS]{"path":"/foo"}';
         const result = convertResponse(Buffer.from(input, 'utf8'));
         expect(result).toEqual([
-            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: { path: '/a' } },
-            { type: 'tool-call', toolCallId: 'toolcall_2', toolName: 'grep', input: { pattern: 'foo' } }
+            { type: 'text', text: 'Some text before' },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: '{"path":"/foo"}' }
         ]);
     });
-    it('parses strict OpenAI array with empty parameters', () => {
-        const input = '[{"type":"function","function":{"name":"list","parameters":{}}}]';
+    it('parses marker format with text after tool call', () => {
+        const input = '[TOOL_CALLS]grep[ARGS]{"pattern":"foo"}Some text after';
         const result = convertResponse(Buffer.from(input, 'utf8'));
         expect(result).toEqual([
-            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'list', input: {} }
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'grep', input: '{"pattern":"foo"}' },
+            { type: 'text', text: 'Some text after' }
         ]);
     });
-    it('returns text for old marker format (no backward compat)', () => {
-        const input = '[TOOL_CALLS]search[ARGS]{"q":"test"}';
+    it('parses multiple tool calls in marker format', () => {
+        const input = '[TOOL_CALLS]read[ARGS]{"path":"/a"}[TOOL_CALLS]grep[ARGS]{"pattern":"foo"}';
         const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([{ type: 'text', text: '[TOOL_CALLS]search[ARGS]{"q":"test"}' }]);
+        expect(result).toEqual([
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: '{"path":"/a"}' },
+            { type: 'tool-call', toolCallId: 'toolcall_2', toolName: 'grep', input: '{"pattern":"foo"}' }
+        ]);
     });
-    it('returns text for old TOOL_CALLS format (no backward compat)', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"q":"test"}}}{}';
+    it('parses TOOL_CALLS format with numeric tool id', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"pattern":"test"}}}';
         const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([{ type: 'text', text: input }]);
+        expect(result).toEqual([
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'grep', input: '{"pattern":"test"}' }
+        ]);
+    });
+    it('maps tool id 1 to read', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":1,"parameters":{"path":"/file"}}}';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: '{"path":"/file"}' }
+        ]);
+    });
+    it('maps tool id 2 to glob', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":2,"parameters":{"pattern":"*.ts"}}}';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'glob', input: '{"pattern":"*.ts"}' }
+        ]);
+    });
+    it('maps unknown tool id to tool_N', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":99,"parameters":{}}}';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'tool_99', input: '{}' }
+        ]);
     });
     it('returns text for non-array JSON', () => {
         const input = '{"type":"function","function":{"name":"search","parameters":{}}}';

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

@@ -17,13 +17,18 @@ 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.
+const TOOL_FORMAT_INSTRUCTION = `CRITICAL: When using tools, output ONLY a JSON array (no text before or after). Use this EXACT format:
 
-Example format:
-[{"type": "function", "function": {"name": "tool_name", "parameters": {"arg1": "value1"}}}]
+[{"type":"function","function":{"name":"tool_name","parameters":{"arg":"value"}}}]
 
-For multiple tool calls:
-[{"type": "function", "function": {"name": "tool1", "parameters": {"arg1": "value1"}}}, {"type": "function", "function": {"name": "tool2", "parameters": {"arg2": "value2"}}}]`;
+RULES:
+- Start with [ and end with ]
+- Each tool call has: type="function", function.name (string), function.parameters (object)
+- NO markdown, NO code blocks, NO [TOOL_CALLS] markers
+- Use the EXACT parameter names from the tool definition
+
+Example for calculator(a, b):
+[{"type":"function","function":{"name":"calculator","parameters":{"a":15,"b":27}}}]`;
 export class DevstralLanguageModel {
     specificationVersion = 'v2';
     provider = 'windsurf';

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('[{"type":"function","function":{"name":"searchRepo","parameters":{"query":"jwt manager"}}}]', 'utf8');
+            const payload = Buffer.from('[TOOL_CALLS]searchRepo[ARGS]{"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' });
@@ -302,9 +302,9 @@ describe('DevstralLanguageModel doGenerate', () => {
         });
         const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
         const combined = strings.join('\n');
-        expect(combined).toContain('When you need to call tools');
+        expect(combined).toContain('CRITICAL: When using tools');
     });
-    it('does not inject tool format instruction when no tools provided', async () => {
+    it('does not inject tool format instruction when no tools present', async () => {
         const requestBodies = [];
         const jwt = makeJwt(4_200_000_101, 'no-instruction');
         const fakeFetch = async (input, init) => {
@@ -321,9 +321,9 @@ describe('DevstralLanguageModel doGenerate', () => {
         });
         const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
         const combined = strings.join('\n');
-        expect(combined).not.toContain('When you need to call tools');
+        expect(combined).not.toContain('CRITICAL: When using tools');
     });
-    it('does not inject tool format instruction when only provider-defined tools', async () => {
+    it('injects tool format instruction for function tools only, not provider-defined', async () => {
         const requestBodies = [];
         const jwt = makeJwt(4_200_000_102, 'provider-only');
         const fakeFetch = async (input, init) => {
@@ -348,7 +348,7 @@ describe('DevstralLanguageModel doGenerate', () => {
         });
         const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
         const combined = strings.join('\n');
-        expect(combined).not.toContain('When you need to call tools');
+        expect(combined).not.toContain('CRITICAL: When using tools');
     });
 });
 describe('DevstralLanguageModel doStream', () => {
@@ -454,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('[{"type":"function","function":{"name":"searchRepo","parameters":{"query":"jwt manager"}}}]', 'utf8');
+        const toolPayload = Buffer.from('[TOOL_CALLS]searchRepo[ARGS]{"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.2",
+  "version": "1.1.4",
   "description": "AI SDK V3 provider for Windsurf's Devstral code search API",
   "type": "module",
   "scripts": {