@bxb1337/windsurf-fast-context 1.0.9 → 1.1.1

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

@@ -7,38 +7,6 @@ describe('convertResponse', () => {
         const result = convertResponse(Buffer.from('plain response text', 'utf8'));
         expect(result).toEqual([{ type: 'text', text: 'plain response text' }]);
     });
-    it('tool-call - parses tool markers and preserves surrounding text', () => {
-        const input = 'Before [TOOL_CALLS]searchDocs[ARGS]{"query":"prompt converter"} between [TOOL_CALLS]answer[ARGS]{"answer":"final answer"} after';
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([
-            { type: 'text', text: 'Before ' },
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'searchDocs',
-                input: { query: 'prompt converter' },
-            },
-            { type: 'text', text: ' between ' },
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_2',
-                toolName: 'answer',
-                input: { answer: 'final answer' },
-            },
-            { type: 'text', text: ' after' },
-        ]);
-    });
-    it('malformed - invalid marker json remains text and does not throw', () => {
-        const input = 'prefix [TOOL_CALLS]searchDocs[ARGS]{"query": nope} suffix';
-        expect(() => convertResponse(Buffer.from(input, 'utf8'))).not.toThrow();
-        const result = convertResponse(Buffer.from(input, 'utf8'));
-        const combinedText = result
-            .filter((part) => part.type === 'text')
-            .map((part) => part.text)
-            .join('');
-        expect(result.every((part) => part.type === 'text')).toBe(true);
-        expect(combinedText).toBe(input);
-    });
     it('protobuf payload - extracts clean utf8 text without binary mojibake prefix', () => {
         const payload = new ProtobufEncoder();
         payload.writeVarint(1, 150);
@@ -46,20 +14,6 @@ describe('convertResponse', () => {
         const result = convertResponse(payload.toBuffer());
         expect(result).toEqual([{ type: 'text', text: '你好，TypeScript' }]);
     });
-    it('protobuf payload - still parses tool-call markers from extracted strings', () => {
-        const payload = new ProtobufEncoder();
-        payload.writeVarint(1, 150);
-        payload.writeString(2, '[TOOL_CALLS]answer[ARGS]{"answer":"final answer"}');
-        const result = convertResponse(payload.toBuffer());
-        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();
         payload.writeString(1, 'meta');
@@ -77,70 +31,52 @@ describe('convertResponse', () => {
         const result = convertResponse(Buffer.from(input, 'utf8'));
         expect(result).toEqual([{ type: 'text', text: 'Hello world' }]);
     });
-    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"}}}{}';
+    // Strict OpenAI array format tests
+    it('parses strict OpenAI array with single tool call', () => {
+        const input = '[{"type":"function","function":{"name":"search","parameters":{"q":"test"}}}]';
         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' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'search', input: { q: 'test' } }
         ]);
     });
-    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"}}}{}';
+    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"}}}]';
         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' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: { path: '/a' } },
+            { type: 'tool-call', toolCallId: 'toolcall_2', toolName: 'grep', input: { pattern: 'foo' } }
         ]);
     });
-    it('maps unknown tool IDs to tool_N format', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":99,"parameters":{"arg":"value"}}}{}';
+    it('parses strict OpenAI array with empty parameters', () => {
+        const input = '[{"type":"function","function":{"name":"list","parameters":{}}}]';
         const result = convertResponse(Buffer.from(input, 'utf8'));
         expect(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'tool_99',
-                input: { arg: 'value' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'list', input: {} }
         ]);
     });
-    it('handles OpenAI-style with string tool names', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":"custom_tool","parameters":{"key":"value"}}}{}';
+    it('returns text for old marker format (no backward compat)', () => {
+        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: 'custom_tool',
-                input: { key: 'value' },
-            },
-        ]);
+        expect(result).toEqual([{ type: 'text', text: '[TOOL_CALLS]search[ARGS]{"q":"test"}' }]);
     });
-    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"}}}{}';
+    it('returns text for old TOOL_CALLS format (no backward compat)', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"q":"test"}}}{}';
         const result = convertResponse(Buffer.from(input, 'utf8'));
-        expect(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'answer',
-                input: { answer: 'final answer' },
-            },
-        ]);
+        expect(result).toEqual([{ type: 'text', text: input }]);
+    });
+    it('returns text for non-array JSON', () => {
+        const input = '{"type":"function","function":{"name":"search","parameters":{}}}';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([{ type: 'text', text: input }]);
+    });
+    it('returns text for empty array', () => {
+        const input = '[]';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([{ type: 'text', text: '[]' }]);
+    });
+    it('returns text for malformed JSON array', () => {
+        const input = '[{"type":"function","function":{"name":"search","parameters":';
+        const result = convertResponse(Buffer.from(input, 'utf8'));
+        expect(result).toEqual([{ type: 'text', text: input }]);
     });
 });

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

@@ -17,8 +17,15 @@ const WS_APP_VER = process.env.WS_APP_VER ?? '1.48.2';
 const WS_LS_VER = process.env.WS_LS_VER ?? '1.9544.35';
 const SENTRY_PUBLIC_KEY = 'b813f73488da69eedec534dba1029111';
 const CONNECT_USER_AGENT = 'connect-go/1.18.1 (go1.25.5)';
