@bxb1337/windsurf-fast-context 1.0.7 → 1.0.9

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

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

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

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

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

@@ -53,12 +53,18 @@ 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 unified = content.some((part) => part.type === 'tool-call')
+            ? 'tool-calls'
+            : 'stop';
         return {
             content,
-            finishReason: 'stop',
+            finishReason: {
+                unified,
+                raw: undefined,
+            },
             usage: emptyUsage(),
             warnings: [],
         };
@@ -86,6 +92,7 @@ export class DevstralLanguageModel {
                     options.abortSignal?.addEventListener('abort', abortHandler, { once: true });
                     let textSegmentId = null;
                     let textSegmentCounter = 0;
+                    let hasToolCalls = false;
                     let pending = Buffer.alloc(0);
                     const closeTextSegment = () => {
                         if (textSegmentId == null) {
@@ -100,7 +107,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;
@@ -135,6 +142,7 @@ export class DevstralLanguageModel {
                                         continue;
                                     }
                                     closeTextSegment();
+                                    hasToolCalls = true;
                                     safeEnqueue(controller, {
                                         type: 'tool-input-start',
                                         id: part.toolCallId,
@@ -151,6 +159,9 @@ export class DevstralLanguageModel {
                                     });
                                     safeEnqueue(controller, part);
                                 }
+                                if (frameResult.isEndStream) {
+                                    break outerLoop;
+                                }
                             }
                         }
                         if (isAborted(options.abortSignal)) {
@@ -158,10 +169,13 @@ export class DevstralLanguageModel {
                             return;
                         }
                         closeTextSegment();
+                        const unified = hasToolCalls ? 'tool-calls' : 'stop';
                         safeEnqueue(controller, {
                             type: 'finish',
-                            finishReason: 'stop',
-                            rawFinishReason: 'stop',
+                            finishReason: {
+                                unified,
+                                raw: undefined,
+                            },
                             usage: emptyUsage(),
                         });
                         safeClose(controller);
@@ -175,8 +189,10 @@ export class DevstralLanguageModel {
                             });
                             safeEnqueue(controller, {
                                 type: 'finish',
-                                finishReason: 'error',
-                                rawFinishReason: 'error',
+                                finishReason: {
+                                    unified: 'error',
+                                    raw: undefined,
+                                },
                                 usage: emptyUsage(),
                             });
                         }
