@bxb1337/windsurf-fast-context 1.0.0

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

@@ -0,0 +1,408 @@
+import { describe, expect, it } from 'vitest';
+import { extractStrings } from '../protocol/protobuf.js';
+import { connectFrameDecode, connectFrameEncode } from '../protocol/connect-frame.js';
+import { DevstralLanguageModel } from './devstral-language-model.js';
+function bufferFromBody(body) {
+    if (body == null) {
+        return Buffer.alloc(0);
+    }
+    if (typeof body === 'string') {
+        return Buffer.from(body, 'utf8');
+    }
+    if (body instanceof ArrayBuffer) {
+        return Buffer.from(body);
+    }
+    if (ArrayBuffer.isView(body)) {
+        return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    }
+    throw new Error(`Unsupported request body type: ${typeof body}`);
+}
+function makeJwt(exp, tag) {
+    const header = Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT' })).toString('base64url');
+    const payload = Buffer.from(JSON.stringify({ exp, tag })).toString('base64url');
+    return `${header}.${payload}.signature`;
+}
+function chunkBuffer(buffer, chunkSize) {
+    const chunks = [];
+    for (let offset = 0; offset < buffer.length; offset += chunkSize) {
+        chunks.push(Uint8Array.from(buffer.subarray(offset, offset + chunkSize)));
+    }
+    return chunks;
+}
+function makeChunkedBody(chunks, options = {}) {
+    let index = 0;
+    return new ReadableStream({
+        async pull(controller) {
+            if (options.signal?.aborted) {
+                controller.close();
+                return;
+            }
+            if (index >= chunks.length) {
+                controller.close();
+                return;
+            }
+            if (options.pauseAtChunkIndex === index && options.waitForChunk) {
+                await options.waitForChunk;
+            }
+            if ((options.delayMs ?? 0) > 0) {
+                await new Promise((resolve) => setTimeout(resolve, options.delayMs));
+            }
+            if (options.signal?.aborted) {
+                controller.close();
+                return;
+            }
+            const chunk = chunks[index];
+            if (chunk) {
+                controller.enqueue(chunk);
+            }
+            index += 1;
+        },
+    });
+}
+function waitFor(ms) {
+    return new Promise((resolve) => setTimeout(resolve, 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);
+}
+async function collectStreamParts(stream) {
+    const reader = stream.getReader();
+    const parts = [];
+    while (true) {
+        const next = await reader.read();
+        if (next.done) {
+            break;
+        }
+        parts.push(next.value);
+    }
+    return parts;
+}
+describe('DevstralLanguageModel doGenerate', () => {
+    it('generate request uses connect endpoint and connect+proto gzip headers', async () => {
+        const calls = [];
+        const requestBodies = [];
+        const jwt = makeJwt(4_050_000_000, 'connect-gzip');
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            calls.push({ url, init });
+            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: 'test-api-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
+        await model.doGenerate({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Use connect route.' }] }],
+        });
+        const generateCall = calls[1];
+        expect(generateCall?.url).toBe('https://windsurf.test/exa.api_server_pb.ApiServerService/GetDevstralStream');
+        const headers = new Headers(generateCall?.init?.headers);
+        expect(headers.get('content-type')).toBe('application/connect+proto');
+        expect(headers.get('connect-protocol-version')).toBe('1');
+        expect(headers.get('connect-timeout-ms')).toBe('30000');
+        expect(headers.get('connect-accept-encoding')).toBe('gzip');
+        expect(headers.get('connect-content-encoding')).toBe('gzip');
+        expect(headers.get('accept-encoding')).toBe('identity');
+        const body = requestBodies[0];
+        expect(body?.readUInt8(0)).toBe(1);
+        const strings = extractStrings(decodeRequestPayload(body ?? Buffer.alloc(0)));
+        const combined = strings.join('\n');
+        expect(combined).toContain('Use connect route.');
+    });
+    it('generate request returns plain text content', async () => {
+        const calls = [];
+        const requestBodies = [];
+        const jwt = makeJwt(4_100_000_000, 'generate');
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            calls.push({ url, init });
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(`prefix:${jwt}:suffix`, 'utf8')), { status: 200 });
+            }
+            requestBodies.push(bufferFromBody(init?.body));
+            return new Response(Uint8Array.from(connectFrameEncode(Buffer.from('generated answer', 'utf8'))), {
+                status: 200,
+            });
+        };
+        const model = new DevstralLanguageModel({ apiKey: 'test-api-key', fetch: fakeFetch, baseURL: 'https://windsurf.test' });
+        expect(model.specificationVersion).toBe('v3');
+        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: 'stop' });
+        expect(result.usage).toEqual({
+            inputTokens: {
+                total: undefined,
+                noCache: undefined,
+                cacheRead: undefined,
+                cacheWrite: undefined,
+            },
+            outputTokens: {
+                total: undefined,
+                text: undefined,
+                reasoning: undefined,
+            },
+        });
+        expect(calls).toHaveLength(2);
+        expect(calls[0]?.url).toBe('https://windsurf.test/exa.auth_pb.AuthService/GetUserJwt');
+        expect(calls[1]?.url).toBe('https://windsurf.test/exa.api_server_pb.ApiServerService/GetDevstralStream');
+        const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const combined = strings.join('\n');
+        expect(combined).toContain('test-api-key');
+        expect(combined).toContain(jwt);
+        expect(combined).toContain('Find auth logic.');
+    });
+    it('generate request with tool markers returns tool-call content parts', async () => {
+        const requestBodies = [];
+        const jwt = makeJwt(4_200_000_000, 'tools');
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            requestBodies.push(bufferFromBody(init?.body));
+            const payload = Buffer.from('[TOOL_CALLS]searchRepo[ARGS]{"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' });
+        const result = await model.doGenerate({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Inspect jwt manager.' }] }],
+            tools: {
+                searchRepo: {
+                    description: 'Search repository files',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string' },
+                        },
+                        required: ['query'],
+                    },
+                },
+            },
+        });
+        expect(result.content).toEqual([
+            {
+                type: 'tool-call',
+                toolCallType: 'function',
+                toolCallId: 'toolcall_1',
+                toolName: 'searchRepo',
+                args: '{"query":"jwt manager"}',
+            },
+        ]);
+        const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const combined = strings.join('\n');
+        expect(combined).toContain('searchRepo');
+        expect(combined).toContain('Search repository files');
+        expect(combined).toContain('Inspect jwt manager.');
+        expect(combined).toContain('query');
+    });
+});
+describe('DevstralLanguageModel doStream', () => {
+    it('stream-text resolves before full body arrives and emits parts incrementally', async () => {
+        const jwt = makeJwt(4_300_000_000, 'stream-text');
+        const firstFrame = connectFrameEncode(Buffer.from('hello ', 'utf8'));
+        const secondFrame = connectFrameEncode(Buffer.from('world', 'utf8'));
+        let releaseSecondFrame;
+        const waitForSecondFrame = new Promise((resolve) => {
+            releaseSecondFrame = () => resolve();
+        });
+        const chunks = [
+            Uint8Array.from(firstFrame.subarray(0, 3)),
+            Uint8Array.from(firstFrame.subarray(3, 8)),
+            Uint8Array.from(firstFrame.subarray(8)),
+            Uint8Array.from(secondFrame.subarray(0, 4)),
+            Uint8Array.from(secondFrame.subarray(4)),
+        ];
+        const calls = [];
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            calls.push({ url, init });
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            return new Response(makeChunkedBody(chunks, {
+                pauseAtChunkIndex: 3,
+                waitForChunk: waitForSecondFrame,
+            }), { status: 200 });
+        };
+        const model = new DevstralLanguageModel({
+            apiKey: 'stream-api-key',
+            fetch: fakeFetch,
+            baseURL: 'https://windsurf.test',
+        });
+        const resultPromise = model.doStream({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Stream text.' }] }],
+        });
+        try {
+            const earlyResolution = await Promise.race([
+                resultPromise.then(() => 'resolved'),
+                waitFor(30).then(() => 'timed-out'),
+            ]);
+            expect(earlyResolution).toBe('resolved');
+            const result = await resultPromise;
+            const reader = result.stream.getReader();
+            const firstParts = [];
+            while (firstParts.length < 4) {
+                const next = await reader.read();
+                if (next.done) {
+                    break;
+                }
+                firstParts.push(next.value);
+                if (next.value.type === 'text-delta') {
+                    break;
+                }
+            }
+            expect(firstParts.map((part) => part.type)).toEqual([
+                'stream-start',
+                'response-metadata',
+                'text-start',
+                'text-delta',
+            ]);
+            expect(firstParts[3]).toMatchObject({ type: 'text-delta', delta: 'hello ' });
+            releaseSecondFrame?.();
+            const remainingParts = [];
+            while (true) {
+                const next = await reader.read();
+                if (next.done) {
+                    break;
+                }
+                remainingParts.push(next.value);
+            }
+            const parts = [...firstParts, ...remainingParts];
+            expect(parts.map((part) => part.type)).toEqual([
+                'stream-start',
+                'response-metadata',
+                'text-start',
+                'text-delta',
+                'text-delta',
+                'text-end',
+                'finish',
+            ]);
+            expect(parts[0]).toEqual({ type: 'stream-start', warnings: [] });
+            expect(parts[1]).toMatchObject({ type: 'response-metadata' });
+            expect(parts[4]).toMatchObject({ type: 'text-delta', delta: 'world' });
+            expect(parts[6]).toEqual({
+                type: 'finish',
+                finishReason: { unified: 'stop', raw: 'stop' },
+                usage: {
+                    inputTokens: {
+                        total: undefined,
+                        noCache: undefined,
+                        cacheRead: undefined,
+                        cacheWrite: undefined,
+                    },
+                    outputTokens: {
+                        total: undefined,
+                        text: undefined,
+                        reasoning: undefined,
+                    },
+                },
+            });
+        }
+        finally {
+            releaseSecondFrame?.();
+        }
+        expect(calls).toHaveLength(2);
+        expect(calls[0]?.url).toBe('https://windsurf.test/exa.auth_pb.AuthService/GetUserJwt');
+        expect(calls[1]?.url).toBe('https://windsurf.test/exa.api_server_pb.ApiServerService/GetDevstralStream');
+    });
+    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 frames = Buffer.concat([connectFrameEncode(toolPayload)]);
+        const fakeFetch = async (input) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            return new Response(makeChunkedBody(chunkBuffer(frames, 6)), { status: 200 });
+        };
+        const model = new DevstralLanguageModel({
+            apiKey: 'stream-tool-key',
+            fetch: fakeFetch,
+            baseURL: 'https://windsurf.test',
+        });
+        const result = await model.doStream({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Call tools.' }] }],
+            tools: {
+                searchRepo: {
+                    description: 'Search repository files',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string' },
+                        },
+                        required: ['query'],
+                    },
+                },
+            },
+        });
+        const parts = await collectStreamParts(result.stream);
+        expect(parts.map((part) => part.type)).toEqual([
+            'stream-start',
+            'response-metadata',
+            'tool-input-start',
+            'tool-input-delta',
+            'tool-input-end',
+            'tool-call',
+            'finish',
+        ]);
+        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"}',
+        });
+    });
+    it('abort stops stream mid-response', async () => {
+        const controller = new AbortController();
+        const jwt = makeJwt(4_300_000_002, 'abort');
+        const frames = Buffer.concat([
+            connectFrameEncode(Buffer.from('first ', 'utf8')),
+            connectFrameEncode(Buffer.from('second ', 'utf8')),
+            connectFrameEncode(Buffer.from('third', 'utf8')),
+        ]);
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            return new Response(makeChunkedBody(chunkBuffer(frames, 5), { delayMs: 10, signal: init?.signal ?? undefined }), {
+                status: 200,
+            });
+        };
+        const model = new DevstralLanguageModel({
+            apiKey: 'stream-abort-key',
+            fetch: fakeFetch,
+            baseURL: 'https://windsurf.test',
+        });
+        const result = await model.doStream({
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Abort stream.' }] }],
+            abortSignal: controller.signal,
+        });
+        const reader = result.stream.getReader();
+        const seen = [];
+        while (true) {
+            const next = await reader.read();
+            if (next.done) {
+                break;
+            }
+            const part = next.value;
+            seen.push(part);
+            if (part.type === 'text-delta') {
+                controller.abort();
+            }
+        }
+        const types = seen.map((part) => part.type);
+        expect(types).toContain('text-delta');
+        expect(types.filter((type) => type === 'text-delta')).toHaveLength(1);
+        expect(types).not.toContain('finish');
+    });
+});

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

