@bxb1337/windsurf-fast-context 1.0.9 → 1.1.1

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

@@ -133,25 +133,17 @@ async function collectStreamParts(stream) {
             });
         };
         const model = new devstral_language_model_js_1.DevstralLanguageModel({ apiKey: 'test-api-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
-        (0, vitest_1.expect)(model.specificationVersion).toBe('v3');
+        (0, vitest_1.expect)(model.specificationVersion).toBe('v2');
         (0, vitest_1.expect)(model.supportedUrls).toEqual({});
         const result = await model.doGenerate({
             prompt: [{ role: 'user', content: [{ type: 'text', text: 'Find auth logic.' }] }],
         });
         (0, vitest_1.expect)(result.content).toEqual([{ type: 'text', text: 'generated answer' }]);
-        (0, vitest_1.expect)(result.finishReason).toEqual({ unified: 'stop', raw: undefined });
+        (0, vitest_1.expect)(result.finishReason).toBe('stop');
         (0, vitest_1.expect)(result.usage).toEqual({
-            inputTokens: {
-                total: undefined,
-                noCache: undefined,
-                cacheRead: undefined,
-                cacheWrite: undefined,
-            },
-            outputTokens: {
-                total: undefined,
-                text: undefined,
-                reasoning: undefined,
-            },
+            inputTokens: undefined,
+            outputTokens: undefined,
+            totalTokens: undefined,
         });
         (0, vitest_1.expect)(calls).toHaveLength(2);
         (0, vitest_1.expect)(calls[0]?.url).toBe('https://windsurf.test/exa.auth_pb.AuthService/GetUserJwt');
@@ -171,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' });
@@ -200,7 +192,7 @@ async function collectStreamParts(stream) {
                 input: '{"query":"jwt manager"}',
             },
         ]);
-        (0, vitest_1.expect)(result.finishReason).toEqual({ unified: 'tool-calls', raw: undefined });
+        (0, vitest_1.expect)(result.finishReason).toBe('tool-calls');
         const strings = (0, protobuf_js_1.extractStrings)(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
         const toolsPayload = extractToolsPayload(strings);
         (0, vitest_1.expect)(toolsPayload).toBeDefined();
@@ -250,7 +242,7 @@ async function collectStreamParts(stream) {
                     },
                 },
                 {
-                    type: 'provider',
+                    type: 'provider-defined',
                     id: 'windsurf.restricted_exec',
                     name: 'restricted_exec',
                     args: { mode: 'read-only' },
@@ -283,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 () => {
@@ -370,22 +439,11 @@ async function collectStreamParts(stream) {
             (0, vitest_1.expect)(parts[4]).toMatchObject({ type: 'text-delta', delta: 'world' });
             (0, vitest_1.expect)(parts[6]).toEqual({
                 type: 'finish',
-                finishReason: {
-                    unified: 'stop',
-                    raw: undefined,
-                },
+                finishReason: 'stop',
                 usage: {
-                    inputTokens: {
-                        total: undefined,
-                        noCache: undefined,
-                        cacheRead: undefined,
-                        cacheWrite: undefined,
-                    },
-                    outputTokens: {
-                        total: undefined,
-                        text: undefined,
-                        reasoning: undefined,
-                    },
+                    inputTokens: undefined,
+                    outputTokens: undefined,
+                    totalTokens: undefined,
                 },
             });
         }
@@ -398,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);
@@ -448,22 +506,11 @@ async function collectStreamParts(stream) {
         });
         (0, vitest_1.expect)(parts[6]).toEqual({
             type: 'finish',
-            finishReason: {
-                unified: 'tool-calls',
-                raw: undefined,
-            },
+            finishReason: 'tool-calls',
             usage: {
-                inputTokens: {
-                    total: undefined,
-                    noCache: undefined,
-                    cacheRead: undefined,
-                    cacheWrite: undefined,
-                },
-                outputTokens: {
-                    total: undefined,
-                    text: undefined,
-                    reasoning: undefined,
-                },
+                inputTokens: undefined,
+                outputTokens: undefined,
+                totalTokens: undefined,
             },
         });
     });

package/dist/conversion/prompt-converter.d.ts

@@ -1,3 +1,3 @@
-import type { LanguageModelV3Prompt } from '@ai-sdk/provider';
+import type { LanguageModelV2Prompt } from '@ai-sdk/provider';
 import type { DevstralMessage } from '../types/index.js';
-export declare function convertPrompt(prompt: LanguageModelV3Prompt): DevstralMessage[];
+export declare function convertPrompt(prompt: LanguageModelV2Prompt): DevstralMessage[];

package/dist/conversion/response-converter.d.ts

@@ -8,5 +8,5 @@ export interface ToolCallPart {
     toolName: string;
     input: unknown;
 }
-export type LanguageModelV3Content = TextPart | ToolCallPart;
-export declare function convertResponse(buffer: Buffer): LanguageModelV3Content[];
+export type LanguageModelV2Content = TextPart | ToolCallPart;
+export declare function convertResponse(buffer: Buffer): LanguageModelV2Content[];

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

@@ -34,7 +34,7 @@ describe('convertPrompt', () => {
             },
         });
     });
-    it('multi-turn preserves ordering across mixed roles (V3 output shape)', () => {
+    it('multi-turn preserves ordering across mixed roles (V2 output shape)', () => {
         const prompt = [
             { role: 'system', content: 'System instruction' },
             {
@@ -159,7 +159,7 @@ describe('convertPrompt', () => {
             },
         ]);
     });
-    it('tool-result with execution-denied output includes reason', () => {
+    it('tool-result with error-text output includes denial reason', () => {
         const prompt = [
             {
                 role: 'tool',
@@ -168,7 +168,7 @@ describe('convertPrompt', () => {
                         type: 'tool-result',
                         toolCallId: 'call_denied',
                         toolName: 'dangerousAction',
-                        output: { type: 'execution-denied', reason: 'User rejected tool execution' },
+                        output: { type: 'error-text', value: 'User rejected tool execution' },
                     },
                 ],
             },
@@ -177,12 +177,12 @@ describe('convertPrompt', () => {
         expect(result).toEqual([
             {
                 role: 4,
-                content: '{"type":"execution-denied","reason":"User rejected tool execution"}',
+                content: 'User rejected tool execution',
                 metadata: { refCallId: 'call_denied' },
             },
         ]);
     });
-    it('tool-result with execution-denied output handles missing reason', () => {
+    it('tool-result with error-text output handles fallback denial text', () => {
         const prompt = [
             {
                 role: 'tool',
@@ -191,7 +191,7 @@ describe('convertPrompt', () => {
                         type: 'tool-result',
                         toolCallId: 'call_denied_no_reason',
                         toolName: 'someTool',
-                        output: { type: 'execution-denied' },
+                        output: { type: 'error-text', value: 'Tool execution denied' },
                     },
                 ],
             },
@@ -200,7 +200,7 @@ describe('convertPrompt', () => {
         expect(result).toEqual([
             {
                 role: 4,
-                content: '{"type":"execution-denied"}',
+                content: 'Tool execution denied',
                 metadata: { refCallId: 'call_denied_no_reason' },
             },
         ]);

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;
 }