+const TOOL_FORMAT_INSTRUCTION = `When you need to call tools, you must format your response as a JSON array of tool calls following the OpenAI function calling format. Each tool call must be an object with "type" set to "function" and a "function" object containing "name" (string matching one of the provided tool names) and "parameters" (object with the tool's arguments). Output ONLY the JSON array, no surrounding text.
+
+Example format:
+[{"type": "function", "function": {"name": "tool_name", "parameters": {"arg1": "value1"}}}]
+
+For multiple tool calls:
+[{"type": "function", "function": {"name": "tool1", "parameters": {"arg1": "value1"}}}, {"type": "function", "function": {"name": "tool2", "parameters": {"arg2": "value2"}}}]`;
 export class DevstralLanguageModel {
-    specificationVersion = 'v3';
+    specificationVersion = 'v2';
     provider = 'windsurf';
     modelId;
     supportedUrls = {};
@@ -55,16 +62,13 @@ export class DevstralLanguageModel {
         const responseFrame = await this.transport.postUnary(`${this.baseURL}${API_SERVICE_PATH}${DEVSTRAL_STREAM_PATH}`, requestFrame, headers);
         const { payloads: responsePayloads } = connectFrameDecode(responseFrame);
         const payloads = responsePayloads.length > 0 ? responsePayloads : [responseFrame];
-        const content = payloads.flatMap((payload) => toV3Content(convertResponse(payload)));
+        const content = payloads.flatMap((payload) => toV2Content(convertResponse(payload)));
         const unified = content.some((part) => part.type === 'tool-call')
             ? 'tool-calls'
             : 'stop';
         return {
             content,
-            finishReason: {
-                unified,
-                raw: undefined,
-            },
+            finishReason: unified,
             usage: emptyUsage(),
             warnings: [],
         };
@@ -122,7 +126,7 @@ export class DevstralLanguageModel {
                                     break;
                                 }
                                 pending = frameResult.rest;
-                                const contentParts = toV3Content(convertResponse(frameResult.payload));
+                                const contentParts = toV2Content(convertResponse(frameResult.payload));
                                 for (const part of contentParts) {
                                     if (isAborted(options.abortSignal)) {
                                         safeClose(controller);
@@ -172,10 +176,7 @@ export class DevstralLanguageModel {
                         const unified = hasToolCalls ? 'tool-calls' : 'stop';
                         safeEnqueue(controller, {
                             type: 'finish',
-                            finishReason: {
-                                unified,
-                                raw: undefined,
-                            },
+                            finishReason: unified,
                             usage: emptyUsage(),
                         });
                         safeClose(controller);
@@ -189,10 +190,7 @@ export class DevstralLanguageModel {
                             });
                             safeEnqueue(controller, {
                                 type: 'finish',
-                                finishReason: {
-                                    unified: 'error',
-                                    raw: undefined,
-                                },
+                                finishReason: 'error',
                                 usage: emptyUsage(),
                             });
                         }
@@ -251,20 +249,12 @@ function isAborted(signal) {
 }
 function emptyUsage() {
     return {
-        inputTokens: {
-            total: undefined,
-            noCache: undefined,
-            cacheRead: undefined,
-            cacheWrite: undefined,
-        },
-        outputTokens: {
-            total: undefined,
-            text: undefined,
-            reasoning: undefined,
-        },
+        inputTokens: undefined,
+        outputTokens: undefined,
+        totalTokens: undefined,
     };
 }
-function toV3Content(parts) {
+function toV2Content(parts) {
     return parts.map((part) => {
         if (part.type !== 'tool-call') {
             return part;
@@ -284,10 +274,13 @@ function isFunctionTool(tool) {
 function buildGenerateRequest(input) {
     const request = new ProtobufEncoder();
     request.writeMessage(1, buildMetadata(input.apiKey, input.jwt));
-    for (const message of input.messages) {
+    const functionTools = input.tools?.filter(isFunctionTool) ?? [];
+    const messages = functionTools.length > 0
+        ? [{ role: 5, content: TOOL_FORMAT_INSTRUCTION }, ...input.messages]
+        : input.messages;
+    for (const message of messages) {
         request.writeMessage(2, buildMessage(message));
     }
-    const functionTools = input.tools?.filter(isFunctionTool) ?? [];
     if (functionTools.length > 0) {
         const toolsArray = functionTools.map((tool) => ({
             type: 'function',

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

@@ -131,25 +131,17 @@ describe('DevstralLanguageModel doGenerate', () => {
             });
         };
         const model = new DevstralLanguageModel({ apiKey: 'test-api-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
-        expect(model.specificationVersion).toBe('v3');
+        expect(model.specificationVersion).toBe('v2');
         expect(model.supportedUrls).toEqual({});
         const result = await model.doGenerate({
             prompt: [{ role: 'user', content: [{ type: 'text', text: 'Find auth logic.' }] }],
         });
         expect(result.content).toEqual([{ type: 'text', text: 'generated answer' }]);
-        expect(result.finishReason).toEqual({ unified: 'stop', raw: undefined });
+        expect(result.finishReason).toBe('stop');
         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,
         });
         expect(calls).toHaveLength(2);
         expect(calls[0]?.url).toBe('https://windsurf.test/exa.auth_pb.AuthService/GetUserJwt');
@@ -169,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('[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(connectFrameEncode(payload)), { status: 200 });
         };
         const model = new DevstralLanguageModel({ apiKey: 'tools-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
@@ -198,7 +190,7 @@ describe('DevstralLanguageModel doGenerate', () => {
                 input: '{"query":"jwt manager"}',
             },
         ]);
-        expect(result.finishReason).toEqual({ unified: 'tool-calls', raw: undefined });
+        expect(result.finishReason).toBe('tool-calls');
         const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
         const toolsPayload = extractToolsPayload(strings);
         expect(toolsPayload).toBeDefined();
@@ -248,7 +240,7 @@ describe('DevstralLanguageModel doGenerate', () => {
                     },
                 },
                 {
-                    type: 'provider',
+                    type: 'provider-defined',
                     id: 'windsurf.restricted_exec',
                     name: 'restricted_exec',
                     args: { mode: 'read-only' },
@@ -281,6 +273,83 @@ describe('DevstralLanguageModel doGenerate', () => {
         const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
         expect(extractToolsPayload(strings)).toBeUndefined();
     });
+    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(connectFrameEncode(Buffer.from('ok', 'utf8'))), { status: 200 });
+        };
+        const model = new 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 = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        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 () => {
+        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(connectFrameEncode(Buffer.from('ok', 'utf8'))), { status: 200 });
+        };
+        const model = new 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 = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const combined = strings.join('\n');
+        expect(combined).not.toContain('When you need to call tools');
+    });
+    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(connectFrameEncode(Buffer.from('ok', 'utf8'))), { status: 200 });
+        };
+        const model = new 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 = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const combined = strings.join('\n');
+        expect(combined).not.toContain('When you need to call tools');
+    });
 });
 describe('DevstralLanguageModel doStream', () => {
     it('stream-text resolves before full body arrives and emits parts incrementally', async () => {
@@ -368,22 +437,11 @@ describe('DevstralLanguageModel doStream', () => {
             expect(parts[4]).toMatchObject({ type: 'text-delta', delta: 'world' });
             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,
                 },
             });
         }
@@ -396,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('[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([connectFrameEncode(toolPayload)]);
         const fakeFetch = async (input) => {
             const url = String(input);
@@ -446,22 +504,11 @@ describe('DevstralLanguageModel doStream', () => {
         });
         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/model/devstral-language-model.d.ts

@@ -1,4 +1,4 @@
-import type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult } from '@ai-sdk/provider';
+import type { LanguageModelV2, LanguageModelV2CallOptions } from '@ai-sdk/provider';
 import { JwtManager } from '../auth/jwt-manager.js';
 import { DevstralTransport } from '../transport/http.js';
 import type { WindsurfProviderOptions } from '../types/index.js';
@@ -7,8 +7,10 @@ export interface DevstralLanguageModelOptions extends WindsurfProviderOptions {
     transport?: DevstralTransport;
     jwtManager?: JwtManager;
 }
-export declare class DevstralLanguageModel implements LanguageModelV3 {
-    readonly specificationVersion = "v3";
+type LanguageModelV2GenerateResult = Awaited<ReturnType<LanguageModelV2['doGenerate']>>;
+type LanguageModelV2StreamResult = Awaited<ReturnType<LanguageModelV2['doStream']>>;
+export declare class DevstralLanguageModel implements LanguageModelV2 {
+    readonly specificationVersion = "v2";
     readonly provider = "windsurf";
     readonly modelId: string;
     readonly supportedUrls: Record<string, RegExp[]>;
@@ -18,6 +20,7 @@ export declare class DevstralLanguageModel implements LanguageModelV3 {
     private readonly transport;
     private readonly jwtManager;
     constructor(options?: DevstralLanguageModelOptions);
-    doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult>;
-    doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult>;
+    doGenerate(options: LanguageModelV2CallOptions): Promise<LanguageModelV2GenerateResult>;
+    doStream(options: LanguageModelV2CallOptions): Promise<LanguageModelV2StreamResult>;
 }
+export {};

package/dist/types/index.d.ts

@@ -6,7 +6,7 @@ export interface WindsurfProviderOptions {
     generateId?: () => string;
 }
 /**
- * Windsurf provider interface extending AI SDK V3 ProviderV3 pattern.
+ * Windsurf provider interface extending AI SDK V2 ProviderV2 pattern.
  * The provider is callable as a function and has a languageModel method.
  */
 export interface WindsurfProvider {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bxb1337/windsurf-fast-context",
-  "version": "1.0.9",
+  "version": "1.1.1",
   "description": "AI SDK V3 provider for Windsurf's Devstral code search API",
   "type": "module",
   "scripts": {