@bxb1337/windsurf-fast-context 1.0.4 → 1.0.6

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

@@ -35,7 +35,7 @@ function convertPrompt(prompt) {
                         metadata: {
                             toolCallId: part.toolCallId,
                             toolName: part.toolName,
-                            toolArgsJson: JSON.stringify(part.args),
+                            toolArgsJson: JSON.stringify(part.input),
                         },
                     });
                 }

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

@@ -18,7 +18,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
                         type: 'tool-call',
                         toolCallId: 'call_1',
                         toolName: 'searchDocs',
-                        args: { query: 'prompt converter', topK: 3 },
+                        input: { query: 'prompt converter', topK: 3 },
                     },
                 ],
             },
@@ -50,7 +50,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
                 role: 'assistant',
                 content: [
                     { type: 'text', text: 'I will call a tool now.' },
-                    { type: 'tool-call', toolCallId: 'call_2', toolName: 'searchDocs', args: { q: 'usage examples' } },
+                    { type: 'tool-call', toolCallId: 'call_2', toolName: 'searchDocs', input: { q: 'usage examples' } },
                 ],
             },
             {

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

@@ -6,7 +6,70 @@ const protobuf_js_1 = require("../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*\}/g;
+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;
+    }
+    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 });
@@ -194,6 +257,10 @@ 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) {
+        return openaiToolCalls;
+    }
     const parts = [];
     let cursor = 0;
     let toolCallCount = 0;
@@ -228,7 +295,7 @@ function convertResponse(buffer) {
                 type: 'tool-call',
                 toolCallId: `toolcall_${toolCallCount}`,
                 toolName,
-                args: parsedArgs.parsed,
+                input: parsedArgs.parsed,
             });
         }
         cursor = parsedArgs.endIndex;

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

@@ -18,7 +18,7 @@ const response_converter_js_1 = require("./response-converter.js");
                 type: 'tool-call',
                 toolCallId: 'toolcall_1',
                 toolName: 'searchDocs',
-                args: { query: 'prompt converter' },
+                input: { query: 'prompt converter' },
             },
             { type: 'text', text: ' between ' },
             { type: 'text', text: 'final answer' },
@@ -75,7 +75,7 @@ const response_converter_js_1 = require("./response-converter.js");
     (0, vitest_1.it)('strips empty TOOL_CALLS markers with whitespace', () => {
         const input = 'Text TOOL_CALLS2{   } more text';
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Text  more text' }]);
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Text more text' }]);
     });
     (0, vitest_1.it)('strips standalone stop token', () => {
         const input = 'Hello world</s>';
@@ -85,6 +85,105 @@ const response_converter_js_1 = require("./response-converter.js");
     (0, vitest_1.it)('handles TOOL_CALLS with number prefix before stop token', () => {
         const input = 'Text before TOOL_CALLS1</s>{} text after';
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Text before  text after' }]);
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Text before text after' }]);
+    });
+    (0, vitest_1.it)('strips TOOL_CALLS with double empty braces', () => {
+        const input = 'Hello world TOOL_CALLS1{}{}';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Hello world ' }]);
+    });
+    (0, vitest_1.it)('strips TOOL_CALLS with triple empty braces', () => {
+        const input = 'Response TOOL_CALLS2{}{}{} end';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Response end' }]);
+    });
+    (0, vitest_1.it)('strips TOOL_CALLS with stop token and multiple braces', () => {
+        const input = 'Text TOOL_CALLS0</s>{}{} more text';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Text more text' }]);
+    });
+    (0, vitest_1.it)('handles empty marker followed by real tool call', () => {
+        const input = 'TOOL_CALLS0{} [TOOL_CALLS]searchDocs[ARGS]{"query":"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: 'searchDocs',
+                input: { query: 'test' },
+            },
+        ]);
+    });
+    (0, vitest_1.it)('handles real tool call followed by empty marker', () => {
+        const input = '[TOOL_CALLS]searchDocs[ARGS]{"query":"test"} TOOL_CALLS1{} done';
+        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: 'searchDocs',
+                input: { query: 'test' },
+            },
+            { type: 'text', text: ' done' },
+        ]);
+    });
+    (0, vitest_1.it)('handles empty marker adjacent to real tool call', () => {
+        const input = 'TOOL_CALLS0{}[TOOL_CALLS]answer[ARGS]{"answer":"result"}';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'result' }]);
+    });
+    (0, vitest_1.it)('parses OpenAI-style TOOL_CALLS with numeric IDs', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"file_path":"/home/test","search_pattern":"binance"}}}{}';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'grep',
+                input: { file_path: '/home/test', search_pattern: 'binance' },
+            },
+        ]);
+    });
+    (0, vitest_1.it)('parses multiple OpenAI-style tool calls', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":1,"parameters":{"file_path":"/home/test"}}}, {"type":"function","function":{"name":2,"parameters":{"pattern":"*.ts"}}}{}';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'read',
+                input: { file_path: '/home/test' },
+            },
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_2',
+                toolName: 'glob',
+                input: { pattern: '*.ts' },
+            },
+        ]);
+    });
+    (0, vitest_1.it)('maps unknown tool IDs to tool_N format', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":99,"parameters":{"arg":"value"}}}{}';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'tool_99',
+                input: { arg: 'value' },
+            },
+        ]);
+    });
+    (0, vitest_1.it)('handles OpenAI-style with string tool names', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":"custom_tool","parameters":{"key":"value"}}}{}';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'custom_tool',
+                input: { key: 'value' },
+            },
+        ]);
     });
 });

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

