titan-agent 2026.4.0

package/dist/agent/agent.js

@@ -0,0 +1,1458 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/logger.ts
+import chalk from "chalk";
+function formatTimestamp() {
+  return chalk.gray((/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19));
+}
+function log(level, component, message, ...args) {
+  if (level < currentLevel) return;
+  const prefix = `${formatTimestamp()} ${LEVEL_LABELS[level]} ${chalk.blue(`[${component}]`)}`;
+  console.log(`${prefix} ${message}`, ...args);
+}
+var LEVEL_LABELS, currentLevel, logger, logger_default;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    LEVEL_LABELS = {
+      [0 /* DEBUG */]: chalk.gray("DEBUG"),
+      [1 /* INFO */]: chalk.cyan("INFO "),
+      [2 /* WARN */]: chalk.yellow("WARN "),
+      [3 /* ERROR */]: chalk.red("ERROR"),
+      [4 /* SILENT */]: ""
+    };
+    currentLevel = 1 /* INFO */;
+    logger = {
+      debug: (component, msg, ...args) => log(0 /* DEBUG */, component, msg, ...args),
+      info: (component, msg, ...args) => log(1 /* INFO */, component, msg, ...args),
+      warn: (component, msg, ...args) => log(2 /* WARN */, component, msg, ...args),
+      error: (component, msg, ...args) => log(3 /* ERROR */, component, msg, ...args)
+    };
+    logger_default = logger;
+  }
+});
+
+// src/security/encryption.ts
+var encryption_exports = {};
+__export(encryption_exports, {
+  decrypt: () => decrypt,
+  encrypt: () => encrypt,
+  generateKey: () => generateKey
+});
+import { randomBytes, createCipheriv, createDecipheriv } from "crypto";
+function generateKey() {
+  return randomBytes(32);
+}
+function encrypt(text, key) {
+  try {
+    const keyBuffer = typeof key === "string" ? Buffer.from(key, "hex") : key;
+    if (keyBuffer.length !== 32) {
+      throw new Error("Encryption key must be exactly 32 bytes (256 bits).");
+    }
+    const iv = randomBytes(16);
+    const cipher = createCipheriv(ALGORITHM, keyBuffer, iv);
+    let encrypted = cipher.update(text, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    const authTag = cipher.getAuthTag().toString("hex");
+    return {
+      iv: iv.toString("hex"),
+      authTag,
+      data: encrypted
+    };
+  } catch (e) {
+    logger_default.error(COMPONENT7, `Encryption failed: ${e.message}`);
+    throw new Error("Failed to encrypt session data.");
+  }
+}
+function decrypt(payload, key) {
+  try {
+    const keyBuffer = typeof key === "string" ? Buffer.from(key, "hex") : key;
+    if (keyBuffer.length !== 32) {
+      throw new Error("Decryption key must be exactly 32 bytes (256 bits).");
+    }
+    const decipher = createDecipheriv(ALGORITHM, keyBuffer, Buffer.from(payload.iv, "hex"));
+    decipher.setAuthTag(Buffer.from(payload.authTag, "hex"));
+    let decrypted = decipher.update(payload.data, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+  } catch (e) {
+    logger_default.error(COMPONENT7, `Decryption failed: ${e.message}`);
+    throw new Error("Failed to decrypt session data. Invalid key or corrupted payload.");
+  }
+}
+var COMPONENT7, ALGORITHM;
+var init_encryption = __esm({
+  "src/security/encryption.ts"() {
+    "use strict";
+    init_logger();
+    COMPONENT7 = "Encryption";
+    ALGORITHM = "aes-256-gcm";
+  }
+});
+
+// src/agent/agent.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+
+// src/providers/base.ts
+var LLMProvider = class {
+  /** Get the provider identifier from a model string like "anthropic/claude-3" */
+  static parseModelId(modelId) {
+    const parts = modelId.split("/");
+    if (parts.length >= 2) {
+      return { provider: parts[0], model: parts.slice(1).join("/") };
+    }
+    return { provider: "anthropic", model: modelId };
+  }
+};
+
+// src/config/config.ts
+import { existsSync as existsSync2 } from "fs";
+
+// src/utils/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var TITAN_VERSION = "2026.4.0";
+var TITAN_NAME = "TITAN";
+var TITAN_ASCII_LOGO = `
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                    \u2551
+\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2557         \u2551
+\u2551   \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551         \u2551
+\u2551      \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551         \u2551
+\u2551      \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551         \u2551
+\u2551      \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551         \u2551
+\u2551      \u255A\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D         \u2551
+\u2551                                                    \u2551
+\u2551   The Intelligent Task Automation Network          \u2551
+\u2551   v${TITAN_VERSION}                                          \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`;
+var TITAN_HOME = join(homedir(), ".titan");
+var TITAN_CONFIG_PATH = join(TITAN_HOME, "titan.json");
+var TITAN_DB_PATH = join(TITAN_HOME, "titan.db");
+var TITAN_WORKSPACE = join(TITAN_HOME, "workspace");
+var TITAN_SKILLS_DIR = join(TITAN_WORKSPACE, "skills");
+var TITAN_LOGS_DIR = join(TITAN_HOME, "logs");
+var TITAN_MEMORY_DIR = join(TITAN_HOME, "memory");
+var AGENTS_MD = join(TITAN_WORKSPACE, "AGENTS.md");
+var SOUL_MD = join(TITAN_WORKSPACE, "SOUL.md");
+var TOOLS_MD = join(TITAN_WORKSPACE, "TOOLS.md");
+var DEFAULT_GATEWAY_HOST = "127.0.0.1";
+var DEFAULT_GATEWAY_PORT = 18789;
+var DEFAULT_WEB_PORT = 18790;
+var DEFAULT_MODEL = "anthropic/claude-sonnet-4-20250514";
+var DEFAULT_MAX_TOKENS = 8192;
+var DEFAULT_TEMPERATURE = 0.7;
+var MAX_CONTEXT_MESSAGES = 50;
+var SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_SANDBOX_MODE = "host";
+var ALLOWED_TOOLS_DEFAULT = [
+  "shell",
+  "read_file",
+  "write_file",
+  "edit_file",
+  "list_dir",
+  "web_search",
+  "browser",
+  "cron",
+  "webhook",
+  "email",
+  "memory"
+];
+
+// src/utils/helpers.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function readJsonFile(filePath) {
+  try {
+    if (!existsSync(filePath)) return null;
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var ProviderConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  baseUrl: z.string().optional(),
+  model: z.string().optional(),
+  maxTokens: z.number().optional(),
+  temperature: z.number().min(0).max(2).optional()
+});
+var ChannelConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  token: z.string().optional(),
+  apiKey: z.string().optional(),
+  allowFrom: z.array(z.string()).default([]),
+  dmPolicy: z.enum(["pairing", "open", "closed"]).default("pairing")
+});
+var SecurityConfigSchema = z.object({
+  sandboxMode: z.enum(["host", "docker", "none"]).default(DEFAULT_SANDBOX_MODE),
+  allowedTools: z.array(z.string()).default(ALLOWED_TOOLS_DEFAULT),
+  deniedTools: z.array(z.string()).default([]),
+  maxConcurrentTasks: z.number().default(5),
+  commandTimeout: z.number().default(3e4),
+  fileSystemAllowlist: z.array(z.string()).default([]),
+  networkAllowlist: z.array(z.string()).default(["*"]),
+  shield: z.object({
+    enabled: z.boolean().default(true),
+    mode: z.enum(["standard", "strict"]).default("strict")
+  }).default({})
+});
+var GatewayConfigSchema = z.object({
+  host: z.string().default(DEFAULT_GATEWAY_HOST),
+  port: z.number().default(DEFAULT_GATEWAY_PORT),
+  webPort: z.number().default(DEFAULT_WEB_PORT),
+  auth: z.object({
+    mode: z.enum(["none", "token", "password"]).default("token"),
+    token: z.string().optional(),
+    password: z.string().optional()
+  }).default({})
+});
+var AgentConfigSchema = z.object({
+  model: z.string().default(DEFAULT_MODEL),
+  maxTokens: z.number().default(DEFAULT_MAX_TOKENS),
+  temperature: z.number().default(DEFAULT_TEMPERATURE),
+  systemPrompt: z.string().optional(),
+  workspace: z.string().optional(),
+  thinkingMode: z.enum(["off", "low", "medium", "high"]).default("medium")
+});
+var TitanConfigSchema = z.object({
+  agent: AgentConfigSchema.default({}),
+  providers: z.object({
+    anthropic: ProviderConfigSchema.default({}),
+    openai: ProviderConfigSchema.default({}),
+    google: ProviderConfigSchema.default({}),
+    ollama: ProviderConfigSchema.default({})
+  }).default({}),
+  channels: z.object({
+    discord: ChannelConfigSchema.default({}),
+    telegram: ChannelConfigSchema.default({}),
+    slack: ChannelConfigSchema.default({}),
+    whatsapp: ChannelConfigSchema.default({}),
+    webchat: ChannelConfigSchema.default({}),
+    googlechat: ChannelConfigSchema.default({}),
+    matrix: ChannelConfigSchema.default({}),
+    signal: ChannelConfigSchema.default({}),
+    msteams: ChannelConfigSchema.default({}),
+    bluebubbles: ChannelConfigSchema.default({})
+  }).default({}),
+  gateway: GatewayConfigSchema.default({}),
+  security: SecurityConfigSchema.default({}),
+  memory: z.object({
+    enabled: z.boolean().default(true),
+    maxHistoryMessages: z.number().default(50),
+    vectorSearchEnabled: z.boolean().default(false)
+  }).default({}),
+  skills: z.object({
+    enabled: z.boolean().default(true),
+    autoDiscover: z.boolean().default(true),
+    marketplace: z.boolean().default(false)
+  }).default({}),
+  logging: z.object({
+    level: z.enum(["debug", "info", "warn", "error", "silent"]).default("info"),
+    file: z.boolean().default(true)
+  }).default({}),
+  autonomy: z.object({
+    /** autonomous = full auto, supervised = asks for dangerous ops, locked = asks for everything */
+    mode: z.enum(["autonomous", "supervised", "locked"]).default("supervised"),
+    /** Auto-approve moderate-risk tools in main session (cli/webchat) */
+    autoApproveMainSession: z.boolean().default(true),
+    /** Timeout for HITL approval requests (ms). Auto-deny after timeout. */
+    approvalTimeoutMs: z.number().default(6e4),
+    /** Notify user of auto-approved actions */
+    notifyOnAutoApprove: z.boolean().default(true)
+  }).default({})
+});
+
+// src/config/config.ts
+init_logger();
+var COMPONENT = "Config";
+var cachedConfig = null;
+function getDefaultConfig() {
+  return TitanConfigSchema.parse({});
+}
+function loadConfig() {
+  if (cachedConfig) return cachedConfig;
+  ensureDir(TITAN_HOME);
+  let rawConfig = {};
+  if (existsSync2(TITAN_CONFIG_PATH)) {
+    const loaded = readJsonFile(TITAN_CONFIG_PATH);
+    if (loaded) {
+      rawConfig = loaded;
+      logger_default.debug(COMPONENT, `Loaded config from ${TITAN_CONFIG_PATH}`);
+    } else {
+      logger_default.warn(COMPONENT, `Failed to parse config at ${TITAN_CONFIG_PATH}, using defaults`);
+    }
+  } else {
+    logger_default.info(COMPONENT, "No config file found, using defaults");
+  }
+  applyEnvOverrides(rawConfig);
+  const result = TitanConfigSchema.safeParse(rawConfig);
+  if (!result.success) {
+    logger_default.warn(COMPONENT, "Config validation issues, using defaults for invalid fields");
+    logger_default.debug(COMPONENT, result.error.message);
+    cachedConfig = getDefaultConfig();
+  } else {
+    cachedConfig = result.data;
+  }
+  return cachedConfig;
+}
+function applyEnvOverrides(config) {
+  const envMap = {
+    TITAN_MODEL: (val) => setNested(config, "agent.model", val),
+    TITAN_GATEWAY_PORT: (val) => setNested(config, "gateway.port", parseInt(val, 10)),
+    TITAN_GATEWAY_HOST: (val) => setNested(config, "gateway.host", val),
+    TITAN_LOG_LEVEL: (val) => setNested(config, "logging.level", val),
+    ANTHROPIC_API_KEY: (val) => setNested(config, "providers.anthropic.apiKey", val),
+    OPENAI_API_KEY: (val) => setNested(config, "providers.openai.apiKey", val),
+    GOOGLE_API_KEY: (val) => setNested(config, "providers.google.apiKey", val),
+    OLLAMA_BASE_URL: (val) => setNested(config, "providers.ollama.baseUrl", val),
+    DISCORD_TOKEN: (val) => setNested(config, "channels.discord.token", val),
+    TELEGRAM_TOKEN: (val) => setNested(config, "channels.telegram.token", val),
+    SLACK_TOKEN: (val) => setNested(config, "channels.slack.token", val)
+  };
+  for (const [envKey, setter] of Object.entries(envMap)) {
+    const val = process.env[envKey];
+    if (val) {
+      setter(val);
+      logger_default.debug(COMPONENT, `Applied env override: ${envKey}`);
+    }
+  }
+}
+function setNested(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (!current[parts[i]] || typeof current[parts[i]] !== "object") {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+
+// src/providers/anthropic.ts
+init_logger();
+import { v4 as uuid } from "uuid";
+var COMPONENT2 = "Anthropic";
+var AnthropicProvider = class extends LLMProvider {
+  name = "anthropic";
+  displayName = "Anthropic (Claude)";
+  get apiKey() {
+    const config = loadConfig();
+    return config.providers.anthropic.apiKey || process.env.ANTHROPIC_API_KEY || "";
+  }
+  get baseUrl() {
+    const config = loadConfig();
+    return config.providers.anthropic.baseUrl || "https://api.anthropic.com";
+  }
+  async chat(options) {
+    const model = options.model || "claude-sonnet-4-20250514";
+    const apiKey = this.apiKey;
+    if (!apiKey) throw new Error("Anthropic API key not configured");
+    logger_default.debug(COMPONENT2, `Chat request: model=${model}, messages=${options.messages.length}`);
+    const systemMessage = options.messages.find((m) => m.role === "system");
+    const nonSystemMessages = options.messages.filter((m) => m.role !== "system");
+    const body = {
+      model: model.replace("anthropic/", ""),
+      max_tokens: options.maxTokens || 8192,
+      messages: nonSystemMessages.map((m) => ({
+        role: m.role === "tool" ? "user" : m.role,
+        content: m.role === "tool" ? [{ type: "tool_result", tool_use_id: m.toolCallId, content: m.content }] : m.content
+      }))
+    };
+    if (systemMessage) {
+      body.system = systemMessage.content;
+    }
+    if (options.tools && options.tools.length > 0) {
+      body.tools = options.tools.map((t) => ({
+        name: t.function.name,
+        description: t.function.description,
+        input_schema: t.function.parameters
+      }));
+    }
+    if (options.temperature !== void 0) {
+      body.temperature = options.temperature;
+    }
+    const response = await fetch(`${this.baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Anthropic API error (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    const content = data.content;
+    let textContent = "";
+    const toolCalls = [];
+    for (const block of content) {
+      if (block.type === "text") {
+        textContent += block.text;
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          type: "function",
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          }
+        });
+      }
+    }
+    const usage = data.usage;
+    return {
+      id: data.id || uuid(),
+      content: textContent,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      usage: usage ? {
+        promptTokens: usage.input_tokens,
+        completionTokens: usage.output_tokens,
+        totalTokens: usage.input_tokens + usage.output_tokens
+      } : void 0,
+      finishReason: toolCalls.length > 0 ? "tool_calls" : "stop",
+      model
+    };
+  }
+  async *chatStream(options) {
+    try {
+      const response = await this.chat(options);
+      if (response.content) {
+        yield { type: "text", content: response.content };
+      }
+      if (response.toolCalls) {
+        for (const tc of response.toolCalls) {
+          yield { type: "tool_call", toolCall: tc };
+        }
+      }
+      yield { type: "done" };
+    } catch (error) {
+      yield { type: "error", error: error.message };
+    }
+  }
+  async listModels() {
+    return [
+      "claude-opus-4-0",
+      "claude-sonnet-4-20250514",
+      "claude-haiku-4-20250414",
+      "claude-3-5-sonnet-20241022",
+      "claude-3-5-haiku-20241022"
+    ];
+  }
+  async healthCheck() {
+    try {
+      if (!this.apiKey) return false;
+      const response = await fetch(`${this.baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: "claude-haiku-4-20250414",
+          max_tokens: 1,
+          messages: [{ role: "user", content: "ping" }]
+        })
+      });
+      return response.ok || response.status === 400;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/providers/openai.ts
+init_logger();
+import { v4 as uuid2 } from "uuid";
+var COMPONENT3 = "OpenAI";
+var OpenAIProvider = class extends LLMProvider {
+  name = "openai";
+  displayName = "OpenAI (GPT)";
+  get apiKey() {
+    const config = loadConfig();
+    return config.providers.openai.apiKey || process.env.OPENAI_API_KEY || "";
+  }
+  get baseUrl() {
+    const config = loadConfig();
+    return config.providers.openai.baseUrl || "https://api.openai.com";
+  }
+  async chat(options) {
+    const model = options.model || "gpt-4o";
+    const apiKey = this.apiKey;
+    if (!apiKey) throw new Error("OpenAI API key not configured");
+    logger_default.debug(COMPONENT3, `Chat request: model=${model}, messages=${options.messages.length}`);
+    const body = {
+      model: model.replace("openai/", ""),
+      messages: options.messages.map((m) => {
+        if (m.role === "tool") {
+          return { role: "tool", content: m.content, tool_call_id: m.toolCallId };
+        }
+        if (m.role === "assistant" && m.toolCalls) {
+          return {
+            role: "assistant",
+            content: m.content || null,
+            tool_calls: m.toolCalls.map((tc) => ({
+              id: tc.id,
+              type: "function",
+              function: { name: tc.function.name, arguments: tc.function.arguments }
+            }))
+          };
+        }
+        return { role: m.role, content: m.content };
+      }),
+      max_tokens: options.maxTokens || 8192
+    };
+    if (options.tools && options.tools.length > 0) {
+      body.tools = options.tools;
+    }
+    if (options.temperature !== void 0) {
+      body.temperature = options.temperature;
+    }
+    const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`OpenAI API error (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    const choices = data.choices;
+    const choice = choices[0];
+    const message = choice.message;
+    const toolCalls = [];
+    if (message.tool_calls) {
+      for (const tc of message.tool_calls) {
+        const fn = tc.function;
+        toolCalls.push({
+          id: tc.id,
+          type: "function",
+          function: { name: fn.name, arguments: fn.arguments }
+        });
+      }
+    }
+    const usage = data.usage;
+    return {
+      id: data.id || uuid2(),
+      content: message.content || "",
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      usage: usage ? {
+        promptTokens: usage.prompt_tokens,
+        completionTokens: usage.completion_tokens,
+        totalTokens: usage.total_tokens
+      } : void 0,
+      finishReason: toolCalls.length > 0 ? "tool_calls" : choice.finish_reason || "stop",
+      model
+    };
+  }
+  async *chatStream(options) {
+    try {
+      const response = await this.chat(options);
+      if (response.content) {
+        yield { type: "text", content: response.content };
+      }
+      if (response.toolCalls) {
+        for (const tc of response.toolCalls) {
+          yield { type: "tool_call", toolCall: tc };
+        }
+      }
+      yield { type: "done" };
+    } catch (error) {
+      yield { type: "error", error: error.message };
+    }
+  }
+  async listModels() {
+    return ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "o1", "o1-mini", "o3-mini"];
+  }
+  async healthCheck() {
+    try {
+      if (!this.apiKey) return false;
+      const response = await fetch(`${this.baseUrl}/v1/models`, {
+        headers: { Authorization: `Bearer ${this.apiKey}` }
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/providers/google.ts
+init_logger();
+import { v4 as uuid3 } from "uuid";
+var COMPONENT4 = "Google";
+var GoogleProvider = class extends LLMProvider {
+  name = "google";
+  displayName = "Google (Gemini)";
+  get apiKey() {
+    const config = loadConfig();
+    return config.providers.google.apiKey || process.env.GOOGLE_API_KEY || "";
+  }
+  async chat(options) {
+    const model = (options.model || "gemini-2.0-flash").replace("google/", "");
+    const apiKey = this.apiKey;
+    if (!apiKey) throw new Error("Google API key not configured");
+    logger_default.debug(COMPONENT4, `Chat request: model=${model}, messages=${options.messages.length}`);
+    const systemInstruction = options.messages.find((m) => m.role === "system")?.content;
+    const contents = options.messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    const body = {
+      contents,
+      generationConfig: {
+        maxOutputTokens: options.maxTokens || 8192,
+        temperature: options.temperature ?? 0.7
+      }
+    };
+    if (systemInstruction) {
+      body.systemInstruction = { parts: [{ text: systemInstruction }] };
+    }
+    if (options.tools && options.tools.length > 0) {
+      body.tools = [{
+        functionDeclarations: options.tools.map((t) => ({
+          name: t.function.name,
+          description: t.function.description,
+          parameters: t.function.parameters
+        }))
+      }];
+    }
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Google API error (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    const candidates = data.candidates;
+    let textContent = "";
+    const toolCalls = [];
+    if (candidates && candidates.length > 0) {
+      const parts = candidates[0].content?.parts || [];
+      for (const part of parts) {
+        if (part.text) {
+          textContent += part.text;
+        }
+        if (part.functionCall) {
+          const fc = part.functionCall;
+          toolCalls.push({
+            id: uuid3(),
+            type: "function",
+            function: {
+              name: fc.name,
+              arguments: JSON.stringify(fc.args)
+            }
+          });
+        }
+      }
+    }
+    const usageMeta = data.usageMetadata;
+    return {
+      id: uuid3(),
+      content: textContent,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      usage: usageMeta ? {
+        promptTokens: usageMeta.promptTokenCount || 0,
+        completionTokens: usageMeta.candidatesTokenCount || 0,
+        totalTokens: usageMeta.totalTokenCount || 0
+      } : void 0,
+      finishReason: toolCalls.length > 0 ? "tool_calls" : "stop",
+      model: `google/${model}`
+    };
+  }
+  async *chatStream(options) {
+    try {
+      const response = await this.chat(options);
+      if (response.content) yield { type: "text", content: response.content };
+      if (response.toolCalls) {
+        for (const tc of response.toolCalls) yield { type: "tool_call", toolCall: tc };
+      }
+      yield { type: "done" };
+    } catch (error) {
+      yield { type: "error", error: error.message };
+    }
+  }
+  async listModels() {
+    return ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash", "gemini-1.5-pro"];
+  }
+  async healthCheck() {
+    try {
+      if (!this.apiKey) return false;
+      const url = `https://generativelanguage.googleapis.com/v1beta/models?key=${this.apiKey}`;
+      const response = await fetch(url);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/providers/ollama.ts
+init_logger();
+import { v4 as uuid4 } from "uuid";
+var COMPONENT5 = "Ollama";
+var OllamaProvider = class extends LLMProvider {
+  name = "ollama";
+  displayName = "Ollama (Local)";
+  get baseUrl() {
+    const config = loadConfig();
+    return config.providers.ollama.baseUrl || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+  }
+  async chat(options) {
+    const model = (options.model || "llama3.1").replace("ollama/", "");
+    logger_default.debug(COMPONENT5, `Chat request: model=${model}, messages=${options.messages.length}`);
+    const body = {
+      model,
+      messages: options.messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      stream: false,
+      options: {
+        num_predict: options.maxTokens || 8192,
+        temperature: options.temperature ?? 0.7
+      }
+    };
+    if (options.tools && options.tools.length > 0) {
+      body.tools = options.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.function.name,
+          description: t.function.description,
+          parameters: t.function.parameters
+        }
+      }));
+    }
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Ollama error (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    const message = data.message;
+    const toolCalls = [];
+    if (message.tool_calls) {
+      for (const tc of message.tool_calls) {
+        const fn = tc.function;
+        toolCalls.push({
+          id: uuid4(),
+          type: "function",
+          function: {
+            name: fn.name,
+            arguments: JSON.stringify(fn.arguments)
+          }
+        });
+      }
+    }
+    return {
+      id: uuid4(),
+      content: message.content || "",
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      usage: {
+        promptTokens: data.prompt_eval_count || 0,
+        completionTokens: data.eval_count || 0,
+        totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+      },
+      finishReason: toolCalls.length > 0 ? "tool_calls" : "stop",
+      model: `ollama/${model}`
+    };
+  }
+  async *chatStream(options) {
+    try {
+      const response = await this.chat(options);
+      if (response.content) yield { type: "text", content: response.content };
+      if (response.toolCalls) {
+        for (const tc of response.toolCalls) yield { type: "tool_call", toolCall: tc };
+      }
+      yield { type: "done" };
+    } catch (error) {
+      yield { type: "error", error: error.message };
+    }
+  }
+  async listModels() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`);
+      if (!response.ok) return [];
+      const data = await response.json();
+      return (data.models || []).map((m) => m.name);
+    } catch {
+      return [];
+    }
+  }
+  async healthCheck() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/providers/router.ts
+init_logger();
+var COMPONENT6 = "Router";
+var providers = /* @__PURE__ */ new Map();
+var initialized = false;
+function initProviders() {
+  if (initialized) return;
+  providers.set("anthropic", new AnthropicProvider());
+  providers.set("openai", new OpenAIProvider());
+  providers.set("google", new GoogleProvider());
+  providers.set("ollama", new OllamaProvider());
+  initialized = true;
+}
+function resolveModel(modelId) {
+  initProviders();
+  const { provider: providerName, model } = LLMProvider.parseModelId(modelId);
+  const provider = providers.get(providerName);
+  if (!provider) {
+    throw new Error(`Unknown provider: ${providerName}. Available: ${Array.from(providers.keys()).join(", ")}`);
+  }
+  return { provider, model };
+}
+async function chat(options) {
+  const modelId = options.model || "anthropic/claude-sonnet-4-20250514";
+  const { provider, model } = resolveModel(modelId);
+  logger_default.info(COMPONENT6, `Routing to ${provider.displayName} (model: ${model})`);
+  try {
+    return await provider.chat({ ...options, model });
+  } catch (error) {
+    logger_default.error(COMPONENT6, `Provider ${provider.name} failed: ${error.message}`);
+    const failoverOrder = ["anthropic", "openai", "google", "ollama"];
+    for (const fallbackName of failoverOrder) {
+      if (fallbackName === provider.name) continue;
+      const fallback = providers.get(fallbackName);
+      if (!fallback) continue;
+      try {
+        const healthy = await fallback.healthCheck();
+        if (!healthy) continue;
+        const models = await fallback.listModels();
+        if (models.length === 0) continue;
+        logger_default.warn(COMPONENT6, `Failing over to ${fallback.displayName} (model: ${models[0]})`);
+        return await fallback.chat({ ...options, model: models[0] });
+      } catch {
+        continue;
+      }
+    }
+    throw error;
+  }
+}
+
+// src/agent/session.ts
+import { v4 as uuid5 } from "uuid";
+
+// src/memory/memory.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+init_logger();
+init_encryption();
+var COMPONENT8 = "Memory";
+var DB_FILE = join2(TITAN_HOME, "titan-data.json");
+var store = null;
+function getDefaultStore() {
+  return {
+    conversations: [],
+    memories: [],
+    sessions: [],
+    usageStats: [],
+    cronJobs: [],
+    skillsInstalled: []
+  };
+}
+function loadStore() {
+  if (store) return store;
+  ensureDir(TITAN_HOME);
+  if (existsSync3(DB_FILE)) {
+    try {
+      const raw = readFileSync2(DB_FILE, "utf-8");
+      store = JSON.parse(raw);
+      store.conversations = store.conversations || [];
+      store.memories = store.memories || [];
+      store.sessions = store.sessions || [];
+      store.usageStats = store.usageStats || [];
+      store.cronJobs = store.cronJobs || [];
+      store.skillsInstalled = store.skillsInstalled || [];
+    } catch {
+      logger_default.warn(COMPONENT8, "Could not load data store, creating fresh one");
+      store = getDefaultStore();
+    }
+  } else {
+    store = getDefaultStore();
+  }
+  return store;
+}
+function saveStore() {
+  if (!store) return;
+  ensureDir(TITAN_HOME);
+  try {
+    writeFileSync2(DB_FILE, JSON.stringify(store, null, 2), "utf-8");
+  } catch (e) {
+    logger_default.error(COMPONENT8, `Failed to save data: ${e.message}`);
+  }
+}
+var saveTimeout = null;
+function debouncedSave() {
+  if (saveTimeout) clearTimeout(saveTimeout);
+  saveTimeout = setTimeout(saveStore, 1e3);
+}
+function getDb() {
+  return loadStore();
+}
+function saveMessage(message, e2eKey) {
+  const s = loadStore();
+  let content = message.content;
+  let isEncrypted = false;
+  if (e2eKey) {
+    try {
+      const payload = encrypt(message.content, Buffer.from(e2eKey, "base64"));
+      content = JSON.stringify(payload);
+      isEncrypted = true;
+    } catch (e) {
+      logger_default.error(COMPONENT8, `Failed to encrypt message for storage`);
+      content = "[ENCRYPTION FAILED] " + content;
+    }
+  }
+  s.conversations.push({
+    ...message,
+    content,
+    isEncrypted,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (s.conversations.length > 5e3) {
+    s.conversations = s.conversations.slice(-5e3);
+  }
+  debouncedSave();
+}
+function getHistory(sessionId, limit = 50, e2eKey) {
+  const s = loadStore();
+  const rawHistory = s.conversations.filter((m) => m.sessionId === sessionId).slice(-limit);
+  if (!e2eKey) {
+    return rawHistory;
+  }
+  return rawHistory.map((m) => {
+    if (m.isEncrypted) {
+      try {
+        const payload = JSON.parse(m.content);
+        return {
+          ...m,
+          content: decrypt(payload, Buffer.from(e2eKey, "base64"))
+        };
+      } catch (e) {
+        logger_default.error(COMPONENT8, `Failed to decrypt message ${m.id}`);
+        return { ...m, content: "[DECRYPTION FAILED]" };
+      }
+    }
+    return m;
+  });
+}
+function searchMemories(category, query) {
+  const s = loadStore();
+  let results = s.memories;
+  if (category) {
+    results = results.filter((m) => m.category === category);
+  }
+  if (query) {
+    const q = query.toLowerCase();
+    results = results.filter(
+      (m) => m.key.toLowerCase().includes(q) || m.value.toLowerCase().includes(q)
+    );
+  }
+  return results.slice(-50).map((m) => ({ key: m.key, value: m.value, category: m.category }));
+}
+function recordUsage(sessionId, provider, model, promptTokens, completionTokens) {
+  const s = loadStore();
+  s.usageStats.push({
+    id: s.usageStats.length + 1,
+    session_id: sessionId,
+    provider,
+    model,
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    total_tokens: promptTokens + completionTokens,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (s.usageStats.length > 1e4) {
+    s.usageStats = s.usageStats.slice(-1e4);
+  }
+  debouncedSave();
+}
+
+// src/agent/session.ts
+init_logger();
+var COMPONENT9 = "Session";
+var activeSessions = /* @__PURE__ */ new Map();
+function getOrCreateSession(channel, userId, agentId = "default", isEncrypted = false) {
+  const sessionKey = `${channel}:${userId}:${agentId}`;
+  const cached = activeSessions.get(sessionKey);
+  if (cached && cached.status === "active") {
+    return cached;
+  }
+  const store2 = getDb();
+  const existing = store2.sessions.find(
+    (s) => s.channel === channel && s.user_id === userId && s.agent_id === agentId && s.status === "active"
+  );
+  if (existing) {
+    const lastActive = new Date(existing.last_active || existing.created_at).getTime();
+    if (Date.now() - lastActive > SESSION_TIMEOUT_MS) {
+      existing.status = "idle";
+      logger_default.debug(COMPONENT9, `Session ${existing.id} timed out, creating new one`);
+    } else {
+      const session2 = {
+        id: existing.id,
+        channel: existing.channel,
+        userId: existing.user_id,
+        agentId: existing.agent_id,
+        status: existing.status,
+        messageCount: existing.message_count,
+        createdAt: existing.created_at,
+        lastActive: existing.last_active,
+        // Note: If a session was encrypted but dropped from memory, we cannot recover the key
+        // A robust implementation would involve key exchange, but for now we warn:
+        e2eKey: void 0
+      };
+      if (isEncrypted) {
+        logger_default.warn(COMPONENT9, `Recovered session ${existing.id}, but E2E key was lost from memory.`);
+      }
+      activeSessions.set(sessionKey, session2);
+      return session2;
+    }
+  }
+  const session = {
+    id: uuid5(),
+    channel,
+    userId,
+    agentId,
+    status: "active",
+    messageCount: 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastActive: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (isEncrypted) {
+    Promise.resolve().then(() => (init_encryption(), encryption_exports)).then(({ generateKey: generateKey2 }) => {
+      session.e2eKey = generateKey2().toString("base64");
+      logger_default.info(COMPONENT9, `Generated E2E key for session ${session.id}`);
+    }).catch((err) => {
+      logger_default.error(COMPONENT9, `Failed to load encryption module: ${err}`);
+    });
+  }
+  store2.sessions.push({
+    id: session.id,
+    channel,
+    user_id: userId,
+    agent_id: agentId,
+    status: "active",
+    message_count: 0,
+    created_at: session.createdAt,
+    last_active: session.lastActive
+  });
+  activeSessions.set(sessionKey, session);
+  logger_default.info(COMPONENT9, `Created new session: ${session.id} (${channel}/${userId})`);
+  return session;
+}
+function addMessage(session, role, content, extra) {
+  const messageId = uuid5();
+  saveMessage({
+    id: messageId,
+    sessionId: session.id,
+    role,
+    content,
+    toolCalls: extra?.toolCalls,
+    toolCallId: extra?.toolCallId,
+    model: extra?.model,
+    tokenCount: extra?.tokenCount || 0
+  }, session.e2eKey);
+  session.messageCount++;
+  session.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+  const store2 = getDb();
+  const sessionRec = store2.sessions.find((s) => s.id === session.id);
+  if (sessionRec) {
+    sessionRec.message_count = session.messageCount;
+    sessionRec.last_active = session.lastActive;
+  }
+}
+function getContextMessages(session, maxMessages = MAX_CONTEXT_MESSAGES) {
+  const history = getHistory(session.id, maxMessages, session.e2eKey);
+  return history.map((msg) => ({
+    role: msg.role,
+    content: msg.content,
+    toolCallId: msg.toolCallId || void 0,
+    toolCalls: msg.toolCalls ? JSON.parse(msg.toolCalls) : void 0
+  }));
+}
+
+// src/agent/toolRunner.ts
+init_logger();
+var COMPONENT10 = "ToolRunner";
+var toolRegistry = /* @__PURE__ */ new Map();
+function getToolDefinitions() {
+  const config = loadConfig();
+  const allowed = new Set(config.security.allowedTools);
+  const denied = new Set(config.security.deniedTools);
+  return Array.from(toolRegistry.values()).filter((tool) => {
+    if (denied.has(tool.name)) return false;
+    if (allowed.size > 0 && !allowed.has(tool.name)) return false;
+    return true;
+  }).map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  }));
+}
+async function executeTool(toolCall) {
+  const config = loadConfig();
+  const startTime = Date.now();
+  const handler = toolRegistry.get(toolCall.function.name);
+  if (!handler) {
+    return {
+      toolCallId: toolCall.id,
+      name: toolCall.function.name,
+      content: `Error: Unknown tool "${toolCall.function.name}"`,
+      success: false,
+      durationMs: Date.now() - startTime
+    };
+  }
+  if (config.security.deniedTools.includes(handler.name)) {
+    return {
+      toolCallId: toolCall.id,
+      name: handler.name,
+      content: `Error: Tool "${handler.name}" is denied by security policy`,
+      success: false,
+      durationMs: Date.now() - startTime
+    };
+  }
+  try {
+    let args = {};
+    try {
+      args = JSON.parse(toolCall.function.arguments);
+    } catch {
+      args = {};
+    }
+    logger_default.info(COMPONENT10, `Executing tool: ${handler.name}`);
+    const timeout = config.security.commandTimeout || 3e4;
+    const result = await Promise.race([
+      handler.execute(args),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`Tool "${handler.name}" timed out after ${timeout}ms`)), timeout)
+      )
+    ]);
+    const durationMs = Date.now() - startTime;
+    logger_default.info(COMPONENT10, `Tool ${handler.name} completed in ${durationMs}ms`);
+    return {
+      toolCallId: toolCall.id,
+      name: handler.name,
+      content: result,
+      success: true,
+      durationMs
+    };
+  } catch (error) {
+    const durationMs = Date.now() - startTime;
+    const errorMsg = error.message;
+    logger_default.error(COMPONENT10, `Tool ${handler.name} failed: ${errorMsg}`);
+    return {
+      toolCallId: toolCall.id,
+      name: handler.name,
+      content: `Error: ${errorMsg}`,
+      success: false,
+      durationMs
+    };
+  }
+}
+async function executeTools(toolCalls) {
+  const config = loadConfig();
+  const maxConcurrent = config.security.maxConcurrentTasks || 5;
+  const results = [];
+  for (let i = 0; i < toolCalls.length; i += maxConcurrent) {
+    const batch = toolCalls.slice(i, i + maxConcurrent);
+    const batchResults = await Promise.all(batch.map(executeTool));
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+// src/memory/learning.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+init_logger();
+var KNOWLEDGE_FILE = join3(TITAN_HOME, "knowledge.json");
+var kb = null;
+function loadKnowledgeBase() {
+  if (kb) return kb;
+  ensureDir(TITAN_HOME);
+  if (existsSync4(KNOWLEDGE_FILE)) {
+    try {
+      kb = JSON.parse(readFileSync3(KNOWLEDGE_FILE, "utf-8"));
+      kb.entries = kb.entries || [];
+      kb.toolSuccessRates = kb.toolSuccessRates || {};
+      kb.errorPatterns = kb.errorPatterns || {};
+      kb.userCorrections = kb.userCorrections || [];
+      kb.conversationInsights = kb.conversationInsights || [];
+    } catch {
+      kb = createEmptyKB();
+    }
+  } else {
+    kb = createEmptyKB();
+  }
+  return kb;
+}
+function createEmptyKB() {
+  return {
+    entries: [],
+    toolSuccessRates: {},
+    errorPatterns: {},
+    userCorrections: [],
+    conversationInsights: []
+  };
+}
+var saveTimeout2 = null;
+function debouncedSave2() {
+  if (saveTimeout2) clearTimeout(saveTimeout2);
+  saveTimeout2 = setTimeout(() => {
+    if (!kb) return;
+    ensureDir(TITAN_HOME);
+    writeFileSync3(KNOWLEDGE_FILE, JSON.stringify(kb, null, 2), "utf-8");
+  }, 2e3);
+}
+function recordToolResult(toolName, success, context, error) {
+  const k = loadKnowledgeBase();
+  if (!k.toolSuccessRates[toolName]) {
+    k.toolSuccessRates[toolName] = { success: 0, fail: 0, total: 0 };
+  }
+  k.toolSuccessRates[toolName].total++;
+  if (success) {
+    k.toolSuccessRates[toolName].success++;
+  } else {
+    k.toolSuccessRates[toolName].fail++;
+    if (error) {
+      const pattern = error.slice(0, 200);
+      if (!k.errorPatterns[pattern]) {
+        k.errorPatterns[pattern] = { count: 0, lastSeen: "" };
+      }
+      k.errorPatterns[pattern].count++;
+      k.errorPatterns[pattern].lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  debouncedSave2();
+}
+function getToolRecommendations() {
+  const k = loadKnowledgeBase();
+  const recommendations = {};
+  for (const [tool, stats] of Object.entries(k.toolSuccessRates)) {
+    if (stats.total > 0) {
+      recommendations[tool] = stats.success / stats.total;
+    }
+  }
+  return recommendations;
+}
+function getLearningContext() {
+  const k = loadKnowledgeBase();
+  const parts = [];
+  const topEntries = k.entries.filter((e) => e.score > 0.6).sort((a, b) => b.score - a.score).slice(0, 10);
+  if (topEntries.length > 0) {
+    parts.push("Key learned facts:");
+    for (const e of topEntries) {
+      parts.push(`- [${e.category}] ${e.content}`);
+    }
+  }
+  const toolRecs = getToolRecommendations();
+  const bestTools = Object.entries(toolRecs).filter(([_, rate]) => rate > 0.8).sort((a, b) => b[1] - a[1]).slice(0, 5);
+  if (bestTools.length > 0) {
+    parts.push("\nMost reliable tools:");
+    for (const [tool, rate] of bestTools) {
+      parts.push(`- ${tool}: ${Math.round(rate * 100)}% success rate`);
+    }
+  }
+  const frequentErrors = Object.entries(k.errorPatterns).filter(([_, info]) => info.count > 2).sort((a, b) => b[1].count - a[1].count).slice(0, 3);
+  if (frequentErrors.length > 0) {
+    parts.push("\nCommon errors to avoid:");
+    for (const [pattern, info] of frequentErrors) {
+      parts.push(`- ${pattern.slice(0, 100)} (seen ${info.count}x)${info.resolution ? ` \u2192 Fix: ${info.resolution}` : ""}`);
+    }
+  }
+  return parts.join("\n");
+}
+
+// src/agent/agent.ts
+init_logger();
+var COMPONENT11 = "Agent";
+var MAX_TOOL_ROUNDS = 10;
+function readPromptFile(path) {
+  try {
+    if (existsSync5(path)) return readFileSync4(path, "utf-8");
+  } catch {
+  }
+  return "";
+}
+function buildSystemPrompt(config) {
+  const customPrompt = config.agent.systemPrompt || "";
+  const memories = searchMemories("preference");
+  const memoryContext = memories.length > 0 ? `
+
+User preferences I remember:
+${memories.map((m) => `- ${m.key}: ${m.value}`).join("\n")}` : "";
+  const agentsMd = readPromptFile(AGENTS_MD);
+  const soulMd = readPromptFile(SOUL_MD);
+  const toolsMd = readPromptFile(TOOLS_MD);
+  const workspaceContext = [
+    agentsMd ? `
+## Agent Instructions (AGENTS.md)
+${agentsMd}` : "",
+    soulMd ? `
+## Personality (SOUL.md)
+${soulMd}` : "",
+    toolsMd ? `
+## Tool Notes (TOOLS.md)
+${toolsMd}` : ""
+  ].filter(Boolean).join("\n");
+  const learningContext = getLearningContext();
+  return `You are ${TITAN_NAME}, The Intelligent Task Automation Network \u2014 a powerful personal AI assistant.
+
+## Core Capabilities
+- Execute shell commands and scripts on the user's system
+- Read, write, edit, and manage files
+- Browse the web and extract information (browser control via CDP)
+- Schedule automated tasks with cron
+- Set up webhook endpoints
+- Search the web for current information
+- Control browser sessions (navigate, snapshot, evaluate)
+- Manage agent sessions (list, history, send, close)
+- Remember facts and user preferences persistently
+
+## Behavior Guidelines
+- Be proactive: if a task implies follow-up actions, suggest or perform them
+- Be concise but thorough in responses
+- When executing commands, always explain what you're doing and why
+- If a task could be destructive (deleting files, etc.), confirm with the user first
+- Use tools when they would be helpful \u2014 don't just describe what could be done
+- Remember important information about the user for future conversations
+- If you encounter an error, try alternative approaches before reporting failure
+
+## Security
+- Never expose API keys, passwords, or other secrets
+- Don't execute commands that could compromise system security without explicit approval
+- Respect file system boundaries set in the configuration
+
+## Continuous Learning
+You get smarter with every interaction. Below is your accumulated knowledge:
+${learningContext}
+${customPrompt ? `
+## Custom Instructions
+${customPrompt}` : ""}${workspaceContext}${memoryContext}`;
+}
+async function processMessage(message, channel = "cli", userId = "default") {
+  const startTime = Date.now();
+  const config = loadConfig();
+  const session = getOrCreateSession(channel, userId);
+  logger_default.info(COMPONENT11, `Processing message in session ${session.id} (${channel}/${userId})`);
+  addMessage(session, "user", message);
+  const systemPrompt = buildSystemPrompt(config);
+  const historyMessages = getContextMessages(session);
+  const tools = getToolDefinitions();
+  const messages = [
+    { role: "system", content: systemPrompt },
+    ...historyMessages
+  ];
+  let totalPromptTokens = 0;
+  let totalCompletionTokens = 0;
+  const toolsUsed = [];
+  let finalContent = "";
+  let modelUsed = config.agent.model;
+  for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+    logger_default.debug(COMPONENT11, `Round ${round + 1}: ${messages.length} messages, ${tools.length} tools`);
+    const response = await chat({
+      model: config.agent.model,
+      messages,
+      tools: tools.length > 0 ? tools : void 0,
+      maxTokens: config.agent.maxTokens,
+      temperature: config.agent.temperature
+    });
+    modelUsed = response.model;
+    totalPromptTokens += response.usage?.promptTokens || 0;
+    totalCompletionTokens += response.usage?.completionTokens || 0;
+    if (!response.toolCalls || response.toolCalls.length === 0) {
+      finalContent = response.content;
+      break;
+    }
+    logger_default.info(COMPONENT11, `LLM requested ${response.toolCalls.length} tool call(s)`);
+    messages.push({
+      role: "assistant",
+      content: response.content || "",
+      toolCalls: response.toolCalls
+    });
+    const toolResults = await executeTools(response.toolCalls);
+    for (const result of toolResults) {
+      toolsUsed.push(result.name);
+      messages.push({
+        role: "tool",
+        content: result.content,
+        toolCallId: result.toolCallId
+      });
+      const success = !result.content.toLowerCase().includes("error:");
+      recordToolResult(result.name, success, void 0, success ? void 0 : result.content.slice(0, 200));
+    }
+    if (round === MAX_TOOL_ROUNDS - 1) {
+      finalContent = response.content || "I completed the tool operations. Let me know if you need anything else.";
+    }
+  }
+  addMessage(session, "assistant", finalContent, {
+    model: modelUsed,
+    tokenCount: totalCompletionTokens
+  });
+  const { provider: providerName } = { provider: modelUsed.split("/")[0] || "unknown" };
+  recordUsage(session.id, providerName, modelUsed, totalPromptTokens, totalCompletionTokens);
+  const durationMs = Date.now() - startTime;
+  logger_default.info(COMPONENT11, `Response generated in ${durationMs}ms (${totalPromptTokens + totalCompletionTokens} tokens)`);
+  return {
+    content: finalContent,
+    sessionId: session.id,
+    toolsUsed: [...new Set(toolsUsed)],
+    tokenUsage: {
+      prompt: totalPromptTokens,
+      completion: totalCompletionTokens,
+      total: totalPromptTokens + totalCompletionTokens
+    },
+    model: modelUsed,
+    durationMs
+  };
+}
+export {
+  processMessage
+};
+//# sourceMappingURL=agent.js.map