lynkr 1.0.0 → 2.0.0

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

@@ -0,0 +1,354 @@
+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

@@ -0,0 +1,281 @@
+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");
+    });
+  });
+});