lynkr 3.2.1 → 3.3.1

package/src/clients/routing.js

@@ -78,6 +78,18 @@ function determineProvider(payload) {
         "Routing to llama.cpp (moderate tools)"
       );
       return "llamacpp";
+    } else if (config.lmstudio?.endpoint) {
+      logger.debug(
+        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "lmstudio" },
+        "Routing to LM Studio (moderate tools)"
+      );
+      return "lmstudio";
+    } else if (config.bedrock?.apiKey) {
+      logger.debug(
+        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "bedrock" },
+        "Routing to AWS Bedrock (moderate tools)"
+      );
+      return "bedrock";
     }
   }
 

package/src/config/index.js

@@ -62,7 +62,7 @@ function resolveConfigPath(targetPath) {
   return path.resolve(normalised);
 }
 
-const SUPPORTED_MODEL_PROVIDERS = new Set(["databricks", "azure-anthropic", "ollama", "openrouter", "azure-openai", "openai", "llamacpp"]);
+const SUPPORTED_MODEL_PROVIDERS = new Set(["databricks", "azure-anthropic", "ollama", "openrouter", "azure-openai", "openai", "llamacpp", "lmstudio", "bedrock"]);
 const rawModelProvider = (process.env.MODEL_PROVIDER ?? "databricks").toLowerCase();
 const modelProvider = SUPPORTED_MODEL_PROVIDERS.has(rawModelProvider)
   ? rawModelProvider
@@ -102,6 +102,17 @@ const llamacppModel = process.env.LLAMACPP_MODEL?.trim() || "default";
 const llamacppTimeout = Number.parseInt(process.env.LLAMACPP_TIMEOUT_MS ?? "120000", 10);
 const llamacppApiKey = process.env.LLAMACPP_API_KEY?.trim() || null;
 
+// LM Studio configuration
+const lmstudioEndpoint = process.env.LMSTUDIO_ENDPOINT?.trim() || "http://localhost:1234";
+const lmstudioModel = process.env.LMSTUDIO_MODEL?.trim() || "default";
+const lmstudioTimeout = Number.parseInt(process.env.LMSTUDIO_TIMEOUT_MS ?? "120000", 10);
+const lmstudioApiKey = process.env.LMSTUDIO_API_KEY?.trim() || null;
+
+// AWS Bedrock configuration
+const bedrockRegion = process.env.AWS_BEDROCK_REGION?.trim() || process.env.AWS_REGION?.trim() || "us-east-1";
+const bedrockApiKey = process.env.AWS_BEDROCK_API_KEY?.trim() || null; // Bearer token
+const bedrockModelId = process.env.AWS_BEDROCK_MODEL_ID?.trim() || "anthropic.claude-3-5-sonnet-20241022-v2:0";
+
 // Hybrid routing configuration
 const preferOllama = process.env.PREFER_OLLAMA === "true";
 const fallbackEnabled = process.env.FALLBACK_ENABLED !== "false"; // default true
@@ -201,6 +212,22 @@ if (modelProvider === "llamacpp") {
   }
 }
 
