@bxb1337/windsurf-fast-context 1.0.6 → 1.0.8

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

@@ -69,6 +69,9 @@ function decodeRequestPayload(body) {
     const decodedFrames = (0, connect_frame_js_1.connectFrameDecode)(body);
     return decodedFrames[0] ?? Buffer.alloc(0);
 }
+function extractToolsPayload(strings) {
+    return strings.find((value) => value.startsWith('[{"type":"function"'));
+}
 async function collectStreamParts(stream) {
     const reader = stream.getReader();
     const parts = [];
@@ -136,7 +139,7 @@ async function collectStreamParts(stream) {
             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).toBe('stop');
+        (0, vitest_1.expect)(result.finishReason).toEqual({ unified: 'stop', raw: undefined });
         (0, vitest_1.expect)(result.usage).toEqual({
             inputTokens: {
                 total: undefined,
@@ -159,7 +162,7 @@ async function collectStreamParts(stream) {
         (0, vitest_1.expect)(combined).toContain(jwt);
         (0, vitest_1.expect)(combined).toContain('Find auth logic.');
     });
-    (0, vitest_1.it)('generate request with tool markers returns tool-call content parts', async () => {
+    (0, vitest_1.it)('doGenerate accepts function tools array with inputSchema', async () => {
         const requestBodies = [];
         const jwt = makeJwt(4_200_000_000, 'tools');
         const fakeFetch = async (input, init) => {
@@ -174,10 +177,12 @@ async function collectStreamParts(stream) {
         const model = new devstral_language_model_js_1.DevstralLanguageModel({ apiKey: 'tools-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
         const result = await model.doGenerate({
             prompt: [{ role: 'user', content: [{ type: 'text', text: 'Inspect jwt manager.' }] }],
-            tools: {
-                searchRepo: {
+            tools: [
+                {
+                    type: 'function',
+                    name: 'searchRepo',
                     description: 'Search repository files',
-                    parameters: {
+                    inputSchema: {
                         type: 'object',
                         properties: {
                             query: { type: 'string' },
@@ -185,7 +190,7 @@ async function collectStreamParts(stream) {
                         required: ['query'],
                     },
                 },
-            },
+            ],
         });
         (0, vitest_1.expect)(result.content).toEqual([
             {
@@ -195,12 +200,88 @@ async function collectStreamParts(stream) {
                 input: '{"query":"jwt manager"}',
             },
         ]);
+        (0, vitest_1.expect)(result.finishReason).toEqual({ unified: 'tool-calls', raw: undefined });
         const strings = (0, protobuf_js_1.extractStrings)(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
-        const combined = strings.join('\n');
-        (0, vitest_1.expect)(combined).toContain('searchRepo');
-        (0, vitest_1.expect)(combined).toContain('Search repository files');
-        (0, vitest_1.expect)(combined).toContain('Inspect jwt manager.');
-        (0, vitest_1.expect)(combined).toContain('query');
+        const toolsPayload = extractToolsPayload(strings);
+        (0, vitest_1.expect)(toolsPayload).toBeDefined();
+        const parsedTools = JSON.parse(toolsPayload ?? '[]');
+        (0, vitest_1.expect)(parsedTools).toEqual([
+            {
+                type: 'function',
+                function: {
+                    name: 'searchRepo',
+                    description: 'Search repository files',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string' },
+                        },
+                        required: ['query'],
+                    },
+                },
+            },
+        ]);
+    });
+    (0, vitest_1.it)('filters provider tools from tools array serialization', async () => {
+        const requestBodies = [];
+        const jwt = makeJwt(4_200_000_001, 'provider-tools');
+        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: 'Filter provider tools.' }] }],
+            tools: [
+                {
+                    type: 'function',
+                    name: 'searchRepo',
+                    description: 'Search repository files',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string' },
+                        },
+                        required: ['query'],
+                    },
+                },
+                {
+                    type: 'provider',
+                    id: 'windsurf.restricted_exec',
+                    name: 'restricted_exec',
+                    args: { mode: 'read-only' },
+                },
+            ],
+        });
+        const strings = (0, protobuf_js_1.extractStrings)(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const toolsPayload = extractToolsPayload(strings);
+        (0, vitest_1.expect)(toolsPayload).toBeDefined();
+        const parsedTools = JSON.parse(toolsPayload ?? '[]');
+        (0, vitest_1.expect)(parsedTools).toHaveLength(1);
+        (0, vitest_1.expect)(parsedTools[0]).toMatchObject({ function: { name: 'searchRepo' } });
+    });
+    (0, vitest_1.it)('handles empty tools array without serializing tool payload', async () => {
+        const requestBodies = [];
+        const jwt = makeJwt(4_200_000_002, 'empty-tools');
+        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: 'No tools this turn.' }] }],
+            tools: [],
+        });
+        const strings = (0, protobuf_js_1.extractStrings)(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        (0, vitest_1.expect)(extractToolsPayload(strings)).toBeUndefined();
     });
 });
 (0, vitest_1.describe)('DevstralLanguageModel doStream', () => {
@@ -289,8 +370,10 @@ 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: 'stop',
-                rawFinishReason: 'stop',
+                finishReason: {
+                    unified: 'stop',
+                    raw: undefined,
+                },
                 usage: {
                     inputTokens: {
                         total: undefined,
@@ -331,10 +414,12 @@ async function collectStreamParts(stream) {
         });
         const result = await model.doStream({
             prompt: [{ role: 'user', content: [{ type: 'text', text: 'Call tools.' }] }],
-            tools: {
-                searchRepo: {
+            tools: [
+                {
+                    type: 'function',
+                    name: 'searchRepo',
                     description: 'Search repository files',
-                    parameters: {
+                    inputSchema: {
                         type: 'object',
                         properties: {
                             query: { type: 'string' },
@@ -342,7 +427,7 @@ async function collectStreamParts(stream) {
                         required: ['query'],
                     },
                 },
-            },
+            ],
         });
         const parts = await collectStreamParts(result.stream);
         (0, vitest_1.expect)(parts.map((part) => part.type)).toEqual([
@@ -361,6 +446,26 @@ async function collectStreamParts(stream) {
             toolName: 'searchRepo',
             input: '{"query":"jwt manager"}',
         });
+        (0, vitest_1.expect)(parts[6]).toEqual({
+            type: 'finish',
+            finishReason: {
+                unified: 'tool-calls',
+                raw: undefined,
+            },
+            usage: {
+                inputTokens: {
+                    total: undefined,
+                    noCache: undefined,
+                    cacheRead: undefined,
+                    cacheWrite: undefined,
+                },
+                outputTokens: {
+                    total: undefined,
+                    text: undefined,
+                    reasoning: undefined,
+                },
+            },
+        });
     });
     (0, vitest_1.it)('abort stops stream mid-response', async () => {
         const controller = new AbortController();

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

@@ -1,49 +1,3 @@
+import type { LanguageModelV3Prompt } from '@ai-sdk/provider';
 import type { DevstralMessage } from '../types/index.js';
-export type LanguageModelV3Prompt = Array<{
-    role: 'system';
-    content: string;
-} | {
-    role: 'user';
-    content: Array<{
-        type: 'text';
-        text: string;
-    } | {
-        type: 'file';
-        data: string;
-        mediaType: string;
-    } | {
-        type: 'image';
-        image: string;
-    }>;
-} | {
-    role: 'assistant';
-    content: Array<{
-        type: 'text';
-        text: string;
-    } | {
-        type: 'tool-call';
-        toolCallId: string;
-        toolName: string;
-        input: unknown;
-    } | {
-        type: 'file';
-        data: string;
-        mediaType: string;
-    } | {
-        type: 'image';
-        image: string;
-    } | {
-        type: 'reasoning';
-        text: string;
-    }>;
-} | {
-    role: 'tool';
-    content: Array<{
-        type: 'tool-result';
-        toolCallId: string;
-        toolName: string;
-        result: unknown;
-        isError?: boolean;
-    }>;
-}>;
 export declare function convertPrompt(prompt: LanguageModelV3Prompt): DevstralMessage[];

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

@@ -1,8 +1,22 @@
-function toContentString(value) {
-    if (typeof value === 'string') {
-        return value;
+function toolOutputToString(output) {
+    switch (output.type) {
+        case 'text':
+        case 'error-text':
+            return output.value;
+        case 'json':
+        case 'error-json':
+            return JSON.stringify(output.value);
+        case 'execution-denied': {
+            const obj = { type: 'execution-denied' };
+            if (output.reason !== undefined)
+                obj.reason = output.reason;
+            return JSON.stringify(obj);
+        }
+        case 'content':
+            return JSON.stringify(output.value);
+        default:
+            return JSON.stringify(output);
     }
-    return JSON.stringify(value);
 }
 export function convertPrompt(prompt) {
     const messages = [];
@@ -39,13 +53,14 @@ export function convertPrompt(prompt) {
             }
             continue;
         }
-        // Tool result messages - use refCallId to reference the original tool call
         for (const part of message.content) {
+            if (part.type !== 'tool-result')
+                continue;
             messages.push({
                 role: 4,
-                content: toContentString(part.result),
+                content: toolOutputToString(part.output),
                 metadata: {
-                    refCallId: part.toolCallId, // This links back to the tool call
+                    refCallId: part.toolCallId,
                 },
             });
         }

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

@@ -34,7 +34,7 @@ describe('convertPrompt', () => {
             },
         });
     });
-    it('multi-turn preserves ordering across mixed roles', () => {
+    it('multi-turn preserves ordering across mixed roles (V3 output shape)', () => {
         const prompt = [
             { role: 'system', content: 'System instruction' },
             {
@@ -58,7 +58,7 @@ describe('convertPrompt', () => {
                         type: 'tool-result',
                         toolCallId: 'call_2',
                         toolName: 'searchDocs',
-                        result: { hits: ['a.ts', 'b.ts'] },
+                        output: { type: 'json', value: { hits: ['a.ts', 'b.ts'] } },
                     },
                 ],
             },
@@ -90,4 +90,119 @@ describe('convertPrompt', () => {
         ]);
         expect(prompt).toEqual(snapshot);
     });
+    it('tool-result with json output serializes value to JSON', () => {
+        const prompt = [
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call_json',
+                        toolName: 'searchTool',
+                        output: { type: 'json', value: { files: ['x.ts', 'y.ts'], count: 2 } },
+                    },
+                ],
+            },
+        ];
+        const result = convertPrompt(prompt);
+        expect(result).toEqual([
+            {
+                role: 4,
+                content: '{"files":["x.ts","y.ts"],"count":2}',
+                metadata: { refCallId: 'call_json' },
+            },
+        ]);
+    });
+    it('tool-result with text output uses string directly', () => {
+        const prompt = [
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call_text',
+                        toolName: 'readFile',
+                        output: { type: 'text', value: 'Operation completed successfully' },
+                    },
+                ],
+            },
+        ];
+        const result = convertPrompt(prompt);
+        expect(result).toEqual([
+            {
+                role: 4,
+                content: 'Operation completed successfully',
+                metadata: { refCallId: 'call_text' },
+            },
+        ]);
+    });
+    it('tool-result with error-text output serializes error message', () => {
+        const prompt = [
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call_error',
+                        toolName: 'executeCommand',
+                        output: { type: 'error-text', value: 'Tool execution failed: timeout' },
+                    },
+                ],
+            },
+        ];
+        const result = convertPrompt(prompt);
+        expect(result).toEqual([
+            {
+                role: 4,
+                content: 'Tool execution failed: timeout',
+                metadata: { refCallId: 'call_error' },
+            },
+        ]);
+    });
+    it('tool-result with execution-denied output includes reason', () => {
+        const prompt = [
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call_denied',
+                        toolName: 'dangerousAction',
+                        output: { type: 'execution-denied', reason: 'User rejected tool execution' },
+                    },
+                ],
+            },
+        ];
+        const result = convertPrompt(prompt);
+        expect(result).toEqual([
+            {
+                role: 4,
+                content: '{"type":"execution-denied","reason":"User rejected tool execution"}',
+                metadata: { refCallId: 'call_denied' },
+            },
+        ]);
+    });
+    it('tool-result with execution-denied output handles missing reason', () => {
+        const prompt = [
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call_denied_no_reason',
+                        toolName: 'someTool',
+                        output: { type: 'execution-denied' },
+                    },
+                ],
+            },
+        ];
+        const result = convertPrompt(prompt);
+        expect(result).toEqual([
+            {
+                role: 4,
+                content: '{"type":"execution-denied"}',
+                metadata: { refCallId: 'call_denied_no_reason' },
+            },
+        ]);
+    });
 });

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

