Commit 958d6e8fb09f

@@ -0,0 +1,171 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
+let
+  cfg = config.services.daneel;
+in
+{
+  options.services.daneel = {
+    enable = lib.mkEnableOption "Daneel XMPP research bot";
+
+    package = lib.mkOption {
+      type = lib.types.package;
+      default = pkgs.callPackage ./package.nix { };
+      description = "The daneel package to use";
+    };
+
+    xmppJid = lib.mkOption {
+      type = lib.types.str;
+      example = "daneel@xmpp.example.com";
+      description = "XMPP JID for the bot";
+    };
+
+    xmppPasswordFile = lib.mkOption {
+      type = lib.types.path;
+      description = "Path to file containing XMPP password";
+    };
+
+    ownerJid = lib.mkOption {
+      type = lib.types.str;
+      example = "user@xmpp.example.com";
+      description = "XMPP JID of the bot owner (only this JID can interact)";
+    };
+
+    dataDir = lib.mkOption {
+      type = lib.types.path;
+      default = "/var/lib/daneel";
+      description = "Directory for session data";
+    };
+
+    inboxPath = lib.mkOption {
+      type = lib.types.path;
+      default = "/var/lib/daneel/inbox.org";
+      description = "Path to org-mode inbox file";
+    };
+
+    defaultModel = lib.mkOption {
+      type = lib.types.str;
+      default = "sonnet";
+      description = "Default model alias (e.g., sonnet, opus, gemini)";
+    };
+
+    anthropicApiKeyFile = lib.mkOption {
+      type = lib.types.nullOr lib.types.path;
+      default = null;
+      description = "Path to file containing Anthropic API key";
+    };
+
+    googleApiKeyFile = lib.mkOption {
+      type = lib.types.nullOr lib.types.path;
+      default = null;
+      description = "Path to file containing Google API key";
+    };
+
+    openaiApiKeyFile = lib.mkOption {
+      type = lib.types.nullOr lib.types.path;
+      default = null;
+      description = "Path to file containing OpenAI API key";
+    };
+
+    ollamaBaseUrl = lib.mkOption {
+      type = lib.types.nullOr lib.types.str;
+      default = null;
+      example = "http://localhost:11434";
+      description = "Base URL for Ollama API";
+    };
+
+    debug = lib.mkOption {
+      type = lib.types.bool;
+      default = false;
+      description = "Enable debug logging";
+    };
+
+    user = lib.mkOption {
+      type = lib.types.str;
+      default = "daneel";
+      description = "User to run daneel as";
+    };
+
+    group = lib.mkOption {
+      type = lib.types.str;
+      default = "daneel";
+      description = "Group to run daneel as";
+    };
+  };
+
+  config = lib.mkIf cfg.enable {
+    users.users.${cfg.user} = {
+      isSystemUser = true;
+      group = cfg.group;
+      home = cfg.dataDir;
+      createHome = true;
+    };
+
+    users.groups.${cfg.group} = { };
+
+    systemd.services.daneel = {
+      description = "Daneel XMPP Research Bot";
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network.target" ];
+
+      serviceConfig = {
+        Type = "simple";
+        User = cfg.user;
+        Group = cfg.group;
+        WorkingDirectory = cfg.dataDir;
+        ExecStart = "${cfg.package}/bin/daneel";
+        Restart = "always";
+        RestartSec = "10s";
+
+        # Hardening
+        NoNewPrivileges = true;
+        PrivateTmp = true;
+        ProtectSystem = "strict";
+        ProtectHome = true;
+        ReadWritePaths = [ cfg.dataDir (builtins.dirOf cfg.inboxPath) ];
+        ProtectKernelTunables = true;
+        ProtectKernelModules = true;
+        ProtectControlGroups = true;
+        RestrictAddressFamilies = [
+          "AF_INET"
+          "AF_INET6"
+          "AF_UNIX"
+        ];
+        RestrictNamespaces = true;
+        LockPersonality = true;
+        MemoryDenyWriteExecute = true;
+        RestrictRealtime = true;
+        RestrictSUIDSGID = true;
+        PrivateDevices = true;
+      };
+
+      script = ''
+        export DANEEL_XMPP_JID="${cfg.xmppJid}"
+        export DANEEL_XMPP_PASSWORD="$(cat ${cfg.xmppPasswordFile})"
+        export DANEEL_OWNER_JID="${cfg.ownerJid}"
+        export DANEEL_DATA_DIR="${cfg.dataDir}"
+        export DANEEL_INBOX_PATH="${cfg.inboxPath}"
+        export DANEEL_DEFAULT_MODEL="${cfg.defaultModel}"
+        ${lib.optionalString cfg.debug ''export DANEEL_DEBUG="true"''}
+
+        ${lib.optionalString (cfg.anthropicApiKeyFile != null) ''
+          export ANTHROPIC_API_KEY="$(cat ${cfg.anthropicApiKeyFile})"
+        ''}
+        ${lib.optionalString (cfg.googleApiKeyFile != null) ''
+          export GOOGLE_API_KEY="$(cat ${cfg.googleApiKeyFile})"
+        ''}
+        ${lib.optionalString (cfg.openaiApiKeyFile != null) ''
+          export OPENAI_API_KEY="$(cat ${cfg.openaiApiKeyFile})"
+        ''}
+        ${lib.optionalString (cfg.ollamaBaseUrl != null) ''
+          export OLLAMA_BASE_URL="${cfg.ollamaBaseUrl}"
+        ''}
+
+        exec ${cfg.package}/bin/daneel
+      '';
+    };
+  };
+}

@@ -0,0 +1,48 @@
+{
+  lib,
+  buildNpmPackage,
+  nodejs_22,
+}:
+
+buildNpmPackage {
+  pname = "daneel";
+  version = "0.1.0";
+
+  src = ./..;
+
+  nodejs = nodejs_22;
+
+  npmDepsHash = lib.fakeHash;
+
+  # Build TypeScript
+  buildPhase = ''
+    runHook preBuild
+    npm run build
+    runHook postBuild
+  '';
+
+  # Install the built files
+  installPhase = ''
+    runHook preInstall
+    mkdir -p $out/lib/daneel
+    cp -r dist $out/lib/daneel/
+    cp -r node_modules $out/lib/daneel/
+    cp package.json $out/lib/daneel/
+
+    mkdir -p $out/bin
+    cat > $out/bin/daneel <<EOF
+    #!${nodejs_22}/bin/node
+    import("$out/lib/daneel/dist/main.js");
+    EOF
+    chmod +x $out/bin/daneel
+    runHook postInstall
+  '';
+
+  meta = {
+    description = "XMPP research bot using AI";
+    homepage = "https://codeberg.org/vdemeester/daneel";
+    license = lib.licenses.asl20;
+    maintainers = [ ];
+    mainProgram = "daneel";
+  };
+}

