titan-agent 2026.4.0

package/dist/skills/builtin/auto_generate.js

@@ -0,0 +1,1129 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/utils/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var TITAN_VERSION, 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, 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_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;
+    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, path2, value) {
+  const parts = path2.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(handler2) {
+  toolRegistry.set(handler2.name, handler2);
+  logger_default.debug(COMPONENT2, `Registered tool: ${handler2.name}`);
+}
+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
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function registerSkill(meta2, handler2) {
+  registeredSkills.set(meta2.name, meta2);
+  registerTool(handler2);
+  logger_default.debug(COMPONENT3, `Registered skill: ${meta2.name} (${meta2.source})`);
+}
+async function loadAutoSkills() {
+  const autoDir = join2(TITAN_HOME, "skills", "auto");
+  if (!existsSync3(autoDir)) return;
+  logger_default.info(COMPONENT3, "Checking for auto-generated skills...");
+  const files = readdirSync(autoDir).filter((f) => f.endsWith(".js"));
+  let loadedCount = 0;
+  for (const file of files) {
+    try {
+      const skillPath = join2(autoDir, file);
+      const modulePath = `file://${skillPath}?t=${Date.now()}`;
+      const mod = await import(modulePath);
+      if (mod.default && mod.default.name && mod.default.execute) {
+        const handler2 = mod.default;
+        const meta2 = {
+          name: handler2.name,
+          description: handler2.description || "Auto-generated skill",
+          version: "1.0.0",
+          source: "workspace",
+          // Consider it part of user workspace
+          enabled: true
+        };
+        registerSkill(meta2, handler2);
+        loadedCount++;
+      }
+    } catch (e) {
+      logger_default.error(COMPONENT3, `Failed to load auto skill ${file}: ${e.message}`);
+    }
+  }
+  if (loadedCount > 0) {
+    logger_default.info(COMPONENT3, `Successfully loaded ${loadedCount} auto-generated skills`);
+  }
+}
+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/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 uuid } from "uuid";
+var COMPONENT4, AnthropicProvider;
+var init_anthropic = __esm({
+  "src/providers/anthropic.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT4 = "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(COMPONENT4, `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
+import { v4 as uuid2 } from "uuid";
+var COMPONENT5, OpenAIProvider;
+var init_openai = __esm({
+  "src/providers/openai.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT5 = "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(COMPONENT5, `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
+import { v4 as uuid3 } from "uuid";
+var COMPONENT6, GoogleProvider;
+var init_google = __esm({
+  "src/providers/google.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT6 = "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(COMPONENT6, `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
+import { v4 as uuid4 } from "uuid";
+var COMPONENT7, OllamaProvider;
+var init_ollama = __esm({
+  "src/providers/ollama.ts"() {
+    "use strict";
+    init_base();
+    init_config();
+    init_logger();
+    COMPONENT7 = "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(COMPONENT7, `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
+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(COMPONENT8, `Routing to ${provider.displayName} (model: ${model})`);
+  try {
+    return await provider.chat({ ...options, model });
+  } catch (error) {
+    logger_default.error(COMPONENT8, `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(COMPONENT8, `Failing over to ${fallback.displayName} (model: ${models[0]})`);
+        return await fallback.chat({ ...options, model: models[0] });
+      } catch {
+        continue;
+      }
+    }
+    throw error;
+  }
+}
+var COMPONENT8, providers, initialized;
+var init_router = __esm({
+  "src/providers/router.ts"() {
+    "use strict";
+    init_base();
+    init_anthropic();
+    init_openai();
+    init_google();
+    init_ollama();
+    init_logger();
+    COMPONENT8 = "Router";
+    providers = /* @__PURE__ */ new Map();
+    initialized = false;
+  }
+});
+
+// src/agent/generator.ts
+import path from "path";
+import { existsSync as existsSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { execSync } from "child_process";
+async function generateAndInstallSkill(description, requestedName) {
+  logger_default.info(COMPONENT9, `Initiating auto-generation for skill: "${requestedName}"`);
+  if (!existsSync4(AUTO_SKILLS_DIR)) {
+    mkdirSync2(AUTO_SKILLS_DIR, { recursive: true });
+  }
+  try {
+    const config = loadConfig();
+    const model = config.agent.model;
+    logger_default.debug(COMPONENT9, `Prompting ${model} to generate code...`);
+    const messages = [
+      { role: "user", content: GENERATOR_PROMPT + `
+Requested Capability: ${description}
+Requested Name: ${requestedName}` }
+    ];
+    const response = await chat({ messages, model });
+    let code = response.content;
+    if (code.startsWith("```typescript")) {
+      code = code.replace(/^\`\`\`typescript\n/, "").replace(/\n\`\`\`$/, "");
+    } else if (code.startsWith("```")) {
+      code = code.replace(/^\`\`\`\n/, "").replace(/\n\`\`\`$/, "");
+    }
+    if (code.includes("process.exit") || code.includes("rm -rf /*") || code.includes("fs.rmSync('/'")) {
+      return { success: false, error: "Generated code failed safety static analysis." };
+    }
+    const nameMatch = code.match(/name:\s*['"]([a-z0-9_]+)['"]/);
+    const finalName = nameMatch ? nameMatch[1] : requestedName.replace(/[^a-z0-9_]/g, "_");
+    const tsFilePath = path.join(AUTO_SKILLS_DIR, `${finalName}.ts`);
+    const jsFilePath = path.join(AUTO_SKILLS_DIR, `${finalName}.js`);
+    writeFileSync2(tsFilePath, code, "utf-8");
+    logger_default.info(COMPONENT9, `Wrote generated source to ${tsFilePath}`);
+    try {
+      execSync(`npx tsc ${tsFilePath} --module NodeNext --moduleResolution NodeNext --target ES2022`, { stdio: "pipe" });
+      logger_default.info(COMPONENT9, `Compiled ${finalName}.ts successfully.`);
+    } catch (compileError) {
+      logger_default.error(COMPONENT9, `Compilation failed for ${finalName}`);
+      return { success: false, error: `Compilation failed: ${compileError.message || "Unknown error"}` };
+    }
+    if (!existsSync4(jsFilePath)) {
+      return { success: false, error: "Compilation did not produce a .js file." };
+    }
+    await loadAutoSkills();
+    logger_default.info(COMPONENT9, `\u2728 Successfully generated and installed new skill: ${finalName}`);
+    return {
+      success: true,
+      skillName: finalName,
+      filePath: tsFilePath
+    };
+  } catch (e) {
+    logger_default.error(COMPONENT9, `Auto-generation failed: ${e.message}`);
+    return { success: false, error: e.message };
+  }
+}
+var COMPONENT9, AUTO_SKILLS_DIR, GENERATOR_PROMPT;
+var init_generator = __esm({
+  "src/agent/generator.ts"() {
+    "use strict";
+    init_config();
+    init_router();
+    init_constants();
+    init_registry();
+    init_logger();
+    COMPONENT9 = "SkillGenerator";
+    AUTO_SKILLS_DIR = path.join(TITAN_HOME, "skills", "auto");
+    GENERATOR_PROMPT = `You are the core intelligence of TITAN, an elite autonomous AI agent framework.
+Your task is to generate a new, fully functional TypeScript tool (skill) based on the user's request.
+
+CRITICAL REQUIREMENTS FOR THE CODE:
+1. It MUST export a "default" object that implements the "ToolConfig" interface.
+2. It MUST use ESM imports (e.g., "import { ... } from '...'").
+3. It CAN ONLY use built-in Node.js modules (fs, path, crypto, child_process, os, http, https, url) unless you are absolutely certain a specific npm package is guaranteed to be installed globally. Prefer built-ins.
+4. It MUST handle errors gracefully and return descriptive string messages.
+5. Do NOT wrap the output in markdown code blocks. Output ONLY the raw TypeScript code.
+
+Here is the exact ToolConfig interface you must implement:
+export interface ToolConfig {
+    name: string;        // lowercase, alphanumeric, underscores only (e.g. 'my_custom_tool')
+    description: string; // concise explanation of what the tool does
+    parameters: any;     // Zod schema converted to JSON schema format for LLM function calling
+    execute: (args: any, config: any) => Promise<string>; // the async execution function
+}
+
+Example JSON schema for parameters (must follow this exact structure):
+{
+    "type": "object",
+    "properties": {
+        "filePath": {
+            "type": "string",
+            "description": "Absolute path to the file"
+        }
+    },
+    "required": ["filePath"]
+}
+
+Example implementation format:
+import fs from 'fs';
+
+export default {
+    name: "count_lines",
+    description: "Counts the number of lines in a given text file.",
+    parameters: {
+        type: "object",
+        properties: {
+            filePath: { type: "string" }
+        },
+        required: ["filePath"]
+    },
+    execute: async (args, config) => {
+        try {
+            const content = fs.readFileSync(args.filePath, 'utf-8');
+            return \`File has \${content.split('\\n').length} lines.\`;
+        } catch (e) {
+            return \`Error: \${e.message}\`;
+        }
+    }
+};
+
+Now, generate the TypeScript code for the following requested tool capability:
+`;
+  }
+});
+
+// src/skills/builtin/auto_generate.ts
+function registerAutoGenerateSkill() {
+  registerSkill(meta, handler);
+}
+var meta, handler;
+var init_auto_generate = __esm({
+  "src/skills/builtin/auto_generate.ts"() {
+    init_registry();
+    init_generator();
+    meta = {
+      name: "auto_generate_skill",
+      description: "Auto-generates, compiles, and installs a new TypeScript tool/skill when TITAN lacks a necessary capability.",
+      version: "1.0.0",
+      source: "bundled",
+      enabled: true
+    };
+    handler = {
+      name: "auto_generate_skill",
+      description: "Use this tool to write a NEW skill/tool when you realize you cannot complete the user request with your standard tools. Generates real TypeScript code, compiles it, and hot-reloads it into your capabilities.",
+      parameters: {
+        type: "object",
+        properties: {
+          capability_description: {
+            type: "string",
+            description: "A detailed explanation of exactly what this new tool should do, what arguments it should take, and what it should return."
+          },
+          suggested_name: {
+            type: "string",
+            description: 'A short, lowercase name with underscores for the new tool (e.g., "parse_csv", "resize_image").'
+          }
+        },
+        required: ["capability_description", "suggested_name"]
+      },
+      execute: async (args) => {
+        const capability = args.capability_description;
+        const name = args.suggested_name;
+        if (!capability || !name) {
+          return "Error: missing required arguments capability_description or suggested_name.";
+        }
+        const result = await generateAndInstallSkill(capability, name);
+        if (result.success) {
+          return `\u2728 SUCCESS! New skill '${result.skillName}' has been generated, compiled, and hot-loaded into your tools. You can now use this tool natively!`;
+        } else {
+          return `Failed to generate skill: ${result.error}`;
+        }
+      }
+    };
+  }
+});
+init_auto_generate();
+export {
+  registerAutoGenerateSkill
+};
+//# sourceMappingURL=auto_generate.js.map