lynkr 7.2.5 → 8.0.1

package/src/clients/gpt-utils.js

@@ -0,0 +1,181 @@
+/**
+ * GPT-specific utilities for handling tool calls and responses
+ * All settings are hardcoded - no env vars required
+ *
+ * This module addresses GPT model compatibility issues when using Azure OpenAI
+ * through Lynkr proxy with Claude Code:
+ * - GPT doesn't interpret "0 files found" as a final answer
+ * - GPT retries the same tool expecting different results
+ * - GPT needs explicit guidance on tool result interpretation
+ */
+
+const logger = require("../logger");
+
+// Hardcoded GPT settings - optimized for GPT model behavior
+const GPT_SETTINGS = {
+  toolLoopThreshold: 2,        // Lower than Claude's 3 to catch loops earlier
+  enhancedFormatting: true,    // Always format results explicitly for GPT
+  similarityThreshold: 0.8,    // For detecting similar (not just identical) tool calls
+};
+
+// Provider identifiers that use GPT models
+const GPT_PROVIDERS = ['azure-openai', 'openai'];
+
+/**
+ * Check if a provider uses GPT models
+ * @param {string} provider - Provider type (e.g., 'azure-openai', 'databricks')
+ * @returns {boolean} - True if provider uses GPT models
+ */
+function isGPTProvider(provider) {
+  if (!provider) return false;
+  return GPT_PROVIDERS.includes(provider.toLowerCase());
+}
+
+/**
+ * Get the tool loop threshold for GPT models
+ * @returns {number} - Threshold (2 for GPT, lower than Claude's 3)
+ */
+function getGPTToolLoopThreshold() {
+  return GPT_SETTINGS.toolLoopThreshold;
+}
+
+/**
+ * Format tool result with explicit structure for GPT models
+ * GPT models need clear, unambiguous formatting to understand tool results
+ *
+ * @param {string} toolName - Name of the tool that was called
+ * @param {string} content - The tool result content
+ * @param {Object} args - The arguments passed to the tool
+ * @returns {string} - Formatted result with explicit status and instructions
+ */
+function formatToolResultForGPT(toolName, content, args) {
+  // Handle empty/no results explicitly - add clear messaging to prevent retries
+  const isEmpty = !content ||
+    content.trim() === '' ||
+    content.includes('0 files found') ||
+    content.includes('No matches found') ||
+    content.includes('No results') ||
+    content.includes('Found 0') ||
+    /^Found \d+ files?\.$/.test(content.trim()) && content.includes('Found 0');
+
+  if (isEmpty) {
+    // Only format empty results - add explicit "don't retry" instruction
+    return `Tool "${toolName}" completed with no results found.
+Query: ${JSON.stringify(args)}
+
+This is a FINAL result - do not retry this query. Respond to the user based on this outcome.`;
+  }
+
+  // For successful results, return content as-is (don't add markers that might confuse GPT)
+  return content;
+}
+
+/**
+ * Get system prompt addendum for GPT models
+ * This teaches GPT how to properly interpret and use tools
+ *
+ * @returns {string} - System prompt instructions for GPT
+ */
+function getGPTSystemPromptAddendum() {
+  return `Use the Bash tool with ls command for listing files. After any tool returns results, respond to the user.`;
+}
+
+/**
+ * Calculate string similarity using Jaccard index
+ * Used to detect semantically similar tool calls
+ *
+ * @param {string} s1 - First string
+ * @param {string} s2 - Second string
+ * @returns {number} - Similarity score between 0 and 1
+ */
+function stringSimilarity(s1, s2) {
+  if (!s1 || !s2) return 0;
+  if (s1 === s2) return 1;
+
+  // Tokenize by whitespace and common delimiters
+  const tokenize = (s) => new Set(
+    s.toLowerCase()
+      .split(/[\s\-_\/\.\,\:\;]+/)
+      .filter(t => t.length > 0)
+  );
+
+  const set1 = tokenize(s1);
+  const set2 = tokenize(s2);
+
+  const intersection = new Set([...set1].filter(x => set2.has(x)));
+  const union = new Set([...set1, ...set2]);
+
+  return union.size > 0 ? intersection.size / union.size : 0;
+}
+
+/**
+ * Check if two tool calls are semantically similar
+ * GPT often retries with slightly different parameters that are functionally equivalent
+ *
+ * @param {Object} call1 - First tool call {name, arguments}
+ * @param {Object} call2 - Second tool call {name, arguments}
+ * @returns {boolean} - True if calls are similar enough to be considered duplicates
+ */
+function areSimilarToolCalls(call1, call2) {
+  if (!call1 || !call2) return false;
+
+  // Must be the same tool
+  const name1 = call1.function?.name ?? call1.name;
+  const name2 = call2.function?.name ?? call2.name;
+  if (name1 !== name2) return false;
+
+  // Get arguments
+  const args1 = call1.function?.arguments ?? call1.arguments ?? call1.input ?? {};
+  const args2 = call2.function?.arguments ?? call2.arguments ?? call2.input ?? {};
+
+  // Stringify for comparison
+  const argsStr1 = typeof args1 === 'string' ? args1 : JSON.stringify(args1);
+  const argsStr2 = typeof args2 === 'string' ? args2 : JSON.stringify(args2);
+
+  // Exact match
+  if (argsStr1 === argsStr2) return true;
+
+  // For search-related tools, check semantic similarity
+  const searchTools = ['grep', 'glob', 'search', 'find', 'read', 'bash', 'shell'];
+  const toolName = (name1 || '').toLowerCase();
+  const isSearchTool = searchTools.some(t => toolName.includes(t));
+
+  if (isSearchTool) {
+    const similarity = stringSimilarity(argsStr1, argsStr2);
+    if (similarity >= GPT_SETTINGS.similarityThreshold) {
+      logger.debug({
+        tool: name1,
+        similarity,
+        threshold: GPT_SETTINGS.similarityThreshold,
+        args1: argsStr1.substring(0, 100),
+        args2: argsStr2.substring(0, 100),
+      }, "Similar tool call detected");
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Get a signature for a tool call (for tracking in history)
+ * @param {Object} call - Tool call object
+ * @returns {string} - Unique signature for the call
+ */
+function getToolCallSignature(call) {
+  const name = call.function?.name ?? call.name ?? 'unknown';
+  const args = call.function?.arguments ?? call.arguments ?? call.input ?? {};
+  const argsStr = typeof args === 'string' ? args : JSON.stringify(args);
+  return `${name}:${argsStr}`;
+}
+
+module.exports = {
+  GPT_SETTINGS,
+  isGPTProvider,
+  getGPTToolLoopThreshold,
+  formatToolResultForGPT,
+  getGPTSystemPromptAddendum,
+  stringSimilarity,
+  areSimilarToolCalls,
+  getToolCallSignature,
+};

package/src/clients/ollama-utils.js

@@ -10,12 +10,21 @@ const modelCapabilitiesCache = new Map();
 const TOOL_CAPABLE_MODELS = new Set([
   "llama3.1",
   "llama3.2",
+  "llama3.3",
   "qwen2.5",
+  "qwen3",
   "mistral",
   "mistral-nemo",
   "firefunction-v2",
   "kimi-k2.5",
-  "nemotron"
+  "nemotron",
+  "glm-4",
+  "glm-4.5",
+  "glm-4.7",
+  "glm-5",
+  "gpt-oss",
+  "minimax",
+  "deepseek-r1",
 ]);
 
 /**
@@ -55,25 +64,60 @@ async function checkOllamaToolSupport(modelName = config.ollama?.model) {
   return supportsTools;
 }
 
+// --- Endpoint detection: Anthropic (/v1/messages) vs legacy (/api/chat) ---
+
+// null = not probed yet, true = Anthropic available, false = use legacy
+let anthropicEndpointAvailable = null;
+
+/**
+ * Probe whether Ollama exposes the Anthropic-compatible /v1/messages endpoint (v0.14.0+).
+ * Result is cached for the process lifetime.
+ */
+async function hasAnthropicEndpoint(baseUrl) {
+  if (anthropicEndpointAvailable !== null) return anthropicEndpointAvailable;
+
+  try {
+    // Send a minimal request — we only care about whether the route exists
+    const res = await fetch(`${baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify({
+        model: "probe",
+        max_tokens: 1,
+        messages: [{ role: "user", content: "hi" }],
+      }),
+    });
+
+    // 404 → endpoint doesn't exist (old Ollama)
+    // Any other status (200, 400, 500) → endpoint exists
+    anthropicEndpointAvailable = res.status !== 404;
+    logger.info(
+      { available: anthropicEndpointAvailable, status: res.status },
+      anthropicEndpointAvailable
+        ? "Ollama Anthropic API detected (/v1/messages) — using native passthrough"
+        : "Ollama Anthropic API not available — falling back to legacy /api/chat (upgrade to Ollama v0.14.0+ for best results)"
+    );
+  } catch (err) {
+    // Network error — assume legacy
+    anthropicEndpointAvailable = false;
+    logger.warn({ error: err.message }, "Failed to probe Ollama Anthropic endpoint, using legacy /api/chat");
+  }
+
+  return anthropicEndpointAvailable;
+}
+
+// Exposed for tests
+function resetEndpointCache() {
+  anthropicEndpointAvailable = null;
+}
+
+// --- Legacy format conversion (for Ollama < v0.14.0 using /api/chat) ---
+
 /**
- * Convert Anthropic tool format to Ollama format
- *
- * Anthropic format:
- * {
- *   name: "get_weather",
- *   description: "Get weather",
- *   input_schema: { type: "object", properties: {...}, required: [...] }
- * }
- *
- * Ollama format:
- * {
- *   type: "function",
- *   function: {
- *     name: "get_weather",
- *     description: "Get weather",
- *     parameters: { type: "object", properties: {...}, required: [...] }
- *   }
- * }
+ * Convert Anthropic tool format to Ollama/OpenAI function-calling format
  */
 function convertAnthropicToolsToOllama(anthropicTools) {
   if (!Array.isArray(anthropicTools) || anthropicTools.length === 0) {
@@ -93,128 +137,10 @@ function convertAnthropicToolsToOllama(anthropicTools) {
   }));
 }
 
-/**
- * Convert Ollama tool call response to Anthropic format
- *
- * Ollama format (actual):
- * {
- *   message: {
- *     role: "assistant",
- *     content: "",
- *     tool_calls: [{
- *       function: {
- *         name: "get_weather",
- *         arguments: { location: "SF" }  // Already parsed object
- *       }
- *     }]
- *   }
- * }
- *
- * Anthropic format:
- * {
- *   content: [{
- *     type: "tool_use",
- *     id: "toolu_123",
- *     name: "get_weather",
- *     input: { location: "SF" }
- *   }],
- *   stop_reason: "tool_use"
- * }
- */
-function convertOllamaToolCallsToAnthropic(ollamaResponse) {
-  const message = ollamaResponse?.message || {};
-  const toolCalls = message.tool_calls || [];
-  const textContent = message.content || "";
-
-  const contentBlocks = [];
-
-  // Add text content if present
-  if (textContent && textContent.trim()) {
-    contentBlocks.push({
-      type: "text",
-      text: textContent,
-    });
-  }
-
-  // Add tool calls
-  for (const toolCall of toolCalls) {
-    const func = toolCall.function || {};
-    let input = {};
-
-    // Handle arguments - can be string JSON or already parsed object
-    if (func.arguments) {
-      if (typeof func.arguments === "string") {
-        try {
-          input = JSON.parse(func.arguments);
-        } catch (err) {
-          logger.warn({
-            error: err.message,
-            arguments: func.arguments
-          }, "Failed to parse Ollama tool arguments string");
-          input = {};
-        }
-      } else if (typeof func.arguments === "object") {
-        // Already an object, use directly
-        input = func.arguments;
-      }
-    }
-
-    // Generate tool use ID (Ollama may or may not provide one)
-    const toolUseId = toolCall.id || `toolu_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-
-    contentBlocks.push({
-      type: "tool_use",
-      id: toolUseId,
-      name: func.name || "unknown",
-      input,
-    });
-  }
-
-  // Determine stop reason
-  const stopReason = toolCalls.length > 0 ? "tool_use" : "end_turn";
-
-  return {
-    contentBlocks,
-    stopReason,
-  };
-}
-
-/**
- * Build complete Anthropic response from Ollama with tool calls
- */
-function buildAnthropicResponseFromOllama(ollamaResponse, requestedModel) {
-  const { contentBlocks, stopReason } = convertOllamaToolCallsToAnthropic(ollamaResponse);
-
-  // Ensure at least one content block
-  const finalContent = contentBlocks.length > 0
-    ? contentBlocks
-    : [{ type: "text", text: "" }];
-
-  // Extract token counts
-  const inputTokens = ollamaResponse.prompt_eval_count || 0;
-  const outputTokens = ollamaResponse.eval_count || 0;
-
-  return {
-    id: `msg_${Date.now()}`,
-    type: "message",
-    role: "assistant",
-    model: requestedModel,
-    content: finalContent,
-    stop_reason: stopReason,
-    stop_sequence: null,
-    usage: {
-      input_tokens: inputTokens,
-      output_tokens: outputTokens,
-      cache_creation_input_tokens: 0,
-      cache_read_input_tokens: 0,
-    },
-  };
-}
-
 module.exports = {
   checkOllamaToolSupport,
-  convertAnthropicToolsToOllama,
-  convertOllamaToolCallsToAnthropic,
-  buildAnthropicResponseFromOllama,
   modelNameSupportsTools,
+  hasAnthropicEndpoint,
+  resetEndpointCache,
+  convertAnthropicToolsToOllama,
 };

package/src/clients/routing.js

@@ -14,7 +14,6 @@ const smartRouting = require('../routing');
 
 // Re-export all functions from smart routing
 module.exports = {
-  determineProvider: smartRouting.determineProvider,
   determineProviderSmart: smartRouting.determineProviderSmart,
   isFallbackEnabled: smartRouting.isFallbackEnabled,
   getFallbackProvider: smartRouting.getFallbackProvider,

package/src/clients/standard-tools.js

@@ -76,7 +76,7 @@ const STANDARD_TOOLS = [
   },
   {
     name: "Bash",
-    description: "Executes a bash command in a persistent shell session. Use for terminal operations like git, npm, docker, etc. DO NOT use for file operations - use specialized tools instead.",
+    description: "Executes a bash command in a persistent shell session. Use for terminal operations like git, npm, docker, listing files (ls), etc. PREFERRED for listing directory contents - use 'ls' command. DO NOT use for reading file contents - use Read tool instead.",
     input_schema: {
       type: "object",
       properties: {
@@ -98,7 +98,7 @@ const STANDARD_TOOLS = [
   },
   {
     name: "Glob",
-    description: "Fast file pattern matching tool. Supports glob patterns like '**/*.js' or 'src/**/*.ts'. Returns matching file paths sorted by modification time.",
+    description: "File pattern matching for finding files by name pattern. Use ONLY when you need to find files matching a specific pattern like '**/*.js'. For simple directory listing, use Bash with 'ls' instead.",
     input_schema: {
       type: "object",
       properties: {
@@ -145,6 +145,66 @@ const STANDARD_TOOLS = [
       required: ["pattern"]
     }
   },
+  {
+    name: "MultiEdit",
+    description: "Makes multiple edits to a single file in one atomic operation. More efficient than calling Edit multiple times. Each edit is an exact string replacement.",
+    input_schema: {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Relative path within workspace. DO NOT use absolute paths."
+        },
+        edits: {
+          type: "array",
+          description: "Array of edits to apply to the file",
+          items: {
+            type: "object",
+            properties: {
+              old_string: {
+                type: "string",
+                description: "The text to replace"
+              },
+              new_string: {
+                type: "string",
+                description: "The text to replace it with"
+              }
+            },
+            required: ["old_string", "new_string"]
+          }
+        }
+      },
+      required: ["file_path", "edits"]
+    }
+  },
+  {
+    name: "LS",
+    description: "Lists files and directories in a given path. Returns a structured listing with file types and sizes. Use for quick directory overview.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "The directory to list. Defaults to current working directory."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "NotebookRead",
+    description: "Reads and displays the contents of a Jupyter notebook (.ipynb file), including all cells with their outputs, combining code, text, and visualizations.",
+    input_schema: {
+      type: "object",
+      properties: {
+        notebook_path: {
+          type: "string",
+          description: "Relative path to the Jupyter notebook (e.g., 'analysis.ipynb'). DO NOT use absolute paths."
+        }
+      },
+      required: ["notebook_path"]
+    }
+  },
   {
     name: "TodoWrite",
     description: "Create and manage a structured task list for tracking progress and organizing complex tasks. Use proactively for multi-step tasks or when user provides multiple tasks.",
@@ -320,6 +380,29 @@ EXAMPLE: User says "explore this project" → Call Task with subagent_type="Expl
       required: ["url", "prompt"]
     }
   },
+  {
+    name: "WebAgent",
+    description: "Launches a browser agent to navigate a website and accomplish a goal. Use when you need to interact with dynamic web content (click buttons, fill forms, extract data from JS-rendered pages) beyond what a simple HTTP fetch can do. Returns structured JSON. Takes 10-60 seconds.",
+    input_schema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "Target URL to navigate to"
+        },
+        goal: {
+          type: "string",
+          description: "What to accomplish on the page. Be specific about what data to extract or actions to take."
+        },
+        browser_profile: {
+          type: "string",
+          enum: ["lite", "stealth"],
+          description: "lite (default, faster) or stealth (for bot-protected sites)"
+        }
+      },
+      required: ["url", "goal"]
+    }
+  },
   {
     name: "NotebookEdit",
     description: "Completely replaces the contents of a specific cell in a Jupyter notebook (.ipynb file). Use for editing interactive documents that combine code, text, and visualizations.",
@@ -354,4 +437,17 @@ EXAMPLE: User says "explore this project" → Call Task with subagent_type="Expl
   }
 ];
 
-module.exports = { STANDARD_TOOLS };
+// Pre-computed name list to avoid re-mapping on every log call
+const STANDARD_TOOL_NAMES = STANDARD_TOOLS.map(t => t.name);
+
+// Tools that cannot work through a proxy (require bidirectional user interaction).
+// All other tools are safe — per-client filtering via CLIENT_TOOL_MAPPINGS in
+// openai-router.js handles excluding tools that specific clients don't support
+// (e.g. Codex has no equivalent for Task, WebFetch, NotebookEdit).
+const IDE_UNSUPPORTED_TOOLS = new Set(['AskUserQuestion']);
+
+// Filtered tool set for IDE clients — excludes tools with no IDE equivalent
+const IDE_SAFE_TOOLS = STANDARD_TOOLS.filter(t => !IDE_UNSUPPORTED_TOOLS.has(t.name));
+const IDE_SAFE_TOOL_NAMES = IDE_SAFE_TOOLS.map(t => t.name);
+
+module.exports = { STANDARD_TOOLS, STANDARD_TOOL_NAMES, IDE_SAFE_TOOLS, IDE_SAFE_TOOL_NAMES, IDE_UNSUPPORTED_TOOLS };