lynkr 2.0.0 → 3.0.0

package/src/clients/databricks.js

@@ -424,6 +424,156 @@ async function invokeAzureOpenAI(body) {
   }
 }
 
+async function invokeOpenAI(body) {
+  if (!config.openai?.apiKey) {
+    throw new Error("OpenAI API key is not configured.");
+  }
+
+  const {
+    convertAnthropicToolsToOpenRouter,
+    convertAnthropicMessagesToOpenRouter
+  } = require("./openrouter-utils");
+
+  const endpoint = config.openai.endpoint || "https://api.openai.com/v1/chat/completions";
+  const headers = {
+    "Authorization": `Bearer ${config.openai.apiKey}`,
+    "Content-Type": "application/json",
+  };
+
+  // Add organization header if configured
+  if (config.openai.organization) {
+    headers["OpenAI-Organization"] = config.openai.organization;
+  }
+
+  // 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 openAIBody = {
+    model: config.openai.model || "gpt-4o",
+    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 - 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 (OpenAI) ===");
+  }
+
+  if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
+    openAIBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
+    openAIBody.parallel_tool_calls = true;  // Enable parallel tool calling
+    openAIBody.tool_choice = "auto";  // Let the model decide when to use tools
+    logger.info({
+      toolCount: toolsToSend.length,
+      toolNames: toolsToSend.map(t => t.name),
+      toolsInjected
+    }, "=== SENDING TOOLS TO OPENAI ===");
+  }
+
+  logger.info({
+    endpoint,
+    model: openAIBody.model,
+    hasTools: !!openAIBody.tools,
+    toolCount: openAIBody.tools?.length || 0,
+    temperature: openAIBody.temperature,
+    max_tokens: openAIBody.max_tokens,
+  }, "=== OPENAI REQUEST ===");
+
+  return performJsonRequest(endpoint, { headers, body: openAIBody }, "OpenAI");
+}
+
+async function invokeLlamaCpp(body) {
+  if (!config.llamacpp?.endpoint) {
+    throw new Error("llama.cpp endpoint is not configured.");
+  }
+
+  const {
+    convertAnthropicToolsToOpenRouter,
+    convertAnthropicMessagesToOpenRouter
+  } = require("./openrouter-utils");
+
+  const endpoint = `${config.llamacpp.endpoint}/v1/chat/completions`;
+  const headers = {
+    "Content-Type": "application/json",
+  };
+
+  // Add API key if configured (for secured llama.cpp servers)
+  if (config.llamacpp.apiKey) {
+    headers["Authorization"] = `Bearer ${config.llamacpp.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 llamacppBody = {
+    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 (llama.cpp) ===");
+  }
+
+  if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
+    llamacppBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
+    llamacppBody.tool_choice = "auto";
+    logger.info({
+      toolCount: toolsToSend.length,
+      toolNames: toolsToSend.map(t => t.name),
+      toolsInjected
+    }, "=== SENDING TOOLS TO LLAMA.CPP ===");
+  }
+
+  logger.info({
+    endpoint,
+    hasTools: !!llamacppBody.tools,
+    toolCount: llamacppBody.tools?.length || 0,
+    temperature: llamacppBody.temperature,
+    max_tokens: llamacppBody.max_tokens,
+  }, "=== LLAMA.CPP REQUEST ===");
+
+  return performJsonRequest(endpoint, { headers, body: llamacppBody }, "llama.cpp");
+}
+
 async function invokeModel(body, options = {}) {
   const { determineProvider, isFallbackEnabled, getFallbackProvider } = require("./routing");
   const metricsCollector = getMetricsCollector();
@@ -463,6 +613,10 @@ async function invokeModel(body, options = {}) {
         return await invokeOllama(body);
       } else if (initialProvider === "openrouter") {
         return await invokeOpenRouter(body);
+      } else if (initialProvider === "openai") {
+        return await invokeOpenAI(body);
+      } else if (initialProvider === "llamacpp") {
+        return await invokeLlamaCpp(body);
       }
       return await invokeDatabricks(body);
     });
@@ -538,6 +692,10 @@ async function invokeModel(body, options = {}) {
           return await invokeAzureAnthropic(body);
         } else if (fallbackProvider === "openrouter") {
           return await invokeOpenRouter(body);
+        } else if (fallbackProvider === "openai") {
+          return await invokeOpenAI(body);
+        } else if (fallbackProvider === "llamacpp") {
+          return await invokeLlamaCpp(body);
         }
         return await invokeDatabricks(body);
       });

package/src/clients/routing.js

@@ -52,7 +52,7 @@ function determineProvider(payload) {
     return "ollama";
   }
 
-  // Moderate tool count → OpenRouter or Azure OpenAI (if configured and fallback enabled)
+  // Moderate tool count → OpenRouter, OpenAI, or Azure OpenAI (if configured and fallback enabled)
   if (toolCount < maxToolsForOpenRouter && isFallbackEnabled()) {
     if (config.openrouter?.apiKey) {
       logger.debug(
@@ -60,12 +60,24 @@ function determineProvider(payload) {
         "Routing to OpenRouter (moderate tools)"
       );
       return "openrouter";
+    } else if (config.openai?.apiKey) {
+      logger.debug(
+        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "openai" },
+        "Routing to OpenAI (moderate tools)"
+      );
+      return "openai";
     } else if (config.azureOpenAI?.apiKey) {
       logger.debug(
         { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "azure-openai" },
         "Routing to Azure OpenAI (moderate tools)"
       );
       return "azure-openai";
+    } else if (config.llamacpp?.endpoint) {
+      logger.debug(
+        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "llamacpp" },
+        "Routing to llama.cpp (moderate tools)"
+      );
+      return "llamacpp";
     }
   }
 

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"]);
+const SUPPORTED_MODEL_PROVIDERS = new Set(["databricks", "azure-anthropic", "ollama", "openrouter", "azure-openai", "openai", "llamacpp"]);
 const rawModelProvider = (process.env.MODEL_PROVIDER ?? "databricks").toLowerCase();
 const modelProvider = SUPPORTED_MODEL_PROVIDERS.has(rawModelProvider)
   ? rawModelProvider
@@ -90,6 +90,17 @@ 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";
 
+// OpenAI configuration
+const openAIApiKey = process.env.OPENAI_API_KEY?.trim() || null;
+const openAIModel = process.env.OPENAI_MODEL?.trim() || "gpt-4o";
+const openAIEndpoint = process.env.OPENAI_ENDPOINT?.trim() || "https://api.openai.com/v1/chat/completions";
+const openAIOrganization = process.env.OPENAI_ORGANIZATION?.trim() || null;
+
+// llama.cpp configuration
+const llamacppEndpoint = process.env.LLAMACPP_ENDPOINT?.trim() || "http://localhost:8080";
+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;
 
 // Hybrid routing configuration
 const preferOllama = process.env.PREFER_OLLAMA === "true";
@@ -112,6 +123,18 @@ if (!["server", "client", "passthrough"].includes(toolExecutionMode)) {
   );
 }
 
+// Memory system configuration (Titans-inspired long-term memory)
+const memoryEnabled = process.env.MEMORY_ENABLED !== "false"; // default true
+const memoryRetrievalLimit = Number.parseInt(process.env.MEMORY_RETRIEVAL_LIMIT ?? "5", 10);
+const memorySurpriseThreshold = Number.parseFloat(process.env.MEMORY_SURPRISE_THRESHOLD ?? "0.3");
+const memoryMaxAgeDays = Number.parseInt(process.env.MEMORY_MAX_AGE_DAYS ?? "90", 10);
+const memoryMaxCount = Number.parseInt(process.env.MEMORY_MAX_COUNT ?? "10000", 10);
+const memoryIncludeGlobal = process.env.MEMORY_INCLUDE_GLOBAL !== "false"; // default true
+const memoryInjectionFormat = (process.env.MEMORY_INJECTION_FORMAT ?? "system").toLowerCase();
+const memoryExtractionEnabled = process.env.MEMORY_EXTRACTION_ENABLED !== "false"; // default true
+const memoryDecayEnabled = process.env.MEMORY_DECAY_ENABLED !== "false"; // default true
+const memoryDecayHalfLifeDays = Number.parseInt(process.env.MEMORY_DECAY_HALF_LIFE ?? "30", 10);
+
 // 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.");
@@ -134,6 +157,12 @@ if (modelProvider === "azure-openai" && (!azureOpenAIEndpoint || !azureOpenAIApi
   );
 }
 
+if (modelProvider === "openai" && !openAIApiKey) {
+  throw new Error(
+    "Set OPENAI_API_KEY before starting the proxy.",
+  );
+}
+
 if (modelProvider === "ollama") {
   try {
     new URL(ollamaEndpoint);
@@ -142,6 +171,14 @@ if (modelProvider === "ollama") {
   }
 }
 
+if (modelProvider === "llamacpp") {
+  try {
+    new URL(llamacppEndpoint);
+  } catch (err) {
+    throw new Error("LLAMACPP_ENDPOINT must be a valid URL (default: http://localhost:8080)");
+  }
+}
+
 // Validate hybrid routing configuration
 if (preferOllama) {
   if (!ollamaEndpoint) {
@@ -353,6 +390,18 @@ const config = {
     deployment: azureOpenAIDeployment,
     apiVersion: azureOpenAIApiVersion
   },
+  openai: {
+    apiKey: openAIApiKey,
+    model: openAIModel,
+    endpoint: openAIEndpoint,
+    organization: openAIOrganization,
+  },
+  llamacpp: {
+    endpoint: llamacppEndpoint,
+    model: llamacppModel,
+    timeout: Number.isNaN(llamacppTimeout) ? 120000 : llamacppTimeout,
+    apiKey: llamacppApiKey,
+  },
   modelProvider: {
     type: modelProvider,
     defaultModel,
@@ -472,6 +521,24 @@ const config = {
     },
     profiles: Array.isArray(testProfiles) ? testProfiles : null,
   },
+  memory: {
+    enabled: memoryEnabled,
+    retrievalLimit: Number.isNaN(memoryRetrievalLimit) ? 5 : memoryRetrievalLimit,
+    surpriseThreshold: Number.isNaN(memorySurpriseThreshold) ? 0.3 : memorySurpriseThreshold,
+    maxAgeDays: Number.isNaN(memoryMaxAgeDays) ? 90 : memoryMaxAgeDays,
+    maxCount: Number.isNaN(memoryMaxCount) ? 10000 : memoryMaxCount,
+    includeGlobalMemories: memoryIncludeGlobal,
+    injectionFormat: ["system", "assistant_preamble"].includes(memoryInjectionFormat)
+      ? memoryInjectionFormat
+      : "system",
+    extraction: {
+      enabled: memoryExtractionEnabled,
+    },
+    decay: {
+      enabled: memoryDecayEnabled,
+      halfLifeDays: Number.isNaN(memoryDecayHalfLifeDays) ? 30 : memoryDecayHalfLifeDays,
+    },
+  },
 };
 
 module.exports = config;

package/src/db/index.js

@@ -218,6 +218,124 @@ db.exec(`
 
   CREATE INDEX IF NOT EXISTS idx_test_runs_status
     ON test_runs(status);
+
+  -- Memory system tables (Titans-inspired long-term memory)
+  CREATE TABLE IF NOT EXISTS memories (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT,
+    content TEXT NOT NULL,
+    type TEXT NOT NULL,
+    category TEXT,
+    importance REAL DEFAULT 0.5,
+    surprise_score REAL DEFAULT 0.0,
+    access_count INTEGER DEFAULT 0,
+    decay_factor REAL DEFAULT 1.0,
+    source_turn_id INTEGER,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL,
+    last_accessed_at INTEGER,
+    metadata TEXT,
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE SET NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_memories_session_id
+    ON memories(session_id);
+
+  CREATE INDEX IF NOT EXISTS idx_memories_type
+    ON memories(type);
+
+  CREATE INDEX IF NOT EXISTS idx_memories_category
+    ON memories(category);
+
+  CREATE INDEX IF NOT EXISTS idx_memories_importance
+    ON memories(importance DESC);
+
+  CREATE INDEX IF NOT EXISTS idx_memories_surprise
+    ON memories(surprise_score DESC);
+
+  CREATE INDEX IF NOT EXISTS idx_memories_created_at
+    ON memories(created_at DESC);
+
+  CREATE INDEX IF NOT EXISTS idx_memories_last_accessed
+    ON memories(last_accessed_at DESC);
+
+  -- Full-text search for memories
+  CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+    content,
+    type,
+    category,
+    content=memories,
+    content_rowid=id,
+    tokenize="porter unicode61"
+  );
+`)
+
+;
+
+// FTS5 triggers to keep search index in sync
+db.exec(`
+  CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+    INSERT INTO memories_fts(rowid, content, type, category)
+    VALUES (new.id, new.content, new.type, new.category);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, content, type, category)
+    VALUES ('delete', old.id, old.content, old.type, old.category);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, content, type, category)
+    VALUES ('delete', old.id, old.content, old.type, old.category);
+    INSERT INTO memories_fts(rowid, content, type, category)
+    VALUES (new.id, new.content, new.type, new.category);
+  END;
+`);
+
+db.exec(`
+  -- Memory embeddings for optional semantic search
+  CREATE TABLE IF NOT EXISTS memory_embeddings (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    memory_id INTEGER NOT NULL UNIQUE,
+    embedding BLOB NOT NULL,
+    model TEXT NOT NULL,
+    dimensions INTEGER NOT NULL,
+    created_at INTEGER NOT NULL,
+    FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+  );
+
+  -- Entity tracking for surprise detection
+  CREATE TABLE IF NOT EXISTS memory_entities (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entity_type TEXT NOT NULL,
+    entity_name TEXT NOT NULL,
+    first_seen_at INTEGER NOT NULL,
+    last_seen_at INTEGER NOT NULL,
+    occurrence_count INTEGER DEFAULT 1,
+    properties TEXT,
+    UNIQUE(entity_type, entity_name)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_memory_entities_type_name
+    ON memory_entities(entity_type, entity_name);
+
+  -- Memory associations (graph relationships)
+  CREATE TABLE IF NOT EXISTS memory_associations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    from_memory_id INTEGER NOT NULL,
+    to_memory_id INTEGER NOT NULL,
+    relationship TEXT,
+    strength REAL DEFAULT 0.5,
+    created_at INTEGER NOT NULL,
+    FOREIGN KEY (from_memory_id) REFERENCES memories(id) ON DELETE CASCADE,
+    FOREIGN KEY (to_memory_id) REFERENCES memories(id) ON DELETE CASCADE
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_memory_associations_from
+    ON memory_associations(from_memory_id);
+
+  CREATE INDEX IF NOT EXISTS idx_memory_associations_to
+    ON memory_associations(to_memory_id);
 `);
 
 logger.info({ dbPath }, "SQLite session store initialised");