lynkr 1.0.0 → 2.0.0

package/test/format-conversion.test.js

@@ -0,0 +1,578 @@
+const assert = require("assert");
+const { describe, it, beforeEach, afterEach } = require("node:test");
+
+describe("Enhanced 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 OpenRouter Conversion", () => {
+    describe("Message Conversion", () => {
+      it("should convert simple text messages", () => {
+        const anthropicMessages = [
+          {
+            role: "user",
+            content: "Hello, how are you?"
+          }
+        ];
+
+        const result = openrouterUtils.convertAnthropicMessagesToOpenRouter(anthropicMessages);
+
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].role, "user");
+        assert.strictEqual(result[0].content, "Hello, how are you?");
+      });
+
+      it("should convert messages with content blocks", () => {
+        const anthropicMessages = [
+          {
+            role: "user",
+            content: [
+              { type: "text", text: "Please read this file" }
+            ]
+          }
+        ];
+
+        const result = openrouterUtils.convertAnthropicMessagesToOpenRouter(anthropicMessages);
+
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].role, "user");
+        assert.strictEqual(result[0].content, "Please read this file");
+      });
+
+      it("should handle multiple text blocks", () => {
+        const anthropicMessages = [
+          {
+            role: "user",
+            content: [
+              { type: "text", text: "First part" },
+              { type: "text", text: "Second part" }
+            ]
+          }
+        ];
+
+        const result = openrouterUtils.convertAnthropicMessagesToOpenRouter(anthropicMessages);
+
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].content, "First part\nSecond part");
+      });
+
+      it("should convert assistant messages with tool_use blocks", () => {
+        const anthropicMessages = [
+          {
+            role: "assistant",
+            content: [
+              { type: "text", text: "I'll read that file" },
+              {
+                type: "tool_use",
+                id: "toolu_123",
+                name: "Read",
+                input: { file_path: "/tmp/test.txt" }
+              }
+            ]
+          }
+        ];
+
+        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.strictEqual(Array.isArray(result[0].tool_calls), true);
+        assert.strictEqual(result[0].tool_calls.length, 1);
+        assert.strictEqual(result[0].tool_calls[0].id, "toolu_123");
+        assert.strictEqual(result[0].tool_calls[0].function.name, "Read");
+      });
+
+      it("should convert tool_result blocks to tool messages", () => {
+        // Must include the assistant message with tool_use first
+        // otherwise tool_result is orphaned and gets removed
+        const anthropicMessages = [
+          {
+            role: "assistant",
+            content: [
+              {
+                type: "tool_use",
+                id: "toolu_123",
+                name: "Read",
+                input: { file_path: "/tmp/test.txt" }
+              }
+            ]
+          },
+          {
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: "toolu_123",
+                content: "File content here"
+              }
+            ]
+          }
+        ];
+
+        const result = openrouterUtils.convertAnthropicMessagesToOpenRouter(anthropicMessages);
+
+        // Tool results should be converted to tool role messages
+        const toolMessage = result.find(m => m.role === "tool");
+        assert.ok(toolMessage, "Tool message should be present");
+        assert.strictEqual(toolMessage.tool_call_id, "toolu_123");
+        assert.strictEqual(toolMessage.content, "File content here");
+      });
+
+      it("should handle text content separate from tool_result", () => {
+        // Note: OpenRouter validation requires tool messages to immediately follow
+        // the assistant message with tool_calls. A user message in between will
+        // cause the tool message to be filtered as orphaned.
+        const anthropicMessages = [
+          {
+            role: "assistant",
+            content: [
+              {
+                type: "tool_use",
+                id: "toolu_123",
+                name: "Write",
+                input: { file_path: "/tmp/test.txt", content: "data" }
+              }
+            ]
+          },
+          {
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: "toolu_123",
+                content: "Success"
+              }
+            ]
+          },
+          {
+            role: "user",
+            content: "Here's additional feedback"
+          }
+        ];
+
+        const result = openrouterUtils.convertAnthropicMessagesToOpenRouter(anthropicMessages);
+
+        // Should have assistant with tool_calls, tool message, and user message
+        const assistantMsg = result.find(m => m.role === "assistant");
+        const toolMsg = result.find(m => m.role === "tool");
+        const userMsg = result.find(m => m.role === "user" && m.content === "Here's additional feedback");
+
+        assert.ok(assistantMsg, "Assistant message should be present");
+        assert.ok(toolMsg, "Tool message should be present");
+        assert.ok(userMsg, "User message should be present");
+        assert.strictEqual(toolMsg.content, "Success");
+      });
+    });
+
+    describe("Tool Conversion", () => {
+      it("should convert Anthropic tools to OpenRouter format", () => {
+        const anthropicTools = [
+          {
+            name: "Write",
+            description: "Write a file to the filesystem",
+            input_schema: {
+              type: "object",
+              properties: {
+                file_path: { type: "string", description: "Path to file" },
+                content: { type: "string", description: "File content" }
+              },
+              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 a file to the filesystem");
+        assert.deepStrictEqual(result[0].function.parameters, anthropicTools[0].input_schema);
+      });
+
+      it("should handle tools without descriptions", () => {
+        const anthropicTools = [
+          {
+            name: "TestTool",
+            input_schema: {
+              type: "object",
+              properties: {}
+            }
+          }
+        ];
+
+        const result = openrouterUtils.convertAnthropicToolsToOpenRouter(anthropicTools);
+
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].function.name, "TestTool");
+        assert.strictEqual(result[0].function.description, "");
+      });
+
+      it("should handle empty tools array", () => {
+        const result = openrouterUtils.convertAnthropicToolsToOpenRouter([]);
+        assert.strictEqual(result.length, 0);
+      });
+
+      it("should convert multiple tools", () => {
+        const anthropicTools = [
+          {
+            name: "Read",
+            description: "Read a file",
+            input_schema: { type: "object", properties: {} }
+          },
+          {
+            name: "Write",
+            description: "Write a file",
+            input_schema: { type: "object", properties: {} }
+          },
+          {
+            name: "Execute",
+            description: "Execute a command",
+            input_schema: { type: "object", properties: {} }
+          }
+        ];
+
+        const result = openrouterUtils.convertAnthropicToolsToOpenRouter(anthropicTools);
+
+        assert.strictEqual(result.length, 3);
+        assert.strictEqual(result[0].function.name, "Read");
+        assert.strictEqual(result[1].function.name, "Write");
+        assert.strictEqual(result[2].function.name, "Execute");
+      });
+    });
+  });
+
+  describe("OpenRouter to Anthropic Conversion", () => {
+    describe("Response Conversion", () => {
+      it("should convert text-only response", () => {
+        const openRouterResponse = {
+          choices: [
+            {
+              message: {
+                role: "assistant",
+                content: "Hello! I'm here to help."
+              },
+              finish_reason: "stop"
+            }
+          ],
+          model: "openai/gpt-4o-mini",
+          usage: { prompt_tokens: 10, completion_tokens: 8, total_tokens: 18 }
+        };
+
+        const result = openrouterUtils.convertOpenRouterResponseToAnthropic(
+          openRouterResponse,
+          "test-model"
+        );
+
+        assert.strictEqual(result.type, "message");
+        assert.strictEqual(result.role, "assistant");
+        assert.strictEqual(result.content.length, 1);
+        assert.strictEqual(result.content[0].type, "text");
+        assert.strictEqual(result.content[0].text, "Hello! I'm here to help.");
+        assert.strictEqual(result.stop_reason, "end_turn");
+      });
+
+      it("should convert response with tool calls", () => {
+        const openRouterResponse = {
+          choices: [
+            {
+              message: {
+                role: "assistant",
+                content: "I'll read that file",
+                tool_calls: [
+                  {
+                    id: "call_abc123",
+                    type: "function",
+                    function: {
+                      name: "Read",
+                      arguments: JSON.stringify({ file_path: "/tmp/test.txt" })
+                    }
+                  }
+                ]
+              },
+              finish_reason: "tool_calls"
+            }
+          ],
+          model: "openai/gpt-4o-mini",
+          usage: { prompt_tokens: 15, completion_tokens: 25, total_tokens: 40 }
+        };
+
+        const result = openrouterUtils.convertOpenRouterResponseToAnthropic(
+          openRouterResponse,
+          "test-model"
+        );
+
+        assert.strictEqual(result.content.length, 2);
+        assert.strictEqual(result.content[0].type, "text");
+        assert.strictEqual(result.content[1].type, "tool_use");
+        assert.strictEqual(result.content[1].id, "call_abc123");
+        assert.strictEqual(result.content[1].name, "Read");
+        assert.deepStrictEqual(result.content[1].input, { file_path: "/tmp/test.txt" });
+        assert.strictEqual(result.stop_reason, "tool_use");
+      });
+
+      it("should convert response with multiple tool calls", () => {
+        const openRouterResponse = {
+          choices: [
+            {
+              message: {
+                role: "assistant",
+                content: "Processing multiple operations",
+                tool_calls: [
+                  {
+                    id: "call_1",
+                    type: "function",
+                    function: {
+                      name: "Read",
+                      arguments: JSON.stringify({ file_path: "/input.txt" })
+                    }
+                  },
+                  {
+                    id: "call_2",
+                    type: "function",
+                    function: {
+                      name: "Write",
+                      arguments: JSON.stringify({
+                        file_path: "/output.txt",
+                        content: "result"
+                      })
+                    }
+                  }
+                ]
+              },
+              finish_reason: "tool_calls"
+            }
+          ],
+          model: "openai/gpt-4o-mini",
+          usage: { prompt_tokens: 20, completion_tokens: 40, total_tokens: 60 }
+        };
+
+        const result = openrouterUtils.convertOpenRouterResponseToAnthropic(
+          openRouterResponse,
+          "test-model"
+        );
+
+        assert.strictEqual(result.content.length, 3); // 1 text + 2 tool_use
+        assert.strictEqual(result.content[0].type, "text");
+        assert.strictEqual(result.content[1].type, "tool_use");
+        assert.strictEqual(result.content[1].name, "Read");
+        assert.strictEqual(result.content[2].type, "tool_use");
+        assert.strictEqual(result.content[2].name, "Write");
+      });
+
+      it("should generate unique IDs for tools", () => {
+        const openRouterResponse = {
+          choices: [
+            {
+              message: {
+                role: "assistant",
+                content: "Using tools",
+                tool_calls: [
+                  {
+                    id: "call_1",
+                    type: "function",
+                    function: { name: "Tool1", arguments: "{}" }
+                  },
+                  {
+                    id: "call_2",
+                    type: "function",
+                    function: { name: "Tool2", arguments: "{}" }
+                  }
+                ]
+              },
+              finish_reason: "tool_calls"
+            }
+          ],
+          model: "test-model",
+          usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 }
+        };
+
+        const result = openrouterUtils.convertOpenRouterResponseToAnthropic(
+          openRouterResponse,
+          "test-model"
+        );
+
+        const tool1Id = result.content[1].id;
+        const tool2Id = result.content[2].id;
+
+        assert.strictEqual(tool1Id !== tool2Id, true);
+        assert.strictEqual(typeof tool1Id, "string");
+        assert.strictEqual(typeof tool2Id, "string");
+      });
+
+      it("should map finish_reason correctly", () => {
+        const testCases = [
+          { finish_reason: "stop", expected: "end_turn" },
+          { finish_reason: "tool_calls", expected: "tool_use" },
+          { finish_reason: "length", expected: "max_tokens" }
+        ];
+
+        testCases.forEach(({ finish_reason, expected }) => {
+          const response = {
+            choices: [
+              {
+                message: {
+                  role: "assistant",
+                  content: "Test",
+                  ...(finish_reason === "tool_calls" && {
+                    tool_calls: [
+                      {
+                        id: "test",
+                        function: { name: "test", arguments: "{}" }
+                      }
+                    ]
+                  })
+                },
+                finish_reason
+              }
+            ],
+            model: "test-model",
+            usage: { prompt_tokens: 10, completion_tokens: 10, total_tokens: 20 }
+          };
+
+          const result = openrouterUtils.convertOpenRouterResponseToAnthropic(
+            response,
+            "test-model"
+          );
+
+          assert.strictEqual(result.stop_reason, expected);
+        });
+      });
+
+      it("should include proper message ID format", () => {
+        const response = {
+          choices: [
+            {
+              message: {
+                role: "assistant",
+                content: "Response"
+              },
+              finish_reason: "stop"
+            }
+          ],
+          id: "chatcmpl-123",
+          model: "openai/gpt-4o-mini",
+          usage: { prompt_tokens: 10, completion_tokens: 10, total_tokens: 20 }
+        };
+
+        const result = openrouterUtils.convertOpenRouterResponseToAnthropic(
+          response,
+          "test-model"
+        );
+
+        assert.strictEqual(typeof result.id, "string");
+        assert.strictEqual(result.id.length > 0, true);
+      });
+
+      it("should preserve usage metadata", () => {
+        const response = {
+          choices: [
+            {
+              message: {
+                role: "assistant",
+                content: "Test"
+              },
+              finish_reason: "stop"
+            }
+          ],
+          model: "openai/gpt-4o-mini",
+          usage: {
+            prompt_tokens: 100,
+            completion_tokens: 50,
+            total_tokens: 150
+          }
+        };
+
+        const result = openrouterUtils.convertOpenRouterResponseToAnthropic(
+          response,
+          "test-model"
+        );
+
+        assert.strictEqual(result.usage.input_tokens, 100);
+        assert.strictEqual(result.usage.output_tokens, 50);
+      });
+    });
+  });
+
+  describe("Round-Trip Conversion", () => {
+    it("should maintain data integrity through round-trip conversion", () => {
+      const originalMessage = {
+        role: "user",
+        content: "Please write to /tmp/test.txt"
+      };
+
+      // Convert to OpenRouter
+      const openRouterFormat = openrouterUtils.convertAnthropicMessagesToOpenRouter([
+        originalMessage
+      ]);
+
+      // Verify conversion
+      assert.strictEqual(openRouterFormat[0].role, "user");
+      assert.strictEqual(openRouterFormat[0].content, "Please write to /tmp/test.txt");
+    });
+
+    it("should handle complex conversation with tools", () => {
+      const conversation = [
+        {
+          role: "user",
+          content: "Read /tmp/input.txt and write to /tmp/output.txt"
+        },
+        {
+          role: "assistant",
+          content: [
+            { type: "text", text: "I'll do that for you" },
+            {
+              type: "tool_use",
+              id: "toolu_1",
+              name: "Read",
+              input: { file_path: "/tmp/input.txt" }
+            }
+          ]
+        },
+        {
+          role: "user",
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: "toolu_1",
+              content: "File contents"
+            }
+          ]
+        }
+      ];
+
+      // Convert to OpenRouter
+      const openRouterFormat = openrouterUtils.convertAnthropicMessagesToOpenRouter(
+        conversation
+      );
+
+      // Verify structure is maintained
+      assert.strictEqual(openRouterFormat.length >= 3, true);
+
+      // Check user message
+      const userMsgs = openRouterFormat.filter(m => m.role === "user");
+      assert.strictEqual(userMsgs.length >= 1, true);
+
+      // Check assistant message with tool calls
+      const assistantMsgs = openRouterFormat.filter(m => m.role === "assistant");
+      assert.strictEqual(assistantMsgs.length >= 1, true);
+      assert.strictEqual(Array.isArray(assistantMsgs[0].tool_calls), true);
+
+      // Check tool message
+      const toolMsgs = openRouterFormat.filter(m => m.role === "tool");
+      assert.strictEqual(toolMsgs.length >= 1, true);
+    });
+  });
+});