@@ -140,17 +140,17 @@ class DevstralLanguageModel {
                                     closeTextSegment();
                                     safeEnqueue(controller, {
                                         type: 'tool-input-start',
-                                        toolCallId: part.toolCallId,
+                                        id: part.toolCallId,
                                         toolName: part.toolName,
                                     });
                                     safeEnqueue(controller, {
                                         type: 'tool-input-delta',
-                                        toolCallId: part.toolCallId,
-                                        delta: part.args,
+                                        id: part.toolCallId,
+                                        delta: part.input,
                                     });
                                     safeEnqueue(controller, {
                                         type: 'tool-input-end',
-                                        toolCallId: part.toolCallId,
+                                        id: part.toolCallId,
                                     });
                                     safeEnqueue(controller, part);
                                 }
@@ -256,10 +256,9 @@ function toV3Content(parts) {
         if (part.type === 'tool-call') {
             return {
                 type: 'tool-call',
-                toolCallType: 'function',
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                args: JSON.stringify(part.args),
+                input: JSON.stringify(part.input),
             };
         }
         return part;

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

@@ -190,10 +190,9 @@ async function collectStreamParts(stream) {
         (0, vitest_1.expect)(result.content).toEqual([
             {
                 type: 'tool-call',
-                toolCallType: 'function',
                 toolCallId: 'toolcall_1',
                 toolName: 'searchRepo',
-                args: '{"query":"jwt manager"}',
+                input: '{"query":"jwt manager"}',
             },
         ]);
         const strings = (0, protobuf_js_1.extractStrings)(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
@@ -358,10 +357,9 @@ async function collectStreamParts(stream) {
         (0, vitest_1.expect)(parts[3]).toMatchObject({ type: 'tool-input-delta', delta: '{"query":"jwt manager"}' });
         (0, vitest_1.expect)(parts[5]).toEqual({
             type: 'tool-call',
-            toolCallType: 'function',
             toolCallId: 'toolcall_1',
             toolName: 'searchRepo',
-            args: '{"query":"jwt manager"}',
+            input: '{"query":"jwt manager"}',
         });
     });
     (0, vitest_1.it)('abort stops stream mid-response', async () => {

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

@@ -24,7 +24,7 @@ export type LanguageModelV3Prompt = Array<{
         type: 'tool-call';
         toolCallId: string;
         toolName: string;
-        args: unknown;
+        input: unknown;
     } | {
         type: 'file';
         data: string;

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

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

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

@@ -32,7 +32,7 @@ export function convertPrompt(prompt) {
                         metadata: {
                             toolCallId: part.toolCallId,
                             toolName: part.toolName,
-                            toolArgsJson: JSON.stringify(part.args),
+                            toolArgsJson: JSON.stringify(part.input),
                         },
                     });
                 }

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

@@ -16,7 +16,7 @@ describe('convertPrompt', () => {
                         type: 'tool-call',
                         toolCallId: 'call_1',
                         toolName: 'searchDocs',
-                        args: { query: 'prompt converter', topK: 3 },
+                        input: { query: 'prompt converter', topK: 3 },
                     },
                 ],
             },
@@ -48,7 +48,7 @@ describe('convertPrompt', () => {
                 role: 'assistant',
                 content: [
                     { type: 'text', text: 'I will call a tool now.' },
-                    { type: 'tool-call', toolCallId: 'call_2', toolName: 'searchDocs', args: { q: 'usage examples' } },
+                    { type: 'tool-call', toolCallId: 'call_2', toolName: 'searchDocs', input: { q: 'usage examples' } },
                 ],
             },
             {

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

@@ -3,7 +3,70 @@ 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*\}/g;
+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;
+    }
+    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 });
@@ -191,6 +254,10 @@ 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) {
+        return openaiToolCalls;
+    }
     const parts = [];
     let cursor = 0;
     let toolCallCount = 0;