@@ -0,0 +1,80 @@
+export const SYSTEM_PROMPT = `You are Daneel, a personal research assistant named after R. Daneel Olivaw from Isaac Asimov's Robot/Foundation series. You communicate via XMPP (Jabber) with your owner.
+
+Your core traits:
+- Helpful and thorough in research
+- Concise but complete in responses (this is chat, not email)
+- Honest about limitations and uncertainty
+- You can use tools to help with tasks
+
+When responding:
+- Keep responses focused and scannable
+- Use markdown formatting when helpful
+- If a question requires research, use the research tool
+- If asked to save something, use the save_to_org tool
+- For system status, use the status tool
+
+Remember: You're in an XMPP chat context. Keep responses reasonably sized but don't truncate important information.`;
+
+export const HELP_TEXT = `**Daneel - XMPP Research Bot**
+
+**Commands:**
+- \`/help\` - Show this help message
+- \`/ping\` - Check if I'm alive
+- \`/status\` - Show system status
+- \`/clear\` - Clear conversation history
+- \`/models\` - List available models
+
+**Model Prefixes:**
+Use these prefixes to select a specific model:
+
+*Anthropic:*
+- \`opus:\` or \`o:\` - Claude Opus 4.5
+- \`sonnet:\` or \`s:\` - Claude Sonnet 4.5 (default)
+- \`haiku:\` or \`h:\` - Claude Haiku
+
+*Google:*
+- \`gemini:\` or \`g:\` - Gemini 2.0 Flash
+- \`gemini-pro:\` or \`gp:\` - Gemini 2.5 Pro
+
+*OpenAI:*
+- \`gpt:\` or \`gpt4:\` - GPT-4o
+- \`o1:\` - O1
+- \`o3:\` - O3 Mini
+
+*GitHub Copilot:*
+- \`copilot:\` or \`cp:\` - GPT-4o via Copilot
+- \`copilot-claude:\` - Claude Sonnet via Copilot
+
+*Ollama (Local):*
+- \`ollama:\` or \`llama:\` - Llama 3.2
+- \`qwen:\` - Qwen 2.5
+- \`deepseek:\` - DeepSeek R1
+
+*Others:*
+- \`groq:\` - Llama via Groq
+- \`mistral:\` - Mistral Large
+
+**Examples:**
+- \`opus: What is quantum entanglement?\`
+- \`g: Summarize recent AI news\`
+- \`What's the weather like?\` (uses default model)`;
+
+export const MODELS_TEXT = `**Available Models:**
+
+| Prefix | Provider | Model |
+|--------|----------|-------|
+| opus:, o: | Anthropic | claude-opus-4-5 |
+| sonnet:, s: | Anthropic | claude-sonnet-4-5 |
+| haiku:, h: | Anthropic | claude-haiku |
+| gemini:, g: | Google | gemini-2.0-flash |
+| gemini-pro:, gp: | Google | gemini-2.5-pro |
+| gpt:, gpt4: | OpenAI | gpt-4o |
+| o1: | OpenAI | o1 |
+| o3: | OpenAI | o3-mini |
+| copilot:, cp: | GitHub | gpt-4o |
+| copilot-claude: | GitHub | claude-sonnet-4 |
+| ollama:, llama: | Ollama | llama3.2 |
+| qwen: | Ollama | qwen2.5 |
+| deepseek: | Ollama | deepseek-r1 |
+| groq: | Groq | llama-3.3-70b |
+| mistral: | Mistral | mistral-large |`;

