@bxb1337/windsurf-fast-context 1.0.0

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const prompt_converter_js_1 = require("./prompt-converter.js");
+(0, vitest_1.describe)('convertPrompt', () => {
+    (0, vitest_1.it)('system maps to role 5', () => {
+        const prompt = [{ role: 'system', content: 'Keep answers concise.' }];
+        const result = (0, prompt_converter_js_1.convertPrompt)(prompt);
+        (0, vitest_1.expect)(result).toEqual([{ role: 5, content: 'Keep answers concise.' }]);
+    });
+    (0, vitest_1.it)('tool-call converts assistant tool calls and preserves id/name/args', () => {
+        const prompt = [
+            {
+                role: 'assistant',
+                content: [
+                    { type: 'text', text: 'Let me call a tool.' },
+                    {
+                        type: 'tool-call',
+                        toolCallId: 'call_1',
+                        toolName: 'searchDocs',
+                        args: { query: 'prompt converter', topK: 3 },
+                    },
+                ],
+            },
+        ];
+        const result = (0, prompt_converter_js_1.convertPrompt)(prompt);
+        (0, vitest_1.expect)(result).toHaveLength(2);
+        (0, vitest_1.expect)(result[0]).toEqual({ role: 2, content: 'Let me call a tool.' });
+        (0, vitest_1.expect)(result[1]).toEqual({
+            role: 2,
+            content: '',
+            metadata: {
+                toolCallId: 'call_1',
+                toolName: 'searchDocs',
+                toolArgsJson: '{"query":"prompt converter","topK":3}',
+            },
+        });
+    });
+    (0, vitest_1.it)('multi-turn preserves ordering across mixed roles', () => {
+        const prompt = [
+            { role: 'system', content: 'System instruction' },
+            {
+                role: 'user',
+                content: [
+                    { type: 'text', text: 'Find usage examples.' },
+                    { type: 'file', data: 'ZmFrZQ==', mediaType: 'image/png' },
+                ],
+            },
+            {
+                role: 'assistant',
+                content: [
+                    { type: 'text', text: 'I will call a tool now.' },
+                    { type: 'tool-call', toolCallId: 'call_2', toolName: 'searchDocs', args: { q: 'usage examples' } },
+                ],
+            },
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call_2',
+                        toolName: 'searchDocs',
+                        result: { hits: ['a.ts', 'b.ts'] },
+                    },
+                ],
+            },
+            { role: 'assistant', content: [{ type: 'text', text: 'Done.' }] },
+        ];
+        const snapshot = JSON.parse(JSON.stringify(prompt));
+        const result = (0, prompt_converter_js_1.convertPrompt)(prompt);
+        (0, vitest_1.expect)(result).toEqual([
+            { role: 5, content: 'System instruction' },
+            { role: 1, content: 'Find usage examples.' },
+            { role: 2, content: 'I will call a tool now.' },
+            {
+                role: 2,
+                content: '',
+                metadata: {
+                    toolCallId: 'call_2',
+                    toolName: 'searchDocs',
+                    toolArgsJson: '{"q":"usage examples"}',
+                },
+            },
+            {
+                role: 4,
+                content: '{"hits":["a.ts","b.ts"]}',
+                metadata: {
+                    refCallId: 'call_2',
+                },
+            },
+            { role: 2, content: 'Done.' },
+        ]);
+        (0, vitest_1.expect)(prompt).toEqual(snapshot);
+    });
+});

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

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertResponse = convertResponse;
+const node_zlib_1 = require("node:zlib");
+const protobuf_js_1 = require("../protocol/protobuf.js");
+const TOOL_CALL_PREFIX = '[TOOL_CALLS]';
+const ARGS_PREFIX = '[ARGS]';
+function pushText(parts, text) {
+    if (text.length > 0) {
+        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;
+    while (index < value.length) {
+        const char = value[index];
+        if (escaping) {
+            escaping = false;
+        }
+        else if (char === '\\') {
+            escaping = true;
+        }
+        else if (char === '"') {
+            return index + 1;
+        }
+        index += 1;
+    }
+    return null;
+}
+function parseBalancedEnd(value, startIndex) {
+    const stack = [value[startIndex] === '{' ? '}' : ']'];
+    let index = startIndex + 1;
+    let inString = false;
+    let escaping = false;
+    while (index < value.length) {
+        const char = value[index];
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+            }
+            else if (char === '\\') {
+                escaping = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            index += 1;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            index += 1;
+            continue;
+        }
+        if (char === '{') {
+            stack.push('}');
+            index += 1;
+            continue;
+        }
+        if (char === '[') {
+            stack.push(']');
+            index += 1;
+            continue;
+        }
+        if (char === '}' || char === ']') {
+            const expected = stack[stack.length - 1];
+            if (expected !== char) {
+                return null;
+            }
+            stack.pop();
+            index += 1;
+            if (stack.length === 0) {
+                return index;
+            }
+            continue;
+        }
+        index += 1;
+    }
+    return null;
+}
+function parsePrimitiveEnd(value, startIndex) {
+    let index = startIndex;
+    while (index < value.length) {
+        const char = value[index];
+        if (char === ' ' || char === '\n' || char === '\r' || char === '\t') {
+            break;
+        }
+        index += 1;
+    }
+    return index;
+}
+function parseJsonValue(value, startIndex) {
+    let jsonStart = startIndex;
+    while (jsonStart < value.length) {
+        const char = value[jsonStart];
+        if (char !== ' ' && char !== '\n' && char !== '\r' && char !== '\t') {
+            break;
+        }
+        jsonStart += 1;
+    }
+    if (jsonStart >= value.length) {
+        return null;
+    }
+    const firstChar = value[jsonStart];
+    let endIndex;
+    if (firstChar === '{' || firstChar === '[') {
+        endIndex = parseBalancedEnd(value, jsonStart);
+    }
+    else if (firstChar === '"') {
+        endIndex = parseStringEnd(value, jsonStart);
+    }
+    else {
+        endIndex = parsePrimitiveEnd(value, jsonStart);
+    }
+    if (endIndex == null || endIndex <= jsonStart) {
+        return null;
+    }
+    const rawJson = value.slice(jsonStart, endIndex);
+    try {
+        return {
+            parsed: JSON.parse(rawJson),
+            endIndex,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function hasControlChars(value) {
+    for (const char of value) {
+        const code = char.charCodeAt(0);
+        if (code <= 8 || code === 11 || code === 12 || (code >= 14 && code <= 31)) {
+            return true;
+        }
+    }
+    return false;
+}
+function maybeGunzip(buffer) {
+    if (buffer.length < 2) {
+        return buffer;
+    }
+    if (buffer.readUInt8(0) !== 0x1f || buffer.readUInt8(1) !== 0x8b) {
+        return buffer;
+    }
+    try {
+        return (0, node_zlib_1.gunzipSync)(buffer);
+    }
+    catch {
+        return buffer;
+    }
+}
+function isLikelyMetadata(value) {
+    return /^[A-Za-z0-9._:-]{1,32}$/.test(value);
+}
+function pickBestExtractedText(values) {
+    const markerValues = values.filter((value) => value.includes(TOOL_CALL_PREFIX) || value.includes(ARGS_PREFIX));
+    if (markerValues.length > 0) {
+        return markerValues.join('');
+    }
+    const nonMetadata = values.filter((value) => !isLikelyMetadata(value));
+    const candidates = nonMetadata.length > 0 ? nonMetadata : values;
+    return candidates.reduce((best, current) => (current.length > best.length ? current : best), candidates[0] ?? '');
+}
+function decodeResponseText(buffer) {
+    const source = maybeGunzip(buffer);
+    const raw = source.toString('utf8');
+    if (!hasControlChars(raw) && !raw.includes('\ufffd')) {
+        return raw;
+    }
+    const extracted = (0, protobuf_js_1.extractStrings)(source).filter((value) => value.length > 0 && !hasControlChars(value));
+    if (extracted.length === 0) {
+        return raw;
+    }
+    return pickBestExtractedText(extracted);
+}
+function convertResponse(buffer) {
+    const responseText = decodeResponseText(buffer);
+    const parts = [];
+    let cursor = 0;
+    let toolCallCount = 0;
+    while (cursor < responseText.length) {
+        const markerStart = responseText.indexOf(TOOL_CALL_PREFIX, cursor);
+        if (markerStart === -1) {
+            pushText(parts, responseText.slice(cursor));
+            break;
+        }
+        pushText(parts, responseText.slice(cursor, markerStart));
+        const toolNameStart = markerStart + TOOL_CALL_PREFIX.length;
+        const argsStart = responseText.indexOf(ARGS_PREFIX, toolNameStart);
+        if (argsStart === -1) {
+            pushText(parts, responseText.slice(markerStart));
+            break;
+        }
+        const toolName = responseText.slice(toolNameStart, argsStart);
+        const parsedArgs = parseJsonValue(responseText, argsStart + ARGS_PREFIX.length);
+        if (parsedArgs == null) {
+            const nextMarker = responseText.indexOf(TOOL_CALL_PREFIX, markerStart + TOOL_CALL_PREFIX.length);
+            const malformedEnd = nextMarker === -1 ? responseText.length : nextMarker;
+            pushText(parts, responseText.slice(markerStart, malformedEnd));
+            cursor = malformedEnd;
+            continue;
+        }
+        if (toolName === 'answer') {
+            pushText(parts, extractAnswerText(parsedArgs.parsed));
+        }
+        else {
+            toolCallCount += 1;
+            parts.push({
+                type: 'tool-call',
+                toolCallId: `toolcall_${toolCallCount}`,
+                toolName,
+                args: parsedArgs.parsed,
+            });
+        }
+        cursor = parsedArgs.endIndex;
+    }
+    return parts;
+}

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const node_zlib_1 = require("node:zlib");
+const protobuf_js_1 = require("../protocol/protobuf.js");
+const response_converter_js_1 = require("./response-converter.js");
+(0, vitest_1.describe)('convertResponse', () => {
+    (0, vitest_1.it)('text - returns plain text part for plain response', () => {
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from('plain response text', 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'plain response text' }]);
+    });
+    (0, vitest_1.it)('tool-call - parses tool markers and preserves surrounding text', () => {
+        const input = 'Before [TOOL_CALLS]searchDocs[ARGS]{"query":"prompt converter"} between [TOOL_CALLS]answer[ARGS]{"answer":"final answer"} after';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([
+            { type: 'text', text: 'Before ' },
+            {
+                type: 'tool-call',
+                toolCallId: 'toolcall_1',
+                toolName: 'searchDocs',
+                args: { query: 'prompt converter' },
+            },
+            { type: 'text', text: ' between ' },
+            { type: 'text', text: 'final answer' },
+            { type: 'text', text: ' after' },
+        ]);
+    });
+    (0, vitest_1.it)('malformed - invalid marker json remains text and does not throw', () => {
+        const input = 'prefix [TOOL_CALLS]searchDocs[ARGS]{"query": nope} suffix';
+        (0, vitest_1.expect)(() => (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'))).not.toThrow();
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        const combinedText = result
+            .filter((part) => part.type === 'text')
+            .map((part) => part.text)
+            .join('');
+        (0, vitest_1.expect)(result.every((part) => part.type === 'text')).toBe(true);
+        (0, vitest_1.expect)(combinedText).toBe(input);
+    });
+    (0, vitest_1.it)('protobuf payload - extracts clean utf8 text without binary mojibake prefix', () => {
+        const payload = new protobuf_js_1.ProtobufEncoder();
+        payload.writeVarint(1, 150);
+        payload.writeString(2, '你好，TypeScript');
+        const result = (0, response_converter_js_1.convertResponse)(payload.toBuffer());
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: '你好，TypeScript' }]);
+    });
+    (0, vitest_1.it)('protobuf payload - still parses tool-call markers from extracted strings', () => {
+        const payload = new protobuf_js_1.ProtobufEncoder();
+        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.it)('protobuf payload - ignores metadata strings and keeps main text field', () => {
+        const payload = new protobuf_js_1.ProtobufEncoder();
+        payload.writeString(1, 'meta');
+        payload.writeString(2, '你好，TypeScript');
+        const result = (0, response_converter_js_1.convertResponse)(payload.toBuffer());
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: '你好，TypeScript' }]);
+    });
+    (0, vitest_1.it)('gzip payload - decompresses before decoding text', () => {
+        const compressed = (0, node_zlib_1.gzipSync)(Buffer.from('hello from gzip', 'utf8'));
+        const result = (0, response_converter_js_1.convertResponse)(compressed);
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: 'hello from gzip' }]);
+    });
+});

package/dist/cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.windsurf = exports.createWindsurfProvider = void 0;
+__exportStar(require("./types/index.js"), exports);
+var provider_js_1 = require("./provider.js");
+Object.defineProperty(exports, "createWindsurfProvider", { enumerable: true, get: function () { return provider_js_1.createWindsurfProvider; } });
+Object.defineProperty(exports, "windsurf", { enumerable: true, get: function () { return provider_js_1.windsurf; } });
+var provider_js_2 = require("./provider.js");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return provider_js_2.default; } });