mycto_agent 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2913 @@
+import { convertToModelMessages, stepCountIs, streamText, zodSchema } from 'ai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { getEncoding } from 'js-tiktoken';
+import { z } from 'zod';
+import { spawn } from 'child_process';
+import { stat, readFile, mkdir, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { isAbsolute, resolve, dirname } from 'path';
+import { glob } from 'glob';
+
+// src/core/session-store.ts
+var currentStore = null;
+function setSessionStore(store) {
+  currentStore = store;
+}
+function getSessionStore() {
+  if (!currentStore) {
+    throw new Error("SessionStore not initialized. Call setSessionStore() or initOpenAgent() first.");
+  }
+  return currentStore;
+}
+function hasSessionStore() {
+  return currentStore !== null;
+}
+
+// src/utils/id.ts
+var counter = 0;
+var lastTimestamp = 0;
+function generateId(prefix) {
+  const timestamp = Date.now();
+  if (timestamp === lastTimestamp) {
+    counter++;
+  } else {
+    counter = 0;
+    lastTimestamp = timestamp;
+  }
+  const random = Math.random().toString(36).substring(2, 8);
+  const id = `${timestamp.toString(36)}_${counter.toString(36)}_${random}`;
+  return prefix ? `${prefix}_${id}` : id;
+}
+function sessionId() {
+  return generateId("ses");
+}
+function messageId() {
+  return generateId("msg");
+}
+function partId() {
+  return generateId("part");
+}
+function toolCallId() {
+  return generateId("call");
+}
+
+// src/core/memory-store.ts
+function createStorage() {
+  return {
+    sessions: /* @__PURE__ */ new Map(),
+    messages: /* @__PURE__ */ new Map(),
+    parts: /* @__PURE__ */ new Map(),
+    sessionMessages: /* @__PURE__ */ new Map(),
+    messageParts: /* @__PURE__ */ new Map()
+  };
+}
+var MemorySessionStore = class {
+  storage;
+  constructor() {
+    this.storage = createStorage();
+  }
+  // ---- Session CRUD ----
+  async createSession(input) {
+    const id = sessionId();
+    const now = /* @__PURE__ */ new Date();
+    const session = {
+      id,
+      projectId: input.projectId,
+      taskId: input.taskId,
+      parentId: input.parentId,
+      agent: input.agent,
+      mode: input.mode ?? "build",
+      status: "IDLE",
+      title: input.title,
+      totalCost: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.storage.sessions.set(id, session);
+    this.storage.sessionMessages.set(id, []);
+    return session;
+  }
+  async getSession(id) {
+    return this.storage.sessions.get(id) ?? null;
+  }
+  async updateSession(id, data) {
+    const session = this.storage.sessions.get(id);
+    if (!session) {
+      throw new Error(`Session not found: ${id}`);
+    }
+    const updated = {
+      ...session,
+      ...data,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.storage.sessions.set(id, updated);
+    return updated;
+  }
+  async deleteSession(id) {
+    const messageIds = this.storage.sessionMessages.get(id) ?? [];
+    for (const messageId2 of messageIds) {
+      const partIds = this.storage.messageParts.get(messageId2) ?? [];
+      for (const partId3 of partIds) {
+        this.storage.parts.delete(partId3);
+      }
+      this.storage.messageParts.delete(messageId2);
+      this.storage.messages.delete(messageId2);
+    }
+    this.storage.sessionMessages.delete(id);
+    this.storage.sessions.delete(id);
+  }
+  async listSessions(options) {
+    let sessions = Array.from(this.storage.sessions.values());
+    if (options.projectId) {
+      sessions = sessions.filter((s) => s.projectId === options.projectId);
+    }
+    if (options.taskId) {
+      sessions = sessions.filter((s) => s.taskId === options.taskId);
+    }
+    if (options.status) {
+      sessions = sessions.filter((s) => s.status === options.status);
+    }
+    sessions.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? 50;
+    return sessions.slice(offset, offset + limit);
+  }
+  // ---- Message CRUD ----
+  async createMessage(data) {
+    const id = messageId();
+    const now = /* @__PURE__ */ new Date();
+    const message = {
+      id,
+      sessionId: data.sessionId,
+      parentId: data.parentId,
+      role: data.role,
+      agent: data.agent,
+      providerId: data.providerId,
+      modelId: data.modelId,
+      cost: 0,
+      createdAt: now
+    };
+    this.storage.messages.set(id, message);
+    this.storage.messageParts.set(id, []);
+    const messageIds = this.storage.sessionMessages.get(data.sessionId) ?? [];
+    messageIds.push(id);
+    this.storage.sessionMessages.set(data.sessionId, messageIds);
+    return message;
+  }
+  async getMessage(id) {
+    const message = this.storage.messages.get(id);
+    if (!message) return null;
+    const partIds = this.storage.messageParts.get(id) ?? [];
+    const parts = partIds.map((pid) => this.storage.parts.get(pid)).filter((p) => p !== void 0).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    return { ...message, parts };
+  }
+  async updateMessage(id, data) {
+    const message = this.storage.messages.get(id);
+    if (!message) {
+      throw new Error(`Message not found: ${id}`);
+    }
+    const updated = {
+      ...message,
+      ...data
+    };
+    this.storage.messages.set(id, updated);
+    return updated;
+  }
+  async getSessionMessages(sessionId2) {
+    const messageIds = this.storage.sessionMessages.get(sessionId2) ?? [];
+    const messages = [];
+    for (const messageId2 of messageIds) {
+      const message = await this.getMessage(messageId2);
+      if (message) {
+        messages.push(message);
+      }
+    }
+    messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    return messages;
+  }
+  // ---- Part CRUD ----
+  async createPart(messageId2, data) {
+    const id = partId();
+    const now = /* @__PURE__ */ new Date();
+    let part;
+    switch (data.type) {
+      case "TEXT":
+        part = {
+          id,
+          messageId: messageId2,
+          type: "TEXT",
+          text: data.text,
+          createdAt: now
+        };
+        break;
+      case "TOOL":
+        part = {
+          id,
+          messageId: messageId2,
+          type: "TOOL",
+          toolName: data.toolName,
+          toolCallId: data.toolCallId,
+          toolInput: data.toolInput,
+          toolOutput: data.toolOutput,
+          toolStatus: data.toolStatus,
+          toolMeta: data.toolMeta,
+          createdAt: now
+        };
+        break;
+      case "REASONING":
+        part = {
+          id,
+          messageId: messageId2,
+          type: "REASONING",
+          reasoning: data.reasoning,
+          createdAt: now
+        };
+        break;
+      case "FILE":
+        part = {
+          id,
+          messageId: messageId2,
+          type: "FILE",
+          fileUrl: data.fileUrl,
+          fileName: data.fileName,
+          fileMime: data.fileMime,
+          createdAt: now
+        };
+        break;
+    }
+    this.storage.parts.set(id, part);
+    const partIds = this.storage.messageParts.get(messageId2) ?? [];
+    partIds.push(id);
+    this.storage.messageParts.set(messageId2, partIds);
+    return part;
+  }
+  async updatePart(id, data) {
+    const part = this.storage.parts.get(id);
+    if (!part) {
+      throw new Error(`Part not found: ${id}`);
+    }
+    let updated;
+    if (part.type === "TEXT" && data.text !== void 0) {
+      updated = { ...part, text: data.text };
+    } else if (part.type === "TOOL") {
+      updated = {
+        ...part,
+        toolOutput: data.toolOutput ?? part.toolOutput,
+        toolStatus: data.toolStatus ?? part.toolStatus,
+        toolMeta: data.toolMeta ?? part.toolMeta
+      };
+    } else if (part.type === "REASONING" && data.reasoning !== void 0) {
+      updated = { ...part, reasoning: data.reasoning };
+    } else {
+      updated = part;
+    }
+    this.storage.parts.set(id, updated);
+    return updated;
+  }
+  async appendPartText(id, delta) {
+    const part = this.storage.parts.get(id);
+    if (!part || part.type !== "TEXT") {
+      throw new Error(`Text part not found: ${id}`);
+    }
+    const updated = {
+      ...part,
+      text: (part.text ?? "") + delta
+    };
+    this.storage.parts.set(id, updated);
+  }
+  async appendPartReasoning(id, delta) {
+    const part = this.storage.parts.get(id);
+    if (!part || part.type !== "REASONING") {
+      throw new Error(`Reasoning part not found: ${id}`);
+    }
+    const updated = {
+      ...part,
+      reasoning: (part.reasoning ?? "") + delta
+    };
+    this.storage.parts.set(id, updated);
+  }
+  // ---- Batch Operations ----
+  async batchSaveMessage(input) {
+    const message = await this.createMessage({
+      sessionId: input.sessionId,
+      parentId: input.parentId,
+      role: input.role,
+      agent: input.agent,
+      providerId: input.providerId,
+      modelId: input.modelId
+    });
+    const updated = await this.updateMessage(message.id, {
+      finish: input.finish,
+      cost: input.cost,
+      tokens: input.tokens,
+      completedAt: input.completedAt
+    });
+    const parts = [];
+    for (const partInput of input.parts) {
+      const part = await this.createPart(message.id, partInput);
+      parts.push(part);
+    }
+    return { ...updated, parts };
+  }
+  async batchUpdateSession(input) {
+    await this.updateSession(input.sessionId, {
+      totalCost: input.totalCost,
+      totalTokens: input.totalTokens
+    });
+  }
+  // ---- Utility ----
+  /**
+   * 清空所有存储（用于测试）
+   */
+  clear() {
+    this.storage = createStorage();
+  }
+  /**
+   * 获取存储统计
+   */
+  stats() {
+    return {
+      sessions: this.storage.sessions.size,
+      messages: this.storage.messages.size,
+      parts: this.storage.parts.size
+    };
+  }
+};
+function createMemoryStore() {
+  return new MemorySessionStore();
+}
+
+// src/utils/log.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var currentLevel = process.env.LOG_LEVEL || "info";
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel];
+}
+function formatMessage(level, service, message, data) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const dataStr = data ? ` ${JSON.stringify(data)}` : "";
+  return `[${timestamp}] [${level.toUpperCase()}] [${service}] ${message}${dataStr}`;
+}
+function createLogger(service) {
+  return {
+    debug(message, data) {
+      if (shouldLog("debug")) {
+        console.debug(formatMessage("debug", service, message, data));
+      }
+    },
+    info(message, data) {
+      if (shouldLog("info")) {
+        console.info(formatMessage("info", service, message, data));
+      }
+    },
+    warn(message, data) {
+      if (shouldLog("warn")) {
+        console.warn(formatMessage("warn", service, message, data));
+      }
+    },
+    error(message, data) {
+      if (shouldLog("error")) {
+        console.error(formatMessage("error", service, message, data));
+      }
+    }
+  };
+}
+
+// src/core/session.ts
+var log = createLogger("session");
+async function createSession(input) {
+  log.info("Creating session", { agent: input.agent, mode: input.mode });
+  return getSessionStore().createSession(input);
+}
+async function getSession(id) {
+  return getSessionStore().getSession(id);
+}
+async function updateSession(id, data) {
+  return getSessionStore().updateSession(id, data);
+}
+async function deleteSession(id) {
+  return getSessionStore().deleteSession(id);
+}
+async function listSessions(options) {
+  return getSessionStore().listSessions(options);
+}
+async function createMessage(data) {
+  return getSessionStore().createMessage(data);
+}
+async function getMessage(id) {
+  return getSessionStore().getMessage(id);
+}
+async function updateMessage(id, data) {
+  return getSessionStore().updateMessage(id, data);
+}
+async function getSessionMessages(sessionId2) {
+  return getSessionStore().getSessionMessages(sessionId2);
+}
+async function createPart(messageId2, data) {
+  return getSessionStore().createPart(messageId2, data);
+}
+async function updatePart(id, data) {
+  return getSessionStore().updatePart(id, data);
+}
+async function batchSaveMessage(input) {
+  log.info("Batch saving message", {
+    sessionId: input.sessionId,
+    role: input.role,
+    partsCount: input.parts.length
+  });
+  return getSessionStore().batchSaveMessage(input);
+}
+async function batchUpdateSession(input) {
+  return getSessionStore().batchUpdateSession(input);
+}
+
+// src/utils/error.ts
+var OpenAgentError = class extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "OpenAgentError";
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      data: this.data
+    };
+  }
+};
+var SessionNotFoundError = class extends OpenAgentError {
+  constructor(sessionId2) {
+    super(`Session not found: ${sessionId2}`, "SESSION_NOT_FOUND", { sessionId: sessionId2 });
+    this.name = "SessionNotFoundError";
+  }
+};
+var SessionBusyError = class extends OpenAgentError {
+  constructor(sessionId2) {
+    super(`Session is busy: ${sessionId2}`, "SESSION_BUSY", { sessionId: sessionId2 });
+    this.name = "SessionBusyError";
+  }
+};
+var AgentNotFoundError = class extends OpenAgentError {
+  constructor(agentName) {
+    super(`Agent not found: ${agentName}`, "AGENT_NOT_FOUND", { agentName });
+    this.name = "AgentNotFoundError";
+  }
+};
+var ModelNotFoundError = class extends OpenAgentError {
+  constructor(providerId, modelId) {
+    super(
+      `Model not found: ${providerId}/${modelId}`,
+      "MODEL_NOT_FOUND",
+      { providerId, modelId }
+    );
+    this.name = "ModelNotFoundError";
+  }
+};
+var ToolExecutionError = class extends OpenAgentError {
+  constructor(toolName, message, cause) {
+    super(`Tool execution failed: ${toolName} - ${message}`, "TOOL_EXECUTION_ERROR", {
+      toolName,
+      cause: cause?.message
+    });
+    this.name = "ToolExecutionError";
+    if (cause) {
+      this.cause = cause;
+    }
+  }
+};
+var PermissionDeniedError = class extends OpenAgentError {
+  constructor(permission, pattern) {
+    super(
+      `Permission denied: ${permission} for ${pattern}`,
+      "PERMISSION_DENIED",
+      { permission, pattern }
+    );
+    this.name = "PermissionDeniedError";
+  }
+};
+var McpConnectionError = class extends OpenAgentError {
+  constructor(serverName, message) {
+    super(
+      `MCP connection failed: ${serverName} - ${message}`,
+      "MCP_CONNECTION_ERROR",
+      { serverName }
+    );
+    this.name = "McpConnectionError";
+  }
+};
+var ProviderApiError = class extends OpenAgentError {
+  constructor(message, statusCode, provider) {
+    super(message, "PROVIDER_API_ERROR", { statusCode, provider });
+    this.statusCode = statusCode;
+    this.provider = provider;
+    this.name = "ProviderApiError";
+  }
+};
+var ContextOverflowError = class extends OpenAgentError {
+  constructor(maxTokens, currentTokens) {
+    super(
+      `Context overflow: ${currentTokens} tokens exceeds limit of ${maxTokens}`,
+      "CONTEXT_OVERFLOW",
+      { maxTokens, currentTokens }
+    );
+    this.name = "ContextOverflowError";
+  }
+};
+function toMessageError(error) {
+  if (error instanceof OpenAgentError) {
+    return {
+      name: error.name,
+      message: error.message,
+      code: error.code
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message
+    };
+  }
+  return {
+    name: "Error",
+    message: String(error)
+  };
+}
+function extractErrorInfo(error) {
+  if (error instanceof OpenAgentError) {
+    return {
+      type: error.name,
+      message: error.message,
+      details: { code: error.code, ...error.data }
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      type: error.name,
+      message: error.message,
+      details: error.cause ? { cause: String(error.cause) } : void 0
+    };
+  }
+  return {
+    type: "UnknownError",
+    message: String(error)
+  };
+}
+
+// src/core/agent.ts
+var DEFAULT_AGENTS = {
+  "general": {
+    name: "general",
+    displayName: "General Assistant",
+    description: "A general-purpose AI assistant",
+    systemPrompt: `You are a helpful AI assistant.
+
+You have access to tools that allow you to:
+- Read, write, and edit files
+- Search files with glob patterns
+- Search file contents with grep
+- Execute bash commands
+- Fetch web content
+
+When working on tasks:
+1. First understand the request fully
+2. Break down complex tasks into steps
+3. Use tools to gather information before making changes
+4. Verify your changes work as expected
+
+Be precise, efficient, and thorough in your work.`
+  },
+  "coder": {
+    name: "coder",
+    displayName: "Code Assistant",
+    description: "Specialized in writing and modifying code",
+    systemPrompt: `You are an expert software developer AI assistant.
+
+## Your Capabilities
+- Read and analyze code files
+- Write new code and create files
+- Edit existing code with precise modifications
+- Search codebases efficiently
+- Execute commands to test and build code
+
+## Code Quality Guidelines
+- Write clean, maintainable code
+- Follow existing code style and conventions
+- Include appropriate comments and documentation
+- Handle errors gracefully
+- Use TypeScript types properly
+
+## Working Process
+1. Understand the requirements
+2. Explore the codebase to understand the context
+3. Plan your changes
+4. Implement changes incrementally
+5. Verify changes work correctly
+
+Be precise with edits - always read a file before editing it to ensure accuracy.`
+  }
+};
+var runtimeAgents = /* @__PURE__ */ new Map();
+function getDefaultAgent(name) {
+  return DEFAULT_AGENTS[name];
+}
+function getDefaultAgentNames() {
+  return Object.keys(DEFAULT_AGENTS);
+}
+function getAllAgentNames() {
+  const names = /* @__PURE__ */ new Set([
+    ...Object.keys(DEFAULT_AGENTS),
+    ...runtimeAgents.keys()
+  ]);
+  return Array.from(names);
+}
+function getAgent(name) {
+  const runtimeAgent = runtimeAgents.get(name);
+  if (runtimeAgent) {
+    return runtimeAgent;
+  }
+  const defaultAgent = DEFAULT_AGENTS[name];
+  if (!defaultAgent) {
+    throw new AgentNotFoundError(name);
+  }
+  return defaultAgent;
+}
+function registerAgent(agent) {
+  runtimeAgents.set(agent.name, agent);
+}
+function registerAgents(agents) {
+  for (const agent of agents) {
+    registerAgent(agent);
+  }
+}
+function unregisterAgent(name) {
+  return runtimeAgents.delete(name);
+}
+function clearAgents() {
+  runtimeAgents.clear();
+}
+var log2 = createLogger("provider");
+var providers = {};
+var providerInstances = /* @__PURE__ */ new Map();
+function configureProvider(config) {
+  log2.info("Configuring provider", { id: config.id, type: config.type });
+  providers[config.id] = config;
+  providerInstances.delete(config.id);
+}
+function configureProviders(configs) {
+  for (const config of configs) {
+    configureProvider(config);
+  }
+}
+function configureFromOpenCodeConfig(config) {
+  for (const [providerId, providerConfig] of Object.entries(config.provider)) {
+    let type = "openai";
+    if (providerId === "anthropic" || providerId.includes("anthropic")) {
+      type = "anthropic";
+    } else if (providerId === "google" || providerId.includes("google") || providerId.includes("gemini")) {
+      type = "google";
+    }
+    const models = Object.entries(providerConfig.models).map(([modelId, model]) => ({
+      id: model.id || modelId,
+      name: model.name || modelId,
+      contextWindow: model.limit?.context || 128e3,
+      maxOutput: model.limit?.output || 8192,
+      supportsFunctions: model.tool_call ?? true,
+      supportsVision: model.attachment ?? false,
+      supportsStreaming: true
+    }));
+    configureProvider({
+      id: providerId,
+      name: providerId.charAt(0).toUpperCase() + providerId.slice(1),
+      type,
+      options: {
+        baseURL: providerConfig.options.baseURL,
+        apiKey: providerConfig.options.apiKey,
+        headers: providerConfig.options.headers
+      },
+      models
+    });
+  }
+}
+function resetProviders() {
+  providers = {};
+  providerInstances.clear();
+}
+function getOrCreateProviderInstance(providerId) {
+  const cached = providerInstances.get(providerId);
+  if (cached) return cached;
+  const config = providers[providerId];
+  if (!config) {
+    throw new ModelNotFoundError(providerId, "unknown");
+  }
+  log2.debug("Creating provider instance", {
+    providerId,
+    type: config.type,
+    hasBaseURL: !!config.options.baseURL,
+    hasApiKey: !!config.options.apiKey
+  });
+  let instance;
+  switch (config.type) {
+    case "anthropic": {
+      const options = {};
+      if (config.options.baseURL) {
+        options.baseURL = config.options.baseURL;
+      }
+      if (config.options.apiKey) {
+        options.apiKey = config.options.apiKey;
+      }
+      if (config.options.headers) {
+        options.headers = config.options.headers;
+      }
+      instance = createAnthropic(options);
+      break;
+    }
+    case "openai": {
+      const options = {};
+      if (config.options.baseURL) {
+        options.baseURL = config.options.baseURL;
+      }
+      if (config.options.apiKey) {
+        options.apiKey = config.options.apiKey;
+      }
+      if (config.options.headers) {
+        options.headers = config.options.headers;
+      }
+      instance = createOpenAI(options);
+      break;
+    }
+    case "google": {
+      const options = {};
+      if (config.options.baseURL) {
+        options.baseURL = config.options.baseURL;
+      }
+      if (config.options.apiKey) {
+        options.apiKey = config.options.apiKey;
+      }
+      if (config.options.headers) {
+        options.headers = config.options.headers;
+      }
+      instance = createGoogleGenerativeAI(options);
+      break;
+    }
+    default:
+      throw new Error(`Unknown provider type: ${config.type}`);
+  }
+  providerInstances.set(providerId, instance);
+  return instance;
+}
+var PROVIDERS = new Proxy({}, {
+  get(_, key) {
+    const config = providers[key];
+    if (!config) return void 0;
+    return {
+      id: config.id,
+      name: config.name,
+      models: config.models
+    };
+  },
+  ownKeys() {
+    return Object.keys(providers);
+  },
+  getOwnPropertyDescriptor() {
+    return { enumerable: true, configurable: true };
+  }
+});
+function getProviders() {
+  return Object.values(providers).map((config) => ({
+    id: config.id,
+    name: config.name,
+    models: config.models
+  }));
+}
+function getProvider(providerId) {
+  const config = providers[providerId];
+  if (!config) return void 0;
+  return {
+    id: config.id,
+    name: config.name,
+    models: config.models
+  };
+}
+function getModelInfo(providerId, modelId) {
+  const config = providers[providerId];
+  if (!config) return void 0;
+  return config.models.find((m) => m.id === modelId);
+}
+function getLanguageModel(providerId, modelId) {
+  const config = providers[providerId];
+  if (!config) {
+    throw new ModelNotFoundError(providerId, modelId);
+  }
+  const modelInfo = config.models.find((m) => m.id === modelId);
+  if (!modelInfo) {
+    log2.warn("Model not in registry, creating anyway", { providerId, modelId });
+  }
+  log2.debug("Creating language model", { providerId, modelId, type: config.type });
+  const instance = getOrCreateProviderInstance(providerId);
+  if (config.type === "openai" && providerId === "zhipuai") {
+    return instance.chat(modelId);
+  }
+  return instance(modelId);
+}
+function getDefaultModel() {
+  const defaultProvider = process.env.DEFAULT_AI_PROVIDER || "anthropic";
+  const defaultModel = process.env.DEFAULT_AI_MODEL || "claude-3-5-haiku";
+  return {
+    providerId: defaultProvider,
+    modelId: defaultModel
+  };
+}
+function calculateCost(providerId, modelId, tokens) {
+  const modelInfo = getModelInfo(providerId, modelId);
+  if (!modelInfo?.pricing) return 0;
+  const { pricing } = modelInfo;
+  let cost = 0;
+  cost += tokens.input / 1e6 * pricing.input;
+  cost += tokens.output / 1e6 * pricing.output;
+  if (tokens.cache && pricing.cache) {
+    cost += tokens.cache.read / 1e6 * pricing.cache.read;
+    cost += tokens.cache.write / 1e6 * pricing.cache.write;
+  }
+  return cost;
+}
+var encoder = null;
+function getEncoder() {
+  if (!encoder) {
+    encoder = getEncoding("cl100k_base");
+  }
+  return encoder;
+}
+function estimateTokens(text) {
+  if (!text) return 0;
+  try {
+    return getEncoder().encode(text).length;
+  } catch {
+    return Math.ceil(text.length / 4);
+  }
+}
+function estimateJsonTokens(obj) {
+  try {
+    return estimateTokens(JSON.stringify(obj));
+  } catch {
+    return 0;
+  }
+}
+function estimateMessageTokens(message) {
+  let tokens = 0;
+  tokens += 4;
+  if (typeof message.content === "string") {
+    tokens += estimateTokens(message.content);
+  } else if (Array.isArray(message.content)) {
+    for (const part of message.content) {
+      if (part.type === "text") {
+        tokens += estimateTokens(part.text);
+      } else if (part.type === "image") {
+        tokens += 1e3;
+      } else if (part.type === "tool-call") {
+        tokens += estimateTokens(part.toolName);
+        tokens += estimateJsonTokens(part.input);
+      } else if (part.type === "tool-result") {
+        tokens += estimateJsonTokens(part.output);
+      }
+    }
+  }
+  return tokens;
+}
+function estimateMessagesTokens(messages) {
+  let total = 0;
+  for (const message of messages) {
+    total += estimateMessageTokens(message);
+  }
+  total += 3;
+  return total;
+}
+
+// src/utils/truncation.ts
+var log3 = createLogger("truncation");
+var DEFAULT_TRUNCATION_CONFIG = {
+  maxLines: 2e3,
+  maxBytes: 50 * 1024,
+  lineMaxLength: 2e3
+};
+function truncateLine(line, maxLength) {
+  if (line.length <= maxLength) return line;
+  return line.substring(0, maxLength) + "... (line truncated)";
+}
+function truncateSimple(text, maxLength = 1e5) {
+  if (text.length <= maxLength) {
+    return { content: text, truncated: false };
+  }
+  return {
+    content: text.substring(0, maxLength) + "\n\n... (output truncated)",
+    truncated: true
+  };
+}
+function truncateToolOutput(output, config) {
+  const cfg = { ...DEFAULT_TRUNCATION_CONFIG, ...config };
+  const lines = output.split("\n");
+  const totalBytes = Buffer.byteLength(output, "utf-8");
+  if (lines.length <= cfg.maxLines && totalBytes <= cfg.maxBytes) {
+    const truncatedLines2 = lines.map((line) => truncateLine(line, cfg.lineMaxLength));
+    return {
+      content: truncatedLines2.join("\n"),
+      truncated: false
+    };
+  }
+  const truncatedLines = [];
+  let currentBytes = 0;
+  for (let i = 0; i < lines.length && i < cfg.maxLines; i++) {
+    const line = truncateLine(lines[i], cfg.lineMaxLength);
+    const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
+    if (currentBytes + lineBytes > cfg.maxBytes) {
+      break;
+    }
+    truncatedLines.push(line);
+    currentBytes += lineBytes;
+  }
+  const removedLines = lines.length - truncatedLines.length;
+  const removedBytes = totalBytes - currentBytes;
+  const hint = `
+
+... (${removedLines} lines / ${removedBytes} bytes truncated)`;
+  return {
+    content: truncatedLines.join("\n") + hint,
+    truncated: true
+  };
+}
+var DEFAULT_SMART_TRUNCATION_CONFIG = {
+  maxTokens: 1e4,
+  headRatio: 0.3,
+  tailRatio: 0.7
+};
+function truncateForAI(text, config) {
+  const cfg = { ...DEFAULT_SMART_TRUNCATION_CONFIG, ...config };
+  const originalTokens = estimateTokens(text);
+  if (originalTokens <= cfg.maxTokens) {
+    return {
+      content: text,
+      truncated: false,
+      originalTokens,
+      keptTokens: originalTokens
+    };
+  }
+  const lines = text.split("\n");
+  const totalLines = lines.length;
+  const headTokens = Math.floor(cfg.maxTokens * cfg.headRatio);
+  const tailTokens = Math.floor(cfg.maxTokens * cfg.tailRatio);
+  const headLines = [];
+  let headTokenCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const lineTokens = estimateTokens(lines[i]);
+    if (headTokenCount + lineTokens > headTokens) {
+      break;
+    }
+    headLines.push(lines[i]);
+    headTokenCount += lineTokens;
+  }
+  const tailLines = [];
+  let tailTokenCount = 0;
+  for (let i = lines.length - 1; i >= headLines.length; i--) {
+    const lineTokens = estimateTokens(lines[i]);
+    if (tailTokenCount + lineTokens > tailTokens) {
+      break;
+    }
+    tailLines.unshift(lines[i]);
+    tailTokenCount += lineTokens;
+  }
+  const omittedLines = totalLines - headLines.length - tailLines.length;
+  const omittedTokens = originalTokens - headTokenCount - tailTokenCount;
+  const separator = cfg.partId ? `
+
+... [${omittedLines} lines / ~${omittedTokens} tokens omitted]
+[Use read_tool_output with partId="${cfg.partId}" to see full content]
+
+` : `
+
+... [${omittedLines} lines / ~${omittedTokens} tokens omitted]
+
+`;
+  const truncatedContent = headLines.join("\n") + separator + tailLines.join("\n");
+  const keptTokens = headTokenCount + tailTokenCount + estimateTokens(separator);
+  log3.debug("Smart truncation applied", {
+    originalTokens,
+    keptTokens,
+    headLines: headLines.length,
+    tailLines: tailLines.length,
+    omittedLines
+  });
+  return {
+    content: truncatedContent,
+    truncated: true,
+    originalTokens,
+    keptTokens
+  };
+}
+
+// src/core/llm.ts
+var log4 = createLogger("llm");
+var TOOL_OUTPUT_MAX_TOKENS = 1e4;
+var TOOL_OUTPUT_TRUNCATION_CONFIG = {
+  maxTokens: TOOL_OUTPUT_MAX_TOKENS,
+  headRatio: 0.3,
+  tailRatio: 0.7
+};
+function toModelOutput(output) {
+  if (typeof output === "string") {
+    return { type: "text", value: output };
+  }
+  if (typeof output === "object" && output !== null) {
+    const obj = output;
+    if (obj.text !== void 0) {
+      return { type: "text", value: obj.text };
+    }
+    return { type: "json", value: output };
+  }
+  return { type: "json", value: output };
+}
+async function toModelMessages(messages) {
+  const result = [];
+  const toolNames = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (msg.parts.length === 0) continue;
+    if (msg.role === "USER") {
+      const userMessage = {
+        id: msg.id,
+        role: "user",
+        parts: []
+      };
+      for (const part of msg.parts) {
+        if (part.type === "TEXT" && part.text) {
+          userMessage.parts.push({
+            type: "text",
+            text: part.text
+          });
+        }
+        if (part.type === "FILE" && part.fileUrl) {
+          if (part.fileMime?.startsWith("image/")) {
+            userMessage.parts.push({
+              type: "file",
+              url: part.fileUrl,
+              mediaType: part.fileMime,
+              filename: part.fileName
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            });
+          }
+        }
+      }
+      if (userMessage.parts.length > 0) {
+        result.push(userMessage);
+      }
+    } else if (msg.role === "ASSISTANT") {
+      const assistantMessage = {
+        id: msg.id,
+        role: "assistant",
+        parts: []
+      };
+      for (const part of msg.parts) {
+        if (part.type === "TEXT" && part.text) {
+          assistantMessage.parts.push({
+            type: "text",
+            text: part.text
+          });
+        }
+        if (part.type === "REASONING" && part.reasoning) {
+          assistantMessage.parts.push({
+            type: "reasoning",
+            text: part.reasoning
+          });
+        }
+        if (part.type === "TOOL" && part.toolName && part.toolCallId) {
+          toolNames.add(part.toolName);
+          if (part.toolStatus === "COMPLETED") {
+            let output;
+            if (part.prunedAt) {
+              output = `[Tool output pruned - use read_tool_output tool with partId="${part.id}" to retrieve if needed]`;
+            } else {
+              const rawOutput = part.toolOutput || "";
+              const truncateResult = truncateForAI(rawOutput, {
+                ...TOOL_OUTPUT_TRUNCATION_CONFIG,
+                partId: part.id
+              });
+              output = truncateResult.content;
+            }
+            assistantMessage.parts.push({
+              type: `tool-${part.toolName}`,
+              state: "output-available",
+              toolCallId: part.toolCallId,
+              input: part.toolInput || {},
+              output
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            });
+          } else if (part.toolStatus === "ERROR") {
+            assistantMessage.parts.push({
+              type: `tool-${part.toolName}`,
+              state: "output-error",
+              toolCallId: part.toolCallId,
+              input: part.toolInput || {},
+              errorText: part.toolOutput || "Tool execution failed"
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            });
+          } else {
+            assistantMessage.parts.push({
+              type: `tool-${part.toolName}`,
+              state: "output-error",
+              toolCallId: part.toolCallId,
+              input: part.toolInput || {},
+              errorText: "[Tool execution was interrupted]"
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            });
+          }
+        }
+      }
+      if (assistantMessage.parts.length > 0) {
+        result.push(assistantMessage);
+      }
+    }
+  }
+  const tools = Object.fromEntries(
+    Array.from(toolNames).map((toolName) => [toolName, { toModelOutput }])
+  );
+  let modelMessages = await convertToModelMessages(result, {
+    // @ts-expect-error convertToModelMessages expects a ToolSet but only actually needs tools[name]?.toModelOutput
+    tools
+  });
+  modelMessages = modelMessages.map((msg) => {
+    if (typeof msg.content === "string") {
+      if (msg.content === "") return void 0;
+      return msg;
+    }
+    if (!Array.isArray(msg.content)) return msg;
+    const filtered = msg.content.filter((part) => {
+      if (part.type === "text" || part.type === "reasoning") {
+        return part.text !== "" && part.text !== void 0;
+      }
+      return true;
+    });
+    if (filtered.length === 0) return void 0;
+    return { ...msg, content: filtered };
+  }).filter((msg) => msg !== void 0 && msg.content !== "");
+  return modelMessages;
+}
+var CONTEXT_OVERFLOW_PATTERNS = [
+  /prompt is too long/i,
+  /input is too long/i,
+  /exceeds.*context/i,
+  /token.*limit.*exceeded/i,
+  /context.*overflow/i,
+  /maximum.*context.*length/i,
+  /too many tokens/i,
+  /request too large/i
+];
+function isContextOverflowError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return CONTEXT_OVERFLOW_PATTERNS.some((pattern) => pattern.test(message));
+}
+async function stream(input) {
+  const { providerId, modelId, messages, system, tools, temperature, abort, maxSteps = 10 } = input;
+  log4.info("Starting LLM stream", {
+    providerId,
+    modelId,
+    messageCount: messages.length,
+    hasSystem: !!system,
+    toolCount: tools ? Object.keys(tools).length : 0,
+    maxSteps
+  });
+  const model = getLanguageModel(providerId, modelId);
+  const streamOptions = {
+    model,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    messages,
+    system,
+    tools,
+    temperature,
+    abortSignal: abort,
+    stopWhen: stepCountIs(maxSteps)
+  };
+  if (input.maxOutputTokens) {
+    streamOptions.maxTokens = input.maxOutputTokens;
+  }
+  const response = streamText(streamOptions);
+  let resolvedUsage = null;
+  async function* convertStream() {
+    try {
+      for await (const event of (await response).fullStream) {
+        const e = event;
+        switch (e.type) {
+          case "text-delta":
+            yield { type: "text-delta", text: e.text ?? e.textDelta ?? "" };
+            break;
+          case "reasoning-delta":
+            yield { type: "reasoning-delta", text: e.text ?? e.textDelta ?? "" };
+            break;
+          case "tool-call":
+            yield {
+              type: "tool-call",
+              toolCallId: e.toolCallId,
+              toolName: e.toolName,
+              args: e.args ?? e.input ?? {}
+            };
+            break;
+          case "tool-result":
+            yield {
+              type: "tool-result",
+              toolCallId: e.toolCallId,
+              result: e.result ?? e.output
+            };
+            break;
+          case "finish":
+            const usage = await (await response).usage;
+            const tokens = {
+              input: usage?.inputTokens ?? usage?.promptTokens ?? 0,
+              output: usage?.outputTokens ?? usage?.completionTokens ?? 0
+            };
+            const cost = calculateCost(providerId, modelId, tokens);
+            resolvedUsage = { tokens, cost };
+            yield {
+              type: "finish",
+              finishReason: e.finishReason,
+              usage: resolvedUsage
+            };
+            break;
+          case "error":
+            yield { type: "error", error: e.error };
+            break;
+        }
+      }
+    } catch (error) {
+      log4.error("LLM stream error", { error: String(error) });
+      yield { type: "error", error };
+    }
+  }
+  return {
+    fullStream: convertStream(),
+    textPromise: (async () => {
+      const result = await response;
+      return await result.text;
+    })(),
+    usagePromise: (async () => {
+      if (resolvedUsage) return resolvedUsage;
+      const result = await response;
+      const usage = await result.usage;
+      const tokens = {
+        input: usage?.inputTokens ?? usage?.promptTokens ?? 0,
+        output: usage?.outputTokens ?? usage?.completionTokens ?? 0
+      };
+      return {
+        tokens,
+        cost: calculateCost(providerId, modelId, tokens)
+      };
+    })()
+  };
+}
+var TOOL_USAGE_GUIDELINES = `
+## Tool Usage Guidelines
+
+### Parallel Tool Execution
+- You can call multiple tools in a single response when the calls are independent
+- This significantly reduces latency when you need to:
+  - Read multiple files
+  - Run multiple searches
+  - Fetch multiple web pages
+`;
+function buildSystemPrompt(agent, additionalContext) {
+  const parts = [];
+  parts.push(agent.systemPrompt);
+  parts.push(TOOL_USAGE_GUIDELINES);
+  if (additionalContext) {
+    parts.push("");
+    parts.push(additionalContext);
+  }
+  return parts.join("\n");
+}
+function defineTool(config) {
+  return {
+    id: config.id,
+    description: config.description,
+    parameters: config.parameters,
+    execute: async (args, ctx) => {
+      try {
+        config.parameters.parse(args);
+      } catch (error) {
+        if (error instanceof z.ZodError) {
+          const zodError = error;
+          const messages = zodError.issues?.map((e) => e.message).join(", ") ?? String(error);
+          throw new Error(`Tool "${config.id}" received invalid arguments: ${messages}`);
+        }
+        throw error;
+      }
+      return config.execute(args, ctx);
+    }
+  };
+}
+function toAITool(toolDef, ctx) {
+  const inputSchema = zodSchema(toolDef.parameters);
+  const tool = {
+    description: toolDef.description,
+    inputSchema,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    execute: async (args, options) => {
+      const fullCtx = {
+        ...ctx,
+        callId: options?.toolCallId
+      };
+      const result = await toolDef.execute(args, fullCtx);
+      return result.output;
+    }
+  };
+  return tool;
+}
+function toAITools(tools, ctx) {
+  const result = {};
+  for (const tool of tools) {
+    result[tool.id] = toAITool(tool, ctx);
+  }
+  return result;
+}
+
+// src/types.ts
+var TOOL_PERMISSIONS = {
+  // 只读工具 - plan 模式下允许
+  readonly: [
+    "read",
+    // 读取文件
+    "glob",
+    // 文件模式匹配
+    "grep",
+    // 内容搜索
+    "list",
+    // 列出目录
+    "bash",
+    // Shell 命令 (plan 模式下仅限只读命令，由 system prompt 约束)
+    "webfetch",
+    // 获取网页内容
+    "websearch",
+    // 网页搜索
+    "codesearch",
+    // 代码搜索
+    "read_tool_output",
+    // 读取工具输出
+    "batch",
+    // 批量执行 (只能批量执行 plan 模式允许的工具)
+    "todoread"
+    // 读取待办事项
+  ],
+  // 写操作工具 - 仅 build 模式下允许
+  write: [
+    "write",
+    // 写入文件
+    "edit",
+    // 编辑文件
+    "todowrite",
+    // 写入待办事项
+    "task",
+    // 创建子任务 (可能触发写操作)
+    "question",
+    // 询问用户 (仅 build 模式需要交互)
+    "skill"
+    // 加载技能 (可能包含写操作)
+  ]
+};
+function getAllowedToolsForMode(mode) {
+  if (mode === "plan") {
+    return [...TOOL_PERMISSIONS.readonly];
+  }
+  return [...TOOL_PERMISSIONS.readonly, ...TOOL_PERMISSIONS.write];
+}
+function isToolAllowedInMode(toolId, mode) {
+  if (mode === "build") {
+    return true;
+  }
+  return TOOL_PERMISSIONS.readonly.includes(toolId);
+}
+function getModeChangePrompt(from, to) {
+  if (from === "plan" && to === "build") {
+    return `<system-reminder>
+Your operational mode has changed from plan to build.
+You are no longer in read-only mode.
+You are permitted to make file changes, run shell commands, and utilize your arsenal of tools as needed.
+</system-reminder>`;
+  }
+  if (from === "build" && to === "plan") {
+    return `<system-reminder>
+Your operational mode has changed from build to plan.
+You are now in read-only mode.
+You MUST NOT make any file edits, write new files, or run shell commands that have side effects.
+You are only permitted to use read-only tools for analysis, exploration, and planning.
+Focus on understanding the codebase and creating a detailed plan for the task.
+</system-reminder>`;
+  }
+  return "";
+}
+
+// src/tool/registry.ts
+var log5 = createLogger("tool-registry");
+var registeredTools = /* @__PURE__ */ new Map();
+function registerTool(tool) {
+  log5.info("Registering tool", { id: tool.id });
+  registeredTools.set(tool.id, tool);
+}
+function registerTools(tools) {
+  for (const tool of tools) {
+    registerTool(tool);
+  }
+}
+function getTool(id) {
+  return registeredTools.get(id);
+}
+function getAllTools() {
+  return Array.from(registeredTools.values());
+}
+function unregisterTool(id) {
+  return registeredTools.delete(id);
+}
+function clearTools() {
+  registeredTools.clear();
+}
+function getToolsForAgent(agent, mode) {
+  const allTools = getAllTools();
+  return allTools.filter((tool) => {
+    if (mode && !isToolAllowedInMode(tool.id, mode)) {
+      return false;
+    }
+    if (agent.allowedTools && agent.allowedTools.length > 0) {
+      return agent.allowedTools.includes(tool.id);
+    }
+    if (agent.deniedTools && agent.deniedTools.length > 0) {
+      return !agent.deniedTools.includes(tool.id);
+    }
+    return true;
+  });
+}
+function getAIToolsForAgent(agent, ctx, mode) {
+  const tools = getToolsForAgent(agent, mode);
+  const result = {};
+  for (const tool of tools) {
+    result[tool.id] = toAITool(tool, ctx);
+  }
+  return result;
+}
+function getToolsForMode(mode) {
+  const allTools = getAllTools();
+  return allTools.filter((tool) => isToolAllowedInMode(tool.id, mode));
+}
+function getToolDescriptions(tools) {
+  return tools.map((tool) => `- ${tool.id}: ${tool.description}`).join("\n");
+}
+var DEFAULT_TIMEOUT = 12e4;
+async function localBashExecutor(args, ctx) {
+  const { command, workdir, timeout = DEFAULT_TIMEOUT } = args;
+  const cwd = workdir ?? ctx.workingDirectory ?? process.cwd();
+  return new Promise((resolve6, reject) => {
+    const child = spawn("bash", ["-c", command], {
+      cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    const timeoutId = setTimeout(() => {
+      killed = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) {
+          child.kill("SIGKILL");
+        }
+      }, 5e3);
+    }, timeout);
+    const abortHandler = () => {
+      killed = true;
+      child.kill("SIGTERM");
+      clearTimeout(timeoutId);
+    };
+    ctx.abort.addEventListener("abort", abortHandler);
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      clearTimeout(timeoutId);
+      ctx.abort.removeEventListener("abort", abortHandler);
+      if (killed && ctx.abort.aborted) {
+        reject(new Error("Command aborted"));
+        return;
+      }
+      if (killed) {
+        resolve6({
+          title: `Command timed out after ${timeout}ms`,
+          output: `TIMEOUT: Command exceeded ${timeout}ms limit.
+
+Partial stdout:
+${stdout}
+
+Partial stderr:
+${stderr}`
+        });
+        return;
+      }
+      let output = "";
+      if (stdout) {
+        output += stdout;
+      }
+      if (stderr) {
+        output += (output ? "\n\n" : "") + `stderr:
+${stderr}`;
+      }
+      if (!output) {
+        output = "(no output)";
+      }
+      if (code !== 0) {
+        output += `
+
+(exit code: ${code})`;
+      }
+      resolve6({
+        title: args.description ?? `bash: ${command.slice(0, 50)}${command.length > 50 ? "..." : ""}`,
+        output,
+        metadata: {
+          exitCode: code,
+          cwd
+        }
+      });
+    });
+    child.on("error", (err) => {
+      clearTimeout(timeoutId);
+      ctx.abort.removeEventListener("abort", abortHandler);
+      reject(err);
+    });
+  });
+}
+var DEFAULT_LIMIT = 2e3;
+var MAX_LINE_LENGTH = 2e3;
+async function localReadExecutor(args, ctx) {
+  const { filePath, offset = 0, limit = DEFAULT_LIMIT } = args;
+  const absolutePath = isAbsolute(filePath) ? filePath : resolve(ctx.workingDirectory ?? process.cwd(), filePath);
+  if (!existsSync(absolutePath)) {
+    return {
+      title: `File not found: ${filePath}`,
+      output: `Error: File does not exist at path: ${absolutePath}`
+    };
+  }
+  const stats = await stat(absolutePath);
+  if (stats.isDirectory()) {
+    return {
+      title: `Path is a directory: ${filePath}`,
+      output: `Error: Path is a directory, not a file: ${absolutePath}`
+    };
+  }
+  const content = await readFile(absolutePath, "utf-8");
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  const startLine = offset;
+  const endLine = Math.min(startLine + limit, totalLines);
+  const selectedLines = lines.slice(startLine, endLine);
+  const maxLineNum = endLine;
+  const lineNumWidth = String(maxLineNum).length;
+  const formattedLines = selectedLines.map((line, idx) => {
+    const lineNum = startLine + idx + 1;
+    const paddedNum = String(lineNum).padStart(lineNumWidth, " ");
+    const truncatedLine = line.length > MAX_LINE_LENGTH ? line.slice(0, MAX_LINE_LENGTH) + "... (truncated)" : line;
+    return `${paddedNum}	${truncatedLine}`;
+  });
+  let output = formattedLines.join("\n");
+  if (startLine > 0 || endLine < totalLines) {
+    output = `<file>
+${output}
+
+(Showing lines ${startLine + 1}-${endLine} of ${totalLines} total)
+</file>`;
+  } else {
+    output = `<file>
+${output}
+
+(End of file - total ${totalLines} lines)
+</file>`;
+  }
+  return {
+    title: `Read ${filePath}`,
+    output,
+    metadata: {
+      path: absolutePath,
+      totalLines,
+      startLine: startLine + 1,
+      endLine
+    }
+  };
+}
+async function localWriteExecutor(args, ctx) {
+  const { filePath, content } = args;
+  const absolutePath = isAbsolute(filePath) ? filePath : resolve(ctx.workingDirectory ?? process.cwd(), filePath);
+  const existed = existsSync(absolutePath);
+  const dir = dirname(absolutePath);
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  await writeFile(absolutePath, content, "utf-8");
+  const lines = content.split("\n").length;
+  return {
+    title: existed ? `Updated ${filePath}` : `Created ${filePath}`,
+    output: `Successfully ${existed ? "updated" : "created"} file: ${absolutePath}
+
+File contains ${lines} lines.`,
+    metadata: {
+      path: absolutePath,
+      lines,
+      created: !existed
+    }
+  };
+}
+
+// src/tool/local/edit-replacers.ts
+var SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0;
+var MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3;
+function levenshtein(a, b) {
+  if (a === "" || b === "") {
+    return Math.max(a.length, b.length);
+  }
+  const matrix = Array.from(
+    { length: a.length + 1 },
+    (_, i) => Array.from({ length: b.length + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
+  );
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+    }
+  }
+  return matrix[a.length][b.length];
+}
+var SimpleReplacer = function* (_content, find) {
+  yield find;
+};
+var LineTrimmedReplacer = function* (content, find) {
+  const originalLines = content.split("\n");
+  const searchLines = find.split("\n");
+  if (searchLines[searchLines.length - 1] === "") {
+    searchLines.pop();
+  }
+  for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
+    let matches = true;
+    for (let j = 0; j < searchLines.length; j++) {
+      const originalTrimmed = originalLines[i + j].trim();
+      const searchTrimmed = searchLines[j].trim();
+      if (originalTrimmed !== searchTrimmed) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      let matchStartIndex = 0;
+      for (let k = 0; k < i; k++) {
+        matchStartIndex += originalLines[k].length + 1;
+      }
+      let matchEndIndex = matchStartIndex;
+      for (let k = 0; k < searchLines.length; k++) {
+        matchEndIndex += originalLines[i + k].length;
+        if (k < searchLines.length - 1) {
+          matchEndIndex += 1;
+        }
+      }
+      yield content.substring(matchStartIndex, matchEndIndex);
+    }
+  }
+};
+var BlockAnchorReplacer = function* (content, find) {
+  const originalLines = content.split("\n");
+  const searchLines = find.split("\n");
+  if (searchLines.length < 3) {
+    return;
+  }
+  if (searchLines[searchLines.length - 1] === "") {
+    searchLines.pop();
+  }
+  const firstLineSearch = searchLines[0].trim();
+  const lastLineSearch = searchLines[searchLines.length - 1].trim();
+  const searchBlockSize = searchLines.length;
+  const candidates = [];
+  for (let i = 0; i < originalLines.length; i++) {
+    if (originalLines[i].trim() !== firstLineSearch) {
+      continue;
+    }
+    for (let j = i + 2; j < originalLines.length; j++) {
+      if (originalLines[j].trim() === lastLineSearch) {
+        candidates.push({ startLine: i, endLine: j });
+        break;
+      }
+    }
+  }
+  if (candidates.length === 0) {
+    return;
+  }
+  if (candidates.length === 1) {
+    const { startLine, endLine } = candidates[0];
+    const actualBlockSize = endLine - startLine + 1;
+    let similarity = 0;
+    const linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2);
+    if (linesToCheck > 0) {
+      for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+        const originalLine = originalLines[startLine + j].trim();
+        const searchLine = searchLines[j].trim();
+        const maxLen = Math.max(originalLine.length, searchLine.length);
+        if (maxLen === 0) {
+          continue;
+        }
+        const distance = levenshtein(originalLine, searchLine);
+        similarity += (1 - distance / maxLen) / linesToCheck;
+        if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+          break;
+        }
+      }
+    } else {
+      similarity = 1;
+    }
+    if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+      let matchStartIndex = 0;
+      for (let k = 0; k < startLine; k++) {
+        matchStartIndex += originalLines[k].length + 1;
+      }
+      let matchEndIndex = matchStartIndex;
+      for (let k = startLine; k <= endLine; k++) {
+        matchEndIndex += originalLines[k].length;
+        if (k < endLine) {
+          matchEndIndex += 1;
+        }
+      }
+      yield content.substring(matchStartIndex, matchEndIndex);
+    }
+    return;
+  }
+  let bestMatch = null;
+  let maxSimilarity = -1;
+  for (const candidate of candidates) {
+    const { startLine, endLine } = candidate;
+    const actualBlockSize = endLine - startLine + 1;
+    let similarity = 0;
+    const linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2);
+    if (linesToCheck > 0) {
+      for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+        const originalLine = originalLines[startLine + j].trim();
+        const searchLine = searchLines[j].trim();
+        const maxLen = Math.max(originalLine.length, searchLine.length);
+        if (maxLen === 0) {
+          continue;
+        }
+        const distance = levenshtein(originalLine, searchLine);
+        similarity += 1 - distance / maxLen;
+      }
+      similarity /= linesToCheck;
+    } else {
+      similarity = 1;
+    }
+    if (similarity > maxSimilarity) {
+      maxSimilarity = similarity;
+      bestMatch = candidate;
+    }
+  }
+  if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD && bestMatch) {
+    const { startLine, endLine } = bestMatch;
+    let matchStartIndex = 0;
+    for (let k = 0; k < startLine; k++) {
+      matchStartIndex += originalLines[k].length + 1;
+    }
+    let matchEndIndex = matchStartIndex;
+    for (let k = startLine; k <= endLine; k++) {
+      matchEndIndex += originalLines[k].length;
+      if (k < endLine) {
+        matchEndIndex += 1;
+      }
+    }
+    yield content.substring(matchStartIndex, matchEndIndex);
+  }
+};
+var WhitespaceNormalizedReplacer = function* (content, find) {
+  const normalizeWhitespace = (text) => text.replace(/\s+/g, " ").trim();
+  const normalizedFind = normalizeWhitespace(find);
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (normalizeWhitespace(line) === normalizedFind) {
+      yield line;
+    } else {
+      const normalizedLine = normalizeWhitespace(line);
+      if (normalizedLine.includes(normalizedFind)) {
+        const words = find.trim().split(/\s+/);
+        if (words.length > 0) {
+          const pattern = words.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+");
+          try {
+            const regex = new RegExp(pattern);
+            const match = line.match(regex);
+            if (match) {
+              yield match[0];
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  const findLines = find.split("\n");
+  if (findLines.length > 1) {
+    for (let i = 0; i <= lines.length - findLines.length; i++) {
+      const block = lines.slice(i, i + findLines.length);
+      if (normalizeWhitespace(block.join("\n")) === normalizedFind) {
+        yield block.join("\n");
+      }
+    }
+  }
+};
+var IndentationFlexibleReplacer = function* (content, find) {
+  const removeIndentation = (text) => {
+    const lines = text.split("\n");
+    const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+    if (nonEmptyLines.length === 0) return text;
+    const minIndent = Math.min(
+      ...nonEmptyLines.map((line) => {
+        const match = line.match(/^(\s*)/);
+        return match ? match[1].length : 0;
+      })
+    );
+    return lines.map((line) => line.trim().length === 0 ? line : line.slice(minIndent)).join("\n");
+  };
+  const normalizedFind = removeIndentation(find);
+  const contentLines = content.split("\n");
+  const findLines = find.split("\n");
+  for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+    const block = contentLines.slice(i, i + findLines.length).join("\n");
+    if (removeIndentation(block) === normalizedFind) {
+      yield block;
+    }
+  }
+};
+var EscapeNormalizedReplacer = function* (content, find) {
+  const unescapeString = (str) => {
+    return str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (match, capturedChar) => {
+      switch (capturedChar) {
+        case "n":
+          return "\n";
+        case "t":
+          return "	";
+        case "r":
+          return "\r";
+        case "'":
+          return "'";
+        case '"':
+          return '"';
+        case "`":
+          return "`";
+        case "\\":
+          return "\\";
+        case "\n":
+          return "\n";
+        case "$":
+          return "$";
+        default:
+          return match;
+      }
+    });
+  };
+  const unescapedFind = unescapeString(find);
+  if (content.includes(unescapedFind)) {
+    yield unescapedFind;
+  }
+  const lines = content.split("\n");
+  const findLines = unescapedFind.split("\n");
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join("\n");
+    const unescapedBlock = unescapeString(block);
+    if (unescapedBlock === unescapedFind) {
+      yield block;
+    }
+  }
+};
+var TrimmedBoundaryReplacer = function* (content, find) {
+  const trimmedFind = find.trim();
+  if (trimmedFind === find) {
+    return;
+  }
+  if (content.includes(trimmedFind)) {
+    yield trimmedFind;
+  }
+  const lines = content.split("\n");
+  const findLines = find.split("\n");
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join("\n");
+    if (block.trim() === trimmedFind) {
+      yield block;
+    }
+  }
+};
+var ContextAwareReplacer = function* (content, find) {
+  const findLines = find.split("\n");
+  if (findLines.length < 3) {
+    return;
+  }
+  if (findLines[findLines.length - 1] === "") {
+    findLines.pop();
+  }
+  const contentLines = content.split("\n");
+  const firstLine = findLines[0].trim();
+  const lastLine = findLines[findLines.length - 1].trim();
+  for (let i = 0; i < contentLines.length; i++) {
+    if (contentLines[i].trim() !== firstLine) continue;
+    for (let j = i + 2; j < contentLines.length; j++) {
+      if (contentLines[j].trim() === lastLine) {
+        const blockLines = contentLines.slice(i, j + 1);
+        const block = blockLines.join("\n");
+        if (blockLines.length === findLines.length) {
+          let matchingLines = 0;
+          let totalNonEmptyLines = 0;
+          for (let k = 1; k < blockLines.length - 1; k++) {
+            const blockLine = blockLines[k].trim();
+            const findLine = findLines[k].trim();
+            if (blockLine.length > 0 || findLine.length > 0) {
+              totalNonEmptyLines++;
+              if (blockLine === findLine) {
+                matchingLines++;
+              }
+            }
+          }
+          if (totalNonEmptyLines === 0 || matchingLines / totalNonEmptyLines >= 0.5) {
+            yield block;
+            break;
+          }
+        }
+        break;
+      }
+    }
+  }
+};
+var MultiOccurrenceReplacer = function* (content, find) {
+  let startIndex = 0;
+  while (true) {
+    const index = content.indexOf(find, startIndex);
+    if (index === -1) break;
+    yield find;
+    startIndex = index + find.length;
+  }
+};
+var ALL_REPLACERS = [
+  SimpleReplacer,
+  LineTrimmedReplacer,
+  BlockAnchorReplacer,
+  WhitespaceNormalizedReplacer,
+  IndentationFlexibleReplacer,
+  EscapeNormalizedReplacer,
+  TrimmedBoundaryReplacer,
+  ContextAwareReplacer,
+  MultiOccurrenceReplacer
+];
+function smartReplace(content, oldString, newString, replaceAll = false) {
+  if (oldString === newString) {
+    throw new Error("oldString and newString must be different");
+  }
+  let notFound = true;
+  for (const replacer of ALL_REPLACERS) {
+    for (const search of replacer(content, oldString)) {
+      const index = content.indexOf(search);
+      if (index === -1) continue;
+      notFound = false;
+      if (replaceAll) {
+        return {
+          newContent: content.replaceAll(search, newString),
+          matchedString: search
+        };
+      }
+      const lastIndex = content.lastIndexOf(search);
+      if (index !== lastIndex) continue;
+      return {
+        newContent: content.substring(0, index) + newString + content.substring(index + search.length),
+        matchedString: search
+      };
+    }
+  }
+  if (notFound) {
+    throw new Error("oldString not found in file content");
+  }
+  throw new Error(
+    "Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match."
+  );
+}
+
+// src/tool/local/edit.ts
+async function localEditExecutor(args, ctx) {
+  const { filePath, oldString, newString, replaceAll = false } = args;
+  const absolutePath = isAbsolute(filePath) ? filePath : resolve(ctx.workingDirectory ?? process.cwd(), filePath);
+  if (!existsSync(absolutePath)) {
+    return {
+      title: `File not found: ${filePath}`,
+      output: `Error: File does not exist at path: ${absolutePath}`
+    };
+  }
+  const content = await readFile(absolutePath, "utf-8");
+  try {
+    const { newContent, matchedString } = smartReplace(content, oldString, newString, replaceAll);
+    await writeFile(absolutePath, newContent, "utf-8");
+    const oldLines = content.split("\n").length;
+    const newLines = newContent.split("\n").length;
+    const lineDiff = newLines - oldLines;
+    let output = `Successfully edited ${absolutePath}`;
+    if (matchedString !== oldString) {
+      output += `
+
+Note: Used fuzzy matching to find the text.`;
+    }
+    output += `
+
+Lines: ${oldLines} -> ${newLines} (${lineDiff >= 0 ? "+" : ""}${lineDiff})`;
+    return {
+      title: `Edited ${filePath}`,
+      output,
+      metadata: {
+        path: absolutePath,
+        oldLines,
+        newLines,
+        lineDiff,
+        fuzzyMatch: matchedString !== oldString
+      }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      title: `Edit failed: ${filePath}`,
+      output: `Error: ${message}`
+    };
+  }
+}
+var MAX_RESULTS = 500;
+async function localGlobExecutor(args, ctx) {
+  const { pattern, path } = args;
+  const basePath = path ? isAbsolute(path) ? path : resolve(ctx.workingDirectory ?? process.cwd(), path) : ctx.workingDirectory ?? process.cwd();
+  try {
+    const files = await glob(pattern, {
+      cwd: basePath,
+      nodir: true,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/.git/**"]
+    });
+    if (files.length === 0) {
+      return {
+        title: `No files found matching: ${pattern}`,
+        output: `No files found matching pattern "${pattern}" in ${basePath}`
+      };
+    }
+    const filesWithStats = await Promise.all(
+      files.slice(0, MAX_RESULTS).map(async (file) => {
+        try {
+          const stats = await stat(file);
+          return { file, mtime: stats.mtime };
+        } catch {
+          return { file, mtime: /* @__PURE__ */ new Date(0) };
+        }
+      })
+    );
+    filesWithStats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    const sortedFiles = filesWithStats.map((f) => f.file);
+    let output = sortedFiles.join("\n");
+    if (files.length > MAX_RESULTS) {
+      output += `
+
+(Showing ${MAX_RESULTS} of ${files.length} files)`;
+    }
+    return {
+      title: `Found ${files.length} files matching: ${pattern}`,
+      output,
+      metadata: {
+        count: files.length,
+        pattern,
+        basePath,
+        truncated: files.length > MAX_RESULTS
+      }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      title: `Glob error: ${pattern}`,
+      output: `Error searching for files: ${message}`
+    };
+  }
+}
+var MAX_FILES = 100;
+var MAX_MATCHES_PER_FILE = 10;
+var MAX_TOTAL_MATCHES = 200;
+async function localGrepExecutor(args, ctx) {
+  const { pattern, path, include } = args;
+  const basePath = path ? isAbsolute(path) ? path : resolve(ctx.workingDirectory ?? process.cwd(), path) : ctx.workingDirectory ?? process.cwd();
+  try {
+    const regex = new RegExp(pattern, "g");
+    const filePattern = include ?? "**/*";
+    const files = await glob(filePattern, {
+      cwd: basePath,
+      nodir: true,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/.git/**", "**/*.lock", "**/*.min.js", "**/*.min.css"]
+    });
+    const matches = [];
+    let filesSearched = 0;
+    let totalMatches = 0;
+    for (const file of files.slice(0, MAX_FILES)) {
+      if (totalMatches >= MAX_TOTAL_MATCHES) break;
+      try {
+        const stats = await stat(file);
+        if (stats.size > 1024 * 1024) continue;
+        const content = await readFile(file, "utf-8");
+        const lines = content.split("\n");
+        let fileMatches = 0;
+        for (let i = 0; i < lines.length; i++) {
+          if (fileMatches >= MAX_MATCHES_PER_FILE) break;
+          if (totalMatches >= MAX_TOTAL_MATCHES) break;
+          const line = lines[i];
+          if (regex.test(line)) {
+            matches.push({
+              file,
+              line: i + 1,
+              content: line.slice(0, 200) + (line.length > 200 ? "..." : ""),
+              mtime: stats.mtime
+            });
+            fileMatches++;
+            totalMatches++;
+          }
+          regex.lastIndex = 0;
+        }
+        filesSearched++;
+      } catch {
+      }
+    }
+    if (matches.length === 0) {
+      return {
+        title: `No matches found for: ${pattern}`,
+        output: `No matches found for pattern "${pattern}" in ${basePath}
+
+Searched ${filesSearched} files.`
+      };
+    }
+    matches.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    const output = matches.map((m) => `${m.file}:${m.line}: ${m.content}`).join("\n");
+    return {
+      title: `Found ${matches.length} matches for: ${pattern}`,
+      output: output + (totalMatches >= MAX_TOTAL_MATCHES ? `
+
+(Showing first ${MAX_TOTAL_MATCHES} matches)` : ""),
+      metadata: {
+        matches: matches.length,
+        filesSearched,
+        pattern,
+        basePath,
+        truncated: totalMatches >= MAX_TOTAL_MATCHES
+      }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      title: `Grep error: ${pattern}`,
+      output: `Error searching files: ${message}`
+    };
+  }
+}
+
+// src/tool/builtin/read.ts
+var readTool = defineTool({
+  id: "read",
+  description: `Read a file from the filesystem.
+
+Usage:
+- The filePath parameter must be an absolute path, not a relative path
+- By default, it reads up to 2000 lines starting from the beginning
+- You can optionally specify a line offset and limit for long files
+- Results are returned with line numbers (cat -n format)`,
+  parameters: z.object({
+    filePath: z.string().describe("The absolute path to the file to read"),
+    offset: z.number().optional().describe("The line number to start reading from (0-based)"),
+    limit: z.number().optional().describe("The number of lines to read (defaults to 2000)")
+  }),
+  execute: async (args, ctx) => {
+    return localReadExecutor(args, ctx);
+  }
+});
+var writeTool = defineTool({
+  id: "write",
+  description: `Write content to a file. Creates the file if it doesn't exist, or overwrites if it does.
+
+Usage:
+- ALWAYS prefer editing existing files with the 'edit' tool
+- Only use this for creating new files or complete rewrites
+- The directory will be created if it doesn't exist`,
+  parameters: z.object({
+    filePath: z.string().describe("The absolute path to the file to write"),
+    content: z.string().describe("The content to write to the file")
+  }),
+  execute: async (args, ctx) => {
+    return localWriteExecutor(args, ctx);
+  }
+});
+var editTool = defineTool({
+  id: "edit",
+  description: `Edit a file by replacing specific text.
+
+Usage:
+- You must read the file first before editing
+- Provide the exact text to find (oldString) and the replacement text (newString)
+- The edit uses smart matching to handle minor whitespace/indentation differences
+- Use replaceAll to replace all occurrences of the text`,
+  parameters: z.object({
+    filePath: z.string().describe("The absolute path to the file to modify"),
+    oldString: z.string().describe("The text to replace"),
+    newString: z.string().describe("The text to replace it with"),
+    replaceAll: z.boolean().optional().describe("Replace all occurrences (default false)")
+  }),
+  execute: async (args, ctx) => {
+    return localEditExecutor(args, ctx);
+  }
+});
+var globTool = defineTool({
+  id: "glob",
+  description: `Find files matching a glob pattern.
+
+Usage:
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this to find files by name patterns`,
+  parameters: z.object({
+    pattern: z.string().describe("The glob pattern to match files against"),
+    path: z.string().optional().describe("The directory to search in (defaults to working directory)")
+  }),
+  execute: async (args, ctx) => {
+    return localGlobExecutor(args, ctx);
+  }
+});
+var grepTool = defineTool({
+  id: "grep",
+  description: `Search file contents using regular expressions.
+
+Usage:
+- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
+- Filter files by pattern with the include parameter
+- Returns file paths and line numbers with matches`,
+  parameters: z.object({
+    pattern: z.string().describe("The regex pattern to search for in file contents"),
+    path: z.string().optional().describe("The directory to search in (defaults to working directory)"),
+    include: z.string().optional().describe('File pattern to include (e.g., "*.js", "*.{ts,tsx}")')
+  }),
+  execute: async (args, ctx) => {
+    return localGrepExecutor(args, ctx);
+  }
+});
+var bashTool = defineTool({
+  id: "bash",
+  description: `Execute a bash command and return the output. Use this for system operations.
+
+IMPORTANT: 
+- Commands will timeout after 2 minutes (120000ms) by default.
+- For long-running commands (servers, watch processes), add '&' at the end to run in background.
+
+Examples:
+- Normal command: npm install
+- Background command: npm run dev &`,
+  parameters: z.object({
+    command: z.string().describe("The bash command to execute"),
+    workdir: z.string().optional().describe("The working directory to run the command in"),
+    timeout: z.number().optional().describe("Timeout in milliseconds. Default is 120000 (2 minutes)."),
+    description: z.string().optional().describe("A short description of what this command does")
+  }),
+  execute: async (args, ctx) => {
+    return localBashExecutor(args, ctx);
+  }
+});
+var webfetchTool = defineTool({
+  id: "webfetch",
+  description: "Fetch content from a URL. Returns the content in the specified format.",
+  parameters: z.object({
+    url: z.string().describe("The URL to fetch"),
+    method: z.enum(["GET", "POST", "PUT", "DELETE"]).optional().describe("HTTP method (default: GET)"),
+    headers: z.record(z.string(), z.string()).optional().describe("Request headers"),
+    body: z.string().optional().describe("Request body (for POST/PUT)"),
+    format: z.enum(["text", "json", "markdown"]).optional().describe("Response format (default: text)"),
+    timeout: z.number().optional().describe("Timeout in milliseconds (default: 30000)")
+  }),
+  execute: async (args, ctx) => {
+    const { url, method, headers, body, format, timeout } = args;
+    const actualMethod = method ?? "GET";
+    const actualFormat = format ?? "text";
+    const actualTimeout = timeout ?? 3e4;
+    await ctx.metadata({ title: `Fetching ${url}` });
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), actualTimeout);
+    try {
+      const response = await fetch(url, {
+        method: actualMethod,
+        headers: {
+          "User-Agent": "OpenAgent/1.0",
+          ...headers
+        },
+        body: actualMethod !== "GET" ? body : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return {
+          title: `HTTP ${response.status}`,
+          output: `HTTP Error: ${response.status} ${response.statusText}`,
+          metadata: {
+            status: response.status,
+            statusText: response.statusText
+          }
+        };
+      }
+      let content;
+      const contentType = response.headers.get("content-type") || "";
+      if (actualFormat === "json" || contentType.includes("application/json")) {
+        const json = await response.json();
+        content = JSON.stringify(json, null, 2);
+      } else {
+        content = await response.text();
+      }
+      const maxLength = 5e4;
+      if (content.length > maxLength) {
+        content = content.substring(0, maxLength) + "\n\n... (truncated)";
+      }
+      return {
+        title: `Fetched ${url}`,
+        output: content,
+        metadata: {
+          status: response.status,
+          contentType,
+          contentLength: content.length
+        }
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        return {
+          title: "Request timeout",
+          output: `Request to ${url} timed out after ${actualTimeout}ms`,
+          metadata: { error: "timeout" }
+        };
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        title: "Fetch failed",
+        output: `Failed to fetch ${url}: ${message}`,
+        metadata: { error: message }
+      };
+    }
+  }
+});
+var questionTool = defineTool({
+  id: "question",
+  description: "Ask the user a question and wait for their response. Use this when you need clarification or user input.",
+  parameters: z.object({
+    question: z.string().describe("The question to ask the user"),
+    options: z.array(z.object({
+      label: z.string().describe("Short label for the option"),
+      description: z.string().optional().describe("Description of the option")
+    })).optional().describe("Predefined options for the user to choose from"),
+    multiple: z.boolean().optional().describe("Whether the user can select multiple options")
+  }),
+  execute: async (args, ctx) => {
+    const { question, options, multiple } = args;
+    await ctx.metadata({
+      title: "Waiting for user input",
+      metadata: { question, options, multiple }
+    });
+    return {
+      title: "Question asked",
+      output: `[WAITING_FOR_USER_INPUT]
+Question: ${question}
+${options ? `Options: ${options.map((o) => o.label).join(", ")}` : "Free-form input expected"}`,
+      metadata: {
+        question,
+        options,
+        multiple,
+        waitingForInput: true
+      }
+    };
+  }
+});
+
+// src/tool/builtin/index.ts
+var builtinTools = [
+  // 文件操作工具
+  readTool,
+  writeTool,
+  editTool,
+  // 搜索工具
+  globTool,
+  grepTool,
+  // 命令执行
+  bashTool,
+  // 交互和辅助工具
+  webfetchTool,
+  questionTool
+];
+function getBuiltinTools() {
+  return builtinTools;
+}
+
+// src/agent.ts
+var log6 = createLogger("OpenAgent");
+var DEFAULT_MODELS = {
+  anthropic: {
+    id: "claude-sonnet-4-20250514",
+    contextWindow: 2e5,
+    maxOutput: 8192
+  },
+  openai: {
+    id: "gpt-4o",
+    contextWindow: 128e3,
+    maxOutput: 4096
+  },
+  google: {
+    id: "gemini-1.5-pro",
+    contextWindow: 1e6,
+    maxOutput: 8192
+  }
+};
+var OpenAgent = class {
+  constructor(options = {}) {
+    this.options = options;
+    const providerType = options.provider ?? "anthropic";
+    const defaultModel = DEFAULT_MODELS[providerType];
+    this.providerId = providerType;
+    this.modelId = options.model ?? defaultModel.id;
+    this.mode = options.mode ?? "build";
+    this.maxSteps = options.maxSteps ?? 10;
+    this.temperature = options.temperature;
+    this.maxOutputTokens = options.maxOutputTokens;
+    this.workingDirectory = options.workingDirectory ?? process.cwd();
+    this.customTools = options.tools ?? [];
+    this.agent = options.agent ?? {
+      name: "default",
+      systemPrompt: `You are a helpful AI assistant with access to tools.
+
+When working on tasks:
+1. Understand the request fully before acting
+2. Use tools to gather information and make changes
+3. Be precise and verify your work
+
+You can read, write, and edit files, search code, and execute commands.`
+    };
+  }
+  providerId;
+  modelId;
+  agent;
+  mode;
+  maxSteps;
+  temperature;
+  maxOutputTokens;
+  workingDirectory;
+  sessionId;
+  initialized = false;
+  customTools = [];
+  /**
+   * 初始化（延迟初始化，首次调用时执行）
+   */
+  async ensureInitialized() {
+    if (this.initialized) return;
+    log6.info("Initializing OpenAgent...");
+    if (this.options.sessionStore) {
+      setSessionStore(this.options.sessionStore);
+    } else {
+      setSessionStore(createMemoryStore());
+    }
+    if (this.options.providerConfig) {
+      configureProvider(this.options.providerConfig);
+    } else if (this.options.apiKey) {
+      const providerType = this.options.provider ?? "anthropic";
+      const defaultModel = DEFAULT_MODELS[providerType];
+      configureProvider({
+        id: providerType,
+        name: providerType.charAt(0).toUpperCase() + providerType.slice(1),
+        type: providerType,
+        options: {
+          apiKey: this.options.apiKey,
+          baseURL: this.options.baseURL,
+          headers: this.options.headers
+        },
+        models: [{
+          id: this.modelId,
+          name: this.modelId,
+          contextWindow: defaultModel.contextWindow,
+          maxOutput: defaultModel.maxOutput,
+          supportsFunctions: true,
+          supportsVision: true,
+          supportsStreaming: true
+        }]
+      });
+    }
+    if (this.options.useBuiltinTools !== false) {
+      registerTools(builtinTools);
+      log6.info("Registered builtin tools", { count: builtinTools.length });
+    }
+    if (this.customTools.length > 0) {
+      registerTools(this.customTools);
+      log6.info("Registered custom tools", { count: this.customTools.length });
+    }
+    registerAgent(this.agent);
+    this.initialized = true;
+    log6.info("OpenAgent initialized", {
+      provider: this.providerId,
+      model: this.modelId,
+      mode: this.mode
+    });
+  }
+  /**
+   * 获取或创建 Session
+   */
+  async getOrCreateSession() {
+    await this.ensureInitialized();
+    if (this.sessionId) {
+      const session2 = await getSession(this.sessionId);
+      if (session2) return this.sessionId;
+    }
+    const session = await createSession({
+      agent: this.agent.name,
+      mode: this.mode
+    });
+    this.sessionId = session.id;
+    return session.id;
+  }
+  /**
+   * 构建 ToolContext
+   */
+  createToolContext(sessionId2, messageId2) {
+    const abortController = new AbortController();
+    return {
+      sessionId: sessionId2,
+      messageId: messageId2,
+      agent: this.agent.name,
+      abort: abortController.signal,
+      workingDirectory: this.workingDirectory,
+      model: {
+        providerId: this.providerId,
+        modelId: this.modelId
+      },
+      metadata: async () => {
+      },
+      ask: async () => {
+      }
+    };
+  }
+  /**
+   * 执行工具调用
+   */
+  async executeTool(toolName, args, ctx) {
+    const tool = getTool(toolName);
+    if (!tool) {
+      return {
+        title: `Unknown tool: ${toolName}`,
+        output: `Error: Tool "${toolName}" is not registered`
+      };
+    }
+    try {
+      return await tool.execute(args, ctx);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        title: `Tool error: ${toolName}`,
+        output: `Error executing tool: ${message}`
+      };
+    }
+  }
+  /**
+   * 非流式对话（带 Agent Loop）
+   */
+  async chat(message, options) {
+    await this.ensureInitialized();
+    const sessionId2 = options?.sessionId ?? await this.getOrCreateSession();
+    await batchSaveMessage({
+      sessionId: sessionId2,
+      role: "USER",
+      parts: [{ type: "TEXT", text: message }]
+    });
+    const msgId = `msg_${Date.now()}`;
+    const ctx = this.createToolContext(sessionId2, msgId);
+    const tools = getAIToolsForAgent(this.agent, ctx, this.mode);
+    let fullText = "";
+    const toolCalls = [];
+    let totalUsage = { input: 0, output: 0 };
+    let totalCost = 0;
+    let finishReason = "unknown";
+    let step = 0;
+    while (step < this.maxSteps) {
+      step++;
+      log6.debug(`Agent loop step ${step}/${this.maxSteps}`);
+      const messages = await getSessionMessages(sessionId2);
+      const modelMessages = await toModelMessages(messages);
+      const result = await stream({
+        providerId: this.providerId,
+        modelId: this.modelId,
+        messages: modelMessages,
+        system: buildSystemPrompt(this.agent),
+        tools,
+        temperature: this.temperature,
+        maxOutputTokens: this.maxOutputTokens,
+        maxSteps: 1
+        // 每次只执行一步，由我们控制循环
+      });
+      let stepText = "";
+      const stepToolCalls = [];
+      for await (const event of result.fullStream) {
+        switch (event.type) {
+          case "text-delta":
+            stepText += event.text;
+            break;
+          case "tool-call":
+            stepToolCalls.push({
+              id: event.toolCallId,
+              name: event.toolName,
+              args: event.args,
+              status: "PENDING"
+            });
+            break;
+          case "finish":
+            finishReason = event.finishReason;
+            totalUsage.input += event.usage.tokens.input;
+            totalUsage.output += event.usage.tokens.output;
+            totalCost += event.usage.cost;
+            break;
+        }
+      }
+      if (stepText) {
+        fullText += (fullText && stepText ? "\n" : "") + stepText;
+      }
+      if (stepToolCalls.length === 0) {
+        if (stepText) {
+          await batchSaveMessage({
+            sessionId: sessionId2,
+            role: "ASSISTANT",
+            parts: [{ type: "TEXT", text: stepText }]
+          });
+        }
+        break;
+      }
+      const assistantParts = [];
+      if (stepText) {
+        assistantParts.push({ type: "TEXT", text: stepText });
+      }
+      for (const call of stepToolCalls) {
+        log6.debug(`Executing tool: ${call.name}`, { args: call.args });
+        const result2 = await this.executeTool(call.name, call.args, ctx);
+        call.output = result2.output;
+        call.status = "COMPLETED";
+        toolCalls.push({
+          name: call.name,
+          input: call.args,
+          output: result2.output,
+          status: "COMPLETED"
+        });
+        assistantParts.push({
+          type: "TOOL",
+          toolName: call.name,
+          toolCallId: call.id,
+          toolInput: call.args,
+          toolOutput: result2.output,
+          toolStatus: "COMPLETED"
+        });
+      }
+      await batchSaveMessage({
+        sessionId: sessionId2,
+        role: "ASSISTANT",
+        parts: assistantParts
+      });
+    }
+    return {
+      text: fullText,
+      toolCalls,
+      usage: totalUsage,
+      cost: totalCost,
+      finishReason,
+      sessionId: sessionId2
+    };
+  }
+  /**
+   * 流式对话
+   */
+  async *stream(message, options) {
+    await this.ensureInitialized();
+    const sessionId2 = options?.sessionId ?? await this.getOrCreateSession();
+    await batchSaveMessage({
+      sessionId: sessionId2,
+      role: "USER",
+      parts: [{ type: "TEXT", text: message }]
+    });
+    const msgId = `msg_${Date.now()}`;
+    const ctx = this.createToolContext(sessionId2, msgId);
+    const tools = getAIToolsForAgent(this.agent, ctx, this.mode);
+    let fullText = "";
+    const toolCalls = [];
+    let totalUsage = { input: 0, output: 0 };
+    let totalCost = 0;
+    let finishReason = "unknown";
+    let step = 0;
+    try {
+      while (step < this.maxSteps) {
+        step++;
+        const messages = await getSessionMessages(sessionId2);
+        const modelMessages = await toModelMessages(messages);
+        const result = await stream({
+          providerId: this.providerId,
+          modelId: this.modelId,
+          messages: modelMessages,
+          system: buildSystemPrompt(this.agent),
+          tools,
+          temperature: this.temperature,
+          maxOutputTokens: this.maxOutputTokens,
+          maxSteps: 1
+        });
+        let stepText = "";
+        const stepToolCalls = [];
+        for await (const event of result.fullStream) {
+          switch (event.type) {
+            case "text-delta":
+              stepText += event.text;
+              yield { type: "text", text: event.text };
+              break;
+            case "reasoning-delta":
+              yield { type: "reasoning", text: event.text };
+              break;
+            case "tool-call":
+              stepToolCalls.push({
+                id: event.toolCallId,
+                name: event.toolName,
+                args: event.args,
+                status: "PENDING"
+              });
+              yield {
+                type: "tool-start",
+                name: event.toolName,
+                input: event.args
+              };
+              break;
+            case "finish":
+              finishReason = event.finishReason;
+              totalUsage.input += event.usage.tokens.input;
+              totalUsage.output += event.usage.tokens.output;
+              totalCost += event.usage.cost;
+              break;
+            case "error":
+              yield { type: "error", error: event.error };
+              return;
+          }
+        }
+        if (stepText) {
+          fullText += (fullText && stepText ? "\n" : "") + stepText;
+        }
+        if (stepToolCalls.length === 0) {
+          if (stepText) {
+            await batchSaveMessage({
+              sessionId: sessionId2,
+              role: "ASSISTANT",
+              parts: [{ type: "TEXT", text: stepText }]
+            });
+          }
+          break;
+        }
+        const assistantParts = [];
+        if (stepText) {
+          assistantParts.push({ type: "TEXT", text: stepText });
+        }
+        for (const call of stepToolCalls) {
+          const toolResult = await this.executeTool(call.name, call.args, ctx);
+          call.output = toolResult.output;
+          call.status = "COMPLETED";
+          toolCalls.push({
+            name: call.name,
+            input: call.args,
+            output: toolResult.output,
+            status: "COMPLETED"
+          });
+          yield {
+            type: "tool-end",
+            name: call.name,
+            output: toolResult.output
+          };
+          assistantParts.push({
+            type: "TOOL",
+            toolName: call.name,
+            toolCallId: call.id,
+            toolInput: call.args,
+            toolOutput: toolResult.output,
+            toolStatus: "COMPLETED"
+          });
+        }
+        await batchSaveMessage({
+          sessionId: sessionId2,
+          role: "ASSISTANT",
+          parts: assistantParts
+        });
+      }
+      yield {
+        type: "done",
+        result: {
+          text: fullText,
+          toolCalls,
+          usage: totalUsage,
+          cost: totalCost,
+          finishReason,
+          sessionId: sessionId2
+        }
+      };
+    } catch (error) {
+      yield { type: "error", error };
+    }
+  }
+  /**
+   * 继续已有会话
+   */
+  continueSession(sessionId2) {
+    this.sessionId = sessionId2;
+    return this;
+  }
+  /**
+   * 开始新会话
+   */
+  newSession() {
+    this.sessionId = void 0;
+    return this;
+  }
+  /**
+   * 添加自定义工具
+   */
+  addTool(tool) {
+    this.customTools.push(tool);
+    if (this.initialized) {
+      registerTools([tool]);
+    }
+    return this;
+  }
+  /**
+   * 设置模式
+   */
+  setMode(mode) {
+    this.mode = mode;
+    return this;
+  }
+};
+function createAgent(options) {
+  return new OpenAgent(options);
+}
+function anthropic(apiKey, model) {
+  return new OpenAgent({
+    provider: "anthropic",
+    apiKey,
+    model: model ?? "claude-sonnet-4-20250514"
+  });
+}
+function openai(apiKey, model) {
+  return new OpenAgent({
+    provider: "openai",
+    apiKey,
+    model: model ?? "gpt-4o"
+  });
+}
+function google(apiKey, model) {
+  return new OpenAgent({
+    provider: "google",
+    apiKey,
+    model: model ?? "gemini-1.5-pro"
+  });
+}
+
+// src/index.ts
+var log7 = createLogger("openagent");
+var initialized = false;
+async function initOpenAgent(config) {
+  if (initialized) {
+    log7.info("OpenAgent already initialized");
+    return;
+  }
+  log7.info("Initializing OpenAgent...");
+  setSessionStore(createMemoryStore());
+  log7.info("Using memory session store");
+  if (config?.registerBuiltinTools !== false) {
+    registerTools(builtinTools);
+    log7.info("Registered builtin tools", { count: builtinTools.length });
+  }
+  if (config?.providers && config.providers.length > 0) {
+    configureProviders(config.providers);
+    log7.info("Configured providers", { count: config.providers.length });
+  }
+  initialized = true;
+  log7.info("OpenAgent initialized");
+}
+function isInitialized() {
+  return initialized;
+}
+function resetOpenAgent() {
+  initialized = false;
+}
+
+export { AgentNotFoundError, ContextOverflowError, McpConnectionError, MemorySessionStore, ModelNotFoundError, OpenAgent, OpenAgentError, PROVIDERS, PermissionDeniedError, ProviderApiError, SessionBusyError, SessionNotFoundError, TOOL_PERMISSIONS, ToolExecutionError, anthropic, bashTool, batchSaveMessage, batchUpdateSession, buildSystemPrompt, builtinTools, calculateCost, clearAgents, clearTools, configureFromOpenCodeConfig, configureProvider, configureProviders, createAgent, createLogger, createMemoryStore, createMessage, createPart, createSession, defineTool, deleteSession, editTool, estimateJsonTokens, estimateMessageTokens, estimateMessagesTokens, estimateTokens, extractErrorInfo, generateId, getAIToolsForAgent, getAgent, getAllAgentNames, getAllTools, getAllowedToolsForMode, getBuiltinTools, getDefaultAgent, getDefaultAgentNames, getDefaultModel, getLanguageModel, getMessage, getModeChangePrompt, getModelInfo, getProvider, getProviders, getSession, getSessionMessages, getSessionStore, getTool, getToolDescriptions, getToolsForAgent, getToolsForMode, globTool, google, grepTool, hasSessionStore, initOpenAgent, isContextOverflowError, isInitialized, isToolAllowedInMode, listSessions, stream as llmStream, localBashExecutor, localEditExecutor, localGlobExecutor, localGrepExecutor, localReadExecutor, localWriteExecutor, messageId, openai, partId, questionTool, readTool, registerAgent, registerAgents, registerTool, registerTools, resetOpenAgent, resetProviders, sessionId, setSessionStore, smartReplace, toAITool, toAITools, toMessageError, toModelMessages, toolCallId, truncateForAI, truncateSimple, truncateToolOutput, unregisterAgent, unregisterTool, updateMessage, updatePart, updateSession, webfetchTool, writeTool };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map