@@ -225,7 +292,7 @@ export function convertResponse(buffer) {
                 type: 'tool-call',
                 toolCallId: `toolcall_${toolCallCount}`,
                 toolName,
-                args: parsedArgs.parsed,
+                input: parsedArgs.parsed,
             });
         }
         cursor = parsedArgs.endIndex;

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

@@ -16,7 +16,7 @@ describe('convertResponse', () => {
                 type: 'tool-call',
                 toolCallId: 'toolcall_1',
                 toolName: 'searchDocs',
-                args: { query: 'prompt converter' },
+                input: { query: 'prompt converter' },
             },
             { type: 'text', text: ' between ' },
             { type: 'text', text: 'final answer' },
@@ -73,7 +73,7 @@ describe('convertResponse', () => {
     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' }]);
+        expect(result).toEqual([{ type: 'text', text: 'Text more text' }]);
     });
     it('strips standalone stop token', () => {
         const input = 'Hello world</s>';
@@ -83,6 +83,105 @@ describe('convertResponse', () => {
     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' }]);
+        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'));
+        expect(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'grep',
+                input: { file_path: '/home/test', search_pattern: 'binance' },
+            },
+        ]);
+    });
+    it('parses multiple OpenAI-style tool calls', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":1,"parameters":{"file_path":"/home/test"}}}, {"type":"function","function":{"name":2,"parameters":{"pattern":"*.ts"}}}{}';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'read',
+                input: { file_path: '/home/test' },
+            },
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_2',
+                toolName: 'glob',
+                input: { pattern: '*.ts' },
+            },
+        ]);
+    });
+    it('maps unknown tool IDs to tool_N format', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":99,"parameters":{"arg":"value"}}}{}';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'tool_99',
+                input: { arg: 'value' },
+            },
+        ]);
+    });
+    it('handles OpenAI-style with string tool names', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":"custom_tool","parameters":{"key":"value"}}}{}';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'custom_tool',
+                input: { key: 'value' },
+            },
+        ]);
     });
 });

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