+if (modelProvider === "lmstudio") {
+  try {
+    new URL(lmstudioEndpoint);
+  } catch (err) {
+    throw new Error("LMSTUDIO_ENDPOINT must be a valid URL (default: http://localhost:1234)");
+  }
+}
+
+// Validate Bedrock credentials when it's the primary provider
+if (modelProvider === "bedrock" && !bedrockApiKey) {
+  throw new Error(
+    "AWS Bedrock requires AWS_BEDROCK_API_KEY (Bearer token). " +
+    "Generate from AWS Console → Bedrock → API Keys, then set AWS_BEDROCK_API_KEY in your .env file."
+  );
+}
+
 // Validate hybrid routing configuration
 if (preferOllama) {
   if (!ollamaEndpoint) {
@@ -211,8 +238,11 @@ if (preferOllama) {
       `FALLBACK_PROVIDER must be one of: ${Array.from(SUPPORTED_MODEL_PROVIDERS).join(", ")}`
     );
   }
-  if (fallbackEnabled && fallbackProvider === "ollama") {
-    throw new Error("FALLBACK_PROVIDER cannot be 'ollama' (circular fallback)");
+
+  // Prevent local providers from being used as fallback (they can fail just like Ollama)
+  const localProviders = ["ollama", "llamacpp", "lmstudio"];
+  if (fallbackEnabled && localProviders.includes(fallbackProvider)) {
+    throw new Error(`FALLBACK_PROVIDER cannot be '${fallbackProvider}' (local providers should not be fallbacks). Use cloud providers: databricks, azure-anthropic, azure-openai, openrouter, openai, bedrock`);
   }
 
   // Ensure fallback provider is properly configured (only if fallback is enabled)
@@ -226,6 +256,9 @@ if (preferOllama) {
     if (fallbackProvider === "azure-openai" && (!azureOpenAIEndpoint || !azureOpenAIApiKey)) {
       throw new Error("FALLBACK_PROVIDER is set to 'azure-openai' but AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY are not configured. Please set these environment variables or choose a different fallback provider.");
     }
+    if (fallbackProvider === "bedrock" && !bedrockApiKey) {
+      throw new Error("FALLBACK_PROVIDER is set to 'bedrock' but AWS_BEDROCK_API_KEY is not configured. Please set this environment variable or choose a different fallback provider.");
+    }
   }
 }
 
@@ -424,6 +457,17 @@ const config = {
     timeout: Number.isNaN(llamacppTimeout) ? 120000 : llamacppTimeout,
     apiKey: llamacppApiKey,
   },
+  lmstudio: {
+    endpoint: lmstudioEndpoint,
+    model: lmstudioModel,
+    timeout: Number.isNaN(lmstudioTimeout) ? 120000 : lmstudioTimeout,
+    apiKey: lmstudioApiKey,
+  },
+  bedrock: {
+    region: bedrockRegion,
+    apiKey: bedrockApiKey,
+    modelId: bedrockModelId,
+  },
   modelProvider: {
     type: modelProvider,
     defaultModel,

package/src/orchestrator/index.js

@@ -1994,7 +1994,14 @@ async function runAgentLoop({
     // Use actualProvider from invokeModel for hybrid routing support
     const actualProvider = databricksResponse.actualProvider || providerType;
 
-    if (actualProvider === "azure-anthropic") {
+    if (actualProvider === "bedrock") {
+      // Bedrock with Claude models returns native Anthropic format
+      // Other models are already converted by bedrock-utils
+      anthropicPayload = databricksResponse.json;
+      if (Array.isArray(anthropicPayload?.content)) {
+        anthropicPayload.content = policy.sanitiseContent(anthropicPayload.content);
+      }
+    } else if (actualProvider === "azure-anthropic") {
       anthropicPayload = databricksResponse.json;
       if (Array.isArray(anthropicPayload?.content)) {
         anthropicPayload.content = policy.sanitiseContent(anthropicPayload.content);

package/src/tools/smart-selection.js

@@ -16,7 +16,7 @@ const TECHNICAL_KEYWORDS = /code|function|class|file|module|import|export|async|
 const EXPLANATION_PATTERN = /explain|describe|summarize|what does|how does|tell me about|give me an overview|clarify|elaborate/i;
 const WEB_PATTERN = /search|lookup|find info|google|documentation|docs|website|url|link|online|internet|browse/i;
 const READ_PATTERN = /read|show|display|view|cat|check|inspect|look at|see|examine|review|print|output/i;
-const WRITE_PATTERN = /write|create|add|update|modify|change|fix|delete|remove|insert|append|replace|save/i;
+const WRITE_PATTERN = /write|create|add|update|modify|change|fix|delete|remove|insert|append|replace|save|put|make|generate|produce/i;
 const EDIT_PATTERN = /edit|refactor|rename|move|reorganize|restructure|rewrite/i;
 const EXECUTION_PATTERN = /run|execute|test|compile|build|deploy|start|install|launch|boot|fire up|npm|git|python|node|docker|bash|sh|cmd/i;
 const COMPLEX_PATTERN = /implement|build|create|develop|design|architect|plan|strategy|approach|help with|work on|improve|optimize|enhance|refactor|migrate/i;

package/test/bedrock-integration.test.js

@@ -0,0 +1,471 @@
+const assert = require("assert");
+const { describe, it, beforeEach, afterEach } = require("node:test");
+
+describe("AWS Bedrock Integration", () => {
+  let originalEnv;
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+
+    // Clear module cache
+    delete require.cache[require.resolve("../src/config")];
+    delete require.cache[require.resolve("../src/clients/routing")];
+    delete require.cache[require.resolve("../src/clients/bedrock-utils")];
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe("Configuration", () => {
+    it("should accept bedrock as a valid MODEL_PROVIDER", () => {
+      process.env.MODEL_PROVIDER = "bedrock";
+      process.env.AWS_ACCESS_KEY_ID = "AKIATEST123";
+      process.env.AWS_SECRET_ACCESS_KEY = "testSecretKey123";
+
+      const config = require("../src/config");
+      assert.strictEqual(config.modelProvider.type, "bedrock");
+    });
+
+    it("should throw error when AWS credentials are missing", () => {
+      process.env.MODEL_PROVIDER = "bedrock";
+      // Set to empty string to override .env file values
+      process.env.AWS_ACCESS_KEY_ID = "";
+      process.env.AWS_SECRET_ACCESS_KEY = "";
+
+      assert.throws(
+        () => require("../src/config"),
+        /AWS Bedrock requires AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY/
+      );
+    });
+
+    it("should use default region (us-east-1)", () => {
+      process.env.MODEL_PROVIDER = "bedrock";
+      process.env.AWS_ACCESS_KEY_ID = "AKIATEST123";
+      process.env.AWS_SECRET_ACCESS_KEY = "testSecretKey123";
+      process.env.AWS_BEDROCK_REGION = "";  // Override .env value
+      process.env.AWS_REGION = "";  // Override .env value
+
+      const config = require("../src/config");
+      assert.strictEqual(config.bedrock.region, "us-east-1");
+    });
+
+    it("should use custom region when AWS_BEDROCK_REGION is set", () => {
+      process.env.MODEL_PROVIDER = "bedrock";
+      process.env.AWS_ACCESS_KEY_ID = "AKIATEST123";
+      process.env.AWS_SECRET_ACCESS_KEY = "testSecretKey123";
+      process.env.AWS_BEDROCK_REGION = "us-west-2";
+
+      const config = require("../src/config");
+      assert.strictEqual(config.bedrock.region, "us-west-2");
+    });
+
+    it("should use AWS_REGION as fallback for region", () => {
+      process.env.MODEL_PROVIDER = "bedrock";
+      process.env.AWS_ACCESS_KEY_ID = "AKIATEST123";
+      process.env.AWS_SECRET_ACCESS_KEY = "testSecretKey123";
+      process.env.AWS_BEDROCK_REGION = "";  // Override .env value
+      process.env.AWS_REGION = "ap-southeast-1";
+
+      const config = require("../src/config");
+      assert.strictEqual(config.bedrock.region, "ap-southeast-1");
+    });
+
+    it("should use default model ID", () => {
+      process.env.MODEL_PROVIDER = "bedrock";
+      process.env.AWS_ACCESS_KEY_ID = "AKIATEST123";
+      process.env.AWS_SECRET_ACCESS_KEY = "testSecretKey123";
+      process.env.AWS_BEDROCK_MODEL_ID = "";  // Override .env value
+
+      const config = require("../src/config");
+      assert.strictEqual(config.bedrock.modelId, "anthropic.claude-3-5-sonnet-20241022-v2:0");
+    });
+
+    it("should use custom model ID when AWS_BEDROCK_MODEL_ID is set", () => {
+      process.env.MODEL_PROVIDER = "bedrock";
+      process.env.AWS_ACCESS_KEY_ID = "AKIATEST123";
+      process.env.AWS_SECRET_ACCESS_KEY = "testSecretKey123";
+      process.env.AWS_BEDROCK_MODEL_ID = "anthropic.claude-3-opus-20240229-v1:0";
+
+      const config = require("../src/config");
+      assert.strictEqual(config.bedrock.modelId, "anthropic.claude-3-opus-20240229-v1:0");
+    });
+  });
+
+  describe("Model Family Detection", () => {
+    it("should detect claude family", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { detectModelFamily } = require("../src/clients/bedrock-utils");
+      assert.strictEqual(
+        detectModelFamily("anthropic.claude-3-5-sonnet-20241022-v2:0"),
+        "claude"
+      );
+    });
+
+    it("should detect claude family from global inference profile", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { detectModelFamily } = require("../src/clients/bedrock-utils");
+      assert.strictEqual(
+        detectModelFamily("global.anthropic.claude-sonnet-4-5-20250929-v1:0"),
+        "claude"
+      );
+    });
+
+    it("should detect claude family from US inference profile", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { detectModelFamily } = require("../src/clients/bedrock-utils");
+      assert.strictEqual(
+        detectModelFamily("us.anthropic.claude-sonnet-4-5-20250929-v1:0"),
+        "claude"
+      );
+    });
+
+    it("should detect titan family", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { detectModelFamily } = require("../src/clients/bedrock-utils");
+      assert.strictEqual(
+        detectModelFamily("amazon.titan-text-express-v1"),
+        "titan"
+      );
+    });
+
+    it("should detect llama family", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { detectModelFamily } = require("../src/clients/bedrock-utils");
+      assert.strictEqual(
+        detectModelFamily("meta.llama3-70b-instruct-v1:0"),
+        "llama"
+      );
+    });
+
+    it("should detect jurassic family", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { detectModelFamily } = require("../src/clients/bedrock-utils");
+      assert.strictEqual(
+        detectModelFamily("ai21.j2-ultra-v1"),
+        "jurassic"
+      );
+    });
+
+    it("should detect cohere family", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { detectModelFamily } = require("../src/clients/bedrock-utils");
+      assert.strictEqual(
+        detectModelFamily("cohere.command-text-v14"),
+        "cohere"
+      );
+    });
+
+    it("should detect mistral family", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { detectModelFamily } = require("../src/clients/bedrock-utils");
+      assert.strictEqual(
+        detectModelFamily("mistral.mistral-7b-instruct-v0:2"),
+        "mistral"
+      );
+    });
+
+    it("should throw error for unsupported model", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { detectModelFamily } = require("../src/clients/bedrock-utils");
+      assert.throws(
+        () => detectModelFamily("unknown.model-v1"),
+        /Unsupported Bedrock model/
+      );
+    });
+  });
+
+  describe("Format Conversion - Request", () => {
+    it("should keep Claude requests in Anthropic format", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { convertAnthropicToBedrockFormat } = require("../src/clients/bedrock-utils");
+
+      const anthropicBody = {
+        messages: [{ role: "user", content: "Hello" }],
+        max_tokens: 1024,
+        temperature: 0.7,
+      };
+
+      const result = convertAnthropicToBedrockFormat(anthropicBody, "claude");
+
+      assert.strictEqual(result.anthropic_version, "bedrock-2023-05-31");
+      assert.strictEqual(result.max_tokens, 1024);
+      assert.strictEqual(result.temperature, 0.7);
+      assert.deepStrictEqual(result.messages, anthropicBody.messages);
+    });
+
+    it("should convert to Titan format", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { convertAnthropicToBedrockFormat } = require("../src/clients/bedrock-utils");
+
+      const anthropicBody = {
+        messages: [{ role: "user", content: "Hello" }],
+        max_tokens: 1024,
+        temperature: 0.8,
+      };
+
+      const result = convertAnthropicToBedrockFormat(anthropicBody, "titan");
+
+      assert.strictEqual(result.textGenerationConfig.maxTokenCount, 1024);
+      assert.strictEqual(result.textGenerationConfig.temperature, 0.8);
+      assert.ok(result.inputText.includes("Human: Hello"));
+    });
+
+    it("should convert to Llama format", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { convertAnthropicToBedrockFormat } = require("../src/clients/bedrock-utils");
+
+      const anthropicBody = {
+        messages: [{ role: "user", content: "Test" }],
+        max_tokens: 512,
+        temperature: 0.9,
+      };
+
+      const result = convertAnthropicToBedrockFormat(anthropicBody, "llama");
+
+      assert.strictEqual(result.max_gen_len, 512);
+      assert.strictEqual(result.temperature, 0.9);
+      assert.ok(result.prompt.includes("Human: Test"));
+    });
+
+    it("should convert to Jurassic format", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { convertAnthropicToBedrockFormat } = require("../src/clients/bedrock-utils");
+
+      const anthropicBody = {
+        messages: [{ role: "user", content: "Test" }],
+        max_tokens: 200,
+        temperature: 0.7,
+      };
+
+      const result = convertAnthropicToBedrockFormat(anthropicBody, "jurassic");
+
+      assert.strictEqual(result.maxTokens, 200);
+      assert.strictEqual(result.temperature, 0.7);
+      assert.ok(result.prompt.includes("Human: Test"));
+    });
+  });
+
+  describe("Format Conversion - Response", () => {
+    it("should parse Claude responses (native Anthropic)", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { convertBedrockResponseToAnthropic } = require("../src/clients/bedrock-utils");
+
+      const claudeResponse = {
+        id: "msg_123",
+        type: "message",
+        role: "assistant",
+        content: [{ type: "text", text: "Hello!" }],
+        stop_reason: "end_turn",
+        usage: { input_tokens: 10, output_tokens: 5 },
+      };
+
+      const result = convertBedrockResponseToAnthropic(
+        claudeResponse,
+        "claude",
+        "anthropic.claude-3-5-sonnet-20241022-v2:0"
+      );
+
+      assert.deepStrictEqual(result, claudeResponse);
+    });
+
+    it("should convert Titan responses to Anthropic format", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { convertBedrockResponseToAnthropic } = require("../src/clients/bedrock-utils");
+
+      const titanResponse = {
+        results: [{
+          outputText: "Response text",
+          tokenCount: 50,
+          completionReason: "FINISH",
+        }],
+        inputTextTokenCount: 20,
+      };
+
+      const result = convertBedrockResponseToAnthropic(
+        titanResponse,
+        "titan",
+        "amazon.titan-text-express-v1"
+      );
+
+      assert.strictEqual(result.role, "assistant");
+      assert.strictEqual(result.content[0].type, "text");
+      assert.strictEqual(result.content[0].text, "Response text");
+      assert.strictEqual(result.stop_reason, "end_turn");
+      assert.strictEqual(result.usage.input_tokens, 20);
+      assert.strictEqual(result.usage.output_tokens, 50);
+    });
+
+    it("should convert Llama responses to Anthropic format", () => {
+      process.env.MODEL_PROVIDER = "databricks";
+      process.env.DATABRICKS_API_KEY = "test";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+
+      const { convertBedrockResponseToAnthropic } = require("../src/clients/bedrock-utils");
+
+      const llamaResponse = {
+        generation: "Llama response",
+        prompt_token_count: 15,
+        generation_token_count: 30,
+        stop_reason: "stop",
+      };
+
+      const result = convertBedrockResponseToAnthropic(
+        llamaResponse,
+        "llama",
+        "meta.llama3-70b-instruct-v1:0"
+      );
+
+      assert.strictEqual(result.role, "assistant");
+      assert.strictEqual(result.content[0].text, "Llama response");
+      assert.strictEqual(result.stop_reason, "end_turn");
+      assert.strictEqual(result.usage.input_tokens, 15);
+      assert.strictEqual(result.usage.output_tokens, 30);
+    });
+  });
+
+  describe("Routing", () => {
+    it("should route to bedrock when MODEL_PROVIDER is bedrock", () => {
+      process.env.MODEL_PROVIDER = "bedrock";
+      process.env.AWS_ACCESS_KEY_ID = "AKIATEST123";
+      process.env.AWS_SECRET_ACCESS_KEY = "testSecretKey123";
+      process.env.PREFER_OLLAMA = "false";
+
+      const config = require("../src/config");
+      const routing = require("../src/clients/routing");
+
+      const payload = { messages: [{ role: "user", content: "test" }] };
+      const provider = routing.determineProvider(payload);
+
+      // When not in hybrid mode, should use primary provider
+      assert.strictEqual(provider, "bedrock");
+    });
+
+    it("should route to bedrock in hybrid mode for moderate tool counts", () => {
+      process.env.MODEL_PROVIDER = "ollama";
+      process.env.PREFER_OLLAMA = "true";
+      process.env.OLLAMA_MODEL = "llama3.1";
+      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
+      process.env.AWS_ACCESS_KEY_ID = "AKIATEST123";
+      process.env.AWS_SECRET_ACCESS_KEY = "testSecretKey123";
+      process.env.OLLAMA_MAX_TOOLS_FOR_ROUTING = "2";
+      process.env.FALLBACK_ENABLED = "true";
+      process.env.FALLBACK_PROVIDER = "bedrock";
+
+      // Clear other providers to ensure bedrock is chosen
+      delete process.env.OPENROUTER_API_KEY;
+      delete process.env.OPENAI_API_KEY;
+      delete process.env.AZURE_OPENAI_API_KEY;
+      delete process.env.AZURE_OPENAI_ENDPOINT;
+      delete process.env.LLAMACPP_ENDPOINT;
+      delete process.env.LMSTUDIO_ENDPOINT;
+      delete process.env.DATABRICKS_API_KEY;
+      delete process.env.DATABRICKS_API_BASE;
+
+      const config = require("../src/config");
+      const routing = require("../src/clients/routing");
+
+      // 20 tools should exceed both Ollama and OpenRouter limits, routing to fallback provider (bedrock)
+      const payload = {
+        messages: [{ role: "user", content: "test" }],
+        tools: Array(20).fill({ name: "tool" }),
+      };
+      const provider = routing.determineProvider(payload);
+
+      assert.strictEqual(provider, "bedrock");
+    });
+  });
+
+  describe("Fallback Provider", () => {
+    it("should allow bedrock as fallback provider", () => {
+      process.env.MODEL_PROVIDER = "ollama";
+      process.env.PREFER_OLLAMA = "true";
+      process.env.OLLAMA_MODEL = "llama3.1";
+      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
+      process.env.FALLBACK_PROVIDER = "bedrock";
+      process.env.AWS_ACCESS_KEY_ID = "AKIATEST123";
+      process.env.AWS_SECRET_ACCESS_KEY = "testSecretKey123";
+      process.env.FALLBACK_ENABLED = "true";
+
+      // Should not throw
+      const config = require("../src/config");
+      assert.strictEqual(config.modelProvider.fallbackProvider, "bedrock");
+    });
+
+    it("should validate bedrock credentials when used as fallback", () => {
+      process.env.MODEL_PROVIDER = "ollama";
+      process.env.PREFER_OLLAMA = "true";
+      process.env.OLLAMA_MODEL = "llama3.1";
+      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
+      process.env.FALLBACK_PROVIDER = "bedrock";
+      process.env.FALLBACK_ENABLED = "true";
+      // Set to empty string to override .env file values
+      process.env.AWS_ACCESS_KEY_ID = "";
+      process.env.AWS_SECRET_ACCESS_KEY = "";
+
+      assert.throws(
+        () => require("../src/config"),
+        /FALLBACK_PROVIDER is set to 'bedrock' but AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY are not configured/
+      );
+    });
+
+    it("should not allow local providers as fallback", () => {
+      process.env.MODEL_PROVIDER = "ollama";
+      process.env.PREFER_OLLAMA = "true";
+      process.env.OLLAMA_MODEL = "llama3.1";
+      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
+      process.env.FALLBACK_PROVIDER = "llamacpp";
+      process.env.FALLBACK_ENABLED = "true";
+
+      assert.throws(
+        () => require("../src/config"),
+        /FALLBACK_PROVIDER cannot be 'llamacpp'/
+      );
+    });
+  });
+});