lynkr 1.0.0 → 2.0.0

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

@@ -0,0 +1,148 @@
+const assert = require("assert");
+const { describe, it, beforeEach, afterEach } = require("node:test");
+
+describe("Azure OpenAI Routing Tests", () => {
+  let routing;
+  let originalConfig;
+
+  beforeEach(() => {
+    // Clear module cache
+    delete require.cache[require.resolve("../src/config")];
+    delete require.cache[require.resolve("../src/clients/routing")];
+
+    // Store original config
+    originalConfig = { ...process.env };
+
+    // Clean OpenRouter config from previous tests
+    delete process.env.OPENROUTER_API_KEY;
+
+    // Base config for routing tests
+    process.env.MODEL_PROVIDER = "databricks"; // Set default to avoid validation errors
+    process.env.DATABRICKS_API_KEY = "test-key";
+    process.env.DATABRICKS_API_BASE = "http://test.com";
+  });
+
+  afterEach(() => {
+    // Restore original environment
+    process.env = originalConfig;
+  });
+
+  describe("Primary Provider Routing", () => {
+    it("should route to azure-openai when set as MODEL_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";
+      process.env.PREFER_OLLAMA = "false";
+
+      routing = require("../src/clients/routing");
+
+      const provider = routing.determineProvider({ tools: [] });
+
+      assert.strictEqual(provider, "azure-openai");
+    });
+  });
+
+  describe("Hybrid Routing with Azure OpenAI", () => {
+    it("should route moderate tool requests to azure-openai when available", () => {
+      // Explicitly unset OpenRouter to ensure it's not available
+      // Set to empty string instead of delete to prevent dotenv from reloading it
+      process.env.OPENROUTER_API_KEY = "";
+
+      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.OLLAMA_MAX_TOOLS_FOR_ROUTING = "3";
+      process.env.OPENROUTER_MAX_TOOLS_FOR_ROUTING = "15";
+      process.env.AZURE_OPENAI_ENDPOINT = "https://test.openai.azure.com";
+      process.env.AZURE_OPENAI_API_KEY = "test-key";
+
+      // Clear cache after env setup
+      delete require.cache[require.resolve("../src/config")];
+      delete require.cache[require.resolve("../src/clients/routing")];
+
+      routing = require("../src/clients/routing");
+
+      // 5 tools: more than Ollama threshold (3), less than OpenRouter threshold (15)
+      const provider = routing.determineProvider({
+        tools: [{}, {}, {}, {}, {}]
+      });
+
+      assert.strictEqual(provider, "azure-openai");
+    });
+
+    it("should prefer OpenRouter over Azure OpenAI when both configured", () => {
+      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.OLLAMA_MAX_TOOLS_FOR_ROUTING = "3";
+      process.env.OPENROUTER_MAX_TOOLS_FOR_ROUTING = "15";
+      process.env.OPENROUTER_API_KEY = "openrouter-key";
+      process.env.AZURE_OPENAI_ENDPOINT = "https://test.openai.azure.com";
+      process.env.AZURE_OPENAI_API_KEY = "azure-key";
+
+      routing = require("../src/clients/routing");
+
+      // 5 tools: should prefer OpenRouter
+      const provider = routing.determineProvider({
+        tools: [{}, {}, {}, {}, {}]
+      });
+
+      assert.strictEqual(provider, "openrouter");
+    });
+
+    it("should route simple requests to Ollama even when Azure OpenAI configured", () => {
+      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.OLLAMA_MAX_TOOLS_FOR_ROUTING = "3";
+      process.env.AZURE_OPENAI_ENDPOINT = "https://test.openai.azure.com";
+      process.env.AZURE_OPENAI_API_KEY = "test-key";
+
+      routing = require("../src/clients/routing");
+
+      // 2 tools: under Ollama threshold
+      const provider = routing.determineProvider({
+        tools: [{}, {}]
+      });
+
+      assert.strictEqual(provider, "ollama");
+    });
+  });
+
+  describe("Fallback Configuration", () => {
+    it("should support 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";
+
+      routing = require("../src/clients/routing");
+
+      const fallbackProvider = routing.getFallbackProvider();
+
+      assert.strictEqual(fallbackProvider, "azure-openai");
+    });
+
+    it("should return true for fallback enabled", () => {
+      process.env.FALLBACK_ENABLED = "true";
+
+      routing = require("../src/clients/routing");
+
+      assert.strictEqual(routing.isFallbackEnabled(), true);
+    });
+
+    it("should return false when fallback disabled", () => {
+      process.env.FALLBACK_ENABLED = "false";
+
+      routing = require("../src/clients/routing");
+
+      assert.strictEqual(routing.isFallbackEnabled(), false);
+    });
+  });
+});

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