@@ -0,0 +1,223 @@
+import { Config, ModelInfo, parseModelPrefix } from "../config.js";
+import { SessionManager } from "./session.js";
+import { SessionEntry, ConversationMessage } from "./types.js";
+import { SYSTEM_PROMPT, HELP_TEXT, MODELS_TEXT } from "./prompts.js";
+import { ToolRegistry } from "../tools/index.js";
+import { createProvider, LLMProvider, Message } from "../llm/index.js";
+import { bareJid } from "../xmpp/types.js";
+
+const MAX_TOOL_ITERATIONS = 10;
+
+export class AgentRunner {
+  private config: Config;
+  private sessionManager: SessionManager;
+  private toolRegistry: ToolRegistry;
+  private jid: string;
+  private processing: boolean = false;
+  private messageQueue: Array<{ message: string; resolve: (response: string) => void }> = [];
+
+  constructor(
+    jid: string,
+    config: Config,
+    sessionManager: SessionManager,
+    toolRegistry: ToolRegistry
+  ) {
+    this.jid = bareJid(jid);
+    this.config = config;
+    this.sessionManager = sessionManager;
+    this.toolRegistry = toolRegistry;
+  }
+
+  async processMessage(message: string): Promise<string> {
+    return new Promise((resolve) => {
+      this.messageQueue.push({ message, resolve });
+      this.processQueue();
+    });
+  }
+
+  private async processQueue(): Promise<void> {
+    if (this.processing || this.messageQueue.length === 0) {
+      return;
+    }
+
+    this.processing = true;
+
+    while (this.messageQueue.length > 0) {
+      const item = this.messageQueue.shift()!;
+      try {
+        const response = await this.handleMessage(item.message);
+        item.resolve(response);
+      } catch (err) {
+        item.resolve(`Error: ${(err as Error).message}`);
+      }
+    }
+
+    this.processing = false;
+  }
+
+  private async handleMessage(message: string): Promise<string> {
+    // Handle slash commands
+    if (message.startsWith("/")) {
+      return this.handleCommand(message);
+    }
+
+    // Parse model prefix
+    const { model, content } = parseModelPrefix(message);
+    const modelInfo = model || this.config.llm.defaultModel;
+
+    // Log user message
+    await this.sessionManager.appendEntry(this.jid, {
+      timestamp: new Date().toISOString(),
+      type: "user",
+      content,
+      model: modelInfo,
+    });
+
+    // Get conversation history
+    const history = await this.sessionManager.getConversationHistory(this.jid);
+
+    // Create provider for this request
+    const provider = createProvider(modelInfo, this.config.llm.providers);
+
+    // Run agent loop
+    const response = await this.runAgentLoop(provider, history, content);
+
+    // Log assistant response
+    await this.sessionManager.appendEntry(this.jid, {
+      timestamp: new Date().toISOString(),
+      type: "assistant",
+      content: response,
+      model: modelInfo,
+    });
+
+    return response;
+  }
+
+  private async handleCommand(message: string): Promise<string> {
+    const parts = message.slice(1).split(/\s+/);
+    const command = parts[0].toLowerCase();
+
+    switch (command) {
+      case "ping":
+        return "Pong!";
+
+      case "help":
+        return HELP_TEXT;
+
+      case "models":
+        return MODELS_TEXT;
+
+      case "status": {
+        const statusTool = this.toolRegistry.get("status");
+        if (statusTool) {
+          const result = await statusTool.execute({});
+          return `**System Status:**\n\`\`\`json\n${result}\n\`\`\``;
+        }
+        return "Status tool not available";
+      }
+
+      case "clear":
+        await this.sessionManager.clearSession(this.jid);
+        return "Conversation history cleared.";
+
+      case "stats": {
+        const stats = await this.sessionManager.getSessionStats(this.jid);
+        return `**Session Stats:**\n- Messages: ${stats.messageCount}\n- First: ${stats.firstMessage || "N/A"}\n- Last: ${stats.lastMessage || "N/A"}`;
+      }
+
+      default:
+        return `Unknown command: /${command}\nType /help for available commands.`;
+    }
+  }
+
+  private async runAgentLoop(
+    provider: LLMProvider,
+    history: ConversationMessage[],
+    currentMessage: string
+  ): Promise<string> {
+    const messages: Message[] = [
+      ...history,
+      { role: "user", content: currentMessage },
+    ];
+
+    const tools = this.toolRegistry.getSchemas();
+
+    let iterations = 0;
+    let finalResponse = "";
+
+    while (iterations < MAX_TOOL_ITERATIONS) {
+      iterations++;
+
+      const response = await provider.chat(messages, {
+        systemPrompt: SYSTEM_PROMPT,
+        tools,
+        maxTokens: 4096,
+      });
+
+      // Handle tool calls
+      if (response.stopReason === "tool_use" && response.toolCalls.length > 0) {
+        // Add assistant message with tool calls
+        if (response.content) {
+          messages.push({ role: "assistant", content: response.content });
+        }
+
+        // Execute each tool
+        for (const toolCall of response.toolCalls) {
+          const tool = this.toolRegistry.get(toolCall.name);
+          if (!tool) {
+            messages.push({
+              role: "user",
+              content: `Tool '${toolCall.name}' not found`,
+            });
+            continue;
+          }
+
+          // Log tool call
+          await this.sessionManager.appendEntry(this.jid, {
+            timestamp: new Date().toISOString(),
+            type: "tool_call",
+            content: JSON.stringify({
+              name: toolCall.name,
+              arguments: toolCall.arguments,
+            }),
+            toolName: toolCall.name,
+            toolCallId: toolCall.id,
+          });
+
+          try {
+            const result = await tool.execute(toolCall.arguments);
+
+            // Log tool result
+            await this.sessionManager.appendEntry(this.jid, {
+              timestamp: new Date().toISOString(),
+              type: "tool_result",
+              content: result,
+              toolName: toolCall.name,
+              toolCallId: toolCall.id,
+            });
+
+            messages.push({
+              role: "user",
+              content: `Tool result for ${toolCall.name}:\n${result}`,
+            });
+          } catch (err) {
+            const errorMsg = `Tool error: ${(err as Error).message}`;
+            messages.push({ role: "user", content: errorMsg });
+          }
+        }
+
+        continue;
+      }
+
+      // No more tool calls, return final response
+      finalResponse = response.content || "";
+      break;
+    }
+
+    if (iterations >= MAX_TOOL_ITERATIONS) {
+      finalResponse += "\n\n(Reached maximum tool iterations)";
+    }
+
+    return finalResponse;
+  }
+}