@@ -0,0 +1,36 @@
+import { gunzipSync, gzipSync } from 'node:zlib';
+const FRAME_HEADER_SIZE = 5;
+const FLAG_COMPRESSED = 1;
+/**
+ * Encode a protobuf payload into a Connect-RPC frame.
+ *
+ * @param payload - The raw protobuf bytes to encode
+ * @param compress - Whether to gzip-compress the payload (default: true)
+ *                   When true, the payload is gzipped and flags=1 is set
+ * @returns Buffer containing: [flags byte][4-byte length][payload (gzipped if compress=true)]
+ */
+export function connectFrameEncode(payload, compress = true) {
+    const payloadBytes = compress ? gzipSync(payload) : payload;
+    const frame = Buffer.allocUnsafe(FRAME_HEADER_SIZE + payloadBytes.length);
+    frame.writeUInt8(compress ? FLAG_COMPRESSED : 0, 0);
+    frame.writeUInt32BE(payloadBytes.length, 1);
+    payloadBytes.copy(frame, FRAME_HEADER_SIZE);
+    return frame;
+}
+export function connectFrameDecode(buffer) {
+    const decoded = [];
+    let offset = 0;
+    while (offset + FRAME_HEADER_SIZE <= buffer.length) {
+        const flags = buffer.readUInt8(offset);
+        const payloadLength = buffer.readUInt32BE(offset + 1);
+        const payloadStart = offset + FRAME_HEADER_SIZE;
+        const payloadEnd = payloadStart + payloadLength;
+        if (payloadEnd > buffer.length) {
+            break;
+        }
+        const payload = buffer.subarray(payloadStart, payloadEnd);
+        decoded.push(flags === FLAG_COMPRESSED ? gunzipSync(payload) : Buffer.from(payload));
+        offset = payloadEnd;
+    }
+    return decoded;
+}

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