@@ -3,9 +3,6 @@ import { extractStrings } from '../protocol/protobuf.js';
 const TOOL_CALL_PREFIX = '[TOOL_CALLS]';
 const ARGS_PREFIX = '[ARGS]';
 const STOP_TOKEN = '</s>';
-const EMPTY_TOOL_CALLS_PATTERN = /TOOL_CALLS\d*(?:<\/s>)?\s*(?:\{\s*\}\s*)+/g;
-// OpenAI-style TOOL_CALLS format: TOOL_CALLS{"type":"function","function":{"name":3,...}}{}...
-const OPENAI_TOOL_CALLS_PATTERN = /^TOOL_CALLS(\{[\s\S]*\}\s*)+\s*$/;
 function parseOpenAIToolCalls(responseText) {
     if (!responseText.startsWith('TOOL_CALLS')) {
         return null;
@@ -72,20 +69,6 @@ function pushText(parts, text) {
         parts.push({ type: 'text', text });
     }
 }
-function extractAnswerText(args) {
-    if (typeof args === 'string') {
-        return args;
-    }
-    if (args != null && typeof args === 'object') {
-        if ('answer' in args && typeof args.answer === 'string') {
-            return args.answer;
-        }
-        if ('text' in args && typeof args.text === 'string') {
-            return args.text;
-        }
-    }
-    return JSON.stringify(args);
-}
 function parseStringEnd(value, startIndex) {
     let index = startIndex + 1;
     let escaping = false;
@@ -252,7 +235,6 @@ function decodeResponseText(buffer) {
 }
 export function convertResponse(buffer) {
     let responseText = decodeResponseText(buffer);
-    responseText = responseText.replace(EMPTY_TOOL_CALLS_PATTERN, '');
     responseText = responseText.replace(STOP_TOKEN, '');
     const openaiToolCalls = parseOpenAIToolCalls(responseText);
     if (openaiToolCalls) {
@@ -283,18 +265,13 @@ export function convertResponse(buffer) {
             cursor = malformedEnd;
             continue;
         }
-        if (toolName === 'answer') {
-            pushText(parts, extractAnswerText(parsedArgs.parsed));
-        }
-        else {
-            toolCallCount += 1;
-            parts.push({
-                type: 'tool-call',
-                toolCallId: `toolcall_${toolCallCount}`,
-                toolName,
-                input: parsedArgs.parsed,
-            });
-        }
+        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

@@ -19,7 +19,12 @@ describe('convertResponse', () => {
                 input: { query: 'prompt converter' },
             },
             { type: 'text', text: ' between ' },
-            { type: 'text', text: 'final answer' },
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_2',
+                toolName: 'answer',
+                input: { answer: 'final answer' },
+            },
             { type: 'text', text: ' after' },
         ]);
     });
