nextclaw 0.2.0 → 0.2.2

package/dist/chunk-HXRBJNWA.js

@@ -0,0 +1,2324 @@
+// src/config/brand.ts
+var ENV_APP_NAME_KEY = "NEXTCLAW_APP_NAME";
+var envAppName = process.env[ENV_APP_NAME_KEY]?.trim();
+var APP_NAME = envAppName && envAppName.length > 0 ? envAppName : "nextclaw";
+var APP_TAGLINE = "Personal AI Assistant";
+var APP_TITLE = `${APP_NAME.slice(0, 1).toUpperCase()}${APP_NAME.slice(1)}`;
+var ENV_HOME_KEY = "NEXTCLAW_HOME";
+var DEFAULT_HOME_DIR = ".nextclaw";
+var DEFAULT_CONFIG_FILE = "config.json";
+var DEFAULT_WORKSPACE_DIR = "workspace";
+var DEFAULT_CONFIG_PATH = `~/${DEFAULT_HOME_DIR}/${DEFAULT_CONFIG_FILE}`;
+var DEFAULT_WORKSPACE_PATH = `~/${DEFAULT_HOME_DIR}/${DEFAULT_WORKSPACE_DIR}`;
+var APP_USER_AGENT = APP_NAME;
+var APP_REPLY_SUBJECT = `${APP_NAME} reply`;
+var SKILL_METADATA_KEY = "nextclaw";
+
+// src/utils/helpers.ts
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { resolve } from "path";
+function ensureDir(path) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+  return path;
+}
+function getDataPath() {
+  const override = process.env[ENV_HOME_KEY]?.trim();
+  if (override) {
+    return ensureDir(resolve(override));
+  }
+  return ensureDir(resolve(homedir(), DEFAULT_HOME_DIR));
+}
+function getWorkspacePath(workspace) {
+  if (workspace) {
+    return ensureDir(resolve(expandHome(workspace)));
+  }
+  return ensureDir(resolve(getDataPath(), "workspace"));
+}
+function getSessionsPath() {
+  return ensureDir(resolve(getDataPath(), "sessions"));
+}
+function todayDate() {
+  const now = /* @__PURE__ */ new Date();
+  return now.toISOString().slice(0, 10);
+}
+function safeFilename(value) {
+  return value.replace(/[<>:"/\\|?*]/g, "_").trim();
+}
+function expandHome(value) {
+  if (value.startsWith("~/")) {
+    return resolve(homedir(), value.slice(2));
+  }
+  return value;
+}
+
+// src/session/manager.ts
+import { readFileSync, writeFileSync, existsSync as existsSync2, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+var SessionManager = class {
+  constructor(workspace) {
+    this.workspace = workspace;
+    this.sessionsDir = getSessionsPath();
+  }
+  sessionsDir;
+  cache = /* @__PURE__ */ new Map();
+  getSessionPath(key) {
+    const safeKey = safeFilename(key.replace(/:/g, "_"));
+    return join(this.sessionsDir, `${safeKey}.jsonl`);
+  }
+  getOrCreate(key) {
+    const cached = this.cache.get(key);
+    if (cached) {
+      return cached;
+    }
+    const loaded = this.load(key);
+    const session = loaded ?? {
+      key,
+      messages: [],
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      metadata: {}
+    };
+    this.cache.set(key, session);
+    return session;
+  }
+  addMessage(session, role, content, extra = {}) {
+    const msg = {
+      role,
+      content,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...extra
+    };
+    session.messages.push(msg);
+    session.updatedAt = /* @__PURE__ */ new Date();
+  }
+  getHistory(session, maxMessages = 50) {
+    const recent = session.messages.length > maxMessages ? session.messages.slice(-maxMessages) : session.messages;
+    return recent.map((msg) => ({ role: msg.role, content: msg.content }));
+  }
+  clear(session) {
+    session.messages = [];
+    session.updatedAt = /* @__PURE__ */ new Date();
+  }
+  load(key) {
+    const path = this.getSessionPath(key);
+    if (!existsSync2(path)) {
+      return null;
+    }
+    try {
+      const lines = readFileSync(path, "utf-8").split("\n").filter(Boolean);
+      const messages = [];
+      let metadata = {};
+      let createdAt = /* @__PURE__ */ new Date();
+      let updatedAt = /* @__PURE__ */ new Date();
+      for (const line of lines) {
+        const data = JSON.parse(line);
+        if (data._type === "metadata") {
+          metadata = data.metadata ?? {};
+          if (data.created_at) {
+            createdAt = new Date(String(data.created_at));
+          }
+          if (data.updated_at) {
+            updatedAt = new Date(String(data.updated_at));
+          }
+        } else {
+          messages.push(data);
+        }
+      }
+      return {
+        key,
+        messages,
+        createdAt,
+        updatedAt,
+        metadata
+      };
+    } catch {
+      return null;
+    }
+  }
+  save(session) {
+    const path = this.getSessionPath(session.key);
+    const metadataLine = {
+      _type: "metadata",
+      created_at: session.createdAt.toISOString(),
+      updated_at: session.updatedAt.toISOString(),
+      metadata: session.metadata
+    };
+    const lines = [JSON.stringify(metadataLine), ...session.messages.map((msg) => JSON.stringify(msg))].join("\n");
+    writeFileSync(path, `${lines}
+`);
+    this.cache.set(session.key, session);
+  }
+  delete(key) {
+    this.cache.delete(key);
+    const path = this.getSessionPath(key);
+    if (existsSync2(path)) {
+      unlinkSync(path);
+      return true;
+    }
+    return false;
+  }
+  listSessions() {
+    const sessions = [];
+    for (const entry of readdirSync(this.sessionsDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+        continue;
+      }
+      const path = join(this.sessionsDir, entry.name);
+      const firstLine = readFileSync(path, "utf-8").split("\n")[0];
+      if (!firstLine) {
+        continue;
+      }
+      try {
+        const data = JSON.parse(firstLine);
+        if (data._type === "metadata") {
+          sessions.push({
+            key: entry.name.replace(/\.jsonl$/, "").replace(/_/g, ":"),
+            created_at: data.created_at,
+            updated_at: data.updated_at,
+            path
+          });
+        }
+      } catch {
+        continue;
+      }
+    }
+    return sessions;
+  }
+};
+
+// src/agent/context.ts
+import { readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
+import { join as join4, extname } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/agent/memory.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join2 } from "path";
+var MemoryStore = class {
+  constructor(workspace) {
+    this.workspace = workspace;
+    this.memoryDir = ensureDir(join2(workspace, "memory"));
+    this.memoryFile = join2(this.memoryDir, "MEMORY.md");
+  }
+  memoryDir;
+  memoryFile;
+  getTodayFile() {
+    return join2(this.memoryDir, `${todayDate()}.md`);
+  }
+  readToday() {
+    const todayFile = this.getTodayFile();
+    if (existsSync3(todayFile)) {
+      return readFileSync2(todayFile, "utf-8");
+    }
+    return "";
+  }
+  appendToday(content) {
+    const todayFile = this.getTodayFile();
+    let nextContent = content;
+    if (existsSync3(todayFile)) {
+      const existing = readFileSync2(todayFile, "utf-8");
+      nextContent = `${existing}
+${content}`;
+    } else {
+      const header = `# ${todayDate()}
+
+`;
+      nextContent = header + content;
+    }
+    writeFileSync2(todayFile, nextContent, "utf-8");
+  }
+  readLongTerm() {
+    if (existsSync3(this.memoryFile)) {
+      return readFileSync2(this.memoryFile, "utf-8");
+    }
+    return "";
+  }
+  writeLongTerm(content) {
+    writeFileSync2(this.memoryFile, content, "utf-8");
+  }
+  getRecentMemories(days = 7) {
+    const memories = [];
+    const today = /* @__PURE__ */ new Date();
+    for (let i = 0; i < days; i += 1) {
+      const date = new Date(today);
+      date.setDate(today.getDate() - i);
+      const dateStr = date.toISOString().slice(0, 10);
+      const path = join2(this.memoryDir, `${dateStr}.md`);
+      if (existsSync3(path)) {
+        memories.push(readFileSync2(path, "utf-8"));
+      }
+    }
+    return memories.length ? memories.join("\n\n---\n\n") : "";
+  }
+  listMemoryFiles() {
+    if (!existsSync3(this.memoryDir)) {
+      return [];
+    }
+    return readdirSync2(this.memoryDir).filter((name) => /^\d{4}-\d{2}-\d{2}\.md$/.test(name)).sort().reverse().map((name) => join2(this.memoryDir, name));
+  }
+  getMemoryContext() {
+    const parts = [];
+    const longTerm = this.readLongTerm();
+    if (longTerm) {
+      parts.push(`## Long-term Memory
+${longTerm}`);
+    }
+    const today = this.readToday();
+    if (today) {
+      parts.push(`## Today's Notes
+${today}`);
+    }
+    return parts.length ? parts.join("\n\n") : "";
+  }
+};
+
+// src/agent/skills.ts
+import { readFileSync as readFileSync3, existsSync as existsSync4, readdirSync as readdirSync3 } from "fs";
+import { join as join3 } from "path";
+import { fileURLToPath } from "url";
+var BUILTIN_SKILLS_DIR = join3(fileURLToPath(new URL(".", import.meta.url)), "skills");
+var SkillsLoader = class {
+  constructor(workspace, builtinSkillsDir) {
+    this.workspace = workspace;
+    this.workspaceSkills = join3(workspace, "skills");
+    this.builtinSkills = builtinSkillsDir ?? BUILTIN_SKILLS_DIR;
+  }
+  workspaceSkills;
+  builtinSkills;
+  listSkills(filterUnavailable = true) {
+    const skills = [];
+    if (existsSync4(this.workspaceSkills)) {
+      for (const entry of readdirSync3(this.workspaceSkills, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+          continue;
+        }
+        const skillFile = join3(this.workspaceSkills, entry.name, "SKILL.md");
+        if (existsSync4(skillFile)) {
+          skills.push({ name: entry.name, path: skillFile, source: "workspace" });
+        }
+      }
+    }
+    if (existsSync4(this.builtinSkills)) {
+      for (const entry of readdirSync3(this.builtinSkills, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+          continue;
+        }
+        const skillFile = join3(this.builtinSkills, entry.name, "SKILL.md");
+        if (existsSync4(skillFile) && !skills.some((s) => s.name === entry.name)) {
+          skills.push({ name: entry.name, path: skillFile, source: "builtin" });
+        }
+      }
+    }
+    if (filterUnavailable) {
+      return skills.filter((skill) => this.checkRequirements(this.getSkillMeta(skill.name)));
+    }
+    return skills;
+  }
+  loadSkill(name) {
+    const workspaceSkill = join3(this.workspaceSkills, name, "SKILL.md");
+    if (existsSync4(workspaceSkill)) {
+      return readFileSync3(workspaceSkill, "utf-8");
+    }
+    const builtinSkill = join3(this.builtinSkills, name, "SKILL.md");
+    if (existsSync4(builtinSkill)) {
+      return readFileSync3(builtinSkill, "utf-8");
+    }
+    return null;
+  }
+  loadSkillsForContext(skillNames) {
+    const parts = [];
+    for (const name of skillNames) {
+      const content = this.loadSkill(name);
+      if (content) {
+        parts.push(`### Skill: ${name}
+
+${this.stripFrontmatter(content)}`);
+      }
+    }
+    return parts.length ? parts.join("\n\n---\n\n") : "";
+  }
+  buildSkillsSummary() {
+    const allSkills = this.listSkills(false);
+    if (!allSkills.length) {
+      return "";
+    }
+    const escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    const lines = ["<skills>"];
+    for (const skill of allSkills) {
+      const desc = escapeXml(this.getSkillDescription(skill.name));
+      const meta = this.getSkillMeta(skill.name);
+      const available = this.checkRequirements(meta);
+      lines.push(`  <skill available="${available}">`);
+      lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+      lines.push(`    <description>${desc}</description>`);
+      lines.push(`    <location>${skill.path}</location>`);
+      if (!available) {
+        const missing = this.getMissingRequirements(meta);
+        if (missing) {
+          lines.push(`    <requires>${escapeXml(missing)}</requires>`);
+        }
+      }
+      lines.push("  </skill>");
+    }
+    lines.push("</skills>");
+    return lines.join("\n");
+  }
+  getAlwaysSkills() {
+    const result = [];
+    for (const skill of this.listSkills(true)) {
+      const meta = this.getSkillMetadata(skill.name) ?? {};
+      const parsed = this.parseSkillMetadata(meta.metadata ?? "");
+      if (parsed.always || meta.always === "true") {
+        result.push(skill.name);
+      }
+    }
+    return result;
+  }
+  getSkillMetadata(name) {
+    const content = this.loadSkill(name);
+    if (!content || !content.startsWith("---")) {
+      return null;
+    }
+    const match = content.match(/^---\n(.*?)\n---/s);
+    if (!match) {
+      return null;
+    }
+    const metadata = {};
+    for (const line of match[1].split("\n")) {
+      const [key, ...rest] = line.split(":");
+      if (!key || rest.length === 0) {
+        continue;
+      }
+      metadata[key.trim()] = rest.join(":").trim().replace(/^['"]|['"]$/g, "");
+    }
+    return metadata;
+  }
+  getSkillDescription(name) {
+    const meta = this.getSkillMetadata(name);
+    if (meta?.description) {
+      return meta.description;
+    }
+    return name;
+  }
+  stripFrontmatter(content) {
+    if (content.startsWith("---")) {
+      const match = content.match(/^---\n.*?\n---\n/s);
+      if (match) {
+        return content.slice(match[0].length).trim();
+      }
+    }
+    return content;
+  }
+  parseSkillMetadata(raw) {
+    try {
+      const data = JSON.parse(raw);
+      if (typeof data !== "object" || !data) {
+        return {};
+      }
+      const meta = data[SKILL_METADATA_KEY];
+      if (typeof meta === "object" && meta) {
+        return meta;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  getSkillMeta(name) {
+    const meta = this.getSkillMetadata(name) ?? {};
+    return this.parseSkillMetadata(meta.metadata ?? "");
+  }
+  checkRequirements(skillMeta) {
+    const requires = skillMeta.requires ?? {};
+    if (requires.bins) {
+      for (const bin of requires.bins) {
+        if (!this.which(bin)) {
+          return false;
+        }
+      }
+    }
+    if (requires.env) {
+      for (const env of requires.env) {
+        if (!process.env[env]) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  getMissingRequirements(skillMeta) {
+    const missing = [];
+    const requires = skillMeta.requires ?? {};
+    if (requires.bins) {
+      for (const bin of requires.bins) {
+        if (!this.which(bin)) {
+          missing.push(`CLI: ${bin}`);
+        }
+      }
+    }
+    if (requires.env) {
+      for (const env of requires.env) {
+        if (!process.env[env]) {
+          missing.push(`ENV: ${env}`);
+        }
+      }
+    }
+    return missing.join(", ");
+  }
+  which(binary) {
+    const paths = (process.env.PATH ?? "").split(":");
+    for (const dir of paths) {
+      const full = join3(dir, binary);
+      if (existsSync4(full)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/agent/context.ts
+var BOOTSTRAP_FILES = ["AGENTS.md", "SOUL.md", "USER.md", "TOOLS.md", "IDENTITY.md"];
+var ContextBuilder = class {
+  constructor(workspace) {
+    this.workspace = workspace;
+    this.memory = new MemoryStore(workspace);
+    this.skills = new SkillsLoader(workspace, join4(fileURLToPath2(new URL("..", import.meta.url)), "skills"));
+  }
+  memory;
+  skills;
+  buildSystemPrompt(skillNames) {
+    const parts = [];
+    parts.push(this.getIdentity());
+    const bootstrap = this.loadBootstrapFiles();
+    if (bootstrap) {
+      parts.push(bootstrap);
+    }
+    const memory = this.memory.getMemoryContext();
+    if (memory) {
+      parts.push(`# Memory
+
+${memory}`);
+    }
+    const alwaysSkills = this.skills.getAlwaysSkills();
+    if (alwaysSkills.length) {
+      const alwaysContent = this.skills.loadSkillsForContext(alwaysSkills);
+      if (alwaysContent) {
+        parts.push(`# Active Skills
+
+${alwaysContent}`);
+      }
+    }
+    if (skillNames && skillNames.length) {
+      const requestedContent = this.skills.loadSkillsForContext(skillNames);
+      if (requestedContent) {
+        parts.push(`# Requested Skills
+
+${requestedContent}`);
+      }
+    }
+    const skillsSummary = this.skills.buildSkillsSummary();
+    if (skillsSummary) {
+      parts.push(`# Skills
+
+The following skills extend your capabilities. To use a skill, read its SKILL.md file using the read_file tool.
+Skills with available="false" need dependencies installed first - you can try installing them with apt/brew.
+
+${skillsSummary}`);
+    }
+    return parts.join("\n\n---\n\n");
+  }
+  buildMessages(params) {
+    const messages = [];
+    let systemPrompt = this.buildSystemPrompt(params.skillNames);
+    if (params.channel && params.chatId) {
+      systemPrompt += `
+
+## Current Session
+Channel: ${params.channel}
+Chat ID: ${params.chatId}`;
+    }
+    messages.push({ role: "system", content: systemPrompt });
+    messages.push(...params.history);
+    const userContent = this.buildUserContent(params.currentMessage, params.media ?? []);
+    messages.push({ role: "user", content: userContent });
+    return messages;
+  }
+  addToolResult(messages, toolCallId, toolName, result) {
+    messages.push({
+      role: "tool",
+      tool_call_id: toolCallId,
+      name: toolName,
+      content: result
+    });
+    return messages;
+  }
+  addAssistantMessage(messages, content, toolCalls, reasoningContent) {
+    const msg = { role: "assistant", content: content ?? "" };
+    if (toolCalls?.length) {
+      msg.tool_calls = toolCalls;
+    }
+    if (reasoningContent) {
+      msg.reasoning_content = reasoningContent;
+    }
+    messages.push(msg);
+    return messages;
+  }
+  getIdentity() {
+    const now = (/* @__PURE__ */ new Date()).toLocaleString();
+    return `# ${APP_NAME} \u{1F916}
+
+You are ${APP_NAME}, a helpful AI assistant. You have access to tools that allow you to:
+- Read, write, and edit files
+- Execute shell commands
+- Search the web and fetch web pages
+- Send messages to users on chat channels
+- Spawn subagents for complex background tasks
+
+## Current Time
+${now}
+
+## Runtime
+${process.platform} ${process.arch}, Node ${process.version}
+
+## Workspace
+Your workspace is at: ${this.workspace}
+- Memory files: ${this.workspace}/memory/MEMORY.md
+- Daily notes: ${this.workspace}/memory/YYYY-MM-DD.md
+- Custom skills: ${this.workspace}/skills/{skill-name}/SKILL.md
+
+IMPORTANT: When responding to direct questions or conversations, reply directly with your text response.
+Only use the 'message' tool when you need to send a message to a specific chat channel (like WhatsApp).
+For normal conversation, just respond with text - do not call the message tool.
+
+Always be helpful, accurate, and concise. When using tools, explain what you're doing.
+When remembering something, write to ${this.workspace}/memory/MEMORY.md`;
+  }
+  loadBootstrapFiles() {
+    const parts = [];
+    for (const filename of BOOTSTRAP_FILES) {
+      const filePath = join4(this.workspace, filename);
+      if (existsSync5(filePath)) {
+        const content = readFileSync4(filePath, "utf-8");
+        parts.push(`## ${filename}
+
+${content}`);
+      }
+    }
+    return parts.join("\n\n");
+  }
+  buildUserContent(text, media) {
+    if (!media.length) {
+      return text;
+    }
+    const images = [];
+    for (const path of media) {
+      const mime = guessImageMime(path);
+      if (!mime) {
+        continue;
+      }
+      try {
+        const b64 = readFileSync4(path).toString("base64");
+        images.push({ type: "image_url", image_url: { url: `data:${mime};base64,${b64}` } });
+      } catch {
+        continue;
+      }
+    }
+    if (!images.length) {
+      return text;
+    }
+    return [...images, { type: "text", text }];
+  }
+};
+function guessImageMime(path) {
+  const ext = extname(path).toLowerCase();
+  if (ext === ".png") return "image/png";
+  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
+  if (ext === ".gif") return "image/gif";
+  if (ext === ".webp") return "image/webp";
+  return null;
+}
+
+// src/agent/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  unregister(name) {
+    this.tools.delete(name);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  getDefinitions() {
+    return Array.from(this.tools.values()).map((tool) => tool.toSchema());
+  }
+  async execute(name, params) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return `Error: Tool '${name}' not found`;
+    }
+    try {
+      const errors = tool.validateParams(params);
+      if (errors.length) {
+        return `Error: Invalid parameters for tool '${name}': ${errors.join("; ")}`;
+      }
+      return await tool.execute(params);
+    } catch (err) {
+      return `Error executing ${name}: ${String(err)}`;
+    }
+  }
+  get toolNames() {
+    return Array.from(this.tools.keys());
+  }
+};
+
+// src/agent/tools/filesystem.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync6, readdirSync as readdirSync4, statSync } from "fs";
+import { resolve as resolve2, dirname } from "path";
+
+// src/agent/tools/base.ts
+var Tool = class _Tool {
+  static typeMap = {
+    string: (v) => typeof v === "string",
+    integer: (v) => typeof v === "number" && Number.isInteger(v),
+    number: (v) => typeof v === "number",
+    boolean: (v) => typeof v === "boolean",
+    array: Array.isArray,
+    object: (v) => typeof v === "object" && v !== null && !Array.isArray(v)
+  };
+  validateParams(params) {
+    const schema = this.parameters;
+    if (schema?.type !== "object") {
+      throw new Error(`Schema must be object type, got ${schema?.type ?? "unknown"}`);
+    }
+    return this.validateValue(params, schema, "");
+  }
+  toSchema() {
+    return {
+      type: "function",
+      function: {
+        name: this.name,
+        description: this.description,
+        parameters: this.parameters
+      }
+    };
+  }
+  validateValue(value, schema, path) {
+    const label = path || "parameter";
+    if (schema.type in _Tool.typeMap && !_Tool.typeMap[schema.type](value)) {
+      return [`${label} should be ${schema.type}`];
+    }
+    const errors = [];
+    const typedValue = value;
+    if (schema.enum && !schema.enum.includes(value)) {
+      errors.push(`${label} must be one of ${JSON.stringify(schema.enum)}`);
+    }
+    if (typeof value === "number") {
+      if (schema.minimum !== void 0 && value < schema.minimum) {
+        errors.push(`${label} must be >= ${schema.minimum}`);
+      }
+      if (schema.maximum !== void 0 && value > schema.maximum) {
+        errors.push(`${label} must be <= ${schema.maximum}`);
+      }
+    }
+    if (typeof value === "string") {
+      if (schema.minLength !== void 0 && value.length < schema.minLength) {
+        errors.push(`${label} must be at least ${schema.minLength} chars`);
+      }
+      if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+        errors.push(`${label} must be at most ${schema.maxLength} chars`);
+      }
+    }
+    if (schema.type === "object") {
+      for (const key of schema.required ?? []) {
+        if (!(key in typedValue)) {
+          errors.push(`missing required ${path ? `${path}.${key}` : key}`);
+        }
+      }
+      const properties = schema.properties ?? {};
+      for (const [key, val] of Object.entries(typedValue)) {
+        const propSchema = properties[key];
+        if (propSchema) {
+          errors.push(...this.validateValue(val, propSchema, path ? `${path}.${key}` : key));
+        }
+      }
+    }
+    if (schema.type === "array" && schema.items) {
+      value.forEach((item, index) => {
+        errors.push(...this.validateValue(item, schema.items, `${label}[${index}]`));
+      });
+    }
+    return errors;
+  }
+};
+
+// src/agent/tools/filesystem.ts
+function resolvePath(path, allowedDir) {
+  const resolved = resolve2(path);
+  if (allowedDir) {
+    const allowed = resolve2(allowedDir);
+    if (!resolved.startsWith(allowed)) {
+      throw new Error("Access denied: path outside allowed directory");
+    }
+  }
+  return resolved;
+}
+var ReadFileTool = class extends Tool {
+  constructor(allowedDir) {
+    super();
+    this.allowedDir = allowedDir;
+  }
+  get name() {
+    return "read_file";
+  }
+  get description() {
+    return "Read a file from disk";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the file" }
+      },
+      required: ["path"]
+    };
+  }
+  async execute(params) {
+    const path = resolvePath(String(params.path), this.allowedDir);
+    if (!existsSync6(path)) {
+      return `Error: File not found: ${path}`;
+    }
+    return readFileSync5(path, "utf-8");
+  }
+};
+var WriteFileTool = class extends Tool {
+  constructor(allowedDir) {
+    super();
+    this.allowedDir = allowedDir;
+  }
+  get name() {
+    return "write_file";
+  }
+  get description() {
+    return "Write content to a file";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the file" },
+        content: { type: "string", description: "Content to write" }
+      },
+      required: ["path", "content"]
+    };
+  }
+  async execute(params) {
+    const path = resolvePath(String(params.path), this.allowedDir);
+    const content = String(params.content ?? "");
+    const dir = dirname(path);
+    if (!existsSync6(dir)) {
+      throw new Error("Directory does not exist");
+    }
+    writeFileSync3(path, content, "utf-8");
+    return `Wrote ${content.length} bytes to ${path}`;
+  }
+};
+var EditFileTool = class extends Tool {
+  constructor(allowedDir) {
+    super();
+    this.allowedDir = allowedDir;
+  }
+  get name() {
+    return "edit_file";
+  }
+  get description() {
+    return "Edit a file by replacing a string";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the file" },
+        oldText: { type: "string", description: "Text to replace" },
+        newText: { type: "string", description: "Replacement text" }
+      },
+      required: ["path", "oldText", "newText"]
+    };
+  }
+  async execute(params) {
+    const path = resolvePath(String(params.path), this.allowedDir);
+    if (!existsSync6(path)) {
+      return `Error: File not found: ${path}`;
+    }
+    const oldText = String(params.oldText ?? "");
+    const newText = String(params.newText ?? "");
+    const content = readFileSync5(path, "utf-8");
+    if (!content.includes(oldText)) {
+      return "Error: Text to replace not found";
+    }
+    const updated = content.replace(oldText, newText);
+    writeFileSync3(path, updated, "utf-8");
+    return `Edited ${path}`;
+  }
+};
+var ListDirTool = class extends Tool {
+  constructor(allowedDir) {
+    super();
+    this.allowedDir = allowedDir;
+  }
+  get name() {
+    return "list_dir";
+  }
+  get description() {
+    return "List files in a directory";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the directory" }
+      },
+      required: ["path"]
+    };
+  }
+  async execute(params) {
+    const path = resolvePath(String(params.path), this.allowedDir);
+    if (!existsSync6(path)) {
+      return `Error: Directory not found: ${path}`;
+    }
+    const entries = readdirSync4(path, { withFileTypes: true });
+    const lines = entries.map((entry) => {
+      const full = resolve2(path, entry.name);
+      const stats = statSync(full);
+      return `${entry.name}${entry.isDirectory() ? "/" : ""} (${stats.size} bytes)`;
+    });
+    return lines.join("\n") || "(empty)";
+  }
+};
+
+// src/agent/tools/shell.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { resolve as resolve3 } from "path";
+var execAsync = promisify(exec);
+var ExecTool = class extends Tool {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.denyPatterns = (options.denyPatterns ?? [
+      "\\brm\\s+-[rf]{1,2}\\b",
+      "\\bdel\\s+/[fq]\\b",
+      "\\brmdir\\s+/s\\b",
+      "\\b(format|mkfs|diskpart)\\b",
+      "\\bdd\\s+if=",
+      ">\\s*/dev/sd",
+      "\\b(shutdown|reboot|poweroff)\\b",
+      ":\\(\\)\\s*\\{.*\\};\\s*:"
+    ]).map((pattern) => new RegExp(pattern, "i"));
+    this.allowPatterns = (options.allowPatterns ?? []).map((pattern) => new RegExp(pattern, "i"));
+  }
+  denyPatterns;
+  allowPatterns;
+  get name() {
+    return "exec";
+  }
+  get description() {
+    return "Execute a shell command and return its output. Use with caution.";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The shell command to execute" },
+        workingDir: { type: "string", description: "Optional working directory for the command" }
+      },
+      required: ["command"]
+    };
+  }
+  async execute(params) {
+    const command = String(params.command ?? "");
+    const cwd = String(params.workingDir ?? this.options.workingDir ?? process.cwd());
+    const guardError = this.guardCommand(command, cwd);
+    if (guardError) {
+      return guardError;
+    }
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd,
+        timeout: (this.options.timeout ?? 60) * 1e3,
+        maxBuffer: 1e7
+      });
+      const outputParts = [];
+      if (stdout) {
+        outputParts.push(stdout);
+      }
+      if (stderr?.trim()) {
+        outputParts.push(`STDERR:
+${stderr}`);
+      }
+      const result = outputParts.length ? outputParts.join("\n") : "(no output)";
+      return truncateOutput(result);
+    } catch (err) {
+      return `Error executing command: ${String(err)}`;
+    }
+  }
+  guardCommand(command, cwd) {
+    const normalized = command.trim().toLowerCase();
+    for (const pattern of this.denyPatterns) {
+      if (pattern.test(normalized)) {
+        return "Error: Command blocked by safety guard (dangerous pattern detected)";
+      }
+    }
+    if (this.allowPatterns.length && !this.allowPatterns.some((pattern) => pattern.test(normalized))) {
+      return "Error: Command blocked by safety guard (not in allowlist)";
+    }
+    if (this.options.restrictToWorkspace) {
+      if (command.includes("../") || command.includes("..\\")) {
+        return "Error: Command blocked by safety guard (path traversal detected)";
+      }
+      const cwdPath = resolve3(cwd);
+      const matches = [...command.matchAll(/(?:^|[\s|>])([^\s"'>]+)/g)].map((match) => match[1]);
+      for (const raw of matches) {
+        if (raw.startsWith("/") || /^[A-Za-z]:\\/.test(raw)) {
+          const resolved = resolve3(raw);
+          if (!resolved.startsWith(cwdPath)) {
+            return "Error: Command blocked by safety guard (path outside working dir)";
+          }
+        }
+      }
+    }
+    return null;
+  }
+};
+function truncateOutput(result, maxLen = 1e4) {
+  if (result.length <= maxLen) {
+    return result;
+  }
+  return `${result.slice(0, maxLen)}
+... (truncated, ${result.length - maxLen} more chars)`;
+}
+
+// src/agent/tools/web.ts
+import { fetch } from "undici";
+var WebSearchTool = class extends Tool {
+  constructor(apiKey, maxResults = 5) {
+    super();
+    this.apiKey = apiKey;
+    this.maxResults = maxResults;
+  }
+  get name() {
+    return "web_search";
+  }
+  get description() {
+    return "Search the web using Brave Search API";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" },
+        maxResults: { type: "integer", description: "Max results" }
+      },
+      required: ["query"]
+    };
+  }
+  async execute(params) {
+    if (!this.apiKey) {
+      return "Error: Brave Search API key not configured";
+    }
+    const query = String(params.query ?? "");
+    const maxResults = Number(params.maxResults ?? this.maxResults);
+    const url = new URL("https://api.search.brave.com/res/v1/web/search");
+    url.searchParams.set("q", query);
+    url.searchParams.set("count", String(maxResults));
+    const response = await fetch(url.toString(), {
+      headers: {
+        "Accept": "application/json",
+        "X-Subscription-Token": this.apiKey
+      }
+    });
+    if (!response.ok) {
+      return `Error: Brave Search request failed (${response.status})`;
+    }
+    const data = await response.json();
+    const results = data.web?.results ?? [];
+    if (!results.length) {
+      return "No results found.";
+    }
+    const lines = results.map((item) => {
+      const title = item.title ?? "";
+      const urlValue = item.url ?? "";
+      const description = item.description ?? "";
+      return `- ${title}
+  ${urlValue}
+  ${description}`;
+    });
+    return lines.join("\n\n");
+  }
+};
+var WebFetchTool = class extends Tool {
+  get name() {
+    return "web_fetch";
+  }
+  get description() {
+    return "Fetch the contents of a web page";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "URL to fetch" }
+      },
+      required: ["url"]
+    };
+  }
+  async execute(params) {
+    const url = String(params.url ?? "");
+    const response = await fetch(url, { headers: { "User-Agent": APP_USER_AGENT } });
+    if (!response.ok) {
+      return `Error: Fetch failed (${response.status})`;
+    }
+    const text = await response.text();
+    return text.slice(0, 12e3);
+  }
+};
+
+// src/agent/tools/message.ts
+var MessageTool = class extends Tool {
+  constructor(sendCallback) {
+    super();
+    this.sendCallback = sendCallback;
+  }
+  channel = "cli";
+  chatId = "direct";
+  get name() {
+    return "message";
+  }
+  get description() {
+    return "Send a message to a chat channel";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "Message to send" },
+        channel: { type: "string", description: "Channel name" },
+        chatId: { type: "string", description: "Chat ID" }
+      },
+      required: ["content"]
+    };
+  }
+  setContext(channel, chatId) {
+    this.channel = channel;
+    this.chatId = chatId;
+  }
+  async execute(params) {
+    const content = String(params.content ?? "");
+    const channel = String(params.channel ?? this.channel);
+    const chatId = String(params.chatId ?? this.chatId);
+    await this.sendCallback({
+      channel,
+      chatId,
+      content,
+      media: [],
+      metadata: {}
+    });
+    return `Message sent to ${channel}:${chatId}`;
+  }
+};
+
+// src/agent/tools/spawn.ts
+var SpawnTool = class extends Tool {
+  constructor(manager) {
+    super();
+    this.manager = manager;
+  }
+  channel = "cli";
+  chatId = "direct";
+  get name() {
+    return "spawn";
+  }
+  get description() {
+    return "Spawn a background subagent to handle a task";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        task: { type: "string", description: "Task for the subagent" },
+        label: { type: "string", description: "Optional label" }
+      },
+      required: ["task"]
+    };
+  }
+  setContext(channel, chatId) {
+    this.channel = channel;
+    this.chatId = chatId;
+  }
+  async execute(params) {
+    const task = String(params.task ?? "");
+    const label = params.label ? String(params.label) : void 0;
+    return this.manager.spawn({
+      task,
+      label,
+      originChannel: this.channel,
+      originChatId: this.chatId
+    });
+  }
+};
+
+// src/agent/tools/cron.ts
+var CronTool = class extends Tool {
+  constructor(cronService) {
+    super();
+    this.cronService = cronService;
+  }
+  channel = "cli";
+  chatId = "direct";
+  get name() {
+    return "cron";
+  }
+  get description() {
+    return "Schedule a task to run later";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        message: { type: "string" },
+        every: { type: "integer" },
+        cron: { type: "string" },
+        at: { type: "string" },
+        deliver: { type: "boolean" }
+      },
+      required: ["name", "message"]
+    };
+  }
+  setContext(channel, chatId) {
+    this.channel = channel;
+    this.chatId = chatId;
+  }
+  async execute(params) {
+    const name = String(params.name ?? "");
+    const message = String(params.message ?? "");
+    const every = params.every ? Number(params.every) : void 0;
+    const cron = params.cron ? String(params.cron) : void 0;
+    const at = params.at ? String(params.at) : void 0;
+    const deliver = Boolean(params.deliver ?? false);
+    let schedule = null;
+    if (every) {
+      schedule = { kind: "every", everyMs: every * 1e3 };
+    } else if (cron) {
+      schedule = { kind: "cron", expr: cron };
+    } else if (at) {
+      const atMs = Date.parse(at);
+      schedule = { kind: "at", atMs };
+    }
+    if (!schedule) {
+      return "Error: Must specify --every, --cron, or --at";
+    }
+    const job = this.cronService.addJob({
+      name,
+      schedule,
+      message,
+      deliver,
+      channel: this.channel,
+      to: this.chatId
+    });
+    return `Scheduled job '${job.name}' (${job.id})`;
+  }
+};
+
+// src/agent/subagent.ts
+import { randomUUID } from "crypto";
+var SubagentManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  runningTasks = /* @__PURE__ */ new Map();
+  async spawn(params) {
+    const taskId = randomUUID().slice(0, 8);
+    const displayLabel = params.label ?? `${params.task.slice(0, 30)}${params.task.length > 30 ? "..." : ""}`;
+    const origin = {
+      channel: params.originChannel ?? "cli",
+      chatId: params.originChatId ?? "direct"
+    };
+    const background = this.runSubagent({
+      taskId,
+      task: params.task,
+      label: displayLabel,
+      origin
+    });
+    this.runningTasks.set(taskId, background);
+    background.finally(() => this.runningTasks.delete(taskId));
+    return `Subagent [${displayLabel}] started (id: ${taskId}). I'll notify you when it completes.`;
+  }
+  async runSubagent(params) {
+    try {
+      const tools = new ToolRegistry();
+      const allowedDir = this.options.restrictToWorkspace ? this.options.workspace : void 0;
+      tools.register(new ReadFileTool(allowedDir));
+      tools.register(new WriteFileTool(allowedDir));
+      tools.register(new ListDirTool(allowedDir));
+      tools.register(
+        new ExecTool({
+          workingDir: this.options.workspace,
+          timeout: this.options.execConfig?.timeout ?? 60,
+          restrictToWorkspace: this.options.restrictToWorkspace ?? false
+        })
+      );
+      tools.register(new WebSearchTool(this.options.braveApiKey ?? void 0));
+      tools.register(new WebFetchTool());
+      const systemPrompt = this.buildSubagentPrompt(params.task);
+      const messages = [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: params.task }
+      ];
+      let iteration = 0;
+      let finalResult = null;
+      while (iteration < 15) {
+        iteration += 1;
+        const response = await this.options.provider.chat({
+          messages,
+          tools: tools.getDefinitions(),
+          model: this.options.model
+        });
+        if (response.toolCalls.length) {
+          const toolCalls = response.toolCalls.map((call) => ({
+            id: call.id,
+            type: "function",
+            function: {
+              name: call.name,
+              arguments: JSON.stringify(call.arguments)
+            }
+          }));
+          messages.push({ role: "assistant", content: response.content ?? "", tool_calls: toolCalls });
+          for (const call of response.toolCalls) {
+            const result = await tools.execute(call.name, call.arguments);
+            messages.push({ role: "tool", tool_call_id: call.id, name: call.name, content: result });
+          }
+        } else {
+          finalResult = response.content ?? "";
+          break;
+        }
+      }
+      if (!finalResult) {
+        finalResult = "Task completed but no final response was generated.";
+      }
+      await this.announceResult({
+        label: params.label,
+        task: params.task,
+        result: finalResult,
+        origin: params.origin,
+        status: "ok"
+      });
+    } catch (err) {
+      await this.announceResult({
+        label: params.label,
+        task: params.task,
+        result: `Error: ${String(err)}`,
+        origin: params.origin,
+        status: "error"
+      });
+    }
+  }
+  async announceResult(params) {
+    const statusText = params.status === "ok" ? "completed successfully" : "failed";
+    const announceContent = `[Subagent '${params.label}' ${statusText}]
+
+Task: ${params.task}
+
+Result:
+${params.result}
+
+Summarize this naturally for the user. Keep it brief (1-2 sentences). Do not mention technical details like "subagent" or task IDs.`;
+    const msg = {
+      channel: "system",
+      senderId: "subagent",
+      chatId: `${params.origin.channel}:${params.origin.chatId}`,
+      content: announceContent,
+      timestamp: /* @__PURE__ */ new Date(),
+      media: [],
+      metadata: {}
+    };
+    await this.options.bus.publishInbound(msg);
+  }
+  buildSubagentPrompt(task) {
+    return `# Subagent
+
+You are a subagent spawned by the main agent to complete a specific task.
+
+## Your Task
+${task}
+
+## Rules
+1. Stay focused - complete only the assigned task, nothing else
+2. Your final response will be reported back to the main agent
+3. Do not initiate conversations or take on side tasks
+4. Be concise but informative in your findings
+
+## What You Can Do
+- Read and write files in the workspace
+- Execute shell commands
+- Search the web and fetch web pages
+- Complete the task thoroughly
+
+## What You Cannot Do
+- Send messages directly to users (no message tool available)
+- Spawn other subagents
+- Access the main agent's conversation history
+
+## Workspace
+Your workspace is at: ${this.options.workspace}
+
+When you have completed the task, provide a clear summary of your findings or actions.`;
+  }
+  getRunningCount() {
+    return this.runningTasks.size;
+  }
+};
+
+// src/agent/loop.ts
+var AgentLoop = class {
+  constructor(options) {
+    this.options = options;
+    this.context = new ContextBuilder(options.workspace);
+    this.sessions = options.sessionManager ?? new SessionManager(options.workspace);
+    this.tools = new ToolRegistry();
+    this.subagents = new SubagentManager({
+      provider: options.provider,
+      workspace: options.workspace,
+      bus: options.bus,
+      model: options.model ?? options.provider.getDefaultModel(),
+      braveApiKey: options.braveApiKey ?? void 0,
+      execConfig: options.execConfig ?? { timeout: 60 },
+      restrictToWorkspace: options.restrictToWorkspace ?? false
+    });
+    this.registerDefaultTools();
+  }
+  context;
+  sessions;
+  tools;
+  subagents;
+  running = false;
+  registerDefaultTools() {
+    const allowedDir = this.options.restrictToWorkspace ? this.options.workspace : void 0;
+    this.tools.register(new ReadFileTool(allowedDir));
+    this.tools.register(new WriteFileTool(allowedDir));
+    this.tools.register(new EditFileTool(allowedDir));
+    this.tools.register(new ListDirTool(allowedDir));
+    this.tools.register(
+      new ExecTool({
+        workingDir: this.options.workspace,
+        timeout: this.options.execConfig?.timeout ?? 60,
+        restrictToWorkspace: this.options.restrictToWorkspace ?? false
+      })
+    );
+    this.tools.register(new WebSearchTool(this.options.braveApiKey ?? void 0));
+    this.tools.register(new WebFetchTool());
+    const messageTool = new MessageTool((msg) => this.options.bus.publishOutbound(msg));
+    this.tools.register(messageTool);
+    const spawnTool = new SpawnTool(this.subagents);
+    this.tools.register(spawnTool);
+    if (this.options.cronService) {
+      const cronTool = new CronTool(this.options.cronService);
+      this.tools.register(cronTool);
+    }
+  }
+  async run() {
+    this.running = true;
+    while (this.running) {
+      const msg = await this.options.bus.consumeInbound();
+      try {
+        const response = await this.processMessage(msg);
+        if (response) {
+          await this.options.bus.publishOutbound(response);
+        }
+      } catch (err) {
+        await this.options.bus.publishOutbound({
+          channel: msg.channel,
+          chatId: msg.chatId,
+          content: `Sorry, I encountered an error: ${String(err)}`,
+          media: [],
+          metadata: {}
+        });
+      }
+    }
+  }
+  stop() {
+    this.running = false;
+  }
+  async processDirect(params) {
+    const msg = {
+      channel: params.channel ?? "cli",
+      senderId: "user",
+      chatId: params.chatId ?? "direct",
+      content: params.content,
+      timestamp: /* @__PURE__ */ new Date(),
+      media: [],
+      metadata: {}
+    };
+    const response = await this.processMessage(msg, params.sessionKey);
+    return response?.content ?? "";
+  }
+  async processMessage(msg, sessionKeyOverride) {
+    if (msg.channel === "system") {
+      return this.processSystemMessage(msg);
+    }
+    const sessionKey = sessionKeyOverride ?? `${msg.channel}:${msg.chatId}`;
+    const session = this.sessions.getOrCreate(sessionKey);
+    const messageTool = this.tools.get("message");
+    if (messageTool instanceof MessageTool) {
+      messageTool.setContext(msg.channel, msg.chatId);
+    }
+    const spawnTool = this.tools.get("spawn");
+    if (spawnTool instanceof SpawnTool) {
+      spawnTool.setContext(msg.channel, msg.chatId);
+    }
+    const cronTool = this.tools.get("cron");
+    if (cronTool instanceof CronTool) {
+      cronTool.setContext(msg.channel, msg.chatId);
+    }
+    const messages = this.context.buildMessages({
+      history: this.sessions.getHistory(session),
+      currentMessage: msg.content,
+      media: msg.media,
+      channel: msg.channel,
+      chatId: msg.chatId
+    });
+    let iteration = 0;
+    let finalContent = null;
+    const maxIterations = this.options.maxIterations ?? 20;
+    while (iteration < maxIterations) {
+      iteration += 1;
+      const response = await this.options.provider.chat({
+        messages,
+        tools: this.tools.getDefinitions(),
+        model: this.options.model ?? void 0
+      });
+      if (response.toolCalls.length) {
+        const toolCallDicts = response.toolCalls.map((call) => ({
+          id: call.id,
+          type: "function",
+          function: {
+            name: call.name,
+            arguments: JSON.stringify(call.arguments)
+          }
+        }));
+        this.context.addAssistantMessage(messages, response.content, toolCallDicts, response.reasoningContent ?? null);
+        for (const call of response.toolCalls) {
+          const result = await this.tools.execute(call.name, call.arguments);
+          this.context.addToolResult(messages, call.id, call.name, result);
+        }
+      } else {
+        finalContent = response.content;
+        break;
+      }
+    }
+    if (!finalContent) {
+      finalContent = "I've completed processing but have no response to give.";
+    }
+    this.sessions.addMessage(session, "user", msg.content);
+    this.sessions.addMessage(session, "assistant", finalContent);
+    this.sessions.save(session);
+    return {
+      channel: msg.channel,
+      chatId: msg.chatId,
+      content: finalContent,
+      media: [],
+      metadata: msg.metadata ?? {}
+    };
+  }
+  async processSystemMessage(msg) {
+    const [originChannel, originChatId] = msg.chatId.includes(":") ? msg.chatId.split(":", 2) : ["cli", msg.chatId];
+    const sessionKey = `${originChannel}:${originChatId}`;
+    const session = this.sessions.getOrCreate(sessionKey);
+    const messageTool = this.tools.get("message");
+    if (messageTool instanceof MessageTool) {
+      messageTool.setContext(originChannel, originChatId);
+    }
+    const spawnTool = this.tools.get("spawn");
+    if (spawnTool instanceof SpawnTool) {
+      spawnTool.setContext(originChannel, originChatId);
+    }
+    const cronTool = this.tools.get("cron");
+    if (cronTool instanceof CronTool) {
+      cronTool.setContext(originChannel, originChatId);
+    }
+    const messages = this.context.buildMessages({
+      history: this.sessions.getHistory(session),
+      currentMessage: msg.content,
+      channel: originChannel,
+      chatId: originChatId
+    });
+    let iteration = 0;
+    let finalContent = null;
+    const maxIterations = this.options.maxIterations ?? 20;
+    while (iteration < maxIterations) {
+      iteration += 1;
+      const response = await this.options.provider.chat({
+        messages,
+        tools: this.tools.getDefinitions(),
+        model: this.options.model ?? void 0
+      });
+      if (response.toolCalls.length) {
+        const toolCallDicts = response.toolCalls.map((call) => ({
+          id: call.id,
+          type: "function",
+          function: {
+            name: call.name,
+            arguments: JSON.stringify(call.arguments)
+          }
+        }));
+        this.context.addAssistantMessage(messages, response.content, toolCallDicts, response.reasoningContent ?? null);
+        for (const call of response.toolCalls) {
+          const result = await this.tools.execute(call.name, call.arguments);
+          this.context.addToolResult(messages, call.id, call.name, result);
+        }
+      } else {
+        finalContent = response.content;
+        break;
+      }
+    }
+    if (!finalContent) {
+      finalContent = "Background task completed.";
+    }
+    this.sessions.addMessage(session, "user", `[System: ${msg.senderId}] ${msg.content}`);
+    this.sessions.addMessage(session, "assistant", finalContent);
+    this.sessions.save(session);
+    return {
+      channel: originChannel,
+      chatId: originChatId,
+      content: finalContent,
+      media: [],
+      metadata: {}
+    };
+  }
+};
+
+// src/providers/registry.ts
+var PROVIDERS = [
+  {
+    name: "openrouter",
+    keywords: ["openrouter"],
+    envKey: "OPENROUTER_API_KEY",
+    displayName: "OpenRouter",
+    litellmPrefix: "openrouter",
+    skipPrefixes: [],
+    envExtras: [],
+    isGateway: true,
+    isLocal: false,
+    detectByKeyPrefix: "sk-or-",
+    detectByBaseKeyword: "openrouter",
+    defaultApiBase: "https://openrouter.ai/api/v1",
+    stripModelPrefix: false,
+    modelOverrides: []
+  },
+  {
+    name: "aihubmix",
+    keywords: ["aihubmix"],
+    envKey: "OPENAI_API_KEY",
+    displayName: "AiHubMix",
+    litellmPrefix: "openai",
+    skipPrefixes: [],
+    envExtras: [],
+    isGateway: true,
+    isLocal: false,
+    detectByKeyPrefix: "",
+    detectByBaseKeyword: "aihubmix",
+    defaultApiBase: "https://aihubmix.com/v1",
+    stripModelPrefix: true,
+    modelOverrides: []
+  },
+  {
+    name: "anthropic",
+    keywords: ["anthropic", "claude"],
+    envKey: "ANTHROPIC_API_KEY",
+    displayName: "Anthropic",
+    litellmPrefix: "",
+    skipPrefixes: [],
+    envExtras: [],
+    isGateway: false,
+    isLocal: false,
+    detectByKeyPrefix: "",
+    detectByBaseKeyword: "",
+    defaultApiBase: "",
+    stripModelPrefix: false,
+    modelOverrides: []
+  },
+  {
+    name: "openai",
+    keywords: ["openai", "gpt"],
+    envKey: "OPENAI_API_KEY",
+    displayName: "OpenAI",
+    litellmPrefix: "",
+    skipPrefixes: [],
+    envExtras: [],
+    isGateway: false,
+    isLocal: false,
+    detectByKeyPrefix: "",
+    detectByBaseKeyword: "",
+    defaultApiBase: "",
+    stripModelPrefix: false,
+    modelOverrides: []
+  },
+  {
+    name: "deepseek",
+    keywords: ["deepseek"],
+    envKey: "DEEPSEEK_API_KEY",
+    displayName: "DeepSeek",
+    litellmPrefix: "deepseek",
+    skipPrefixes: ["deepseek/"],
+    envExtras: [],
+    isGateway: false,
+    isLocal: false,
+    detectByKeyPrefix: "",
+    detectByBaseKeyword: "",
+    defaultApiBase: "",
+    stripModelPrefix: false,
+    modelOverrides: []
+  },
+  {
+    name: "gemini",
+    keywords: ["gemini"],
+    envKey: "GEMINI_API_KEY",
+    displayName: "Gemini",
+    litellmPrefix: "gemini",
+    skipPrefixes: ["gemini/"],
+    envExtras: [],
+    isGateway: false,
+    isLocal: false,
+    detectByKeyPrefix: "",
+    detectByBaseKeyword: "",
+    defaultApiBase: "",
+    stripModelPrefix: false,
+    modelOverrides: []
+  },
+  {
+    name: "zhipu",
+    keywords: ["zhipu", "glm", "zai"],
+    envKey: "ZAI_API_KEY",
+    displayName: "Zhipu AI",
+    litellmPrefix: "zai",
+    skipPrefixes: ["zhipu/", "zai/", "openrouter/", "hosted_vllm/"],
+    envExtras: [["ZHIPUAI_API_KEY", "{api_key}"]],
+    isGateway: false,
+    isLocal: false,
+    detectByKeyPrefix: "",
+    detectByBaseKeyword: "",
+    defaultApiBase: "",
+    stripModelPrefix: false,
+    modelOverrides: []
+  },
+  {
+    name: "dashscope",
+    keywords: ["qwen", "dashscope"],
+    envKey: "DASHSCOPE_API_KEY",
+    displayName: "DashScope",
+    litellmPrefix: "dashscope",
+    skipPrefixes: ["dashscope/", "openrouter/"],
+    envExtras: [],
+    isGateway: false,
+    isLocal: false,
+    detectByKeyPrefix: "",
+    detectByBaseKeyword: "",
+    defaultApiBase: "",
+    stripModelPrefix: false,
+    modelOverrides: []
+  },
+  {
+    name: "moonshot",
+    keywords: ["moonshot", "kimi"],
+    envKey: "MOONSHOT_API_KEY",
+    displayName: "Moonshot",
+    litellmPrefix: "moonshot",
+    skipPrefixes: ["moonshot/", "openrouter/"],
+    envExtras: [["MOONSHOT_API_BASE", "{api_base}"]],
+    isGateway: false,
+    isLocal: false,
+    detectByKeyPrefix: "",
+    detectByBaseKeyword: "",
+    defaultApiBase: "https://api.moonshot.ai/v1",
+    stripModelPrefix: false,
+    modelOverrides: [["kimi-k2.5", { temperature: 1 }]]
+  },
+  {
+    name: "minimax",
+    keywords: ["minimax"],
+    envKey: "MINIMAX_API_KEY",
+    displayName: "MiniMax",
+    litellmPrefix: "minimax",
+    skipPrefixes: ["minimax/", "openrouter/"],
+    envExtras: [],
+    isGateway: false,
+    isLocal: false,
+    detectByKeyPrefix: "",
+    detectByBaseKeyword: "",
+    defaultApiBase: "https://api.minimax.io/v1",
+    stripModelPrefix: false,
+    modelOverrides: []
+  },
+  {
+    name: "vllm",
+    keywords: ["vllm"],
+    envKey: "HOSTED_VLLM_API_KEY",
+    displayName: "vLLM/Local",
+    litellmPrefix: "hosted_vllm",
+    skipPrefixes: [],
+    envExtras: [],
+    isGateway: false,
+    isLocal: true,
+    detectByKeyPrefix: "",
+    detectByBaseKeyword: "",
+    defaultApiBase: "",
+    stripModelPrefix: false,
+    modelOverrides: []
+  },
+  {
+    name: "groq",
+    keywords: ["groq"],
+    envKey: "GROQ_API_KEY",
+    displayName: "Groq",
+    litellmPrefix: "groq",
+    skipPrefixes: ["groq/"],
+    envExtras: [],
+    isGateway: false,
+    isLocal: false,
+    detectByKeyPrefix: "",
+    detectByBaseKeyword: "",
+    defaultApiBase: "",
+    stripModelPrefix: false,
+    modelOverrides: []
+  }
+];
+function findProviderByName(name) {
+  return PROVIDERS.find((spec) => spec.name === name);
+}
+function findProviderByModel(model) {
+  const modelLower = model.toLowerCase();
+  return PROVIDERS.find((spec) => {
+    if (spec.isGateway || spec.isLocal) {
+      return false;
+    }
+    return spec.keywords.some((keyword) => modelLower.includes(keyword));
+  });
+}
+function findGateway(providerName, apiKey, apiBase) {
+  if (providerName) {
+    const spec = findProviderByName(providerName);
+    if (spec && (spec.isGateway || spec.isLocal)) {
+      return spec;
+    }
+  }
+  for (const spec of PROVIDERS) {
+    if (spec.detectByKeyPrefix && apiKey && apiKey.startsWith(spec.detectByKeyPrefix)) {
+      return spec;
+    }
+    if (spec.detectByBaseKeyword && apiBase && apiBase.includes(spec.detectByBaseKeyword)) {
+      return spec;
+    }
+  }
+  return void 0;
+}
+function providerLabel(spec) {
+  return spec.displayName || spec.name;
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var allowFrom = z.array(z.string()).default([]);
+var WhatsAppConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  bridgeUrl: z.string().default("ws://localhost:3001"),
+  allowFrom
+});
+var TelegramConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  token: z.string().default(""),
+  allowFrom,
+  proxy: z.string().nullable().default(null)
+});
+var FeishuConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  appId: z.string().default(""),
+  appSecret: z.string().default(""),
+  encryptKey: z.string().default(""),
+  verificationToken: z.string().default(""),
+  allowFrom
+});
+var DingTalkConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  clientId: z.string().default(""),
+  clientSecret: z.string().default(""),
+  allowFrom
+});
+var DiscordConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  token: z.string().default(""),
+  allowFrom,
+  gatewayUrl: z.string().default("wss://gateway.discord.gg/?v=10&encoding=json"),
+  intents: z.number().int().default(37377)
+});
+var EmailConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  consentGranted: z.boolean().default(false),
+  imapHost: z.string().default(""),
+  imapPort: z.number().int().default(993),
+  imapUsername: z.string().default(""),
+  imapPassword: z.string().default(""),
+  imapMailbox: z.string().default("INBOX"),
+  imapUseSsl: z.boolean().default(true),
+  smtpHost: z.string().default(""),
+  smtpPort: z.number().int().default(587),
+  smtpUsername: z.string().default(""),
+  smtpPassword: z.string().default(""),
+  smtpUseTls: z.boolean().default(true),
+  smtpUseSsl: z.boolean().default(false),
+  fromAddress: z.string().default(""),
+  autoReplyEnabled: z.boolean().default(true),
+  pollIntervalSeconds: z.number().int().default(30),
+  markSeen: z.boolean().default(true),
+  maxBodyChars: z.number().int().default(12e3),
+  subjectPrefix: z.string().default("Re: "),
+  allowFrom
+});
+var MochatMentionSchema = z.object({
+  requireInGroups: z.boolean().default(false)
+});
+var MochatGroupRuleSchema = z.object({
+  requireMention: z.boolean().default(false)
+});
+var MochatConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  baseUrl: z.string().default("https://mochat.io"),
+  socketUrl: z.string().default(""),
+  socketPath: z.string().default("/socket.io"),
+  socketDisableMsgpack: z.boolean().default(false),
+  socketReconnectDelayMs: z.number().int().default(1e3),
+  socketMaxReconnectDelayMs: z.number().int().default(1e4),
+  socketConnectTimeoutMs: z.number().int().default(1e4),
+  refreshIntervalMs: z.number().int().default(3e4),
+  watchTimeoutMs: z.number().int().default(25e3),
+  watchLimit: z.number().int().default(100),
+  retryDelayMs: z.number().int().default(500),
+  maxRetryAttempts: z.number().int().default(0),
+  clawToken: z.string().default(""),
+  agentUserId: z.string().default(""),
+  sessions: z.array(z.string()).default([]),
+  panels: z.array(z.string()).default([]),
+  allowFrom,
+  mention: MochatMentionSchema.default({}),
+  groups: z.record(MochatGroupRuleSchema).default({}),
+  replyDelayMode: z.string().default("non-mention"),
+  replyDelayMs: z.number().int().default(12e4)
+});
+var SlackDMSchema = z.object({
+  enabled: z.boolean().default(true),
+  policy: z.string().default("open"),
+  allowFrom
+});
+var SlackConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  mode: z.string().default("socket"),
+  webhookPath: z.string().default("/slack/events"),
+  botToken: z.string().default(""),
+  appToken: z.string().default(""),
+  userTokenReadOnly: z.boolean().default(true),
+  groupPolicy: z.string().default("mention"),
+  groupAllowFrom: allowFrom,
+  dm: SlackDMSchema.default({})
+});
+var QQConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  appId: z.string().default(""),
+  secret: z.string().default(""),
+  allowFrom
+});
+var ChannelsConfigSchema = z.object({
+  whatsapp: WhatsAppConfigSchema.default({}),
+  telegram: TelegramConfigSchema.default({}),
+  discord: DiscordConfigSchema.default({}),
+  feishu: FeishuConfigSchema.default({}),
+  mochat: MochatConfigSchema.default({}),
+  dingtalk: DingTalkConfigSchema.default({}),
+  email: EmailConfigSchema.default({}),
+  slack: SlackConfigSchema.default({}),
+  qq: QQConfigSchema.default({})
+});
+var AgentDefaultsSchema = z.object({
+  workspace: z.string().default(DEFAULT_WORKSPACE_PATH),
+  model: z.string().default("anthropic/claude-opus-4-5"),
+  maxTokens: z.number().int().default(8192),
+  temperature: z.number().default(0.7),
+  maxToolIterations: z.number().int().default(20)
+});
+var AgentsConfigSchema = z.object({
+  defaults: AgentDefaultsSchema.default({})
+});
+var ProviderConfigSchema = z.object({
+  apiKey: z.string().default(""),
+  apiBase: z.string().nullable().default(null),
+  extraHeaders: z.record(z.string()).nullable().default(null)
+});
+var ProvidersConfigSchema = z.object({
+  anthropic: ProviderConfigSchema.default({}),
+  openai: ProviderConfigSchema.default({}),
+  openrouter: ProviderConfigSchema.default({}),
+  deepseek: ProviderConfigSchema.default({}),
+  groq: ProviderConfigSchema.default({}),
+  zhipu: ProviderConfigSchema.default({}),
+  dashscope: ProviderConfigSchema.default({}),
+  vllm: ProviderConfigSchema.default({}),
+  gemini: ProviderConfigSchema.default({}),
+  moonshot: ProviderConfigSchema.default({}),
+  minimax: ProviderConfigSchema.default({}),
+  aihubmix: ProviderConfigSchema.default({})
+});
+var GatewayConfigSchema = z.object({
+  host: z.string().default("0.0.0.0"),
+  port: z.number().int().default(18790)
+});
+var UiConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  host: z.string().default("127.0.0.1"),
+  port: z.number().int().default(18791),
+  open: z.boolean().default(false)
+});
+var WebSearchConfigSchema = z.object({
+  apiKey: z.string().default(""),
+  maxResults: z.number().int().default(5)
+});
+var WebToolsConfigSchema = z.object({
+  search: WebSearchConfigSchema.default({})
+});
+var ExecToolConfigSchema = z.object({
+  timeout: z.number().int().default(60)
+});
+var ToolsConfigSchema = z.object({
+  web: WebToolsConfigSchema.default({}),
+  exec: ExecToolConfigSchema.default({}),
+  restrictToWorkspace: z.boolean().default(false)
+});
+var ConfigSchema = z.object({
+  agents: AgentsConfigSchema.default({}),
+  channels: ChannelsConfigSchema.default({}),
+  providers: ProvidersConfigSchema.default({}),
+  gateway: GatewayConfigSchema.default({}),
+  ui: UiConfigSchema.default({}),
+  tools: ToolsConfigSchema.default({})
+});
+function getWorkspacePathFromConfig(config) {
+  return expandHome(config.agents.defaults.workspace);
+}
+function matchProvider(config, model) {
+  const modelLower = (model ?? config.agents.defaults.model).toLowerCase();
+  for (const spec of PROVIDERS) {
+    const provider = config.providers[spec.name];
+    if (provider && provider.apiKey && spec.keywords.some((kw) => modelLower.includes(kw))) {
+      return { provider, name: spec.name };
+    }
+  }
+  for (const spec of PROVIDERS) {
+    const provider = config.providers[spec.name];
+    if (provider && provider.apiKey) {
+      return { provider, name: spec.name };
+    }
+  }
+  return { provider: null, name: null };
+}
+function getProvider(config, model) {
+  return matchProvider(config, model).provider;
+}
+function getProviderName(config, model) {
+  return matchProvider(config, model).name;
+}
+function getApiKey(config, model) {
+  const provider = getProvider(config, model);
+  return provider?.apiKey ?? null;
+}
+function getApiBase(config, model) {
+  const { provider, name } = matchProvider(config, model);
+  if (provider?.apiBase) {
+    return provider.apiBase;
+  }
+  if (name) {
+    const spec = findProviderByName(name);
+    if (spec?.isGateway && spec.defaultApiBase) {
+      return spec.defaultApiBase;
+    }
+  }
+  return null;
+}
+
+// src/config/loader.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
+import { resolve as resolve4 } from "path";
+import { z as z2 } from "zod";
+function getConfigPath() {
+  return resolve4(getDataPath(), "config.json");
+}
+function getDataDir() {
+  return getDataPath();
+}
+function loadConfig(configPath) {
+  const path = configPath ?? getConfigPath();
+  if (existsSync7(path)) {
+    try {
+      const raw = readFileSync6(path, "utf-8");
+      const data = JSON.parse(raw);
+      const migrated = migrateConfig(data);
+      return ConfigSchema.parse(migrated);
+    } catch (err) {
+      const message = err instanceof z2.ZodError ? err.message : String(err);
+      console.warn(`Warning: Failed to load config from ${path}: ${message}`);
+    }
+  }
+  return ConfigSchema.parse({});
+}
+function saveConfig(config, configPath) {
+  const path = configPath ?? getConfigPath();
+  mkdirSync2(resolve4(path, ".."), { recursive: true });
+  writeFileSync4(path, JSON.stringify(config, null, 2));
+}
+function migrateConfig(data) {
+  const tools = data.tools ?? {};
+  const execConfig = tools.exec ?? {};
+  if (execConfig.restrictToWorkspace !== void 0 && tools.restrictToWorkspace === void 0) {
+    tools.restrictToWorkspace = execConfig.restrictToWorkspace;
+  }
+  return { ...data, tools };
+}
+
+// src/providers/base.ts
+var LLMProvider = class {
+  apiKey;
+  apiBase;
+  constructor(apiKey, apiBase) {
+    this.apiKey = apiKey ?? void 0;
+    this.apiBase = apiBase ?? void 0;
+  }
+};
+
+// src/providers/openai_provider.ts
+import OpenAI from "openai";
+var OpenAICompatibleProvider = class extends LLMProvider {
+  client;
+  defaultModel;
+  extraHeaders;
+  constructor(options) {
+    super(options.apiKey, options.apiBase);
+    this.defaultModel = options.defaultModel;
+    this.extraHeaders = options.extraHeaders ?? null;
+    this.client = new OpenAI({
+      apiKey: options.apiKey ?? void 0,
+      baseURL: options.apiBase ?? void 0,
+      defaultHeaders: options.extraHeaders ?? void 0
+    });
+  }
+  getDefaultModel() {
+    return this.defaultModel;
+  }
+  async chat(params) {
+    const model = params.model ?? this.defaultModel;
+    const temperature = params.temperature ?? 0.7;
+    const maxTokens = params.maxTokens ?? 4096;
+    const response = await this.client.chat.completions.create({
+      model,
+      messages: params.messages,
+      tools: params.tools,
+      tool_choice: params.tools?.length ? "auto" : void 0,
+      temperature,
+      max_tokens: maxTokens
+    });
+    const choice = response.choices[0];
+    const message = choice?.message;
+    const toolCalls = [];
+    if (message?.tool_calls) {
+      for (const toolCall of message.tool_calls) {
+        if (toolCall.type !== "function") {
+          continue;
+        }
+        let args = {};
+        try {
+          args = JSON.parse(toolCall.function.arguments ?? "{}");
+        } catch {
+          args = {};
+        }
+        toolCalls.push({
+          id: toolCall.id,
+          name: toolCall.function.name,
+          arguments: args
+        });
+      }
+    }
+    const reasoningContent = message?.reasoning_content ?? message?.reasoning ?? null;
+    return {
+      content: message?.content ?? null,
+      toolCalls,
+      finishReason: choice?.finish_reason ?? "stop",
+      usage: {
+        prompt_tokens: response.usage?.prompt_tokens ?? 0,
+        completion_tokens: response.usage?.completion_tokens ?? 0,
+        total_tokens: response.usage?.total_tokens ?? 0
+      },
+      reasoningContent
+    };
+  }
+};
+
+// src/providers/litellm_provider.ts
+var LiteLLMProvider = class extends LLMProvider {
+  defaultModel;
+  extraHeaders;
+  providerName;
+  gatewaySpec;
+  client;
+  constructor(options) {
+    super(options.apiKey, options.apiBase);
+    this.defaultModel = options.defaultModel;
+    this.extraHeaders = options.extraHeaders ?? null;
+    this.providerName = options.providerName ?? null;
+    this.gatewaySpec = findGateway(this.providerName, options.apiKey ?? null, options.apiBase ?? null) ?? void 0;
+    this.client = new OpenAICompatibleProvider({
+      apiKey: options.apiKey ?? null,
+      apiBase: options.apiBase ?? null,
+      defaultModel: options.defaultModel,
+      extraHeaders: options.extraHeaders ?? null
+    });
+  }
+  getDefaultModel() {
+    return this.defaultModel;
+  }
+  async chat(params) {
+    const requestedModel = params.model ?? this.defaultModel;
+    const resolvedModel = this.resolveModel(requestedModel);
+    const apiModel = this.stripRoutingPrefix(resolvedModel);
+    const temperature = params.temperature ?? 0.7;
+    const maxTokens = params.maxTokens ?? 4096;
+    const overrides = this.applyModelOverrides(apiModel, { temperature, maxTokens });
+    return this.client.chat({
+      messages: params.messages,
+      tools: params.tools,
+      model: apiModel,
+      temperature: overrides.temperature,
+      maxTokens: overrides.maxTokens
+    });
+  }
+  resolveModel(model) {
+    if (this.gatewaySpec) {
+      let resolved = model;
+      if (this.gatewaySpec.stripModelPrefix && resolved.includes("/")) {
+        resolved = resolved.split("/").slice(-1)[0];
+      }
+      const prefix = this.gatewaySpec.litellmPrefix ?? "";
+      if (prefix && !resolved.startsWith(`${prefix}/`)) {
+        resolved = `${prefix}/${resolved}`;
+      }
+      return resolved;
+    }
+    const spec = this.getStandardSpec(model);
+    if (!spec) {
+      return model;
+    }
+    if (spec.litellmPrefix) {
+      const skipPrefixes = spec.skipPrefixes ?? [];
+      if (!skipPrefixes.some((prefix) => model.startsWith(prefix))) {
+        return `${spec.litellmPrefix}/${model}`;
+      }
+    }
+    return model;
+  }
+  stripRoutingPrefix(model) {
+    if (this.gatewaySpec) {
+      return model;
+    }
+    const spec = this.getStandardSpec(model);
+    if (!spec?.litellmPrefix) {
+      return model;
+    }
+    const prefix = `${spec.litellmPrefix}/`;
+    if (model.startsWith(prefix)) {
+      return model.slice(prefix.length);
+    }
+    return model;
+  }
+  applyModelOverrides(model, params) {
+    const spec = this.getStandardSpec(model);
+    if (!spec?.modelOverrides?.length) {
+      return params;
+    }
+    const match = spec.modelOverrides.find(([pattern]) => model.toLowerCase().includes(pattern));
+    if (!match) {
+      return params;
+    }
+    const overrides = match[1];
+    return {
+      temperature: typeof overrides.temperature === "number" ? overrides.temperature : params.temperature,
+      maxTokens: typeof overrides.max_tokens === "number" ? overrides.max_tokens : params.maxTokens
+    };
+  }
+  getStandardSpec(model) {
+    return findProviderByModel(model) ?? (this.providerName ? findProviderByName(this.providerName) : void 0);
+  }
+};
+
+export {
+  APP_NAME,
+  APP_TAGLINE,
+  APP_TITLE,
+  APP_REPLY_SUBJECT,
+  getDataPath,
+  getWorkspacePath,
+  SessionManager,
+  AgentLoop,
+  PROVIDERS,
+  findProviderByName,
+  findProviderByModel,
+  findGateway,
+  providerLabel,
+  WhatsAppConfigSchema,
+  TelegramConfigSchema,
+  FeishuConfigSchema,
+  DingTalkConfigSchema,
+  DiscordConfigSchema,
+  EmailConfigSchema,
+  MochatMentionSchema,
+  MochatGroupRuleSchema,
+  MochatConfigSchema,
+  SlackDMSchema,
+  SlackConfigSchema,
+  QQConfigSchema,
+  ChannelsConfigSchema,
+  AgentDefaultsSchema,
+  AgentsConfigSchema,
+  ProviderConfigSchema,
+  ProvidersConfigSchema,
+  GatewayConfigSchema,
+  UiConfigSchema,
+  WebSearchConfigSchema,
+  WebToolsConfigSchema,
+  ExecToolConfigSchema,
+  ToolsConfigSchema,
+  ConfigSchema,
+  getWorkspacePathFromConfig,
+  matchProvider,
+  getProvider,
+  getProviderName,
+  getApiKey,
+  getApiBase,
+  getConfigPath,
+  getDataDir,
+  loadConfig,
+  saveConfig,
+  LLMProvider,
+  LiteLLMProvider
+};