@@ -0,0 +1,34 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { connectFrameDecode, connectFrameEncode } 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'));
+const payloadHello = Buffer.from('CONNECT\x01hello', 'utf8');
+const payloadWorld = Buffer.from('CONNECT\x02world', 'utf8');
+describe('connectFrameEncode', () => {
+    it('roundtrip encodes and decodes uncompressed payload', () => {
+        const encoded = connectFrameEncode(payloadHello, false);
+        expect(encoded.readUInt8(0)).toBe(0);
+        expect(encoded.readUInt32BE(1)).toBe(payloadHello.length);
+        expect(encoded.subarray(5)).toEqual(payloadHello);
+        expect(connectFrameDecode(encoded)).toEqual([payloadHello]);
+    });
+    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]);
+    });
+});
+describe('connectFrameDecode fixtures', () => {
+    it('decodes frame-simple fixture payload', () => {
+        expect(connectFrameDecode(fixtureSimpleFrame)).toEqual([payloadHello]);
+    });
+    it('decodes gzip fixture payload', () => {
+        expect(connectFrameDecode(fixtureGzipFrame)).toEqual([payloadWorld]);
+    });
+    it('decodes multiple concatenated frames in order', () => {
+        expect(connectFrameDecode(fixtureMultiFrame)).toEqual([payloadHello, payloadHello]);
+    });
+});

