lynkr 1.0.0 → 2.0.0

package/src/clients/standard-tools.js

@@ -0,0 +1,341 @@
+/**
+ * Standard tool definitions for Claude Code
+ * These tools are injected when the client doesn't send tools in passthrough mode
+ */
+
+const STANDARD_TOOLS = [
+  {
+    name: "Write",
+    description: "Writes a file to the local filesystem. Overwrites existing files. ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.",
+    input_schema: {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "The absolute path to the file to write (must be absolute, not relative)"
+        },
+        content: {
+          type: "string",
+          description: "The content to write to the file"
+        }
+      },
+      required: ["file_path", "content"]
+    }
+  },
+  {
+    name: "Read",
+    description: "Reads a file from the local filesystem. You can access any file directly by using this tool.",
+    input_schema: {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "The absolute path to the file to read"
+        },
+        limit: {
+          type: "number",
+          description: "The number of lines to read. Only provide if the file is too large to read at once."
+        },
+        offset: {
+          type: "number",
+          description: "The line number to start reading from. Only provide if the file is too large to read at once"
+        }
+      },
+      required: ["file_path"]
+    }
+  },
+  {
+    name: "Edit",
+    description: "Performs exact string replacements in files. You must use your Read tool at least once before editing. The edit will FAIL if old_string is not unique in the file.",
+    input_schema: {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "The absolute path to the file to modify"
+        },
+        old_string: {
+          type: "string",
+          description: "The text to replace"
+        },
+        new_string: {
+          type: "string",
+          description: "The text to replace it with (must be different from old_string)"
+        },
+        replace_all: {
+          type: "boolean",
+          description: "Replace all occurences of old_string (default false)"
+        }
+      },
+      required: ["file_path", "old_string", "new_string"]
+    }
+  },
+  {
+    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.",
+    input_schema: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The command to execute"
+        },
+        description: {
+          type: "string",
+          description: "Clear, concise description of what this command does in 5-10 words"
+        },
+        timeout: {
+          type: "number",
+          description: "Optional timeout in milliseconds (max 600000)"
+        }
+      },
+      required: ["command"]
+    }
+  },
+  {
+    name: "Glob",
+    description: "Fast file pattern matching tool. Supports glob patterns like '**/*.js' or 'src/**/*.ts'. Returns matching file paths sorted by modification time.",
+    input_schema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "The glob pattern to match files against"
+        },
+        path: {
+          type: "string",
+          description: "The directory to search in. If not specified, the current working directory will be used."
+        }
+      },
+      required: ["pattern"]
+    }
+  },
+  {
+    name: "Grep",
+    description: "A powerful search tool built on ripgrep. Supports full regex syntax. Filter files with glob parameter or type parameter.",
+    input_schema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "The regular expression pattern to search for in file contents"
+        },
+        path: {
+          type: "string",
+          description: "File or directory to search in. Defaults to current working directory."
+        },
+        glob: {
+          type: "string",
+          description: "Glob pattern to filter files (e.g. '*.js', '*.{ts,tsx}')"
+        },
+        output_mode: {
+          type: "string",
+          enum: ["content", "files_with_matches", "count"],
+          description: "Output mode: 'content' shows matching lines, 'files_with_matches' shows file paths, 'count' shows match counts"
+        },
+        "-i": {
+          type: "boolean",
+          description: "Case insensitive search"
+        }
+      },
+      required: ["pattern"]
+    }
+  },
+  {
+    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.",
+    input_schema: {
+      type: "object",
+      properties: {
+        todos: {
+          type: "array",
+          description: "Array of todo items with status tracking",
+          items: {
+            type: "object",
+            properties: {
+              content: {
+                type: "string",
+                description: "Task description in imperative form (e.g., 'Run tests', 'Build project')"
+              },
+              status: {
+                type: "string",
+                enum: ["pending", "in_progress", "completed"],
+                description: "Task status: pending (not started), in_progress (currently working), completed (finished)"
+              },
+              activeForm: {
+                type: "string",
+                description: "Present continuous form shown during execution (e.g., 'Running tests', 'Building project')"
+              }
+            },
+            required: ["content", "status", "activeForm"]
+          }
+        }
+      },
+      required: ["todos"]
+    }
+  },
+  {
+    name: "Task",
+    description: "Launch specialized agents for complex multi-step tasks. Available agents: general-purpose (complex tasks), Explore (codebase exploration), Plan (implementation planning), claude-code-guide (Claude Code documentation).",
+    input_schema: {
+      type: "object",
+      properties: {
+        description: {
+          type: "string",
+          description: "A short (3-5 word) description of the task"
+        },
+        prompt: {
+          type: "string",
+          description: "The detailed task for the agent to perform"
+        },
+        subagent_type: {
+          type: "string",
+          enum: ["general-purpose", "Explore", "Plan", "claude-code-guide"],
+          description: "The type of specialized agent to use"
+        },
+        model: {
+          type: "string",
+          enum: ["sonnet", "opus", "haiku"],
+          description: "Optional model to use (haiku for quick tasks, sonnet for balanced, opus for complex)"
+        }
+      },
+      required: ["description", "prompt", "subagent_type"]
+    }
+  },
+  {
+    name: "AskUserQuestion",
+    description: "Ask the user questions to gather preferences, clarify requirements, or get decisions on implementation choices. Supports multiple choice questions.",
+    input_schema: {
+      type: "object",
+      properties: {
+        questions: {
+          type: "array",
+          description: "Questions to ask the user (1-4 questions)",
+          minItems: 1,
+          maxItems: 4,
+          items: {
+            type: "object",
+            properties: {
+              question: {
+                type: "string",
+                description: "The complete question to ask. Should be clear, specific, and end with a question mark."
+              },
+              header: {
+                type: "string",
+                description: "Very short label (max 12 chars). Examples: 'Auth method', 'Library', 'Approach'"
+              },
+              options: {
+                type: "array",
+                description: "Available choices (2-4 options). Each should be distinct and mutually exclusive.",
+                minItems: 2,
+                maxItems: 4,
+                items: {
+                  type: "object",
+                  properties: {
+                    label: {
+                      type: "string",
+                      description: "Display text for this option (1-5 words)"
+                    },
+                    description: {
+                      type: "string",
+                      description: "Explanation of what this option means or implications"
+                    }
+                  },
+                  required: ["label", "description"]
+                }
+              },
+              multiSelect: {
+                type: "boolean",
+                description: "Set to true to allow multiple selections instead of just one"
+              }
+            },
+            required: ["question", "header", "options", "multiSelect"]
+          }
+        }
+      },
+      required: ["questions"]
+    }
+  },
+  {
+    name: "WebSearch",
+    description: "Search the web for current information beyond the model's knowledge cutoff. Returns search results that can inform responses. Always include sources in your response.",
+    input_schema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query to use",
+          minLength: 2
+        },
+        allowed_domains: {
+          type: "array",
+          description: "Only include search results from these domains",
+          items: {
+            type: "string"
+          }
+        },
+        blocked_domains: {
+          type: "array",
+          description: "Never include search results from these domains",
+          items: {
+            type: "string"
+          }
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "WebFetch",
+    description: "Fetches content from a specified URL and processes it using AI. Takes a URL and a prompt describing what information to extract from the page.",
+    input_schema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch content from (must be fully-formed valid URL)",
+          format: "uri"
+        },
+        prompt: {
+          type: "string",
+          description: "The prompt describing what information you want to extract from the page"
+        }
+      },
+      required: ["url", "prompt"]
+    }
+  },
+  {
+    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.",
+    input_schema: {
+      type: "object",
+      properties: {
+        notebook_path: {
+          type: "string",
+          description: "The absolute path to the Jupyter notebook file to edit"
+        },
+        new_source: {
+          type: "string",
+          description: "The new source for the cell"
+        },
+        cell_id: {
+          type: "string",
+          description: "The ID of the cell to edit. When inserting, new cell will be inserted after this cell."
+        },
+        cell_type: {
+          type: "string",
+          enum: ["code", "markdown"],
+          description: "The type of the cell. Required when using edit_mode=insert."
+        },
+        edit_mode: {
+          type: "string",
+          enum: ["replace", "insert", "delete"],
+          description: "The type of edit to make. Defaults to replace."
+        }
+      },
+      required: ["notebook_path", "new_source"]
+    }
+  }
+];
+
+module.exports = { STANDARD_TOOLS };

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"]);
+const SUPPORTED_MODEL_PROVIDERS = new Set(["databricks", "azure-anthropic", "ollama", "openrouter", "azure-openai"]);
 const rawModelProvider = (process.env.MODEL_PROVIDER ?? "databricks").toLowerCase();
 const modelProvider = SUPPORTED_MODEL_PROVIDERS.has(rawModelProvider)
   ? rawModelProvider
