@bxb1337/windsurf-fast-context 1.0.8 → 1.1.0

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

@@ -36,7 +36,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
             },
         });
     });
-    (0, vitest_1.it)('multi-turn preserves ordering across mixed roles (V3 output shape)', () => {
+    (0, vitest_1.it)('multi-turn preserves ordering across mixed roles (V2 output shape)', () => {
         const prompt = [
             { role: 'system', content: 'System instruction' },
             {
@@ -161,7 +161,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
             },
         ]);
     });
-    (0, vitest_1.it)('tool-result with execution-denied output includes reason', () => {
+    (0, vitest_1.it)('tool-result with error-text output includes denial reason', () => {
         const prompt = [
             {
                 role: 'tool',
@@ -170,7 +170,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
                         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' },
                     },
                 ],
             },
@@ -179,12 +179,12 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
         (0, vitest_1.expect)(result).toEqual([
             {
                 role: 4,
-                content: '{"type":"execution-denied","reason":"User rejected tool execution"}',
+                content: 'User rejected tool execution',
                 metadata: { refCallId: 'call_denied' },
             },
         ]);
     });
-    (0, vitest_1.it)('tool-result with execution-denied output handles missing reason', () => {
+    (0, vitest_1.it)('tool-result with error-text output handles fallback denial text', () => {
         const prompt = [
             {
                 role: 'tool',
@@ -193,7 +193,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
                         type: 'tool-result',
                         toolCallId: 'call_denied_no_reason',
                         toolName: 'someTool',
-                        output: { type: 'execution-denied' },
+                        output: { type: 'error-text', value: 'Tool execution denied' },
                     },
                 ],
             },
@@ -202,7 +202,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
         (0, vitest_1.expect)(result).toEqual([
             {
                 role: 4,
-                content: '{"type":"execution-denied"}',
+                content: 'Tool execution denied',
                 metadata: { refCallId: 'call_denied_no_reason' },
             },
         ]);

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

@@ -21,7 +21,7 @@ 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)';
 class DevstralLanguageModel {
-    specificationVersion = 'v3';
+    specificationVersion = 'v2';
     provider = 'windsurf';
     modelId;
     supportedUrls = {};
@@ -56,18 +56,15 @@ class DevstralLanguageModel {
         const requestFrame = (0, connect_frame_js_1.connectFrameEncode)(requestPayload);
         const headers = createConnectHeaders(this.headers);
         const responseFrame = await this.transport.postUnary(`${this.baseURL}${API_SERVICE_PATH}${DEVSTRAL_STREAM_PATH}`, requestFrame, headers);
-        const responsePayloads = (0, connect_frame_js_1.connectFrameDecode)(responseFrame);
+        const { payloads: responsePayloads } = (0, connect_frame_js_1.connectFrameDecode)(responseFrame);
         const payloads = responsePayloads.length > 0 ? responsePayloads : [responseFrame];
-        const content = payloads.flatMap((payload) => toV3Content((0, response_converter_js_1.convertResponse)(payload)));
+        const content = payloads.flatMap((payload) => toV2Content((0, response_converter_js_1.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: [],
         };
@@ -110,7 +107,7 @@ class DevstralLanguageModel {
                     try {
                         safeEnqueue(controller, { type: 'stream-start', warnings: [] });
                         safeEnqueue(controller, { type: 'response-metadata', modelId: this.modelId });
-                        while (!isAborted(options.abortSignal)) {
+                        outerLoop: while (!isAborted(options.abortSignal)) {
                             const next = await reader.read();
                             if (next.done) {
                                 break;
@@ -125,7 +122,7 @@ class DevstralLanguageModel {
                                     break;
                                 }
                                 pending = frameResult.rest;
-                                const contentParts = toV3Content((0, response_converter_js_1.convertResponse)(frameResult.payload));
+                                const contentParts = toV2Content((0, response_converter_js_1.convertResponse)(frameResult.payload));
                                 for (const part of contentParts) {
                                     if (isAborted(options.abortSignal)) {
                                         safeClose(controller);
@@ -162,6 +159,9 @@ class DevstralLanguageModel {
                                     });
                                     safeEnqueue(controller, part);
                                 }
+                                if (frameResult.isEndStream) {
+                                    break outerLoop;
+                                }
                             }
                         }
                         if (isAborted(options.abortSignal)) {
@@ -172,10 +172,7 @@ class DevstralLanguageModel {
                         const unified = hasToolCalls ? 'tool-calls' : 'stop';
                         safeEnqueue(controller, {
                             type: 'finish',
-                            finishReason: {
-                                unified,
-                                raw: undefined,
-                            },
+                            finishReason: unified,
                             usage: emptyUsage(),
                         });
                         safeClose(controller);
@@ -189,10 +186,7 @@ class DevstralLanguageModel {
                             });
                             safeEnqueue(controller, {
                                 type: 'finish',
-                                finishReason: {
-                                    unified: 'error',
-                                    raw: undefined,
-                                },
+                                finishReason: 'error',
                                 usage: emptyUsage(),
                             });
                         }
@@ -219,10 +213,11 @@ function readNextConnectFrame(buffer) {
         return null;
     }
     const frame = buffer.subarray(0, frameLength);
-    const decoded = (0, connect_frame_js_1.connectFrameDecode)(frame);
+    const { payloads, isEndStream } = (0, connect_frame_js_1.connectFrameDecode)(frame);
     return {
-        payload: decoded[0] ?? Buffer.alloc(0),
+        payload: payloads[0] ?? Buffer.alloc(0),
         rest: buffer.subarray(frameLength),
+        isEndStream,
     };
 }
 function safeEnqueue(controller, part) {
@@ -251,20 +246,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;

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

@@ -66,8 +66,8 @@ function waitFor(ms) {
 }
 function decodeRequestPayload(body) {
     // Body is now a connect frame directly (gzip is inside the frame, not outside)
-    const decodedFrames = (0, connect_frame_js_1.connectFrameDecode)(body);
-    return decodedFrames[0] ?? Buffer.alloc(0);
+    const { payloads } = (0, connect_frame_js_1.connectFrameDecode)(body);
+    return payloads[0] ?? Buffer.alloc(0);
 }
 function extractToolsPayload(strings) {
     return strings.find((value) => value.startsWith('[{"type":"function"'));
@@ -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');
@@ -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' },
@@ -370,22 +362,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,
                 },
             });
         }
@@ -448,25 +429,84 @@ 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,
             },
         });
     });
+    (0, vitest_1.it)('stream terminates immediately on EndStreamResponse frame (flags=2)', async () => {
+        const jwt = makeJwt(4_300_000_003, 'end-stream-response');
+        const textFrame = (0, connect_frame_js_1.connectFrameEncode)(Buffer.from('hello world', 'utf8'));
+        const endStreamPayload = Buffer.alloc(0);
+        const endStreamFrame = Buffer.allocUnsafe(5 + endStreamPayload.length);
+        endStreamFrame.writeUInt8(2, 0);
+        endStreamFrame.writeUInt32BE(endStreamPayload.length, 1);
+        endStreamPayload.copy(endStreamFrame, 5);
+        let releaseHttpClose;
+        const waitForHttpClose = new Promise((resolve) => {
+            releaseHttpClose = resolve;
+        });
+        const fakeFetch = async (input) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            let sentTextFrame = false;
+            let sentEndStreamFrame = false;
+            return new Response(new ReadableStream({
+                async pull(controller) {
+                    if (!sentTextFrame) {
+                        controller.enqueue(Uint8Array.from(textFrame));
+                        sentTextFrame = true;
+                        return;
+                    }
+                    if (!sentEndStreamFrame) {
+                        controller.enqueue(Uint8Array.from(endStreamFrame));
+                        sentEndStreamFrame = true;
+                        return;
+                    }
+                    await waitForHttpClose;
+                    controller.close();
+                },
+            }), { status: 200 });
+        };
+        const model = new devstral_language_model_js_1.DevstralLanguageModel({
+            apiKey: 'end-stream-key',
+            fetch: fakeFetch,
+            baseURL: 'https://windsurf.test',
+        });
+        const result = await model.doStream({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Stream with end.' }] }],
+        });
+        const reader = result.stream.getReader();
+        const parts = [];
+        const resultType = await Promise.race([
+            (async () => {
+                while (true) {
+                    const next = await reader.read();
+                    if (next.done) {
+                        break;
+                    }
+                    parts.push(next.value);
+                }
+                return 'completed';
+            })(),
+            waitFor(100).then(() => 'timed-out'),
+        ]);
+        (0, vitest_1.expect)(resultType).toBe('completed');
+        (0, vitest_1.expect)(parts.map((p) => p.type)).toEqual([
+            'stream-start',
+            'response-metadata',
+            'text-start',
+            'text-delta',
+            'text-end',
+            'finish',
+        ]);
+        releaseHttpClose?.();
+    });
     (0, vitest_1.it)('abort stops stream mid-response', async () => {
         const controller = new AbortController();
         const jwt = makeJwt(4_300_000_002, 'abort');

package/dist/cjs/protocol/connect-frame.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLAG_END_STREAM = exports.FLAG_COMPRESSED = void 0;
 exports.connectFrameEncode = connectFrameEncode;
 exports.connectFrameDecode = connectFrameDecode;
 const node_zlib_1 = require("node:zlib");
 const FRAME_HEADER_SIZE = 5;
-const FLAG_COMPRESSED = 1;
+exports.FLAG_COMPRESSED = 1;
+exports.FLAG_END_STREAM = 2;
 /**
  * Encode a protobuf payload into a Connect-RPC frame.
  *
@@ -16,7 +18,7 @@ const FLAG_COMPRESSED = 1;
 function connectFrameEncode(payload, compress = true) {
     const payloadBytes = compress ? (0, node_zlib_1.gzipSync)(payload) : payload;
     const frame = Buffer.allocUnsafe(FRAME_HEADER_SIZE + payloadBytes.length);
-    frame.writeUInt8(compress ? FLAG_COMPRESSED : 0, 0);
+    frame.writeUInt8(compress ? exports.FLAG_COMPRESSED : 0, 0);
     frame.writeUInt32BE(payloadBytes.length, 1);
     payloadBytes.copy(frame, FRAME_HEADER_SIZE);
     return frame;
@@ -24,6 +26,7 @@ function connectFrameEncode(payload, compress = true) {
 function connectFrameDecode(buffer) {
     const decoded = [];
     let offset = 0;
+    let isEndStream = false;
     while (offset + FRAME_HEADER_SIZE <= buffer.length) {
         const flags = buffer.readUInt8(offset);
         const payloadLength = buffer.readUInt32BE(offset + 1);
@@ -33,8 +36,11 @@ function connectFrameDecode(buffer) {
             break;
         }
         const payload = buffer.subarray(payloadStart, payloadEnd);
-        decoded.push(flags === FLAG_COMPRESSED ? (0, node_zlib_1.gunzipSync)(payload) : Buffer.from(payload));
+        decoded.push((flags & exports.FLAG_COMPRESSED) !== 0 ? (0, node_zlib_1.gunzipSync)(payload) : Buffer.from(payload));
+        if ((flags & exports.FLAG_END_STREAM) !== 0) {
+            isEndStream = true;
+        }
         offset = payloadEnd;
     }
-    return decoded;
+    return { payloads: decoded, isEndStream };
 }

package/dist/cjs/protocol/connect-frame.test.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_zlib_1 = require("node:zlib");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const vitest_1 = require("vitest");
@@ -15,22 +16,94 @@ const payloadWorld = Buffer.from('CONNECT\x02world', 'utf8');
         (0, vitest_1.expect)(encoded.readUInt8(0)).toBe(0);
         (0, vitest_1.expect)(encoded.readUInt32BE(1)).toBe(payloadHello.length);
         (0, vitest_1.expect)(encoded.subarray(5)).toEqual(payloadHello);
-        (0, vitest_1.expect)((0, connect_frame_js_1.connectFrameDecode)(encoded)).toEqual([payloadHello]);
+        (0, vitest_1.expect)((0, connect_frame_js_1.connectFrameDecode)(encoded)).toEqual({ payloads: [payloadHello], isEndStream: false });
     });
     (0, vitest_1.it)('gzip roundtrip uses compressed frame and decodes back to source payload', () => {
         const encoded = (0, connect_frame_js_1.connectFrameEncode)(payloadWorld, true);
         (0, vitest_1.expect)(encoded.readUInt8(0)).toBe(1);
-        (0, vitest_1.expect)((0, connect_frame_js_1.connectFrameDecode)(encoded)).toEqual([payloadWorld]);
+        (0, vitest_1.expect)((0, connect_frame_js_1.connectFrameDecode)(encoded)).toEqual({ payloads: [payloadWorld], isEndStream: false });
     });
 });
 (0, vitest_1.describe)('connectFrameDecode fixtures', () => {
     (0, vitest_1.it)('decodes frame-simple fixture payload', () => {
-        (0, vitest_1.expect)((0, connect_frame_js_1.connectFrameDecode)(fixtureSimpleFrame)).toEqual([payloadHello]);
+        (0, vitest_1.expect)((0, connect_frame_js_1.connectFrameDecode)(fixtureSimpleFrame)).toEqual({ payloads: [payloadHello], isEndStream: false });
     });
     (0, vitest_1.it)('decodes gzip fixture payload', () => {
-        (0, vitest_1.expect)((0, connect_frame_js_1.connectFrameDecode)(fixtureGzipFrame)).toEqual([payloadWorld]);
+        (0, vitest_1.expect)((0, connect_frame_js_1.connectFrameDecode)(fixtureGzipFrame)).toEqual({ payloads: [payloadWorld], isEndStream: false });
     });
     (0, vitest_1.it)('decodes multiple concatenated frames in order', () => {
-        (0, vitest_1.expect)((0, connect_frame_js_1.connectFrameDecode)(fixtureMultiFrame)).toEqual([payloadHello, payloadHello]);
+        (0, vitest_1.expect)((0, connect_frame_js_1.connectFrameDecode)(fixtureMultiFrame)).toEqual({ payloads: [payloadHello, payloadHello], isEndStream: false });
+    });
+});
+(0, vitest_1.describe)('connect frame flags', () => {
+    (0, vitest_1.it)('exports FLAG_COMPRESSED constant with value 1', () => {
+        (0, vitest_1.expect)(connect_frame_js_1.FLAG_COMPRESSED).toBe(1);
+    });
+    (0, vitest_1.it)('exports FLAG_END_STREAM constant with value 2', () => {
+        (0, vitest_1.expect)(connect_frame_js_1.FLAG_END_STREAM).toBe(2);
+    });
+    (0, vitest_1.it)('supports bit combination: FLAG_COMPRESSED | FLAG_END_STREAM === 3', () => {
+        (0, vitest_1.expect)(connect_frame_js_1.FLAG_COMPRESSED | connect_frame_js_1.FLAG_END_STREAM).toBe(3);
+    });
+});
+(0, vitest_1.describe)('connectFrameDecode isEndStream', () => {
+    /**
+     * TDD RED PHASE: Tests for isEndStream flag detection.
+     * These tests MUST FAIL because connectFrameDecode currently returns Buffer[],
+     * not { payloads: Buffer[], isEndStream: boolean }.
+     *
+     * Connect-RPC flag bits:
+     * - Bit 0 (value 1): FLAG_COMPRESSED
+     * - Bit 1 (value 2): FLAG_END_STREAM
+     */
+    (0, vitest_1.it)('returns isEndStream: false for flags=0 (no flags)', () => {
+        // flags=0: neither compressed nor end stream
+        const frame = Buffer.allocUnsafe(5 + payloadHello.length);
+        frame.writeUInt8(0, 0); // flags = 0
+        frame.writeUInt32BE(payloadHello.length, 1);
+        payloadHello.copy(frame, 5);
+        const result = (0, connect_frame_js_1.connectFrameDecode)(frame);
+        (0, vitest_1.expect)(result).toHaveProperty('payloads');
+        (0, vitest_1.expect)(result).toHaveProperty('isEndStream');
+        (0, vitest_1.expect)(result.payloads).toEqual([payloadHello]);
+        (0, vitest_1.expect)(result.isEndStream).toBe(false);
+    });
+    (0, vitest_1.it)('returns isEndStream: false for flags=1 (compressed only)', () => {
+        // flags=1: compressed but not end stream
+        const gzipped = (0, node_zlib_1.gzipSync)(payloadHello);
+        const frame = Buffer.allocUnsafe(5 + gzipped.length);
+        frame.writeUInt8(connect_frame_js_1.FLAG_COMPRESSED, 0); // flags = 1
+        frame.writeUInt32BE(gzipped.length, 1);
+        gzipped.copy(frame, 5);
+        const result = (0, connect_frame_js_1.connectFrameDecode)(frame);
+        (0, vitest_1.expect)(result).toHaveProperty('payloads');
+        (0, vitest_1.expect)(result).toHaveProperty('isEndStream');
+        (0, vitest_1.expect)(result.payloads).toEqual([payloadHello]);
+        (0, vitest_1.expect)(result.isEndStream).toBe(false);
+    });
+    (0, vitest_1.it)('returns isEndStream: true for flags=2 (end stream only)', () => {
+        // flags=2: end stream but not compressed
+        const frame = Buffer.allocUnsafe(5 + payloadHello.length);
+        frame.writeUInt8(connect_frame_js_1.FLAG_END_STREAM, 0); // flags = 2
+        frame.writeUInt32BE(payloadHello.length, 1);
+        payloadHello.copy(frame, 5);
+        const result = (0, connect_frame_js_1.connectFrameDecode)(frame);
+        (0, vitest_1.expect)(result).toHaveProperty('payloads');
+        (0, vitest_1.expect)(result).toHaveProperty('isEndStream');
+        (0, vitest_1.expect)(result.payloads).toEqual([payloadHello]);
+        (0, vitest_1.expect)(result.isEndStream).toBe(true);
+    });
+    (0, vitest_1.it)('returns isEndStream: true for flags=3 (compressed + end stream)', () => {
+        // flags=3: both compressed and end stream
+        const gzipped = (0, node_zlib_1.gzipSync)(payloadHello);
+        const frame = Buffer.allocUnsafe(5 + gzipped.length);
+        frame.writeUInt8(connect_frame_js_1.FLAG_COMPRESSED | connect_frame_js_1.FLAG_END_STREAM, 0); // flags = 3
+        frame.writeUInt32BE(gzipped.length, 1);
+        gzipped.copy(frame, 5);
+        const result = (0, connect_frame_js_1.connectFrameDecode)(frame);
+        (0, vitest_1.expect)(result).toHaveProperty('payloads');
+        (0, vitest_1.expect)(result).toHaveProperty('isEndStream');
+        (0, vitest_1.expect)(result.payloads).toEqual([payloadHello]);
+        (0, vitest_1.expect)(result.isEndStream).toBe(true);
     });
 });

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/model/devstral-language-model.js

@@ -18,7 +18,7 @@ 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)';
 export class DevstralLanguageModel {
-    specificationVersion = 'v3';
+    specificationVersion = 'v2';
     provider = 'windsurf';
     modelId;
     supportedUrls = {};
@@ -53,18 +53,15 @@ export class DevstralLanguageModel {
         const requestFrame = connectFrameEncode(requestPayload);
         const headers = createConnectHeaders(this.headers);
         const responseFrame = await this.transport.postUnary(`${this.baseURL}${API_SERVICE_PATH}${DEVSTRAL_STREAM_PATH}`, requestFrame, headers);
-        const responsePayloads = connectFrameDecode(responseFrame);
+        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: [],
         };
@@ -107,7 +104,7 @@ export class DevstralLanguageModel {
                     try {
                         safeEnqueue(controller, { type: 'stream-start', warnings: [] });
                         safeEnqueue(controller, { type: 'response-metadata', modelId: this.modelId });
-                        while (!isAborted(options.abortSignal)) {
+                        outerLoop: while (!isAborted(options.abortSignal)) {
                             const next = await reader.read();
                             if (next.done) {
                                 break;
@@ -122,7 +119,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);
@@ -159,6 +156,9 @@ export class DevstralLanguageModel {
                                     });
                                     safeEnqueue(controller, part);
                                 }
+                                if (frameResult.isEndStream) {
+                                    break outerLoop;
+                                }
                             }
                         }
                         if (isAborted(options.abortSignal)) {
@@ -169,10 +169,7 @@ export class DevstralLanguageModel {
                         const unified = hasToolCalls ? 'tool-calls' : 'stop';
                         safeEnqueue(controller, {
                             type: 'finish',
-                            finishReason: {
-                                unified,
-                                raw: undefined,
-                            },
+                            finishReason: unified,
                             usage: emptyUsage(),
                         });
                         safeClose(controller);
@@ -186,10 +183,7 @@ export class DevstralLanguageModel {
                             });
                             safeEnqueue(controller, {
                                 type: 'finish',
-                                finishReason: {
-                                    unified: 'error',
-                                    raw: undefined,
-                                },
+                                finishReason: 'error',
                                 usage: emptyUsage(),
                             });
                         }
@@ -215,10 +209,11 @@ function readNextConnectFrame(buffer) {
         return null;
     }
     const frame = buffer.subarray(0, frameLength);
-    const decoded = connectFrameDecode(frame);
+    const { payloads, isEndStream } = connectFrameDecode(frame);
     return {
-        payload: decoded[0] ?? Buffer.alloc(0),
+        payload: payloads[0] ?? Buffer.alloc(0),
         rest: buffer.subarray(frameLength),
+        isEndStream,
     };
 }
 function safeEnqueue(controller, part) {
@@ -247,20 +242,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;

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

@@ -64,8 +64,8 @@ function waitFor(ms) {
 }
 function decodeRequestPayload(body) {
     // Body is now a connect frame directly (gzip is inside the frame, not outside)
-    const decodedFrames = connectFrameDecode(body);
-    return decodedFrames[0] ?? Buffer.alloc(0);
+    const { payloads } = connectFrameDecode(body);
+    return payloads[0] ?? Buffer.alloc(0);
 }
 function extractToolsPayload(strings) {
     return strings.find((value) => value.startsWith('[{"type":"function"'));
@@ -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');
@@ -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' },
@@ -368,22 +360,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,
                 },
             });
         }
