Commit de6e32e39033

@@ -46,10 +46,10 @@ in
       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)";
+    geminiApiKeyFile = lib.mkOption {
+      type = lib.types.nullOr lib.types.path;
+      default = null;
+      description = "Path to file containing Google Gemini API key";
     };
 
     anthropicApiKeyFile = lib.mkOption {
@@ -58,23 +58,17 @@ in
       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 {
+    searxngUrl = lib.mkOption {
       type = lib.types.nullOr lib.types.str;
       default = null;
-      example = "http://localhost:11434";
-      description = "Base URL for Ollama API";
+      example = "https://search.sbr.pm";
+      description = "URL of SearXNG instance for web search";
     };
 
     debug = lib.mkOption {
@@ -97,6 +91,16 @@ in
   };
 
   config = lib.mkIf cfg.enable {
+    assertions = [
+      {
+        assertion =
+          cfg.geminiApiKeyFile != null
+          || cfg.anthropicApiKeyFile != null
+          || cfg.openaiApiKeyFile != null;
+        message = "At least one API key file must be configured for Daneel (geminiApiKeyFile, anthropicApiKeyFile, or openaiApiKeyFile)";
+      }
+    ];
+
     users.users.${cfg.user} = {
       isSystemUser = true;
       group = cfg.group;
@@ -116,7 +120,6 @@ in
         User = cfg.user;
         Group = cfg.group;
         WorkingDirectory = cfg.dataDir;
-        ExecStart = "${cfg.package}/bin/daneel";
         Restart = "always";
         RestartSec = "10s";
 
@@ -136,7 +139,6 @@ in
         ];
         RestrictNamespaces = true;
         LockPersonality = true;
-        MemoryDenyWriteExecute = true;
         RestrictRealtime = true;
         RestrictSUIDSGID = true;
         PrivateDevices = true;
@@ -148,20 +150,19 @@ in
         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.geminiApiKeyFile != null) ''
+          export GEMINI_API_KEY="$(cat ${cfg.geminiApiKeyFile})"
+        ''}
         ${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}"
+        ${lib.optionalString (cfg.searxngUrl != null) ''
+          export SEARXNG_URL="${cfg.searxngUrl}"
         ''}
 
         exec ${cfg.package}/bin/daneel

@@ -2,15 +2,18 @@
   lib,
   buildNpmPackage,
   nodejs_22,
+  ddgr,
+  makeWrapper,
 }:
 
 buildNpmPackage {
   pname = "daneel";
-  version = "0.1.0";
+  version = "0.2.0";
 
   src = ./..;
 
   nodejs = nodejs_22;
+  nativeBuildInputs = [ makeWrapper ];
 
   npmDepsHash = lib.fakeHash;
 
@@ -30,16 +33,20 @@ buildNpmPackage {
     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");
+    cat > $out/bin/daneel <<'EOF'
+    #!/usr/bin/env node
+    import("$out/lib/daneel/dist/main-pi.js");
     EOF
     chmod +x $out/bin/daneel
+
+    # Wrap to include ddgr in PATH (for web search)
+    wrapProgram $out/bin/daneel \
+      --prefix PATH : ${lib.makeBinPath [ ddgr ]}
     runHook postInstall
   '';
 
   meta = {
-    description = "XMPP research bot using AI";
+    description = "XMPP research bot using Pi AI toolkit";
     homepage = "https://codeberg.org/vdemeester/daneel";
     license = lib.licenses.asl20;
     maintainers = [ ];

@@ -1,80 +0,0 @@
-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 |`;

@@ -1,223 +0,0 @@
-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;
-  }
-}

@@ -1,100 +0,0 @@
-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,
-    };
-  }
-}

@@ -1,27 +0,0 @@
-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;
-}

@@ -1,155 +0,0 @@
-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";
-  }
-}

@@ -1,154 +0,0 @@
-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;
-  }
-}

@@ -1,99 +0,0 @@
-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}`);
-  }
-}

@@ -1,179 +0,0 @@
-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";
-  }
-}

@@ -1,159 +0,0 @@
-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";
-  }
-}

@@ -1,46 +0,0 @@
-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>;
-}

