@causyne/agent 0.0.0-stage → 1.10.0

package/src/mcp/mcpRegistry.js

@@ -0,0 +1,207 @@
+// The bridge between user-configured MCP servers and Causyne's tool catalogue.
+//
+// Discovered tools are namespaced `mcp__<server>__<tool>`, which is what keeps
+// them from ever colliding with a native tool name — and makes it obvious in a
+// transcript, an audit log and an approval prompt that the call is leaving
+// Causyne's own code.
+
+import { McpClient } from './mcpClient.js';
+import { loadConfig, saveConfig } from '../config.js';
+import { auditLog } from '../auditLog.js';
+
+const NAMESPACE = 'mcp__';
+const connected = new Map(); // server name -> McpClient
+
+/** Server definitions the USER configured. Never model-supplied. */
+export function configuredServers() {
+  const config = loadConfig();
+  const servers = Array.isArray(config.mcpServers) ? config.mcpServers : [];
+  return servers.filter(s => McpClient.validateDefinition(s) === null);
+}
+
+
+export function addServer(definition) {
+  const problem = McpClient.validateDefinition(definition);
+  if (problem) return { ok: false, error: problem };
+
+  const config = loadConfig();
+  const servers = Array.isArray(config.mcpServers) ? [...config.mcpServers] : [];
+
+  if (servers.some(s => s && s.name === definition.name)) {
+    return { ok: false, error: `a server named "${definition.name}" is already configured` };
+  }
+
+  // Store only the fields the client actually reads. Anything else a caller
+  // sends is dropped rather than persisted into the user's config.
+  const stored = { name: definition.name };
+  if (definition.url) {
+    stored.url = definition.url;
+    if (definition.headers && typeof definition.headers === 'object') stored.headers = definition.headers;
+  } else {
+    stored.command = definition.command;
+    if (Array.isArray(definition.args)) stored.args = definition.args;
+    if (definition.env && typeof definition.env === 'object') stored.env = definition.env;
+    if (typeof definition.cwd === 'string') stored.cwd = definition.cwd;
+  }
+
+  config.mcpServers = [...servers, stored];
+  // Registering is not consenting: leave it ungranted.
+  config.mcpConsent = { ...(config.mcpConsent || {}), [definition.name]: false };
+  saveConfig(config);
+
+  auditLog.log({ event: 'mcp_server_added', server: definition.name, transport: definition.url ? 'http' : 'stdio' });
+  return { ok: true };
+}
+
+/** Remove a server, drop its consent, and close any live connection. */
+export function removeServer(name) {
+  const config = loadConfig();
+  const servers = Array.isArray(config.mcpServers) ? config.mcpServers : [];
+  if (!servers.some(s => s && s.name === name)) {
+    return { ok: false, error: `no server named "${name}" is configured` };
+  }
+
+  config.mcpServers = servers.filter(s => !s || s.name !== name);
+  const consent = { ...(config.mcpConsent || {}) };
+  delete consent[name];
+  config.mcpConsent = consent;
+  saveConfig(config);
+
+  const client = connected.get(name);
+  if (client) { try { client.close(); } catch (e) {} connected.delete(name); }
+
+  auditLog.log({ event: 'mcp_server_removed', server: name });
+  return { ok: true };
+}
+
+export function isServerGranted(name) {
+  const config = loadConfig();
+  return (config.mcpConsent || {})[name] === true;
+}
+
+export function grantServer(name) {
+  const config = loadConfig();
+  config.mcpConsent = { ...(config.mcpConsent || {}), [name]: true };
+  saveConfig(config);
+  // The consent boundary is exactly what a post-hoc review needs to see.
+  auditLog.log({ event: 'mcp_server_granted', server: name });
+}
+
+export function revokeServer(name) {
+  const config = loadConfig();
+  config.mcpConsent = { ...(config.mcpConsent || {}), [name]: false };
+  saveConfig(config);
+  const client = connected.get(name);
+  if (client) { client.close(); connected.delete(name); }
+  auditLog.log({ event: 'mcp_server_revoked', server: name });
+}
+
+export function toolName(serverName, tool) {
+  return `${NAMESPACE}${serverName}__${tool}`;
+}
+
+export function isMcpToolName(name) {
+  return typeof name === 'string' && name.startsWith(NAMESPACE);
+}
+
+/** Split `mcp__server__tool` back into its parts. Tool names may contain `__`. */
+export function parseToolName(name) {
+  if (!isMcpToolName(name)) return null;
+  const rest = name.slice(NAMESPACE.length);
+  const separator = rest.indexOf('__');
+  if (separator === -1) return null;
+  return { server: rest.slice(0, separator), tool: rest.slice(separator + 2) };
+}
+
+/**
+ * Connect to a granted server, or return the live client.
+ * Connecting is never automatic: the caller has already checked consent.
+ */
+export async function connectServer(name) {
+  if (connected.has(name)) return connected.get(name);
+  const definition = configuredServers().find(s => s.name === name);
+  if (!definition) throw new Error(`no MCP server named "${name}" is configured`);
+  const client = await new McpClient(definition).connect();
+  connected.set(name, client);
+  return client;
+}
+
+/**
+ * Tool schemas for every granted, reachable server.
+ *
+ * A server that fails to start is skipped silently rather than failing the
+ * whole catalogue — one broken third-party server must not take the agent down.
+ */
+export async function discoverTools() {
+  const definitions = [];
+  for (const server of configuredServers()) {
+    if (!isServerGranted(server.name)) continue;
+    let client;
+    try {
+      client = await connectServer(server.name);
+    } catch (e) {
+      console.warn(`[MCP] ${server.name} unavailable: ${e.message}`);
+      continue;
+    }
+    for (const tool of client.tools) {
+      definitions.push({
+        name: toolName(server.name, tool.name),
+        description: `[MCP: ${server.name}] ${tool.description}`.trim(),
+        parameters: tool.inputSchema
+      });
+    }
+  }
+  return definitions;
+}
+
+/**
+ * A tool object the registry can execute, for any `mcp__…` name.
+ * Returns null for a name that is not MCP, or whose server is not granted.
+ */
+export function resolveMcpTool(name) {
+  const parsed = parseToolName(name);
+  if (!parsed) return null;
+  if (!configuredServers().some(s => s.name === parsed.server)) return null;
+
+  return {
+    schema: { name, description: `MCP tool ${parsed.tool} on server ${parsed.server}`, parameters: { type: 'object', properties: {} } },
+    async execute(args) {
+      if (!isServerGranted(parsed.server)) {
+        return {
+          success: false,
+          requiresConsent: true,
+          error: `The MCP server "${parsed.server}" is configured but not enabled. ` +
+                 `Call manage_local_dependencies with action "grant_mcp_server" and group "${parsed.server}" ` +
+                 `to request the user's approval.`
+        };
+      }
+      try {
+        const client = await connectServer(parsed.server);
+        return await client.callTool(parsed.tool, args);
+      } catch (e) {
+        return { success: false, error: `MCP server "${parsed.server}": ${e.message}` };
+      }
+    }
+  };
+}
+
+/** State for the user-facing listing. */
+export function serverStatus() {
+  return configuredServers().map(server => ({
+    name: server.name,
+    transport: server.url ? 'http' : 'stdio',
+    // The full invocation, not just the binary. "npx" alone tells a user nothing
+    // about what they are consenting to run; "npx -y @scope/server-fs /tmp" does.
+    target: server.url || [server.command, ...(server.args || [])].join(' '),
+    granted: isServerGranted(server.name),
+    connected: connected.has(server.name),
+    tools: connected.has(server.name) ? connected.get(server.name).tools.map(t => t.name) : []
+  }));
+}
+
+export function closeAll() {
+  for (const [, client] of connected) {
+    try { client.close(); } catch (e) {}
+  }
+  connected.clear();
+}

