@bxb1337/windsurf-fast-context 1.1.1 → 1.1.3

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

@@ -3,38 +3,192 @@ 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) {
+    if (!responseText.startsWith('TOOL_CALLS')) {
         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;
     }
-    catch {
+    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) {
         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);
@@ -62,6 +216,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 +239,43 @@ function decodeResponseText(buffer) {
 function convertResponse(buffer) {
     let responseText = decodeResponseText(buffer);
     responseText = responseText.replace(STOP_TOKEN, '');
-    const strictToolCalls = parseStrictOpenAIToolCalls(responseText);
-    if (strictToolCalls)
-        return strictToolCalls;
+    const openaiToolCalls = parseOpenAIToolCalls(responseText);
+    if (openaiToolCalls) {
+        return openaiToolCalls;
+    }
     const parts = [];
-    pushText(parts, responseText);
+    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;
+    }
     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' } }
         ]);
     });
-    (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: 'text', text: 'Some text before' },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: { path: '/foo' } }
+        ]);
+    });
+    (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: 'grep', input: { pattern: 'foo' } },
+            { type: 'text', text: 'Some text after' }
+        ]);
+    });
+    (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: '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)('parses strict OpenAI array with empty parameters', () => {
-        const input = '[{"type":"function","function":{"name":"list","parameters":{}}}]';
+    (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: 'tool-call', toolCallId: 'toolcall_1', toolName: 'list', input: {} }
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'grep', input: { pattern: 'test' } }
         ]);
     });
-    (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)('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: 'text', text: '[TOOL_CALLS]search[ARGS]{"q":"test"}' }]);
+        (0, vitest_1.expect)(result).toEqual([
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: { path: '/file' } }
+        ]);
     });
-    (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)('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: 'text', text: input }]);
+        (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

@@ -279,9 +279,7 @@ function buildGenerateRequest(input) {
     const request = new protobuf_js_1.ProtobufEncoder();
     request.writeMessage(1, buildMetadata(input.apiKey, input.jwt));
     const functionTools = input.tools?.filter(isFunctionTool) ?? [];
-    const messages = functionTools.length > 0
-        ? [{ role: 5, content: TOOL_FORMAT_INSTRUCTION }, ...input.messages]
-        : input.messages;
+    const messages = [{ role: 5, content: TOOL_FORMAT_INSTRUCTION }, ...input.messages];
     for (const message of messages) {
         request.writeMessage(2, buildMessage(message));
     }

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' });
@@ -306,7 +306,7 @@ async function collectStreamParts(stream) {
         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 () => {
+    (0, vitest_1.it)('always injects tool format instruction even without tools', 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).toContain('When you need to call tools');
     });
-    (0, vitest_1.it)('does not inject tool format instruction when only provider-defined tools', async () => {
+    (0, vitest_1.it)('always injects tool format instruction even with only provider-defined tools', 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).toContain('When you need to call 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/esm/conversion/response-converter.js

@@ -1,37 +1,191 @@
 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) {
+    if (!responseText.startsWith('TOOL_CALLS')) {
         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;
     }
-    catch {
+    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) {
         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);
@@ -59,6 +213,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 +236,43 @@ function decodeResponseText(buffer) {
 export function convertResponse(buffer) {
     let responseText = decodeResponseText(buffer);
     responseText = responseText.replace(STOP_TOKEN, '');
-    const strictToolCalls = parseStrictOpenAIToolCalls(responseText);
-    if (strictToolCalls)
-        return strictToolCalls;
+    const openaiToolCalls = parseOpenAIToolCalls(responseText);
+    if (openaiToolCalls) {
+        return openaiToolCalls;
+    }
     const parts = [];
-    pushText(parts, responseText);
+    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;
+    }
     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' } }
         ]);
     });
-    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: 'text', text: 'Some text before' },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: { path: '/foo' } }
+        ]);
+    });
+    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: 'grep', input: { pattern: 'foo' } },
+            { type: 'text', text: 'Some text after' }
+        ]);
+    });
+    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: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: { path: '/a' } },
             { type: 'tool-call', toolCallId: 'toolcall_2', toolName: 'grep', input: { pattern: 'foo' } }
         ]);
     });
-    it('parses strict OpenAI array with empty parameters', () => {
-        const input = '[{"type":"function","function":{"name":"list","parameters":{}}}]';
+    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: 'tool-call', toolCallId: 'toolcall_1', toolName: 'list', input: {} }
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'grep', input: { pattern: 'test' } }
         ]);
     });
-    it('returns text for old marker format (no backward compat)', () => {
-        const input = '[TOOL_CALLS]search[ARGS]{"q":"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: 'text', text: '[TOOL_CALLS]search[ARGS]{"q":"test"}' }]);
+        expect(result).toEqual([
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: { path: '/file' } }
+        ]);
     });
-    it('returns text for old TOOL_CALLS format (no backward compat)', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"q":"test"}}}{}';
+    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: 'text', text: input }]);
+        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

@@ -275,9 +275,7 @@ function buildGenerateRequest(input) {
     const request = new ProtobufEncoder();
     request.writeMessage(1, buildMetadata(input.apiKey, input.jwt));
     const functionTools = input.tools?.filter(isFunctionTool) ?? [];
-    const messages = functionTools.length > 0
-        ? [{ role: 5, content: TOOL_FORMAT_INSTRUCTION }, ...input.messages]
-        : input.messages;
+    const messages = [{ role: 5, content: TOOL_FORMAT_INSTRUCTION }, ...input.messages];
     for (const message of messages) {
         request.writeMessage(2, buildMessage(message));
     }

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' });
@@ -304,7 +304,7 @@ describe('DevstralLanguageModel doGenerate', () => {
         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 () => {
+    it('always injects tool format instruction even without tools', 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).toContain('When you need to call tools');
     });
-    it('does not inject tool format instruction when only provider-defined tools', async () => {
+    it('always injects tool format instruction even with only provider-defined tools', 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).toContain('When you need to call 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.1",
+  "version": "1.1.3",
   "description": "AI SDK V3 provider for Windsurf's Devstral code search API",
   "type": "module",
   "scripts": {