@vybestack/llxprt-code-core 0.1.12 → 0.1.13

package/dist/src/tools/IToolFormatter.js

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2025 Vybestack LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=IToolFormatter.js.map

package/dist/src/tools/IToolFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IToolFormatter.js","sourceRoot":"","sources":["../../../src/tools/IToolFormatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/src/tools/ToolFormatter.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2025 Vybestack LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { IToolFormatter, ToolFormat, OpenAITool, ResponsesTool } from './IToolFormatter.js';
+import { ITool } from '../providers/ITool.js';
+import { IMessage } from '../providers/IMessage.js';
+export declare class ToolFormatter implements IToolFormatter {
+    /**
+     * Converts Gemini schema format (with uppercase Type enums) to standard JSON Schema format
+     */
+    private convertGeminiSchemaToStandard;
+    toProviderFormat(tools: ITool[], format: 'openai'): OpenAITool[];
+    toProviderFormat(tools: ITool[], format: ToolFormat): unknown;
+    fromProviderFormat(rawToolCall: unknown, format: ToolFormat): IMessage['tool_calls'];
+    /**
+     * Handles streaming tool call accumulation for OpenAI-compatible providers
+     * This accumulates partial tool calls from streaming responses
+     */
+    accumulateStreamingToolCall(deltaToolCall: {
+        index?: number;
+        id?: string;
+        type?: string;
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }, accumulatedToolCalls: NonNullable<IMessage['tool_calls']>, format: ToolFormat): void;
+    /**
+     * Formats tools specifically for the OpenAI Responses API
+     * The Responses API expects a flatter format than the regular OpenAI API
+     */
+    toResponsesTool(tools: ITool[]): ResponsesTool[];
+}

package/dist/src/tools/ToolFormatter.js

