@bxb1337/windsurf-fast-context 1.0.0

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

@@ -0,0 +1,54 @@
+function toContentString(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+export function convertPrompt(prompt) {
+    const messages = [];
+    for (const message of prompt) {
+        if (message.role === 'system') {
+            messages.push({ role: 5, content: message.content });
+            continue;
+        }
+        if (message.role === 'user') {
+            const text = message.content
+                .filter((part) => part.type === 'text')
+                .map((part) => part.text)
+                .join('');
+            messages.push({ role: 1, content: text });
+            continue;
+        }
+        if (message.role === 'assistant') {
+            for (const part of message.content) {
+                if (part.type === 'text') {
+                    messages.push({ role: 2, content: part.text });
+                    continue;
+                }
+                if (part.type === 'tool-call') {
+                    messages.push({
+                        role: 2,
+                        content: '',
+                        metadata: {
+                            toolCallId: part.toolCallId,
+                            toolName: part.toolName,
+                            toolArgsJson: JSON.stringify(part.args),
+                        },
+                    });
+                }
+            }
+            continue;
+        }
+        // Tool result messages - use refCallId to reference the original tool call
+        for (const part of message.content) {
+            messages.push({
+                role: 4,
+                content: toContentString(part.result),
+                metadata: {
+                    refCallId: part.toolCallId, // This links back to the tool call
+                },
+            });
+        }
+    }
+    return messages;
+}

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

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+import { convertPrompt } from './prompt-converter.js';
+describe('convertPrompt', () => {
+    it('system maps to role 5', () => {
+        const prompt = [{ role: 'system', content: 'Keep answers concise.' }];
+        const result = convertPrompt(prompt);
+        expect(result).toEqual([{ role: 5, content: 'Keep answers concise.' }]);
+    });
+    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 = convertPrompt(prompt);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toEqual({ role: 2, content: 'Let me call a tool.' });
+        expect(result[1]).toEqual({
+            role: 2,
+            content: '',
+            metadata: {
+                toolCallId: 'call_1',
+                toolName: 'searchDocs',
+                toolArgsJson: '{"query":"prompt converter","topK":3}',
+            },
+        });
+    });
+    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 = convertPrompt(prompt);
+        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.' },
+        ]);
+        expect(prompt).toEqual(snapshot);
+    });
+});

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

@@ -0,0 +1,230 @@
+import { gunzipSync } from 'node:zlib';
+import { extractStrings } from '../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 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 = extractStrings(source).filter((value) => value.length > 0 && !hasControlChars(value));
+    if (extracted.length === 0) {
+        return raw;
+    }
+    return pickBestExtractedText(extracted);
+}
+export 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/esm/conversion/response-converter.test.js

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

package/dist/esm/dist/cjs/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export * from './types/index.js';
+export { createWindsurfProvider, windsurf } from './provider.js';
+export { default } from './provider.js';