lynkr 3.2.1 → 4.0.0

package/src/api/router.js

@@ -3,6 +3,7 @@ const { processMessage } = require("../orchestrator");
 const { getSession } = require("../sessions");
 const metrics = require("../metrics");
 const { createRateLimiter } = require("./middleware/rate-limiter");
+const openaiRouter = require("./openai-router");
 
 const router = express.Router();
 
@@ -383,4 +384,7 @@ router.get("/api/tokens/stats", (req, res) => {
   }
 });
 
+// Mount OpenAI-compatible endpoints for Cursor IDE support
+router.use("/v1", openaiRouter);
+
 module.exports = router;

package/src/clients/bedrock-utils.js

@@ -0,0 +1,298 @@
+/**
+ * AWS Bedrock Model Format Utilities
+ *
+ * Handles format conversion between Anthropic format and various Bedrock model families.
+ * Supports: Claude, Titan, Llama, Jurassic, Cohere, Mistral
+ *
+ * @module clients/bedrock-utils
+ */
+
+const logger = require("../logger");
+
+/**
+ * Convert Anthropic messages array to a simple text prompt
+ * @param {Array} messages - Anthropic messages array
+ * @returns {string} Combined prompt text
+ */
+function messagesToPrompt(messages) {
+  return messages
+    .map((msg) => {
+      const role = msg.role === "user" ? "Human" : "Assistant";
+      let content = "";
+
+      if (typeof msg.content === "string") {
+        content = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        content = msg.content
+          .filter((block) => block.type === "text")
+          .map((block) => block.text)
+          .join("\n");
+      }
+
+      return `${role}: ${content}`;
+    })
+    .join("\n\n");
+}
+
+/**
+ * Detect which model family a Bedrock model ID belongs to
+ * @param {string} modelId - AWS Bedrock model ID or inference profile ID
+ *   Examples: "anthropic.claude-3-5-sonnet-20241022-v2:0", "us.deepseek.r1-v1:0", "qwen.qwen3-235b-v1:0"
+ * @returns {string} Model family identifier
+ */
+function detectModelFamily(modelId) {
+  // Handle inference profiles (e.g., "global.anthropic.claude-..." or "us.deepseek.r1-...")
+  if (modelId.includes(".anthropic.claude")) return "claude";
+  if (modelId.includes(".amazon.titan")) return "titan";
+  if (modelId.includes(".amazon.nova")) return "nova";
+  if (modelId.includes(".meta.llama")) return "llama";
+  if (modelId.includes(".ai21.jamba")) return "jamba";
+  if (modelId.includes(".cohere.command")) return "cohere";
+  if (modelId.includes(".mistral")) return "mistral";
+  if (modelId.includes(".deepseek")) return "deepseek";
+  if (modelId.includes(".qwen")) return "qwen";
+  if (modelId.includes(".openai")) return "openai";
+  if (modelId.includes(".google.gemma")) return "gemma";
+  if (modelId.includes(".minimax")) return "minimax";
+  if (modelId.includes(".writer")) return "writer";
+  if (modelId.includes(".kimi")) return "kimi";
+  if (modelId.includes(".luma")) return "luma";
+  if (modelId.includes(".twelvelabs")) return "twelvelabs";
+
+  // Handle direct model IDs (standard format)
+  if (modelId.startsWith("anthropic.claude")) return "claude";
+  if (modelId.startsWith("amazon.titan")) return "titan";
+  if (modelId.startsWith("amazon.nova")) return "nova";
+  if (modelId.startsWith("meta.llama")) return "llama";
+  if (modelId.startsWith("ai21.j2")) return "jurassic";
+  if (modelId.startsWith("ai21.jamba")) return "jamba";
+  if (modelId.startsWith("cohere.command")) return "cohere";
+  if (modelId.startsWith("mistral.")) return "mistral";
+  if (modelId.startsWith("deepseek.")) return "deepseek";
+  if (modelId.startsWith("qwen.")) return "qwen";
+  if (modelId.startsWith("openai.")) return "openai";
+  if (modelId.startsWith("google.gemma")) return "gemma";
+  if (modelId.startsWith("minimax.")) return "minimax";
+  if (modelId.startsWith("writer.")) return "writer";
+  if (modelId.startsWith("kimi.")) return "kimi";
+  if (modelId.startsWith("luma.")) return "luma";
+  if (modelId.startsWith("twelvelabs.")) return "twelvelabs";
+
+  // If we can't detect, assume it works with Converse API (Bedrock's unified API)
+  logger.info({ modelId }, "Unknown Bedrock model family - assuming Converse API compatibility");
+  return "converse";
+}
+
+/**
+ * Convert Anthropic format request to Bedrock-specific format
+ * @param {Object} body - Request body in Anthropic format
+ * @param {string} modelFamily - Model family from detectModelFamily()
+ * @returns {Object} Request body in Bedrock model-specific format
+ */
+function convertAnthropicToBedrockFormat(body, modelFamily) {
+  switch (modelFamily) {
+    case "claude":
+      // Claude models use native Anthropic Messages API format
+      // Only need to add anthropic_version field for Bedrock
+      return {
+        anthropic_version: "bedrock-2023-05-31",
+        max_tokens: body.max_tokens || 4096,
+        messages: body.messages,
+        system: body.system,
+        temperature: body.temperature,
+        top_p: body.top_p,
+        tools: body.tools,
+      };
+
+    case "titan":
+      // Amazon Titan format
+      return {
+        inputText: messagesToPrompt(body.messages),
+        textGenerationConfig: {
+          maxTokenCount: body.max_tokens || 4096,
+          temperature: body.temperature || 0.7,
+          topP: body.top_p || 1.0,
+          stopSequences: [],
+        },
+      };
+
+    case "llama":
+      // Meta Llama format
+      const llamaPrompt = messagesToPrompt(body.messages);
+      return {
+        prompt: llamaPrompt,
+        max_gen_len: body.max_tokens || 2048,
+        temperature: body.temperature || 0.7,
+        top_p: body.top_p || 0.9,
+      };
+
+    case "jurassic":
+      // AI21 Jurassic format
+      return {
+        prompt: messagesToPrompt(body.messages),
+        maxTokens: body.max_tokens || 200,
+        temperature: body.temperature || 0.7,
+        topP: body.top_p || 1,
+        stopSequences: [],
+        countPenalty: {
+          scale: 0,
+        },
+        presencePenalty: {
+          scale: 0,
+        },
+        frequencyPenalty: {
+          scale: 0,
+        },
+      };
+
+    case "cohere":
+      // Cohere Command format
+      return {
+        prompt: messagesToPrompt(body.messages),
+        max_tokens: body.max_tokens || 400,
+        temperature: body.temperature || 0.75,
+        p: body.top_p || 1.0,
+        k: 0,
+        stop_sequences: [],
+        return_likelihoods: "NONE",
+      };
+
+    case "mistral":
+      // Mistral format (similar to OpenAI)
+      return {
+        prompt: messagesToPrompt(body.messages),
+        max_tokens: body.max_tokens || 2048,
+        temperature: body.temperature || 0.7,
+        top_p: body.top_p || 1.0,
+        stop: [],
+      };
+
+    default:
+      throw new Error(`Unsupported model family: ${modelFamily}`);
+  }
+}
+
+/**
+ * Convert Bedrock response to Anthropic format
+ * @param {Object} response - Raw response from Bedrock model
+ * @param {string} modelFamily - Model family from detectModelFamily()
+ * @param {string} modelId - Full Bedrock model ID
+ * @returns {Object} Response in Anthropic format
+ */
+function convertBedrockResponseToAnthropic(response, modelFamily, modelId) {
+  switch (modelFamily) {
+    case "claude":
+      // Claude models return native Anthropic format
+      // No conversion needed - pass through directly
+      return response;
+
+    case "titan":
+      // Convert Titan response to Anthropic format
+      return {
+        id: `bedrock-titan-${Date.now()}`,
+        type: "message",
+        role: "assistant",
+        model: modelId,
+        content: [
+          {
+            type: "text",
+            text: response.results?.[0]?.outputText || "",
+          },
+        ],
+        stop_reason: response.results?.[0]?.completionReason === "FINISH" ? "end_turn" : "max_tokens",
+        usage: {
+          input_tokens: response.inputTextTokenCount || 0,
+          output_tokens: response.results?.[0]?.tokenCount || 0,
+        },
+      };
+
+    case "llama":
+      // Convert Llama response to Anthropic format
+      return {
+        id: `bedrock-llama-${Date.now()}`,
+        type: "message",
+        role: "assistant",
+        model: modelId,
+        content: [
+          {
+            type: "text",
+            text: response.generation || "",
+          },
+        ],
+        stop_reason: response.stop_reason === "stop" ? "end_turn" : "max_tokens",
+        usage: {
+          input_tokens: response.prompt_token_count || 0,
+          output_tokens: response.generation_token_count || 0,
+        },
+      };
+
+    case "jurassic":
+      // Convert Jurassic response to Anthropic format
+      return {
+        id: `bedrock-jurassic-${Date.now()}`,
+        type: "message",
+        role: "assistant",
+        model: modelId,
+        content: [
+          {
+            type: "text",
+            text: response.completions?.[0]?.data?.text || "",
+          },
+        ],
+        stop_reason: response.completions?.[0]?.finishReason?.reason === "endoftext" ? "end_turn" : "max_tokens",
+        usage: {
+          input_tokens: 0, // Jurassic doesn't provide input token count
+          output_tokens: response.completions?.[0]?.data?.tokens?.length || 0,
+        },
+      };
+
+    case "cohere":
+      // Convert Cohere response to Anthropic format
+      return {
+        id: `bedrock-cohere-${Date.now()}`,
+        type: "message",
+        role: "assistant",
+        model: modelId,
+        content: [
+          {
+            type: "text",
+            text: response.generations?.[0]?.text || "",
+          },
+        ],
+        stop_reason: response.generations?.[0]?.finish_reason === "COMPLETE" ? "end_turn" : "max_tokens",
+        usage: {
+          input_tokens: 0, // Cohere doesn't provide token counts in basic response
+          output_tokens: 0,
+        },
+      };
+
+    case "mistral":
+      // Convert Mistral response to Anthropic format
+      return {
+        id: `bedrock-mistral-${Date.now()}`,
+        type: "message",
+        role: "assistant",
+        model: modelId,
+        content: [
+          {
+            type: "text",
+            text: response.outputs?.[0]?.text || "",
+          },
+        ],
+        stop_reason: response.outputs?.[0]?.stop_reason === "stop" ? "end_turn" : "max_tokens",
+        usage: {
+          input_tokens: 0, // Mistral doesn't provide token counts
+          output_tokens: 0,
+        },
+      };
+
+    default:
+      throw new Error(`Unsupported model family: ${modelFamily}`);
+  }
+}
+
+module.exports = {
+  detectModelFamily,
+  convertAnthropicToBedrockFormat,
+  convertBedrockResponseToAnthropic,
+};

