formagent-sdk 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,4539 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli/cli.ts
+import * as readline from "node:readline";
+import { homedir as homedir4 } from "node:os";
+import { join as join7 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+
+// src/utils/id.ts
+var ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function generateId(prefix, length = 12) {
+  const randomPart = generateRandomString(length);
+  return prefix ? `${prefix}_${randomPart}` : randomPart;
+}
+function generateRandomString(length) {
+  const bytes = new Uint8Array(length);
+  crypto.getRandomValues(bytes);
+  let result = "";
+  for (let i = 0;i < length; i++) {
+    result += ALPHABET[bytes[i] % ALPHABET.length];
+  }
+  return result;
+}
+function generateSessionId() {
+  return generateId("sess", 16);
+}
+function generateMessageId() {
+  return generateId("msg", 20);
+}
+
+// src/utils/events.ts
+import { EventEmitter } from "events";
+
+class TypedEventEmitter {
+  emitter;
+  constructor() {
+    this.emitter = new EventEmitter;
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  emit(event, ...args) {
+    return this.emitter.emit(event, ...args);
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.emitter.removeAllListeners(event);
+    } else {
+      this.emitter.removeAllListeners();
+    }
+    return this;
+  }
+  listenerCount(event) {
+    return this.emitter.listenerCount(event);
+  }
+  listeners(event) {
+    return this.emitter.listeners(event);
+  }
+  setMaxListeners(n) {
+    this.emitter.setMaxListeners(n);
+    return this;
+  }
+  getMaxListeners() {
+    return this.emitter.getMaxListeners();
+  }
+}
+
+// src/hooks/manager.ts
+class HookTimeoutError extends Error {
+  constructor(hookName, timeout) {
+    super(`Hook "${hookName}" timed out after ${timeout}ms`);
+    this.name = "HookTimeoutError";
+  }
+}
+
+class HooksManager {
+  config;
+  sessionId;
+  cwd;
+  constructor(config, sessionId, cwd = process.cwd()) {
+    this.config = config;
+    this.sessionId = sessionId;
+    this.cwd = cwd;
+  }
+  async runPreToolUse(toolName, toolInput, toolUseId, abortSignal) {
+    const matchers = this.config.PreToolUse ?? [];
+    const matchingHooks = this.getMatchingHooks(matchers, toolName);
+    if (matchingHooks.length === 0) {
+      return {
+        allowed: true,
+        decision: "allow",
+        continue: true
+      };
+    }
+    const input = {
+      hook_event_name: "PreToolUse",
+      session_id: this.sessionId,
+      cwd: this.cwd,
+      tool_name: toolName,
+      tool_input: toolInput
+    };
+    const context = { signal: abortSignal };
+    let finalDecision = "allow";
+    let finalReason;
+    let finalUpdatedInput;
+    let systemMessage;
+    let shouldContinue = true;
+    let stopReason;
+    for (const { hook, timeout } of matchingHooks) {
+      try {
+        const result = await this.runHookWithTimeout(hook, input, toolUseId, context, timeout);
+        if (result.continue === false) {
+          shouldContinue = false;
+          stopReason = result.stopReason;
+          break;
+        }
+        if (result.systemMessage) {
+          systemMessage = result.systemMessage;
+        }
+        if (result.hookSpecificOutput) {
+          const output = result.hookSpecificOutput;
+          if (output.hookEventName === "PreToolUse") {
+            if (output.permissionDecision === "deny") {
+              finalDecision = "deny";
+              finalReason = output.permissionDecisionReason;
+            } else if (output.permissionDecision === "ask" && finalDecision !== "deny") {
+              finalDecision = "ask";
+              finalReason = output.permissionDecisionReason;
+            } else if (output.permissionDecision === "allow" && output.updatedInput) {
+              finalUpdatedInput = output.updatedInput;
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`Hook error: ${error}`);
+      }
+    }
+    return {
+      allowed: finalDecision === "allow",
+      decision: finalDecision,
+      reason: finalReason,
+      updatedInput: finalUpdatedInput,
+      systemMessage,
+      continue: shouldContinue,
+      stopReason
+    };
+  }
+  async runPostToolUse(toolName, toolInput, toolResponse, toolUseId, abortSignal) {
+    const matchers = this.config.PostToolUse ?? [];
+    const matchingHooks = this.getMatchingHooks(matchers, toolName);
+    if (matchingHooks.length === 0) {
+      return { continue: true };
+    }
+    const input = {
+      hook_event_name: "PostToolUse",
+      session_id: this.sessionId,
+      cwd: this.cwd,
+      tool_name: toolName,
+      tool_input: toolInput,
+      tool_response: toolResponse
+    };
+    const context = { signal: abortSignal };
+    let additionalContext;
+    let systemMessage;
+    let shouldContinue = true;
+    let stopReason;
+    for (const { hook, timeout } of matchingHooks) {
+      try {
+        const result = await this.runHookWithTimeout(hook, input, toolUseId, context, timeout);
+        if (result.continue === false) {
+          shouldContinue = false;
+          stopReason = result.stopReason;
+          break;
+        }
+        if (result.systemMessage) {
+          systemMessage = result.systemMessage;
+        }
+        if (result.hookSpecificOutput?.hookEventName === "PostToolUse") {
+          if (result.hookSpecificOutput.additionalContext) {
+            additionalContext = result.hookSpecificOutput.additionalContext;
+          }
+        }
+      } catch (error) {
+        console.error(`Hook error: ${error}`);
+      }
+    }
+    return {
+      additionalContext,
+      systemMessage,
+      continue: shouldContinue,
+      stopReason
+    };
+  }
+  async runUserPromptSubmit(prompt, abortSignal) {
+    const matchers = this.config.UserPromptSubmit ?? [];
+    if (matchers.length === 0) {
+      return { continue: true };
+    }
+    const input = {
+      hook_event_name: "UserPromptSubmit",
+      session_id: this.sessionId,
+      cwd: this.cwd,
+      prompt
+    };
+    const context = { signal: abortSignal };
+    let additionalContext;
+    let systemMessage;
+    let shouldContinue = true;
+    let stopReason;
+    for (const matcher of matchers) {
+      for (const hook of matcher.hooks) {
+        try {
+          const result = await this.runHookWithTimeout(hook, input, null, context, matcher.timeout ?? 60);
+          if (result.continue === false) {
+            shouldContinue = false;
+            stopReason = result.stopReason;
+            break;
+          }
+          if (result.systemMessage) {
+            systemMessage = result.systemMessage;
+          }
+          if (result.hookSpecificOutput?.hookEventName === "UserPromptSubmit") {
+            if (result.hookSpecificOutput.additionalContext) {
+              additionalContext = result.hookSpecificOutput.additionalContext;
+            }
+          }
+        } catch (error) {
+          console.error(`Hook error: ${error}`);
+        }
+      }
+      if (!shouldContinue)
+        break;
+    }
+    return {
+      additionalContext,
+      systemMessage,
+      continue: shouldContinue,
+      stopReason
+    };
+  }
+  async runStop(abortSignal) {
+    const matchers = this.config.Stop ?? [];
+    if (matchers.length === 0) {
+      return;
+    }
+    const input = {
+      hook_event_name: "Stop",
+      session_id: this.sessionId,
+      cwd: this.cwd,
+      stop_hook_active: true
+    };
+    const context = { signal: abortSignal };
+    for (const matcher of matchers) {
+      for (const hook of matcher.hooks) {
+        try {
+          await this.runHookWithTimeout(hook, input, null, context, matcher.timeout ?? 60);
+        } catch (error) {
+          console.error(`Hook error: ${error}`);
+        }
+      }
+    }
+  }
+  getMatchingHooks(matchers, toolName) {
+    const result = [];
+    for (const matcher of matchers) {
+      if (!matcher.matcher) {
+        for (const hook of matcher.hooks) {
+          result.push({ hook, timeout: (matcher.timeout ?? 60) * 1000 });
+        }
+        continue;
+      }
+      try {
+        const regex = new RegExp(matcher.matcher);
+        if (regex.test(toolName)) {
+          for (const hook of matcher.hooks) {
+            result.push({ hook, timeout: (matcher.timeout ?? 60) * 1000 });
+          }
+        }
+      } catch {
+        console.warn(`Invalid hook matcher regex: ${matcher.matcher}`);
+      }
+    }
+    return result;
+  }
+  async runHookWithTimeout(hook, input, toolUseId, context, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new HookTimeoutError(input.hook_event_name, timeoutMs));
+      }, timeoutMs);
+      hook(input, toolUseId, context).then((result) => {
+        clearTimeout(timer);
+        resolve(result);
+      }).catch((error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+}
+
+// src/skills/loader.ts
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join, dirname, basename } from "node:path";
+import { homedir } from "node:os";
+
+// src/utils/frontmatter.ts
+function parseFrontmatter(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("---")) {
+    return {
+      data: {},
+      content: input
+    };
+  }
+  const endIndex = trimmed.indexOf(`
+---`, 3);
+  if (endIndex === -1) {
+    return {
+      data: {},
+      content: input
+    };
+  }
+  const raw = trimmed.slice(4, endIndex).trim();
+  const content = trimmed.slice(endIndex + 4).trim();
+  const data = parseYamlLike(raw);
+  return {
+    data,
+    content,
+    raw
+  };
+}
+function parseYamlLike(yaml) {
+  const result = {};
+  const lines = yaml.split(`
+`);
+  let currentKey = null;
+  let currentArray = null;
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#")) {
+      continue;
+    }
+    if (trimmedLine.startsWith("- ") && currentKey && currentArray) {
+      const value = parseValue(trimmedLine.slice(2).trim());
+      currentArray.push(value);
+      continue;
+    }
+    const colonIndex = trimmedLine.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
+    }
+    const key = trimmedLine.slice(0, colonIndex).trim();
+    const rawValue = trimmedLine.slice(colonIndex + 1).trim();
+    if (!rawValue) {
+      currentKey = key;
+      currentArray = [];
+      result[key] = currentArray;
+      continue;
+    }
+    currentKey = null;
+    currentArray = null;
+    result[key] = parseValue(rawValue);
+  }
+  return result;
+}
+function parseValue(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (trimmed === "null" || trimmed === "~") {
+    return null;
+  }
+  if (trimmed === "true") {
+    return true;
+  }
+  if (trimmed === "false") {
+    return false;
+  }
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    const inner = trimmed.slice(1, -1).trim();
+    if (!inner) {
+      return [];
+    }
+    return inner.split(",").map((item) => parseValue(item.trim()));
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  const num = Number(trimmed);
+  if (!isNaN(num) && trimmed !== "") {
+    return num;
+  }
+  return trimmed;
+}
+
+// src/skills/loader.ts
+var SKILL_FILE_NAME = "SKILL.md";
+var USER_SKILLS_DIR = ".claude/skills";
+var PROJECT_SKILLS_DIR = ".claude/skills";
+
+class SkillLoader {
+  skills = new Map;
+  discoveredPaths = new Set;
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  async discover(options = {}) {
+    const {
+      directories = [],
+      includeUserSkills = true,
+      includeProjectSkills = true,
+      maxDepth = 2
+    } = options;
+    const allDirs = [...directories];
+    if (includeUserSkills) {
+      const userSkillsDir = join(homedir(), USER_SKILLS_DIR);
+      if (existsSync(userSkillsDir)) {
+        allDirs.push(userSkillsDir);
+      }
+    }
+    if (includeProjectSkills && this.projectRoot) {
+      const projectSkillsDir = join(this.projectRoot, PROJECT_SKILLS_DIR);
+      if (existsSync(projectSkillsDir)) {
+        allDirs.push(projectSkillsDir);
+      }
+    }
+    const skills = [];
+    for (const dir of allDirs) {
+      const dirSkills = await this.scanDirectory(dir, maxDepth);
+      skills.push(...dirSkills);
+    }
+    return skills;
+  }
+  async load(skillId) {
+    if (this.skills.has(skillId)) {
+      return this.skills.get(skillId);
+    }
+    for (const path of this.discoveredPaths) {
+      const skill = await this.parseSkillFile(path);
+      if (skill && skill.id === skillId) {
+        this.skills.set(skill.id, skill);
+        return skill;
+      }
+    }
+    return;
+  }
+  async search(query) {
+    if (!query) {
+      return this.getAll();
+    }
+    const lowerQuery = query.toLowerCase();
+    return this.getAll().filter((skill) => {
+      if (skill.name.toLowerCase().includes(lowerQuery)) {
+        return true;
+      }
+      if (skill.description.toLowerCase().includes(lowerQuery)) {
+        return true;
+      }
+      if (skill.id.toLowerCase().includes(lowerQuery)) {
+        return true;
+      }
+      if (skill.metadata?.tags?.some((tag) => tag.toLowerCase().includes(lowerQuery))) {
+        return true;
+      }
+      if (skill.triggers?.some((trigger) => trigger.toLowerCase().includes(lowerQuery))) {
+        return true;
+      }
+      return false;
+    });
+  }
+  register(skill) {
+    this.skills.set(skill.id, skill);
+  }
+  unregister(skillId) {
+    this.skills.delete(skillId);
+  }
+  getAll() {
+    return Array.from(this.skills.values());
+  }
+  async checkActivation(message, context) {
+    const lowerMessage = message.toLowerCase();
+    const matchingSkills = [];
+    let matchedTrigger;
+    for (const skill of this.skills.values()) {
+      if (skill.triggers) {
+        for (const trigger of skill.triggers) {
+          if (this.matchesTrigger(lowerMessage, trigger)) {
+            matchingSkills.push(skill);
+            matchedTrigger = trigger;
+            break;
+          }
+        }
+      }
+    }
+    if (matchingSkills.length === 0) {
+      return {
+        shouldActivate: false,
+        skills: []
+      };
+    }
+    return {
+      shouldActivate: true,
+      skills: matchingSkills,
+      systemPromptAddition: this.getSystemPromptContent(matchingSkills.map((s) => s.id))
+    };
+  }
+  getSystemPromptContent(skillIds) {
+    const parts = [];
+    for (const skillId of skillIds) {
+      const skill = this.skills.get(skillId);
+      if (skill) {
+        parts.push(`## Skill: ${skill.name}`);
+        parts.push(skill.content);
+      }
+    }
+    return parts.join(`
+
+`);
+  }
+  async refresh() {
+    this.skills.clear();
+    await this.discover();
+  }
+  clear() {
+    this.skills.clear();
+    this.discoveredPaths.clear();
+  }
+  async scanDirectory(dir, maxDepth, currentDepth = 0) {
+    if (currentDepth > maxDepth) {
+      return [];
+    }
+    if (!existsSync(dir)) {
+      return [];
+    }
+    const skills = [];
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          const skillFile = join(fullPath, SKILL_FILE_NAME);
+          if (existsSync(skillFile)) {
+            if (!this.discoveredPaths.has(skillFile)) {
+              const skill = await this.parseSkillFile(skillFile);
+              if (skill) {
+                this.skills.set(skill.id, skill);
+                this.discoveredPaths.add(skillFile);
+                skills.push(skill);
+              }
+            }
+          }
+          const subSkills = await this.scanDirectory(fullPath, maxDepth, currentDepth + 1);
+          skills.push(...subSkills);
+        } else if (entry === SKILL_FILE_NAME) {
+          if (!this.discoveredPaths.has(fullPath)) {
+            const skill = await this.parseSkillFile(fullPath);
+            if (skill) {
+              this.skills.set(skill.id, skill);
+              this.discoveredPaths.add(fullPath);
+              skills.push(skill);
+            }
+          }
+        }
+      }
+    } catch {}
+    return skills;
+  }
+  async parseSkillFile(filePath) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const { data: frontmatter, content: body } = parseFrontmatter(content);
+      const dirName = basename(dirname(filePath));
+      const id = frontmatter.id || dirName;
+      const metadata = {
+        version: frontmatter.version,
+        author: frontmatter.author,
+        tags: frontmatter.tags,
+        dependencies: frontmatter.dependencies,
+        triggers: frontmatter.triggers,
+        tools: frontmatter.tools
+      };
+      const skill = {
+        id,
+        name: frontmatter.name || id,
+        description: frontmatter.description || "",
+        content: body,
+        triggers: frontmatter.triggers,
+        tools: frontmatter.tools,
+        metadata,
+        filePath
+      };
+      return skill;
+    } catch {
+      return;
+    }
+  }
+  matchesTrigger(message, trigger) {
+    const lowerTrigger = trigger.toLowerCase();
+    if (message.includes(lowerTrigger)) {
+      return true;
+    }
+    if (trigger.startsWith("/") && trigger.endsWith("/")) {
+      try {
+        const regex = new RegExp(trigger.slice(1, -1), "i");
+        return regex.test(message);
+      } catch {
+        return false;
+      }
+    }
+    if (!lowerTrigger.includes(" ")) {
+      const wordBoundary = new RegExp(`\\b${lowerTrigger}\\b`, "i");
+      return wordBoundary.test(message);
+    }
+    return false;
+  }
+}
+var defaultSkillLoader = new SkillLoader;
+
+// src/tools/skill.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+var DEFAULT_USER_SKILLS_PATH = join2(homedir2(), ".claude/skills");
+var skillToolSchema = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["list", "invoke"],
+      description: "Action to perform: 'list' to show available skills, 'invoke' to use a skill"
+    },
+    skill_name: {
+      type: "string",
+      description: "Name or ID of the skill to invoke (required when action is 'invoke')"
+    },
+    query: {
+      type: "string",
+      description: "Optional search query to filter skills (used with 'list' action)"
+    }
+  },
+  required: ["action"]
+};
+function createSkillTool(config = {}) {
+  const loader = new SkillLoader(config.cwd);
+  let initialized = false;
+  const resolvePaths = () => {
+    const paths = [];
+    if (config.settingSources && config.settingSources.length > 0) {
+      for (const source of config.settingSources) {
+        const resolvedPath = source.startsWith("~") ? join2(homedir2(), source.slice(1)) : source;
+        if (existsSync2(resolvedPath)) {
+          paths.push(resolvedPath);
+        }
+      }
+    } else {
+      if (existsSync2(DEFAULT_USER_SKILLS_PATH)) {
+        paths.push(DEFAULT_USER_SKILLS_PATH);
+      }
+    }
+    return paths;
+  };
+  const initialize = async () => {
+    if (initialized)
+      return;
+    const paths = resolvePaths();
+    await loader.discover({
+      directories: paths,
+      includeUserSkills: false,
+      includeProjectSkills: false,
+      maxDepth: 3
+    });
+    initialized = true;
+  };
+  return {
+    name: "Skill",
+    description: `Discover and use specialized skills that extend Claude's capabilities.
+
+Actions:
+- "list": Show available skills with their descriptions and triggers
+- "invoke": Activate a skill by name to get specialized instructions
+
+When you invoke a skill, you will receive detailed instructions and guidelines that you should follow for the current task.
+
+Skills are discovered from configured directories and provide domain-specific expertise.`,
+    inputSchema: skillToolSchema,
+    execute: async (rawInput, _context) => {
+      await initialize();
+      const input = rawInput;
+      const { action, skill_name, query } = input;
+      if (action === "list") {
+        return listSkills(loader, query);
+      }
+      if (action === "invoke") {
+        if (!skill_name) {
+          return {
+            content: "Error: skill_name is required when action is 'invoke'",
+            isError: true
+          };
+        }
+        return invokeSkill(loader, skill_name);
+      }
+      return {
+        content: `Error: Unknown action "${action}". Use "list" or "invoke".`,
+        isError: true
+      };
+    }
+  };
+}
+async function listSkills(loader, query) {
+  const skills = query ? await loader.search(query) : loader.getAll();
+  if (skills.length === 0) {
+    return {
+      content: query ? `No skills found matching "${query}".` : "No skills available. Skills are loaded from configured settingSources directories."
+    };
+  }
+  const skillList = skills.map((skill) => {
+    const triggers = skill.triggers?.slice(0, 3).join(", ") || "none";
+    return `- **${skill.name}** (${skill.id})
+  Description: ${skill.description || "No description"}
+  Triggers: ${triggers}`;
+  });
+  return {
+    content: `# Available Skills
+
+${skillList.join(`
+
+`)}
+
+To use a skill, invoke the Skill tool with action="invoke" and skill_name="<skill-id>".`
+  };
+}
+async function invokeSkill(loader, skillName) {
+  let skill = await loader.load(skillName);
+  if (!skill) {
+    const matches = await loader.search(skillName);
+    if (matches.length === 1) {
+      skill = matches[0];
+    } else if (matches.length > 1) {
+      const names = matches.map((s) => `${s.name} (${s.id})`).join(", ");
+      return {
+        content: `Multiple skills match "${skillName}": ${names}. Please specify the exact skill ID.`,
+        isError: true
+      };
+    }
+  }
+  if (!skill) {
+    return {
+      content: `Skill "${skillName}" not found. Use action="list" to see available skills.`,
+      isError: true
+    };
+  }
+  return {
+    content: formatSkillContent(skill),
+    metadata: {
+      skillId: skill.id,
+      skillName: skill.name,
+      activated: true
+    }
+  };
+}
+function formatSkillContent(skill) {
+  const parts = [];
+  parts.push(`# Skill Activated: ${skill.name}`);
+  parts.push("");
+  if (skill.description) {
+    parts.push(`**Description:** ${skill.description}`);
+    parts.push("");
+  }
+  if (skill.tools && skill.tools.length > 0) {
+    parts.push(`**Recommended Tools:** ${skill.tools.join(", ")}`);
+    parts.push("");
+  }
+  parts.push("## Instructions");
+  parts.push("");
+  parts.push(skill.content);
+  return parts.join(`
+`);
+}
+var skillTool = createSkillTool();
+
+// src/prompt/presets.ts
+var CLI_AGENT_PRESET = `You are FormAgent, a highly capable AI assistant running as a CLI tool.
+You help users with software engineering tasks including coding, debugging, refactoring, and more.
+
+## Tone and Style
+
+Be concise, direct, and to the point. Match detail level to task complexity.
+- Brief responses are preferred (generally <4 lines for simple tasks)
+- Minimize preamble/postamble - don't explain what you're about to do or summarize what you did
+- Answer questions directly without unnecessary elaboration
+- Only provide detailed explanations when the task is complex or when asked
+
+Examples of appropriate brevity:
+- "What is 2+2?" → "4"
+- "Is this a valid JSON?" → "Yes" or "No, missing closing brace on line 3"
+- "What command lists files?" → "ls"
+
+## Proactiveness
+
+Strike a balance between being helpful and not surprising the user:
+- When asked to do something, take appropriate action and follow-up actions
+- When asked HOW to do something, explain first before taking action
+- Don't take unexpected actions without being asked
+- If a task is ambiguous, ask for clarification rather than guessing
+
+## Professional Objectivity
+
+Prioritize technical accuracy over validation:
+- Focus on facts and problem-solving
+- Provide direct, objective technical information
+- Disagree respectfully when the user's approach has issues
+- Investigate to find truth rather than confirming beliefs
+- Avoid unnecessary praise or emotional validation
+
+## Task Management
+
+Use the TodoWrite tool proactively for complex tasks:
+- Create todos when a task has 3+ steps or touches multiple files
+- Break complex tasks into specific, actionable items
+- Mark todos as in_progress BEFORE starting work (only ONE at a time)
+- Mark todos as completed IMMEDIATELY after finishing (don't batch)
+- Only mark complete when FULLY accomplished (not when tests fail or errors occur)
+
+When NOT to use todos:
+- Single, straightforward tasks
+- Trivial operations that take <3 steps
+- Purely informational requests
+
+## Tool Usage
+
+Use the right tool for each task:
+- Read: Read files (NOT cat/head/tail)
+- Write: Create new files
+- Edit: Modify existing files (NOT sed/awk)
+- Glob: Find files by pattern (NOT find/ls)
+- Grep: Search file contents (NOT grep/rg command)
+- Bash: Execute shell commands (for git, npm, build tools, etc.)
+- WebFetch: Retrieve web content
+- Skill: Invoke specialized skills for domain-specific tasks
+
+Best practices:
+- Always Read a file before editing it
+- Verify edits by reading the file after changes
+- Use specialized tools instead of Bash when available
+- Batch independent operations in parallel when possible
+
+## Code Quality Standards
+
+- Follow existing project conventions and patterns
+- Write clean, readable, well-documented code
+- Consider edge cases and error handling
+- Test changes when appropriate
+- Don't over-engineer - only add what's asked for
+
+## Git Workflow (when using Bash for git)
+
+Safety rules:
+- NEVER update git config
+- NEVER run destructive commands (push --force, hard reset) unless explicitly asked
+- NEVER skip hooks (--no-verify) unless explicitly asked
+- NEVER force push to main/master - warn the user if requested
+- Only commit when explicitly asked
+
+When committing:
+- Run git status and git diff first to understand changes
+- Write concise commit messages focused on "why" not "what"
+- Use conventional commit format when the project uses it
+
+## Code References
+
+When referencing code locations, use the format: \`file_path:line_number\`
+Example: "The error handler is in src/utils/error.ts:42"
+
+## Error Handling
+
+When something fails:
+- Investigate the root cause, don't just retry
+- Never disable/skip tests to make things pass
+- Provide actionable suggestions for fixing issues
+- If blocked, explain what's needed to proceed
+
+## Security
+
+- Assist with defensive security tasks only
+- Refuse to create, modify, or improve potentially malicious code
+- Don't generate or guess URLs unless confident they're for programming help
+- Warn about potential security issues in code
+`;
+var SDK_DEFAULT_PRESET = `You are FormAgent, a helpful AI assistant for software development tasks.
+
+## Core Behavior
+
+- Be concise and direct in responses
+- Match detail level to task complexity
+- Use available tools to accomplish tasks efficiently
+- Follow existing code patterns and conventions
+
+## Response Style
+
+- Brief responses preferred for simple tasks
+- Avoid unnecessary preamble or postamble
+- Only explain in detail when the task is complex or when asked
+- Focus on actionable information
+
+## Tool Usage
+
+Use the right tool for each task:
+- Read: Read file contents
+- Write: Create new files
+- Edit: Modify existing files
+- Glob: Find files by pattern
+- Grep: Search file contents
+
+Best practices:
+- Read a file before editing it
+- Verify changes after editing
+- Use specialized tools when available
+
+## Code Quality
+
+- Follow existing project conventions
+- Write clean, readable code
+- Consider error handling
+- Don't over-engineer - only add what's asked for
+
+## Task Management
+
+For complex multi-step tasks:
+- Use TodoWrite to track progress
+- Break tasks into specific items
+- Mark items complete as you finish them
+
+## Professional Objectivity
+
+- Prioritize technical accuracy
+- Provide direct, objective information
+- Point out issues respectfully when needed
+`;
+var MINIMAL_PRESET = `You are a helpful AI assistant. Use available tools to accomplish tasks efficiently.`;
+function generateEnvContext(options) {
+  const {
+    cwd = process.cwd(),
+    isGitRepo = false,
+    platform = process.platform,
+    osVersion,
+    date = new Date,
+    shell
+  } = options;
+  const lines = [
+    "<env>",
+    `Working directory: ${cwd}`,
+    `Is directory a git repo: ${isGitRepo ? "Yes" : "No"}`,
+    `Platform: ${platform}`
+  ];
+  if (osVersion) {
+    lines.push(`OS Version: ${osVersion}`);
+  }
+  if (shell) {
+    lines.push(`Shell: ${shell}`);
+  }
+  lines.push(`Today's date: ${date.toISOString().split("T")[0]}`);
+  lines.push("</env>");
+  return lines.join(`
+`);
+}
+var BUILT_IN_PRESETS = {
+  claude_code: CLI_AGENT_PRESET,
+  default: SDK_DEFAULT_PRESET,
+  minimal: MINIMAL_PRESET
+};
+function getBuiltInPreset(name) {
+  return BUILT_IN_PRESETS[name];
+}
+
+// src/prompt/builder.ts
+class SystemPromptBuilderImpl {
+  customPresets = new Map;
+  async build(config, context) {
+    const parts = [];
+    if (config.prepend) {
+      parts.push(config.prepend.trim());
+    }
+    const baseContent = this.getBaseContent(config);
+    if (baseContent) {
+      parts.push(baseContent.trim());
+    }
+    const contextContent = this.buildContextContent(context);
+    if (contextContent) {
+      parts.push(contextContent.trim());
+    }
+    if (config.append) {
+      parts.push(config.append.trim());
+    }
+    return parts.filter(Boolean).join(`
+
+`);
+  }
+  getPreset(preset) {
+    if (preset === "custom") {
+      return "";
+    }
+    const customPreset = this.customPresets.get(preset);
+    if (customPreset) {
+      return customPreset;
+    }
+    return getBuiltInPreset(preset);
+  }
+  registerPreset(name, content) {
+    this.customPresets.set(name, content);
+  }
+  listPresets() {
+    const presets = [];
+    for (const [name, content] of Object.entries(BUILT_IN_PRESETS)) {
+      presets.push({
+        name,
+        description: this.getPresetDescription(name),
+        length: content.length,
+        builtIn: true
+      });
+    }
+    for (const [name, content] of this.customPresets.entries()) {
+      presets.push({
+        name,
+        description: `Custom preset: ${name}`,
+        length: content.length,
+        builtIn: false
+      });
+    }
+    return presets;
+  }
+  getBaseContent(config) {
+    if (config.custom) {
+      return config.custom;
+    }
+    if (config.preset) {
+      return this.getPreset(config.preset);
+    }
+    return this.getPreset("default");
+  }
+  buildContextContent(context) {
+    if (!context) {
+      return "";
+    }
+    const parts = [];
+    if (context.environment || context.cwd || context.timestamp) {
+      const envParts = [];
+      if (context.cwd) {
+        envParts.push(`Working directory: ${context.cwd}`);
+      }
+      if (context.environment?.platform) {
+        envParts.push(`Platform: ${context.environment.platform}`);
+      }
+      if (context.environment?.shell) {
+        envParts.push(`Shell: ${context.environment.shell}`);
+      }
+      if (context.timestamp) {
+        const date = new Date(context.timestamp);
+        envParts.push(`Current date: ${date.toISOString().split("T")[0]}`);
+      }
+      if (envParts.length > 0) {
+        parts.push(`## Environment
+${envParts.join(`
+`)}`);
+      }
+    }
+    if (context.toolNames && context.toolNames.length > 0) {
+      parts.push(`## Available Tools
+${context.toolNames.join(", ")}`);
+    }
+    if (context.skillNames && context.skillNames.length > 0) {
+      parts.push(`## Available Skills
+${context.skillNames.join(", ")}`);
+    }
+    if (context.user?.name) {
+      parts.push(`## User
+Name: ${context.user.name}`);
+    }
+    return parts.join(`
+
+`);
+  }
+  getPresetDescription(preset) {
+    switch (preset) {
+      case "claude_code":
+        return "Full-featured Claude Code agent behavior";
+      case "default":
+        return "Balanced preset for general use";
+      case "minimal":
+        return "Minimal instructions for simple tasks";
+      case "custom":
+        return "User-defined custom prompt";
+      default:
+        return `Preset: ${preset}`;
+    }
+  }
+}
+var defaultSystemPromptBuilder = new SystemPromptBuilderImpl;
+// src/prompt/claude-md.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join3, dirname as dirname2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+var CLAUDE_MD_FILENAME = "CLAUDE.md";
+var USER_CLAUDE_DIR = ".claude";
+
+class ClaudeMdLoaderImpl {
+  async loadProjectClaudeMd(cwd) {
+    const filePath = await this.findProjectClaudeMd(cwd);
+    if (!filePath) {
+      return;
+    }
+    return this.loadFile(filePath, "project");
+  }
+  async loadUserClaudeMd() {
+    const filePath = join3(homedir3(), USER_CLAUDE_DIR, CLAUDE_MD_FILENAME);
+    if (!existsSync3(filePath)) {
+      return;
+    }
+    return this.loadFile(filePath, "user");
+  }
+  async loadAll(config, cwd) {
+    const contents = [];
+    if (config.user !== false) {
+      const userMd = await this.loadUserClaudeMd();
+      if (userMd) {
+        contents.push(userMd);
+      }
+    }
+    if (config.project !== false && cwd) {
+      const projectMd = await this.loadProjectClaudeMd(cwd);
+      if (projectMd) {
+        contents.push(projectMd);
+      }
+    }
+    if (config.additionalPaths) {
+      for (const path of config.additionalPaths) {
+        if (existsSync3(path)) {
+          const content = await this.loadFile(path, "project");
+          if (content) {
+            contents.push(content);
+          }
+        }
+      }
+    }
+    return contents;
+  }
+  merge(contents) {
+    if (contents.length === 0) {
+      return "";
+    }
+    const parts = [];
+    for (const content of contents) {
+      if (content.raw.trim()) {
+        parts.push(`<!-- Source: ${content.filePath} (${content.type}) -->`);
+        parts.push(content.raw.trim());
+      }
+    }
+    return parts.join(`
+
+`);
+  }
+  async findProjectClaudeMd(startDir) {
+    let currentDir = startDir;
+    while (currentDir !== "/") {
+      const claudeMdPath = join3(currentDir, CLAUDE_MD_FILENAME);
+      if (existsSync3(claudeMdPath)) {
+        return claudeMdPath;
+      }
+      const gitPath = join3(currentDir, ".git");
+      if (existsSync3(gitPath)) {
+        break;
+      }
+      const parentDir = dirname2(currentDir);
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
+    }
+    return;
+  }
+  async loadFile(filePath, type) {
+    try {
+      const raw = await readFile2(filePath, "utf-8");
+      const sections = this.parseSections(raw);
+      return {
+        raw,
+        sections,
+        filePath,
+        type
+      };
+    } catch {
+      return;
+    }
+  }
+  parseSections(content) {
+    const sections = [];
+    const lines = content.split(`
+`);
+    let currentSection = null;
+    let contentLines = [];
+    for (const line of lines) {
+      const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+      if (headingMatch) {
+        if (currentSection) {
+          currentSection.content = contentLines.join(`
+`).trim();
+          sections.push(currentSection);
+        }
+        currentSection = {
+          heading: headingMatch[2],
+          level: headingMatch[1].length,
+          content: ""
+        };
+        contentLines = [];
+      } else if (currentSection) {
+        contentLines.push(line);
+      }
+    }
+    if (currentSection) {
+      currentSection.content = contentLines.join(`
+`).trim();
+      sections.push(currentSection);
+    }
+    return sections;
+  }
+}
+var defaultClaudeMdLoader = new ClaudeMdLoaderImpl;
+// src/session/session.ts
+class SessionImpl {
+  id;
+  config;
+  _state;
+  provider;
+  tools;
+  emitter;
+  pendingMessage = null;
+  isReceiving = false;
+  abortController = null;
+  closed = false;
+  hooksManager = null;
+  maxTurns;
+  constructor(id, config, provider, state) {
+    this.id = id;
+    this.config = config;
+    this.provider = provider;
+    this.tools = new Map;
+    this.emitter = new TypedEventEmitter;
+    this._state = {
+      id,
+      messages: state?.messages ?? [],
+      usage: state?.usage ?? {
+        input_tokens: 0,
+        output_tokens: 0
+      },
+      metadata: state?.metadata ?? {},
+      createdAt: state?.createdAt ?? Date.now(),
+      updatedAt: Date.now(),
+      parentId: state?.parentId
+    };
+    this.maxTurns = config.maxTurns;
+    if (config.tools) {
+      for (const tool of config.tools) {
+        this.tools.set(tool.name, tool);
+      }
+    }
+    if (config.settingSources && config.settingSources.length > 0) {
+      const skillTool2 = createSkillTool({
+        settingSources: config.settingSources,
+        cwd: config.cwd
+      });
+      this.tools.set(skillTool2.name, skillTool2);
+    }
+    this.applyAllowedToolsFilter();
+    if (config.hooks) {
+      this.hooksManager = new HooksManager(config.hooks, id, config.cwd ?? process.cwd());
+    }
+  }
+  get state() {
+    return { ...this._state };
+  }
+  async send(message, options) {
+    if (this.closed) {
+      throw new Error("Session is closed");
+    }
+    if (this.isReceiving) {
+      throw new Error("Cannot send while receiving");
+    }
+    const normalizedMessage = typeof message === "string" ? {
+      id: generateMessageId(),
+      role: "user",
+      content: message
+    } : {
+      ...message,
+      id: message.id ?? generateMessageId()
+    };
+    this.pendingMessage = normalizedMessage;
+    this._state.messages.push(normalizedMessage);
+    this._state.updatedAt = Date.now();
+  }
+  async* receive(options) {
+    if (this.closed) {
+      throw new Error("Session is closed");
+    }
+    if (this.isReceiving) {
+      throw new Error("Already receiving");
+    }
+    if (!this.pendingMessage && !options?.continue) {
+      throw new Error("No pending message to process");
+    }
+    if (this.maxTurns !== undefined) {
+      const assistantCount = this._state.messages.filter((m) => m.role === "assistant").length;
+      if (assistantCount >= this.maxTurns) {
+        this.pendingMessage = null;
+        yield {
+          type: "stop",
+          stop_reason: "max_turns",
+          usage: this._state.usage
+        };
+        return;
+      }
+    }
+    this.isReceiving = true;
+    this.abortController = new AbortController;
+    const abortSignal = options?.abortSignal ? this.combineAbortSignals(options.abortSignal, this.abortController.signal) : this.abortController.signal;
+    try {
+      const request = await this.buildRequest();
+      const streamOptions = {
+        onText: (text) => {
+          const event = { type: "text", text };
+          this.emitter.emit("text", event);
+        },
+        onToolUse: (toolUse) => {
+          const event = {
+            type: "tool_use",
+            id: toolUse.id,
+            name: toolUse.name,
+            input: toolUse.input
+          };
+          this.emitter.emit("tool_use", event);
+        }
+      };
+      const stream = await this.provider.stream(request, streamOptions);
+      const content = [];
+      let currentText = "";
+      let currentToolUse = null;
+      let stopReason = "end_turn";
+      let usage = { input_tokens: 0, output_tokens: 0 };
+      for await (const event of stream) {
+        if (abortSignal.aborted) {
+          break;
+        }
+        if (event.type === "content_block_start") {
+          if (event.content_block.type === "text") {
+            currentText = "";
+          } else if (event.content_block.type === "tool_use") {
+            currentToolUse = {
+              id: event.content_block.id,
+              name: event.content_block.name,
+              input: ""
+            };
+          }
+        } else if (event.type === "content_block_delta") {
+          if (event.delta.type === "text_delta" && event.delta.text) {
+            currentText += event.delta.text;
+            yield { type: "text", text: event.delta.text };
+          } else if (event.delta.type === "input_json_delta" && currentToolUse) {
+            currentToolUse.input += event.delta.partial_json || "";
+          }
+        } else if (event.type === "content_block_stop") {
+          if (currentText) {
+            content.push({ type: "text", text: currentText });
+            currentText = "";
+          }
+          if (currentToolUse) {
+            let parsedInput = {};
+            try {
+              parsedInput = JSON.parse(currentToolUse.input || "{}");
+            } catch {}
+            yield {
+              type: "tool_use",
+              id: currentToolUse.id,
+              name: currentToolUse.name,
+              input: parsedInput
+            };
+            content.push({
+              type: "tool_use",
+              id: currentToolUse.id,
+              name: currentToolUse.name,
+              input: parsedInput
+            });
+            currentToolUse = null;
+          }
+        } else if (event.type === "message_delta") {
+          stopReason = event.delta?.stop_reason;
+          if (event.usage?.output_tokens !== undefined) {
+            usage = {
+              ...usage,
+              output_tokens: event.usage.output_tokens
+            };
+          }
+          if (event.usage?.input_tokens !== undefined) {
+            usage = {
+              ...usage,
+              input_tokens: event.usage.input_tokens
+            };
+          }
+        } else if (event.type === "message_start") {
+          if (event.message?.usage?.input_tokens !== undefined) {
+            usage = {
+              ...usage,
+              input_tokens: event.message.usage.input_tokens
+            };
+          }
+        } else if (event.type === "message_stop") {}
+      }
+      if (currentText) {
+        content.push({ type: "text", text: currentText });
+        currentText = "";
+      }
+      if (currentToolUse) {
+        let parsedInput = {};
+        try {
+          parsedInput = JSON.parse(currentToolUse.input || "{}");
+        } catch {}
+        yield {
+          type: "tool_use",
+          id: currentToolUse.id,
+          name: currentToolUse.name,
+          input: parsedInput
+        };
+        content.push({
+          type: "tool_use",
+          id: currentToolUse.id,
+          name: currentToolUse.name,
+          input: parsedInput
+        });
+        currentToolUse = null;
+      }
+      const assistantContent = content.filter((b) => b.type !== "tool_result");
+      const assistantMessage = {
+        id: generateMessageId(),
+        role: "assistant",
+        content: assistantContent,
+        stop_reason: stopReason,
+        usage
+      };
+      this._state.messages.push(assistantMessage);
+      this._state.usage = {
+        input_tokens: this._state.usage.input_tokens + usage.input_tokens,
+        output_tokens: this._state.usage.output_tokens + usage.output_tokens
+      };
+      this._state.updatedAt = Date.now();
+      yield { type: "message", message: assistantMessage };
+      const toolUseBlocks = assistantContent.filter((b) => b.type === "tool_use");
+      if (toolUseBlocks.length > 0) {
+        if (this.maxTurns !== undefined) {
+          const assistantCountNow = this._state.messages.filter((m) => m.role === "assistant").length;
+          if (assistantCountNow >= this.maxTurns) {
+            yield {
+              type: "stop",
+              stop_reason: "max_turns",
+              usage: this._state.usage
+            };
+            this.pendingMessage = null;
+            return;
+          }
+        }
+        const toolResults = [];
+        for (const block of toolUseBlocks) {
+          if (block.type === "tool_use") {
+            const toolResult = await this.executeToolCall(block, abortSignal);
+            yield toolResult;
+            if (toolResult.type === "tool_result") {
+              toolResults.push({
+                type: "tool_result",
+                tool_use_id: block.id,
+                content: typeof toolResult.content === "string" ? toolResult.content : "",
+                is_error: toolResult.is_error
+              });
+            }
+          }
+        }
+        const toolResultMessage = {
+          id: generateMessageId(),
+          role: "user",
+          content: toolResults
+        };
+        this._state.messages.push(toolResultMessage);
+        for await (const event of this.continueConversation(abortSignal)) {
+          yield event;
+        }
+      } else {
+        yield {
+          type: "stop",
+          stop_reason: stopReason,
+          usage: this._state.usage
+        };
+      }
+      this.pendingMessage = null;
+    } catch (error) {
+      const errorEvent = {
+        type: "error",
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+      this.emitter.emit("error", errorEvent);
+      yield errorEvent;
+    } finally {
+      this.isReceiving = false;
+      this.abortController = null;
+    }
+  }
+  getMessages() {
+    return [...this._state.messages];
+  }
+  getUsage() {
+    return { ...this._state.usage };
+  }
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.abortController?.abort();
+    this.emitter.removeAllListeners();
+    this.tools.clear();
+    this.pendingMessage = null;
+    this.closed = true;
+  }
+  async[Symbol.asyncDispose]() {
+    await this.close();
+  }
+  async buildRequest() {
+    const messages = this._state.messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content
+    }));
+    const tools = Array.from(this.tools.values());
+    const model = typeof this.config.model === "string" ? this.config.model : this.config.model?.model ?? "claude-sonnet-4-20250514";
+    const maxTokens = typeof this.config.model === "string" ? 4096 : this.config.model?.maxTokens ?? 4096;
+    const systemPrompt = await this.buildSystemPrompt(tools.map((t) => t.name));
+    return {
+      messages,
+      tools,
+      config: {
+        ...(typeof this.config.model === "string" ? {} : this.config.model) ?? {},
+        model,
+        maxTokens
+      },
+      systemPrompt,
+      abortSignal: this.abortController?.signal
+    };
+  }
+  async executeToolCall(block, abortSignal) {
+    let toolInput = block.input;
+    let systemMessage;
+    if (this.hooksManager) {
+      const preResult = await this.hooksManager.runPreToolUse(block.name, block.input, block.id, abortSignal);
+      if (!preResult.continue) {
+        return {
+          type: "tool_result",
+          tool_use_id: block.id,
+          content: preResult.stopReason ?? "Execution stopped by hook",
+          is_error: true,
+          _hookSystemMessage: preResult.systemMessage
+        };
+      }
+      if (!preResult.allowed) {
+        return {
+          type: "tool_result",
+          tool_use_id: block.id,
+          content: preResult.reason ?? `Tool "${block.name}" was denied by hook`,
+          is_error: true,
+          _hookSystemMessage: preResult.systemMessage
+        };
+      }
+      if (preResult.updatedInput) {
+        toolInput = preResult.updatedInput;
+      }
+      systemMessage = preResult.systemMessage;
+    }
+    const tool = this.tools.get(block.name);
+    if (!tool) {
+      return {
+        type: "tool_result",
+        tool_use_id: block.id,
+        content: `Error: Tool "${block.name}" not found`,
+        is_error: true,
+        _hookSystemMessage: systemMessage
+      };
+    }
+    const context = {
+      sessionId: this.id,
+      abortSignal
+    };
+    let result;
+    let toolResponse;
+    try {
+      const toolResult = await tool.execute(toolInput, context);
+      const content = typeof toolResult.content === "string" ? toolResult.content : JSON.stringify(toolResult.content);
+      toolResponse = toolResult;
+      result = {
+        type: "tool_result",
+        tool_use_id: block.id,
+        content,
+        is_error: toolResult.isError
+      };
+    } catch (error) {
+      toolResponse = { error: error instanceof Error ? error.message : String(error) };
+      result = {
+        type: "tool_result",
+        tool_use_id: block.id,
+        content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+        is_error: true
+      };
+    }
+    if (this.hooksManager) {
+      const postResult = await this.hooksManager.runPostToolUse(block.name, toolInput, toolResponse, block.id, abortSignal);
+      if (postResult.systemMessage) {
+        systemMessage = postResult.systemMessage;
+      }
+      if (postResult.additionalContext && result.type === "tool_result") {
+        result = {
+          ...result,
+          content: `${result.content}
+
+${postResult.additionalContext}`
+        };
+      }
+    }
+    return {
+      ...result,
+      _hookSystemMessage: systemMessage
+    };
+  }
+  async* continueConversation(abortSignal) {
+    if (this.maxTurns !== undefined) {
+      const assistantCount = this._state.messages.filter((m) => m.role === "assistant").length;
+      if (assistantCount >= this.maxTurns) {
+        yield {
+          type: "stop",
+          stop_reason: "max_turns",
+          usage: this._state.usage
+        };
+        return;
+      }
+    }
+    const request = await this.buildRequest();
+    const stream = await this.provider.stream(request, {});
+    const content = [];
+    let currentText = "";
+    let currentToolUse = null;
+    let stopReason = "end_turn";
+    let usage = { input_tokens: 0, output_tokens: 0 };
+    for await (const event of stream) {
+      if (abortSignal.aborted) {
+        break;
+      }
+      if (event.type === "content_block_start") {
+        if (event.content_block.type === "text") {
+          currentText = "";
+        } else if (event.content_block.type === "tool_use") {
+          currentToolUse = {
+            id: event.content_block.id,
+            name: event.content_block.name,
+            input: ""
+          };
+        }
+      } else if (event.type === "content_block_delta") {
+        if (event.delta.type === "text_delta" && event.delta.text) {
+          currentText += event.delta.text;
+          yield { type: "text", text: event.delta.text };
+        } else if (event.delta.type === "input_json_delta" && currentToolUse) {
+          currentToolUse.input += event.delta.partial_json || "";
+        }
+      } else if (event.type === "content_block_stop") {
+        if (currentText) {
+          content.push({ type: "text", text: currentText });
+          currentText = "";
+        }
+        if (currentToolUse) {
+          let parsedInput = {};
+          try {
+            parsedInput = JSON.parse(currentToolUse.input || "{}");
+          } catch {}
+          yield {
+            type: "tool_use",
+            id: currentToolUse.id,
+            name: currentToolUse.name,
+            input: parsedInput
+          };
+          content.push({
+            type: "tool_use",
+            id: currentToolUse.id,
+            name: currentToolUse.name,
+            input: parsedInput
+          });
+          currentToolUse = null;
+        }
+      } else if (event.type === "message_delta") {
+        stopReason = event.delta?.stop_reason;
+        if (event.usage?.output_tokens !== undefined) {
+          usage = { ...usage, output_tokens: event.usage.output_tokens };
+        }
+        if (event.usage?.input_tokens !== undefined) {
+          usage = { ...usage, input_tokens: event.usage.input_tokens };
+        }
+      } else if (event.type === "message_start") {
+        if (event.message?.usage?.input_tokens !== undefined) {
+          usage = { ...usage, input_tokens: event.message.usage.input_tokens };
+        }
+      }
+    }
+    if (currentText) {
+      content.push({ type: "text", text: currentText });
+      currentText = "";
+    }
+    if (currentToolUse) {
+      let parsedInput = {};
+      try {
+        parsedInput = JSON.parse(currentToolUse.input || "{}");
+      } catch {}
+      yield {
+        type: "tool_use",
+        id: currentToolUse.id,
+        name: currentToolUse.name,
+        input: parsedInput
+      };
+      content.push({
+        type: "tool_use",
+        id: currentToolUse.id,
+        name: currentToolUse.name,
+        input: parsedInput
+      });
+      currentToolUse = null;
+    }
+    const assistantMessage = {
+      id: generateMessageId(),
+      role: "assistant",
+      content,
+      stop_reason: stopReason,
+      usage
+    };
+    this._state.messages.push(assistantMessage);
+    this._state.usage = {
+      input_tokens: this._state.usage.input_tokens + usage.input_tokens,
+      output_tokens: this._state.usage.output_tokens + usage.output_tokens
+    };
+    this._state.updatedAt = Date.now();
+    yield { type: "message", message: assistantMessage };
+    const toolUseBlocks = content.filter((b) => b.type === "tool_use");
+    if (toolUseBlocks.length > 0) {
+      const toolResults = [];
+      for (const block of toolUseBlocks) {
+        if (block.type === "tool_use") {
+          const toolResult = await this.executeToolCall(block, abortSignal);
+          yield toolResult;
+          if (toolResult.type === "tool_result") {
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: block.id,
+              content: typeof toolResult.content === "string" ? toolResult.content : "",
+              is_error: toolResult.is_error
+            });
+          }
+        }
+      }
+      const toolResultMessage = {
+        id: generateMessageId(),
+        role: "user",
+        content: toolResults
+      };
+      this._state.messages.push(toolResultMessage);
+      for await (const event of this.continueConversation(abortSignal)) {
+        yield event;
+      }
+    } else {
+      yield {
+        type: "stop",
+        stop_reason: stopReason,
+        usage: this._state.usage
+      };
+    }
+  }
+  combineAbortSignals(...signals) {
+    const controller = new AbortController;
+    for (const signal of signals) {
+      if (signal.aborted) {
+        controller.abort();
+        break;
+      }
+      signal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    return controller.signal;
+  }
+  applyAllowedToolsFilter() {
+    const spec = this.config.allowedTools;
+    if (!spec)
+      return;
+    const patternsFromList = (list) => (list ?? []).map((p) => p.trim()).filter(Boolean);
+    const wildcardToRegex = (pattern) => {
+      const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+      return new RegExp(`^${escaped}$`);
+    };
+    const matchesAny = (name, patterns) => patterns.some((p) => wildcardToRegex(p).test(name));
+    let allow = null;
+    let deny = [];
+    if (Array.isArray(spec)) {
+      allow = patternsFromList(spec);
+    } else {
+      allow = spec.allow ? patternsFromList(spec.allow) : null;
+      deny = patternsFromList(spec.deny);
+    }
+    for (const name of Array.from(this.tools.keys())) {
+      if (deny.length && matchesAny(name, deny)) {
+        this.tools.delete(name);
+        continue;
+      }
+      if (allow && allow.length && !matchesAny(name, allow)) {
+        this.tools.delete(name);
+      }
+    }
+  }
+  async buildSystemPrompt(toolNames) {
+    if (typeof this.config.systemPrompt === "string") {
+      return this.config.systemPrompt;
+    }
+    if (!this.config.systemPrompt) {
+      return;
+    }
+    const cwd = this.config.cwd ?? process.cwd();
+    const built = await defaultSystemPromptBuilder.build(this.config.systemPrompt, {
+      cwd,
+      toolNames,
+      timestamp: Date.now(),
+      environment: {
+        platform: process.platform,
+        shell: process.env.SHELL
+      }
+    });
+    if (!this.config.systemPrompt.settingSources) {
+      return built || undefined;
+    }
+    const contents = await defaultClaudeMdLoader.loadAll(this.config.systemPrompt.settingSources, cwd);
+    const merged = defaultClaudeMdLoader.merge(contents).trim();
+    const parts = [built?.trim(), merged].filter((p) => p && p.length > 0);
+    return parts.length ? parts.join(`
+
+`) : undefined;
+  }
+}
+function createSessionImpl(config, provider, state) {
+  const id = state?.id ?? generateSessionId();
+  return new SessionImpl(id, config, provider, state);
+}
+
+// src/session/storage.ts
+class MemorySessionStorage {
+  sessions = new Map;
+  async save(state) {
+    const cloned = JSON.parse(JSON.stringify(state));
+    this.sessions.set(state.id, cloned);
+  }
+  async load(sessionId) {
+    const state = this.sessions.get(sessionId);
+    if (!state) {
+      return;
+    }
+    return JSON.parse(JSON.stringify(state));
+  }
+  async delete(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  async list() {
+    return Array.from(this.sessions.keys());
+  }
+  clear() {
+    this.sessions.clear();
+  }
+  size() {
+    return this.sessions.size;
+  }
+}
+
+// src/session/manager.ts
+class SessionManagerImpl {
+  sessions = new Map;
+  storage;
+  provider;
+  defaultConfig;
+  constructor(options) {
+    this.storage = options.storage ?? new MemorySessionStorage;
+    this.provider = options.provider;
+    this.defaultConfig = options.defaultConfig ?? {};
+  }
+  async create(config) {
+    const mergedConfig = {
+      ...this.defaultConfig,
+      ...config
+    };
+    if (config?.resume) {
+      return this.resume(config.resume, mergedConfig);
+    }
+    if (config?.fork) {
+      return this.fork(config.fork, mergedConfig);
+    }
+    const session = createSessionImpl(mergedConfig, this.provider);
+    this.sessions.set(session.id, session);
+    await this.storage.save(session.state);
+    return session;
+  }
+  async resume(sessionId, config) {
+    const existingSession = this.sessions.get(sessionId);
+    if (existingSession) {
+      return existingSession;
+    }
+    const state = await this.storage.load(sessionId);
+    if (!state) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const mergedConfig = {
+      ...this.defaultConfig,
+      ...config
+    };
+    const session = createSessionImpl(mergedConfig, this.provider, state);
+    this.sessions.set(session.id, session);
+    return session;
+  }
+  async fork(sessionId, config) {
+    const originalState = await this.storage.load(sessionId);
+    if (!originalState) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const mergedConfig = {
+      ...this.defaultConfig,
+      ...config
+    };
+    const newId = generateSessionId();
+    const forkedState = {
+      ...originalState,
+      id: newId,
+      parentId: sessionId,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      messages: JSON.parse(JSON.stringify(originalState.messages))
+    };
+    const session = createSessionImpl(mergedConfig, this.provider, forkedState);
+    this.sessions.set(session.id, session);
+    await this.storage.save(session.state);
+    return session;
+  }
+  get(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  list() {
+    return Array.from(this.sessions.keys());
+  }
+  async close(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return;
+    }
+    await this.storage.save(session.state);
+    await session.close();
+    this.sessions.delete(sessionId);
+  }
+  async closeAll() {
+    const sessionIds = Array.from(this.sessions.keys());
+    await Promise.all(sessionIds.map((id) => this.close(id)));
+  }
+  getStorage() {
+    return this.storage;
+  }
+  getProvider() {
+    return this.provider;
+  }
+}
+
+// src/llm/anthropic.ts
+class AnthropicProvider {
+  id = "anthropic";
+  name = "Anthropic";
+  supportedModels = [
+    /^claude-sonnet-4/,
+    /^claude-opus-4/,
+    /^claude-3/,
+    /^claude-2/,
+    /^claude-instant/
+  ];
+  config;
+  constructor(config = {}) {
+    const apiKey = config.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new Error("Anthropic API key is required. Set ANTHROPIC_API_KEY environment variable or pass apiKey in config.");
+    }
+    this.config = {
+      apiKey,
+      baseUrl: config.baseUrl ?? process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com",
+      apiVersion: config.apiVersion ?? "2023-06-01",
+      defaultMaxTokens: config.defaultMaxTokens ?? 4096
+    };
+  }
+  supportsModel(model) {
+    return this.supportedModels.some((pattern) => pattern.test(model));
+  }
+  async complete(request) {
+    const anthropicRequest = this.buildRequest(request, false);
+    const response = await fetch(`${this.config.baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(anthropicRequest),
+      signal: request.abortSignal
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${response.status} ${error}`);
+    }
+    const data = await response.json();
+    return this.convertResponse(data);
+  }
+  async stream(request, options) {
+    const anthropicRequest = this.buildRequest(request, true);
+    const response = await fetch(`${this.config.baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(anthropicRequest),
+      signal: request.abortSignal
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${response.status} ${error}`);
+    }
+    return this.createStreamIterator(response.body, options);
+  }
+  buildRequest(request, stream) {
+    const messages = this.convertMessages(request.messages);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+    return {
+      model: request.config.model,
+      messages,
+      system: request.systemPrompt,
+      max_tokens: request.config.maxTokens ?? this.config.defaultMaxTokens,
+      temperature: request.config.temperature,
+      top_p: request.config.topP,
+      top_k: request.config.topK,
+      stop_sequences: request.config.stopSequences,
+      stream,
+      tools
+    };
+  }
+  convertMessages(messages) {
+    return messages.filter((msg) => msg.role !== "system").map((msg) => {
+      if (typeof msg.content === "string") {
+        return {
+          role: msg.role,
+          content: msg.content
+        };
+      }
+      const content = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          content.push({ type: "text", text: block.text });
+        } else if (block.type === "image") {
+          if (block.source.type === "base64") {
+            content.push({
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: block.source.media_type,
+                data: block.source.data
+              }
+            });
+          }
+        } else if (block.type === "tool_use") {
+          content.push({
+            type: "tool_use",
+            id: block.id,
+            name: block.name,
+            input: block.input
+          });
+        } else if (block.type === "tool_result") {
+          content.push({
+            type: "tool_result",
+            tool_use_id: block.tool_use_id,
+            content: typeof block.content === "string" ? block.content : undefined,
+            is_error: block.is_error
+          });
+        }
+      }
+      return {
+        role: msg.role,
+        content
+      };
+    });
+  }
+  convertTools(tools) {
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.inputSchema
+    }));
+  }
+  convertResponse(data) {
+    const content = data.content.map((block) => {
+      if (block.type === "text") {
+        return { type: "text", text: block.text };
+      }
+      if (block.type === "tool_use") {
+        return {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+      }
+      return { type: "text", text: "" };
+    });
+    return {
+      id: data.id,
+      model: data.model,
+      content,
+      stopReason: data.stop_reason,
+      stopSequence: data.stop_sequence,
+      usage: {
+        input_tokens: data.usage.input_tokens,
+        output_tokens: data.usage.output_tokens,
+        cache_creation_input_tokens: data.usage.cache_creation_input_tokens,
+        cache_read_input_tokens: data.usage.cache_read_input_tokens
+      }
+    };
+  }
+  createStreamIterator(body, options) {
+    const self = this;
+    return {
+      async* [Symbol.asyncIterator]() {
+        const reader = body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                const data = line.slice(6).trim();
+                if (!data || data === "[DONE]")
+                  continue;
+                try {
+                  const event = JSON.parse(data);
+                  const streamEvent = self.parseStreamEvent(event);
+                  if (streamEvent) {
+                    if (streamEvent.type === "content_block_delta" && streamEvent.delta.type === "text_delta") {
+                      options?.onText?.(streamEvent.delta.text);
+                    }
+                    options?.onEvent?.(streamEvent);
+                    yield streamEvent;
+                  }
+                } catch {}
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+    };
+  }
+  parseStreamEvent(event) {
+    switch (event.type) {
+      case "message_start":
+        return {
+          type: "message_start",
+          message: {
+            id: event.message.id,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model: event.message.model,
+            stop_reason: null,
+            stop_sequence: null,
+            usage: event.message.usage
+          }
+        };
+      case "content_block_start":
+        return {
+          type: "content_block_start",
+          index: event.index,
+          content_block: event.content_block
+        };
+      case "content_block_delta":
+        return {
+          type: "content_block_delta",
+          index: event.index,
+          delta: event.delta
+        };
+      case "content_block_stop":
+        return {
+          type: "content_block_stop",
+          index: event.index
+        };
+      case "message_delta":
+        return {
+          type: "message_delta",
+          delta: {
+            stop_reason: event.delta.stop_reason,
+            stop_sequence: event.delta.stop_sequence
+          },
+          usage: {
+            output_tokens: event.usage.output_tokens
+          }
+        };
+      case "message_stop":
+        return {
+          type: "message_stop"
+        };
+      case "error":
+        return {
+          type: "error",
+          error: {
+            type: event.error.type,
+            message: event.error.message
+          }
+        };
+      default:
+        return null;
+    }
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "x-api-key": this.config.apiKey,
+      "anthropic-version": this.config.apiVersion
+    };
+  }
+}
+
+// src/llm/openai.ts
+class OpenAIProvider {
+  id = "openai";
+  name = "OpenAI";
+  supportedModels = [
+    /^gpt-4/,
+    /^gpt-3\.5/,
+    /^o1/,
+    /^chatgpt/
+  ];
+  config;
+  constructor(config = {}) {
+    const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass apiKey in config.");
+    }
+    this.config = {
+      apiKey,
+      baseUrl: config.baseUrl ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1",
+      organization: config.organization,
+      defaultMaxTokens: config.defaultMaxTokens ?? 4096
+    };
+  }
+  supportsModel(model) {
+    return this.supportedModels.some((pattern) => pattern.test(model));
+  }
+  async complete(request) {
+    const openaiRequest = this.buildRequest(request, false);
+    const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(openaiRequest),
+      signal: request.abortSignal
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} ${error}`);
+    }
+    const data = await response.json();
+    return this.convertResponse(data);
+  }
+  async stream(request, options) {
+    const openaiRequest = this.buildRequest(request, true);
+    const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(openaiRequest),
+      signal: request.abortSignal
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} ${error}`);
+    }
+    return this.createStreamIterator(response.body, options);
+  }
+  buildRequest(request, stream) {
+    const messages = this.convertMessages(request.messages, request.systemPrompt);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+    return {
+      model: request.config.model,
+      messages,
+      max_tokens: request.config.maxTokens ?? this.config.defaultMaxTokens,
+      temperature: request.config.temperature,
+      top_p: request.config.topP,
+      stop: request.config.stopSequences,
+      stream,
+      stream_options: stream ? { include_usage: true } : undefined,
+      tools
+    };
+  }
+  convertMessages(messages, systemPrompt) {
+    const result = [];
+    if (systemPrompt) {
+      result.push({
+        role: "system",
+        content: systemPrompt
+      });
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        result.push({
+          role: "system",
+          content: typeof msg.content === "string" ? msg.content : ""
+        });
+        continue;
+      }
+      if (typeof msg.content === "string") {
+        result.push({
+          role: msg.role,
+          content: msg.content
+        });
+        continue;
+      }
+      const content = [];
+      const toolCalls = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          content.push({ type: "text", text: block.text });
+        } else if (block.type === "image") {
+          if (block.source.type === "base64") {
+            content.push({
+              type: "image_url",
+              image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
+            });
+          } else if (block.source.type === "url") {
+            content.push({
+              type: "image_url",
+              image_url: { url: block.source.url }
+            });
+          }
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            type: "function",
+            function: {
+              name: block.name,
+              arguments: JSON.stringify(block.input)
+            }
+          });
+        } else if (block.type === "tool_result") {
+          result.push({
+            role: "tool",
+            tool_call_id: block.tool_use_id,
+            content: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+          });
+          continue;
+        }
+      }
+      if (content.length > 0 || toolCalls.length > 0) {
+        const message = {
+          role: msg.role,
+          content: content.length === 1 && content[0].type === "text" ? content[0].text : content
+        };
+        if (toolCalls.length > 0) {
+          message.tool_calls = toolCalls;
+        }
+        result.push(message);
+      }
+    }
+    return result;
+  }
+  convertTools(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema
+      }
+    }));
+  }
+  convertResponse(data) {
+    const choice = data.choices[0];
+    const content = [];
+    if (choice.message.content) {
+      content.push({ type: "text", text: choice.message.content });
+    }
+    if (choice.message.tool_calls) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: "tool_use",
+          id: toolCall.id,
+          name: toolCall.function.name,
+          input: JSON.parse(toolCall.function.arguments)
+        });
+      }
+    }
+    return {
+      id: data.id,
+      model: data.model,
+      content,
+      stopReason: this.convertStopReason(choice.finish_reason),
+      stopSequence: null,
+      usage: {
+        input_tokens: data.usage.prompt_tokens,
+        output_tokens: data.usage.completion_tokens
+      }
+    };
+  }
+  convertStopReason(reason) {
+    switch (reason) {
+      case "stop":
+        return "end_turn";
+      case "length":
+        return "max_tokens";
+      case "tool_calls":
+        return "tool_use";
+      case "content_filter":
+        return "stop_sequence";
+      default:
+        return "end_turn";
+    }
+  }
+  createStreamIterator(body, options) {
+    const self = this;
+    return {
+      async* [Symbol.asyncIterator]() {
+        const reader = body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        const toolCalls = new Map;
+        let emittedMessageStart = false;
+        let textBlockStarted = false;
+        let finished = false;
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                const data = line.slice(6).trim();
+                if (!data)
+                  continue;
+                if (data === "[DONE]") {
+                  if (!finished) {
+                    const stopEvent = { type: "message_stop" };
+                    options?.onEvent?.(stopEvent);
+                    yield stopEvent;
+                  }
+                  finished = true;
+                  continue;
+                }
+                try {
+                  const json = JSON.parse(data);
+                  const delta = json.choices?.[0]?.delta;
+                  const finishReason = json.choices?.[0]?.finish_reason;
+                  if (!emittedMessageStart) {
+                    emittedMessageStart = true;
+                    const startEvent = {
+                      type: "message_start",
+                      message: {
+                        id: json.id ?? "",
+                        type: "message",
+                        role: "assistant",
+                        content: [],
+                        model: json.model ?? "",
+                        stop_reason: null,
+                        stop_sequence: null,
+                        usage: { input_tokens: 0, output_tokens: 0 }
+                      }
+                    };
+                    options?.onEvent?.(startEvent);
+                    yield startEvent;
+                  }
+                  if (delta?.content) {
+                    if (!textBlockStarted) {
+                      textBlockStarted = true;
+                      const startText = {
+                        type: "content_block_start",
+                        index: 0,
+                        content_block: { type: "text", text: "" }
+                      };
+                      options?.onEvent?.(startText);
+                      yield startText;
+                    }
+                    const textEvent = {
+                      type: "content_block_delta",
+                      index: 0,
+                      delta: {
+                        type: "text_delta",
+                        text: delta.content
+                      }
+                    };
+                    options?.onText?.(delta.content);
+                    options?.onEvent?.(textEvent);
+                    yield textEvent;
+                  }
+                  if (delta?.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                      const index = tc.index;
+                      const blockIndex = 1 + index;
+                      if (!toolCalls.has(index)) {
+                        toolCalls.set(index, {
+                          id: tc.id || "",
+                          name: tc.function?.name || "",
+                          arguments: tc.function?.arguments || ""
+                        });
+                        const startEvent = {
+                          type: "content_block_start",
+                          index: blockIndex,
+                          content_block: {
+                            type: "tool_use",
+                            id: tc.id || "",
+                            name: tc.function?.name || "",
+                            input: {}
+                          }
+                        };
+                        options?.onEvent?.(startEvent);
+                        yield startEvent;
+                      } else {
+                        const existing = toolCalls.get(index);
+                        if (tc.id)
+                          existing.id = tc.id;
+                        if (tc.function?.name)
+                          existing.name = tc.function.name;
+                        if (tc.function?.arguments)
+                          existing.arguments += tc.function.arguments;
+                      }
+                      if (tc.function?.arguments) {
+                        const deltaEvent = {
+                          type: "content_block_delta",
+                          index: blockIndex,
+                          delta: {
+                            type: "input_json_delta",
+                            partial_json: tc.function.arguments
+                          }
+                        };
+                        options?.onEvent?.(deltaEvent);
+                        yield deltaEvent;
+                      }
+                    }
+                  }
+                  if (finishReason) {
+                    finished = true;
+                    if (textBlockStarted) {
+                      const stopText = { type: "content_block_stop", index: 0 };
+                      options?.onEvent?.(stopText);
+                      yield stopText;
+                    }
+                    for (const [index, tc] of toolCalls) {
+                      const stopEvent2 = {
+                        type: "content_block_stop",
+                        index: 1 + index
+                      };
+                      options?.onEvent?.(stopEvent2);
+                      yield stopEvent2;
+                      try {
+                        const input = JSON.parse(tc.arguments);
+                        options?.onToolUse?.({ id: tc.id, name: tc.name, input });
+                      } catch {}
+                    }
+                    const messageDelta = {
+                      type: "message_delta",
+                      delta: {
+                        stop_reason: self.convertStopReason(finishReason),
+                        stop_sequence: null
+                      },
+                      usage: {
+                        output_tokens: json.usage?.completion_tokens ?? 0,
+                        input_tokens: json.usage?.prompt_tokens ?? 0
+                      }
+                    };
+                    options?.onEvent?.(messageDelta);
+                    yield messageDelta;
+                    const stopEvent = { type: "message_stop" };
+                    options?.onEvent?.(stopEvent);
+                    yield stopEvent;
+                  }
+                } catch {}
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+    };
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.config.apiKey}`
+    };
+    if (this.config.organization) {
+      headers["OpenAI-Organization"] = this.config.organization;
+    }
+    return headers;
+  }
+}
+
+// src/api.ts
+var globalManager = null;
+var defaultProvider = null;
+function getGlobalManager() {
+  if (!globalManager) {
+    if (!defaultProvider) {
+      if (process.env.ANTHROPIC_API_KEY) {
+        defaultProvider = new AnthropicProvider;
+      } else if (process.env.OPENAI_API_KEY) {
+        defaultProvider = new OpenAIProvider({
+          apiKey: process.env.OPENAI_API_KEY,
+          baseUrl: process.env.OPENAI_BASE_URL
+        });
+      } else {
+        throw new Error("No default provider set. Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable, " + "call setDefaultProvider(), or pass a provider in the options.");
+      }
+    }
+    globalManager = new SessionManagerImpl({
+      provider: defaultProvider,
+      storage: new MemorySessionStorage
+    });
+  }
+  return globalManager;
+}
+async function createSession(options) {
+  if (options?.provider) {
+    const customManager = new SessionManagerImpl({
+      provider: options.provider,
+      storage: new MemorySessionStorage
+    });
+    return customManager.create(options);
+  }
+  const manager = getGlobalManager();
+  return manager.create(options);
+}
+
+// src/tools/registry.ts
+class ToolRegistry {
+  tools = new Map;
+  register(tool) {
+    this.tools.set(tool.id, tool);
+  }
+  unregister(toolId) {
+    this.tools.delete(toolId);
+  }
+  get(toolId) {
+    return this.tools.get(toolId);
+  }
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  clear() {
+    this.tools.clear();
+  }
+  async execute(toolId, input, context) {
+    const tool = this.tools.get(toolId);
+    if (!tool) {
+      throw new Error(`Tool not found: ${toolId}`);
+    }
+    context.notify?.({ type: "start", toolId, toolName: tool.name, input });
+    try {
+      const result = await tool.execute(input, context);
+      context.notify?.({ type: "result", toolId, result });
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      context.notify?.({ type: "error", toolId, error: errorMessage });
+      throw error;
+    }
+  }
+}
+// src/tools/mcp.ts
+var MCP_NAMESPACE_SEPARATOR = "__";
+function createMCPToolName(serverName, toolName) {
+  return `mcp${MCP_NAMESPACE_SEPARATOR}${serverName}${MCP_NAMESPACE_SEPARATOR}${toolName}`;
+}
+function parseMCPToolName(namespacedName) {
+  const parts = namespacedName.split(MCP_NAMESPACE_SEPARATOR);
+  if (parts.length < 3 || parts[0] !== "mcp") {
+    return null;
+  }
+  return {
+    serverName: parts[1],
+    toolName: parts.slice(2).join(MCP_NAMESPACE_SEPARATOR)
+  };
+}
+function isMCPTool(name) {
+  return name.startsWith(`mcp${MCP_NAMESPACE_SEPARATOR}`);
+}
+
+class MCPServerWrapper {
+  server;
+  toolCache = new Map;
+  constructor(server) {
+    this.server = server;
+  }
+  get name() {
+    return this.server.name;
+  }
+  async getTools() {
+    const mcpTools = await this.server.listTools();
+    const tools = [];
+    for (const mcpTool of mcpTools) {
+      this.toolCache.set(mcpTool.name, mcpTool);
+      const namespacedName = createMCPToolName(this.server.name, mcpTool.name);
+      tools.push({
+        name: namespacedName,
+        description: `[MCP: ${this.server.name}] ${mcpTool.description}`,
+        inputSchema: mcpTool.inputSchema,
+        execute: async (input, _context) => {
+          return this.executeTool(mcpTool.name, input);
+        }
+      });
+    }
+    return tools;
+  }
+  async executeTool(toolName, input) {
+    const result = await this.server.callTool(toolName, input);
+    return this.convertResult(result);
+  }
+  async executeNamespacedTool(namespacedName, input) {
+    const parsed = parseMCPToolName(namespacedName);
+    if (!parsed || parsed.serverName !== this.server.name) {
+      throw new Error(`Tool ${namespacedName} is not from server ${this.server.name}`);
+    }
+    return this.executeTool(parsed.toolName, input);
+  }
+  async close() {
+    await this.server.close();
+    this.toolCache.clear();
+  }
+  convertResult(result) {
+    const content = result.content.map((item) => {
+      if (item.type === "text") {
+        return item.text;
+      }
+      if (item.type === "image") {
+        return `[Image: ${item.mimeType}]`;
+      }
+      return "";
+    }).join(`
+`);
+    return {
+      content,
+      isError: result.isError
+    };
+  }
+}
+class MCPServerManager {
+  servers = new Map;
+  async register(server) {
+    const wrapper = new MCPServerWrapper(server);
+    this.servers.set(server.name, wrapper);
+    return wrapper;
+  }
+  async unregister(serverName) {
+    const wrapper = this.servers.get(serverName);
+    if (wrapper) {
+      await wrapper.close();
+      this.servers.delete(serverName);
+    }
+  }
+  getServers() {
+    return Array.from(this.servers.values());
+  }
+  getServer(name) {
+    return this.servers.get(name);
+  }
+  async getAllTools() {
+    const allTools = [];
+    for (const wrapper of this.servers.values()) {
+      const tools = await wrapper.getTools();
+      allTools.push(...tools);
+    }
+    return allTools;
+  }
+  async closeAll() {
+    for (const wrapper of this.servers.values()) {
+      await wrapper.close();
+    }
+    this.servers.clear();
+  }
+}
+var defaultMCPServerManager = new MCPServerManager;
+// src/tools/manager.ts
+class ToolManager {
+  tools = new Map;
+  mcpServers = new Map;
+  allowedTools;
+  onToolEvent;
+  constructor(options = {}) {
+    this.allowedTools = options.allowedTools;
+    this.onToolEvent = options.onToolEvent;
+  }
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  unregister(name) {
+    this.tools.delete(name);
+  }
+  get(name) {
+    const tool = this.tools.get(name);
+    if (tool) {
+      return tool;
+    }
+    if (isMCPTool(name)) {
+      const parsed = parseMCPToolName(name);
+      if (parsed) {
+        const wrapper = this.mcpServers.get(parsed.serverName);
+        if (wrapper) {
+          return this.createMCPToolProxy(name, wrapper);
+        }
+      }
+    }
+    return;
+  }
+  getAll() {
+    const allTools = [];
+    for (const tool of this.tools.values()) {
+      if (this.isToolAllowed(tool)) {
+        allTools.push(tool);
+      }
+    }
+    for (const wrapper of this.mcpServers.values()) {
+      const mcpTools = Array.from(this.tools.values()).filter((t) => isMCPTool(t.name) && t.name.includes(`__${wrapper.name}__`));
+    }
+    return allTools;
+  }
+  has(name) {
+    return this.get(name) !== undefined;
+  }
+  clear() {
+    this.tools.clear();
+  }
+  async registerMCPServer(server) {
+    const wrapper = new MCPServerWrapper(server);
+    this.mcpServers.set(server.name, wrapper);
+    const tools = await wrapper.getTools();
+    for (const tool of tools) {
+      this.tools.set(tool.name, tool);
+    }
+    return tools.length;
+  }
+  async unregisterMCPServer(serverName) {
+    const wrapper = this.mcpServers.get(serverName);
+    if (wrapper) {
+      for (const [name, _tool] of this.tools) {
+        if (isMCPTool(name)) {
+          const parsed = parseMCPToolName(name);
+          if (parsed?.serverName === serverName) {
+            this.tools.delete(name);
+          }
+        }
+      }
+      await wrapper.close();
+      this.mcpServers.delete(serverName);
+    }
+  }
+  getMCPServers() {
+    return Array.from(this.mcpServers.keys());
+  }
+  async execute(name, input, context) {
+    const tool = this.get(name);
+    if (!tool) {
+      throw new Error(`Tool not found: ${name}`);
+    }
+    if (!this.isToolAllowed(tool)) {
+      throw new Error(`Tool not allowed: ${name}`);
+    }
+    const toolId = generateId("tool");
+    this.emitEvent({
+      type: "tool_start",
+      toolId,
+      toolName: name,
+      input
+    });
+    try {
+      const result = await tool.execute(input, context);
+      this.emitEvent({
+        type: "tool_result",
+        toolId,
+        output: result
+      });
+      return result;
+    } catch (error) {
+      this.emitEvent({
+        type: "tool_error",
+        toolId,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      throw error;
+    }
+  }
+  setAllowedTools(allowedTools) {
+    this.allowedTools = allowedTools;
+  }
+  getFilteredTools() {
+    return this.getAll().filter((tool) => this.isToolAllowed(tool));
+  }
+  isToolAllowed(tool) {
+    if (!this.allowedTools) {
+      return true;
+    }
+    if (typeof this.allowedTools === "function") {
+      return this.allowedTools(tool);
+    }
+    for (const pattern of this.allowedTools) {
+      if (this.matchesPattern(tool.name, pattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  matchesPattern(name, pattern) {
+    if (pattern === "*") {
+      return true;
+    }
+    if (pattern.includes("*")) {
+      const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+      return new RegExp(`^${regexPattern}$`).test(name);
+    }
+    return name === pattern;
+  }
+  createMCPToolProxy(name, wrapper) {
+    const parsed = parseMCPToolName(name);
+    if (!parsed) {
+      return;
+    }
+    return {
+      name,
+      description: `MCP tool: ${parsed.toolName} from ${parsed.serverName}`,
+      inputSchema: { type: "object", properties: {} },
+      execute: async (input, _context) => {
+        return wrapper.executeNamespacedTool(name, input);
+      }
+    };
+  }
+  emitEvent(event) {
+    this.onToolEvent?.(event);
+  }
+}
+var defaultToolManager = new ToolManager;
+// src/tools/builtin/bash.ts
+import { spawn } from "node:child_process";
+
+// src/tools/builtin/path-guard.ts
+import { isAbsolute, normalize, resolve, sep } from "node:path";
+function withTrailingSep(p) {
+  const n = normalize(p);
+  return n.endsWith(sep) ? n : n + sep;
+}
+function isSubpath(parentDir, childPath) {
+  const parent = withTrailingSep(resolve(parentDir));
+  const child = resolve(childPath);
+  return child === parent.slice(0, -1) || child.startsWith(parent);
+}
+function getDefaultAllowedPaths(options) {
+  const cwd = options.cwd ?? process.cwd();
+  return [cwd];
+}
+function validateAbsolutePath(filePath) {
+  if (!isAbsolute(filePath)) {
+    return { ok: false, error: `Invalid path: ${filePath}. Must be an absolute path.` };
+  }
+  return { ok: true, resolved: resolve(filePath) };
+}
+function checkPathAccess(filePath, options, kind = "file") {
+  const abs = validateAbsolutePath(filePath);
+  if (!abs.ok)
+    return abs;
+  const resolved = abs.resolved;
+  const blockedPaths = options.blockedPaths ?? [];
+  for (const blocked of blockedPaths) {
+    if (isSubpath(blocked, resolved)) {
+      return { ok: false, error: `Path is blocked: ${resolved}` };
+    }
+  }
+  const allowedPaths = options.allowedPaths ?? getDefaultAllowedPaths(options);
+  const allowed = allowedPaths.some((allowedPath) => isSubpath(allowedPath, resolved));
+  if (!allowed) {
+    const base = options.cwd ?? process.cwd();
+    return {
+      ok: false,
+      error: `Access denied: ${kind} path is outside allowedPaths.
+Path: ${resolved}
+Allowed: ${allowedPaths.join(", ")}
+Hint: configure tools with createBuiltinTools({ allowedPaths: ["${base}"] })`
+    };
+  }
+  return { ok: true, resolved };
+}
+function checkDirAccess(dirPath, options) {
+  return checkPathAccess(dirPath, options, "dir");
+}
+
+// src/tools/builtin/bash.ts
+var DEFAULT_TIMEOUT = 120000;
+var MAX_OUTPUT_LENGTH = 1e5;
+var DEFAULT_BLOCKED_PATTERNS = [
+  "\\bsudo\\b",
+  "\\bmkfs\\b",
+  "\\bdd\\s+if=",
+  "\\brm\\s+-rf\\s+/(\\s|$)",
+  "\\bshutdown\\b",
+  "\\breboot\\b",
+  "\\bpoweroff\\b"
+];
+function createBashTool(options = {}) {
+  const defaultCwd = options.cwd ?? process.cwd();
+  const defaultTimeout = options.defaultTimeout ?? DEFAULT_TIMEOUT;
+  const blockedPatterns = [
+    ...DEFAULT_BLOCKED_PATTERNS,
+    ...options.blockedCommandPatterns ?? []
+  ].map((p) => {
+    try {
+      return new RegExp(p, "i");
+    } catch {
+      return null;
+    }
+  }).filter((r) => r !== null);
+  return {
+    name: "Bash",
+    description: `Execute bash commands in a persistent shell session. Use for git, npm, docker, and other CLI operations. Avoid using for file operations (use Read/Write/Edit instead).`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The bash command to execute"
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory for the command"
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in milliseconds (max 600000)"
+        },
+        description: {
+          type: "string",
+          description: "Brief description of what this command does"
+        }
+      },
+      required: ["command"]
+    },
+    execute: async (rawInput, _context) => {
+      const input = rawInput;
+      const { command, cwd = defaultCwd, timeout = defaultTimeout } = input;
+      const cwdAccess = checkDirAccess(cwd, options);
+      if (!cwdAccess.ok) {
+        return { content: cwdAccess.error, isError: true };
+      }
+      if (!options.allowDangerous) {
+        for (const pattern of blockedPatterns) {
+          if (pattern.test(command)) {
+            return {
+              content: `Command blocked by policy (allowDangerous=false): matched /${pattern.source}/`,
+              isError: true
+            };
+          }
+        }
+      }
+      const actualTimeout = Math.min(timeout, 600000);
+      return new Promise((resolve2) => {
+        let stdout = "";
+        let stderr = "";
+        let killed = false;
+        const proc = spawn("bash", ["-c", command], {
+          cwd: cwdAccess.resolved,
+          env: process.env,
+          shell: false
+        });
+        const timer = setTimeout(() => {
+          killed = true;
+          proc.kill("SIGTERM");
+          setTimeout(() => proc.kill("SIGKILL"), 1000);
+        }, actualTimeout);
+        proc.stdout?.on("data", (data) => {
+          stdout += data.toString();
+          if (stdout.length > MAX_OUTPUT_LENGTH) {
+            stdout = stdout.slice(0, MAX_OUTPUT_LENGTH) + `
+... (output truncated)`;
+            proc.kill("SIGTERM");
+          }
+        });
+        proc.stderr?.on("data", (data) => {
+          stderr += data.toString();
+          if (stderr.length > MAX_OUTPUT_LENGTH) {
+            stderr = stderr.slice(0, MAX_OUTPUT_LENGTH) + `
+... (output truncated)`;
+          }
+        });
+        proc.on("close", (code) => {
+          clearTimeout(timer);
+          if (killed) {
+            resolve2({
+              content: `Command timed out after ${actualTimeout}ms
+
+Partial output:
+${stdout}
+
+Stderr:
+${stderr}`,
+              isError: true
+            });
+            return;
+          }
+          const output = stdout + (stderr ? `
+Stderr:
+${stderr}` : "");
+          if (code !== 0) {
+            resolve2({
+              content: `Command failed with exit code ${code}
+
+${output}`,
+              isError: true
+            });
+          } else {
+            resolve2({
+              content: output || "(no output)"
+            });
+          }
+        });
+        proc.on("error", (error) => {
+          clearTimeout(timer);
+          resolve2({
+            content: `Failed to execute command: ${error.message}`,
+            isError: true
+          });
+        });
+      });
+    }
+  };
+}
+var BashTool = createBashTool();
+// src/tools/builtin/read.ts
+import { readFile as readFile3, stat } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { extname } from "node:path";
+var DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+var DEFAULT_LINE_LIMIT = 2000;
+var MAX_LINE_LENGTH = 2000;
+var BINARY_EXTENSIONS = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".rar",
+  ".7z",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot"
+]);
+function createReadTool(options = {}) {
+  const maxFileSize = options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
+  return {
+    name: "Read",
+    description: `Read file contents. Supports text files with optional line range. Returns line numbers in output. For images/PDFs, returns metadata only.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Absolute path to the file to read"
+        },
+        offset: {
+          type: "number",
+          description: "Line number to start reading from (1-indexed)"
+        },
+        limit: {
+          type: "number",
+          description: "Number of lines to read (default: 2000)"
+        }
+      },
+      required: ["file_path"]
+    },
+    execute: async (rawInput, _context) => {
+      const input = rawInput;
+      const { file_path, offset = 1, limit = DEFAULT_LINE_LIMIT } = input;
+      const access = checkPathAccess(file_path, options, "file");
+      if (!access.ok) {
+        return { content: access.error, isError: true };
+      }
+      if (!existsSync4(access.resolved)) {
+        return {
+          content: `File not found: ${access.resolved}`,
+          isError: true
+        };
+      }
+      const fileStat = await stat(access.resolved);
+      if (fileStat.size > maxFileSize) {
+        return {
+          content: `File too large: ${fileStat.size} bytes (max: ${maxFileSize} bytes)`,
+          isError: true
+        };
+      }
+      const ext = extname(access.resolved).toLowerCase();
+      if (BINARY_EXTENSIONS.has(ext)) {
+        return {
+          content: `Binary file: ${access.resolved}
+Size: ${fileStat.size} bytes
+Type: ${ext}`
+        };
+      }
+      try {
+        const content = await readFile3(access.resolved, "utf-8");
+        const lines = content.split(`
+`);
+        const startLine = Math.max(1, offset);
+        const endLine = Math.min(lines.length, startLine + limit - 1);
+        const outputLines = [];
+        for (let i = startLine - 1;i < endLine; i++) {
+          const lineNum = i + 1;
+          let line = lines[i];
+          if (line.length > MAX_LINE_LENGTH) {
+            line = line.slice(0, MAX_LINE_LENGTH) + "...";
+          }
+          const padding = String(endLine).length;
+          outputLines.push(`${String(lineNum).padStart(padding)}→${line}`);
+        }
+        let header = "";
+        if (startLine > 1 || endLine < lines.length) {
+          header = `[Lines ${startLine}-${endLine} of ${lines.length}]
+
+`;
+        }
+        return {
+          content: header + outputLines.join(`
+`)
+        };
+      } catch (error) {
+        return {
+          content: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var ReadTool = createReadTool();
+// src/tools/builtin/write.ts
+import { writeFile, mkdir } from "node:fs/promises";
+import { existsSync as existsSync5 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+function createWriteTool(options = {}) {
+  return {
+    name: "Write",
+    description: `Write content to a file. Creates parent directories if needed. Overwrites existing files. Use Edit tool for modifying existing files.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Absolute path to the file to write"
+        },
+        content: {
+          type: "string",
+          description: "Content to write to the file"
+        }
+      },
+      required: ["file_path", "content"]
+    },
+    execute: async (rawInput, _context) => {
+      const input = rawInput;
+      const { file_path, content } = input;
+      const access = checkPathAccess(file_path, options, "file");
+      if (!access.ok) {
+        return { content: access.error, isError: true };
+      }
+      try {
+        const dir = dirname3(access.resolved);
+        if (!existsSync5(dir)) {
+          await mkdir(dir, { recursive: true });
+        }
+        await writeFile(access.resolved, content, "utf-8");
+        const lines = content.split(`
+`).length;
+        const bytes = Buffer.byteLength(content, "utf-8");
+        return {
+          content: `Successfully wrote ${bytes} bytes (${lines} lines) to ${access.resolved}`
+        };
+      } catch (error) {
+        return {
+          content: `Failed to write file: ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var WriteTool = createWriteTool();
+// src/tools/builtin/edit.ts
+import { readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { existsSync as existsSync6 } from "node:fs";
+function createEditTool(options = {}) {
+  return {
+    name: "Edit",
+    description: `Edit a file by replacing text. Finds old_string and replaces with new_string. The old_string must be unique in the file unless replace_all is true.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Absolute path to the file to edit"
+        },
+        old_string: {
+          type: "string",
+          description: "Text to find and replace"
+        },
+        new_string: {
+          type: "string",
+          description: "Replacement text"
+        },
+        replace_all: {
+          type: "boolean",
+          description: "Replace all occurrences (default: false)",
+          default: false
+        }
+      },
+      required: ["file_path", "old_string", "new_string"]
+    },
+    execute: async (rawInput, _context) => {
+      const input = rawInput;
+      const { file_path, old_string, new_string, replace_all = false } = input;
+      const access = checkPathAccess(file_path, options, "file");
+      if (!access.ok) {
+        return { content: access.error, isError: true };
+      }
+      if (!existsSync6(access.resolved)) {
+        return {
+          content: `File not found: ${access.resolved}`,
+          isError: true
+        };
+      }
+      if (old_string === new_string) {
+        return {
+          content: `old_string and new_string are identical. No changes needed.`,
+          isError: true
+        };
+      }
+      try {
+        const content = await readFile4(access.resolved, "utf-8");
+        const occurrences = content.split(old_string).length - 1;
+        if (occurrences === 0) {
+          return {
+            content: `Text not found in file: "${old_string.slice(0, 100)}${old_string.length > 100 ? "..." : ""}"`,
+            isError: true
+          };
+        }
+        if (!replace_all && occurrences > 1) {
+          return {
+            content: `Found ${occurrences} occurrences of the text. Use replace_all: true to replace all, or provide a more unique string.`,
+            isError: true
+          };
+        }
+        let newContent;
+        let replacedCount;
+        if (replace_all) {
+          newContent = content.split(old_string).join(new_string);
+          replacedCount = occurrences;
+        } else {
+          newContent = content.replace(old_string, new_string);
+          replacedCount = 1;
+        }
+        await writeFile2(access.resolved, newContent, "utf-8");
+        return {
+          content: `Successfully replaced ${replacedCount} occurrence${replacedCount > 1 ? "s" : ""} in ${access.resolved}`
+        };
+      } catch (error) {
+        return {
+          content: `Failed to edit file: ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var EditTool = createEditTool();
+// src/tools/builtin/glob.ts
+import { readdir, stat as stat2 } from "node:fs/promises";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join4, relative } from "node:path";
+var MAX_RESULTS = 1000;
+function matchGlob(pattern, path) {
+  const regexPattern = pattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/{{GLOBSTAR}}/g, ".*").replace(/\./g, "\\.");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(path);
+}
+async function scanDir(dir, pattern, results, baseDir, maxDepth = 10, currentDepth = 0) {
+  if (currentDepth > maxDepth || results.length >= MAX_RESULTS) {
+    return;
+  }
+  if (!existsSync7(dir)) {
+    return;
+  }
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (results.length >= MAX_RESULTS)
+        break;
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      const fullPath = join4(dir, entry.name);
+      const relativePath = relative(baseDir, fullPath);
+      if (entry.isDirectory()) {
+        if (matchGlob(pattern, relativePath) || matchGlob(pattern, relativePath + "/")) {
+          results.push(fullPath);
+        }
+        await scanDir(fullPath, pattern, results, baseDir, maxDepth, currentDepth + 1);
+      } else if (entry.isFile()) {
+        if (matchGlob(pattern, relativePath)) {
+          results.push(fullPath);
+        }
+      }
+    }
+  } catch {}
+}
+function createGlobTool(options = {}) {
+  const defaultCwd = options.cwd ?? process.cwd();
+  return {
+    name: "Glob",
+    description: `Find files matching a glob pattern. Supports ** for recursive matching, * for single directory, ? for single character. Returns file paths sorted by modification time.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: 'Glob pattern to match (e.g., "**/*.ts", "src/**/*.js")'
+        },
+        path: {
+          type: "string",
+          description: "Directory to search in (default: current directory)"
+        }
+      },
+      required: ["pattern"]
+    },
+    execute: async (rawInput, _context) => {
+      const input = rawInput;
+      const { pattern, path = defaultCwd } = input;
+      const access = checkDirAccess(path, options);
+      if (!access.ok) {
+        return { content: access.error, isError: true };
+      }
+      if (!existsSync7(access.resolved)) {
+        return {
+          content: `Directory not found: ${access.resolved}`,
+          isError: true
+        };
+      }
+      try {
+        const results = [];
+        await scanDir(access.resolved, pattern, results, access.resolved);
+        if (results.length === 0) {
+          return {
+            content: `No files found matching pattern: ${pattern}`
+          };
+        }
+        const filesWithStats = await Promise.all(results.map(async (file) => {
+          try {
+            const stats = await stat2(file);
+            return { file, mtime: stats.mtime.getTime() };
+          } catch {
+            return { file, mtime: 0 };
+          }
+        }));
+        filesWithStats.sort((a, b) => b.mtime - a.mtime);
+        const output = filesWithStats.map((f) => f.file).join(`
+`);
+        const truncated = results.length >= MAX_RESULTS ? `
+
+(Results truncated at ${MAX_RESULTS} files)` : "";
+        return {
+          content: `Found ${results.length} files:
+
+${output}${truncated}`
+        };
+      } catch (error) {
+        return {
+          content: `Failed to search: ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var GlobTool = createGlobTool();
+// src/tools/builtin/grep.ts
+import { readFile as readFile5, readdir as readdir2, stat as stat3 } from "node:fs/promises";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join5, extname as extname2 } from "node:path";
+var MAX_RESULTS2 = 500;
+var MAX_LINE_LENGTH2 = 500;
+var BINARY_EXTENSIONS2 = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".rar",
+  ".7z",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".lock"
+]);
+function matchGlob2(pattern, filename) {
+  const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\./g, "\\.");
+  return new RegExp(`^${regexPattern}$`).test(filename);
+}
+async function searchFile(filePath, regex, before, after) {
+  const matches = [];
+  try {
+    const content = await readFile5(filePath, "utf-8");
+    const lines = content.split(`
+`);
+    for (let i = 0;i < lines.length; i++) {
+      if (regex.test(lines[i])) {
+        const match = {
+          file: filePath,
+          line: i + 1,
+          content: lines[i].slice(0, MAX_LINE_LENGTH2)
+        };
+        if (before > 0) {
+          match.before = lines.slice(Math.max(0, i - before), i).map((l) => l.slice(0, MAX_LINE_LENGTH2));
+        }
+        if (after > 0) {
+          match.after = lines.slice(i + 1, i + 1 + after).map((l) => l.slice(0, MAX_LINE_LENGTH2));
+        }
+        matches.push(match);
+        if (matches.length >= MAX_RESULTS2) {
+          break;
+        }
+      }
+    }
+  } catch {}
+  return matches;
+}
+async function searchDir(dir, regex, glob, before, after, results, maxDepth = 10, currentDepth = 0) {
+  if (currentDepth > maxDepth || results.length >= MAX_RESULTS2) {
+    return;
+  }
+  try {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (results.length >= MAX_RESULTS2)
+        break;
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      const fullPath = join5(dir, entry.name);
+      if (entry.isDirectory()) {
+        await searchDir(fullPath, regex, glob, before, after, results, maxDepth, currentDepth + 1);
+      } else if (entry.isFile()) {
+        const ext = extname2(entry.name).toLowerCase();
+        if (BINARY_EXTENSIONS2.has(ext)) {
+          continue;
+        }
+        if (glob && !matchGlob2(glob, entry.name)) {
+          continue;
+        }
+        const matches = await searchFile(fullPath, regex, before, after);
+        results.push(...matches);
+      }
+    }
+  } catch {}
+}
+function createGrepTool(options = {}) {
+  const defaultCwd = options.cwd ?? process.cwd();
+  return {
+    name: "Grep",
+    description: `Search file contents using regular expressions. Supports context lines before/after matches. Returns matching lines with file paths and line numbers.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Regular expression pattern to search for"
+        },
+        path: {
+          type: "string",
+          description: "File or directory to search in"
+        },
+        glob: {
+          type: "string",
+          description: 'Glob pattern to filter files (e.g., "*.ts")'
+        },
+        before: {
+          type: "number",
+          description: "Number of lines to show before each match"
+        },
+        after: {
+          type: "number",
+          description: "Number of lines to show after each match"
+        },
+        ignoreCase: {
+          type: "boolean",
+          description: "Case insensitive search"
+        }
+      },
+      required: ["pattern"]
+    },
+    execute: async (rawInput, _context) => {
+      const input = rawInput;
+      const {
+        pattern,
+        path = defaultCwd,
+        glob,
+        before = 0,
+        after = 0,
+        ignoreCase = false
+      } = input;
+      const access = checkPathAccess(path, options, "dir");
+      if (!access.ok) {
+        return { content: access.error, isError: true };
+      }
+      if (!existsSync8(access.resolved)) {
+        return {
+          content: `Path not found: ${access.resolved}`,
+          isError: true
+        };
+      }
+      try {
+        const flags = ignoreCase ? "gi" : "g";
+        const regex = new RegExp(pattern, flags);
+        const results = [];
+        const pathStat = await stat3(access.resolved);
+        if (pathStat.isFile()) {
+          const matches = await searchFile(access.resolved, regex, before, after);
+          results.push(...matches);
+        } else if (pathStat.isDirectory()) {
+          await searchDir(access.resolved, regex, glob, before, after, results);
+        }
+        if (results.length === 0) {
+          return {
+            content: `No matches found for pattern: ${pattern}`
+          };
+        }
+        const output = [];
+        for (const match of results) {
+          if (match.before?.length) {
+            for (let i = 0;i < match.before.length; i++) {
+              const lineNum = match.line - match.before.length + i;
+              output.push(`${match.file}:${lineNum}- ${match.before[i]}`);
+            }
+          }
+          output.push(`${match.file}:${match.line}: ${match.content}`);
+          if (match.after?.length) {
+            for (let i = 0;i < match.after.length; i++) {
+              const lineNum = match.line + i + 1;
+              output.push(`${match.file}:${lineNum}+ ${match.after[i]}`);
+            }
+          }
+          if (match.before?.length || match.after?.length) {
+            output.push("--");
+          }
+        }
+        const truncated = results.length >= MAX_RESULTS2 ? `
+
+(Results truncated at ${MAX_RESULTS2} matches)` : "";
+        return {
+          content: `Found ${results.length} matches:
+
+${output.join(`
+`)}${truncated}`
+        };
+      } catch (error) {
+        return {
+          content: `Search failed: ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var GrepTool = createGrepTool();
+// src/tools/builtin/webfetch.ts
+import { lookup } from "node:dns/promises";
+var MAX_CONTENT_LENGTH = 1e5;
+var FETCH_TIMEOUT = 30000;
+function isIpV4(host) {
+  return /^\d{1,3}(\.\d{1,3}){3}$/.test(host);
+}
+function isIpV6(host) {
+  return /^[0-9a-fA-F:]+$/.test(host) && host.includes(":");
+}
+function isPrivateIpv4(ip) {
+  const parts = ip.split(".").map((p) => Number(p));
+  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n) || n < 0 || n > 255))
+    return true;
+  const [a, b] = parts;
+  if (a === 10)
+    return true;
+  if (a === 127)
+    return true;
+  if (a === 0)
+    return true;
+  if (a === 169 && b === 254)
+    return true;
+  if (a === 172 && b >= 16 && b <= 31)
+    return true;
+  if (a === 192 && b === 168)
+    return true;
+  if (a === 100 && b >= 64 && b <= 127)
+    return true;
+  if (a >= 224)
+    return true;
+  return false;
+}
+function isPrivateIpv6(ip) {
+  const normalized = ip.toLowerCase();
+  if (normalized === "::" || normalized === "::1")
+    return true;
+  if (normalized.startsWith("fe80:"))
+    return true;
+  if (normalized.startsWith("fc") || normalized.startsWith("fd"))
+    return true;
+  return false;
+}
+async function denyPrivateNetworkTargets(url, options) {
+  if (options.allowPrivateNetwork)
+    return null;
+  const hostname = url.hostname.toLowerCase();
+  if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname.endsWith(".local")) {
+    return `Blocked by policy (allowPrivateNetwork=false): hostname "${hostname}" is local-only`;
+  }
+  if (isIpV4(hostname) && isPrivateIpv4(hostname)) {
+    return `Blocked by policy (allowPrivateNetwork=false): private IPv4 target "${hostname}"`;
+  }
+  if (isIpV6(hostname) && isPrivateIpv6(hostname)) {
+    return `Blocked by policy (allowPrivateNetwork=false): private IPv6 target "${hostname}"`;
+  }
+  const resolveHostnames = options.resolveHostnames ?? true;
+  if (!resolveHostnames)
+    return null;
+  try {
+    const addrs = await lookup(hostname, { all: true, verbatim: true });
+    for (const addr of addrs) {
+      if (addr.family === 4 && isPrivateIpv4(addr.address)) {
+        return `Blocked by policy (allowPrivateNetwork=false): "${hostname}" resolves to private IPv4 "${addr.address}"`;
+      }
+      if (addr.family === 6 && isPrivateIpv6(addr.address)) {
+        return `Blocked by policy (allowPrivateNetwork=false): "${hostname}" resolves to private IPv6 "${addr.address}"`;
+      }
+    }
+  } catch (e) {
+    return `DNS resolution failed for "${hostname}" (allowPrivateNetwork=false): ${e instanceof Error ? e.message : String(e)}`;
+  }
+  return null;
+}
+function htmlToMarkdown(html) {
+  let md = html;
+  md = md.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
+  md = md.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+  md = md.replace(/<h1[^>]*>(.*?)<\/h1>/gi, `
+# $1
+`);
+  md = md.replace(/<h2[^>]*>(.*?)<\/h2>/gi, `
+## $1
+`);
+  md = md.replace(/<h3[^>]*>(.*?)<\/h3>/gi, `
+### $1
+`);
+  md = md.replace(/<h4[^>]*>(.*?)<\/h4>/gi, `
+#### $1
+`);
+  md = md.replace(/<h5[^>]*>(.*?)<\/h5>/gi, `
+##### $1
+`);
+  md = md.replace(/<h6[^>]*>(.*?)<\/h6>/gi, `
+###### $1
+`);
+  md = md.replace(/<p[^>]*>(.*?)<\/p>/gi, `
+$1
+`);
+  md = md.replace(/<a[^>]*href=["']([^"']+)["'][^>]*>(.*?)<\/a>/gi, "[$2]($1)");
+  md = md.replace(/<(strong|b)[^>]*>(.*?)<\/\1>/gi, "**$2**");
+  md = md.replace(/<(em|i)[^>]*>(.*?)<\/\1>/gi, "*$2*");
+  md = md.replace(/<code[^>]*>(.*?)<\/code>/gi, "`$1`");
+  md = md.replace(/<pre[^>]*>(.*?)<\/pre>/gis, "\n```\n$1\n```\n");
+  md = md.replace(/<li[^>]*>(.*?)<\/li>/gi, `- $1
+`);
+  md = md.replace(/<\/?[ou]l[^>]*>/gi, `
+`);
+  md = md.replace(/<br\s*\/?>/gi, `
+`);
+  md = md.replace(/<[^>]+>/g, "");
+  md = md.replace(/&nbsp;/g, " ");
+  md = md.replace(/&amp;/g, "&");
+  md = md.replace(/&lt;/g, "<");
+  md = md.replace(/&gt;/g, ">");
+  md = md.replace(/&quot;/g, '"');
+  md = md.replace(/\n{3,}/g, `
+
+`);
+  md = md.trim();
+  return md;
+}
+function createWebFetchTool(options = {}) {
+  return {
+    name: "WebFetch",
+    description: `Fetch content from a URL. Converts HTML to markdown for readability. Use for retrieving web pages, documentation, or API responses.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "URL to fetch"
+        },
+        prompt: {
+          type: "string",
+          description: "Optional prompt to describe what information to extract"
+        }
+      },
+      required: ["url"]
+    },
+    execute: async (rawInput, _context) => {
+      const input = rawInput;
+      const { url, prompt } = input;
+      let parsedUrl;
+      try {
+        parsedUrl = new URL(url);
+        if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+          return {
+            content: `Invalid URL protocol: ${parsedUrl.protocol}. Only http/https are allowed.`,
+            isError: true
+          };
+        }
+        if (parsedUrl.protocol === "http:")
+          parsedUrl.protocol = "https:";
+      } catch {
+        return {
+          content: `Invalid URL: ${url}`,
+          isError: true
+        };
+      }
+      const ssrfDeny = await denyPrivateNetworkTargets(parsedUrl, options);
+      if (ssrfDeny) {
+        return { content: ssrfDeny, isError: true };
+      }
+      try {
+        const controller = new AbortController;
+        const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+        const response = await fetch(parsedUrl.toString(), {
+          signal: controller.signal,
+          headers: {
+            "User-Agent": "Mozilla/5.0 (compatible; OpenCode-Agent/1.0)",
+            Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+          }
+        });
+        clearTimeout(timeout);
+        if (!response.ok) {
+          return {
+            content: `HTTP error: ${response.status} ${response.statusText}`,
+            isError: true
+          };
+        }
+        const finalUrl = new URL(response.url);
+        if (finalUrl.host !== parsedUrl.host) {
+          return {
+            content: `Redirected to different host: ${response.url}
+
+Please fetch the new URL if you want to continue.`
+          };
+        }
+        const ssrfDenyAfter = await denyPrivateNetworkTargets(finalUrl, options);
+        if (ssrfDenyAfter) {
+          return { content: `Redirect target denied: ${ssrfDenyAfter}`, isError: true };
+        }
+        const contentType = response.headers.get("content-type") || "";
+        let content = await response.text();
+        if (content.length > MAX_CONTENT_LENGTH) {
+          content = content.slice(0, MAX_CONTENT_LENGTH) + `
+
+... (content truncated)`;
+        }
+        if (contentType.includes("text/html")) {
+          content = htmlToMarkdown(content);
+        }
+        let output = `URL: ${response.url}
+`;
+        output += `Content-Type: ${contentType}
+
+`;
+        if (prompt) {
+          output += `Requested: ${prompt}
+
+`;
+        }
+        output += content;
+        return {
+          content: output
+        };
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          return {
+            content: `Request timed out after ${FETCH_TIMEOUT}ms`,
+            isError: true
+          };
+        }
+        return {
+          content: `Failed to fetch: ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var WebFetchTool = createWebFetchTool();
+// src/tools/builtin/todo.ts
+var globalTodos = [];
+var onTodoChange = null;
+function setTodoChangeCallback(callback) {
+  onTodoChange = callback;
+}
+function getTodos() {
+  return [...globalTodos];
+}
+function clearTodos() {
+  globalTodos = [];
+  onTodoChange?.(globalTodos);
+}
+function createTodoWriteTool(options = {}) {
+  return {
+    name: "TodoWrite",
+    description: `Manage a task list to track progress on complex tasks. Use to plan work, track completed items, and show progress to the user.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        todos: {
+          type: "array",
+          description: "Updated todo list",
+          items: {
+            type: "object",
+            properties: {
+              content: {
+                type: "string",
+                description: "Task description (imperative form, e.g., 'Run tests')"
+              },
+              status: {
+                type: "string",
+                enum: ["pending", "in_progress", "completed"],
+                description: "Task status"
+              },
+              activeForm: {
+                type: "string",
+                description: "Present continuous form (e.g., 'Running tests')"
+              }
+            },
+            required: ["content", "status", "activeForm"]
+          }
+        }
+      },
+      required: ["todos"]
+    },
+    execute: async (rawInput, _context) => {
+      const input = rawInput;
+      const { todos } = input;
+      for (const todo of todos) {
+        if (!todo.content || !todo.status || !todo.activeForm) {
+          return {
+            content: "Invalid todo item: missing required fields (content, status, activeForm)",
+            isError: true
+          };
+        }
+        if (!["pending", "in_progress", "completed"].includes(todo.status)) {
+          return {
+            content: `Invalid status: ${todo.status}. Must be pending, in_progress, or completed.`,
+            isError: true
+          };
+        }
+      }
+      globalTodos = todos;
+      onTodoChange?.(globalTodos);
+      const completed = todos.filter((t) => t.status === "completed").length;
+      const inProgress = todos.filter((t) => t.status === "in_progress").length;
+      const pending = todos.filter((t) => t.status === "pending").length;
+      const lines = [
+        `Todo list updated (${completed}/${todos.length} completed)`,
+        ""
+      ];
+      for (const todo of todos) {
+        const icon = todo.status === "completed" ? "✓" : todo.status === "in_progress" ? "→" : "○";
+        lines.push(`${icon} ${todo.content}`);
+      }
+      if (inProgress > 0) {
+        lines.push("");
+        lines.push(`Currently: ${todos.find((t) => t.status === "in_progress")?.activeForm}`);
+      }
+      return {
+        content: lines.join(`
+`)
+      };
+    }
+  };
+}
+var TodoWriteTool = createTodoWriteTool();
+// src/tools/builtin/index.ts
+var builtinTools = [
+  BashTool,
+  ReadTool,
+  WriteTool,
+  EditTool,
+  GlobTool,
+  GrepTool,
+  WebFetchTool,
+  TodoWriteTool
+];
+// src/utils/env.ts
+import { existsSync as existsSync9, readFileSync } from "node:fs";
+import { join as join6 } from "node:path";
+function loadEnvOverride(cwd) {
+  const dir = cwd || process.cwd();
+  const envPath = join6(dir, ".env");
+  if (!existsSync9(envPath)) {
+    return;
+  }
+  try {
+    const content = readFileSync(envPath, "utf-8");
+    const lines = content.split(`
+`);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        continue;
+      }
+      const eqIndex = trimmed.indexOf("=");
+      if (eqIndex === -1) {
+        continue;
+      }
+      const key = trimmed.slice(0, eqIndex).trim();
+      let value = trimmed.slice(eqIndex + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      process.env[key] = value;
+    }
+  } catch {}
+}
+
+// src/cli/cli.ts
+loadEnvOverride();
+var VERSION = "0.1.0";
+var SKILLS_PATH = join7(homedir4(), ".claude");
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+var c = {
+  bold: (s) => `${colors.bold}${s}${colors.reset}`,
+  dim: (s) => `${colors.dim}${s}${colors.reset}`,
+  red: (s) => `${colors.red}${s}${colors.reset}`,
+  green: (s) => `${colors.green}${s}${colors.reset}`,
+  yellow: (s) => `${colors.yellow}${s}${colors.reset}`,
+  blue: (s) => `${colors.blue}${s}${colors.reset}`,
+  magenta: (s) => `${colors.magenta}${s}${colors.reset}`,
+  cyan: (s) => `${colors.cyan}${s}${colors.reset}`,
+  gray: (s) => `${colors.gray}${s}${colors.reset}`
+};
+var session = null;
+var totalInputTokens = 0;
+var totalOutputTokens = 0;
+var messageCount = 0;
+function isGitRepo(dir) {
+  return existsSync10(join7(dir, ".git"));
+}
+function getOsVersion() {
+  try {
+    return __require("node:os").release();
+  } catch {
+    return "";
+  }
+}
+function buildSystemPrompt() {
+  const cwd = process.cwd();
+  const envContext = generateEnvContext({
+    cwd,
+    isGitRepo: isGitRepo(cwd),
+    platform: process.platform,
+    osVersion: getOsVersion(),
+    date: new Date,
+    shell: process.env.SHELL
+  });
+  return `${CLI_AGENT_PRESET}
+
+${envContext}
+`;
+}
+function getAllTools() {
+  const skillTool2 = createSkillTool({
+    settingSources: [SKILLS_PATH],
+    cwd: process.cwd()
+  });
+  return [...builtinTools, skillTool2];
+}
+function printHelp() {
+  console.log(`
+${c.bold("FormAgent CLI")} - Interactive AI Agent
+
+${c.bold("Usage:")}
+  ${c.cyan("npx formagent")}              Start interactive mode
+  ${c.cyan("npx formagent <question>")}   Quick query mode
+  ${c.cyan("npx formagent --help")}       Show this help
+  ${c.cyan("npx formagent --version")}    Show version
+
+${c.bold("Interactive Commands:")}
+  ${c.cyan("/help")}     Show available commands
+  ${c.cyan("/clear")}    Clear conversation history
+  ${c.cyan("/tools")}    List available tools
+  ${c.cyan("/skills")}   List available skills
+  ${c.cyan("/todos")}    Show current todo list
+  ${c.cyan("/usage")}    Show token usage statistics
+  ${c.cyan("/exit")}     Exit the CLI
+
+${c.bold("Environment:")}
+  ${c.cyan("ANTHROPIC_API_KEY")}   Anthropic API key (for Claude models)
+  ${c.cyan("ANTHROPIC_MODEL")}     Optional. Claude model (default: claude-sonnet-4-20250514)
+  ${c.cyan("OPENAI_API_KEY")}      OpenAI API key (for GPT models)
+  ${c.cyan("OPENAI_MODEL")}        Optional. OpenAI model (default: gpt-4o)
+  ${c.cyan("OPENAI_BASE_URL")}     Optional. Custom OpenAI-compatible API URL
+
+${c.bold("Examples:")}
+  ${c.dim("# Start interactive mode")}
+  npx formagent
+
+  ${c.dim("# Quick query")}
+  npx formagent "What is the capital of France?"
+
+  ${c.dim("# Multi-word query")}
+  npx formagent "Explain how async/await works in JavaScript"
+`);
+}
+function printVersion() {
+  console.log(`formagent-sdk v${VERSION}`);
+}
+function printBanner() {
+  const model = getDefaultModel();
+  console.log();
+  console.log(c.cyan("╔═══════════════════════════════════════════════════════════╗"));
+  console.log(c.cyan("║") + c.bold("              FormAgent CLI v" + VERSION + "                     ") + c.cyan("║"));
+  console.log(c.cyan("║") + c.dim("           AI Agent Framework                              ") + c.cyan("║"));
+  console.log(c.cyan("╚═══════════════════════════════════════════════════════════╝"));
+  console.log();
+  console.log(c.dim("  Model: ") + c.green(model));
+  console.log(c.dim("  Type your message and press Enter to chat."));
+  console.log(c.dim("  Use /help for commands, /exit to quit."));
+  console.log();
+}
+function printInteractiveHelp() {
+  console.log();
+  console.log(c.bold("Available Commands:"));
+  console.log();
+  console.log(`  ${c.cyan("/help")}     Show this help message`);
+  console.log(`  ${c.cyan("/clear")}    Clear conversation history`);
+  console.log(`  ${c.cyan("/tools")}    List available tools`);
+  console.log(`  ${c.cyan("/skills")}   List available skills`);
+  console.log(`  ${c.cyan("/todos")}    Show current todo list`);
+  console.log(`  ${c.cyan("/usage")}    Show token usage statistics`);
+  console.log(`  ${c.cyan("/exit")}     Exit the CLI`);
+  console.log();
+}
+function printTools() {
+  const tools = getAllTools();
+  console.log();
+  console.log(c.bold("Available Tools:"));
+  console.log();
+  for (const tool2 of tools) {
+    console.log(`  ${c.green("●")} ${c.bold(tool2.name)}`);
+    const desc = tool2.description?.split(`
+`)[0] || "";
+    console.log(`    ${c.dim(desc.slice(0, 70))}${desc.length > 70 ? "..." : ""}`);
+  }
+  console.log();
+}
+async function printSkills() {
+  console.log();
+  console.log(c.bold("Available Skills:"));
+  console.log(c.dim(`  (from ${SKILLS_PATH})`));
+  console.log();
+  const loader = new SkillLoader;
+  const skills = await loader.discover({
+    directories: [SKILLS_PATH],
+    includeUserSkills: false,
+    includeProjectSkills: false,
+    maxDepth: 3
+  });
+  if (skills.length === 0) {
+    console.log(c.dim("  No skills found."));
+  } else {
+    for (const skill of skills) {
+      const triggers = skill.triggers?.slice(0, 3).join(", ") || "none";
+      console.log(`  ${c.magenta("◆")} ${c.bold(skill.name)} ${c.dim(`[${skill.id}]`)}`);
+      if (skill.description) {
+        console.log(`    ${c.dim(skill.description.slice(0, 60))}...`);
+      }
+      console.log(`    ${c.dim("Triggers:")} ${triggers}`);
+    }
+  }
+  console.log();
+}
+function printTodos() {
+  const todos = getTodos();
+  console.log();
+  if (todos.length === 0) {
+    console.log(c.dim("  No todos."));
+  } else {
+    console.log(c.bold("Current Todos:"));
+    console.log();
+    for (const todo of todos) {
+      const icon = todo.status === "completed" ? c.green("✓") : todo.status === "in_progress" ? c.yellow("→") : c.dim("○");
+      console.log(`  ${icon} ${todo.content}`);
+    }
+  }
+  console.log();
+}
+function printUsage() {
+  console.log();
+  console.log(c.bold("Token Usage:"));
+  console.log();
+  console.log(`  ${c.cyan("Messages:")}      ${messageCount}`);
+  console.log(`  ${c.cyan("Input tokens:")}  ${totalInputTokens.toLocaleString()}`);
+  console.log(`  ${c.cyan("Output tokens:")} ${totalOutputTokens.toLocaleString()}`);
+  console.log(`  ${c.cyan("Total tokens:")}  ${(totalInputTokens + totalOutputTokens).toLocaleString()}`);
+  const inputCost = totalInputTokens / 1e6 * 3;
+  const outputCost = totalOutputTokens / 1e6 * 15;
+  console.log(`  ${c.cyan("Est. cost:")}     $${(inputCost + outputCost).toFixed(4)}`);
+  console.log();
+}
+function formatToolInput(name, input) {
+  switch (name) {
+    case "Bash":
+      return String(input.command || "");
+    case "Read":
+      return String(input.file_path || "");
+    case "Write":
+      return `${input.file_path} (${String(input.content || "").length} chars)`;
+    case "Edit":
+      return String(input.file_path || "");
+    case "Glob":
+      return `${input.pattern}${input.path ? ` in ${input.path}` : ""}`;
+    case "Grep":
+      return `/${input.pattern}/${input.path ? ` in ${input.path}` : ""}`;
+    case "WebFetch":
+      return String(input.url || "");
+    case "TodoWrite":
+      return `${input.todos?.length || 0} items`;
+    case "Skill":
+      if (input.action === "list") {
+        return input.query ? `list (query: ${input.query})` : "list";
+      }
+      return `invoke ${input.skill_name || ""}`;
+    default:
+      return JSON.stringify(input).slice(0, 50);
+  }
+}
+function getDefaultModel() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return process.env.ANTHROPIC_MODEL || "claude-sonnet-4-20250514";
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return process.env.OPENAI_MODEL || "gpt-4o";
+  }
+  return "claude-sonnet-4-20250514";
+}
+async function getSession() {
+  if (!session) {
+    session = await createSession({
+      model: getDefaultModel(),
+      tools: getAllTools(),
+      systemPrompt: buildSystemPrompt()
+    });
+  }
+  return session;
+}
+async function processStream(sess) {
+  let hasText = false;
+  for await (const event of sess.receive()) {
+    switch (event.type) {
+      case "text":
+        if (!hasText) {
+          process.stdout.write(`
+`);
+          hasText = true;
+        }
+        process.stdout.write(event.text);
+        break;
+      case "tool_use":
+        const inputDisplay = formatToolInput(event.name, event.input);
+        console.log(`
+${c.yellow("⚡")} ${c.bold(event.name)} ${c.dim(inputDisplay)}`);
+        break;
+      case "tool_result":
+        const content = typeof event.content === "string" ? event.content : JSON.stringify(event.content);
+        if (event.is_error) {
+          console.log(`${c.red("✗")} ${c.red("Error:")} ${content?.slice(0, 100)}`);
+        } else {
+          const preview = content?.split(`
+`)[0]?.slice(0, 80) || "";
+          console.log(`${c.green("✓")} ${c.dim(preview)}${content && content.length > 80 ? "..." : ""}`);
+        }
+        break;
+      case "error":
+        console.log(`
+${c.red("Error:")} ${event.error}`);
+        break;
+      case "stop":
+        if (event.usage) {
+          totalInputTokens += event.usage.input_tokens || 0;
+          totalOutputTokens += event.usage.output_tokens || 0;
+        }
+        if (hasText) {
+          console.log(`
+`);
+        }
+        break;
+    }
+  }
+  messageCount++;
+}
+async function handleInput(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return true;
+  }
+  if (trimmed.startsWith("/")) {
+    const cmd = trimmed.toLowerCase();
+    switch (cmd) {
+      case "/help":
+        printInteractiveHelp();
+        return true;
+      case "/clear":
+        if (session) {
+          await session.close();
+          session = null;
+        }
+        clearTodos();
+        totalInputTokens = 0;
+        totalOutputTokens = 0;
+        messageCount = 0;
+        console.log(c.green(`
+  ✓ Conversation cleared.
+`));
+        return true;
+      case "/tools":
+        printTools();
+        return true;
+      case "/skills":
+        await printSkills();
+        return true;
+      case "/todos":
+        printTodos();
+        return true;
+      case "/usage":
+        printUsage();
+        return true;
+      case "/exit":
+      case "/quit":
+      case "/q":
+        return false;
+      default:
+        console.log(c.yellow(`
+  Unknown command: ${cmd}. Type /help for available commands.
+`));
+        return true;
+    }
+  }
+  try {
+    const sess = await getSession();
+    await sess.send(trimmed);
+    await processStream(sess);
+  } catch (error) {
+    console.log(c.red(`
+Error: ${error instanceof Error ? error.message : String(error)}
+`));
+  }
+  return true;
+}
+async function runQuickQuery(query) {
+  if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+    console.error(c.red("Error: No API key found"));
+    console.error(c.dim("Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable"));
+    process.exit(1);
+  }
+  try {
+    const sess = await getSession();
+    await sess.send(query);
+    await processStream(sess);
+    await sess.close();
+  } catch (error) {
+    console.error(c.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function runInteractive() {
+  if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+    console.error(c.red("Error: No API key found"));
+    console.error(c.dim("Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable"));
+    process.exit(1);
+  }
+  setTodoChangeCallback(() => {});
+  printBanner();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  const prompt = () => {
+    rl.question(c.cyan("❯ "), async (input) => {
+      const shouldContinue = await handleInput(input);
+      if (shouldContinue) {
+        prompt();
+      } else {
+        console.log(c.dim(`
+Goodbye!
+`));
+        if (session) {
+          await session.close();
+        }
+        rl.close();
+        process.exit(0);
+      }
+    });
+  };
+  rl.on("SIGINT", async () => {
+    console.log(c.dim(`
+
+Interrupted. Goodbye!
+`));
+    if (session) {
+      await session.close();
+    }
+    process.exit(0);
+  });
+  prompt();
+}
+async function runCLI(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    return;
+  }
+  if (args.includes("--version") || args.includes("-v")) {
+    printVersion();
+    return;
+  }
+  const query = args.filter((arg) => !arg.startsWith("-")).join(" ").trim();
+  if (query) {
+    await runQuickQuery(query);
+  } else {
+    await runInteractive();
+  }
+}
+
+// src/cli/index.ts
+runCLI(process.argv.slice(2)).catch((error) => {
+  console.error(`\x1B[31mFatal error: ${error.message}\x1B[0m`);
+  process.exit(1);
+});