@@ -137,17 +137,17 @@ export class DevstralLanguageModel {
                                     closeTextSegment();
                                     safeEnqueue(controller, {
                                         type: 'tool-input-start',
-                                        toolCallId: part.toolCallId,
+                                        id: part.toolCallId,
                                         toolName: part.toolName,
                                     });
                                     safeEnqueue(controller, {
                                         type: 'tool-input-delta',
-                                        toolCallId: part.toolCallId,
-                                        delta: part.args,
+                                        id: part.toolCallId,
+                                        delta: part.input,
                                     });
                                     safeEnqueue(controller, {
                                         type: 'tool-input-end',
-                                        toolCallId: part.toolCallId,
+                                        id: part.toolCallId,
                                     });
                                     safeEnqueue(controller, part);
                                 }
@@ -252,10 +252,9 @@ function toV3Content(parts) {
         if (part.type === 'tool-call') {
             return {
                 type: 'tool-call',
-                toolCallType: 'function',
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                args: JSON.stringify(part.args),
+                input: JSON.stringify(part.input),
             };
         }
         return part;

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

@@ -188,10 +188,9 @@ describe('DevstralLanguageModel doGenerate', () => {
         expect(result.content).toEqual([
             {
                 type: 'tool-call',
-                toolCallType: 'function',
                 toolCallId: 'toolcall_1',
                 toolName: 'searchRepo',
-                args: '{"query":"jwt manager"}',
+                input: '{"query":"jwt manager"}',
             },
         ]);
         const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
@@ -356,10 +355,9 @@ describe('DevstralLanguageModel doStream', () => {
         expect(parts[3]).toMatchObject({ type: 'tool-input-delta', delta: '{"query":"jwt manager"}' });
         expect(parts[5]).toEqual({
             type: 'tool-call',
-            toolCallType: 'function',
             toolCallId: 'toolcall_1',
             toolName: 'searchRepo',
-            args: '{"query":"jwt manager"}',
+            input: '{"query":"jwt manager"}',
         });
     });
     it('abort stops stream mid-response', async () => {

package/dist/model/devstral-language-model.d.ts

@@ -34,10 +34,9 @@ export interface LanguageModelV3StreamResult {
 }
 interface LanguageModelV3ToolCallContent {
     type: 'tool-call';
-    toolCallType: 'function';
     toolCallId: string;
     toolName: string;
-    args: string;
+    input: string;
 }
 type GenerateContentPart = {
     type: 'text';
@@ -61,15 +60,15 @@ type LanguageModelV3StreamPart = {
     id: string;
 } | {
     type: 'tool-input-start';
-    toolCallId: string;
+    id: string;
     toolName: string;
 } | {
     type: 'tool-input-delta';
-    toolCallId: string;
+    id: string;
     delta: string;
 } | {
     type: 'tool-input-end';
-    toolCallId: string;
+    id: string;
 } | LanguageModelV3ToolCallContent | {
     type: 'error';
     error: unknown;

package/package.json

@@ -1,8 +1,16 @@
 {
   "name": "@bxb1337/windsurf-fast-context",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "AI SDK V3 provider for Windsurf's Devstral code search API",
   "type": "module",
+  "scripts": {
+    "test": "vitest --run",
+    "build:types": "tsc -p tsconfig.types.json",
+    "build:esm": "tsc -p tsconfig.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build": "pnpm -s run build:types && pnpm -s run build:esm && pnpm -s run build:cjs && node ./scripts/postbuild.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
   "keywords": [
     "windsurf",
     "devstral",
@@ -17,6 +25,9 @@
     "type": "git",
     "url": "https://github.com/bxb1337/windsurf-fast-context"
   },
+  "dependencies": {
+    "@ai-sdk/provider": "^3.0.0"
+  },
   "devDependencies": {
     "ai": "^6.0.116",
     "typescript": "^5.0.0",
@@ -39,13 +50,5 @@
     "dist",
     "README.md",
     "LICENSE"
-  ],
-  "scripts": {
-    "test": "vitest --run",
-    "build:types": "tsc -p tsconfig.types.json",
-    "build:esm": "tsc -p tsconfig.json",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build": "pnpm -s run build:types && pnpm -s run build:esm && pnpm -s run build:cjs && node ./scripts/postbuild.js",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
-  }
-}
+  ]
+}