@@ -1,122 +0,0 @@
-#!/usr/bin/env node
-/**
- * Temporary test runner for Pi-based Daneel
- * This is a quick integration to test current progress
- * Will be replaced by proper XMPP integration in Phase 6
- */
-
-import { XmppClient } from "../xmpp/client.js";
-import { XmppAgent } from "./agent-wrapper.js";
-import { getModel } from "@mariozechner/pi-ai";
-import { bareJid } from "../xmpp/types.js";
-import { statusTool } from "./tools/status.js";
-
-interface XmppConfig {
-  jid: string;
-  password: string;
-  ownerJid: string;
-}
-
-function loadConfig(): XmppConfig {
-  const jid = process.env.DANEEL_XMPP_JID;
-  const password = process.env.DANEEL_XMPP_PASSWORD;
-  const ownerJid = process.env.DANEEL_OWNER_JID;
-
-  if (!jid || !password || !ownerJid) {
-    console.error("Missing required environment variables:");
-    console.error("  DANEEL_XMPP_JID");
-    console.error("  DANEEL_XMPP_PASSWORD");
-    console.error("  DANEEL_OWNER_JID");
-    process.exit(1);
-  }
-
-  return { jid, password, ownerJid };
-}
-
-async function main() {
-  console.log("Daneel - XMPP Research Bot (Pi Edition)");
-  console.log("=========================================\n");
-
-  const config = loadConfig();
-  
-  // Determine default model
-  const defaultModel = getModel("google", "gemini-2.0-flash");
-  console.log("Using default model: Google Gemini 2.0 Flash");
-
-  // Map of JID -> XmppAgent
-  const agents = new Map<string, XmppAgent>();
-
-  function getOrCreateAgent(jid: string): XmppAgent {
-    const bare = bareJid(jid);
-    let agent = agents.get(bare);
-    
-    if (!agent) {
-      console.log(`Creating new agent for JID: ${bare}`);
-      // Create agent with status tool
-      agent = new XmppAgent(bare, defaultModel, [statusTool]);
-      agents.set(bare, agent);
-    }
-    
-    return agent;
-  }
-
-  // Create XMPP client
-  const xmpp = new XmppClient({
-    xmpp: {
-      jid: config.jid,
-      password: config.password,
-      ownerJid: config.ownerJid,
-    },
-    llm: {
-      defaultModel: { provider: "google" as any, model: "gemini-2.0-flash" },
-      providers: {},
-    },
-    paths: {
-      dataDir: "./data",
-      inboxPath: process.env.DANEEL_INBOX_PATH || "~/desktop/org/inbox.org",
-    },
-    debug: process.env.DANEEL_DEBUG === "true",
-  });
-
-  // Set up message handler
-  xmpp.onMessage(async (message) => {
-    console.log(`[${new Date().toISOString()}] Message from ${bareJid(message.from)}: ${message.body.slice(0, 50)}...`);
-    
-    try {
-      const agent = getOrCreateAgent(message.from);
-      const response = await agent.processMessage(message.body);
-      
-      await xmpp.sendMessage(message.from, response);
-      console.log(`[${new Date().toISOString()}] Response sent (${response.length} chars)`);
-    } catch (error) {
-      console.error("Error processing message:", error);
-      await xmpp.sendMessage(
-        message.from,
-        `Error processing your message: ${error instanceof Error ? error.message : 'Unknown error'}`
-      );
-    }
-  });
-
-  // Graceful shutdown
-  const shutdown = async (signal: string) => {
-    console.log(`\nReceived ${signal}, shutting down...`);
-    await xmpp.stop();
-    process.exit(0);
-  };
-
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-
-  // Start XMPP client
-  console.log("\nConnecting to XMPP server...");
-  console.log(`Bot JID: ${config.jid}`);
-  console.log(`Owner JID: ${config.ownerJid}`);
-  console.log("\nWaiting for messages...\n");
-  
-  await xmpp.start();
-}
-
-main().catch((error) => {
-  console.error("Fatal error:", error);
-  process.exit(1);
-});

@@ -1,35 +0,0 @@
-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";

@@ -1,85 +0,0 @@
-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;
-}

@@ -1,41 +0,0 @@
-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.",
-      });
-    },
-  };
-}

@@ -1,71 +0,0 @@
-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
-      );
-    },
-  };
-}

@@ -1,25 +0,0 @@
-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;
-  }>;
-}

@@ -1,43 +0,0 @@
-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.",
-      });
-    },
-  };
-}