package/dist/esm/protocol/protobuf.js

@@ -0,0 +1,108 @@
+function encodeVarint(value) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`Varint value must be a non-negative integer: ${value}`);
+    }
+    const bytes = [];
+    let remaining = value;
+    while (remaining >= 0x80) {
+        bytes.push((remaining & 0x7f) | 0x80);
+        remaining = Math.floor(remaining / 0x80);
+    }
+    bytes.push(remaining);
+    return Buffer.from(bytes);
+}
+function decodeUtf8IfValid(value) {
+    if (value.length === 0) {
+        return '';
+    }
+    const decoded = value.toString('utf8');
+    const encoded = Buffer.from(decoded, 'utf8');
+    if (!encoded.equals(value)) {
+        return null;
+    }
+    return decoded;
+}
+export class ProtobufEncoder {
+    chunks = [];
+    writeVarint(field, value) {
+        this.writeTag(field, 0);
+        this.chunks.push(encodeVarint(value));
+    }
+    writeString(field, value) {
+        this.writeBytes(field, Buffer.from(value, 'utf8'));
+    }
+    writeBytes(field, data) {
+        this.writeTag(field, 2);
+        this.chunks.push(encodeVarint(data.length));
+        this.chunks.push(data);
+    }
+    writeMessage(field, encoder) {
+        this.writeBytes(field, encoder.toBuffer());
+    }
+    toBuffer() {
+        return Buffer.concat(this.chunks);
+    }
+    writeTag(field, wireType) {
+        if (!Number.isInteger(field) || field <= 0) {
+            throw new Error(`Field number must be a positive integer: ${field}`);
+        }
+        this.chunks.push(encodeVarint((field << 3) | wireType));
+    }
+}
+export function decodeVarint(buffer, offset) {
+    let value = 0;
+    let shift = 0;
+    let cursor = offset;
+    while (cursor < buffer.length) {
+        const byte = buffer.readUInt8(cursor);
+        value += (byte & 0x7f) * 2 ** shift;
+        cursor += 1;
+        if ((byte & 0x80) === 0) {
+            return [value, cursor];
+        }
+        shift += 7;
+    }
+    throw new Error('Unexpected end of buffer while decoding varint');
+}
+export function extractStrings(buffer) {
+    const result = [];
+    let offset = 0;
+    while (offset < buffer.length) {
+        let key;
+        [key, offset] = decodeVarint(buffer, offset);
+        const wireType = key & 0x07;
+        if (wireType === 0) {
+            [, offset] = decodeVarint(buffer, offset);
+            continue;
+        }
+        if (wireType === 1) {
+            offset += 8;
+            continue;
+        }
+        if (wireType === 2) {
+            let length;
+            [length, offset] = decodeVarint(buffer, offset);
+            const end = offset + length;
+            if (end > buffer.length) {
+                break;
+            }
+            const slice = buffer.subarray(offset, end);
+            const candidate = decodeUtf8IfValid(slice);
+            if (candidate !== null) {
+                result.push(candidate);
+            }
+            else {
+                const nested = extractStrings(slice);
+                result.push(...nested);
+            }
+            offset = end;
+            continue;
+        }
+        if (wireType === 5) {
+            offset += 4;
+            continue;
+        }
+        break;
+    }
+    return result;
+}