@@ -0,0 +1,100 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { SessionEntry, ConversationMessage } from "./types.js";
+import { bareJid } from "../xmpp/types.js";
+
+export class SessionManager {
+  private dataDir: string;
+
+  constructor(dataDir: string) {
+    this.dataDir = dataDir;
+  }
+
+  private getSessionDir(jid: string): string {
+    // Sanitize JID for filesystem (replace @ and . with safe chars)
+    const sanitized = bareJid(jid).replace(/@/g, "_at_").replace(/\./g, "_");
+    return path.join(this.dataDir, sanitized);
+  }
+
+  private getContextPath(jid: string): string {
+    return path.join(this.getSessionDir(jid), "context.jsonl");
+  }
+
+  async ensureSessionDir(jid: string): Promise<void> {
+    const dir = this.getSessionDir(jid);
+    await fs.mkdir(dir, { recursive: true });
+  }
+
+  async appendEntry(jid: string, entry: SessionEntry): Promise<void> {
+    await this.ensureSessionDir(jid);
+    const contextPath = this.getContextPath(jid);
+    const line = JSON.stringify(entry) + "\n";
+    await fs.appendFile(contextPath, line, "utf-8");
+  }
+
+  async loadHistory(jid: string): Promise<SessionEntry[]> {
+    const contextPath = this.getContextPath(jid);
+
+    try {
+      const content = await fs.readFile(contextPath, "utf-8");
+      const lines = content.trim().split("\n").filter((l) => l.length > 0);
+      return lines.map((line) => JSON.parse(line) as SessionEntry);
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+  }
+
+  async getConversationHistory(
+    jid: string,
+    maxEntries: number = 50
+  ): Promise<ConversationMessage[]> {
+    const entries = await this.loadHistory(jid);
+    const messages: ConversationMessage[] = [];
+
+    // Take last N entries and convert to conversation format
+    const recentEntries = entries.slice(-maxEntries);
+
+    for (const entry of recentEntries) {
+      if (entry.type === "user") {
+        messages.push({ role: "user", content: entry.content });
+      } else if (entry.type === "assistant") {
+        messages.push({ role: "assistant", content: entry.content });
+      } else if (entry.type === "system") {
+        messages.push({ role: "system", content: entry.content });
+      }
+      // Tool calls and results are embedded in assistant/user messages
+    }
+
+    return messages;
+  }
+
+  async clearSession(jid: string): Promise<void> {
+    const contextPath = this.getContextPath(jid);
+    try {
+      await fs.unlink(contextPath);
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+
+  async getSessionStats(jid: string): Promise<{
+    messageCount: number;
+    firstMessage: string | null;
+    lastMessage: string | null;
+  }> {
+    const entries = await this.loadHistory(jid);
+    const userEntries = entries.filter((e) => e.type === "user");
+
+    return {
+      messageCount: userEntries.length,
+      firstMessage: entries.length > 0 ? entries[0].timestamp : null,
+      lastMessage:
+        entries.length > 0 ? entries[entries.length - 1].timestamp : null,
+    };
+  }
+}

@@ -0,0 +1,27 @@
+import { ModelInfo } from "../config.js";
+
+export interface SessionEntry {
+  timestamp: string;
+  type: "user" | "assistant" | "tool_call" | "tool_result" | "system";
+  content: string;
+  model?: ModelInfo;
+  toolName?: string;
+  toolCallId?: string;
+}
+
+export interface ConversationMessage {
+  role: "user" | "assistant" | "system";
+  content: string;
+}
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+export interface ToolResult {
+  toolCallId: string;
+  result: string;
+  isError?: boolean;
+}

@@ -0,0 +1,155 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { LLMProvider, Message, ToolDefinition, LLMResponse } from "./types.js";
+import { TSchema, Kind } from "@sinclair/typebox";
+
+export class AnthropicProvider implements LLMProvider {
+  name = "anthropic";
+  private client: Anthropic;
+  private model: string;
+
+  constructor(apiKey: string, model: string) {
+    this.client = new Anthropic({ apiKey });
+    this.model = model;
+  }
+
+  async chat(
+    messages: Message[],
+    options: {
+      systemPrompt?: string;
+      tools?: ToolDefinition[];
+      maxTokens?: number;
+    }
+  ): Promise<LLMResponse> {
+    const anthropicMessages: Anthropic.MessageParam[] = messages
+      .filter((m) => m.role !== "system")
+      .map((m) => ({
+        role: m.role as "user" | "assistant",
+        content: m.content,
+      }));
+
+    const tools = options.tools?.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: typeboxToJsonSchema(t.parameters),
+    }));
+
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: options.maxTokens || 4096,
+      system: options.systemPrompt,
+      messages: anthropicMessages,
+      tools: tools as Anthropic.Tool[],
+    });
+
+    let textContent: string | null = null;
+    const toolCalls: LLMResponse["toolCalls"] = [];
+
+    for (const block of response.content) {
+      if (block.type === "text") {
+        textContent = block.text;
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          name: block.name,
+          arguments: block.input as Record<string, unknown>,
+        });
+      }
+    }
+
+    let stopReason: LLMResponse["stopReason"] = "end_turn";
+    if (response.stop_reason === "tool_use") {
+      stopReason = "tool_use";
+    } else if (response.stop_reason === "max_tokens") {
+      stopReason = "max_tokens";
+    }
+
+    return {
+      content: textContent,
+      toolCalls,
+      stopReason,
+    };
+  }
+}
+
+function typeboxToJsonSchema(schema: TSchema): Record<string, unknown> {
+  // Convert TypeBox schema to JSON Schema for Anthropic
+  const result: Record<string, unknown> = {
+    type: getJsonSchemaType(schema),
+  };
+
+  if (schema.description) {
+    result.description = schema.description;
+  }
+
+  if (schema[Kind] === "Object" && schema.properties) {
+    result.properties = {};
+    const required: string[] = [];
+
+    for (const [key, prop] of Object.entries(
+      schema.properties as Record<string, TSchema>
+    )) {
+      (result.properties as Record<string, unknown>)[key] =
+        typeboxToJsonSchema(prop);
+      // In TypeBox, properties are required by default unless wrapped in Type.Optional
+      const optionalSymbol = Symbol.for("TypeBox.Optional");
+      if (prop[Kind] !== "Optional" && !(optionalSymbol in prop)) {
+        required.push(key);
+      }
+    }
+
+    if (required.length > 0) {
+      result.required = required;
+    }
+  }
+
+  if (schema[Kind] === "Array" && schema.items) {
+    result.items = typeboxToJsonSchema(schema.items as TSchema);
+  }
+
+  if (schema[Kind] === "Union" && schema.anyOf) {
+    result.anyOf = (schema.anyOf as TSchema[]).map(typeboxToJsonSchema);
+    delete result.type;
+  }
+
+  if (schema[Kind] === "Literal") {
+    result.const = schema.const;
+  }
+
+  if (schema.default !== undefined) {
+    result.default = schema.default;
+  }
+
+  if (schema.minimum !== undefined) {
+    result.minimum = schema.minimum;
+  }
+
+  if (schema.maximum !== undefined) {
+    result.maximum = schema.maximum;
+  }
+
+  return result;
+}
+
+function getJsonSchemaType(schema: TSchema): string {
+  const kind = schema[Kind];
+  switch (kind) {
+    case "String":
+      return "string";
+    case "Number":
+    case "Integer":
+      return "number";
+    case "Boolean":
+      return "boolean";
+    case "Array":
+      return "array";
+    case "Object":
+      return "object";
+    case "Null":
+      return "null";
+    case "Optional":
+      // Unwrap optional
+      return getJsonSchemaType(schema.anyOf?.[0] || schema);
+    default:
+      return "object";
+  }
+}