package/test/hybrid-routing-integration.test.js

@@ -42,35 +42,40 @@ describe("Hybrid Routing Integration Tests", () => {
       assert.strictEqual(config.ollama.endpoint, "http://localhost:11434");
     });
 
-    it("should reject invalid OLLAMA_FALLBACK_PROVIDER", () => {
+    it("should reject invalid FALLBACK_PROVIDER", () => {
       process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.OLLAMA_FALLBACK_PROVIDER = "invalid-provider";
+      process.env.FALLBACK_ENABLED = "true";
+      process.env.FALLBACK_PROVIDER = "invalid-provider";
 
       assert.throws(() => {
         require("../src/config");
-      }, /OLLAMA_FALLBACK_PROVIDER must be one of/);
+      }, /FALLBACK_PROVIDER must be one of/);
     });
 
     it("should reject circular fallback (ollama -> ollama)", () => {
       process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.OLLAMA_FALLBACK_PROVIDER = "ollama";
+      process.env.FALLBACK_ENABLED = "true";
+      process.env.FALLBACK_PROVIDER = "ollama";
 
       assert.throws(() => {
         require("../src/config");
-      }, /OLLAMA_FALLBACK_PROVIDER cannot be 'ollama'/);
+      }, /FALLBACK_PROVIDER cannot be 'ollama'/);
     });
 
     it("should reject PREFER_OLLAMA with databricks fallback but no databricks credentials", () => {
+      process.env.MODEL_PROVIDER = "ollama";  // Set to ollama for hybrid routing scenario
       process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.OLLAMA_FALLBACK_PROVIDER = "databricks";
-      delete process.env.DATABRICKS_API_KEY;
-      delete process.env.DATABRICKS_API_BASE;
+      process.env.FALLBACK_ENABLED = "true";
+      process.env.FALLBACK_PROVIDER = "databricks";
+      // Set to empty strings instead of deleting (dotenv.config() in config module would reload from .env)
+      process.env.DATABRICKS_API_KEY = "";
+      process.env.DATABRICKS_API_BASE = "";
 
       // Should throw error about missing databricks credentials
       // (Either from standard validation or hybrid routing validation)
@@ -83,16 +88,18 @@ describe("Hybrid Routing Integration Tests", () => {
       process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.OLLAMA_FALLBACK_PROVIDER = "databricks";
+      process.env.FALLBACK_ENABLED = "true";
+      process.env.FALLBACK_PROVIDER = "databricks";
+      process.env.OLLAMA_MAX_TOOLS_FOR_ROUTING = "3"; // Override .env which sets it to 2
       process.env.DATABRICKS_API_KEY = "test-key";
       process.env.DATABRICKS_API_BASE = "http://test.com";
 
       const config = require("../src/config");
 
       assert.strictEqual(config.modelProvider.preferOllama, true);
-      assert.strictEqual(config.modelProvider.ollamaFallbackEnabled, true);
+      assert.strictEqual(config.modelProvider.fallbackEnabled, true);
       assert.strictEqual(config.modelProvider.ollamaMaxToolsForRouting, 3);
-      assert.strictEqual(config.modelProvider.ollamaFallbackProvider, "databricks");
+      assert.strictEqual(config.modelProvider.fallbackProvider, "databricks");
     });
   });