@bxb1337/windsurf-fast-context 1.0.7 → 1.0.9

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

@@ -1,11 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertPrompt = convertPrompt;
-function toContentString(value) {
-    if (typeof value === 'string') {
-        return value;
+function toolOutputToString(output) {
+    switch (output.type) {
+        case 'text':
+        case 'error-text':
+            return output.value;
+        case 'json':
+        case 'error-json':
+            return JSON.stringify(output.value);
+        case 'execution-denied': {
+            const obj = { type: 'execution-denied' };
+            if (output.reason !== undefined)
+                obj.reason = output.reason;
+            return JSON.stringify(obj);
+        }
+        case 'content':
+            return JSON.stringify(output.value);
+        default:
+            return JSON.stringify(output);
     }
-    return JSON.stringify(value);
 }
 function convertPrompt(prompt) {
     const messages = [];
@@ -42,13 +56,14 @@ function convertPrompt(prompt) {
             }
             continue;
         }
-        // Tool result messages - use refCallId to reference the original tool call
         for (const part of message.content) {
+            if (part.type !== 'tool-result')
+                continue;
             messages.push({
                 role: 4,
-                content: toContentString(part.result),
+                content: toolOutputToString(part.output),
                 metadata: {
-                    refCallId: part.toolCallId, // This links back to the tool call
+                    refCallId: part.toolCallId,
                 },
             });
         }

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', () => {
+    (0, vitest_1.it)('multi-turn preserves ordering across mixed roles (V3 output shape)', () => {
         const prompt = [
             { role: 'system', content: 'System instruction' },
             {
@@ -60,7 +60,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
                         type: 'tool-result',
                         toolCallId: 'call_2',
                         toolName: 'searchDocs',
-                        result: { hits: ['a.ts', 'b.ts'] },
+                        output: { type: 'json', value: { hits: ['a.ts', 'b.ts'] } },
                     },
                 ],
             },
@@ -92,4 +92,119 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
         ]);
         (0, vitest_1.expect)(prompt).toEqual(snapshot);
     });
+    (0, vitest_1.it)('tool-result with json output serializes value to JSON', () => {
+        const prompt = [
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call_json',
+                        toolName: 'searchTool',
+                        output: { type: 'json', value: { files: ['x.ts', 'y.ts'], count: 2 } },
+                    },
+                ],
+            },
+        ];
+        const result = (0, prompt_converter_js_1.convertPrompt)(prompt);
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                role: 4,
+                content: '{"files":["x.ts","y.ts"],"count":2}',
+                metadata: { refCallId: 'call_json' },
+            },
+        ]);
+    });
+    (0, vitest_1.it)('tool-result with text output uses string directly', () => {
+        const prompt = [
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call_text',
+                        toolName: 'readFile',
+                        output: { type: 'text', value: 'Operation completed successfully' },
+                    },
+                ],
+            },
+        ];
+        const result = (0, prompt_converter_js_1.convertPrompt)(prompt);
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                role: 4,
+                content: 'Operation completed successfully',
+                metadata: { refCallId: 'call_text' },
+            },
+        ]);
+    });
+    (0, vitest_1.it)('tool-result with error-text output serializes error message', () => {
+        const prompt = [
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call_error',
+                        toolName: 'executeCommand',
+                        output: { type: 'error-text', value: 'Tool execution failed: timeout' },
+                    },
+                ],
+            },
+        ];
+        const result = (0, prompt_converter_js_1.convertPrompt)(prompt);
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                role: 4,
+                content: 'Tool execution failed: timeout',
+                metadata: { refCallId: 'call_error' },
+            },
+        ]);
+    });
+    (0, vitest_1.it)('tool-result with execution-denied output includes reason', () => {
+        const prompt = [
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call_denied',
+                        toolName: 'dangerousAction',
+                        output: { type: 'execution-denied', reason: 'User rejected tool execution' },
+                    },
+                ],
+            },
+        ];
+        const result = (0, prompt_converter_js_1.convertPrompt)(prompt);
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                role: 4,
+                content: '{"type":"execution-denied","reason":"User rejected tool execution"}',
+                metadata: { refCallId: 'call_denied' },
+            },
+        ]);
+    });
+    (0, vitest_1.it)('tool-result with execution-denied output handles missing reason', () => {
+        const prompt = [
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call_denied_no_reason',
+                        toolName: 'someTool',
+                        output: { type: 'execution-denied' },
+                    },
+                ],
+            },
+        ];
+        const result = (0, prompt_converter_js_1.convertPrompt)(prompt);
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                role: 4,
+                content: '{"type":"execution-denied"}',
+                metadata: { refCallId: 'call_denied_no_reason' },
+            },
+        ]);
+    });
 });

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

@@ -6,9 +6,6 @@ const protobuf_js_1 = require("../protocol/protobuf.js");
 const TOOL_CALL_PREFIX = '[TOOL_CALLS]';
 const ARGS_PREFIX = '[ARGS]';
 const STOP_TOKEN = '</s>';
-const EMPTY_TOOL_CALLS_PATTERN = /TOOL_CALLS\d*(?:<\/s>)?\s*(?:\{\s*\}\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;
@@ -75,20 +72,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;
@@ -255,7 +238,6 @@ function decodeResponseText(buffer) {
 }
 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) {
@@ -286,18 +268,13 @@ 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/cjs/conversion/response-converter.test.js

@@ -21,7 +21,12 @@ const response_converter_js_1 = require("./response-converter.js");
                 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' },
         ]);
     });
