titan-agent 2026.4.0

package/dist/skills/builtin/sessions.js

@@ -0,0 +1,1729 @@
+#!/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/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var TITAN_VERSION, TITAN_NAME, TITAN_ASCII_LOGO, TITAN_HOME, TITAN_CONFIG_PATH, TITAN_DB_PATH, TITAN_WORKSPACE, TITAN_SKILLS_DIR, TITAN_LOGS_DIR, TITAN_MEMORY_DIR, AGENTS_MD, SOUL_MD, TOOLS_MD, DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, DEFAULT_WEB_PORT, DEFAULT_MODEL, DEFAULT_MAX_TOKENS, DEFAULT_TEMPERATURE, MAX_CONTEXT_MESSAGES, SESSION_TIMEOUT_MS, DEFAULT_SANDBOX_MODE, ALLOWED_TOOLS_DEFAULT;
+var init_constants = __esm({
+  "src/utils/constants.ts"() {
+    "use strict";
+    TITAN_VERSION = "2026.4.0";
+    TITAN_NAME = "TITAN";
+    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`;
+    TITAN_HOME = join(homedir(), ".titan");
+    TITAN_CONFIG_PATH = join(TITAN_HOME, "titan.json");
+    TITAN_DB_PATH = join(TITAN_HOME, "titan.db");
+    TITAN_WORKSPACE = join(TITAN_HOME, "workspace");
+    TITAN_SKILLS_DIR = join(TITAN_WORKSPACE, "skills");
+    TITAN_LOGS_DIR = join(TITAN_HOME, "logs");
+    TITAN_MEMORY_DIR = join(TITAN_HOME, "memory");
+    AGENTS_MD = join(TITAN_WORKSPACE, "AGENTS.md");
+    SOUL_MD = join(TITAN_WORKSPACE, "SOUL.md");
+    TOOLS_MD = join(TITAN_WORKSPACE, "TOOLS.md");
+    DEFAULT_GATEWAY_HOST = "127.0.0.1";
+    DEFAULT_GATEWAY_PORT = 18789;
+    DEFAULT_WEB_PORT = 18790;
+    DEFAULT_MODEL = "anthropic/claude-sonnet-4-20250514";
+    DEFAULT_MAX_TOKENS = 8192;
+    DEFAULT_TEMPERATURE = 0.7;
+    MAX_CONTEXT_MESSAGES = 50;
+    SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+    DEFAULT_SANDBOX_MODE = "host";
+    ALLOWED_TOOLS_DEFAULT = [
+      "shell",
+      "read_file",
+      "write_file",
+      "edit_file",
+      "list_dir",
+      "web_search",
+      "browser",
+      "cron",
+      "webhook",
+      "email",
+      "memory"
+    ];
+  }
+});
+
+// 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/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;
+  }
+}
+var init_helpers = __esm({
+  "src/utils/helpers.ts"() {
+    "use strict";
+  }
+});
+
+// src/config/schema.ts
+import { z } from "zod";
+var ProviderConfigSchema, ChannelConfigSchema, SecurityConfigSchema, GatewayConfigSchema, AgentConfigSchema, TitanConfigSchema;
+var init_schema = __esm({
+  "src/config/schema.ts"() {
+    "use strict";
+    init_constants();
+    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()
+    });
+    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")
+    });
+    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({})
+    });
+    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({})
+    });
+    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")
+    });
+    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
+import { existsSync as existsSync2 } from "fs";
+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;
+}
+var COMPONENT, cachedConfig;
+var init_config = __esm({
+  "src/config/config.ts"() {
+    "use strict";
+    init_constants();
+    init_helpers();
+    init_schema();
+    init_logger();
+    COMPONENT = "Config";
+    cachedConfig = null;
+  }
+});
+
+// src/agent/toolRunner.ts
+function registerTool(handler) {
+  toolRegistry.set(handler.name, handler);
+  logger_default.debug(COMPONENT2, `Registered tool: ${handler.name}`);
+}
+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(COMPONENT2, `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(COMPONENT2, `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(COMPONENT2, `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;
+}
+var COMPONENT2, toolRegistry;
+var init_toolRunner = __esm({
+  "src/agent/toolRunner.ts"() {
+    "use strict";
+    init_logger();
+    init_config();
+    COMPONENT2 = "ToolRunner";
+    toolRegistry = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/skills/registry.ts
+function registerSkill(meta, handler) {
+  registeredSkills.set(meta.name, meta);
+  registerTool(handler);
+  logger_default.debug(COMPONENT3, `Registered skill: ${meta.name} (${meta.source})`);
+}
+var COMPONENT3, registeredSkills;
+var init_registry = __esm({
+  "src/skills/registry.ts"() {
+    "use strict";
+    init_constants();
+    init_toolRunner();
+    init_helpers();
+    init_logger();
+    COMPONENT3 = "Skills";
+    registeredSkills = /* @__PURE__ */ new Map();
+  }
+});
+
+// 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(COMPONENT4, `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(COMPONENT4, `Decryption failed: ${e.message}`);
+    throw new Error("Failed to decrypt session data. Invalid key or corrupted payload.");
+  }
+}
+var COMPONENT4, ALGORITHM;
+var init_encryption = __esm({
+  "src/security/encryption.ts"() {
+    "use strict";
+    init_logger();
+    COMPONENT4 = "Encryption";
+    ALGORITHM = "aes-256-gcm";
+  }
+});
+
+// src/memory/memory.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+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(COMPONENT5, "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(COMPONENT5, `Failed to save data: ${e.message}`);
+  }
+}
+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(COMPONENT5, `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(COMPONENT5, `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();
+}
+var COMPONENT5, DB_FILE, store, saveTimeout;
+var init_memory = __esm({
+  "src/memory/memory.ts"() {
+    "use strict";
+    init_constants();
+    init_helpers();
+    init_logger();
+    init_encryption();
+    COMPONENT5 = "Memory";
+    DB_FILE = join2(TITAN_HOME, "titan-data.json");
+    store = null;
+    saveTimeout = null;
+  }
+});
+
+// src/agent/session.ts
+import { v4 as uuid } from "uuid";
+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(COMPONENT6, `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(COMPONENT6, `Recovered session ${existing.id}, but E2E key was lost from memory.`);
+      }
+      activeSessions.set(sessionKey, session2);
+      return session2;
+    }
+  }
+  const session = {
+    id: uuid(),
+    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(COMPONENT6, `Generated E2E key for session ${session.id}`);
+    }).catch((err) => {
+      logger_default.error(COMPONENT6, `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(COMPONENT6, `Created new session: ${session.id} (${channel}/${userId})`);
+  return session;
+}
+function addMessage(session, role, content, extra) {
+  const messageId = uuid();
+  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
+  }));
+}
+function listSessions() {
+  const store2 = getDb();
+  return store2.sessions.filter((s) => s.status === "active").sort((a, b) => b.last_active.localeCompare(a.last_active)).map((s) => ({
+    id: s.id,
+    channel: s.channel,
+    userId: s.user_id,
+    agentId: s.agent_id,
+    status: s.status,
+    messageCount: s.message_count,
+    createdAt: s.created_at,
+    lastActive: s.last_active
+  }));
+}
+function closeSession(sessionId) {
+  const store2 = getDb();
+  const sessionRec = store2.sessions.find((s) => s.id === sessionId);
+  if (sessionRec) {
+    sessionRec.status = "closed";
+  }
+  for (const [key, session] of activeSessions) {
+    if (session.id === sessionId) {
+      activeSessions.delete(key);
+      break;
+    }
+  }
+  logger_default.info(COMPONENT6, `Closed session: ${sessionId}`);
+}
+var COMPONENT6, activeSessions;
+var init_session = __esm({
+  "src/agent/session.ts"() {
+    "use strict";
+    init_memory();
+    init_constants();
+    init_logger();
+    COMPONENT6 = "Session";
+    activeSessions = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/providers/base.ts
+var LLMProvider;
+var init_base = __esm({
+  "src/providers/base.ts"() {
+    "use strict";
+    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/providers/anthropic.ts
+import { v4 as uuid2 } from "uuid";
+var COMPONENT7, AnthropicProvider;
+var init_anthropic = __esm({
+  "src/providers/anthropic.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT7 = "Anthropic";
+    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(COMPONENT7, `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 || uuid2(),
+          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
+import { v4 as uuid3 } from "uuid";
+var COMPONENT8, OpenAIProvider;
+var init_openai = __esm({
+  "src/providers/openai.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT8 = "OpenAI";
+    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(COMPONENT8, `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 || uuid3(),
+          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
+import { v4 as uuid4 } from "uuid";
+var COMPONENT9, GoogleProvider;
+var init_google = __esm({
+  "src/providers/google.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT9 = "Google";
+    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(COMPONENT9, `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: uuid4(),
+                type: "function",
+                function: {
+                  name: fc.name,
+                  arguments: JSON.stringify(fc.args)
+                }
+              });
+            }
+          }
+        }
+        const usageMeta = data.usageMetadata;
+        return {
+          id: uuid4(),
+          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
+import { v4 as uuid5 } from "uuid";
+var COMPONENT10, OllamaProvider;
+var init_ollama = __esm({
+  "src/providers/ollama.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT10 = "Ollama";
+    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(COMPONENT10, `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: uuid5(),
+              type: "function",
+              function: {
+                name: fn.name,
+                arguments: JSON.stringify(fn.arguments)
+              }
+            });
+          }
+        }
+        return {
+          id: uuid5(),
+          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
+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(COMPONENT11, `Routing to ${provider.displayName} (model: ${model})`);
+  try {
+    return await provider.chat({ ...options, model });
+  } catch (error) {
+    logger_default.error(COMPONENT11, `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(COMPONENT11, `Failing over to ${fallback.displayName} (model: ${models[0]})`);
+        return await fallback.chat({ ...options, model: models[0] });
+      } catch {
+        continue;
+      }
+    }
+    throw error;
+  }
+}
+var COMPONENT11, providers, initialized;
+var init_router = __esm({
+  "src/providers/router.ts"() {
+    "use strict";
+    init_base();
+    init_anthropic();
+    init_openai();
+    init_google();
+    init_ollama();
+    init_logger();
+    COMPONENT11 = "Router";
+    providers = /* @__PURE__ */ new Map();
+    initialized = false;
+  }
+});
+
+// src/memory/learning.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+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: []
+  };
+}
+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");
+}
+var KNOWLEDGE_FILE, kb, saveTimeout2;
+var init_learning = __esm({
+  "src/memory/learning.ts"() {
+    "use strict";
+    init_constants();
+    init_helpers();
+    init_logger();
+    KNOWLEDGE_FILE = join3(TITAN_HOME, "knowledge.json");
+    kb = null;
+    saveTimeout2 = null;
+  }
+});
+
+// src/agent/agent.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+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(COMPONENT12, `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(COMPONENT12, `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(COMPONENT12, `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(COMPONENT12, `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
+  };
+}
+var COMPONENT12, MAX_TOOL_ROUNDS;
+var init_agent = __esm({
+  "src/agent/agent.ts"() {
+    "use strict";
+    init_router();
+    init_config();
+    init_session();
+    init_toolRunner();
+    init_memory();
+    init_learning();
+    init_logger();
+    init_constants();
+    COMPONENT12 = "Agent";
+    MAX_TOOL_ROUNDS = 10;
+  }
+});
+
+// src/skills/builtin/sessions.ts
+function registerSessionsSkill() {
+  registerSkill(
+    { name: "sessions_list", description: "List active sessions", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "sessions_list",
+      description: "List all active agent sessions with their IDs, channels, users, and message counts.",
+      parameters: {
+        type: "object",
+        properties: {}
+      },
+      execute: async () => {
+        const sessions = listSessions();
+        if (sessions.length === 0) return "No active sessions.";
+        return sessions.map(
+          (s) => `\u2022 ${s.id.slice(0, 8)} | ${s.channel} | user: ${s.userId} | msgs: ${s.messageCount} | last active: ${s.lastActive}`
+        ).join("\n");
+      }
+    }
+  );
+  registerSkill(
+    { name: "sessions_history", description: "Get session message history", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "sessions_history",
+      description: "Retrieve the recent message history for a specific session.",
+      parameters: {
+        type: "object",
+        properties: {
+          sessionChannel: { type: "string", description: "Channel of the session" },
+          sessionUserId: { type: "string", description: "User ID of the session" },
+          limit: { type: "number", description: "Max messages to return (default: 20)" }
+        },
+        required: ["sessionChannel", "sessionUserId"]
+      },
+      execute: async (args) => {
+        const channel = args.sessionChannel;
+        const userId = args.sessionUserId;
+        const limit = args.limit || 20;
+        const session = getOrCreateSession(channel, userId);
+        const messages = getContextMessages(session, limit);
+        if (messages.length === 0) return `No messages in session ${channel}/${userId}.`;
+        return messages.map(
+          (m) => `[${m.role}] ${m.content.slice(0, 500)}`
+        ).join("\n---\n");
+      }
+    }
+  );
+  registerSkill(
+    { name: "sessions_send", description: "Send a message to another session", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "sessions_send",
+      description: "Send a message to a specific user's session on a channel, triggering agent processing.",
+      parameters: {
+        type: "object",
+        properties: {
+          targetChannel: { type: "string", description: 'Target channel (e.g., "discord", "telegram")' },
+          targetUserId: { type: "string", description: "Target user ID" },
+          message: { type: "string", description: "Message to send" }
+        },
+        required: ["targetChannel", "targetUserId", "message"]
+      },
+      execute: async (args) => {
+        const channel = args.targetChannel;
+        const userId = args.targetUserId;
+        const message = args.message;
+        logger_default.info(COMPONENT13, `Sending inter-session message to ${channel}/${userId}`);
+        try {
+          const response = await processMessage(message, channel, userId);
+          return `Message delivered to ${channel}/${userId}. Response: ${response.content.slice(0, 500)}`;
+        } catch (error) {
+          return `Error sending to ${channel}/${userId}: ${error.message}`;
+        }
+      }
+    }
+  );
+  registerSkill(
+    { name: "sessions_close", description: "Close a session", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "sessions_close",
+      description: "Close a specific session by its session ID.",
+      parameters: {
+        type: "object",
+        properties: {
+          sessionId: { type: "string", description: "Session ID to close" }
+        },
+        required: ["sessionId"]
+      },
+      execute: async (args) => {
+        const sessionId = args.sessionId;
+        closeSession(sessionId);
+        return `Session ${sessionId} closed.`;
+      }
+    }
+  );
+}
+var COMPONENT13;
+var init_sessions = __esm({
+  "src/skills/builtin/sessions.ts"() {
+    init_registry();
+    init_session();
+    init_agent();
+    init_logger();
+    COMPONENT13 = "Sessions";
+  }
+});
+init_sessions();
+export {
+  registerSessionsSkill
+};
+//# sourceMappingURL=sessions.js.map