@@ -1,22 +1,27 @@
 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 interface XmppConfig {
+  jid: string;
+  password: string;
+  ownerJid: string;
+}
 
 export type MessageHandler = (message: XmppMessage) => Promise<void>;
 
 export class XmppClient {
   private xmpp: ReturnType<typeof client>;
   private messageHandler: MessageHandler | null = null;
-  private config: Config;
+  private ownerJid: string;
 
-  constructor(config: Config) {
-    this.config = config;
+  constructor(config: XmppConfig) {
+    this.ownerJid = config.ownerJid;
 
     this.xmpp = client({
-      service: `xmpp://${jid(config.xmpp.jid).domain}`,
-      username: jid(config.xmpp.jid).local,
-      password: config.xmpp.password,
+      service: `xmpp://${jid(config.jid).domain}`,
+      username: jid(config.jid).local,
+      password: config.password,
     });
 
     this.setupEventHandlers();
@@ -63,7 +68,7 @@ export class XmppClient {
     const id = stanza.attrs.id as string | undefined;
 
     // Security: only respond to owner
-    if (bareJid(from) !== bareJid(this.config.xmpp.ownerJid)) {
+    if (bareJid(from) !== bareJid(this.ownerJid)) {
       console.log(`Ignoring message from unauthorized JID: ${bareJid(from)}`);
       return;
     }

@@ -1,211 +0,0 @@
-import * as path from "path";
-import * as os from "os";
-
-// Model aliases for easy selection
-export type ModelAlias =
-  // Anthropic
-  | "opus"
-  | "sonnet"
-  | "haiku"
-  // Google
-  | "gemini"
-  | "gemini-pro"
-  | "gemini-flash"
-  // OpenAI
-  | "gpt4"
-  | "gpt4o"
-  | "o1"
-  | "o3"
-  // GitHub Copilot
-  | "copilot"
-  | "copilot-claude"
-  // Ollama (local)
-  | "ollama"
-  | "llama"
-  | "qwen"
-  | "deepseek"
-  // Others
-  | "groq"
-  | "mistral";
-
-export type Provider =
-  | "anthropic"
-  | "google"
-  | "openai"
-  | "github"
-  | "ollama"
-  | "groq"
-  | "mistral"
-  | "openrouter";
-
-export interface ProviderConfig {
-  anthropic?: { apiKey: string };
-  google?: { apiKey: string };
-  openai?: { apiKey: string };
-  github?: { token: string };
-  ollama?: { baseUrl: string };
-  openrouter?: { apiKey: string };
-  groq?: { apiKey: string };
-  mistral?: { apiKey: string };
-}
-
-export interface ModelInfo {
-  provider: Provider;
-  model: string;
-}
-
-// Model prefix mapping for message parsing
-export const MODEL_PREFIXES: Record<string, ModelInfo> = {
-  // Anthropic
-  "opus:": { provider: "anthropic", model: "claude-opus-4-5-20250514" },
-  "o:": { provider: "anthropic", model: "claude-opus-4-5-20250514" },
-  "sonnet:": { provider: "anthropic", model: "claude-sonnet-4-20250514" },
-  "s:": { provider: "anthropic", model: "claude-sonnet-4-20250514" },
-  "haiku:": { provider: "anthropic", model: "claude-3-5-haiku-20241022" },
-  "h:": { provider: "anthropic", model: "claude-3-5-haiku-20241022" },
-
-  // Google
-  "gemini:": { provider: "google", model: "gemini-2.0-flash" },
-  "g:": { provider: "google", model: "gemini-2.0-flash" },
-  "gemini-pro:": { provider: "google", model: "gemini-2.5-pro-preview-05-06" },
-  "gp:": { provider: "google", model: "gemini-2.5-pro-preview-05-06" },
-
-  // OpenAI
-  "gpt:": { provider: "openai", model: "gpt-4o" },
-  "gpt4:": { provider: "openai", model: "gpt-4o" },
-  "o1:": { provider: "openai", model: "o1" },
-  "o3:": { provider: "openai", model: "o3-mini" },
-
-  // GitHub Copilot
-  "copilot:": { provider: "github", model: "gpt-4o" },
-  "cp:": { provider: "github", model: "gpt-4o" },
-  "copilot-claude:": { provider: "github", model: "claude-sonnet-4" },
-
-  // Ollama (local)
-  "ollama:": { provider: "ollama", model: "llama3.2" },
-  "llama:": { provider: "ollama", model: "llama3.2" },
-  "qwen:": { provider: "ollama", model: "qwen2.5" },
-  "deepseek:": { provider: "ollama", model: "deepseek-r1" },
-
-  // Others
-  "groq:": { provider: "groq", model: "llama-3.3-70b-versatile" },
-  "mistral:": { provider: "mistral", model: "mistral-large-latest" },
-};
-
-export interface XmppConfig {
-  jid: string;
-  password: string;
-  ownerJid: string;
-}
-
-export interface PathsConfig {
-  dataDir: string;
-  inboxPath: string;
-}
-
-export interface Config {
-  xmpp: XmppConfig;
-  llm: {
-    defaultModel: ModelInfo;
-    providers: ProviderConfig;
-  };
-  paths: PathsConfig;
-  debug: boolean;
-}
-
-function getEnvOrThrow(name: string): string {
-  const value = process.env[name];
-  if (!value) {
-    throw new Error(`Required environment variable ${name} is not set`);
-  }
-  return value;
-}
-
-function getEnvOrDefault(name: string, defaultValue: string): string {
-  return process.env[name] || defaultValue;
-}
-
-export function loadConfig(): Config {
-  const xmppJid = getEnvOrThrow("DANEEL_XMPP_JID");
-  const xmppPassword = getEnvOrThrow("DANEEL_XMPP_PASSWORD");
-  const ownerJid = getEnvOrThrow("DANEEL_OWNER_JID");
-
-  const dataDir = getEnvOrDefault(
-    "DANEEL_DATA_DIR",
-    path.join(process.cwd(), "data")
-  );
-
-  const inboxPath = getEnvOrDefault(
-    "DANEEL_INBOX_PATH",
-    path.join(os.homedir(), "org", "inbox.org")
-  );
-
-  const defaultModelPrefix = getEnvOrDefault("DANEEL_DEFAULT_MODEL", "sonnet");
-  const defaultModel = MODEL_PREFIXES[`${defaultModelPrefix}:`] || {
-    provider: "anthropic" as Provider,
-    model: "claude-sonnet-4-20250514",
-  };
-
-  const providers: ProviderConfig = {};
-
-  // Load provider credentials from environment
-  if (process.env.ANTHROPIC_API_KEY) {
-    providers.anthropic = { apiKey: process.env.ANTHROPIC_API_KEY };
-  }
-  if (process.env.GOOGLE_API_KEY) {
-    providers.google = { apiKey: process.env.GOOGLE_API_KEY };
-  }
-  if (process.env.OPENAI_API_KEY) {
-    providers.openai = { apiKey: process.env.OPENAI_API_KEY };
-  }
-  if (process.env.GITHUB_TOKEN) {
-    providers.github = { token: process.env.GITHUB_TOKEN };
-  }
-  if (process.env.OLLAMA_BASE_URL) {
-    providers.ollama = {
-      baseUrl: getEnvOrDefault("OLLAMA_BASE_URL", "http://localhost:11434"),
-    };
-  }
-  if (process.env.GROQ_API_KEY) {
-    providers.groq = { apiKey: process.env.GROQ_API_KEY };
-  }
-  if (process.env.MISTRAL_API_KEY) {
-    providers.mistral = { apiKey: process.env.MISTRAL_API_KEY };
-  }
-  if (process.env.OPENROUTER_API_KEY) {
-    providers.openrouter = { apiKey: process.env.OPENROUTER_API_KEY };
-  }
-
-  return {
-    xmpp: {
-      jid: xmppJid,
-      password: xmppPassword,
-      ownerJid,
-    },
-    llm: {
-      defaultModel,
-      providers,
-    },
-    paths: {
-      dataDir,
-      inboxPath,
-    },
-    debug: process.env.DANEEL_DEBUG === "true",
-  };
-}
-
-// Parse model prefix from message
-export function parseModelPrefix(message: string): {
-  model: ModelInfo | null;
-  content: string;
-} {
-  for (const [prefix, modelInfo] of Object.entries(MODEL_PREFIXES)) {
-    if (message.toLowerCase().startsWith(prefix)) {
-      return {
-        model: modelInfo,
-        content: message.slice(prefix.length).trim(),
-      };
-    }
-  }
-  return { model: null, content: message };
-}