@@ -48,7 +53,14 @@ const response_converter_js_1 = require("./response-converter.js");
         payload.writeVarint(1, 150);
         payload.writeString(2, '[TOOL_CALLS]answer[ARGS]{"answer":"final answer"}');
         const result = (0, response_converter_js_1.convertResponse)(payload.toBuffer());
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'final answer' }]);
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'answer',
+                input: { answer: 'final answer' },
+            },
+        ]);
     });
     (0, vitest_1.it)('protobuf payload - ignores metadata strings and keeps main text field', () => {
         const payload = new protobuf_js_1.ProtobufEncoder();
@@ -62,76 +74,11 @@ const response_converter_js_1 = require("./response-converter.js");
         const result = (0, response_converter_js_1.convertResponse)(compressed);
         (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'hello from gzip' }]);
     });
-    (0, vitest_1.it)('strips empty TOOL_CALLS markers with stop token', () => {
-        const input = 'Hello world TOOL_CALLS0</s>{}';
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Hello world ' }]);
-    });
-    (0, vitest_1.it)('strips empty TOOL_CALLS markers without stop token', () => {
-        const input = 'Hello world TOOL_CALLS1{}';
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Hello world ' }]);
-    });
-    (0, vitest_1.it)('strips empty TOOL_CALLS markers with whitespace', () => {
-        const input = 'Text TOOL_CALLS2{   } more text';
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Text more text' }]);
-    });
     (0, vitest_1.it)('strips standalone stop token', () => {
         const input = 'Hello world</s>';
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
         (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Hello world' }]);
     });
-    (0, vitest_1.it)('handles TOOL_CALLS with number prefix before stop token', () => {
-        const input = 'Text before TOOL_CALLS1</s>{} text after';
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Text before text after' }]);
-    });
-    (0, vitest_1.it)('strips TOOL_CALLS with double empty braces', () => {
-        const input = 'Hello world TOOL_CALLS1{}{}';
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Hello world ' }]);
-    });
-    (0, vitest_1.it)('strips TOOL_CALLS with triple empty braces', () => {
-        const input = 'Response TOOL_CALLS2{}{}{} end';
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Response end' }]);
-    });
-    (0, vitest_1.it)('strips TOOL_CALLS with stop token and multiple braces', () => {
-        const input = 'Text TOOL_CALLS0</s>{}{} more text';
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'Text more text' }]);
-    });
-    (0, vitest_1.it)('handles empty marker followed by real tool call', () => {
-        const input = 'TOOL_CALLS0{} [TOOL_CALLS]searchDocs[ARGS]{"query":"test"}';
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'searchDocs',
-                input: { query: 'test' },
-            },
-        ]);
-    });
-    (0, vitest_1.it)('handles real tool call followed by empty marker', () => {
-        const input = '[TOOL_CALLS]searchDocs[ARGS]{"query":"test"} TOOL_CALLS1{} done';
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_1',
-                toolName: 'searchDocs',
-                input: { query: 'test' },
-            },
-            { type: 'text', text: ' done' },
-        ]);
-    });
-    (0, vitest_1.it)('handles empty marker adjacent to real tool call', () => {
-        const input = 'TOOL_CALLS0{}[TOOL_CALLS]answer[ARGS]{"answer":"result"}';
-        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
-        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'result' }]);
-    });
     (0, vitest_1.it)('parses OpenAI-style TOOL_CALLS with numeric IDs', () => {
         const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"file_path":"/home/test","search_pattern":"binance"}}}{}';
         const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
@@ -186,4 +133,16 @@ const response_converter_js_1 = require("./response-converter.js");
             },
         ]);
     });
+    (0, vitest_1.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 = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'answer',
+                input: { answer: 'final answer' },
+            },
+        ]);
+    });
 });

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

@@ -56,12 +56,18 @@ 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 unified = content.some((part) => part.type === 'tool-call')
+            ? 'tool-calls'
+            : 'stop';
         return {
             content,
-            finishReason: 'stop',
+            finishReason: {
+                unified,
+                raw: undefined,
+            },
             usage: emptyUsage(),
             warnings: [],
         };
@@ -89,6 +95,7 @@ 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) {
@@ -103,7 +110,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;
@@ -138,6 +145,7 @@ class DevstralLanguageModel {
                                         continue;
                                     }
                                     closeTextSegment();
+                                    hasToolCalls = true;
                                     safeEnqueue(controller, {
                                         type: 'tool-input-start',
                                         id: part.toolCallId,
@@ -154,6 +162,9 @@ class DevstralLanguageModel {
                                     });
                                     safeEnqueue(controller, part);
                                 }
+                                if (frameResult.isEndStream) {
+                                    break outerLoop;
+                                }
                             }
                         }
                         if (isAborted(options.abortSignal)) {
@@ -161,10 +172,13 @@ 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);
@@ -178,8 +192,10 @@ class DevstralLanguageModel {
                             });
                             safeEnqueue(controller, {
                                 type: 'finish',
-                                finishReason: 'error',
-                                rawFinishReason: 'error',
+                                finishReason: {
+                                    unified: 'error',
+                                    raw: undefined,
+                                },
                                 usage: emptyUsage(),
                             });
                         }
@@ -206,10 +222,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) {
@@ -253,31 +270,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 protobuf_js_1.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));