get-claudia 1.32.0 → 1.34.0

package/gateway/src/bridge.js

@@ -18,6 +18,7 @@ import { existsSync } from 'fs';
 import { readFileSync } from 'fs';
 import { createLogger } from './utils/logger.js';
 import { loadPersonality } from './personality.js';
+import { ToolManager } from './tools.js';
 
 const log = createLogger('bridge');
 
@@ -45,6 +46,8 @@ export class Bridge {
     this.extractor = null; // Set by gateway after construction
     this._consecutiveFailures = 0;
     this._personality = null; // Loaded Claudia personality prompt
+    this._toolManager = null; // ToolManager instance (or null if tool_use disabled)
+    this._toolUseEnabled = false;
   }
 
   async start() {
@@ -97,6 +100,16 @@ export class Bridge {
 
     // Try to connect to memory daemon via MCP
     await this._connectMemory();
+
+    // Initialize tool_use if memory is available and tool_use is enabled
+    if (this.memoryAvailable && this._isToolUseEnabled()) {
+      this._toolManager = new ToolManager();
+      await this._toolManager.initialize(this.mcpClient);
+      this._toolUseEnabled = this._toolManager.isReady();
+      if (this._toolUseEnabled) {
+        log.info('Tool use enabled', { toolCount: this._toolManager.toolCount });
+      }
+    }
   }
 
   async stop() {
@@ -127,9 +140,12 @@ export class Bridge {
   async processMessage(message, conversationHistory = [], episodeId = null) {
     const { text, userId, userName, channel } = message;
 
-    // 1. Recall relevant memories (skip if memory is failing repeatedly)
+    const useTools = this._toolUseEnabled && this._isToolUseEnabled(channel);
+
+    // 1. Recall relevant memories (skip if tool_use is active and preRecall is off)
     let memoryContext = '';
-    if (this.memoryAvailable && this._consecutiveFailures < 3) {
+    const doPreRecall = this.config.preRecall !== false;
+    if (this.memoryAvailable && this._consecutiveFailures < 3 && (doPreRecall || !useTools)) {
       try {
         memoryContext = await this._recallContext(text, userName);
         this._consecutiveFailures = 0;
@@ -143,7 +159,7 @@ export class Bridge {
     }
 
     // 2. Build the prompt
-    const systemPrompt = this._buildSystemPrompt(memoryContext, userName, channel);
+    const systemPrompt = this._buildSystemPrompt(memoryContext, userName, channel, useTools);
 
     // 3. Build message history
     const messages = [];
@@ -155,21 +171,30 @@ export class Bridge {
     }
     messages.push({ role: 'user', content: text });
 
-    // 4. Call LLM (Anthropic or Ollama)
+    // 4. Call LLM (Anthropic or Ollama), with or without tool loop
     const resolvedModel = this._resolveModel(channel);
     log.info('Calling LLM', {
       provider: this.provider,
       model: resolvedModel,
       channel,
       messageCount: messages.length,
+      toolUse: useTools,
     });
 
     let result;
     try {
-      if (this.provider === 'anthropic') {
-        result = await this._callAnthropic(systemPrompt, messages, resolvedModel);
+      if (useTools) {
+        if (this.provider === 'anthropic') {
+          result = await this._callAnthropicWithTools(systemPrompt, messages, resolvedModel, channel);
+        } else {
+          result = await this._callOllamaWithTools(systemPrompt, messages, resolvedModel, channel);
+        }
       } else {
-        result = await this._callOllama(systemPrompt, messages, resolvedModel);
+        if (this.provider === 'anthropic') {
+          result = await this._callAnthropic(systemPrompt, messages, resolvedModel);
+        } else {
+          result = await this._callOllama(systemPrompt, messages, resolvedModel);
+        }
       }
     } catch (err) {
       log.error('LLM call failed', { provider: this.provider, error: err.message });
@@ -409,7 +434,7 @@ export class Bridge {
    * 2. Custom systemPromptPath file (backward compat)
    * 3. DEFAULT_SYSTEM_PROMPT fallback
    */
-  _buildSystemPrompt(memoryContext, userName, channel) {
+  _buildSystemPrompt(memoryContext, userName, channel, toolUse = false) {
     let prompt;
 
     if (this._personality) {
@@ -435,6 +460,16 @@ export class Bridge {
       prompt += `\n\n# Memory Context\n${memoryContext}`;
     }
 
+    if (toolUse) {
+      prompt += `\n\n# Memory Tools
+You have access to memory tools to search, store, and manage your persistent knowledge. Use them naturally during conversation:
+- Search for more context when a name, topic, or project comes up that you don't have enough info on
+- Store new facts when the user mentions something important worth remembering
+- Correct or invalidate memories when the user tells you something is wrong or outdated
+- Trace provenance when asked where you learned something
+Don't announce tool usage -- just use the tools and incorporate results naturally into your response.`;
+    }
+
     return prompt;
   }
 
@@ -515,6 +550,237 @@ export class Bridge {
     throw lastError;
   }
 
+  /**
+   * Check if tool_use is enabled for a given channel.
+   * Resolution: per-channel override → global config → auto-detect by provider.
+   *
+   * @param {string} [channel] - Channel name
+   * @returns {boolean}
+   */
+  _isToolUseEnabled(channel) {
+    // Per-channel override (must be explicit boolean, not undefined)
+    if (channel) {
+      const channelToolUse = this.config.channels?.[channel]?.toolUse;
+      if (typeof channelToolUse === 'boolean') return channelToolUse;
+    }
+
+    // Global config override
+    if (typeof this.config.toolUse === 'boolean') return this.config.toolUse;
+
+    // Auto-detect: enabled for Anthropic, disabled for Ollama
+    return this.provider === 'anthropic';
+  }
+
+  /**
+   * Call Anthropic API with tool_use loop.
+   * Runs up to toolUseMaxIterations rounds, executing tool calls and feeding
+   * results back until the model produces a final text response.
+   *
+   * @param {string} systemPrompt
+   * @param {Object[]} messages - Conversation messages (will be mutated with tool results)
+   * @param {string} model
+   * @param {string} channel
+   * @returns {{ text: string, usage: Object }}
+   */
+  async _callAnthropicWithTools(systemPrompt, messages, model, channel) {
+    const tools = this._toolManager.getAnthropicTools();
+    const maxIterations = this.config.toolUseMaxIterations || 5;
+    let totalUsage = { input_tokens: 0, output_tokens: 0 };
+
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+      const response = await this.anthropic.messages.create({
+        model,
+        max_tokens: this.config.maxTokens || 2048,
+        system: systemPrompt,
+        messages,
+        tools,
+      });
+
+      // Accumulate usage
+      if (response.usage) {
+        totalUsage.input_tokens += response.usage.input_tokens || 0;
+        totalUsage.output_tokens += response.usage.output_tokens || 0;
+      }
+
+      // If model didn't request tool use, extract text and return
+      if (response.stop_reason !== 'tool_use') {
+        const text = response.content
+          .filter((block) => block.type === 'text')
+          .map((block) => block.text)
+          .join('\n');
+        return { text, usage: totalUsage };
+      }
+
+      // Process tool calls
+      const toolUseBlocks = response.content.filter((b) => b.type === 'tool_use');
+      const toolResults = [];
+
+      for (const block of toolUseBlocks) {
+        log.debug('Tool call', {
+          iteration,
+          tool: block.name,
+          id: block.id,
+        });
+
+        const result = await this._executeToolCall(block.name, block.input, channel);
+        toolResults.push({
+          type: 'tool_result',
+          tool_use_id: block.id,
+          content: result,
+        });
+      }
+
+      // Append assistant response + tool results for next iteration
+      messages.push({ role: 'assistant', content: response.content });
+      messages.push({ role: 'user', content: toolResults });
+    }
+
+    // Exhausted iterations -- make one final call without tools to force a text response
+    log.warn('Tool loop exhausted max iterations', { maxIterations });
+    const finalResponse = await this.anthropic.messages.create({
+      model,
+      max_tokens: this.config.maxTokens || 2048,
+      system: systemPrompt,
+      messages,
+    });
+
+    if (finalResponse.usage) {
+      totalUsage.input_tokens += finalResponse.usage.input_tokens || 0;
+      totalUsage.output_tokens += finalResponse.usage.output_tokens || 0;
+    }
+
+    const text = finalResponse.content
+      .filter((block) => block.type === 'text')
+      .map((block) => block.text)
+      .join('\n');
+
+    return { text, usage: totalUsage };
+  }
+
+  /**
+   * Call Ollama /api/chat with tool_use loop.
+   *
+   * @param {string} systemPrompt
+   * @param {Object[]} messages
+   * @param {string} model
+   * @param {string} channel
+   * @returns {{ text: string, usage: null }}
+   */
+  async _callOllamaWithTools(systemPrompt, messages, model, channel) {
+    const tools = this._toolManager.getOllamaTools();
+    const host = this.config.ollama?.host || 'http://localhost:11434';
+    const maxIterations = this.config.toolUseMaxIterations || 5;
+
+    const ollamaMessages = [{ role: 'system', content: systemPrompt }];
+    for (const msg of messages) {
+      ollamaMessages.push({ role: msg.role, content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content) });
+    }
+
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+      const res = await fetch(`${host}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model,
+          messages: ollamaMessages,
+          stream: false,
+          tools,
+          options: { temperature: 0.7 },
+        }),
+        signal: AbortSignal.timeout(60000),
+      });
+
+      if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`Ollama HTTP ${res.status}: ${body}`);
+      }
+
+      const data = await res.json();
+
+      // If no tool calls, return the text response
+      if (!data.message?.tool_calls?.length) {
+        return { text: data.message?.content || '', usage: null };
+      }
+
+      // Append assistant message with tool calls
+      ollamaMessages.push(data.message);
+
+      // Execute each tool call and add results
+      for (const tc of data.message.tool_calls) {
+        const toolName = tc.function?.name;
+        const toolInput = tc.function?.arguments || {};
+
+        log.debug('Ollama tool call', { iteration, tool: toolName });
+
+        const result = await this._executeToolCall(toolName, toolInput, channel);
+        ollamaMessages.push({
+          role: 'tool',
+          content: result,
+        });
+      }
+    }
+
+    // Exhausted iterations -- final call without tools
+    log.warn('Ollama tool loop exhausted max iterations', { maxIterations });
+    const finalRes = await fetch(`${host}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        messages: ollamaMessages,
+        stream: false,
+        options: { temperature: 0.7 },
+      }),
+      signal: AbortSignal.timeout(60000),
+    });
+
+    if (!finalRes.ok) {
+      const body = await finalRes.text().catch(() => '');
+      throw new Error(`Ollama HTTP ${finalRes.status}: ${body}`);
+    }
+
+    const finalData = await finalRes.json();
+    return { text: finalData.message?.content || '', usage: null };
+  }
+
+  /**
+   * Execute a single tool call from the LLM against the MCP daemon.
+   *
+   * Safety: rejects calls to non-exposed tools.
+   * Auto-injects source_channel for write operations.
+   *
+   * @param {string} toolName
+   * @param {Object} toolInput
+   * @param {string} channel
+   * @returns {string} JSON string result (always valid, errors wrapped)
+   */
+  async _executeToolCall(toolName, toolInput, channel) {
+    // Safety gate: only execute exposed tools
+    if (!this._toolManager.isExposed(toolName)) {
+      log.warn('LLM attempted to call non-exposed tool', { tool: toolName });
+      return JSON.stringify({ error: `Tool "${toolName}" is not available` });
+    }
+
+    try {
+      // Auto-inject source_channel for write operations
+      const writeTools = new Set(['memory.remember', 'memory.batch', 'memory.correct']);
+      if (writeTools.has(toolName) && channel) {
+        toolInput = { ...toolInput, source_channel: channel };
+      }
+
+      const result = await this.mcpClient.callTool({
+        name: toolName,
+        arguments: toolInput,
+      });
+
+      const parsed = this._parseMcpResult(result);
+      return JSON.stringify(parsed ?? { ok: true });
+    } catch (err) {
+      log.warn('Tool execution failed', { tool: toolName, error: err.message });
+      return JSON.stringify({ error: err.message });
+    }
+  }
+
   /**
    * Connect to the memory daemon via MCP stdio.
    */
@@ -575,6 +841,8 @@ export class Bridge {
       personalityLoaded: !!this._personality,
       model:
         this.provider === 'ollama' ? this.config.ollama?.model : this.config.model,
+      toolUseEnabled: this._toolUseEnabled,
+      toolCount: this._toolManager?.toolCount || 0,
     };
   }
 }

package/gateway/src/config.js

@@ -18,7 +18,7 @@ const PID_PATH = join(CONFIG_DIR, 'gateway.pid');
 const DEFAULT_CONFIG = {
   // Anthropic API
   anthropicApiKey: '',
-  model: 'claude-sonnet-4-20250514',
+  model: 'claude-haiku-4-5-20251001',
   maxTokens: 2048,
 
   // Ollama (local model, auto-detected from ~/.claudia/config.json)
@@ -27,6 +27,11 @@ const DEFAULT_CONFIG = {
     model: '', // Auto-detected from ~/.claudia/config.json language_model field
   },
 
+  // Tool use (LLM-driven memory tool calls)
+  toolUse: undefined,           // true/false/undefined (undefined = auto: true for Anthropic, false for Ollama)
+  toolUseMaxIterations: 5,      // Max tool loop rounds per message
+  preRecall: true,              // Keep programmatic pre-call recall alongside tool_use
+
   // Personality
   personalityDir: '',          // Path to Claudia template dir (contains CLAUDE.md + .claude/rules/)
   personalityMaxChars: 15000,  // Safety limit for prompt size
@@ -52,6 +57,7 @@ const DEFAULT_CONFIG = {
       token: '',
       allowedUsers: [],
       model: '',  // Per-channel model override (empty = use global)
+      toolUse: undefined,  // Per-channel tool_use override (undefined = use global)
     },
     slack: {
       enabled: false,
@@ -60,6 +66,7 @@ const DEFAULT_CONFIG = {
       signingSecret: '',
       allowedUsers: [],
       model: '',  // Per-channel model override (empty = use global)
+      toolUse: undefined,  // Per-channel tool_use override (undefined = use global)
     },
   },
 

package/gateway/src/tools.js

@@ -0,0 +1,202 @@
+/**
+ * Tool Schema Manager for Claudia Gateway
+ *
+ * Fetches MCP tool schemas from the memory daemon, filters to a curated
+ * subset safe for LLM use, and converts them to Anthropic/Ollama formats.
+ *
+ * Design: rather than hardcoding 14 tool definitions in JavaScript
+ * (duplicating the Python schemas), we fetch at startup, filter to the
+ * curated set, and convert the format. When daemon schemas change, the
+ * gateway automatically picks them up.
+ */
+
+import { createLogger } from './utils/logger.js';
+
+const log = createLogger('tools');
+
+/**
+ * Tools exposed to the LLM for agentic use.
+ *
+ * Criteria for inclusion:
+ * - Read-only or safe writes (remember, correct, invalidate)
+ * - Useful in a conversational context
+ * - No destructive/admin operations
+ * - No session lifecycle tools (gateway manages those internally)
+ */
+const EXPOSED_TOOLS = new Set([
+  'memory.recall',
+  'memory.about',
+  'memory.remember',
+  'memory.relate',
+  'memory.entity',
+  'memory.search_entities',
+  'memory.batch',
+  'memory.correct',
+  'memory.invalidate',
+  'memory.trace',
+  'memory.reflections',
+  'memory.project_network',
+  'memory.find_path',
+  'memory.briefing',
+]);
+
+export class ToolManager {
+  constructor() {
+    this._mcpTools = [];       // Raw MCP tool schemas (filtered)
+    this._anthropicTools = [];  // Converted to Anthropic format
+    this._ollamaTools = [];     // Converted to Ollama format
+    this._initialized = false;
+  }
+
+  /**
+   * Fetch tool schemas from the MCP daemon and prepare provider-specific formats.
+   *
+   * @param {import('@modelcontextprotocol/sdk/client/index.js').Client} mcpClient
+   */
+  async initialize(mcpClient) {
+    try {
+      const result = await mcpClient.listTools();
+      const allTools = result?.tools || [];
+
+      // Filter to the curated exposed set
+      this._mcpTools = allTools.filter((t) => EXPOSED_TOOLS.has(t.name));
+
+      // Convert to provider formats
+      this._anthropicTools = this._mcpTools.map((t) => this._toAnthropicSchema(t));
+      this._ollamaTools = this._mcpTools.map((t) => this._toOllamaSchema(t));
+
+      this._initialized = true;
+      log.info('Tool schemas loaded', {
+        total: allTools.length,
+        exposed: this._mcpTools.length,
+      });
+    } catch (err) {
+      log.warn('Failed to load tool schemas', { error: err.message });
+      this._mcpTools = [];
+      this._anthropicTools = [];
+      this._ollamaTools = [];
+      this._initialized = false;
+    }
+  }
+
+  /**
+   * Get tools in Anthropic API format.
+   * @returns {Object[]} Array of { name, description, input_schema }
+   */
+  getAnthropicTools() {
+    return this._anthropicTools;
+  }
+
+  /**
+   * Get tools in Ollama API format.
+   * @returns {Object[]} Array of { type: 'function', function: { name, description, parameters } }
+   */
+  getOllamaTools() {
+    return this._ollamaTools;
+  }
+
+  /**
+   * Check whether a tool name is in the exposed set.
+   * Used as a safety gate before executing tool calls from the LLM.
+   *
+   * @param {string} toolName
+   * @returns {boolean}
+   */
+  isExposed(toolName) {
+    return EXPOSED_TOOLS.has(toolName);
+  }
+
+  /**
+   * @returns {boolean} Whether initialization succeeded and tools are available
+   */
+  isReady() {
+    return this._initialized && this._anthropicTools.length > 0;
+  }
+
+  /**
+   * @returns {number} Number of exposed tools loaded
+   */
+  get toolCount() {
+    return this._anthropicTools.length;
+  }
+
+  // --- Private conversion methods ---
+
+  /**
+   * Convert an MCP tool schema to Anthropic format.
+   *
+   * MCP: { name, description, inputSchema: { type, properties, required } }
+   * Anthropic: { name, description, input_schema: { type, properties, required } }
+   */
+  _toAnthropicSchema(mcpTool) {
+    const inputSchema = this._normalizeSchema(mcpTool.inputSchema || { type: 'object', properties: {} });
+    return {
+      name: mcpTool.name,
+      description: mcpTool.description || '',
+      input_schema: inputSchema,
+    };
+  }
+
+  /**
+   * Convert an MCP tool schema to Ollama format.
+   *
+   * Ollama: { type: 'function', function: { name, description, parameters } }
+   */
+  _toOllamaSchema(mcpTool) {
+    const parameters = this._normalizeSchema(mcpTool.inputSchema || { type: 'object', properties: {} });
+    return {
+      type: 'function',
+      function: {
+        name: mcpTool.name,
+        description: mcpTool.description || '',
+        parameters,
+      },
+    };
+  }
+
+  /**
+   * Normalize JSON Schema types for provider compatibility.
+   *
+   * MCP/Python sometimes emits union types like `"type": ["array", "string"]`
+   * which aren't valid in Anthropic's tool schema. We pick the first type
+   * and note the alternative in the description.
+   *
+   * @param {Object} schema - JSON Schema object
+   * @returns {Object} Normalized schema (deep copy)
+   */
+  _normalizeSchema(schema) {
+    if (!schema || typeof schema !== 'object') return schema;
+
+    const normalized = Array.isArray(schema) ? [...schema] : { ...schema };
+
+    // Normalize union types at this level
+    if (Array.isArray(normalized.type)) {
+      const types = normalized.type.filter((t) => t !== 'null');
+      normalized.type = types[0] || 'string';
+      if (types.length > 1) {
+        const altTypes = types.slice(1).join(', ');
+        normalized.description = normalized.description
+          ? `${normalized.description} (also accepts: ${altTypes})`
+          : `Also accepts: ${altTypes}`;
+      }
+    }
+
+    // Recursively normalize nested properties
+    if (normalized.properties && typeof normalized.properties === 'object') {
+      const normalizedProps = {};
+      for (const [key, value] of Object.entries(normalized.properties)) {
+        normalizedProps[key] = this._normalizeSchema(value);
+      }
+      normalized.properties = normalizedProps;
+    }
+
+    // Normalize items schema (for arrays)
+    if (normalized.items && typeof normalized.items === 'object') {
+      normalized.items = this._normalizeSchema(normalized.items);
+    }
+
+    return normalized;
+  }
+}
+
+export { EXPOSED_TOOLS };