lynkr 3.2.1 → 4.0.0

package/src/clients/openai-format.js

@@ -0,0 +1,393 @@
+/**
+ * OpenAI ↔ Anthropic Format Conversion Utilities
+ *
+ * Converts between OpenAI's /v1/chat/completions format and Anthropic's /v1/messages format.
+ * Used for Cursor IDE compatibility.
+ *
+ * @module clients/openai-format
+ */
+
+const logger = require("../logger");
+
+/**
+ * Convert OpenAI chat completion request to Anthropic messages format
+ * @param {Object} openaiRequest - OpenAI format request
+ * @returns {Object} Anthropic format request
+ */
+function convertOpenAIToAnthropic(openaiRequest) {
+  const { messages, model, temperature, max_tokens, top_p, stream, tools, tool_choice } = openaiRequest;
+
+  // Extract system message if present
+  let system = null;
+  const anthropicMessages = [];
+
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      // Anthropic uses a separate system field
+      system = msg.content;
+    } else if (msg.role === "user" || msg.role === "assistant") {
+      // Convert content format
+      let content;
+      if (typeof msg.content === "string") {
+        content = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        // OpenAI content parts format
+        content = msg.content.map(part => {
+          if (part.type === "text") {
+            return { type: "text", text: part.text };
+          } else if (part.type === "image_url") {
+            return {
+              type: "image",
+              source: {
+                type: "url",
+                url: part.image_url.url
+              }
+            };
+          }
+          return part;
+        });
+      }
+
+      // Handle tool calls in assistant messages (OpenAI format)
+      if (msg.role === "assistant" && msg.tool_calls) {
+        // Convert OpenAI tool_calls to Anthropic tool_use blocks
+        const contentBlocks = [];
+
+        // Add text content if present
+        if (msg.content) {
+          contentBlocks.push({ type: "text", text: msg.content });
+        }
+
+        // Add tool use blocks
+        for (const toolCall of msg.tool_calls) {
+          contentBlocks.push({
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.function.name,
+            input: JSON.parse(toolCall.function.arguments)
+          });
+        }
+
+        anthropicMessages.push({
+          role: "assistant",
+          content: contentBlocks
+        });
+      } else {
+        anthropicMessages.push({
+          role: msg.role,
+          content
+        });
+      }
+    } else if (msg.role === "tool") {
+      // OpenAI tool response → Anthropic tool_result
+      const previousMsg = anthropicMessages[anthropicMessages.length - 1];
+
+      // Tool results must follow assistant message with tool_use
+      // Add as separate user message with tool_result
+      anthropicMessages.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: msg.tool_call_id,
+            content: msg.content
+          }
+        ]
+      });
+    }
+  }
+
+  // Convert tools format (OpenAI → Anthropic)
+  let anthropicTools = null;
+  if (tools && tools.length > 0) {
+    anthropicTools = tools.map(tool => ({
+      name: tool.function.name,
+      description: tool.function.description || "",
+      input_schema: tool.function.parameters || {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    }));
+  }
+
+  // Build Anthropic request
+  const anthropicRequest = {
+    model: model || "claude-3-5-sonnet-20241022",
+    messages: anthropicMessages,
+    max_tokens: max_tokens || 4096,
+    stream: stream || false
+  };
+
+  if (system) {
+    anthropicRequest.system = system;
+  }
+
+  if (temperature !== undefined) {
+    anthropicRequest.temperature = temperature;
+  }
+
+  if (top_p !== undefined) {
+    anthropicRequest.top_p = top_p;
+  }
+
+  if (anthropicTools) {
+    anthropicRequest.tools = anthropicTools;
+  }
+
+  // Handle tool_choice
+  if (tool_choice) {
+    if (tool_choice === "auto") {
+      anthropicRequest.tool_choice = { type: "auto" };
+    } else if (tool_choice === "none") {
+      anthropicRequest.tool_choice = { type: "none" };
+    } else if (typeof tool_choice === "object" && tool_choice.function) {
+      anthropicRequest.tool_choice = {
+        type: "tool",
+        name: tool_choice.function.name
+      };
+    }
+  }
+
+  logger.debug({
+    openaiMessageCount: messages.length,
+    anthropicMessageCount: anthropicMessages.length,
+    hasSystem: !!system,
+    hasTools: !!anthropicTools,
+    toolCount: anthropicTools?.length || 0
+  }, "Converted OpenAI request to Anthropic format");
+
+  return anthropicRequest;
+}
+
+/**
+ * Convert Anthropic messages response to OpenAI chat completion format
+ * @param {Object} anthropicResponse - Anthropic format response
+ * @param {string} model - Model name to include in response
+ * @returns {Object} OpenAI format response
+ */
+function convertAnthropicToOpenAI(anthropicResponse, model = "claude-3-5-sonnet-20241022") {
+  const { id, content, stop_reason, usage } = anthropicResponse;
+
+  // Convert content blocks to OpenAI format
+  let messageContent = "";
+  const toolCalls = [];
+
+  for (const block of content) {
+    if (block.type === "text") {
+      messageContent += block.text;
+    } else if (block.type === "tool_use") {
+      toolCalls.push({
+        id: block.id,
+        type: "function",
+        function: {
+          name: block.name,
+          arguments: JSON.stringify(block.input)
+        }
+      });
+    }
+  }
+
+  // Build OpenAI response
+  const openaiResponse = {
+    id: id || `chatcmpl-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model: model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: messageContent || null
+        },
+        finish_reason: mapStopReason(stop_reason)
+      }
+    ],
+    usage: {
+      prompt_tokens: usage?.input_tokens || 0,
+      completion_tokens: usage?.output_tokens || 0,
+      total_tokens: (usage?.input_tokens || 0) + (usage?.output_tokens || 0)
+    }
+  };
+
+  // Add tool_calls if present
+  if (toolCalls.length > 0) {
+    openaiResponse.choices[0].message.tool_calls = toolCalls;
+    openaiResponse.choices[0].finish_reason = "tool_calls";
+  }
+
+  logger.debug({
+    anthropicStopReason: stop_reason,
+    openaiFinishReason: openaiResponse.choices[0].finish_reason,
+    hasToolCalls: toolCalls.length > 0,
+    messageLength: messageContent.length
+  }, "Converted Anthropic response to OpenAI format");
+
+  return openaiResponse;
+}
+
+/**
+ * Convert Anthropic streaming chunk to OpenAI streaming format
+ * @param {Object} chunk - Anthropic SSE event
+ * @param {string} model - Model name
+ * @returns {string} OpenAI format SSE line (data: {...})
+ */
+function convertAnthropicStreamChunkToOpenAI(chunk, model = "claude-3-5-sonnet-20241022") {
+  const eventType = chunk.type;
+
+  if (eventType === "message_start") {
+    // Initial message metadata
+    return {
+      id: chunk.message?.id || `chatcmpl-${Date.now()}`,
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1000),
+      model: model,
+      choices: [
+        {
+          index: 0,
+          delta: { role: "assistant", content: "" },
+          finish_reason: null
+        }
+      ]
+    };
+  } else if (eventType === "content_block_start") {
+    // Start of content block (text or tool_use)
+    const contentBlock = chunk.content_block;
+
+    if (contentBlock?.type === "tool_use") {
+      return {
+        id: `chatcmpl-${Date.now()}`,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model: model,
+        choices: [
+          {
+            index: 0,
+            delta: {
+              tool_calls: [
+                {
+                  index: chunk.index,
+                  id: contentBlock.id,
+                  type: "function",
+                  function: {
+                    name: contentBlock.name,
+                    arguments: ""
+                  }
+                }
+              ]
+            },
+            finish_reason: null
+          }
+        ]
+      };
+    }
+  } else if (eventType === "content_block_delta") {
+    // Incremental content
+    const delta = chunk.delta;
+
+    if (delta?.type === "text_delta") {
+      return {
+        id: `chatcmpl-${Date.now()}`,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model: model,
+        choices: [
+          {
+            index: 0,
+            delta: { content: delta.text },
+            finish_reason: null
+          }
+        ]
+      };
+    } else if (delta?.type === "input_json_delta") {
+      // Tool call arguments streaming
+      return {
+        id: `chatcmpl-${Date.now()}`,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model: model,
+        choices: [
+          {
+            index: 0,
+            delta: {
+              tool_calls: [
+                {
+                  index: chunk.index,
+                  function: {
+                    arguments: delta.partial_json
+                  }
+                }
+              ]
+            },
+            finish_reason: null
+          }
+        ]
+      };
+    }
+  } else if (eventType === "message_delta") {
+    // Final message metadata (stop reason, usage)
+    const stopReason = chunk.delta?.stop_reason;
+    const usage = chunk.usage;
+
+    return {
+      id: `chatcmpl-${Date.now()}`,
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1000),
+      model: model,
+      choices: [
+        {
+          index: 0,
+          delta: {},
+          finish_reason: mapStopReason(stopReason)
+        }
+      ],
+      usage: usage ? {
+        prompt_tokens: 0, // Not available in streaming
+        completion_tokens: usage.output_tokens || 0,
+        total_tokens: usage.output_tokens || 0
+      } : undefined
+    };
+  } else if (eventType === "message_stop") {
+    // End of stream
+    return {
+      id: `chatcmpl-${Date.now()}`,
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1000),
+      model: model,
+      choices: [
+        {
+          index: 0,
+          delta: {},
+          finish_reason: "stop"
+        }
+      ]
+    };
+  }
+
+  // Unknown event type, return empty chunk
+  return null;
+}
+
+/**
+ * Map Anthropic stop_reason to OpenAI finish_reason
+ * @param {string} stopReason - Anthropic stop reason
+ * @returns {string} OpenAI finish reason
+ */
+function mapStopReason(stopReason) {
+  const mapping = {
+    "end_turn": "stop",
+    "max_tokens": "length",
+    "stop_sequence": "stop",
+    "tool_use": "tool_calls"
+  };
+
+  return mapping[stopReason] || "stop";
+}
+
+module.exports = {
+  convertOpenAIToAnthropic,
+  convertAnthropicToOpenAI,
+  convertAnthropicStreamChunkToOpenAI,
+  mapStopReason
+};

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
@@ -78,10 +78,13 @@ const azureAnthropicVersion = process.env.AZURE_ANTHROPIC_VERSION ?? "2023-06-01
 const ollamaEndpoint = process.env.OLLAMA_ENDPOINT ?? "http://localhost:11434";
 const ollamaModel = process.env.OLLAMA_MODEL ?? "qwen2.5-coder:7b";
 const ollamaTimeout = Number.parseInt(process.env.OLLAMA_TIMEOUT_MS ?? "120000", 10);
+const ollamaEmbeddingsEndpoint = process.env.OLLAMA_EMBEDDINGS_ENDPOINT ?? `${ollamaEndpoint}/api/embeddings`;
+const ollamaEmbeddingsModel = process.env.OLLAMA_EMBEDDINGS_MODEL ?? "nomic-embed-text";
 
 // OpenRouter configuration
 const openRouterApiKey = process.env.OPENROUTER_API_KEY ?? null;
 const openRouterModel = process.env.OPENROUTER_MODEL ?? "openai/gpt-4o-mini";
+const openRouterEmbeddingsModel = process.env.OPENROUTER_EMBEDDINGS_MODEL ?? "openai/text-embedding-ada-002";
 const openRouterEndpoint = process.env.OPENROUTER_ENDPOINT ?? "https://openrouter.ai/api/v1/chat/completions";
 
 // Azure OpenAI configuration
@@ -101,6 +104,18 @@ const llamacppEndpoint = process.env.LLAMACPP_ENDPOINT?.trim() || "http://localh
 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;
+const llamacppEmbeddingsEndpoint = process.env.LLAMACPP_EMBEDDINGS_ENDPOINT?.trim() || `${llamacppEndpoint}/embeddings`;
+
+// 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";
@@ -201,6 +216,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 +242,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 +260,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.");
+    }
   }
 }
 
@@ -400,10 +437,13 @@ const config = {
     endpoint: ollamaEndpoint,
     model: ollamaModel,
     timeout: Number.isNaN(ollamaTimeout) ? 120000 : ollamaTimeout,
+    embeddingsEndpoint: ollamaEmbeddingsEndpoint,
+    embeddingsModel: ollamaEmbeddingsModel,
   },
   openrouter: {
     apiKey: openRouterApiKey,
     model: openRouterModel,
+    embeddingsModel: openRouterEmbeddingsModel,
     endpoint: openRouterEndpoint,
   },
   azureOpenAI: {
@@ -423,6 +463,18 @@ const config = {
     model: llamacppModel,
     timeout: Number.isNaN(llamacppTimeout) ? 120000 : llamacppTimeout,
     apiKey: llamacppApiKey,
+    embeddingsEndpoint: llamacppEmbeddingsEndpoint,
+  },
+  lmstudio: {
+    endpoint: lmstudioEndpoint,
+    model: lmstudioModel,
+    timeout: Number.isNaN(lmstudioTimeout) ? 120000 : lmstudioTimeout,
+    apiKey: lmstudioApiKey,
+  },
+  bedrock: {
+    region: bedrockRegion,
+    apiKey: bedrockApiKey,
+    modelId: bedrockModelId,
   },
   modelProvider: {
     type: modelProvider,

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;