@@ -0,0 +1,216 @@
+/**
+ * Copyright 2025 Vybestack LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export class ToolFormatter {
+    /**
+     * Converts Gemini schema format (with uppercase Type enums) to standard JSON Schema format
+     */
+    convertGeminiSchemaToStandard(schema) {
+        if (!schema || typeof schema !== 'object') {
+            return schema;
+        }
+        const newSchema = { ...schema };
+        // Handle properties
+        if (newSchema.properties && typeof newSchema.properties === 'object') {
+            const newProperties = {};
+            for (const [key, value] of Object.entries(newSchema.properties)) {
+                newProperties[key] = this.convertGeminiSchemaToStandard(value);
+            }
+            newSchema.properties = newProperties;
+        }
+        // Handle items
+        if (newSchema.items) {
+            if (Array.isArray(newSchema.items)) {
+                newSchema.items = newSchema.items.map((item) => this.convertGeminiSchemaToStandard(item));
+            }
+            else {
+                newSchema.items = this.convertGeminiSchemaToStandard(newSchema.items);
+            }
+        }
+        // Convert type from UPPERCASE enum to lowercase string
+        if (newSchema.type) {
+            newSchema.type = String(newSchema.type).toLowerCase();
+        }
+        return newSchema;
+    }
+    toProviderFormat(tools, format) {
+        switch (format) {
+            case 'openai':
+            case 'deepseek': // DeepSeek uses same format as OpenAI for now
+            case 'qwen': // Qwen uses same format as OpenAI for now
+                return tools.map((tool) => ({
+                    type: 'function',
+                    function: {
+                        name: tool.function.name,
+                        description: tool.function.description,
+                        parameters: this.convertGeminiSchemaToStandard(tool.function.parameters),
+                    },
+                }));
+            case 'anthropic':
+                return tools.map((tool) => ({
+                    name: tool.function.name,
+                    description: tool.function.description || '',
+                    input_schema: {
+                        type: 'object',
+                        ...tool.function.parameters,
+                    },
+                }));
+            case 'hermes':
+                // Hermes uses text-based format, tools are provided as system prompt
+                // Return a text description of tools for the system prompt
+                return tools.map((tool) => ({
+                    name: tool.function.name,
+                    description: tool.function.description || '',
+                    parameters: tool.function.parameters,
+                }));
+            case 'xml':
+                // XML format also uses text-based format similar to Hermes
+                // Tools are typically described in the system prompt
+                return tools.map((tool) => ({
+                    name: tool.function.name,
+                    description: tool.function.description || '',
+                    parameters: tool.function.parameters,
+                }));
+            default:
+                throw new Error(`Tool format '${format}' not yet implemented`);
+        }
+    }
+    fromProviderFormat(rawToolCall, format) {
+        switch (format) {
+            case 'openai':
+            case 'deepseek':
+            case 'qwen': {
+                const openAiToolCall = rawToolCall;
+                if (!openAiToolCall ||
+                    !openAiToolCall.function ||
+                    !openAiToolCall.function.name ||
+                    !openAiToolCall.function.arguments) {
+                    throw new Error(`Invalid ${format} tool call format`);
+                }
+                return [
+                    {
+                        id: openAiToolCall.id,
+                        type: 'function',
+                        function: {
+                            name: openAiToolCall.function.name,
+                            arguments: openAiToolCall.function.arguments,
+                        },
+                    },
+                ];
+            }
+            case 'anthropic': {
+                const anthropicToolCall = rawToolCall;
+                if (!anthropicToolCall ||
+                    !anthropicToolCall.id ||
+                    !anthropicToolCall.name) {
+                    throw new Error(`Invalid ${format} tool call format`);
+                }
+                return [
+                    {
+                        id: anthropicToolCall.id,
+                        type: 'function',
+                        function: {
+                            name: anthropicToolCall.name,
+                            arguments: anthropicToolCall.input
+                                ? JSON.stringify(anthropicToolCall.input)
+                                : '',
+                        },
+                    },
+                ];
+            }
+            case 'hermes': {
+                // Hermes format comes from TextToolCallParser
+                const hermesToolCall = rawToolCall;
+                if (!hermesToolCall || !hermesToolCall.name) {
+                    throw new Error(`Invalid ${format} tool call format`);
+                }
+                return [
+                    {
+                        id: `hermes_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+                        type: 'function',
+                        function: {
+                            name: hermesToolCall.name,
+                            arguments: JSON.stringify(hermesToolCall.arguments || {}),
+                        },
+                    },
+                ];
+            }
+            case 'xml': {
+                // XML format also comes from TextToolCallParser
+                const xmlToolCall = rawToolCall;
+                if (!xmlToolCall || !xmlToolCall.name) {
+                    throw new Error(`Invalid ${format} tool call format`);
+                }
+                return [
+                    {
+                        id: `xml_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+                        type: 'function',
+                        function: {
+                            name: xmlToolCall.name,
+                            arguments: JSON.stringify(xmlToolCall.arguments || {}),
+                        },
+                    },
+                ];
+            }
+            default:
+                throw new Error(`Tool format '${format}' not yet implemented`);
+        }
+    }
+    /**
+     * Handles streaming tool call accumulation for OpenAI-compatible providers
+     * This accumulates partial tool calls from streaming responses
+     */
+    accumulateStreamingToolCall(deltaToolCall, accumulatedToolCalls, format) {
+        switch (format) {
+            case 'openai':
+            case 'deepseek':
+            case 'qwen':
+                // All use same accumulation logic for now
+                if (deltaToolCall.index !== undefined) {
+                    if (!accumulatedToolCalls[deltaToolCall.index]) {
+                        accumulatedToolCalls[deltaToolCall.index] = {
+                            id: deltaToolCall.id || '',
+                            type: 'function',
+                            function: { name: '', arguments: '' },
+                        };
+                    }
+                    const tc = accumulatedToolCalls[deltaToolCall.index];
+                    if (deltaToolCall.id)
+                        tc.id = deltaToolCall.id;
+                    if (deltaToolCall.function?.name)
+                        tc.function.name = deltaToolCall.function.name;
+                    if (deltaToolCall.function?.arguments)
+                        tc.function.arguments += deltaToolCall.function.arguments;
+                }
+                break;
+            default:
+                throw new Error(`Streaming accumulation for format '${format}' not yet implemented`);
+        }
+    }
+    /**
+     * Formats tools specifically for the OpenAI Responses API
+     * The Responses API expects a flatter format than the regular OpenAI API
+     */
+    toResponsesTool(tools) {
+        return tools.map((tool) => ({
+            type: 'function',
+            name: tool.function.name,
+            description: tool.function.description || null,
+            parameters: this.convertGeminiSchemaToStandard(tool.function.parameters) || null,
+            strict: null,
+        }));
+    }
+}
+//# sourceMappingURL=ToolFormatter.js.map

