@bxb1337/windsurf-fast-context 1.0.9 → 1.1.1

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 (V3 output shape)', () => {
+    (0, vitest_1.it)('multi-turn preserves ordering across mixed roles (V2 output shape)', () => {
         const prompt = [
             { role: 'system', content: 'System instruction' },
             {
@@ -161,7 +161,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
             },
         ]);
     });
-    (0, vitest_1.it)('tool-result with execution-denied output includes reason', () => {
+    (0, vitest_1.it)('tool-result with error-text output includes denial reason', () => {
         const prompt = [
             {
                 role: 'tool',
@@ -170,7 +170,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
                         type: 'tool-result',
                         toolCallId: 'call_denied',
                         toolName: 'dangerousAction',
-                        output: { type: 'execution-denied', reason: 'User rejected tool execution' },
+                        output: { type: 'error-text', value: 'User rejected tool execution' },
                     },
                 ],
             },
@@ -179,12 +179,12 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
         (0, vitest_1.expect)(result).toEqual([
             {
                 role: 4,
-                content: '{"type":"execution-denied","reason":"User rejected tool execution"}',
+                content: 'User rejected tool execution',
                 metadata: { refCallId: 'call_denied' },
             },
         ]);
     });
-    (0, vitest_1.it)('tool-result with execution-denied output handles missing reason', () => {
+    (0, vitest_1.it)('tool-result with error-text output handles fallback denial text', () => {
         const prompt = [
             {
                 role: 'tool',
@@ -193,7 +193,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
                         type: 'tool-result',
                         toolCallId: 'call_denied_no_reason',
                         toolName: 'someTool',
-                        output: { type: 'execution-denied' },
+                        output: { type: 'error-text', value: 'Tool execution denied' },
                     },
                 ],
             },
@@ -202,7 +202,7 @@ const prompt_converter_js_1 = require("./prompt-converter.js");
         (0, vitest_1.expect)(result).toEqual([
             {
                 role: 4,
-                content: '{"type":"execution-denied"}',
+                content: 'Tool execution denied',
                 metadata: { refCallId: 'call_denied_no_reason' },
             },
         ]);

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

@@ -3,192 +3,38 @@ 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]';
 const STOP_TOKEN = '</s>';
-function parseOpenAIToolCalls(responseText) {
-    if (!responseText.startsWith('TOOL_CALLS')) {
+function parseStrictOpenAIToolCalls(responseText) {
+    const trimmed = responseText.trim();
+    if (!trimmed.startsWith('['))
         return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return null;
+        const toolCalls = [];
+        for (let i = 0; i < parsed.length; i++) {
+            const item = parsed[i];
+            if (item.type !== 'function' || !item.function?.name)
+                continue;
+            toolCalls.push({
+                type: 'tool-call',
+                toolCallId: `toolcall_${i + 1}`,
+                toolName: String(item.function.name),
+                input: item.function.parameters ?? {},
+            });
+        }
+        return toolCalls.length > 0 ? toolCalls : null;
     }
-    const jsonPart = responseText.slice('TOOL_CALLS'.length);
-    if (!jsonPart.startsWith('{')) {
-        return null;
-    }
-    const toolCalls = [];
-    let cursor = 0;
-    while (cursor < jsonPart.length) {
-        if (jsonPart[cursor] !== '{') {
-            cursor++;
-            continue;
-        }
-        const endResult = parseBalancedEnd(jsonPart, cursor);
-        if (endResult == null) {
-            break;
-        }
-        const jsonStr = jsonPart.slice(cursor, endResult);
-        cursor = endResult;
-        if (jsonStr === '{}') {
-            continue;
-        }
-        try {
-            const parsed = JSON.parse(jsonStr);
-            if (parsed.type === 'function' && parsed.function) {
-                toolCalls.push(parsed);
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    if (toolCalls.length === 0) {
+    catch {
         return null;
     }
-    return toolCalls.map((call, index) => {
-        const toolId = call.function.name;
-        const toolName = typeof toolId === 'number' ? mapToolIdToName(toolId) : String(toolId);
-        const args = call.function.parameters ?? {};
-        return {
-            type: 'tool-call',
-            toolCallId: `toolcall_${index + 1}`,
-            toolName,
-            input: args,
-        };
-    });
-}
-function mapToolIdToName(id) {
-    switch (id) {
-        case 1:
-            return 'read';
-        case 2:
-            return 'glob';
-        case 3:
-            return 'grep';
-        default:
-            return `tool_${id}`;
-    }
 }
 function pushText(parts, text) {
     if (text.length > 0) {
         parts.push({ type: 'text', text });
     }
 }
-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);
@@ -216,10 +62,6 @@ 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] ?? '');
@@ -239,43 +81,10 @@ function decodeResponseText(buffer) {
 function convertResponse(buffer) {
     let responseText = decodeResponseText(buffer);
     responseText = responseText.replace(STOP_TOKEN, '');
-    const openaiToolCalls = parseOpenAIToolCalls(responseText);
-    if (openaiToolCalls) {
-        return openaiToolCalls;
-    }
+    const strictToolCalls = parseStrictOpenAIToolCalls(responseText);
+    if (strictToolCalls)
+        return strictToolCalls;
     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;
-        }
-        toolCallCount += 1;
-        parts.push({
-            type: 'tool-call',
-            toolCallId: `toolcall_${toolCallCount}`,
-            toolName,
-            input: parsedArgs.parsed,
-        });
-        cursor = parsedArgs.endIndex;
-    }
+    pushText(parts, responseText);
     return parts;
 }

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

@@ -9,38 +9,6 @@ const response_converter_js_1 = require("./response-converter.js");
         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',
-                input: { query: 'prompt converter' },
-            },
-            { type: 'text', text: ' between ' },
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_2',
-                toolName: 'answer',
-                input: { answer: '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);
@@ -48,20 +16,6 @@ const response_converter_js_1 = require("./response-converter.js");
         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: '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();
         payload.writeString(1, 'meta');
@@ -79,70 +33,52 @@ const response_converter_js_1 = require("./response-converter.js");
         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)('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"}}}{}';
+    // Strict OpenAI array format tests
+    (0, vitest_1.it)('parses strict OpenAI array with single tool call', () => {
+        const input = '[{"type":"function","function":{"name":"search","parameters":{"q":"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: 'grep',
-                input: { file_path: '/home/test', search_pattern: 'binance' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'search', input: { q: 'test' } }
         ]);
     });
-    (0, vitest_1.it)('parses multiple OpenAI-style tool calls', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":1,"parameters":{"file_path":"/home/test"}}}, {"type":"function","function":{"name":2,"parameters":{"pattern":"*.ts"}}}{}';
+    (0, vitest_1.it)('parses strict OpenAI array with multiple tool calls', () => {
+        const input = '[{"type":"function","function":{"name":"read","parameters":{"path":"/a"}}},{"type":"function","function":{"name":"grep","parameters":{"pattern":"foo"}}}]';
         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: 'read',
-                input: { file_path: '/home/test' },
-            },
-            {
-                type: 'tool-call',
-                toolCallId: 'toolcall_2',
-                toolName: 'glob',
-                input: { pattern: '*.ts' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'read', input: { path: '/a' } },
+            { type: 'tool-call', toolCallId: 'toolcall_2', toolName: 'grep', input: { pattern: 'foo' } }
         ]);
     });
-    (0, vitest_1.it)('maps unknown tool IDs to tool_N format', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":99,"parameters":{"arg":"value"}}}{}';
+    (0, vitest_1.it)('parses strict OpenAI array with empty parameters', () => {
+        const input = '[{"type":"function","function":{"name":"list","parameters":{}}}]';
         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: 'tool_99',
-                input: { arg: 'value' },
-            },
+            { type: 'tool-call', toolCallId: 'toolcall_1', toolName: 'list', input: {} }
         ]);
     });