@@ -0,0 +1,171 @@
+const assert = require("assert");
+const { describe, it } = require("node:test");
+
+describe("Azure OpenAI Streaming Tests", () => {
+  describe("Streaming Response Structure", () => {
+    it("should recognize Azure OpenAI SSE streaming format", () => {
+      const streamChunk = {
+        id: "chatcmpl-123",
+        object: "chat.completion.chunk",
+        created: 1677652288,
+        model: "gpt-4o",
+        choices: [
+          {
+            index: 0,
+            delta: {
+              content: "Hello"
+            },
+            finish_reason: null
+          }
+        ]
+      };
+
+      assert.strictEqual(streamChunk.object, "chat.completion.chunk");
+      assert.ok(streamChunk.choices[0].delta);
+    });
+
+    it("should handle streaming delta with tool_calls", () => {
+      const streamChunk = {
+        id: "chatcmpl-123",
+        object: "chat.completion.chunk",
+        model: "gpt-4o",
+        choices: [
+          {
+            index: 0,
+            delta: {
+              tool_calls: [
+                {
+                  index: 0,
+                  id: "call_abc123",
+                  type: "function",
+                  function: {
+                    name: "Read",
+                    arguments: "{\"file"
+                  }
+                }
+              ]
+            },
+            finish_reason: null
+          }
+        ]
+      };
+
+      assert.ok(streamChunk.choices[0].delta.tool_calls);
+      assert.strictEqual(streamChunk.choices[0].delta.tool_calls[0].function.name, "Read");
+    });
+
+    it("should handle final streaming chunk with finish_reason", () => {
+      const finalChunk = {
+        id: "chatcmpl-123",
+        object: "chat.completion.chunk",
+        model: "gpt-4o",
+        choices: [
+          {
+            index: 0,
+            delta: {},
+            finish_reason: "stop"
+          }
+        ]
+      };
+
+      assert.strictEqual(finalChunk.choices[0].finish_reason, "stop");
+    });
+
+    it("should handle tool_calls finish_reason in streaming", () => {
+      const toolCallFinish = {
+        id: "chatcmpl-123",
+        object: "chat.completion.chunk",
+        model: "gpt-4o",
+        choices: [
+          {
+            index: 0,
+            delta: {},
+            finish_reason: "tool_calls"
+          }
+        ]
+      };
+
+      assert.strictEqual(toolCallFinish.choices[0].finish_reason, "tool_calls");
+    });
+  });
+
+  describe("Stream Flag in Requests", () => {
+    it("should set stream:false by default for buffered requests", () => {
+      const requestBody = {
+        messages: [{ role: "user", content: "Hello" }],
+        temperature: 0.7
+      };
+
+      // Default stream value
+      const stream = requestBody.stream ?? false;
+
+      assert.strictEqual(stream, false);
+    });
+
+    it("should set stream:true for streaming requests", () => {
+      const requestBody = {
+        messages: [{ role: "user", content: "Hello" }],
+        stream: true
+      };
+
+      assert.strictEqual(requestBody.stream, true);
+    });
+  });
+
+  describe("SSE Format Validation", () => {
+    it("should recognize SSE event format with data prefix", () => {
+      const sseChunk = 'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","choices":[{"delta":{"content":"Hi"}}]}';
+
+      assert.ok(sseChunk.startsWith("data:"));
+
+      // Extract JSON after "data: "
+      const jsonStr = sseChunk.substring(6);
+      const parsed = JSON.parse(jsonStr);
+
+      assert.strictEqual(parsed.object, "chat.completion.chunk");
+      assert.strictEqual(parsed.choices[0].delta.content, "Hi");
+    });
+
+    it("should handle SSE done signal", () => {
+      const doneSig = "data: [DONE]";
+
+      assert.strictEqual(doneSig, "data: [DONE]");
+    });
+  });
+
+  describe("Chunk Accumulation", () => {
+    it("should accumulate tool arguments across multiple chunks", () => {
+      const chunks = [
+        { delta: { tool_calls: [{ index: 0, function: { arguments: "{\"file_" } }] } },
+        { delta: { tool_calls: [{ index: 0, function: { arguments: "path\":" } }] } },
+        { delta: { tool_calls: [{ index: 0, function: { arguments: "\"/test.js" } }] } },
+        { delta: { tool_calls: [{ index: 0, function: { arguments: "\"}" } }] } }
+      ];
+
+      let accumulated = "";
+      for (const chunk of chunks) {
+        accumulated += chunk.delta.tool_calls[0].function.arguments;
+      }
+
+      assert.strictEqual(accumulated, '{"file_path":"/test.js"}');
+      const parsed = JSON.parse(accumulated);
+      assert.strictEqual(parsed.file_path, "/test.js");
+    });
+
+    it("should accumulate content across multiple chunks", () => {
+      const chunks = [
+        { delta: { content: "Hello" } },
+        { delta: { content: ", " } },
+        { delta: { content: "world" } },
+        { delta: { content: "!" } }
+      ];
+
+      let accumulated = "";
+      for (const chunk of chunks) {
+        accumulated += chunk.delta.content;
+      }
+
+      assert.strictEqual(accumulated, "Hello, world!");
+    });
+  });
+});