package/dist/src/tools/ToolFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolFormatter.js","sourceRoot":"","sources":["../../../src/tools/ToolFormatter.ts"],"names":[],"mappings":"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"}

package/dist/src/tools/ToolFormatter.test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2025 Vybestack LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/dist/src/tools/ToolFormatter.test.js

@@ -0,0 +1,349 @@
+/**
+ * Copyright 2025 Vybestack LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ToolFormatter } from './ToolFormatter.js';
+describe('ToolFormatter', () => {
+    let formatter;
+    beforeEach(() => {
+        formatter = new ToolFormatter();
+    });
+    it('should correctly format tools for OpenAI provider', () => {
+        const tools = [
+            {
+                type: 'function',
+                function: {
+                    name: 'sum',
+                    description: 'Add two numbers',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            a: { type: 'number' },
+                            b: { type: 'number' },
+                        },
+                        required: ['a', 'b'],
+                    },
+                },
+            },
+        ];
+        const expected = [
+            {
+                type: 'function',
+                function: {
+                    name: 'sum',
+                    description: 'Add two numbers',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            a: { type: 'number' },
+                            b: { type: 'number' },
+                        },
+                        required: ['a', 'b'],
+                    },
+                },
+            },
+        ];
+        expect(formatter.toProviderFormat(tools, 'openai')).toEqual(expected);
+    });
+    it('should throw an error for invalid OpenAI tool call format', () => {
+        const rawToolCall = {};
+        expect(() => formatter.fromProviderFormat(rawToolCall, 'openai')).toThrow('Invalid openai tool call format');
+    });
+    it('should correctly parse OpenAI tool calls from provider format', () => {
+        const rawToolCall = {
+            id: 'call_123',
+            function: {
+                name: 'sum',
+                arguments: '{"a": 5, "b": 3}',
+            },
+        };
+        const expected = [
+            {
+                id: 'call_123',
+                type: 'function',
+                function: {
+                    name: 'sum',
+                    arguments: '{"a": 5, "b": 3}',
+                },
+            },
+        ];
+        expect(formatter.fromProviderFormat(rawToolCall, 'openai')).toEqual(expected);
+    });
+    it('should correctly format tools for Anthropic provider', () => {
+        const tools = [
+            {
+                type: 'function',
+                function: {
+                    name: 'search',
+                    description: 'Search for information',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string', description: 'Search query' },
+                            limit: { type: 'number', description: 'Max results' },
+                        },
+                        required: ['query'],
+                    },
+                },
+            },
+        ];
+        const expected = [
+            {
+                name: 'search',
+                description: 'Search for information',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Search query' },
+                        limit: { type: 'number', description: 'Max results' },
+                    },
+                    required: ['query'],
+                },
+            },
+        ];
+        expect(formatter.toProviderFormat(tools, 'anthropic')).toEqual(expected);
+    });
+    it('should handle empty description for Anthropic provider', () => {
+        const tools = [
+            {
+                type: 'function',
+                function: {
+                    name: 'calculate',
+                    parameters: {
+                        type: 'object',
+                        properties: { x: { type: 'number' } },
+                    },
+                },
+            },
+        ];
+        const result = formatter.toProviderFormat(tools, 'anthropic');
+        expect(result[0].description).toBe('');
+    });
+    it('should not throw for implemented formats in toProviderFormat', () => {
+        const tools = [
+            {
+                type: 'function',
+                function: {
+                    name: 'test',
+                    description: 'Test function',
+                    parameters: {},
+                },
+            },
+        ];
+        // All these formats are now implemented and should not throw
+        expect(() => formatter.toProviderFormat(tools, 'openai')).not.toThrow();
+        expect(() => formatter.toProviderFormat(tools, 'anthropic')).not.toThrow();
+        expect(() => formatter.toProviderFormat(tools, 'hermes')).not.toThrow();
+        expect(() => formatter.toProviderFormat(tools, 'xml')).not.toThrow();
+        expect(() => formatter.toProviderFormat(tools, 'deepseek')).not.toThrow();
+        expect(() => formatter.toProviderFormat(tools, 'qwen')).not.toThrow();
+    });
+    it('should correctly format tools for Hermes provider', () => {
+        const tools = [
+            {
+                type: 'function',
+                function: {
+                    name: 'get_stock_fundamentals',
+                    description: 'Get fundamental data for a stock',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            symbol: { type: 'string', description: 'Stock symbol' },
+                        },
+                        required: ['symbol'],
+                    },
+                },
+            },
+        ];
+        const expected = [
+            {
+                name: 'get_stock_fundamentals',
+                description: 'Get fundamental data for a stock',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        symbol: { type: 'string', description: 'Stock symbol' },
+                    },
+                    required: ['symbol'],
+                },
+            },
+        ];
+        expect(formatter.toProviderFormat(tools, 'hermes')).toEqual(expected);
+    });
+    it('should correctly parse Anthropic tool calls from provider format', () => {
+        const rawToolCall = {
+            id: 'toolu_01abc123',
+            type: 'tool_use',
+            name: 'search',
+            input: { query: 'test search', limit: 10 },
+        };
+        const expected = [
+            {
+                id: 'toolu_01abc123',
+                type: 'function',
+                function: {
+                    name: 'search',
+                    arguments: '{"query":"test search","limit":10}',
+                },
+            },
+        ];
+        expect(formatter.fromProviderFormat(rawToolCall, 'anthropic')).toEqual(expected);
+    });
+    it('should handle Anthropic tool calls without input', () => {
+        const rawToolCall = {
+            id: 'toolu_01xyz789',
+            name: 'get_time',
+        };
+        const expected = [
+            {
+                id: 'toolu_01xyz789',
+                type: 'function',
+                function: {
+                    name: 'get_time',
+                    arguments: '',
+                },
+            },
+        ];
+        expect(formatter.fromProviderFormat(rawToolCall, 'anthropic')).toEqual(expected);
+    });
+    it('should throw an error for invalid Anthropic tool call format', () => {
+        const invalidCalls = [
+            {},
+            { id: 'test' }, // missing name
+            { name: 'test' }, // missing id
+            null,
+        ];
+        invalidCalls.forEach((rawToolCall) => {
+            expect(() => formatter.fromProviderFormat(rawToolCall, 'anthropic')).toThrow('Invalid anthropic tool call format');
+        });
+    });
+    it('should correctly parse Hermes tool calls from provider format', () => {
+        const rawToolCall = {
+            name: 'get_stock_fundamentals',
+            arguments: { symbol: 'AAPL' },
+        };
+        const result = formatter.fromProviderFormat(rawToolCall, 'hermes');
+        expect(result).toHaveLength(1);
+        expect(result[0].type).toBe('function');
+        expect(result[0].function.name).toBe('get_stock_fundamentals');
+        expect(result[0].function.arguments).toBe('{"symbol":"AAPL"}');
+        expect(result[0].id).toMatch(/^hermes_/); // Should have generated ID
+    });
+    it('should handle Hermes tool calls without arguments', () => {
+        const rawToolCall = {
+            name: 'get_current_time',
+            arguments: {},
+        };
+        const result = formatter.fromProviderFormat(rawToolCall, 'hermes');
+        expect(result).toHaveLength(1);
+        expect(result[0].function.name).toBe('get_current_time');
+        expect(result[0].function.arguments).toBe('{}');
+    });
+    it('should throw error for invalid Hermes tool call format', () => {
+        const invalidCalls = [
+            {},
+            { arguments: {} }, // missing name
+            null,
+        ];
+        invalidCalls.forEach((rawToolCall) => {
+            expect(() => formatter.fromProviderFormat(rawToolCall, 'hermes')).toThrow('Invalid hermes tool call format');
+        });
+    });
+    it('should correctly format tools for XML provider', () => {
+        const tools = [
+            {
+                type: 'function',
+                function: {
+                    name: 'weather_tool',
+                    description: 'Get weather information',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            location: { type: 'string', description: 'City name' },
+                            units: { type: 'string', enum: ['celsius', 'fahrenheit'] },
+                        },
+                        required: ['location'],
+                    },
+                },
+            },
+        ];
+        const expected = [
+            {
+                name: 'weather_tool',
+                description: 'Get weather information',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        location: { type: 'string', description: 'City name' },
+                        units: { type: 'string', enum: ['celsius', 'fahrenheit'] },
+                    },
+                    required: ['location'],
+                },
+            },
+        ];
+        expect(formatter.toProviderFormat(tools, 'xml')).toEqual(expected);
+    });
+    it('should correctly parse XML tool calls from provider format', () => {
+        const rawToolCall = {
+            name: 'weather_tool',
+            arguments: { location: 'Paris', units: 'celsius' },
+        };
+        const result = formatter.fromProviderFormat(rawToolCall, 'xml');
+        expect(result).toHaveLength(1);
+        expect(result[0].type).toBe('function');
+        expect(result[0].function.name).toBe('weather_tool');
+        expect(result[0].function.arguments).toBe('{"location":"Paris","units":"celsius"}');
+        expect(result[0].id).toMatch(/^xml_/); // Should have generated ID
+    });
+    it('should handle XML tool calls without arguments', () => {
+        const rawToolCall = {
+            name: 'get_time',
+            arguments: {},
+        };
+        const result = formatter.fromProviderFormat(rawToolCall, 'xml');
+        expect(result).toHaveLength(1);
+        expect(result[0].function.name).toBe('get_time');
+        expect(result[0].function.arguments).toBe('{}');
+    });
+    it('should throw error for invalid XML tool call format', () => {
+        const invalidCalls = [
+            {},
+            { arguments: {} }, // missing name
+            null,
+        ];
+        invalidCalls.forEach((rawToolCall) => {
+            expect(() => formatter.fromProviderFormat(rawToolCall, 'xml')).toThrow('Invalid xml tool call format');
+        });
+    });
+    it('should format tools correctly for DeepSeek and Qwen providers', () => {
+        const tools = [
+            {
+                type: 'function',
+                function: {
+                    name: 'test_function',
+                    description: 'A test function',
+                    parameters: { type: 'object', properties: {} },
+                },
+            },
+        ];
+        // DeepSeek and Qwen use the same format as OpenAI
+        const deepseekResult = formatter.toProviderFormat(tools, 'deepseek');
+        const qwenResult = formatter.toProviderFormat(tools, 'qwen');
+        const openaiResult = formatter.toProviderFormat(tools, 'openai');
+        expect(deepseekResult).toEqual(openaiResult);
+        expect(qwenResult).toEqual(openaiResult);
+    });
+});
+//# sourceMappingURL=ToolFormatter.test.js.map