package/src/clients/databricks.js

@@ -7,6 +7,11 @@ const { getMetricsCollector } = require("../observability/metrics");
 const logger = require("../logger");
 const { STANDARD_TOOLS } = require("./standard-tools");
 const { convertAnthropicToolsToOpenRouter } = require("./openrouter-utils");
+const {
+  detectModelFamily,
+  convertAnthropicToBedrockFormat,
+  convertBedrockResponseToAnthropic
+} = require("./bedrock-utils");
 
 
 
@@ -574,6 +579,262 @@ async function invokeLlamaCpp(body) {
   return performJsonRequest(endpoint, { headers, body: llamacppBody }, "llama.cpp");
 }
 
+async function invokeLMStudio(body) {
+  if (!config.lmstudio?.endpoint) {
+    throw new Error("LM Studio endpoint is not configured.");
+  }
+
+  const {
+    convertAnthropicToolsToOpenRouter,
+    convertAnthropicMessagesToOpenRouter
+  } = require("./openrouter-utils");
+
+  const endpoint = `${config.lmstudio.endpoint}/v1/chat/completions`;
+  const headers = {
+    "Content-Type": "application/json",
+  };
+
+  // Add API key if configured (for secured LM Studio servers)
+  if (config.lmstudio.apiKey) {
+    headers["Authorization"] = `Bearer ${config.lmstudio.apiKey}`;
+  }
+
+  // Convert messages to OpenAI format
+  const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
+
+  // Handle system message
+  if (body.system) {
+    messages.unshift({ role: "system", content: body.system });
+  }
+
+  const lmstudioBody = {
+    messages,
+    temperature: body.temperature ?? 0.7,
+    max_tokens: body.max_tokens ?? 4096,
+    top_p: body.top_p ?? 1.0,
+    stream: body.stream ?? false
+  };
+
+  // Inject standard tools if client didn't send any
+  let toolsToSend = body.tools;
+  let toolsInjected = false;
+
+  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+    toolsToSend = STANDARD_TOOLS;
+    toolsInjected = true;
+    logger.info({
+      injectedToolCount: STANDARD_TOOLS.length,
+      injectedToolNames: STANDARD_TOOLS.map(t => t.name),
+      reason: "Client did not send tools (passthrough mode)"
+    }, "=== INJECTING STANDARD TOOLS (LM Studio) ===");
+  }
+
+  if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
+    lmstudioBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
+    lmstudioBody.tool_choice = "auto";
+    logger.info({
+      toolCount: toolsToSend.length,
+      toolNames: toolsToSend.map(t => t.name),
+      toolsInjected
+    }, "=== SENDING TOOLS TO LM STUDIO ===");
+  }
+
+  logger.info({
+    endpoint,
+    hasTools: !!lmstudioBody.tools,
+    toolCount: lmstudioBody.tools?.length || 0,
+    temperature: lmstudioBody.temperature,
+    max_tokens: lmstudioBody.max_tokens,
+  }, "=== LM STUDIO REQUEST ===");
+
+  return performJsonRequest(endpoint, { headers, body: lmstudioBody }, "LM Studio");
+}
+
+async function invokeBedrock(body) {
+  // 1. Validate Bearer token
+  if (!config.bedrock?.apiKey) {
+    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."
+    );
+  }
+
+  const bearerToken = config.bedrock.apiKey;
+  logger.info({ authMethod: "Bearer Token" }, "=== BEDROCK AUTH ===");
+
+  // 2. Inject standard tools if needed
+  let toolsToSend = body.tools;
+  let toolsInjected = false;
+
+  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+    toolsToSend = STANDARD_TOOLS;
+    toolsInjected = true;
+    logger.info({
+      injectedToolCount: STANDARD_TOOLS.length,
+      injectedToolNames: STANDARD_TOOLS.map(t => t.name),
+      reason: "Client did not send tools (passthrough mode)"
+    }, "=== INJECTING STANDARD TOOLS (Bedrock) ===");
+  }
+
+  const bedrockBody = { ...body, tools: toolsToSend };
+
+  // 4. Detect model family and convert format
+  const modelId = config.bedrock.modelId;
+  const modelFamily = detectModelFamily(modelId);
+
+  logger.info({
+    modelId,
+    modelFamily,
+    hasTools: !!bedrockBody.tools,
+    toolCount: bedrockBody.tools?.length || 0,
+    streaming: body.stream || false,
+  }, "=== BEDROCK REQUEST (FETCH) ===");
+
+  // 5. Convert to Bedrock Converse API format (simpler, more universal)
+  // Bedrock Converse API only allows 'user' and 'assistant' roles in messages array
+
+  // Extract system messages from messages array (if any)
+  const systemMessages = bedrockBody.messages.filter(msg => msg.role === 'system');
+
+  const converseBody = {
+    messages: bedrockBody.messages
+      .filter(msg => msg.role !== 'system') // Filter out system messages
+      .map(msg => ({
+        role: msg.role,
+        content: Array.isArray(msg.content)
+          ? msg.content.map(c => ({ text: c.text || c.content || "" }))
+          : [{ text: msg.content }]
+      }))
+  };
+
+  // Add system prompt (from Anthropic system field OR extracted from messages)
+  if (bedrockBody.system) {
+    converseBody.system = [{ text: bedrockBody.system }];
+  } else if (systemMessages.length > 0) {
+    // If system messages were in the messages array, use the first one
+    const systemContent = Array.isArray(systemMessages[0].content)
+      ? systemMessages[0].content.map(c => c.text || c.content || "").join("\n")
+      : systemMessages[0].content;
+    converseBody.system = [{ text: systemContent }];
+  }
+
+  // Add inference config
+  if (bedrockBody.max_tokens) {
+    converseBody.inferenceConfig = {
+      maxTokens: bedrockBody.max_tokens,
+      temperature: bedrockBody.temperature,
+      topP: bedrockBody.top_p,
+    };
+  }
+
+  // Add tools if present
+  if (bedrockBody.tools && bedrockBody.tools.length > 0) {
+    converseBody.toolConfig = {
+      tools: bedrockBody.tools.map(tool => ({
+        toolSpec: {
+          name: tool.name,
+          description: tool.description,
+          inputSchema: {
+            json: tool.input_schema
+          }
+        }
+      }))
+    };
+  }
+
+  // 6. Construct Bedrock Converse API endpoint
+  const path = `/model/${modelId}/converse`;
+  const host = `bedrock-runtime.${config.bedrock.region}.amazonaws.com`;
+  const endpoint = `https://${host}${path}`;
+
+  logger.info({
+    endpoint,
+    authMethod: "Bearer Token",
+    hasSystem: !!converseBody.system,
+    hasTools: !!converseBody.toolConfig,
+    messageCount: converseBody.messages.length
+  }, "=== BEDROCK CONVERSE API REQUEST ===");
+
+  // 7. Prepare request headers with Bearer token
+  const requestHeaders = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${bearerToken}`
+  };
+
+  // 8. Make the Converse API request
+  try {
+    const response = await performJsonRequest(endpoint, {
+      headers: requestHeaders,
+      body: converseBody  // Pass object, performJsonRequest will stringify it
+    }, "Bedrock");  // Add provider label for logging
+
+    if (!response.ok) {
+      const errorText = response.text;  // Use property, not method
+      logger.error({
+        status: response.status,
+        error: errorText
+      }, "=== BEDROCK CONVERSE API ERROR ===");
+      throw new Error(`Bedrock Converse API failed: ${response.status} ${errorText}`);
+    }
+
+    // Parse Converse API response (already parsed by performJsonRequest)
+    const converseResponse = response.json;  // Use property, not method
+
+    logger.info({
+      stopReason: converseResponse.stopReason,
+      inputTokens: converseResponse.usage?.inputTokens || 0,
+      outputTokens: converseResponse.usage?.outputTokens || 0,
+      hasToolUse: !!converseResponse.output?.message?.content?.some(c => c.toolUse)
+    }, "=== BEDROCK CONVERSE API RESPONSE ===");
+
+    // Convert Converse API response to Anthropic format
+    const message = converseResponse.output.message;
+    const anthropicResponse = {
+      id: `bedrock-${Date.now()}`,
+      type: "message",
+      role: message.role,
+      model: modelId,
+      content: message.content.map(item => {
+        if (item.text) {
+          return { type: "text", text: item.text };
+        } else if (item.toolUse) {
+          return {
+            type: "tool_use",
+            id: item.toolUse.toolUseId,
+            name: item.toolUse.name,
+            input: item.toolUse.input
+          };
+        }
+        return item;
+      }),
+      stop_reason: converseResponse.stopReason === "end_turn" ? "end_turn" :
+                   converseResponse.stopReason === "tool_use" ? "tool_use" :
+                   converseResponse.stopReason === "max_tokens" ? "max_tokens" : "end_turn",
+      usage: {
+        input_tokens: converseResponse.usage?.inputTokens || 0,
+        output_tokens: converseResponse.usage?.outputTokens || 0,
+      },
+    };
+
+    return {
+      ok: true,
+      status: 200,
+      json: anthropicResponse,
+      actualProvider: "bedrock",
+      modelFamily,
+    };
+  } catch (e) {
+    logger.error({
+      error: e.message,
+      modelId,
+      region: config.bedrock.region,
+      endpoint,
+      stack: e.stack
+    }, "=== BEDROCK CONVERSE API ERROR ===");
+    throw e;
+  }
+}
+
 async function invokeModel(body, options = {}) {
   const { determineProvider, isFallbackEnabled, getFallbackProvider } = require("./routing");
   const metricsCollector = getMetricsCollector();
@@ -617,6 +878,10 @@ async function invokeModel(body, options = {}) {
         return await invokeOpenAI(body);
       } else if (initialProvider === "llamacpp") {
         return await invokeLlamaCpp(body);
+      } else if (initialProvider === "lmstudio") {
+        return await invokeLMStudio(body);
+      } else if (initialProvider === "bedrock") {
+        return await invokeBedrock(body);
       }
       return await invokeDatabricks(body);
     });