@@ -202,10 +218,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) {
@@ -249,31 +266,35 @@ function emptyUsage() {
 }
 function toV3Content(parts) {
     return parts.map((part) => {
-        if (part.type === 'tool-call') {
-            return {
-                type: 'tool-call',
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                input: JSON.stringify(part.input),
-            };
+        if (part.type !== 'tool-call') {
+            return part;
         }
-        return part;
+        const input = typeof part.input === 'string' ? part.input : JSON.stringify(part.input);
+        return {
+            type: 'tool-call',
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            input,
+        };
     });
 }
+function isFunctionTool(tool) {
+    return tool.type === 'function';
+}
 function buildGenerateRequest(input) {
     const request = new ProtobufEncoder();
     request.writeMessage(1, buildMetadata(input.apiKey, input.jwt));
     for (const message of input.messages) {
         request.writeMessage(2, buildMessage(message));
     }
-    // Tools are sent as a single JSON string at field 3 (not repeated messages)
-    if (input.tools && Object.keys(input.tools).length > 0) {
-        const toolsArray = Object.entries(input.tools).map(([name, tool]) => ({
+    const functionTools = input.tools?.filter(isFunctionTool) ?? [];
+    if (functionTools.length > 0) {
+        const toolsArray = functionTools.map((tool) => ({
             type: 'function',
             function: {
-                name,
+                name: tool.name,
                 description: tool.description ?? '',
-                parameters: tool.parameters ?? {},
+                parameters: tool.inputSchema,
             },
         }));
         request.writeString(3, JSON.stringify(toolsArray));

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

@@ -64,8 +64,11 @@ 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"'));
 }
 async function collectStreamParts(stream) {
     const reader = stream.getReader();
@@ -134,7 +137,7 @@ describe('DevstralLanguageModel doGenerate', () => {
             prompt: [{ role: 'user', content: [{ type: 'text', text: 'Find auth logic.' }] }],
         });
         expect(result.content).toEqual([{ type: 'text', text: 'generated answer' }]);
-        expect(result.finishReason).toBe('stop');
+        expect(result.finishReason).toEqual({ unified: 'stop', raw: undefined });
         expect(result.usage).toEqual({
             inputTokens: {
                 total: undefined,
@@ -157,7 +160,7 @@ describe('DevstralLanguageModel doGenerate', () => {
         expect(combined).toContain(jwt);
         expect(combined).toContain('Find auth logic.');
     });
-    it('generate request with tool markers returns tool-call content parts', async () => {
+    it('doGenerate accepts function tools array with inputSchema', async () => {
         const requestBodies = [];
         const jwt = makeJwt(4_200_000_000, 'tools');
         const fakeFetch = async (input, init) => {
@@ -172,10 +175,12 @@ describe('DevstralLanguageModel doGenerate', () => {
         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: {
+            tools: [
+                {
+                    type: 'function',
+                    name: 'searchRepo',
                     description: 'Search repository files',
-                    parameters: {
+                    inputSchema: {
                         type: 'object',
                         properties: {
                             query: { type: 'string' },
@@ -183,7 +188,7 @@ describe('DevstralLanguageModel doGenerate', () => {
                         required: ['query'],
                     },
                 },
-            },
+            ],
         });
         expect(result.content).toEqual([
             {
@@ -193,12 +198,88 @@ describe('DevstralLanguageModel doGenerate', () => {
                 input: '{"query":"jwt manager"}',
             },
         ]);
+        expect(result.finishReason).toEqual({ unified: 'tool-calls', raw: undefined });
         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');
+        const toolsPayload = extractToolsPayload(strings);
+        expect(toolsPayload).toBeDefined();
+        const parsedTools = JSON.parse(toolsPayload ?? '[]');
+        expect(parsedTools).toEqual([
+            {
+                type: 'function',
+                function: {
+                    name: 'searchRepo',
+                    description: 'Search repository files',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string' },
+                        },
+                        required: ['query'],
+                    },
+                },
+            },
+        ]);
+    });
+    it('filters provider tools from tools array serialization', async () => {
+        const requestBodies = [];
+        const jwt = makeJwt(4_200_000_001, 'provider-tools');
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            requestBodies.push(bufferFromBody(init?.body));
+            return new Response(Uint8Array.from(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: 'Filter provider tools.' }] }],
+            tools: [
+                {
+                    type: 'function',
+                    name: 'searchRepo',
+                    description: 'Search repository files',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string' },
+                        },
+                        required: ['query'],
+                    },
+                },
+                {
+                    type: 'provider',
+                    id: 'windsurf.restricted_exec',
+                    name: 'restricted_exec',
+                    args: { mode: 'read-only' },
+                },
+            ],
+        });
+        const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        const toolsPayload = extractToolsPayload(strings);
+        expect(toolsPayload).toBeDefined();
+        const parsedTools = JSON.parse(toolsPayload ?? '[]');
+        expect(parsedTools).toHaveLength(1);
+        expect(parsedTools[0]).toMatchObject({ function: { name: 'searchRepo' } });
+    });
+    it('handles empty tools array without serializing tool payload', async () => {
+        const requestBodies = [];
+        const jwt = makeJwt(4_200_000_002, 'empty-tools');
+        const fakeFetch = async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/GetUserJwt')) {
+                return new Response(Uint8Array.from(Buffer.from(jwt, 'utf8')), { status: 200 });
+            }
+            requestBodies.push(bufferFromBody(init?.body));
+            return new Response(Uint8Array.from(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: 'No tools this turn.' }] }],
+            tools: [],
+        });
+        const strings = extractStrings(decodeRequestPayload(requestBodies[0] ?? Buffer.alloc(0)));
+        expect(extractToolsPayload(strings)).toBeUndefined();
     });
 });
 describe('DevstralLanguageModel doStream', () => {
@@ -287,8 +368,10 @@ describe('DevstralLanguageModel doStream', () => {
             expect(parts[4]).toMatchObject({ type: 'text-delta', delta: 'world' });
             expect(parts[6]).toEqual({
                 type: 'finish',
-                finishReason: 'stop',
-                rawFinishReason: 'stop',
+                finishReason: {
+                    unified: 'stop',
+                    raw: undefined,
+                },
                 usage: {
                     inputTokens: {
                         total: undefined,
@@ -329,10 +412,12 @@ describe('DevstralLanguageModel doStream', () => {
         });
         const result = await model.doStream({
             prompt: [{ role: 'user', content: [{ type: 'text', text: 'Call tools.' }] }],
-            tools: {
-                searchRepo: {
+            tools: [
+                {
+                    type: 'function',
+                    name: 'searchRepo',
                     description: 'Search repository files',
-                    parameters: {
+                    inputSchema: {
                         type: 'object',
                         properties: {
                             query: { type: 'string' },
@@ -340,7 +425,7 @@ describe('DevstralLanguageModel doStream', () => {
                         required: ['query'],
                     },
                 },
-            },
+            ],
         });
         const parts = await collectStreamParts(result.stream);
         expect(parts.map((part) => part.type)).toEqual([
@@ -359,6 +444,96 @@ describe('DevstralLanguageModel doStream', () => {
             toolName: 'searchRepo',
             input: '{"query":"jwt manager"}',
         });
+        expect(parts[6]).toEqual({
+            type: 'finish',
+            finishReason: {
+                unified: 'tool-calls',
+                raw: undefined,
+            },
+            usage: {
+                inputTokens: {
+                    total: undefined,
+                    noCache: undefined,
+                    cacheRead: undefined,
+                    cacheWrite: undefined,
+                },
+                outputTokens: {
+                    total: undefined,
+                    text: undefined,
+                    reasoning: undefined,
+                },
+            },
+        });
+    });
+    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();

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 };
 }