lynkr 1.0.0 → 2.0.0

package/src/agents/store.js

@@ -0,0 +1,244 @@
+const Database = require("better-sqlite3");
+const path = require("path");
+const fs = require("fs");
+const logger = require("../logger");
+
+class AgentStore {
+  constructor() {
+    // Use same database location as main app
+    const dbDir = path.join(process.cwd(), "data");
+    if (!fs.existsSync(dbDir)) {
+      fs.mkdirSync(dbDir, { recursive: true });
+    }
+
+    const dbPath = path.join(dbDir, "lynkr.db");
+    this.db = new Database(dbPath, {
+      verbose: process.env.DEBUG_SQL ? console.log : null,
+      fileMustExist: false
+    });
+
+    this.initTables();
+    this.prepareStatements();
+  }
+
+  initTables() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_executions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT,
+        agent_type TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        model TEXT NOT NULL,
+        status TEXT NOT NULL, -- 'pending', 'running', 'completed', 'failed'
+        result TEXT,
+        error TEXT,
+        steps INTEGER DEFAULT 0,
+        duration_ms INTEGER,
+        input_tokens INTEGER DEFAULT 0,
+        output_tokens INTEGER DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        completed_at INTEGER
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_agent_executions_session_id
+        ON agent_executions(session_id);
+
+      CREATE INDEX IF NOT EXISTS idx_agent_executions_agent_type
+        ON agent_executions(agent_type);
+
+      CREATE INDEX IF NOT EXISTS idx_agent_executions_status
+        ON agent_executions(status);
+
+      CREATE INDEX IF NOT EXISTS idx_agent_executions_created_at
+        ON agent_executions(created_at DESC);
+    `);
+
+    logger.info("Agent store tables initialized");
+  }
+
+  prepareStatements() {
+    this.stmts = {
+      create: this.db.prepare(`
+        INSERT INTO agent_executions (
+          session_id, agent_type, prompt, model, status, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?)
+      `),
+
+      updateStatus: this.db.prepare(`
+        UPDATE agent_executions
+        SET status = ?, completed_at = ?
+        WHERE id = ?
+      `),
+
+      complete: this.db.prepare(`
+        UPDATE agent_executions
+        SET status = 'completed',
+            result = ?,
+            steps = ?,
+            duration_ms = ?,
+            input_tokens = ?,
+            output_tokens = ?,
+            completed_at = ?
+        WHERE id = ?
+      `),
+
+      fail: this.db.prepare(`
+        UPDATE agent_executions
+        SET status = 'failed',
+            error = ?,
+            steps = ?,
+            duration_ms = ?,
+            completed_at = ?
+        WHERE id = ?
+      `),
+
+      get: this.db.prepare(`
+        SELECT * FROM agent_executions WHERE id = ?
+      `),
+
+      getBySession: this.db.prepare(`
+        SELECT * FROM agent_executions
+        WHERE session_id = ?
+        ORDER BY created_at DESC
+      `),
+
+      getRecent: this.db.prepare(`
+        SELECT * FROM agent_executions
+        ORDER BY created_at DESC
+        LIMIT ?
+      `),
+
+      stats: this.db.prepare(`
+        SELECT
+          agent_type,
+          COUNT(*) as total_executions,
+          SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
+          SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed,
+          AVG(CASE WHEN status = 'completed' THEN duration_ms ELSE NULL END) as avg_duration_ms,
+          SUM(input_tokens) as total_input_tokens,
+          SUM(output_tokens) as total_output_tokens
+        FROM agent_executions
+        GROUP BY agent_type
+      `)
+    };
+  }
+
+  /**
+   * Create new agent execution
+   */
+  createExecution({ sessionId, agentType, prompt, model }) {
+    const now = Date.now();
+    const result = this.stmts.create.run(
+      sessionId || null,
+      agentType,
+      prompt,
+      model,
+      'pending',
+      now
+    );
+
+    logger.info({
+      executionId: result.lastInsertRowid,
+      agentType,
+      sessionId
+    }, "Created agent execution");
+
+    return result.lastInsertRowid;
+  }
+
+  /**
+   * Update execution status
+   */
+  updateStatus(executionId, status) {
+    const now = Date.now();
+    this.stmts.updateStatus.run(status, now, executionId);
+  }
+
+  /**
+   * Mark execution as completed
+   */
+  completeExecution(executionId, result, stats = {}) {
+    const now = Date.now();
+    this.stmts.complete.run(
+      result,
+      stats.steps || 0,
+      stats.durationMs || 0,
+      stats.inputTokens || 0,
+      stats.outputTokens || 0,
+      now,
+      executionId
+    );
+
+    logger.info({
+      executionId,
+      steps: stats.steps,
+      durationMs: stats.durationMs
+    }, "Agent execution completed");
+  }
+
+  /**
+   * Mark execution as failed
+   */
+  failExecution(executionId, error, stats = {}) {
+    const now = Date.now();
+    this.stmts.fail.run(
+      error.message || String(error),
+      stats.steps || 0,
+      stats.durationMs || 0,
+      now,
+      executionId
+    );
+
+    logger.warn({
+      executionId,
+      error: error.message
+    }, "Agent execution failed");
+  }
+
+  /**
+   * Get execution by ID
+   */
+  getExecution(executionId) {
+    return this.stmts.get.get(executionId);
+  }
+
+  /**
+   * Get executions by session
+   */
+  getSessionExecutions(sessionId) {
+    return this.stmts.getBySession.all(sessionId);
+  }
+
+  /**
+   * Get recent executions
+   */
+  getRecentExecutions(limit = 100) {
+    return this.stmts.getRecent.all(limit);
+  }
+
+  /**
+   * Get aggregate statistics
+   */
+  getStats() {
+    return this.stmts.stats.all();
+  }
+
+  /**
+   * Close database connection
+   */
+  close() {
+    this.db.close();
+  }
+}
+
+// Singleton instance
+let instance = null;
+
+function getInstance() {
+  if (!instance) {
+    instance = new AgentStore();
+  }
+  return instance;
+}
+
+module.exports = getInstance();

package/src/api/router.js

@@ -250,4 +250,59 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
   }
 });
 
+// List available agents (must come before parameterized routes)
+router.get("/v1/agents", (req, res) => {
+  try {
+    const { listAgents } = require("../agents");
+    const agents = listAgents();
+    res.json({ agents });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Agent stats endpoint (specific path before parameterized)
+router.get("/v1/agents/stats", (req, res) => {
+  try {
+    const { getAgentStats } = require("../agents");
+    const stats = getAgentStats();
+    res.json({ stats });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Read agent transcript (specific path with param before catch-all)
+router.get("/v1/agents/:agentId/transcript", (req, res) => {
+  try {
+    const ContextManager = require("../agents/context-manager");
+    const cm = new ContextManager();
+    const transcript = cm.readTranscript(req.params.agentId);
+
+    if (!transcript) {
+      return res.status(404).json({ error: "Transcript not found" });
+    }
+
+    res.json({ transcript });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Agent execution details (parameterized - must come last)
+router.get("/v1/agents/:executionId", (req, res) => {
+  try {
+    const { getAgentExecution } = require("../agents");
+    const details = getAgentExecution(req.params.executionId);
+
+    if (!details) {
+      return res.status(404).json({ error: "Execution not found" });
+    }
+
+    res.json(details);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
 module.exports = router;

package/src/clients/databricks.js

@@ -5,11 +5,18 @@ const { withRetry } = require("./retry");
 const { getCircuitBreakerRegistry } = require("./circuit-breaker");
 const { getMetricsCollector } = require("../observability/metrics");
 const logger = require("../logger");
+const { STANDARD_TOOLS } = require("./standard-tools");
+const { convertAnthropicToolsToOpenRouter } = require("./openrouter-utils");
+
+
+
 
 if (typeof fetch !== "function") {
   throw new Error("Node 18+ is required for the built-in fetch API.");
 }
 
+
+
 // HTTP connection pooling for better performance
 const httpAgent = new http.Agent({
   keepAlive: true,
@@ -117,17 +124,61 @@ async function invokeDatabricks(body) {
   if (!config.databricks?.url) {
     throw new Error("Databricks configuration is missing required URL.");
   }
+
+  // Create a copy of body to avoid mutating the original
+  const databricksBody = { ...body };
+
+  // Inject standard tools if client didn't send any (passthrough mode)
+  if (!Array.isArray(databricksBody.tools) || databricksBody.tools.length === 0) {
+    databricksBody.tools = STANDARD_TOOLS;
+    logger.info({
+      injectedToolCount: STANDARD_TOOLS.length,
+      injectedToolNames: STANDARD_TOOLS.map(t => t.name),
+      reason: "Client did not send tools (passthrough mode)"
+    }, "=== INJECTING STANDARD TOOLS (Databricks) ===");
+  }
+
+  // Convert Anthropic format tools to OpenAI format (Databricks uses OpenAI format)
+  if (Array.isArray(databricksBody.tools) && databricksBody.tools.length > 0) {
+    // Check if tools are already in OpenAI format (have type: "function")
+    const alreadyConverted = databricksBody.tools[0]?.type === "function";
+
+    if (!alreadyConverted) {
+      databricksBody.tools = convertAnthropicToolsToOpenRouter(databricksBody.tools);
+      logger.debug({
+        convertedToolCount: databricksBody.tools.length,
+        convertedToolNames: databricksBody.tools.map(t => t.function?.name),
+      }, "Converted tools to OpenAI format for Databricks");
+    } else {
+      logger.debug({
+        toolCount: databricksBody.tools.length,
+        toolNames: databricksBody.tools.map(t => t.function?.name),
+      }, "Tools already in OpenAI format, skipping conversion");
+    }
+  }
+
   const headers = {
     Authorization: `Bearer ${config.databricks.apiKey}`,
     "Content-Type": "application/json",
   };
-  return performJsonRequest(config.databricks.url, { headers, body }, "Databricks");
+  return performJsonRequest(config.databricks.url, { headers, body: databricksBody }, "Databricks");
 }
 
 async function invokeAzureAnthropic(body) {
   if (!config.azureAnthropic?.endpoint) {
     throw new Error("Azure Anthropic endpoint is not configured.");
   }
+
+  // Inject standard tools if client didn't send any (passthrough mode)
+  if (!Array.isArray(body.tools) || body.tools.length === 0) {
+    body.tools = STANDARD_TOOLS;
+    logger.info({
+      injectedToolCount: STANDARD_TOOLS.length,
+      injectedToolNames: STANDARD_TOOLS.map(t => t.name),
+      reason: "Client did not send tools (passthrough mode)"
+    }, "=== INJECTING STANDARD TOOLS (Azure Anthropic) ===");
+  }
+
   const headers = {
     "Content-Type": "application/json",
     "x-api-key": config.azureAnthropic.apiKey,
@@ -180,12 +231,27 @@ async function invokeOllama(body) {
     },
   };
 
+  // Inject standard tools if client didn't send any (passthrough mode)
+  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 (Ollama) ===");
+  }
+
   // Add tools if present (for tool-capable models)
-  if (Array.isArray(body.tools) && body.tools.length > 0) {
-    ollamaBody.tools = convertAnthropicToolsToOllama(body.tools);
-    logger.debug({
-      toolCount: body.tools.length,
-      toolNames: body.tools.map(t => t.name)
+  if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
+    ollamaBody.tools = convertAnthropicToolsToOllama(toolsToSend);
+    logger.info({
+      toolCount: toolsToSend.length,
+      toolNames: toolsToSend.map(t => t.name),
+      toolsInjected
     }, "Sending tools to Ollama");
   }
 
@@ -210,27 +276,154 @@ async function invokeOpenRouter(body) {
     "X-Title": "Claude-Ollama-Proxy"
   };
 
+  // Convert messages and handle system message
+  const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
+
+  // Anthropic uses separate 'system' field, OpenAI needs it as first message
+  if (body.system) {
+    messages.unshift({
+      role: "system",
+      content: body.system
+    });
+  }
+
   const openRouterBody = {
     model: config.openrouter.model,
-    messages: convertAnthropicMessagesToOpenRouter(body.messages || []),
+    messages,
     temperature: body.temperature ?? 0.7,
     max_tokens: body.max_tokens ?? 4096,
     top_p: body.top_p ?? 1.0,
     stream: body.stream ?? false
   };
 
-  // Add tools if present
-  if (Array.isArray(body.tools) && body.tools.length > 0) {
-    openRouterBody.tools = convertAnthropicToolsToOpenRouter(body.tools);
-    logger.debug({
-      toolCount: body.tools.length,
-      toolNames: body.tools.map(t => t.name)
+  // Add tools - inject standard tools if client didn't send any (passthrough mode)
+  let toolsToSend = body.tools;
+  let toolsInjected = false;
+
+  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+    // Client didn't send tools (likely passthrough mode) - inject standard Claude Code tools
+    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 (OpenRouter) ===");
+  }
+
+  if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
+    openRouterBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
+    logger.info({
+      toolCount: toolsToSend.length,
+      toolNames: toolsToSend.map(t => t.name),
+      toolsInjected
     }, "Sending tools to OpenRouter");
   }
 
   return performJsonRequest(endpoint, { headers, body: openRouterBody }, "OpenRouter");
 }
 
+function detectAzureFormat(url) {
+  if (url.includes("/openai/responses")) return "responses";
+  if (url.includes("/models/")) return "models";
+  if (url.includes("/openai/deployments")) return "deployments";
+  throw new Error("Unknown Azure OpenAI endpoint");
+}
+
+
+async function invokeAzureOpenAI(body) {
+  if (!config.azureOpenAI?.endpoint || !config.azureOpenAI?.apiKey) {
+    throw new Error("Azure OpenAI endpoint or API key is not configured.");
+  }
+
+  const {
+    convertAnthropicToolsToOpenRouter,
+    convertAnthropicMessagesToOpenRouter
+  } = require("./openrouter-utils");
+
+  // Azure OpenAI URL format
+  const endpoint = config.azureOpenAI.endpoint;
+  const format = detectAzureFormat(endpoint);
+
+  const headers = {
+    "api-key": config.azureOpenAI.apiKey,  // Azure uses "api-key" not "Authorization"
+    "Content-Type": "application/json"
+  };
+
+  // Convert messages and handle system message
+  const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
+
+  // Anthropic uses separate 'system' field, OpenAI needs it as first message
+  if (body.system) {
+    messages.unshift({
+      role: "system",
+      content: body.system
+    });
+  }
+
+  const azureBody = {
+    messages,
+    temperature: body.temperature ?? 0.3,  // Lower temperature for more deterministic, action-oriented behavior
+    max_tokens: Math.min(body.max_tokens ?? 4096, 16384),  // Cap at Azure OpenAI's limit
+    top_p: body.top_p ?? 1.0,
+    stream: body.stream ?? false,
+    model: config.azureOpenAI.deployment
+  };
+
+  // Add tools - inject standard tools if client didn't send any (passthrough mode)
+  let toolsToSend = body.tools;
+  let toolsInjected = false;
+
+  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+    // Client didn't send tools (likely passthrough mode) - inject standard Claude Code tools
+    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 ===");
+  }
+
+  if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
+    azureBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
+    azureBody.parallel_tool_calls = true;  // Enable parallel tool calling for better performance
+    azureBody.tool_choice = "auto";  // Explicitly enable tool use (helps GPT models understand they should use tools)
+    logger.info({
+      toolCount: toolsToSend.length,
+      toolNames: toolsToSend.map(t => t.name),
+      toolsInjected,
+      hasSystemMessage: !!body.system,
+      messageCount: messages.length,
+      temperature: azureBody.temperature,
+      sampleTool: azureBody.tools[0] // Log first tool for inspection
+    }, "=== SENDING TOOLS TO AZURE OPENAI ===");
+  }
+
+  logger.info({
+    endpoint,
+    hasTools: !!azureBody.tools,
+    toolCount: azureBody.tools?.length || 0,
+    temperature: azureBody.temperature,
+    max_tokens: azureBody.max_tokens,
+    tool_choice: azureBody.tool_choice
+  }, "=== AZURE OPENAI REQUEST ===");
+
+  if (format === "deployments" || format === "models") {
+    return performJsonRequest(endpoint, { headers, body: azureBody }, "Azure OpenAI");
+  }
+  else if (format === "responses") {
+    azureBody.max_completion_tokens = azureBody.max_tokens;
+    delete azureBody.max_tokens;
+    delete azureBody.temperature;
+    delete azureBody.top_p;
+    return performJsonRequest(endpoint, { headers, body: azureBody }, "Azure OpenAI");
+  }
+  else {
+    throw new Error(`Unsupported Azure OpenAI endpoint format: ${format}`);
+  }
+}
+
 async function invokeModel(body, options = {}) {
   const { determineProvider, isFallbackEnabled, getFallbackProvider } = require("./routing");
   const metricsCollector = getMetricsCollector();
@@ -262,7 +455,9 @@ async function invokeModel(body, options = {}) {
   try {
     // Try initial provider with circuit breaker
     const result = await breaker.execute(async () => {
-      if (initialProvider === "azure-anthropic") {
+      if (initialProvider === "azure-openai") {
+        return await invokeAzureOpenAI(body);
+      } else if (initialProvider === "azure-anthropic") {
         return await invokeAzureAnthropic(body);
       } else if (initialProvider === "ollama") {
         return await invokeOllama(body);
@@ -337,7 +532,9 @@ async function invokeModel(body, options = {}) {
 
       // Execute fallback
       const fallbackResult = await fallbackBreaker.execute(async () => {
-        if (fallbackProvider === "azure-anthropic") {
+        if (fallbackProvider === "azure-openai") {
+          return await invokeAzureOpenAI(body);
+        } else if (fallbackProvider === "azure-anthropic") {
           return await invokeAzureAnthropic(body);
         } else if (fallbackProvider === "openrouter") {
           return await invokeOpenRouter(body);
@@ -401,8 +598,8 @@ function categorizeFailure(error) {
     return "timeout";
   }
   if (error.message?.includes("not configured") ||
-      error.message?.includes("not available") ||
-      error.code === "ECONNREFUSED") {
+    error.message?.includes("not available") ||
+    error.code === "ECONNREFUSED") {
     return "service_unavailable";
   }
   if (error.message?.includes("tool") || error.message?.includes("function")) {

package/src/clients/routing.js

@@ -52,13 +52,21 @@ function determineProvider(payload) {
     return "ollama";
   }
 
-  // Moderate tool count → OpenRouter (if configured and fallback enabled)
-  if (toolCount < maxToolsForOpenRouter && isFallbackEnabled() && config.openrouter?.apiKey) {
-    logger.debug(
-      { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "openrouter" },
-      "Routing to OpenRouter (moderate tools)"
-    );
-    return "openrouter";
+  // Moderate tool count → OpenRouter or Azure OpenAI (if configured and fallback enabled)
+  if (toolCount < maxToolsForOpenRouter && isFallbackEnabled()) {
+    if (config.openrouter?.apiKey) {
+      logger.debug(
+        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "openrouter" },
+        "Routing to OpenRouter (moderate tools)"
+      );
+      return "openrouter";
+    } else if (config.azureOpenAI?.apiKey) {
+      logger.debug(
+        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "azure-openai" },
+        "Routing to Azure OpenAI (moderate tools)"
+      );
+      return "azure-openai";
+    }
   }
 
   // Heavy tool count → cloud (only if fallback is enabled)