-    (0, vitest_1.it)('handles OpenAI-style with string tool names', () => {
-        const input = 'TOOL_CALLS{"type":"function","function":{"name":"custom_tool","parameters":{"key":"value"}}}{}';
+    (0, vitest_1.it)('returns text for old marker format (no backward compat)', () => {
+        const input = '[TOOL_CALLS]search[ARGS]{"q":"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: 'custom_tool',
-                input: { key: 'value' },
-            },
-        ]);
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: '[TOOL_CALLS]search[ARGS]{"q":"test"}' }]);
     });
-    (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"}}}{}';
+    (0, vitest_1.it)('returns text for old TOOL_CALLS format (no backward compat)', () => {
+        const input = 'TOOL_CALLS{"type":"function","function":{"name":3,"parameters":{"q":"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: 'answer',
-                input: { answer: 'final answer' },
-            },
-        ]);
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: input }]);
+    });
+    (0, vitest_1.it)('returns text for non-array JSON', () => {
+        const input = '{"type":"function","function":{"name":"search","parameters":{}}}';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: input }]);
+    });
+    (0, vitest_1.it)('returns text for empty array', () => {
+        const input = '[]';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: '[]' }]);
+    });
+    (0, vitest_1.it)('returns text for malformed JSON array', () => {
+        const input = '[{"type":"function","function":{"name":"search","parameters":';
+        const result = (0, response_converter_js_1.convertResponse)(Buffer.from(input, 'utf8'));
+        (0, vitest_1.expect)(result).toEqual([{ type: 'text', text: input }]);
     });
 });

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

