lynkr 7.2.5 → 8.0.1

package/test/azure-openai-format-conversion.test.js

@@ -1,354 +0,0 @@
-const assert = require("assert");
-const { describe, it, beforeEach } = require("node:test");
-
-describe("Azure OpenAI Format Conversion", () => {
-  let openrouterUtils;
-
-  beforeEach(() => {
-    // Set MODEL_PROVIDER to avoid validation errors
-    process.env.MODEL_PROVIDER = "databricks";
-    process.env.DATABRICKS_API_KEY = "test-key";
-    process.env.DATABRICKS_API_BASE = "http://test.com";
-
-    // Clear module cache
-    delete require.cache[require.resolve("../src/clients/openrouter-utils")];
-    delete require.cache[require.resolve("../src/config")];
-    openrouterUtils = require("../src/clients/openrouter-utils");
-  });
-
-  describe("Anthropic to Azure OpenAI (OpenAI format) Conversion", () => {
-    it("should convert simple Anthropic messages to OpenAI format", () => {
-      const anthropicMessages = [
-        {
-          role: "user",
-          content: "Hello, Azure OpenAI!"
-        }
-      ];
-
-      const result = openrouterUtils.convertAnthropicMessagesToOpenRouter(anthropicMessages);
-
-      assert.strictEqual(result.length, 1);
-      assert.strictEqual(result[0].role, "user");
-      assert.strictEqual(result[0].content, "Hello, Azure OpenAI!");
-    });
-
-    it("should convert Anthropic content blocks to OpenAI text content", () => {
-      const anthropicMessages = [
-        {
-          role: "user",
-          content: [
-            { type: "text", text: "Analyze this code" },
-            { type: "text", text: "and provide feedback" }
-          ]
-        }
-      ];
-
-      const result = openrouterUtils.convertAnthropicMessagesToOpenRouter(anthropicMessages);
-
-      assert.strictEqual(result.length, 1);
-      assert.strictEqual(result[0].content, "Analyze this code\nand provide feedback");
-    });
-
-    it("should convert Anthropic tool_use to OpenAI tool_calls", () => {
-      const anthropicMessages = [
-        {
-          role: "assistant",
-          content: [
-            { type: "text", text: "I'll read that file" },
-            {
-              type: "tool_use",
-              id: "toolu_abc123",
-              name: "Read",
-              input: { file_path: "/app/test.js" }
-            }
-          ]
-        }
-      ];
-
-      const result = openrouterUtils.convertAnthropicMessagesToOpenRouter(anthropicMessages);
-
-      assert.strictEqual(result.length, 1);
-      assert.strictEqual(result[0].role, "assistant");
-      assert.strictEqual(result[0].content, "I'll read that file");
-      assert.ok(Array.isArray(result[0].tool_calls));
-      assert.strictEqual(result[0].tool_calls.length, 1);
-      assert.strictEqual(result[0].tool_calls[0].id, "toolu_abc123");
-      assert.strictEqual(result[0].tool_calls[0].type, "function");
-      assert.strictEqual(result[0].tool_calls[0].function.name, "Read");
-      assert.strictEqual(result[0].tool_calls[0].function.arguments, '{"file_path":"/app/test.js"}');
-    });
-
-    it("should convert Anthropic tool definitions to OpenAI tools format", () => {
-      const anthropicTools = [
-        {
-          name: "Write",
-          description: "Write content to a file",
-          input_schema: {
-            type: "object",
-            properties: {
-              file_path: { type: "string" },
-              content: { type: "string" }
-            },
-            required: ["file_path", "content"]
-          }
-        }
-      ];
-
-      const result = openrouterUtils.convertAnthropicToolsToOpenRouter(anthropicTools);
-
-      assert.strictEqual(result.length, 1);
-      assert.strictEqual(result[0].type, "function");
-      assert.strictEqual(result[0].function.name, "Write");
-      assert.strictEqual(result[0].function.description, "Write content to a file");
-      assert.deepStrictEqual(result[0].function.parameters, anthropicTools[0].input_schema);
-    });
-
-    it("should handle multiple tool conversions", () => {
-      const anthropicTools = [
-        {
-          name: "Read",
-          description: "Read file",
-          input_schema: {
-            type: "object",
-            properties: { file_path: { type: "string" } }
-          }
-        },
-        {
-          name: "Write",
-          description: "Write file",
-          input_schema: {
-            type: "object",
-            properties: { file_path: { type: "string" }, content: { type: "string" } }
-          }
-        }
-      ];
-
-      const result = openrouterUtils.convertAnthropicToolsToOpenRouter(anthropicTools);
-
-      assert.strictEqual(result.length, 2);
-      assert.strictEqual(result[0].function.name, "Read");
-      assert.strictEqual(result[1].function.name, "Write");
-    });
-  });
-
-  describe("Azure OpenAI to Anthropic Conversion", () => {
-    it("should convert OpenAI text response to Anthropic format", () => {
-      const azureOpenAIResponse = {
-        choices: [
-          {
-            message: {
-              role: "assistant",
-              content: "Hello from Azure OpenAI!"
-            },
-            finish_reason: "stop"
-          }
-        ],
-        usage: {
-          prompt_tokens: 10,
-          completion_tokens: 5,
-          total_tokens: 15
-        }
-      };
-
-      const result = openrouterUtils.convertOpenRouterResponseToAnthropic(
-        azureOpenAIResponse,
-        "gpt-4o"
-      );
-
-      assert.strictEqual(result.role, "assistant");
-      assert.ok(Array.isArray(result.content));
-      assert.strictEqual(result.content.length, 1);
-      assert.strictEqual(result.content[0].type, "text");
-      assert.strictEqual(result.content[0].text, "Hello from Azure OpenAI!");
-      assert.strictEqual(result.stop_reason, "end_turn");
-      assert.strictEqual(result.usage.input_tokens, 10);
-      assert.strictEqual(result.usage.output_tokens, 5);
-    });
-
-    it("should convert OpenAI tool_calls to Anthropic tool_use", () => {
-      const azureOpenAIResponse = {
-        choices: [
-          {
-            message: {
-              role: "assistant",
-              content: "I'll execute that bash command",
-              tool_calls: [
-                {
-                  id: "call_xyz789",
-                  type: "function",
-                  function: {
-                    name: "Bash",
-                    arguments: '{"command": "ls -la"}'
-                  }
-                }
-              ]
-            },
-            finish_reason: "tool_calls"
-          }
-        ],
-        usage: {
-          prompt_tokens: 20,
-          completion_tokens: 10
-        }
-      };
-
-      const result = openrouterUtils.convertOpenRouterResponseToAnthropic(
-        azureOpenAIResponse,
-        "gpt-4o"
-      );
-
-      assert.strictEqual(result.role, "assistant");
-      assert.ok(Array.isArray(result.content));
-      assert.strictEqual(result.content.length, 2);
-
-      // Text content
-      assert.strictEqual(result.content[0].type, "text");
-      assert.strictEqual(result.content[0].text, "I'll execute that bash command");
-
-      // Tool use
-      assert.strictEqual(result.content[1].type, "tool_use");
-      assert.strictEqual(result.content[1].id, "call_xyz789");
-      assert.strictEqual(result.content[1].name, "Bash");
-      assert.deepStrictEqual(result.content[1].input, { command: "ls -la" });
-
-      assert.strictEqual(result.stop_reason, "tool_use");
-    });
-
-    it("should handle multiple tool calls", () => {
-      const azureOpenAIResponse = {
-        choices: [
-          {
-            message: {
-              role: "assistant",
-              content: null,
-              tool_calls: [
-                {
-                  id: "call_1",
-                  type: "function",
-                  function: {
-                    name: "Read",
-                    arguments: '{"file_path": "/app/file1.js"}'
-                  }
-                },
-                {
-                  id: "call_2",
-                  type: "function",
-                  function: {
-                    name: "Read",
-                    arguments: '{"file_path": "/app/file2.js"}'
-                  }
-                }
-              ]
-            },
-            finish_reason: "tool_calls"
-          }
-        ]
-      };
-
-      const result = openrouterUtils.convertOpenRouterResponseToAnthropic(
-        azureOpenAIResponse,
-        "gpt-4o"
-      );
-
-      assert.strictEqual(result.content.length, 2);
-      assert.strictEqual(result.content[0].type, "tool_use");
-      assert.strictEqual(result.content[0].name, "Read");
-      assert.strictEqual(result.content[1].type, "tool_use");
-      assert.strictEqual(result.content[1].name, "Read");
-    });
-
-    it("should handle empty/null content gracefully", () => {
-      const azureOpenAIResponse = {
-        choices: [
-          {
-            message: {
-              role: "assistant",
-              content: null
-            },
-            finish_reason: "stop"
-          }
-        ]
-      };
-
-      const result = openrouterUtils.convertOpenRouterResponseToAnthropic(
-        azureOpenAIResponse,
-        "gpt-4o"
-      );
-
-      assert.strictEqual(result.role, "assistant");
-      assert.ok(Array.isArray(result.content));
-      // OpenRouter utils creates an empty text block for null content
-      assert.strictEqual(result.content.length, 1);
-      assert.strictEqual(result.content[0].type, "text");
-      assert.strictEqual(result.content[0].text, "");
-    });
-
-    it("should convert finish_reason correctly", () => {
-      const stopResponse = {
-        choices: [{ message: { role: "assistant", content: "Done" }, finish_reason: "stop" }]
-      };
-      const toolCallsResponse = {
-        choices: [{
-          message: { role: "assistant", content: null, tool_calls: [{ id: "1", type: "function", function: { name: "Test", arguments: "{}" } }] },
-          finish_reason: "tool_calls"
-        }]
-      };
-      const lengthResponse = {
-        choices: [{ message: { role: "assistant", content: "Text" }, finish_reason: "length" }]
-      };
-
-      const stopResult = openrouterUtils.convertOpenRouterResponseToAnthropic(stopResponse, "gpt-4o");
-      const toolCallsResult = openrouterUtils.convertOpenRouterResponseToAnthropic(toolCallsResponse, "gpt-4o");
-      const lengthResult = openrouterUtils.convertOpenRouterResponseToAnthropic(lengthResponse, "gpt-4o");
-
-      assert.strictEqual(stopResult.stop_reason, "end_turn");
-      assert.strictEqual(toolCallsResult.stop_reason, "tool_use");
-      assert.strictEqual(lengthResult.stop_reason, "max_tokens");
-    });
-  });
-
-  describe("Round-Trip Integrity", () => {
-    it("should maintain data integrity through Anthropic -> OpenAI -> Anthropic conversion", () => {
-      // Original Anthropic format
-      const originalTools = [
-        {
-          name: "Bash",
-          description: "Execute bash command",
-          input_schema: {
-            type: "object",
-            properties: {
-              command: { type: "string", description: "The command to execute" }
-            },
-            required: ["command"]
-          }
-        }
-      ];
-
-      // Convert to OpenAI format
-      const openAITools = openrouterUtils.convertAnthropicToolsToOpenRouter(originalTools);
-
-      // Verify OpenAI format structure
-      assert.strictEqual(openAITools[0].type, "function");
-      assert.strictEqual(openAITools[0].function.name, "Bash");
-      assert.strictEqual(openAITools[0].function.description, "Execute bash command");
-
-      // Verify schema is preserved
-      assert.deepStrictEqual(openAITools[0].function.parameters, originalTools[0].input_schema);
-    });
-
-    it("should handle text-only conversation round-trip", () => {
-      const anthropicMessages = [
-        { role: "user", content: "Hello" },
-        { role: "assistant", content: [{ type: "text", text: "Hi there!" }] },
-        { role: "user", content: "How are you?" }
-      ];
-
-      const openAIMessages = openrouterUtils.convertAnthropicMessagesToOpenRouter(anthropicMessages);
-
-      assert.strictEqual(openAIMessages.length, 3);
-      assert.strictEqual(openAIMessages[0].content, "Hello");
-      assert.strictEqual(openAIMessages[1].content, "Hi there!");
-      assert.strictEqual(openAIMessages[2].content, "How are you?");
-    });
-  });
-});