@@ -46,7 +51,14 @@ describe('convertResponse', () => {
         payload.writeVarint(1, 150);
         payload.writeString(2, '[TOOL_CALLS]answer[ARGS]{"answer":"final answer"}');
         const result = convertResponse(payload.toBuffer());
-        expect(result).toEqual([{ type: 'text', text: 'final answer' }]);
+        expect(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'answer',
+                input: { answer: 'final answer' },
+            },
+        ]);
     });
     it('protobuf payload - ignores metadata strings and keeps main text field', () => {
         const payload = new ProtobufEncoder();
@@ -60,76 +72,11 @@ describe('convertResponse', () => {
         const result = convertResponse(compressed);
         expect(result).toEqual([{ type: 'text', text: 'hello from gzip' }]);
     });
-    it('strips empty TOOL_CALLS markers with stop token', () => {
-        const input = 'Hello world TOOL_CALLS0</s>{}';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([{ type: 'text', text: 'Hello world ' }]);
-    });
-    it('strips empty TOOL_CALLS markers without stop token', () => {
-        const input = 'Hello world TOOL_CALLS1{}';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([{ type: 'text', text: 'Hello world ' }]);
-    });
-    it('strips empty TOOL_CALLS markers with whitespace', () => {
-        const input = 'Text TOOL_CALLS2{   } more text';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([{ type: 'text', text: 'Text more text' }]);
-    });
     it('strips standalone stop token', () => {
         const input = 'Hello world</s>';
         const result = convertResponse(Buffer.from(input, 'utf8'));
         expect(result).toEqual([{ type: 'text', text: 'Hello world' }]);
     });
-    it('handles TOOL_CALLS with number prefix before stop token', () => {
-        const input = 'Text before TOOL_CALLS1</s>{} text after';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([{ type: 'text', text: 'Text before text after' }]);
-    });
-    it('strips TOOL_CALLS with double empty braces', () => {
-        const input = 'Hello world TOOL_CALLS1{}{}';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([{ type: 'text', text: 'Hello world ' }]);
-    });
-    it('strips TOOL_CALLS with triple empty braces', () => {
-        const input = 'Response TOOL_CALLS2{}{}{} end';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([{ type: 'text', text: 'Response end' }]);
-    });
-    it('strips TOOL_CALLS with stop token and multiple braces', () => {
-        const input = 'Text TOOL_CALLS0</s>{}{} more text';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([{ type: 'text', text: 'Text more text' }]);
-    });
-    it('handles empty marker followed by real tool call', () => {
-        const input = 'TOOL_CALLS0{} [TOOL_CALLS]searchDocs[ARGS]{"query":"test"}';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'searchDocs',
-                input: { query: 'test' },
-            },
-        ]);
-    });
-    it('handles real tool call followed by empty marker', () => {
-        const input = '[TOOL_CALLS]searchDocs[ARGS]{"query":"test"} TOOL_CALLS1{} done';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'searchDocs',
-                input: { query: 'test' },
-            },
-            { type: 'text', text: ' done' },
-        ]);
-    });
-    it('handles empty marker adjacent to real tool call', () => {
-        const input = 'TOOL_CALLS0{}[TOOL_CALLS]answer[ARGS]{"answer":"result"}';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([{ type: 'text', text: 'result' }]);
-    });
     it('parses OpenAI-style TOOL_CALLS with numeric IDs', () => {
         const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"file_path":"/home/test","search_pattern":"binance"}}}{}';
         const result = convertResponse(Buffer.from(input, 'utf8'));
@@ -184,4 +131,16 @@ describe('convertResponse', () => {
             },
         ]);
     });
+    it('handles OpenAI-style with string name "answer" - emits as tool-call', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":"answer","parameters":{"answer":"final answer"}}}{}';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'answer',
+                input: { answer: 'final answer' },
+            },
+        ]);
+    });
 });