@@ -84,6 +84,13 @@ const openRouterApiKey = process.env.OPENROUTER_API_KEY ?? null;
 const openRouterModel = process.env.OPENROUTER_MODEL ?? "openai/gpt-4o-mini";
 const openRouterEndpoint = process.env.OPENROUTER_ENDPOINT ?? "https://openrouter.ai/api/v1/chat/completions";
 
+// Azure OpenAI configuration
+const azureOpenAIEndpoint = process.env.AZURE_OPENAI_ENDPOINT?.trim() || null;
+const azureOpenAIApiKey = process.env.AZURE_OPENAI_API_KEY?.trim() || null;
+const azureOpenAIDeployment = process.env.AZURE_OPENAI_DEPLOYMENT?.trim() || "gpt-4o";
+const azureOpenAIApiVersion = process.env.AZURE_OPENAI_API_VERSION?.trim() || "2024-08-01-preview";
+
+
 // Hybrid routing configuration
 const preferOllama = process.env.PREFER_OLLAMA === "true";
 const fallbackEnabled = process.env.FALLBACK_ENABLED !== "false"; // default true
@@ -108,8 +115,8 @@ if (!["server", "client", "passthrough"].includes(toolExecutionMode)) {
 // Only require Databricks credentials if it's the primary provider or used as fallback
 if (modelProvider === "databricks" && (!rawBaseUrl || !apiKey)) {
   throw new Error("Set DATABRICKS_API_BASE and DATABRICKS_API_KEY before starting the proxy.");
-} else if (modelProvider === "ollama" && fallbackEnabled && fallbackProvider === "databricks" && (!rawBaseUrl || !apiKey)) {
-  // Relaxed: Allow mock credentials for Ollama-only testing
+} else if (modelProvider === "ollama" && !fallbackEnabled && (!rawBaseUrl || !apiKey)) {
+  // Relaxed: Allow mock credentials for true Ollama-only mode (fallback disabled)
   if (!rawBaseUrl) process.env.DATABRICKS_API_BASE = "http://localhost:8080";
   if (!apiKey) process.env.DATABRICKS_API_KEY = "mock-key-for-ollama-only";
   console.log("[CONFIG] Using mock Databricks credentials (Ollama-only mode with fallback disabled)");
@@ -121,6 +128,12 @@ if (modelProvider === "azure-anthropic" && (!azureAnthropicEndpoint || !azureAnt
   );
 }
 
+if (modelProvider === "azure-openai" && (!azureOpenAIEndpoint || !azureOpenAIApiKey)) {
+  throw new Error(
+    "Set AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY before starting the proxy.",
+  );
+}
+
 if (modelProvider === "ollama") {
   try {
     new URL(ollamaEndpoint);
@@ -146,10 +159,13 @@ if (preferOllama) {
   // Ensure fallback provider is properly configured (only if fallback is enabled)
   if (fallbackEnabled) {
     if (fallbackProvider === "databricks" && (!rawBaseUrl || !apiKey)) {
-      console.warn("[CONFIG WARNING] Databricks fallback configured but credentials missing. Fallback will fail if needed.");
+      throw new Error("FALLBACK_PROVIDER is set to 'databricks' but DATABRICKS_API_BASE and DATABRICKS_API_KEY are not configured. Please set these environment variables or choose a different fallback provider.");
     }
     if (fallbackProvider === "azure-anthropic" && (!azureAnthropicEndpoint || !azureAnthropicApiKey)) {
-      console.warn("[CONFIG WARNING] Azure Anthropic fallback configured but credentials missing. Fallback will fail if needed.");
+      throw new Error("FALLBACK_PROVIDER is set to 'azure-anthropic' but AZURE_ANTHROPIC_ENDPOINT and AZURE_ANTHROPIC_API_KEY are not configured. Please set these environment variables or choose a different fallback provider.");
+    }
+    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.");
     }
   }
 }
@@ -300,6 +316,13 @@ if (testCoverageFiles.length === 0) {
 }
 const testProfiles = parseJson(process.env.WORKSPACE_TEST_PROFILES ?? "", null);
 
+// Agents configuration
+const agentsEnabled = process.env.AGENTS_ENABLED === "true";
+const agentsMaxConcurrent = Number.parseInt(process.env.AGENTS_MAX_CONCURRENT ?? "10", 10);
+const agentsDefaultModel = process.env.AGENTS_DEFAULT_MODEL ?? "haiku";
+const agentsMaxSteps = Number.parseInt(process.env.AGENTS_MAX_STEPS ?? "15", 10);
+const agentsTimeout = Number.parseInt(process.env.AGENTS_TIMEOUT ?? "120000", 10);
+
 const config = {
   env: process.env.NODE_ENV ?? "development",
   port: Number.isNaN(port) ? 8080 : port,
@@ -324,6 +347,12 @@ const config = {
     model: openRouterModel,
     endpoint: openRouterEndpoint,
   },
+  azureOpenAI: {
+    endpoint: azureOpenAIEndpoint,
+    apiKey: azureOpenAIApiKey,
+    deployment: azureOpenAIDeployment,
+    apiVersion: azureOpenAIApiVersion
+  },
   modelProvider: {
     type: modelProvider,
     defaultModel,
@@ -426,6 +455,13 @@ const config = {
     maxEntries: Number.isNaN(promptCacheMaxEntriesRaw) ? 64 : promptCacheMaxEntriesRaw,
     ttlMs: Number.isNaN(promptCacheTtlRaw) ? 300000 : promptCacheTtlRaw,
   },
+  agents: {
+    enabled: agentsEnabled,
+    maxConcurrent: Number.isNaN(agentsMaxConcurrent) ? 10 : agentsMaxConcurrent,
+    defaultModel: agentsDefaultModel,
+    maxSteps: Number.isNaN(agentsMaxSteps) ? 15 : agentsMaxSteps,
+    timeout: Number.isNaN(agentsTimeout) ? 120000 : agentsTimeout,
+  },
   tests: {
     defaultCommand: testDefaultCommand ? testDefaultCommand.trim() : null,
     defaultArgs: testDefaultArgs,