package/test/azure-openai-integration.test.js

@@ -1,281 +0,0 @@
-const assert = require("assert");
-const { describe, it, beforeEach, afterEach } = require("node:test");
-
-describe("Azure OpenAI Integration Tests", () => {
-  let originalConfig;
-
-  beforeEach(() => {
-    // Clear module cache
-    delete require.cache[require.resolve("../src/config")];
-    delete require.cache[require.resolve("../src/clients/databricks")];
-    delete require.cache[require.resolve("../src/observability/metrics")];
-
-    // Store original config
-    originalConfig = { ...process.env };
-
-    // Set default provider to avoid validation errors
-    process.env.MODEL_PROVIDER = "databricks";
-    process.env.DATABRICKS_API_KEY = "test-key";
-    process.env.DATABRICKS_API_BASE = "http://test.com";
-  });
-
-  afterEach(() => {
-    // Restore original environment
-    process.env = originalConfig;
-  });
-
-  describe("End-to-End Request Flow", () => {
-    it("should construct valid Azure OpenAI request URL", () => {
-      process.env.AZURE_OPENAI_ENDPOINT = "https://test-resource.openai.azure.com";
-      process.env.AZURE_OPENAI_DEPLOYMENT = "gpt-4o";
-      process.env.AZURE_OPENAI_API_VERSION = "2024-08-01-preview";
-
-      const config = require("../src/config");
-
-      const expectedURL = `${config.azureOpenAI.endpoint}/openai/deployments/${config.azureOpenAI.deployment}/chat/completions?api-version=${config.azureOpenAI.apiVersion}`;
-
-      assert.strictEqual(
-        expectedURL,
-        "https://test-resource.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2024-08-01-preview"
-      );
-    });
-
-    it("should construct valid request headers with api-key", () => {
-      process.env.AZURE_OPENAI_API_KEY = "test-api-key-12345";
-
-      const config = require("../src/config");
-
-      const headers = {
-        "api-key": config.azureOpenAI.apiKey,
-        "Content-Type": "application/json"
-      };
-
-      assert.strictEqual(headers["api-key"], "test-api-key-12345");
-      assert.strictEqual(headers["Content-Type"], "application/json");
-    });
-
-    it("should construct request body with messages and tools", () => {
-      const { convertAnthropicMessagesToOpenRouter, convertAnthropicToolsToOpenRouter } = require("../src/clients/openrouter-utils");
-
-      const anthropicMessages = [
-        { role: "user", content: "Read /app/test.js" }
-      ];
-
-      const anthropicTools = [
-        {
-          name: "Read",
-          description: "Read file",
-          input_schema: {
-            type: "object",
-            properties: { file_path: { type: "string" } },
-            required: ["file_path"]
-          }
-        }
-      ];
-
-      const messages = convertAnthropicMessagesToOpenRouter(anthropicMessages);
-      const tools = convertAnthropicToolsToOpenRouter(anthropicTools);
-
-      const requestBody = {
-        messages,
-        tools,
-        temperature: 0.7,
-        max_tokens: 4096,
-        stream: false
-      };
-
-      assert.ok(Array.isArray(requestBody.messages));
-      assert.strictEqual(requestBody.messages[0].content, "Read /app/test.js");
-      assert.ok(Array.isArray(requestBody.tools));
-      assert.strictEqual(requestBody.tools[0].function.name, "Read");
-    });
-  });
-
-  describe("Tool Calling Round Trip", () => {
-    it("should handle complete tool calling flow", () => {
-      const { convertAnthropicToolsToOpenRouter, convertOpenRouterResponseToAnthropic } = require("../src/clients/openrouter-utils");
-
-      // Step 1: Convert Anthropic tools to Azure OpenAI format
-      const anthropicTools = [
-        {
-          name: "Bash",
-          description: "Execute bash command",
-          input_schema: {
-            type: "object",
-            properties: { command: { type: "string" } },
-            required: ["command"]
-          }
-        }
-      ];
-
-      const azureTools = convertAnthropicToolsToOpenRouter(anthropicTools);
-
-      assert.strictEqual(azureTools[0].type, "function");
-      assert.strictEqual(azureTools[0].function.name, "Bash");
-
-      // Step 2: Simulate Azure OpenAI response with tool call
-      const azureResponse = {
-        choices: [
-          {
-            message: {
-              role: "assistant",
-              content: "I'll run that command",
-              tool_calls: [
-                {
-                  id: "call_123",
-                  type: "function",
-                  function: {
-                    name: "Bash",
-                    arguments: '{"command":"ls -la"}'
-                  }
-                }
-              ]
-            },
-            finish_reason: "tool_calls"
-          }
-        ],
-        usage: {
-          prompt_tokens: 50,
-          completion_tokens: 20
-        }
-      };
-
-      // Step 3: Convert Azure OpenAI response to Anthropic format
-      const anthropicResponse = convertOpenRouterResponseToAnthropic(azureResponse, "gpt-4o");
-
-      assert.strictEqual(anthropicResponse.role, "assistant");
-      assert.strictEqual(anthropicResponse.stop_reason, "tool_use");
-
-      const textContent = anthropicResponse.content.find(c => c.type === "text");
-      const toolUse = anthropicResponse.content.find(c => c.type === "tool_use");
-
-      assert.strictEqual(textContent.text, "I'll run that command");
-      assert.strictEqual(toolUse.name, "Bash");
-      assert.deepStrictEqual(toolUse.input, { command: "ls -la" });
-    });
-  });
-
-  describe("Provider Selection Integration", () => {
-    it("should select azure-openai as primary provider", () => {
-      process.env.MODEL_PROVIDER = "azure-openai";
-      process.env.AZURE_OPENAI_ENDPOINT = "https://test.openai.azure.com";
-      process.env.AZURE_OPENAI_API_KEY = "test-key";
-
-      const config = require("../src/config");
-
-      assert.strictEqual(config.modelProvider.type, "azure-openai");
-      assert.strictEqual(config.azureOpenAI.endpoint, "https://test.openai.azure.com");
-      assert.strictEqual(config.azureOpenAI.apiKey, "test-key");
-    });
-
-    it("should select azure-openai as fallback provider", () => {
-      process.env.PREFER_OLLAMA = "true";
-      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
-      process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.FALLBACK_ENABLED = "true";
-      process.env.FALLBACK_PROVIDER = "azure-openai";
-      process.env.AZURE_OPENAI_ENDPOINT = "https://test.openai.azure.com";
-      process.env.AZURE_OPENAI_API_KEY = "test-key";
-      process.env.DATABRICKS_API_KEY = "test-key";
-      process.env.DATABRICKS_API_BASE = "http://test.com";
-
-      const config = require("../src/config");
-
-      assert.strictEqual(config.modelProvider.fallbackProvider, "azure-openai");
-      assert.strictEqual(config.modelProvider.fallbackEnabled, true);
-    });
-  });
-
-  describe("Response Conversion Integration", () => {
-    it("should handle text-only response conversion", () => {
-      const { convertOpenRouterResponseToAnthropic } = require("../src/clients/openrouter-utils");
-
-      const azureResponse = {
-        id: "chatcmpl-abc123",
-        object: "chat.completion",
-        created: 1677652288,
-        model: "gpt-4o",
-        choices: [
-          {
-            index: 0,
-            message: {
-              role: "assistant",
-              content: "The file contains JavaScript code for a web server."
-            },
-            finish_reason: "stop"
-          }
-        ],
-        usage: {
-          prompt_tokens: 100,
-          completion_tokens: 50,
-          total_tokens: 150
-        }
-      };
-
-      const anthropicResponse = convertOpenRouterResponseToAnthropic(azureResponse, "gpt-4o");
-
-      assert.strictEqual(anthropicResponse.role, "assistant");
-      assert.strictEqual(anthropicResponse.stop_reason, "end_turn");
-      assert.strictEqual(anthropicResponse.model, "gpt-4o");
-      assert.strictEqual(anthropicResponse.usage.input_tokens, 100);
-      assert.strictEqual(anthropicResponse.usage.output_tokens, 50);
-      assert.strictEqual(anthropicResponse.content[0].type, "text");
-      assert.strictEqual(anthropicResponse.content[0].text, "The file contains JavaScript code for a web server.");
-    });
-
-    it("should handle multi-turn conversation", () => {
-      const { convertAnthropicMessagesToOpenRouter } = require("../src/clients/openrouter-utils");
-
-      const anthropicMessages = [
-        { role: "user", content: "What is 2+2?" },
-        { role: "assistant", content: [{ type: "text", text: "2+2 equals 4." }] },
-        { role: "user", content: "What about 3+3?" }
-      ];
-
-      const azureMessages = convertAnthropicMessagesToOpenRouter(anthropicMessages);
-
-      assert.strictEqual(azureMessages.length, 3);
-      assert.strictEqual(azureMessages[0].role, "user");
-      assert.strictEqual(azureMessages[0].content, "What is 2+2?");
-      assert.strictEqual(azureMessages[1].role, "assistant");
-      assert.strictEqual(azureMessages[1].content, "2+2 equals 4.");
-      assert.strictEqual(azureMessages[2].role, "user");
-      assert.strictEqual(azureMessages[2].content, "What about 3+3?");
-    });
-  });
-
-  describe("Multiple Deployments Support", () => {
-    it("should support gpt-4o deployment", () => {
-      process.env.AZURE_OPENAI_DEPLOYMENT = "gpt-4o";
-      process.env.MODEL_PROVIDER = "databricks";
-      process.env.DATABRICKS_API_KEY = "test-key";
-      process.env.DATABRICKS_API_BASE = "http://test.com";
-
-      const config = require("../src/config");
-
-      assert.strictEqual(config.azureOpenAI.deployment, "gpt-4o");
-    });
-
-    it("should support gpt-5 deployment", () => {
-      process.env.AZURE_OPENAI_DEPLOYMENT = "gpt-5";
-      process.env.MODEL_PROVIDER = "databricks";
-      process.env.DATABRICKS_API_KEY = "test-key";
-      process.env.DATABRICKS_API_BASE = "http://test.com";
-
-      const config = require("../src/config");
-
-      assert.strictEqual(config.azureOpenAI.deployment, "gpt-5");
-    });
-
-    it("should support custom deployment names", () => {
-      process.env.AZURE_OPENAI_DEPLOYMENT = "my-custom-gpt-5-codex";
-      process.env.MODEL_PROVIDER = "databricks";
-      process.env.DATABRICKS_API_KEY = "test-key";
-      process.env.DATABRICKS_API_BASE = "http://test.com";
-
-      const config = require("../src/config");
-
-      assert.strictEqual(config.azureOpenAI.deployment, "my-custom-gpt-5-codex");
-    });
-  });
-});