@@ -0,0 +1,154 @@
+import {
+  GoogleGenerativeAI,
+  Content,
+  Part,
+  FunctionDeclaration,
+  SchemaType,
+} from "@google/generative-ai";
+import { LLMProvider, Message, ToolDefinition, LLMResponse } from "./types.js";
+import { TSchema, Kind } from "@sinclair/typebox";
+
+export class GoogleProvider implements LLMProvider {
+  name = "google";
+  private client: GoogleGenerativeAI;
+  private model: string;
+
+  constructor(apiKey: string, model: string) {
+    this.client = new GoogleGenerativeAI(apiKey);
+    this.model = model;
+  }
+
+  async chat(
+    messages: Message[],
+    options: {
+      systemPrompt?: string;
+      tools?: ToolDefinition[];
+      maxTokens?: number;
+    }
+  ): Promise<LLMResponse> {
+    const genModel = this.client.getGenerativeModel({
+      model: this.model,
+      systemInstruction: options.systemPrompt,
+    });
+
+    const contents: Content[] = messages
+      .filter((m) => m.role !== "system")
+      .map((m) => ({
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: m.content }] as Part[],
+      }));
+
+    const tools = options.tools?.map((t) => ({
+      functionDeclarations: [
+        {
+          name: t.name,
+          description: t.description,
+          parameters: typeboxToGeminiSchema(t.parameters),
+        } as FunctionDeclaration,
+      ],
+    }));
+
+    const result = await genModel.generateContent({
+      contents,
+      tools,
+      generationConfig: {
+        maxOutputTokens: options.maxTokens || 4096,
+      },
+    });
+
+    const response = result.response;
+    const candidate = response.candidates?.[0];
+
+    if (!candidate) {
+      return {
+        content: null,
+        toolCalls: [],
+        stopReason: "error",
+      };
+    }
+
+    let textContent: string | null = null;
+    const toolCalls: LLMResponse["toolCalls"] = [];
+
+    for (const part of candidate.content.parts) {
+      if ("text" in part && part.text) {
+        textContent = part.text;
+      } else if ("functionCall" in part && part.functionCall) {
+        toolCalls.push({
+          id: `call_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+          name: part.functionCall.name,
+          arguments: (part.functionCall.args as Record<string, unknown>) || {},
+        });
+      }
+    }
+
+    let stopReason: LLMResponse["stopReason"] = "end_turn";
+    if (toolCalls.length > 0) {
+      stopReason = "tool_use";
+    } else if (candidate.finishReason === "MAX_TOKENS") {
+      stopReason = "max_tokens";
+    }
+
+    return {
+      content: textContent,
+      toolCalls,
+      stopReason,
+    };
+  }
+}
+
+function typeboxToGeminiSchema(
+  schema: TSchema
+): FunctionDeclaration["parameters"] {
+  const result: Record<string, unknown> = {
+    type: getGeminiSchemaType(schema),
+  };
+
+  if (schema.description) {
+    result.description = schema.description;
+  }
+
+  if (schema[Kind] === "Object" && schema.properties) {
+    result.properties = {};
+    const required: string[] = [];
+
+    for (const [key, prop] of Object.entries(
+      schema.properties as Record<string, TSchema>
+    )) {
+      (result.properties as Record<string, unknown>)[key] =
+        typeboxToGeminiSchema(prop);
+      if (prop[Kind] !== "Optional") {
+        required.push(key);
+      }
+    }
+
+    if (required.length > 0) {
+      result.required = required;
+    }
+  }
+
+  if (schema[Kind] === "Array" && schema.items) {
+    result.items = typeboxToGeminiSchema(schema.items as TSchema);
+  }
+
+  return result as unknown as FunctionDeclaration["parameters"];
+}
+
+function getGeminiSchemaType(schema: TSchema): SchemaType {
+  const kind = schema[Kind];
+  switch (kind) {
+    case "String":
+      return SchemaType.STRING;
+    case "Number":
+    case "Integer":
+      return SchemaType.NUMBER;
+    case "Boolean":
+      return SchemaType.BOOLEAN;
+    case "Array":
+      return SchemaType.ARRAY;
+    case "Object":
+      return SchemaType.OBJECT;
+    default:
+      return SchemaType.OBJECT;
+  }
+}

@@ -0,0 +1,99 @@
+import { ModelInfo, Provider, ProviderConfig } from "../config.js";
+import { LLMProvider } from "./types.js";
+import { AnthropicProvider } from "./anthropic.js";
+import { GoogleProvider } from "./google.js";
+import { OpenAIProvider } from "./openai.js";
+import { OllamaProvider } from "./ollama.js";
+
+export type { LLMProvider, Message, ToolDefinition, LLMResponse } from "./types.js";
+
+export function createProvider(
+  modelInfo: ModelInfo,
+  providerConfig: ProviderConfig
+): LLMProvider {
+  const { provider, model } = modelInfo;
+
+  switch (provider) {
+    case "anthropic": {
+      const config = providerConfig.anthropic;
+      if (!config) {
+        throw new Error("Anthropic API key not configured");
+      }
+      return new AnthropicProvider(config.apiKey, model);
+    }
+
+    case "google": {
+      const config = providerConfig.google;
+      if (!config) {
+        throw new Error("Google API key not configured");
+      }
+      return new GoogleProvider(config.apiKey, model);
+    }
+
+    case "openai": {
+      const config = providerConfig.openai;
+      if (!config) {
+        throw new Error("OpenAI API key not configured");
+      }
+      return new OpenAIProvider(config.apiKey, model);
+    }
+
+    case "github": {
+      const config = providerConfig.github;
+      if (!config) {
+        throw new Error("GitHub token not configured");
+      }
+      // GitHub Copilot uses OpenAI-compatible API
+      return new OpenAIProvider(
+        config.token,
+        model,
+        "https://api.githubcopilot.com"
+      );
+    }
+
+    case "ollama": {
+      const config = providerConfig.ollama;
+      const baseUrl = config?.baseUrl || "http://localhost:11434";
+      return new OllamaProvider(baseUrl, model);
+    }
+
+    case "groq": {
+      const config = providerConfig.groq;
+      if (!config) {
+        throw new Error("Groq API key not configured");
+      }
+      return new OpenAIProvider(
+        config.apiKey,
+        model,
+        "https://api.groq.com/openai/v1"
+      );
+    }
+
+    case "mistral": {
+      const config = providerConfig.mistral;
+      if (!config) {
+        throw new Error("Mistral API key not configured");
+      }
+      return new OpenAIProvider(
+        config.apiKey,
+        model,
+        "https://api.mistral.ai/v1"
+      );
+    }
+
+    case "openrouter": {
+      const config = providerConfig.openrouter;
+      if (!config) {
+        throw new Error("OpenRouter API key not configured");
+      }
+      return new OpenAIProvider(
+        config.apiKey,
+        model,
+        "https://openrouter.ai/api/v1"
+      );
+    }
+
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}

@@ -0,0 +1,179 @@
+import { LLMProvider, Message, ToolDefinition, LLMResponse } from "./types.js";
+import { TSchema, Kind } from "@sinclair/typebox";
+
+interface OllamaMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+interface OllamaTool {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+interface OllamaToolCall {
+  function: {
+    name: string;
+    arguments: Record<string, unknown>;
+  };
+}
+
+interface OllamaResponse {
+  message: {
+    role: string;
+    content: string;
+    tool_calls?: OllamaToolCall[];
+  };
+  done: boolean;
+  done_reason?: string;
+}
+
+export class OllamaProvider implements LLMProvider {
+  name = "ollama";
+  private baseUrl: string;
+  private model: string;
+
+  constructor(baseUrl: string, model: string) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.model = model;
+  }
+
+  async chat(
+    messages: Message[],
+    options: {
+      systemPrompt?: string;
+      tools?: ToolDefinition[];
+      maxTokens?: number;
+    }
+  ): Promise<LLMResponse> {
+    const ollamaMessages: OllamaMessage[] = [];
+
+    if (options.systemPrompt) {
+      ollamaMessages.push({
+        role: "system",
+        content: options.systemPrompt,
+      });
+    }
+
+    for (const m of messages) {
+      if (m.role === "system") continue;
+      ollamaMessages.push({
+        role: m.role,
+        content: m.content,
+      });
+    }
+
+    const tools: OllamaTool[] | undefined = options.tools?.map((t) => ({
+      type: "function" as const,
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: typeboxToJsonSchema(t.parameters),
+      },
+    }));
+
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: this.model,
+        messages: ollamaMessages,
+        tools: tools?.length ? tools : undefined,
+        stream: false,
+        options: {
+          num_predict: options.maxTokens || 4096,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as OllamaResponse;
+
+    const textContent = data.message.content || null;
+    const toolCalls: LLMResponse["toolCalls"] = [];
+
+    if (data.message.tool_calls) {
+      for (const tc of data.message.tool_calls) {
+        toolCalls.push({
+          id: `call_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+          name: tc.function.name,
+          arguments: tc.function.arguments || {},
+        });
+      }
+    }
+
+    let stopReason: LLMResponse["stopReason"] = "end_turn";
+    if (toolCalls.length > 0) {
+      stopReason = "tool_use";
+    } else if (data.done_reason === "length") {
+      stopReason = "max_tokens";
+    }
+
+    return {
+      content: textContent,
+      toolCalls,
+      stopReason,
+    };
+  }
+}
+
+function typeboxToJsonSchema(schema: TSchema): Record<string, unknown> {
+  const result: Record<string, unknown> = {
+    type: getJsonSchemaType(schema),
+  };
+
+  if (schema.description) {
+    result.description = schema.description;
+  }
+
+  if (schema[Kind] === "Object" && schema.properties) {
+    result.properties = {};
+    const required: string[] = [];
+
+    for (const [key, prop] of Object.entries(
+      schema.properties as Record<string, TSchema>
+    )) {
+      (result.properties as Record<string, unknown>)[key] =
+        typeboxToJsonSchema(prop);
+      if (prop[Kind] !== "Optional") {
+        required.push(key);
+      }
+    }
+
+    if (required.length > 0) {
+      result.required = required;
+    }
+  }
+
+  if (schema[Kind] === "Array" && schema.items) {
+    result.items = typeboxToJsonSchema(schema.items as TSchema);
+  }
+
+  return result;
+}
+
+function getJsonSchemaType(schema: TSchema): string {
+  const kind = schema[Kind];
+  switch (kind) {
+    case "String":
+      return "string";
+    case "Number":
+    case "Integer":
+      return "number";
+    case "Boolean":
+      return "boolean";
+    case "Array":
+      return "array";
+    case "Object":
+      return "object";
+    default:
+      return "object";
+  }
+}