package/dist/esm/protocol/protobuf.test.js

@@ -0,0 +1,56 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { ProtobufEncoder, decodeVarint, extractStrings } from './protobuf.js';
+const fixtureMsg1 = readFileSync(join(process.cwd(), 'test/fixtures/protobuf/msg-1.bin'));
+const fixtureMsg2 = readFileSync(join(process.cwd(), 'test/fixtures/protobuf/msg-2.bin'));
+describe('ProtobufEncoder', () => {
+    it('matches fixture bytes for synthetic protobuf messages', () => {
+        const encoder1 = new ProtobufEncoder();
+        encoder1.writeVarint(1, 150);
+        encoder1.writeString(2, 'alpha');
+        const encoder2 = new ProtobufEncoder();
+        encoder2.writeVarint(1, 42);
+        encoder2.writeString(2, 'beta');
+        expect(encoder1.toBuffer()).toEqual(fixtureMsg1);
+        expect(encoder2.toBuffer()).toEqual(fixtureMsg2);
+    });
+    it('writes bytes and nested messages', () => {
+        const nested = new ProtobufEncoder();
+        nested.writeString(1, 'xy');
+        const encoder = new ProtobufEncoder();
+        encoder.writeBytes(3, Buffer.from([0xaa, 0xbb]));
+        encoder.writeMessage(4, nested);
+        expect(Array.from(encoder.toBuffer())).toEqual([
+            0x1a,
+            0x02,
+            0xaa,
+            0xbb,
+            0x22,
+            0x04,
+            0x0a,
+            0x02,
+            0x78,
+            0x79,
+        ]);
+    });
+});
+describe('decodeVarint', () => {
+    it('decodes varint value and returns new offset', () => {
+        const buffer = Buffer.from([0x96, 0x01, 0x2a]);
+        const [first, firstOffset] = decodeVarint(buffer, 0);
+        const [second, secondOffset] = decodeVarint(buffer, firstOffset);
+        expect(first).toBe(150);
+        expect(firstOffset).toBe(2);
+        expect(second).toBe(42);
+        expect(secondOffset).toBe(3);
+    });
+});
+describe('extractStrings', () => {
+    it('extractStrings returns all embedded strings from fixtures', () => {
+        const combined = Buffer.concat([fixtureMsg1, fixtureMsg2]);
+        expect(extractStrings(fixtureMsg1)).toEqual(['alpha']);
+        expect(extractStrings(fixtureMsg2)).toEqual(['beta']);
+        expect(extractStrings(combined)).toEqual(['alpha', 'beta']);
+    });
+});

package/dist/esm/provider.js

@@ -0,0 +1,9 @@
+import { DevstralLanguageModel } from './model/devstral-language-model.js';
+export function createWindsurfProvider(options = {}) {
+    return (modelId) => {
+        const opts = { ...options, modelId };
+        return new DevstralLanguageModel(opts);
+    };
+}
+export const windsurf = createWindsurfProvider();
+export default windsurf;