@@ -446,25 +427,84 @@ 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,
             },
         });
     });
+    it('stream terminates immediately on EndStreamResponse frame (flags=2)', async () => {
+        const jwt = makeJwt(4_300_000_003, 'end-stream-response');
+        const textFrame = connectFrameEncode(Buffer.from('hello world', 'utf8'));
+        const endStreamPayload = Buffer.alloc(0);
+        const endStreamFrame = Buffer.allocUnsafe(5 + endStreamPayload.length);
+        endStreamFrame.writeUInt8(2, 0);
+        endStreamFrame.writeUInt32BE(endStreamPayload.length, 1);
+        endStreamPayload.copy(endStreamFrame, 5);
+        let releaseHttpClose;
+        const waitForHttpClose = new Promise((resolve) => {
+            releaseHttpClose = resolve;
+        });
+        const fakeFetch = async (input) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            let sentTextFrame = false;
+            let sentEndStreamFrame = false;
+            return new Response(new ReadableStream({
+                async pull(controller) {
+                    if (!sentTextFrame) {
+                        controller.enqueue(Uint8Array.from(textFrame));
+                        sentTextFrame = true;
+                        return;
+                    }
+                    if (!sentEndStreamFrame) {
+                        controller.enqueue(Uint8Array.from(endStreamFrame));
+                        sentEndStreamFrame = true;
+                        return;
+                    }
+                    await waitForHttpClose;
+                    controller.close();
+                },
+            }), { status: 200 });
+        };
+        const model = new DevstralLanguageModel({
+            apiKey: 'end-stream-key',
+            fetch: fakeFetch,
+            baseURL: 'https://windsurf.test',
+        });
+        const result = await model.doStream({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Stream with end.' }] }],
+        });
+        const reader = result.stream.getReader();
+        const parts = [];
+        const resultType = await Promise.race([
+            (async () => {
+                while (true) {
+                    const next = await reader.read();
+                    if (next.done) {
+                        break;
+                    }
+                    parts.push(next.value);
+                }
+                return 'completed';
+            })(),
+            waitFor(100).then(() => 'timed-out'),
+        ]);
+        expect(resultType).toBe('completed');
+        expect(parts.map((p) => p.type)).toEqual([
+            'stream-start',
+            'response-metadata',
+            'text-start',
+            'text-delta',
+            'text-end',
+            'finish',
+        ]);
+        releaseHttpClose?.();
+    });
     it('abort stops stream mid-response', async () => {
         const controller = new AbortController();
         const jwt = makeJwt(4_300_000_002, 'abort');

package/dist/esm/protocol/connect-frame.js

@@ -1,6 +1,7 @@
 import { gunzipSync, gzipSync } from 'node:zlib';
 const FRAME_HEADER_SIZE = 5;
-const FLAG_COMPRESSED = 1;
+export const FLAG_COMPRESSED = 1;
+export const FLAG_END_STREAM = 2;
 /**
  * Encode a protobuf payload into a Connect-RPC frame.
  *
@@ -20,6 +21,7 @@ export function connectFrameEncode(payload, compress = true) {
 export function connectFrameDecode(buffer) {
     const decoded = [];
     let offset = 0;
+    let isEndStream = false;
     while (offset + FRAME_HEADER_SIZE <= buffer.length) {
         const flags = buffer.readUInt8(offset);
         const payloadLength = buffer.readUInt32BE(offset + 1);
@@ -29,8 +31,11 @@ export function connectFrameDecode(buffer) {
             break;
         }
         const payload = buffer.subarray(payloadStart, payloadEnd);
-        decoded.push(flags === FLAG_COMPRESSED ? gunzipSync(payload) : Buffer.from(payload));
+        decoded.push((flags & FLAG_COMPRESSED) !== 0 ? gunzipSync(payload) : Buffer.from(payload));
+        if ((flags & FLAG_END_STREAM) !== 0) {
+            isEndStream = true;
+        }
         offset = payloadEnd;
     }
-    return decoded;
+    return { payloads: decoded, isEndStream };
 }

package/dist/esm/protocol/connect-frame.test.js

@@ -1,7 +1,8 @@
+import { gzipSync } from 'node:zlib';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { describe, expect, it } from 'vitest';
-import { connectFrameDecode, connectFrameEncode } from './connect-frame.js';
+import { connectFrameDecode, connectFrameEncode, FLAG_COMPRESSED, FLAG_END_STREAM } from './connect-frame.js';
 const fixtureSimpleFrame = readFileSync(join(process.cwd(), 'test/fixtures/connect/frame-simple.bin'));
 const fixtureGzipFrame = readFileSync(join(process.cwd(), 'test/fixtures/connect/frame-gzip.bin'));
 const fixtureMultiFrame = readFileSync(join(process.cwd(), 'test/fixtures/connect/frame-multi.bin'));
@@ -13,22 +14,94 @@ describe('connectFrameEncode', () => {
         expect(encoded.readUInt8(0)).toBe(0);
         expect(encoded.readUInt32BE(1)).toBe(payloadHello.length);
         expect(encoded.subarray(5)).toEqual(payloadHello);
-        expect(connectFrameDecode(encoded)).toEqual([payloadHello]);
+        expect(connectFrameDecode(encoded)).toEqual({ payloads: [payloadHello], isEndStream: false });
     });
     it('gzip roundtrip uses compressed frame and decodes back to source payload', () => {
         const encoded = connectFrameEncode(payloadWorld, true);
         expect(encoded.readUInt8(0)).toBe(1);
-        expect(connectFrameDecode(encoded)).toEqual([payloadWorld]);
+        expect(connectFrameDecode(encoded)).toEqual({ payloads: [payloadWorld], isEndStream: false });
     });
 });
 describe('connectFrameDecode fixtures', () => {
     it('decodes frame-simple fixture payload', () => {
-        expect(connectFrameDecode(fixtureSimpleFrame)).toEqual([payloadHello]);
+        expect(connectFrameDecode(fixtureSimpleFrame)).toEqual({ payloads: [payloadHello], isEndStream: false });
     });
     it('decodes gzip fixture payload', () => {
-        expect(connectFrameDecode(fixtureGzipFrame)).toEqual([payloadWorld]);
+        expect(connectFrameDecode(fixtureGzipFrame)).toEqual({ payloads: [payloadWorld], isEndStream: false });
     });
     it('decodes multiple concatenated frames in order', () => {
-        expect(connectFrameDecode(fixtureMultiFrame)).toEqual([payloadHello, payloadHello]);
+        expect(connectFrameDecode(fixtureMultiFrame)).toEqual({ payloads: [payloadHello, payloadHello], isEndStream: false });
+    });
+});
+describe('connect frame flags', () => {
+    it('exports FLAG_COMPRESSED constant with value 1', () => {
+        expect(FLAG_COMPRESSED).toBe(1);
+    });
+    it('exports FLAG_END_STREAM constant with value 2', () => {
+        expect(FLAG_END_STREAM).toBe(2);
+    });
+    it('supports bit combination: FLAG_COMPRESSED | FLAG_END_STREAM === 3', () => {
+        expect(FLAG_COMPRESSED | FLAG_END_STREAM).toBe(3);
+    });
+});
+describe('connectFrameDecode isEndStream', () => {
+    /**
+     * TDD RED PHASE: Tests for isEndStream flag detection.
+     * These tests MUST FAIL because connectFrameDecode currently returns Buffer[],
+     * not { payloads: Buffer[], isEndStream: boolean }.
+     *
+     * Connect-RPC flag bits:
+     * - Bit 0 (value 1): FLAG_COMPRESSED
+     * - Bit 1 (value 2): FLAG_END_STREAM
+     */
+    it('returns isEndStream: false for flags=0 (no flags)', () => {
+        // flags=0: neither compressed nor end stream
+        const frame = Buffer.allocUnsafe(5 + payloadHello.length);
+        frame.writeUInt8(0, 0); // flags = 0
+        frame.writeUInt32BE(payloadHello.length, 1);
+        payloadHello.copy(frame, 5);
+        const result = connectFrameDecode(frame);
+        expect(result).toHaveProperty('payloads');
+        expect(result).toHaveProperty('isEndStream');
+        expect(result.payloads).toEqual([payloadHello]);
+        expect(result.isEndStream).toBe(false);
+    });
+    it('returns isEndStream: false for flags=1 (compressed only)', () => {
+        // flags=1: compressed but not end stream
+        const gzipped = gzipSync(payloadHello);
+        const frame = Buffer.allocUnsafe(5 + gzipped.length);
+        frame.writeUInt8(FLAG_COMPRESSED, 0); // flags = 1
+        frame.writeUInt32BE(gzipped.length, 1);
+        gzipped.copy(frame, 5);
+        const result = connectFrameDecode(frame);
+        expect(result).toHaveProperty('payloads');
+        expect(result).toHaveProperty('isEndStream');
+        expect(result.payloads).toEqual([payloadHello]);
+        expect(result.isEndStream).toBe(false);
+    });
+    it('returns isEndStream: true for flags=2 (end stream only)', () => {
+        // flags=2: end stream but not compressed
+        const frame = Buffer.allocUnsafe(5 + payloadHello.length);
+        frame.writeUInt8(FLAG_END_STREAM, 0); // flags = 2
+        frame.writeUInt32BE(payloadHello.length, 1);
+        payloadHello.copy(frame, 5);
+        const result = connectFrameDecode(frame);
+        expect(result).toHaveProperty('payloads');
+        expect(result).toHaveProperty('isEndStream');
+        expect(result.payloads).toEqual([payloadHello]);
+        expect(result.isEndStream).toBe(true);
+    });
+    it('returns isEndStream: true for flags=3 (compressed + end stream)', () => {
+        // flags=3: both compressed and end stream
+        const gzipped = gzipSync(payloadHello);
+        const frame = Buffer.allocUnsafe(5 + gzipped.length);
+        frame.writeUInt8(FLAG_COMPRESSED | FLAG_END_STREAM, 0); // flags = 3
+        frame.writeUInt32BE(gzipped.length, 1);
+        gzipped.copy(frame, 5);
+        const result = connectFrameDecode(frame);
+        expect(result).toHaveProperty('payloads');
+        expect(result).toHaveProperty('isEndStream');
+        expect(result.payloads).toEqual([payloadHello]);
+        expect(result.isEndStream).toBe(true);
     });
 });

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/protocol/connect-frame.d.ts

@@ -1,3 +1,5 @@
+export declare const FLAG_COMPRESSED = 1;
+export declare const FLAG_END_STREAM = 2;
 /**
  * Encode a protobuf payload into a Connect-RPC frame.
  *
@@ -7,4 +9,7 @@
  * @returns Buffer containing: [flags byte][4-byte length][payload (gzipped if compress=true)]
  */
 export declare function connectFrameEncode(payload: Buffer, compress?: boolean): Buffer;
-export declare function connectFrameDecode(buffer: Buffer): Buffer[];
+export declare function connectFrameDecode(buffer: Buffer): {
+    payloads: Buffer[];
+    isEndStream: boolean;
+};

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.8",
+  "version": "1.1.0",
   "description": "AI SDK V3 provider for Windsurf's Devstral code search API",
   "type": "module",
   "scripts": {