@@ -0,0 +1,159 @@
+import OpenAI from "openai";
+import { LLMProvider, Message, ToolDefinition, LLMResponse } from "./types.js";
+import { TSchema, Kind } from "@sinclair/typebox";
+
+export class OpenAIProvider implements LLMProvider {
+  name = "openai";
+  private client: OpenAI;
+  private model: string;
+
+  constructor(apiKey: string, model: string, baseUrl?: string) {
+    this.client = new OpenAI({
+      apiKey,
+      baseURL: baseUrl,
+    });
+    this.model = model;
+  }
+
+  async chat(
+    messages: Message[],
+    options: {
+      systemPrompt?: string;
+      tools?: ToolDefinition[];
+      maxTokens?: number;
+    }
+  ): Promise<LLMResponse> {
+    const openaiMessages: OpenAI.ChatCompletionMessageParam[] = [];
+
+    if (options.systemPrompt) {
+      openaiMessages.push({
+        role: "system",
+        content: options.systemPrompt,
+      });
+    }
+
+    for (const m of messages) {
+      if (m.role === "system") continue;
+      openaiMessages.push({
+        role: m.role,
+        content: m.content,
+      });
+    }
+
+    const tools = options.tools?.map((t) => ({
+      type: "function" as const,
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: typeboxToJsonSchema(t.parameters),
+      },
+    }));
+
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages: openaiMessages,
+      tools: tools?.length ? tools : undefined,
+      max_tokens: options.maxTokens || 4096,
+    });
+
+    const choice = response.choices[0];
+    if (!choice) {
+      return {
+        content: null,
+        toolCalls: [],
+        stopReason: "error",
+      };
+    }
+
+    const textContent = choice.message.content;
+    const toolCalls: LLMResponse["toolCalls"] = [];
+
+    if (choice.message.tool_calls) {
+      for (const tc of choice.message.tool_calls) {
+        if (tc.type === "function") {
+          toolCalls.push({
+            id: tc.id,
+            name: tc.function.name,
+            arguments: JSON.parse(tc.function.arguments || "{}"),
+          });
+        }
+      }
+    }
+
+    let stopReason: LLMResponse["stopReason"] = "end_turn";
+    if (choice.finish_reason === "tool_calls") {
+      stopReason = "tool_use";
+    } else if (choice.finish_reason === "length") {
+      stopReason = "max_tokens";
+    }
+
+    return {
+      content: textContent,
+      toolCalls,
+      stopReason,
+    };
+  }
+}
+
+function typeboxToJsonSchema(schema: TSchema): Record<string, unknown> {
+  const result: Record<string, unknown> = {
+    type: getJsonSchemaType(schema),
+  };
+
+  if (schema.description) {
+    result.description = schema.description;
+  }
+
+  if (schema[Kind] === "Object" && schema.properties) {
+    result.properties = {};
+    const required: string[] = [];
+
+    for (const [key, prop] of Object.entries(
+      schema.properties as Record<string, TSchema>
+    )) {
+      (result.properties as Record<string, unknown>)[key] =
+        typeboxToJsonSchema(prop);
+      if (prop[Kind] !== "Optional") {
+        required.push(key);
+      }
+    }
+
+    if (required.length > 0) {
+      result.required = required;
+    }
+  }
+
+  if (schema[Kind] === "Array" && schema.items) {
+    result.items = typeboxToJsonSchema(schema.items as TSchema);
+  }
+
+  if (schema[Kind] === "Union" && schema.anyOf) {
+    result.anyOf = (schema.anyOf as TSchema[]).map(typeboxToJsonSchema);
+    delete result.type;
+  }
+
+  if (schema.default !== undefined) {
+    result.default = schema.default;
+  }
+
+  return result;
+}
+
+function getJsonSchemaType(schema: TSchema): string {
+  const kind = schema[Kind];
+  switch (kind) {
+    case "String":
+      return "string";
+    case "Number":
+    case "Integer":
+      return "number";
+    case "Boolean":
+      return "boolean";
+    case "Array":
+      return "array";
+    case "Object":
+      return "object";
+    default:
+      return "object";
+  }
+}

@@ -0,0 +1,46 @@
+import { TSchema } from "@sinclair/typebox";
+
+export interface Message {
+  role: "user" | "assistant" | "system";
+  content: string;
+}
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: TSchema;
+}
+
+export interface ToolCallRequest {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+export interface LLMResponse {
+  content: string | null;
+  toolCalls: ToolCallRequest[];
+  stopReason: "end_turn" | "tool_use" | "max_tokens" | "error";
+}
+
+export interface ToolResultMessage {
+  role: "user";
+  content: Array<{
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+  }>;
+}
+
+export interface LLMProvider {
+  name: string;
+  chat(
+    messages: Message[],
+    options: {
+      systemPrompt?: string;
+      tools?: ToolDefinition[];
+      maxTokens?: number;
+    }
+  ): Promise<LLMResponse>;
+}

@@ -0,0 +1,35 @@
+import { Tool, ToolRegistry } from "./types.js";
+import { createStatusTool } from "./status.js";
+import { createOrgmodeTool } from "./orgmode.js";
+import { createResearchTool } from "./research.js";
+import { createWebSearchTool } from "./websearch.js";
+import { Config } from "../config.js";
+
+export function createToolRegistry(config: Config): ToolRegistry {
+  const tools = new Map<string, Tool>();
+
+  const registry: ToolRegistry = {
+    tools,
+    register: (tool: Tool) => {
+      tools.set(tool.name, tool);
+    },
+    get: (name: string) => tools.get(name),
+    list: () => Array.from(tools.values()),
+    getSchemas: () =>
+      Array.from(tools.values()).map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+      })),
+  };
+
+  // Register default tools
+  registry.register(createStatusTool());
+  registry.register(createOrgmodeTool(config.paths.inboxPath));
+  registry.register(createResearchTool());
+  registry.register(createWebSearchTool());
+
+  return registry;
+}
+
+export type { Tool, ToolRegistry } from "./types.js";