@@ -20,8 +20,15 @@ const WS_APP_VER = process.env.WS_APP_VER ?? '1.48.2';
 const WS_LS_VER = process.env.WS_LS_VER ?? '1.9544.35';
 const SENTRY_PUBLIC_KEY = 'b813f73488da69eedec534dba1029111';
 const CONNECT_USER_AGENT = 'connect-go/1.18.1 (go1.25.5)';
+const TOOL_FORMAT_INSTRUCTION = `When you need to call tools, you must format your response as a JSON array of tool calls following the OpenAI function calling format. Each tool call must be an object with "type" set to "function" and a "function" object containing "name" (string matching one of the provided tool names) and "parameters" (object with the tool's arguments). Output ONLY the JSON array, no surrounding text.
+
+Example format:
+[{"type": "function", "function": {"name": "tool_name", "parameters": {"arg1": "value1"}}}]
+
+For multiple tool calls:
+[{"type": "function", "function": {"name": "tool1", "parameters": {"arg1": "value1"}}}, {"type": "function", "function": {"name": "tool2", "parameters": {"arg2": "value2"}}}]`;
 class DevstralLanguageModel {
-    specificationVersion = 'v3';
+    specificationVersion = 'v2';
     provider = 'windsurf';
     modelId;
     supportedUrls = {};
@@ -58,16 +65,13 @@ class DevstralLanguageModel {
         const responseFrame = await this.transport.postUnary(`${this.baseURL}${API_SERVICE_PATH}${DEVSTRAL_STREAM_PATH}`, requestFrame, headers);
         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 content = payloads.flatMap((payload) => toV2Content((0, response_converter_js_1.convertResponse)(payload)));
         const unified = content.some((part) => part.type === 'tool-call')
             ? 'tool-calls'
             : 'stop';
         return {
             content,
-            finishReason: {
-                unified,
-                raw: undefined,
-            },
+            finishReason: unified,
             usage: emptyUsage(),
             warnings: [],
         };
@@ -125,7 +129,7 @@ class DevstralLanguageModel {
                                     break;
                                 }
                                 pending = frameResult.rest;
-                                const contentParts = toV3Content((0, response_converter_js_1.convertResponse)(frameResult.payload));
+                                const contentParts = toV2Content((0, response_converter_js_1.convertResponse)(frameResult.payload));
                                 for (const part of contentParts) {
                                     if (isAborted(options.abortSignal)) {
                                         safeClose(controller);
@@ -175,10 +179,7 @@ class DevstralLanguageModel {
                         const unified = hasToolCalls ? 'tool-calls' : 'stop';
                         safeEnqueue(controller, {
                             type: 'finish',
-                            finishReason: {
-                                unified,
-                                raw: undefined,
-                            },
+                            finishReason: unified,
                             usage: emptyUsage(),
                         });
                         safeClose(controller);
@@ -192,10 +193,7 @@ class DevstralLanguageModel {
                             });
                             safeEnqueue(controller, {
                                 type: 'finish',
-                                finishReason: {
-                                    unified: 'error',
-                                    raw: undefined,
-                                },
+                                finishReason: 'error',
                                 usage: emptyUsage(),
                             });
                         }
@@ -255,20 +253,12 @@ function isAborted(signal) {
 }
 function emptyUsage() {
     return {
-        inputTokens: {
-            total: undefined,
-            noCache: undefined,
-            cacheRead: undefined,
-            cacheWrite: undefined,
-        },
-        outputTokens: {
-            total: undefined,
-            text: undefined,
-            reasoning: undefined,
-        },
+        inputTokens: undefined,
+        outputTokens: undefined,
+        totalTokens: undefined,
     };
 }
-function toV3Content(parts) {
+function toV2Content(parts) {
     return parts.map((part) => {
         if (part.type !== 'tool-call') {
             return part;
@@ -288,10 +278,13 @@ function isFunctionTool(tool) {
 function buildGenerateRequest(input) {
     const request = new protobuf_js_1.ProtobufEncoder();
     request.writeMessage(1, buildMetadata(input.apiKey, input.jwt));
-    for (const message of input.messages) {
+    const functionTools = input.tools?.filter(isFunctionTool) ?? [];
+    const messages = functionTools.length > 0
+        ? [{ role: 5, content: TOOL_FORMAT_INSTRUCTION }, ...input.messages]
+        : input.messages;
+    for (const message of messages) {
         request.writeMessage(2, buildMessage(message));
     }
-    const functionTools = input.tools?.filter(isFunctionTool) ?? [];
     if (functionTools.length > 0) {
         const toolsArray = functionTools.map((tool) => ({
             type: 'function',