package/src/memory.js

@@ -0,0 +1,62 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { causyneHome } from './utils/paths.js';
+
+const MEMORY_FILE_PATH = path.join(causyneHome(), 'memory.json');
+
+// Ensure the directory and file exist
+function initMemory() {
+    const dir = path.dirname(MEMORY_FILE_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    if (!fs.existsSync(MEMORY_FILE_PATH)) {
+        fs.writeFileSync(MEMORY_FILE_PATH, JSON.stringify({ facts: [] }, null, 2));
+    }
+}
+
+export function getMemory() {
+    try {
+        initMemory();
+        const data = fs.readFileSync(MEMORY_FILE_PATH, 'utf-8');
+        return JSON.parse(data);
+    } catch (e) {
+        console.error("Failed to read memory.json:", e.message);
+        return { facts: [] };
+    }
+}
+
+export function saveMemory(data) {
+    try {
+        initMemory();
+        fs.writeFileSync(MEMORY_FILE_PATH, JSON.stringify(data, null, 2));
+    } catch (e) {
+        console.error("Failed to write memory.json:", e.message);
+    }
+}
+
+export function addFact(factStr) {
+    const mem = getMemory();
+    // Only add if it doesn't already exist to avoid duplicates
+    if (!mem.facts.includes(factStr)) {
+        mem.facts.push(factStr);
+        saveMemory(mem);
+    }
+}
+
+export function clearMemory() {
+    try {
+        initMemory();
+        fs.writeFileSync(MEMORY_FILE_PATH, JSON.stringify({ facts: [] }, null, 2));
+    } catch (e) {
+        console.error("Failed to clear memory:", e.message);
+    }
+}
+
+export function getMemoryContextString() {
+    const mem = getMemory();
+    if (!mem || !mem.facts || mem.facts.length === 0) return "No prior memory facts available.";
+    
+    return mem.facts.map((fact, index) => `${index + 1}. ${fact}`).join("\n");
+}

package/src/memoryManager.js

@@ -0,0 +1,124 @@
+import fs from 'fs';
+import path from 'path';
+import { resolveSession, createSession, switchSession, saveSessionMessages } from './sessionStore.js';
+import os from 'os';
+import { causyneHome } from './utils/paths.js';
+
+const MEMORY_DIR = path.join(causyneHome(), 'memory');
+const CHAT_HISTORY_FILE = path.join(MEMORY_DIR, 'chat_history.json');
+
+// Persistence ceilings. Without them chat_history.json grew for the lifetime of
+// the installation: every new task reloaded a file that could be tens of
+// megabytes, and the sliding window filled to its limit before the user had
+// typed a single word — so even "list my files" paid a full context window.
+const MAX_PERSISTED_MESSAGES = 120;
+const MAX_PERSISTED_CHARS = 400000;
+const MAX_SINGLE_MESSAGE_CHARS = 40000;
+
+function contentLength(content) {
+  if (typeof content === 'string') return content.length;
+  if (content == null) return 0;
+  return JSON.stringify(content).length;
+}
+
+export class MemoryManager {
+  /**
+   * @param {string} workspace  The directory this conversation belongs to.
+   *
+   * History is now per SESSION, and a session belongs to a workspace. It used
+   * to be one global chat_history.json read by every invocation in every
+   * directory — so typing continue in a new project resumed a conversation
+   * from a different one, months old. See src/sessionStore.js.
+   */
+  constructor(workspace = process.cwd()) {
+    this.ensureMemoryDir();
+    this.workspace = workspace;
+    this.session = resolveSession(workspace);
+  }
+
+  /** The active session's id, for the status line and /sessions. */
+  get sessionId() { return this.session ? this.session.id : null; }
+  get sessionTitle() { return this.session ? this.session.title : ''; }
+
+  /** Abandon this conversation and open a clean one in the same workspace. */
+  startNewSession() {
+    this.session = createSession(this.workspace);
+    return this.session;
+  }
+
+  /** Resume a specific past conversation. */
+  useSession(id) {
+    const next = switchSession(id);
+    if (next) this.session = next;
+    return next;
+  }
+
+  ensureMemoryDir() {
+    if (!fs.existsSync(MEMORY_DIR)) {
+      fs.mkdirSync(MEMORY_DIR, { recursive: true, mode: 0o700 });
+    }
+  }
+
+  loadHistory() {
+    if (!this.session || !Array.isArray(this.session.messages)) return [];
+    // Only return non-system messages to prevent stale system prompts.
+    return this.session.messages.filter(m => m.role !== 'system');
+  }
+
+  
+  boundHistory(messages) {
+    const persistable = messages.filter(m => m.role !== 'system');
+    const bounded = [];
+    let totalChars = 0;
+
+    for (let i = persistable.length - 1; i >= 0; i--) {
+      if (bounded.length >= MAX_PERSISTED_MESSAGES) break;
+
+      const msg = persistable[i];
+      let content = msg.content;
+
+      if (Array.isArray(content)) {
+        const hasMedia = content.some(
+          block => block && (block.type === 'image' || block.type === 'image_url' || block.type === 'input_audio')
+        );
+        if (hasMedia) {
+          const captions = content
+            .filter(block => block && block.type === 'text' && block.text)
+            .map(block => block.text)
+            .join(' ');
+          content = `[media attachment not persisted] ${captions}`.trim();
+        }
+      }
+
+      if (typeof content === 'string' && content.length > MAX_SINGLE_MESSAGE_CHARS) {
+        content = content.slice(0, MAX_SINGLE_MESSAGE_CHARS) + '\n[... truncated on save ...]';
+      }
+
+      const length = contentLength(content);
+      if (totalChars + length > MAX_PERSISTED_CHARS && bounded.length > 0) break;
+      totalChars += length;
+
+      bounded.unshift(content === msg.content ? msg : { ...msg, content });
+    }
+
+    // A history that opens on tool results is unusable: the assistant message
+    // that called them was trimmed away.
+    while (bounded.length > 0 && bounded[0].role === 'tool') {
+      bounded.shift();
+    }
+
+    return bounded;
+  }
+
+  saveHistory(messages) {
+    if (!this.session) return;
+    saveSessionMessages(this.session.id, this.boundHistory(messages));
+  }
+
+  /** /clear — empties THIS conversation, and leaves every other one alone. */
+  clearHistory() {
+    if (!this.session) return;
+    this.session.messages = [];
+    saveSessionMessages(this.session.id, []);
+  }
+}

package/src/modelCatalogue.js

@@ -0,0 +1,132 @@
+// THE model catalogue. One list, one truth.
+//
+// WHY THIS EXISTS: on 2026-09-09 an audit found the supported-model list
+// duplicated by hand in FIVE places, drifting independently:
+//
+//   1. alibaba-cloud/ui-config.js        /api/agent-models — overrides the app entirely
+//   2. AgentViewModel.kt getModelsForProvider()  — the app's offline fallback
+//   3. src/tui/home.js PROVIDERS         — the terminal home screen's defaults
+//   4. src/config.js loadConfig()        — the first-run default
+//   5. src/providers/anthropic.js        — the capability lists that decide behaviour
+//
+// ui-config.js already carried the comment "Three lists, one truth" — it was
+// four, and the count was the smallest of the problems. The drift had shipped:
+
+// does not publish (it uses dashes), which matched NONE of anthropic.js's
+// capability lists and so silently disabled adaptive thinking and deferred
+// tool loading and sent `temperature` to models that reject it. The terminal
+// suggested `gpt-4o` and `gemini-2.5-pro` — models two generations old. And
+// `gpt-6-astra`, `claude-opus-5` and `claude-fable-5-1` could not be selected
+
+//
+// This module is now the source. 3 and 4 import it. 1 and 2 cannot (they are a
+// separately deployed Express service and a Kotlin file), so
+// tests/modelCatalogue.test.js READS them and fails the build when they drift.
+// That is the part that stops this recurring: fixing the lists fixes today,
+// pinning them by test fixes every tomorrow.
+//
+// WHEN A PROVIDER SHIPS A NEW MODEL: add it here, run `npm test`, and the test
+// will name every other file that must be updated to match.
+
+/**
+ * Selectable models per provider, newest first.
+ *
+ * The label keys are a stable configuration format, not display sugar.
+ */
+export const MODEL_CATALOGUE = {
+  'DeepSeek': ['deepseek-v4-pro', 'deepseek-v4-flash'],
+  'Qwen': ['qwen3.7-max', 'qwen3.7-plus', 'qwen3.6-flash'],
+  // Anthropic ids use DASHES and carry no date suffix. A dotted id here is a
+  // bug, not a variant — see src/modelIds.js.
+  'Anthropic': [
+    'claude-fable-5-1',
+    'claude-opus-5',
+    'claude-opus-4-8',
+    'claude-sonnet-5',
+    'claude-haiku-4-5'
+  ],
+  // GPT-6 Astra leads: it is the current flagship and the only model in the
+  // line-up trained for computer use. It is also the priciest ($10/$50 against
+  // Sol's $5/$30), which is why it heads the list but is not the default.
+  'OpenAI': ['gpt-6-astra', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.4-mini'],
+  'Gemini': ['gemini-3.6-flash', 'gemini-3.5-flash', 'gemini-3.1-pro', 'gemini-3.1-flash-lite'],
+  // Standard first. The -contributor variants are cheaper because Meta trains
+  // on the user's prompts and completions, so they must be a choice made
+  // deliberately, never the one at the top of the list.
+  'Meta (Muse)': [
+    'muse-spark-1.3',
+    'muse-spark-1.2',
+    'muse-spark-1.1',
+    'muse-spark-1.3-contributor',
+    'muse-spark-1.2-contributor'
+  ],
+  'Ollama (Local)': ['llama3', 'mistral', 'gemma2', 'custom'],
+  'Alibaba (DashScope)': [
+    'qwen3.7-max', 'qwen3.7-plus', 'kimi-k2.7-code', 'kimi-k2.6',
+    'kimi-k2.5', 'kimi-k2-thinking', 'Moonshot-Kimi-K2-Instruct',
+    'deepseek-v4-flash', 'deepseek-v4-pro'
+  ],
+  'Moonshot (Kimi)': ['kimi-k3', 'kimi-k2.7-code', 'kimi-k2.6'],
+  'xAI (Grok)': ['grok-4.5', 'grok-latest']
+};
+
+/** Provider labels in picker order. */
+export const PROVIDER_LABELS = Object.keys(MODEL_CATALOGUE);
+
+
+export const DEFAULT_MODEL_BY_PROVIDER = {
+  deepseek: 'deepseek-v4-pro',
+  qwen: 'qwen3.7-plus',
+  'dashscope-byok': 'qwen3.7-plus',
+  dashscope: 'qwen3.7-plus',
+  muse: 'muse-spark-1.3',
+  anthropic: 'claude-opus-5',
+  openai: 'gpt-5.6-sol',
+  gemini: 'gemini-3.5-flash',
+  moonshot: 'kimi-k3',
+  xai: 'grok-4.5',
+  ollama: 'llama3',
+  'openai-compatible': ''
+};
+
+/**
+ * Every id this catalogue can produce, flattened. Used by the drift test and
+ * by anything that needs to ask "is this a model we claim to support?".
+ *
+ * @returns {string[]} unique ids, order not significant
+ */
+/**
+ * The cheapest model of each provider that is still competent at UTILITY work —
+ * classification, keyword extraction, log filtering, condensation, triage.
+ *
+ * SAME PROVIDER, ALWAYS. The research spec proposes routing light work to
+ * "DeepSeek V4 Flash or GPT-4o mini" regardless of what the user configured.
+ * That cannot work here: Causyne is BYOK and the user holds exactly ONE key.
+ * Routing across providers would call an endpoint there is no credential for,
+ * so a route may only ever move WITHIN the configured provider.
+ *
+ * MUSE IS DELIBERATELY ABSENT. Its cheap tier is the `-contributor` variant,
+ * which is cheaper precisely because Meta trains on the user's prompts and
+ * completions. That is a privacy decision, not a price decision, and it must
+ * stay something the user opts into by hand — never something a cost optimiser
+ * does to them silently. A muse user simply gets no utility routing.
+ *
+ * Absent providers (moonshot, xai, ollama, openai-compatible) have no published
+ * second tier we can rely on, so they route to nothing and pay full rate. A
+ * guess here would show up on someone's invoice.
+ *
+ * @type {Record<string, string>}
+ */
+export const UTILITY_MODEL_BY_PROVIDER = {
+  deepseek: 'deepseek-v4-flash',      // $0.14/$0.28 against pro's $0.435/$0.87
+  qwen: 'qwen3.6-flash',              // $0.19/$1.13 against plus's $0.32/$1.28
+  dashscope: 'qwen3.6-flash',
+  'dashscope-byok': 'qwen3.6-flash',
+  anthropic: 'claude-haiku-4-5',      // $1/$5 against opus's $5/$25
+  openai: 'gpt-5.4-mini',             // $0.75/$4.50 against sol's $5/$30
+  gemini: 'gemini-3.1-flash-lite'     // $0.25/$1.50 against flash's $1.50/$9
+};
+
+export function allCatalogueModels() {
+  return [...new Set(Object.values(MODEL_CATALOGUE).flat())];
+}

package/src/modelIds.js

@@ -0,0 +1,42 @@
+// Canonical model identifiers.
+//
+// WHY THIS EXISTS: earlier configuration accepted Anthropic model ids with
+// dots, while the canonical ids use dashes. Nothing normalised them, so the
+// invalid string went straight into the provider request payload.
+//
+// The damage was not cosmetic. `providers/anthropic.js modelMatches()` compares
+// with `startsWith`, so a dotted id matched NONE of the capability lists:
+//   - NO_SAMPLING_MODELS missed  → `temperature` was sent to models that
+//     reject sampling parameters with a 400
+//   - ADAPTIVE_THINKING_MODELS missed → thinking silently off
+//   - TOOL_SEARCH_MODELS missed  → deferred tool loading off, so the full
+//     core tool payload shipped on every request
+//
+// THE RULE IS DELIBERATELY NARROW. A blanket dot→dash replacement would
+// destroy every other vendor's ids, because dots are CORRECT for them:
+// `gpt-5.6-sol`, `qwen3.7-max`, `gemini-3.5-flash`, `grok-4.5`,
+// `kimi-k2.7-code`, `muse-spark-1.3`. Only the Anthropic family is rewritten,
+// and no published Anthropic id contains a dot, so the mapping is lossless.
+
+/** Vendor prefixes whose canonical ids never contain a dot. */
+const DOTLESS_MODEL_FAMILIES = ['claude-'];
+
+/**
+ * Resolve a model id to the form its vendor actually publishes.
+ *
+ * Pure and total: a non-string, an empty string, or an id from any other
+ * vendor is returned unchanged. Never throws — this sits on the request path.
+ *
+ * @param   {string} model  Model id as supplied by a client or config file.
+ * @returns {string}        The canonical id.
+ */
+export function canonicalModelId(model) {
+  if (typeof model !== 'string' || model === '') return model;
+
+  const lowered = model.toLowerCase();
+  for (const family of DOTLESS_MODEL_FAMILIES) {
+    if (lowered.startsWith(family)) return model.replace(/\./g, '-');
+  }
+
+  return model;
+}