@@ -0,0 +1,85 @@
+import { Type } from "@sinclair/typebox";
+import { Tool } from "./types.js";
+import * as fs from "fs/promises";
+
+const OrgmodeParams = Type.Object({
+  title: Type.String({ description: "Title for the org entry" }),
+  content: Type.String({ description: "Content to save (markdown or plain text)" }),
+  tags: Type.Optional(
+    Type.Array(Type.String(), { description: "Optional tags for the entry" })
+  ),
+});
+
+type OrgmodeArgs = typeof OrgmodeParams.static;
+
+export function createOrgmodeTool(inboxPath: string): Tool<OrgmodeArgs> {
+  return {
+    name: "save_to_org",
+    description:
+      "Save content to the org-mode inbox file. Use for saving research results, notes, or any content the user wants to keep.",
+    parameters: OrgmodeParams,
+    execute: async (args) => {
+      const { title, content, tags } = args;
+
+      const timestamp = new Date().toISOString();
+      const dateStr = timestamp.slice(0, 10);
+      const timeStr = timestamp.slice(11, 16);
+
+      // Format tags for org-mode
+      const tagStr = tags && tags.length > 0 ? `:${tags.join(":")}:` : "";
+
+      // Convert markdown to org-mode (basic conversion)
+      const orgContent = convertMarkdownToOrg(content);
+
+      // Create org entry
+      const entry = `
+* TODO ${title} ${tagStr}
+:PROPERTIES:
+:CREATED: [${dateStr} ${timeStr}]
+:SOURCE: daneel
+:END:
+
+${orgContent}
+`;
+
+      // Append to inbox file
+      await fs.appendFile(inboxPath, entry, "utf-8");
+
+      return `Saved to org inbox: "${title}"`;
+    },
+  };
+}
+
+function convertMarkdownToOrg(markdown: string): string {
+  let org = markdown;
+
+  // Convert headers (### -> ***)
+  org = org.replace(/^### (.+)$/gm, "*** $1");
+  org = org.replace(/^## (.+)$/gm, "** $1");
+  org = org.replace(/^# (.+)$/gm, "* $1");
+
+  // Convert bold (**text** -> *text*)
+  org = org.replace(/\*\*(.+?)\*\*/g, "*$1*");
+
+  // Convert italic (*text* or _text_ -> /text/)
+  // Be careful not to convert already-converted bold
+  org = org.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, "/$1/");
+  org = org.replace(/_(.+?)_/g, "/$1/");
+
+  // Convert inline code (`code` -> =code=)
+  org = org.replace(/`([^`]+)`/g, "=$1=");
+
+  // Convert code blocks
+  org = org.replace(/```(\w*)\n([\s\S]*?)```/g, (_, lang, code) => {
+    const langStr = lang ? ` ${lang}` : "";
+    return `#+BEGIN_SRC${langStr}\n${code}#+END_SRC`;
+  });
+
+  // Convert links [text](url) -> [[url][text]]
+  org = org.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "[[$2][$1]]");
+
+  // Convert unordered lists (- item -> - item, already compatible)
+  // Convert ordered lists (1. item -> 1. item, already compatible)
+
+  return org;
+}

@@ -0,0 +1,41 @@
+import { Type } from "@sinclair/typebox";
+import { Tool } from "./types.js";
+
+const ResearchParams = Type.Object({
+  query: Type.String({ description: "The research query or question" }),
+  depth: Type.Optional(
+    Type.Union([Type.Literal("quick"), Type.Literal("thorough")], {
+      description: "How deep to research: quick for fast answers, thorough for comprehensive research",
+      default: "quick",
+    })
+  ),
+});
+
+type ResearchArgs = typeof ResearchParams.static;
+
+export function createResearchTool(): Tool<ResearchArgs> {
+  return {
+    name: "research",
+    description:
+      "Research a topic or answer a question. Use this for queries that require gathering information or analysis.",
+    parameters: ResearchParams,
+    execute: async (args) => {
+      const { query, depth = "quick" } = args;
+
+      // For now, this is a placeholder that returns a message
+      // In a full implementation, this could:
+      // - Call web search APIs
+      // - Query knowledge bases
+      // - Use RAG with local documents
+      // - Aggregate multiple sources
+
+      return JSON.stringify({
+        query,
+        depth,
+        note: "Research tool executed. In the current implementation, the LLM should answer based on its training data. Future versions will integrate web search and other data sources.",
+        suggestion:
+          "Provide your best answer based on your knowledge. If you need real-time data, inform the user that web search is not yet implemented.",
+      });
+    },
+  };
+}

@@ -0,0 +1,71 @@
+import { Type } from "@sinclair/typebox";
+import { Tool } from "./types.js";
+import * as os from "os";
+
+const StatusParams = Type.Object({});
+
+type StatusArgs = typeof StatusParams.static;
+
+export function createStatusTool(): Tool<StatusArgs> {
+  return {
+    name: "status",
+    description:
+      "Get system status including uptime, memory usage, and bot information",
+    parameters: StatusParams,
+    execute: async () => {
+      const uptime = process.uptime();
+      const memUsage = process.memoryUsage();
+      const systemUptime = os.uptime();
+
+      const formatBytes = (bytes: number): string => {
+        const mb = bytes / 1024 / 1024;
+        return `${mb.toFixed(1)} MB`;
+      };
+
+      const formatDuration = (seconds: number): string => {
+        const days = Math.floor(seconds / 86400);
+        const hours = Math.floor((seconds % 86400) / 3600);
+        const mins = Math.floor((seconds % 3600) / 60);
+        const secs = Math.floor(seconds % 60);
+
+        const parts = [];
+        if (days > 0) parts.push(`${days}d`);
+        if (hours > 0) parts.push(`${hours}h`);
+        if (mins > 0) parts.push(`${mins}m`);
+        if (secs > 0 || parts.length === 0) parts.push(`${secs}s`);
+        return parts.join(" ");
+      };
+
+      return JSON.stringify(
+        {
+          bot: {
+            name: "Daneel",
+            version: "0.1.0",
+            uptime: formatDuration(uptime),
+          },
+          system: {
+            hostname: os.hostname(),
+            platform: os.platform(),
+            arch: os.arch(),
+            uptime: formatDuration(systemUptime),
+            loadAvg: os.loadavg().map((l) => l.toFixed(2)),
+          },
+          memory: {
+            process: {
+              heapUsed: formatBytes(memUsage.heapUsed),
+              heapTotal: formatBytes(memUsage.heapTotal),
+              rss: formatBytes(memUsage.rss),
+            },
+            system: {
+              total: formatBytes(os.totalmem()),
+              free: formatBytes(os.freemem()),
+              used: formatBytes(os.totalmem() - os.freemem()),
+            },
+          },
+        },
+        null,
+        2
+      );
+    },
+  };
+}

@@ -0,0 +1,25 @@
+import { TSchema } from "@sinclair/typebox";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface Tool<T = any> {
+  name: string;
+  description: string;
+  parameters: TSchema;
+  execute: (args: T) => Promise<string>;
+}
+
+export interface ToolRegistry {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  tools: Map<string, Tool<any>>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  register: (tool: Tool<any>) => void;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get: (name: string) => Tool<any> | undefined;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  list: () => Tool<any>[];
+  getSchemas: () => Array<{
+    name: string;
+    description: string;
+    parameters: TSchema;
+  }>;
+}

@@ -0,0 +1,43 @@
+import { Type } from "@sinclair/typebox";
+import { Tool } from "./types.js";
+
+const WebSearchParams = Type.Object({
+  query: Type.String({ description: "The search query" }),
+  maxResults: Type.Optional(
+    Type.Number({
+      description: "Maximum number of results to return",
+      default: 5,
+      minimum: 1,
+      maximum: 10,
+    })
+  ),
+});
+
+type WebSearchArgs = typeof WebSearchParams.static;
+
+export function createWebSearchTool(): Tool<WebSearchArgs> {
+  return {
+    name: "web_search",
+    description:
+      "Search the web for current information. Use this for queries that require up-to-date data.",
+    parameters: WebSearchParams,
+    execute: async (args) => {
+      const { query, maxResults = 5 } = args;
+
+      // Placeholder implementation
+      // Future: integrate with search APIs like:
+      // - DuckDuckGo API
+      // - Brave Search API
+      // - SearXNG instance
+      // - Tavily API
+
+      return JSON.stringify({
+        query,
+        maxResults,
+        status: "not_implemented",
+        message:
+          "Web search is not yet implemented. Please rely on training data or ask the user to provide the information.",
+      });
+    },
+  };
+}

@@ -0,0 +1,111 @@
+import { client, xml, jid } from "@xmpp/client";
+import type { Element } from "@xmpp/xml";
+import { XmppMessage, bareJid } from "./types.js";
+import { Config } from "../config.js";
+
+export type MessageHandler = (message: XmppMessage) => Promise<void>;
+
+export class XmppClient {
+  private xmpp: ReturnType<typeof client>;
+  private messageHandler: MessageHandler | null = null;
+  private config: Config;
+
+  constructor(config: Config) {
+    this.config = config;
+
+    this.xmpp = client({
+      service: `xmpp://${jid(config.xmpp.jid).domain}`,
+      username: jid(config.xmpp.jid).local,
+      password: config.xmpp.password,
+    });
+
+    this.setupEventHandlers();
+  }
+
+  private setupEventHandlers(): void {
+    this.xmpp.on("error", (err: Error) => {
+      console.error("XMPP error:", err.message);
+    });
+
+    this.xmpp.on("offline", () => {
+      console.log("XMPP offline");
+    });
+
+    this.xmpp.on("online", async (address: ReturnType<typeof jid>) => {
+      console.log(`XMPP online as ${address.toString()}`);
+
+      // Send initial presence
+      await this.xmpp.send(xml("presence"));
+    });
+
+    this.xmpp.on("stanza", async (stanza: Element) => {
+      if (stanza.is("message")) {
+        await this.handleMessage(stanza);
+      }
+    });
+  }
+
+  private async handleMessage(stanza: Element): Promise<void> {
+    const type = stanza.attrs.type as "chat" | "groupchat" | undefined;
+
+    // Only handle chat messages (direct messages)
+    if (type !== "chat") {
+      return;
+    }
+
+    const body = stanza.getChildText("body");
+    if (!body) {
+      return;
+    }
+
+    const from = stanza.attrs.from as string;
+    const to = stanza.attrs.to as string;
+    const id = stanza.attrs.id as string | undefined;
+
+    // Security: only respond to owner
+    if (bareJid(from) !== bareJid(this.config.xmpp.ownerJid)) {
+      console.log(`Ignoring message from unauthorized JID: ${bareJid(from)}`);
+      return;
+    }
+
+    const message: XmppMessage = {
+      from,
+      to,
+      body,
+      type: "chat",
+      id,
+    };
+
+    if (this.messageHandler) {
+      try {
+        await this.messageHandler(message);
+      } catch (err) {
+        console.error("Error handling message:", err);
+        await this.sendMessage(from, `Error: ${(err as Error).message}`);
+      }
+    }
+  }
+
+  onMessage(handler: MessageHandler): void {
+    this.messageHandler = handler;
+  }
+
+  async sendMessage(to: string, body: string): Promise<void> {
+    const message = xml(
+      "message",
+      { type: "chat", to },
+      xml("body", {}, body)
+    );
+    await this.xmpp.send(message);
+  }
+
+  async start(): Promise<void> {
+    console.log("Starting XMPP client...");
+    await this.xmpp.start();
+  }
+
+  async stop(): Promise<void> {
+    console.log("Stopping XMPP client...");
+    await this.xmpp.stop();
+  }
+}

@@ -0,0 +1,36 @@
+export interface XmppMessage {
+  from: string;
+  to: string;
+  body: string;
+  type: "chat" | "groupchat";
+  id?: string;
+}
+
+export interface XmppPresence {
+  from: string;
+  to: string;
+  type?: "available" | "unavailable" | "subscribe" | "subscribed";
+  show?: "away" | "chat" | "dnd" | "xa";
+  status?: string;
+}
+
+// Extract bare JID (without resource)
+export function bareJid(jid: string): string {
+  return jid.split("/")[0];
+}
+
+// Extract resource from JID
+export function resourceFromJid(jid: string): string | null {
+  const parts = jid.split("/");
+  return parts.length > 1 ? parts[1] : null;
+}
+
+// Extract local part (username) from JID
+export function localFromJid(jid: string): string {
+  return bareJid(jid).split("@")[0];
+}
+
+// Extract domain from JID
+export function domainFromJid(jid: string): string {
+  return bareJid(jid).split("@")[1];
+}