@yachiyo-5i/xlyra-agent 0.2.0

package/dist/chunk-QH6SEOO6.js

@@ -0,0 +1,3590 @@
+// src/llm/models.ts
+import { z } from "zod";
+var toolCallSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  /** 参数 JSON 原文（流式归并后的完整串；可能不是合法 JSON，由校验阶段兜底） */
+  raw_arguments: z.string()
+});
+var chatMessageSchema = z.object({
+  role: z.enum(["system", "user", "assistant", "tool"]),
+  content: z.string().default(""),
+  tool_calls: z.array(toolCallSchema).optional(),
+  tool_call_id: z.string().optional(),
+  name: z.string().optional(),
+  is_error: z.boolean().optional(),
+  thinking: z.string().optional(),
+  thinking_signature: z.string().optional()
+});
+function messageText(message) {
+  return message.content ?? "";
+}
+var tokenUsageSchema = z.object({
+  prompt_tokens: z.number().default(0),
+  completion_tokens: z.number().default(0),
+  total_tokens: z.number().default(0),
+  cache_read_tokens: z.number().default(0)
+});
+function emptyUsage() {
+  return { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, cache_read_tokens: 0 };
+}
+function addUsage(total, step) {
+  return {
+    prompt_tokens: total.prompt_tokens + step.prompt_tokens,
+    completion_tokens: total.completion_tokens + step.completion_tokens,
+    total_tokens: total.total_tokens + step.total_tokens,
+    cache_read_tokens: total.cache_read_tokens + step.cache_read_tokens
+  };
+}
+var modelSettingsSchema = z.object({
+  temperature: z.number().optional(),
+  max_tokens: z.number().optional(),
+  /** 思考强度：映射到 Anthropic thinking budget / OpenAI reasoning effort */
+  reasoning_effort: z.enum(["low", "medium", "high"]).optional()
+});
+function responseToMessage(response) {
+  const message = { role: "assistant", content: response.content };
+  if (response.tool_calls.length > 0) message.tool_calls = response.tool_calls;
+  if (response.thinking) message.thinking = response.thinking;
+  if (response.thinking_signature) message.thinking_signature = response.thinking_signature;
+  return message;
+}
+
+// src/llm/errors.ts
+var LlmError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LlmError";
+  }
+};
+
+// src/llm/sse.ts
+async function* parseSse(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let eventName = "";
+  let dataLines = [];
+  const flush = () => {
+    if (dataLines.length === 0) {
+      eventName = "";
+      return null;
+    }
+    const evt = { event: eventName, data: dataLines.join("\n") };
+    eventName = "";
+    dataLines = [];
+    return evt;
+  };
+  const handleLine = function* (line) {
+    if (line.endsWith("\r")) line = line.slice(0, -1);
+    if (line === "") {
+      const evt = flush();
+      if (evt) yield evt;
+      return;
+    }
+    if (line.startsWith(":")) return;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field === "event") eventName = value;
+    else if (field === "data") dataLines.push(value);
+  };
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        yield* handleLine(line);
+      }
+    }
+    if (buffer.length > 0) yield* handleLine(buffer);
+    const tail = flush();
+    if (tail) yield tail;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/llm/stream-assembler.ts
+var ToolCallBuffer = class {
+  buffers = /* @__PURE__ */ new Map();
+  /** 名称确定的第一刻登记；返回仅含 id/name 的 ToolCall（供 toolcall_start 事件） */
+  start(key, id, name) {
+    this.buffers.set(key, { id, name, raw: "" });
+    return { id, name, raw_arguments: "" };
+  }
+  /** 追加参数分片；返回当前快照（供 toolcall_delta 事件携带归属信息） */
+  append(key, delta) {
+    const entry = this.buffers.get(key);
+    if (!entry) return null;
+    entry.raw += delta;
+    return { id: entry.id, name: entry.name, raw_arguments: entry.raw };
+  }
+  /** 结束归并；fullRaw 提供时以全量为准（Responses 的 .done 事件自带全量串） */
+  finish(key, fullRaw) {
+    const entry = this.buffers.get(key);
+    if (!entry) return null;
+    this.buffers.delete(key);
+    return { id: entry.id, name: entry.name, raw_arguments: fullRaw ?? entry.raw };
+  }
+  /** 流异常终止时丢弃全部未完成归并 */
+  clear() {
+    this.buffers.clear();
+  }
+  get pendingCount() {
+    return this.buffers.size;
+  }
+};
+
+// src/llm/protocols/messages.ts
+var DEFAULT_MAX_TOKENS = 8192;
+var THINKING_BUDGET = { low: 2048, medium: 8192, high: 24576 };
+function toAnthropicMessages(messages) {
+  const systemParts = [];
+  const out = [];
+  const flushToolResults = (pending) => {
+    if (pending.length > 0) {
+      out.push({ role: "user", content: pending.splice(0, pending.length) });
+    }
+  };
+  const pendingToolResults = [];
+  for (const m of messages) {
+    if (m.role === "system") {
+      if (m.content) systemParts.push(m.content);
+      continue;
+    }
+    if (m.role === "tool") {
+      const block = {
+        type: "tool_result",
+        tool_use_id: m.tool_call_id ?? "",
+        content: m.content
+      };
+      if (m.is_error) block.is_error = true;
+      pendingToolResults.push(block);
+      continue;
+    }
+    flushToolResults(pendingToolResults);
+    if (m.role === "user") {
+      out.push({ role: "user", content: m.content });
+      continue;
+    }
+    const blocks = [];
+    if (m.thinking && m.thinking_signature) {
+      blocks.push({ type: "thinking", thinking: m.thinking, signature: m.thinking_signature });
+    }
+    if (m.content) blocks.push({ type: "text", text: m.content });
+    for (const tc of m.tool_calls ?? []) {
+      blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input: parseArgs(tc.raw_arguments) });
+    }
+    out.push({ role: "assistant", content: blocks.length ? blocks : [{ type: "text", text: "" }] });
+  }
+  flushToolResults(pendingToolResults);
+  return { system: systemParts.length ? systemParts.join("\n\n") : void 0, messages: out };
+}
+function parseArgs(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function toAnthropicTools(tools) {
+  return tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.parameters }));
+}
+var AnthropicMessagesProtocol = class {
+  name = "anthropic-messages";
+  baseUrl;
+  apiKey;
+  provider;
+  apiVersion;
+  fetchImpl;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.provider = opts.providerName ?? "anthropic";
+    this.apiVersion = opts.apiVersion ?? "2023-06-01";
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+  }
+  async *chatStream(req) {
+    const { system, messages } = toAnthropicMessages(req.messages);
+    const maxTokens = req.settings.max_tokens ?? DEFAULT_MAX_TOKENS;
+    const body = { model: req.model, max_tokens: maxTokens, messages, stream: true };
+    if (system) body.system = system;
+    if (req.tools?.length) body.tools = toAnthropicTools(req.tools);
+    if (req.settings.temperature !== void 0) body.temperature = req.settings.temperature;
+    if (req.settings.reasoning_effort) {
+      const budget = Math.min(THINKING_BUDGET[req.settings.reasoning_effort], maxTokens - 1);
+      if (budget >= 1024) body.thinking = { type: "enabled", budget_tokens: budget };
+    }
+    let res;
+    try {
+      res = await this.fetchImpl(`${this.baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": this.apiVersion
+        },
+        body: JSON.stringify(body),
+        signal: req.signal ?? null
+      });
+    } catch (err) {
+      if (req.signal?.aborted) return;
+      yield { type: "error", error: `\u8BF7\u6C42\u5931\u8D25\uFF08\u7F51\u7EDC\u9519\u8BEF\uFF09\uFF1A${errMsg(err)}` };
+      return;
+    }
+    if (!res.ok || !res.body) {
+      const detail = await res.text().catch(() => "");
+      yield {
+        type: "error",
+        error: `\u8BF7\u6C42\u5931\u8D25\uFF08HTTP ${res.status}\uFF09\uFF1A${detail.slice(0, 500) || res.statusText}`
+      };
+      return;
+    }
+    const blockKinds = /* @__PURE__ */ new Map();
+    const calls = new ToolCallBuffer();
+    const finishedCalls = [];
+    let text = "";
+    let thinking = "";
+    let thinkingSignature = null;
+    let stopReason = null;
+    const usage = { input: 0, output: 0, cacheRead: 0 };
+    let model = "";
+    let sawTerminal = false;
+    try {
+      for await (const sse of parseSse(res.body)) {
+        const evt = safeParse(sse.data);
+        if (!evt) continue;
+        const type = String(evt.type ?? "");
+        if (type === "message_start") {
+          const msg = evt.message ?? {};
+          model = String(msg.model ?? "");
+          const u = msg.usage ?? {};
+          usage.input = Number(u.input_tokens ?? 0);
+          usage.cacheRead = Number(u.cache_read_input_tokens ?? 0);
+        } else if (type === "content_block_start") {
+          const index = Number(evt.index ?? 0);
+          const block = evt.content_block ?? {};
+          const kind = String(block.type ?? "");
+          blockKinds.set(index, kind);
+          if (kind === "tool_use") {
+            const tc = calls.start(String(index), String(block.id ?? ""), String(block.name ?? ""));
+            yield { type: "toolcall_start", tool_call: tc };
+          }
+        } else if (type === "content_block_delta") {
+          const index = Number(evt.index ?? 0);
+          const delta = evt.delta ?? {};
+          const kind = blockKinds.get(index);
+          const deltaType = String(delta.type ?? "");
+          if (deltaType === "text_delta" && kind === "text") {
+            const d = String(delta.text ?? "");
+            text += d;
+            yield { type: "text_delta", delta: d };
+          } else if (deltaType === "thinking_delta" && kind === "thinking") {
+            const d = String(delta.thinking ?? "");
+            thinking += d;
+            yield { type: "thinking_delta", delta: d };
+          } else if (deltaType === "signature_delta" && kind === "thinking") {
+            thinkingSignature = String(delta.signature ?? "") || thinkingSignature;
+          } else if (deltaType === "input_json_delta" && kind === "tool_use") {
+            const d = String(delta.partial_json ?? "");
+            const tc = calls.append(String(index), d);
+            if (tc) yield { type: "toolcall_delta", tool_call: tc, delta: d };
+          } else if (deltaType) {
+            yield { type: "error", error: `\u6D41\u635F\u574F\uFF1Ablock ${index}\uFF08${kind}\uFF09\u6536\u5230 ${deltaType}` };
+            return;
+          }
+        } else if (type === "content_block_stop") {
+          const index = Number(evt.index ?? 0);
+          if (blockKinds.get(index) === "tool_use") {
+            const tc = calls.finish(String(index));
+            if (tc) {
+              finishedCalls.push(tc);
+              yield { type: "toolcall_end", tool_call: tc };
+            }
+          }
+          blockKinds.delete(index);
+        } else if (type === "message_delta") {
+          stopReason = String(evt.delta?.stop_reason ?? "") || stopReason;
+          usage.output = Number(evt.usage?.output_tokens ?? usage.output);
+        } else if (type === "message_stop") {
+          sawTerminal = true;
+          yield {
+            type: "done",
+            response: {
+              content: text,
+              thinking: thinking || null,
+              thinking_signature: thinkingSignature,
+              tool_calls: finishedCalls,
+              usage: {
+                prompt_tokens: usage.input,
+                completion_tokens: usage.output,
+                total_tokens: usage.input + usage.output,
+                cache_read_tokens: usage.cacheRead
+              },
+              finish_reason: stopReason,
+              model,
+              provider: this.provider
+            }
+          };
+          return;
+        } else if (type === "error") {
+          const err = evt.error?.message;
+          yield { type: "error", error: `\u6A21\u578B\u8C03\u7528\u5931\u8D25\uFF1A${String(err ?? "\u539F\u56E0\u672A\u77E5")}` };
+          return;
+        }
+      }
+    } catch (err) {
+      if (req.signal?.aborted) return;
+      yield { type: "error", error: `\u6D41\u8BFB\u53D6\u5931\u8D25\uFF1A${errMsg(err)}` };
+      return;
+    }
+    if (!sawTerminal) yield { type: "error", error: "\u6A21\u578B\u6D41\u5F02\u5E38\u7EC8\u6B62\uFF0C\u672A\u8FD4\u56DE\u7ED3\u679C" };
+  }
+};
+function safeParse(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/llm/protocols/responses.ts
+function toResponsesInput(messages) {
+  const instructions = [];
+  const input = [];
+  for (const m of messages) {
+    if (m.role === "system") {
+      if (m.content) instructions.push(m.content);
+      continue;
+    }
+    if (m.role === "user") {
+      input.push({ type: "message", role: "user", content: [{ type: "input_text", text: m.content }] });
+      continue;
+    }
+    if (m.role === "assistant") {
+      if (m.content) {
+        input.push({ type: "message", role: "assistant", content: [{ type: "output_text", text: m.content }] });
+      }
+      for (const tc of m.tool_calls ?? []) {
+        input.push({ type: "function_call", call_id: tc.id, name: tc.name, arguments: tc.raw_arguments });
+      }
+      continue;
+    }
+    input.push({ type: "function_call_output", call_id: m.tool_call_id ?? "", output: m.content });
+  }
+  return { instructions: instructions.length ? instructions.join("\n\n") : void 0, input };
+}
+function toResponsesTools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    name: t.name,
+    description: t.description,
+    parameters: t.parameters
+  }));
+}
+function responseFromCompleted(response, provider) {
+  let content = "";
+  let thinking = "";
+  const toolCalls = [];
+  for (const item of response.output ?? []) {
+    if (item.type === "message") {
+      for (const part of item.content ?? []) {
+        if (part.type === "output_text" && typeof part.text === "string") content += part.text;
+      }
+    } else if (item.type === "reasoning") {
+      for (const part of item.summary ?? []) {
+        if (part.type === "summary_text" && typeof part.text === "string") {
+          thinking += (thinking ? "\n" : "") + part.text;
+        }
+      }
+    } else if (item.type === "function_call") {
+      toolCalls.push({
+        id: String(item.call_id ?? item.id ?? ""),
+        name: String(item.name ?? ""),
+        raw_arguments: String(item.arguments ?? "")
+      });
+    }
+  }
+  const usage = response.usage ?? {};
+  const cached = usage.input_tokens_details?.cached_tokens;
+  return {
+    content,
+    thinking: thinking || null,
+    thinking_signature: null,
+    // Responses 的思考摘要无签名概念
+    tool_calls: toolCalls,
+    usage: {
+      prompt_tokens: Number(usage.input_tokens ?? 0),
+      completion_tokens: Number(usage.output_tokens ?? 0),
+      total_tokens: Number(usage.total_tokens ?? 0),
+      cache_read_tokens: Number(cached ?? 0)
+    },
+    finish_reason: response.status ?? "completed",
+    model: String(response.model ?? ""),
+    provider
+  };
+}
+var OpenAIResponsesProtocol = class {
+  name = "openai-responses";
+  baseUrl;
+  apiKey;
+  provider;
+  fetchImpl;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.provider = opts.providerName ?? "openai";
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+  }
+  async *chatStream(req) {
+    const { instructions, input } = toResponsesInput(req.messages);
+    const body = { model: req.model, input, stream: true };
+    if (instructions) body.instructions = instructions;
+    if (req.tools?.length) body.tools = toResponsesTools(req.tools);
+    if (req.settings.max_tokens) body.max_output_tokens = req.settings.max_tokens;
+    if (req.settings.temperature !== void 0) body.temperature = req.settings.temperature;
+    if (req.settings.reasoning_effort) {
+      body.reasoning = { effort: req.settings.reasoning_effort, summary: "auto" };
+      body.include = ["reasoning.encrypted_content"];
+    }
+    let res;
+    try {
+      res = await this.fetchImpl(`${this.baseUrl}/responses`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(body),
+        signal: req.signal ?? null
+      });
+    } catch (err) {
+      if (req.signal?.aborted) return;
+      yield { type: "error", error: `\u8BF7\u6C42\u5931\u8D25\uFF08\u7F51\u7EDC\u9519\u8BEF\uFF09\uFF1A${errMsg2(err)}` };
+      return;
+    }
+    if (!res.ok || !res.body) {
+      const detail = await res.text().catch(() => "");
+      yield {
+        type: "error",
+        error: `\u8BF7\u6C42\u5931\u8D25\uFF08HTTP ${res.status}\uFF09\uFF1A${detail.slice(0, 500) || res.statusText}`
+      };
+      return;
+    }
+    const calls = new ToolCallBuffer();
+    const callIdByItem = /* @__PURE__ */ new Map();
+    let streamedText = "";
+    let streamedThinking = "";
+    let doneCalls = [];
+    try {
+      for await (const sse of parseSse(res.body)) {
+        if (sse.data === "[DONE]") break;
+        const evt = safeParse2(sse.data);
+        if (!evt) continue;
+        const type = String(evt.type ?? "");
+        if (type === "response.output_item.added") {
+          const item = evt.item;
+          if (item?.type === "function_call") {
+            const itemId = String(item.id ?? "");
+            const callId = String(item.call_id ?? itemId);
+            callIdByItem.set(itemId, callId);
+            const tc = calls.start(itemId, callId, String(item.name ?? ""));
+            yield { type: "toolcall_start", tool_call: tc };
+          }
+        } else if (type === "response.function_call_arguments.delta") {
+          const itemId = String(evt.item_id ?? "");
+          const tc = calls.append(itemId, String(evt.delta ?? ""));
+          if (tc) yield { type: "toolcall_delta", tool_call: tc, delta: String(evt.delta ?? "") };
+        } else if (type === "response.function_call_arguments.done") {
+          const itemId = String(evt.item_id ?? "");
+          const tc = calls.finish(itemId, String(evt.arguments ?? ""));
+          if (tc) {
+            doneCalls.push(tc);
+            yield { type: "toolcall_end", tool_call: tc };
+          }
+        } else if (type === "response.output_item.done") {
+          const item = evt.item;
+          const itemId = String(item?.id ?? "");
+          if (item?.type === "function_call" && itemId && callIdByItem.has(itemId)) {
+            const tc = calls.finish(itemId, String(item.arguments ?? ""));
+            if (tc) {
+              doneCalls.push(tc);
+              yield { type: "toolcall_end", tool_call: tc };
+            }
+          }
+        } else if (type === "response.output_text.delta") {
+          const delta = String(evt.delta ?? "");
+          streamedText += delta;
+          yield { type: "text_delta", delta };
+        } else if (type === "response.reasoning_summary_text.delta") {
+          const delta = String(evt.delta ?? "");
+          streamedThinking += delta;
+          yield { type: "thinking_delta", delta };
+        } else if (type === "response.completed") {
+          const response = responseFromCompleted(evt.response ?? {}, this.provider);
+          yield { type: "done", response };
+          return;
+        } else if (type === "response.incomplete") {
+          if (doneCalls.length > 0) {
+            const response = responseFromCompleted(evt.response ?? {}, this.provider);
+            yield {
+              type: "done",
+              response: {
+                ...response,
+                content: response.content || streamedText,
+                thinking: response.thinking ?? (streamedThinking || null),
+                tool_calls: doneCalls
+              }
+            };
+          } else {
+            const detail = evt.response?.incomplete_details?.reason;
+            yield { type: "error", error: `\u54CD\u5E94\u4E0D\u5B8C\u6574${detail ? `\uFF08${String(detail)}\uFF09` : ""}\uFF0C\u8BF7\u91CD\u8BD5` };
+          }
+          return;
+        } else if (type === "response.failed") {
+          const err = evt.response?.error?.message;
+          yield { type: "error", error: `\u6A21\u578B\u8C03\u7528\u5931\u8D25\uFF1A${String(err ?? "\u539F\u56E0\u672A\u77E5")}` };
+          return;
+        } else if (type === "error") {
+          yield { type: "error", error: `\u6A21\u578B\u8C03\u7528\u5931\u8D25\uFF1A${String(evt.message ?? "\u539F\u56E0\u672A\u77E5")}` };
+          return;
+        }
+      }
+    } catch (err) {
+      if (req.signal?.aborted) return;
+      yield { type: "error", error: `\u6D41\u8BFB\u53D6\u5931\u8D25\uFF1A${errMsg2(err)}` };
+      return;
+    }
+    yield { type: "error", error: "\u6A21\u578B\u6D41\u5F02\u5E38\u7EC8\u6B62\uFF0C\u672A\u8FD4\u56DE\u7ED3\u679C" };
+  }
+};
+function safeParse2(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function errMsg2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/llm/router.ts
+var BUILTIN_CONTEXT_WINDOWS = [
+  ["claude-", 2e5],
+  ["gpt-4o", 128e3],
+  ["gpt-4.1", 1047576],
+  ["gpt-5", 4e5],
+  ["o1", 2e5],
+  ["o3", 2e5],
+  ["o4", 2e5]
+];
+function builtinContextWindow(modelId) {
+  for (const [prefix, win] of BUILTIN_CONTEXT_WINDOWS) {
+    if (modelId.startsWith(prefix)) return win;
+  }
+  return void 0;
+}
+var EndpointResolver = class {
+  endpoints;
+  protocols = /* @__PURE__ */ new Map();
+  constructor(endpoints) {
+    if (endpoints.length === 0) throw new LlmError("\u672A\u914D\u7F6E\u4EFB\u4F55\u6A21\u578B\u7AEF\u70B9");
+    this.endpoints = endpoints;
+  }
+  resolve(model) {
+    let endpoint;
+    let modelId;
+    if (!model) {
+      endpoint = this.endpoints[0];
+      modelId = endpoint.default_model ?? "";
+      if (!modelId) throw new LlmError(`\u7AEF\u70B9 ${endpoint.name} \u672A\u914D\u7F6E\u9ED8\u8BA4\u6A21\u578B`);
+    } else if (model.includes("/")) {
+      const [name, ...rest] = model.split("/");
+      modelId = rest.join("/");
+      endpoint = this.endpoints.find((e) => e.name === name);
+      if (!endpoint) throw new LlmError(`\u6A21\u578B\u7AEF\u70B9\u4E0D\u5B58\u5728\uFF1A${name}`);
+    } else {
+      modelId = model;
+      const hits = this.endpoints.filter((e) => e.models && model in e.models);
+      if (hits.length > 1) {
+        throw new LlmError(`\u6A21\u578B ${model} \u5728\u591A\u4E2A\u7AEF\u70B9\u4E2D\u5747\u6709\u914D\u7F6E\uFF0C\u8BF7\u7528\u300C\u7AEF\u70B9\u540D/\u6A21\u578Bid\u300D\u663E\u5F0F\u6307\u5B9A`);
+      }
+      endpoint = hits[0] ?? this.endpoints[0];
+    }
+    return {
+      endpoint,
+      protocol: this.protocolFor(endpoint),
+      modelId,
+      contextWindow: endpoint.models?.[modelId]?.context_window ?? builtinContextWindow(modelId)
+    };
+  }
+  protocolFor(endpoint) {
+    let protocol = this.protocols.get(endpoint.name);
+    if (!protocol) {
+      const opts = {
+        baseUrl: endpoint.base_url,
+        apiKey: endpoint.api_key,
+        providerName: endpoint.name
+      };
+      protocol = endpoint.protocol === "anthropic-messages" ? new AnthropicMessagesProtocol(opts) : new OpenAIResponsesProtocol(opts);
+      this.protocols.set(endpoint.name, protocol);
+    }
+    return protocol;
+  }
+};
+
+// src/llm/validate.ts
+function validateToolCall(definitions, call) {
+  const def = definitions.find((d) => d.name === call.name);
+  if (!def) {
+    return { args: null, error: `\u5DE5\u5177\u4E0D\u5B58\u5728\uFF1A${call.name}\uFF1B\u53EF\u7528\u5DE5\u5177\uFF1A${definitions.map((d) => d.name).join("\u3001")}` };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(call.raw_arguments || "{}");
+  } catch {
+    return {
+      args: null,
+      error: `\u5DE5\u5177 ${call.name} \u7684\u53C2\u6570\u4E0D\u662F\u5408\u6CD5 JSON\uFF0C\u8BF7\u4FEE\u6B63\u540E\u91CD\u8BD5\u3002\u539F\u6587\uFF1A${call.raw_arguments.slice(0, 200)}`
+    };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { args: null, error: `\u5DE5\u5177 ${call.name} \u7684\u53C2\u6570\u5FC5\u987B\u662F JSON object` };
+  }
+  const err = validateAgainstSchema(parsed, def.parameters);
+  if (err) return { args: null, error: `\u5DE5\u5177 ${call.name} \u53C2\u6570\u6821\u9A8C\u5931\u8D25\uFF1A${err}` };
+  return { args: parsed, error: null };
+}
+function validateAgainstSchema(args, schema) {
+  const properties = schema.properties ?? {};
+  const required = (schema.required ?? []).filter(
+    (key) => properties[key]?.default === void 0
+  );
+  for (const key of required) {
+    if (!(key in args) || args[key] === void 0 || args[key] === null) {
+      return `\u7F3A\u5C11\u5FC5\u586B\u53C2\u6570 ${key}`;
+    }
+  }
+  for (const [key, value] of Object.entries(args)) {
+    const prop = properties[key];
+    if (!prop) continue;
+    const expected = prop.type;
+    if (value === void 0 || !expected) continue;
+    const ok2 = expected === "string" && typeof value === "string" || expected === "number" && typeof value === "number" || expected === "integer" && typeof value === "number" && Number.isInteger(value) || expected === "boolean" && typeof value === "boolean" || expected === "array" && Array.isArray(value) || expected === "object" && typeof value === "object" && !Array.isArray(value);
+    if (!ok2) return `\u53C2\u6570 ${key} \u7C7B\u578B\u5E94\u4E3A ${expected}`;
+    const enumValues = prop.enum;
+    if (enumValues && !enumValues.includes(value)) {
+      return `\u53C2\u6570 ${key} \u53D6\u503C\u987B\u4E3A ${enumValues.join(" / ")}`;
+    }
+  }
+  return null;
+}
+
+// src/agent/events.ts
+import { z as z2 } from "zod";
+var agentStartParamsSchema = z2.object({
+  /** 用户的任务描述（作为本轮 user 消息） */
+  input: z2.string(),
+  /** 是否把 input 追加为新的 user 消息；提权续跑沿用 history 中的原始输入 */
+  include_input: z2.boolean().default(true),
+  /** 多轮历史（可选）：追加在 system 之后、本轮 input 之前 */
+  history: z2.array(chatMessageSchema).default([]),
+  /** 模型引用（"端点名/模型id" 或裸模型 id）；空串 = 第一个端点的默认模型 */
+  model: z2.string().default(""),
+  /** 覆盖默认系统提示词（缺省用 prompts.buildSystemPrompt()） */
+  system_prompt: z2.string().nullish(),
+  settings: modelSettingsSchema.default({})
+});
+var agentToolResultSchema = z2.object({
+  tool_call_id: z2.string(),
+  name: z2.string(),
+  /** 喂回模型的文本（事件里截断到 2000 字符，完整版进对话上下文） */
+  output: z2.string(),
+  is_error: z2.boolean().default(false),
+  elapsed_ms: z2.number().default(0)
+});
+var agentCompactionSchema = z2.object({
+  summary: z2.string(),
+  tokens_before: z2.number(),
+  tokens_after: z2.number()
+});
+var agentEscalationSchema = z2.object({
+  /** 本次提权请求的唯一 id（确认接口的定位参数） */
+  escalation_id: z2.string(),
+  /** 用户/模型给出的原始路径（展示用） */
+  requested_path: z2.string(),
+  /** 沙箱解析后的绝对路径（确认后登记的授权键） */
+  resolved_path: z2.string(),
+  /** 触发提权的工具名（如 list/read） */
+  tool_name: z2.string(),
+  resource_type: z2.enum(["path", "command"]).default("path"),
+  requested_command: z2.array(z2.string()).nullish(),
+  /** 当前工作区根（展示给用户看边界在哪） */
+  workdir: z2.string()
+});
+var agentDoneSchema = z2.object({
+  /** 最后一步的产出（loop 的最终答复） */
+  text: z2.string().nullish(),
+  thinking: z2.string().nullish(),
+  finish_reason: z2.string().nullish(),
+  /** 全部步骤的累计用量 */
+  usage: tokenUsageSchema.default({ prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, cache_read_tokens: 0 }),
+  /** 模型调用次数 */
+  steps: z2.number().default(1),
+  model: z2.string().default(""),
+  provider: z2.string().default(""),
+  elapsed_ms: z2.number().default(0)
+});
+var agentEventSchema = z2.object({
+  type: z2.enum([
+    "agent_start",
+    "thinking_delta",
+    "text_delta",
+    "tool_call_start",
+    "tool_call_delta",
+    "tool_call",
+    "tool_result",
+    "context_compacted",
+    "escalation_request",
+    "agent_done",
+    "agent_error",
+    "agent_cancelled"
+  ]),
+  /** 本次运行的唯一 id，一次 start 产生的所有事件共享同一个值 */
+  run_id: z2.string(),
+  delta: z2.string().nullish(),
+  tool_call: toolCallSchema.nullish(),
+  tool_call_id: z2.string().nullish(),
+  tool_result: agentToolResultSchema.nullish(),
+  compaction: agentCompactionSchema.nullish(),
+  /** escalation_request 事件：路径提权请求 */
+  escalation: agentEscalationSchema.nullish(),
+  /** agent_start：实际路由到的端点名与模型 id */
+  provider: z2.string().nullish(),
+  model: z2.string().nullish(),
+  /** agent_done 的终态载荷 */
+  result: agentDoneSchema.nullish(),
+  /** agent_error 的中文错误说明 */
+  error: z2.string().nullish()
+});
+var TERMINAL_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "agent_done",
+  "agent_error",
+  "agent_cancelled"
+]);
+
+// src/agent/prompts.ts
+var SUMMARY_PREFIX = "\u3010\u4E0A\u4E0B\u6587\u538B\u7F29\u6458\u8981\u3011\u6B64\u524D\u7684\u5BF9\u8BDD\u5DF2\u88AB\u538B\u7F29\uFF0C\u4EE5\u4E0B\u662F\u4EA4\u63A5\u6458\u8981\uFF1A";
+var COMPACT_PROMPT = `\u4F60\u6B63\u5728\u6267\u884C\u4E00\u6B21\u4E0A\u4E0B\u6587\u538B\u7F29\u3002\u8BF7\u4E3A\u5C06\u8981\u63A5\u624B\u8FD9\u6BB5\u5BF9\u8BDD\u7684\u53E6\u4E00\u4E2A LLM \u5199\u4E00\u4EFD\u4EA4\u63A5\u6458\u8981\u3002
+
+\u6458\u8981\u5FC5\u987B\u5305\u542B\uFF1A
+- \u4EFB\u52A1\u76EE\u6807\u4E0E\u5F53\u524D\u8FDB\u5EA6\u3001\u5DF2\u505A\u51FA\u7684\u5173\u952E\u51B3\u5B9A
+- \u7528\u6237\u63D0\u51FA\u7684\u7EA6\u675F\u3001\u504F\u597D\u548C\u91CD\u8981\u80CC\u666F
+- \u5C1A\u672A\u5B8C\u6210\u7684\u4E8B\u9879\uFF08\u660E\u786E\u7684\u4E0B\u4E00\u6B65\uFF09
+- \u7EE7\u7EED\u5DE5\u4F5C\u5FC5\u987B\u4FDD\u7559\u7684\u5173\u952E\u6570\u636E\uFF08\u8DEF\u5F84\u3001ID\u3001\u7F16\u53F7\u3001\u67E5\u8BE2\u7ED3\u679C\u8981\u70B9\u7B49\uFF09
+
+\u4FDD\u6301\u7B80\u6D01\u3001\u7ED3\u6784\u5316\uFF0C\u4EE5\u5E2E\u52A9\u4E0B\u4E00\u4E2A LLM \u65E0\u7F1D\u63A5\u7EED\u5DE5\u4F5C\u4E3A\u552F\u4E00\u76EE\u6807\u3002\u53EA\u8F93\u51FA\u6458\u8981\u6B63\u6587\u3002
+`;
+var SYSTEM_PROMPT_TEMPLATE = `\u4F60\u662F {agentName}\uFF0C\u4E00\u4E2A\u53CB\u597D\u7684\u667A\u80FD\u52A9\u7406\u3002{persona}
+
+# \u8FD0\u884C\u65B9\u5F0F
+- \u4F60\u7684\u6587\u5B57\u8F93\u51FA\u4EE5 Markdown \u6E32\u67D3\u5728\u4F1A\u8BDD\u9875\uFF0C\u5DE5\u5177\u8C03\u7528\u8FC7\u7A0B\u7528\u6237\u5168\u7A0B\u53EF\u89C1\u3002\u6267\u884C\u4E2D\u4E0D\u8981\u65C1\u767D\u300C\u6211\u73B0\u5728\u8981\u53BB\u505A\u4EC0\u4E48\u300D\u2014\u2014\u5DE5\u5177\u8C03\u7528\u672C\u8EAB\u5C31\u662F\u8FC7\u7A0B\u5C55\u793A\u3002
+- \u9700\u8981\u4E8B\u5B9E\u65F6\u6C38\u8FDC\u5148\u8C03\u7528\u5DE5\u5177\u67E5\u8BC1\uFF0C\u4E00\u5F8B\u4EE5\u5DE5\u5177\u8FD4\u56DE\u4E3A\u51C6\uFF0C\u7EDD\u4E0D\u51ED\u5370\u8C61\u81C6\u65AD\u3002
+- \u6587\u4EF6\u4E0E\u5DE5\u4F5C\u72B6\u6001\u90FD\u5177\u6709\u65F6\u6548\u6027\uFF1B\u6BCF\u6B21\u7528\u6237\u8BE2\u95EE\u6B64\u7C7B\u4FE1\u606F\u65F6\uFF0C\u5FC5\u987B\u5728\u5F53\u524D\u8F6E\u6B21\u91CD\u65B0\u8C03\u7528\u5DE5\u5177\u67E5\u8BE2\u6700\u65B0\u6570\u636E\uFF0C\u4E0D\u8981\u76F8\u4FE1\u6216\u590D\u7528\u5386\u53F2\u5BF9\u8BDD\u4E2D\u5DF2\u7ECF\u83B7\u53D6\u7684\u7ED3\u679C\u3002
+- \u5DE5\u5177\u62A5\u9519\u6216\u88AB\u62D2\u7EDD\uFF0C\u4E0D\u8981\u539F\u6837\u91CD\u53D1\uFF1A\u8BFB\u61C2\u539F\u56E0\uFF0C\u4FEE\u6B63\u53C2\u6570\u6216\u6362\u4E00\u6761\u8DEF\u3002
+
+# \u5DE5\u5177\u4F7F\u7528\u89C4\u5219
+- \u5DE5\u5177\u5217\u8868\u4F1A\u968F\u5F53\u524D\u4F1A\u8BDD\u914D\u7F6E\u52A8\u6001\u6CE8\u5165\uFF1B\u53EA\u80FD\u8C03\u7528\u5217\u8868\u4E2D\u5B9E\u9645\u5B58\u5728\u7684\u5DE5\u5177\uFF0C\u4E0D\u8981\u81C6\u9020\u5DE5\u5177\u540D\u6216\u53C2\u6570\u3002
+- \u5148\u7528 search \u5B9A\u4F4D\u4EE3\u7801\u6216\u6587\u672C\uFF0C\u518D\u7528 read \u67E5\u770B\u5FC5\u8981\u4E0A\u4E0B\u6587\uFF1B\u4E0D\u8981\u4E3A\u5BFB\u627E\u5185\u5BB9\u9012\u5F52\u8BFB\u53D6\u5927\u91CF\u6587\u4EF6\u3002
+- \u4FEE\u6539\u5DF2\u6709\u6587\u4EF6\u4F18\u5148\u4F7F\u7528 edit\uFF1B\u9700\u8981\u540C\u65F6\u4FEE\u6539\u591A\u4E2A\u6587\u4EF6\u65F6\u4F7F\u7528 apply_patch\uFF1B\u53EA\u6709\u660E\u786E\u9700\u8981\u6574\u4F53\u66FF\u6362\u65F6\u624D\u4F7F\u7528 write\u3002
+- \u4FEE\u6539\u540E\u5982\u679C\u5F53\u524D\u4F1A\u8BDD\u63D0\u4F9B exec_command\uFF0C\u5E94\u8FD0\u884C\u6700\u76F8\u5173\u7684\u683C\u5F0F\u5316\u3001\u7C7B\u578B\u68C0\u67E5\u6216\u6D4B\u8BD5\uFF0C\u5E76\u6839\u636E\u7ED3\u679C\u7EE7\u7EED\u4FEE\u6B63\u3002
+- exec_command \u4F7F\u7528 argv \u6570\u7EC4\u800C\u4E0D\u662F shell \u5B57\u7B26\u4E32\uFF1B\u547D\u4EE4\u4F1A\u8BDD\u8FD4\u56DE session_id \u65F6\uFF0C\u7528 write_stdin \u7EE7\u7EED\u8BFB\u53D6\uFF0C\u4E0D\u8981\u91CD\u590D\u542F\u52A8\u540C\u4E00\u4E2A\u547D\u4EE4\u3002
+- exec_command \u4E0E write_stdin \u5373\u4F7F\u9700\u8981\u6388\u6743\u4E5F\u4F1A\u51FA\u73B0\u5728\u5DE5\u5177\u76EE\u5F55\u4E2D\uFF1B\u8C03\u7528\u540E\u82E5\u6536\u5230\u63D0\u6743\u8BF7\u6C42\uFF0C\u5E94\u7B49\u5F85\u7528\u6237\u786E\u8BA4\uFF0C\u4E0D\u8981\u58F0\u79F0\u5F53\u524D\u6CA1\u6709\u547D\u4EE4\u5DE5\u5177\u3002
+- \u4EFB\u4F55\u5DE5\u5177\u88AB\u62D2\u7EDD\u3001\u8D8A\u754C\u6216\u53D6\u6D88\u65F6\uFF0C\u5148\u7406\u89E3\u8FD4\u56DE\u539F\u56E0\uFF1B\u4E0D\u8981\u901A\u8FC7\u6362\u5199\u6CD5\u7ED5\u8FC7\u6743\u9650\u8FB9\u754C\u3002
+
+# \u5E76\u884C\u5DE5\u5177\u8C03\u7528
+\u9700\u8981\u591A\u9879\u4E92\u4E0D\u4F9D\u8D56\u7684\u4FE1\u606F\u65F6\uFF0C\u5728\u540C\u4E00\u8F6E\u91CC\u4E00\u6B21\u6027\u53D1\u8D77\u5168\u90E8\u8C03\u7528\uFF0C\u800C\u4E0D\u662F\u4E00\u8F6E\u4E00\u4E2A\u3002\u72EC\u7ACB\u7684\u68C0\u7D22\u3001\u67E5\u8BE2\u3001\u72B6\u6001\u8BFB\u53D6\u90FD\u5E94\u5408\u5E76\u5230\u540C\u4E00\u6B21\u56DE\u590D\u4E2D\u2014\u2014\u8FD0\u884C\u65F6\u4F1A\u5B89\u5168\u5E76\u53D1\u6267\u884C\u8FDE\u7EED\u7684\u53EA\u8BFB\u8C03\u7528\u5E76\u6309\u539F\u987A\u5E8F\u8FD4\u56DE\u7ED3\u679C\uFF0C\u5408\u5E76\u8C03\u7528\u907F\u514D\u4E86\u6BCF\u591A\u4E00\u8F6E\u5C31\u628A\u6574\u4E2A\u5BF9\u8BDD\u91CD\u65B0\u53D1\u9001\u4E00\u904D\u7684\u5F00\u9500\u3002
+\u53EA\u6709\u5F53\u540E\u4E00\u4E2A\u8C03\u7528\u786E\u5B9E\u4F9D\u8D56\u524D\u4E00\u4E2A\u7684\u7ED3\u679C\u65F6\u624D\u5206\u8F6E\u4E32\u884C\u3002\u62FF\u4E0D\u51C6\u4E14\u8C03\u7528\u4E4B\u95F4\u76F8\u4E92\u72EC\u7ACB\u65F6\uFF0C\u4E00\u5F8B\u5408\u5E76\u3002
+
+# \u5DE5\u4F5C\u5FAA\u73AF
+\u4EE5\u300C\u601D\u8003 \u2192 \u884C\u52A8 \u2192 \u89C2\u5BDF\u300D\u6301\u7EED\u5FAA\u73AF\uFF0C\u76F4\u5230\u4EFB\u52A1\u5B8C\u6210\uFF1A
+- \u6BCF\u6B21\u89C2\u5BDF\u7ED3\u679C\u540E\u91CD\u65B0\u8BC4\u4F30\uFF1A\u63A8\u8FDB\u4E86\u5C31\u8D70\u4E0B\u4E00\u6B65\uFF1B\u6CA1\u63A8\u8FDB\u5C31\u6362\u4E00\u79CD\u65B9\u5F0F\u518D\u8BD5\uFF0C\u800C\u4E0D\u662F\u539F\u6837\u91CD\u8BD5\u3002
+- \u575A\u6301\u5230\u5E95\uFF0C\u4E0D\u628A\u505A\u4E86\u4E00\u534A\u7684\u4EFB\u52A1\u4EA4\u56DE\u7528\u6237\u3002\u540C\u4E00\u969C\u788D\u8FDE\u7EED\u4E24\u6B21\u7ED5\u4E0D\u8FC7\u53BB\uFF0C\u624D\u505C\u4E0B\u5411\u7528\u6237\u8BF4\u660E\u5361\u70B9\u3002
+- \u5141\u8BB8\u505C\u4E0B\u63D0\u95EE\u7684\u53EA\u6709\u4E24\u79CD\u60C5\u51B5\uFF1A\u7F3A\u5C11\u53EA\u6709\u7528\u6237\u80FD\u505A\u7684\u51B3\u5B9A\uFF0C\u6216\u52A8\u4F5C\u8D85\u51FA\u4E86\u672C\u6B21\u7684\u660E\u786E\u6388\u6743\u3002
+
+# \u56DE\u590D\u98CE\u683C
+- \u5168\u7A0B\u4E2D\u6587\u3002\u6700\u7EC8\u7B54\u590D\u5148\u7ED3\u8BBA\u3001\u540E\u5173\u952E\u4F9D\u636E\uFF0C\u4E0D\u590D\u8FF0\u6267\u884C\u8FC7\u7A0B\u3002
+- \u627E\u4E0D\u5230\u5C31\u8BF4\u627E\u4E0D\u5230\uFF0C\u7EDD\u4E0D\u865A\u6784\u4EFB\u4F55\u6570\u636E\u3002
+- \u7B80\u77ED\u4F18\u5148\uFF1A\u4E00\u53E5\u80FD\u8BF4\u6E05\u7684\u4E0D\u7528\u4E09\u53E5\u3002
+- \u53CB\u597D\u3001\u6709\u6E29\u5EA6\uFF1A\u50CF\u4E00\u4E2A\u957F\u671F\u966A\u4F34\u7528\u6237\u7684\u771F\u4EBA\u4F19\u4F34\u90A3\u6837\u4EA4\u6D41\uFF0C\u5728\u6070\u5F53\u7684\u65F6\u5019\u7ED9\u7528\u6237\u60C5\u7EEA\u4EF7\u503C\u3002\u53EF\u4EE5\u9002\u5EA6\u4F7F\u7528\u8868\u60C5\u7B26\u53F7\uFF0C\u4F46\u522B\u6CDB\u6EE5\u3002
+`;
+function buildAvailableToolsPrompt(availableTools) {
+  if (availableTools.length === 0) {
+    return "# \u5F53\u524D\u4F1A\u8BDD\u53EF\u7528\u5DE5\u5177\n- \u5F53\u524D\u4F1A\u8BDD\u6CA1\u6709\u53EF\u7528\u5DE5\u5177\uFF1B\u4E0D\u8981\u5C1D\u8BD5\u8C03\u7528\u5DE5\u5177\u3002";
+  }
+  return [
+    "# \u5F53\u524D\u4F1A\u8BDD\u53EF\u7528\u5DE5\u5177",
+    ...availableTools.map((tool) => `- ${tool.name}\uFF1A${tool.description.replace(/\s+/g, " ").trim()}`)
+  ].join("\n");
+}
+function buildSystemPrompt(opts = {}) {
+  const body = SYSTEM_PROMPT_TEMPLATE.replace("{agentName}", opts.agentName ?? "xlyra \u52A9\u7406").replace(
+    "{persona}",
+    opts.persona ? ` ${opts.persona}` : ""
+  );
+  const lines = [body, "# \u73AF\u5883", `- \u5F53\u524D\u65E5\u671F\uFF1A${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`];
+  if (opts.extraEnvironment) lines.push(opts.extraEnvironment);
+  lines.push(buildAvailableToolsPrompt(opts.availableTools ?? []));
+  return lines.join("\n");
+}
+
+// src/agent/compaction.ts
+var COMPACT_TRIGGER_RATIO = 0.9;
+var RETAINED_USER_TOKEN_BUDGET = 2e4;
+var APPROX_BYTES_PER_TOKEN = 4;
+function estimateTokens(target) {
+  if (typeof target === "string") {
+    return Math.floor(Buffer.byteLength(target, "utf-8") / APPROX_BYTES_PER_TOKEN);
+  }
+  if (Array.isArray(target)) {
+    return target.reduce((sum, m) => sum + estimateTokens(m), 0);
+  }
+  let total = Buffer.byteLength(target.content ?? "", "utf-8");
+  for (const tc of target.tool_calls ?? []) {
+    total += Buffer.byteLength(tc.name, "utf-8");
+    total += Buffer.byteLength(tc.raw_arguments, "utf-8");
+  }
+  return Math.floor(total / APPROX_BYTES_PER_TOKEN);
+}
+function shouldCompact(contextTokens, contextWindow) {
+  if (!contextWindow) return false;
+  return contextTokens >= Math.floor(contextWindow * COMPACT_TRIGGER_RATIO);
+}
+function isSummaryMessage(message) {
+  return message.role === "user" && (message.content ?? "").startsWith(SUMMARY_PREFIX);
+}
+function truncateMiddle(text, maxTokens) {
+  const budgetBytes = maxTokens * APPROX_BYTES_PER_TOKEN;
+  const data = Buffer.from(text, "utf-8");
+  if (data.length <= budgetBytes) return text;
+  const half = Math.floor(budgetBytes / 2);
+  const head = data.subarray(0, half).toString("utf-8");
+  const tail = data.subarray(data.length - half).toString("utf-8");
+  const omitted = Math.floor((data.length - budgetBytes) / APPROX_BYTES_PER_TOKEN);
+  return `${head}
+\u2026\uFF08\u4E2D\u95F4\u7EA6 ${omitted} token \u5DF2\u622A\u65AD\uFF09\u2026
+${tail}`;
+}
+function buildReplacementHistory(messages, summary) {
+  const retained = [];
+  let remaining = RETAINED_USER_TOKEN_BUDGET;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role !== "user" || isSummaryMessage(message)) continue;
+    if (remaining <= 0) break;
+    const tokens = estimateTokens(message);
+    if (tokens <= remaining) {
+      retained.push(message);
+      remaining -= tokens;
+    } else {
+      retained.push({ role: "user", content: truncateMiddle(message.content ?? "", remaining) });
+      break;
+    }
+  }
+  retained.reverse();
+  return [...retained, { role: "user", content: `${SUMMARY_PREFIX}
+${summary}` }];
+}
+async function compact(protocol, model, messages, settings) {
+  let summary = null;
+  try {
+    for await (const event of protocol.chatStream({
+      model,
+      // 摘要指令是普通 user 消息；不带工具定义，模型只能输出文本
+      messages: [...messages, { role: "user", content: COMPACT_PROMPT }],
+      settings
+    })) {
+      if (event.type === "error") {
+        console.warn(`\u4E0A\u4E0B\u6587\u538B\u7F29\u5931\u8D25\uFF08\u6A21\u578B\u8C03\u7528\u51FA\u9519\uFF09\uFF1A${event.error}`);
+        return null;
+      }
+      if (event.type === "done") summary = (event.response.content ?? "").trim();
+    }
+  } catch (err) {
+    console.warn(`\u4E0A\u4E0B\u6587\u538B\u7F29\u5931\u8D25\uFF08\u8BF7\u6C42\u5F02\u5E38\uFF09\uFF1A${err instanceof Error ? err.message : err}`);
+    return null;
+  }
+  if (!summary) {
+    console.warn("\u4E0A\u4E0B\u6587\u538B\u7F29\u5931\u8D25\uFF1A\u6A21\u578B\u8FD4\u56DE\u4E86\u7A7A\u6458\u8981");
+    return null;
+  }
+  const replacement = buildReplacementHistory(messages, summary);
+  const system = messages.slice(0, 1).filter((m) => m.role === "system");
+  return {
+    summary,
+    replacement_history: replacement,
+    tokens_before: estimateTokens(messages),
+    tokens_after: estimateTokens([...system, ...replacement])
+  };
+}
+
+// src/agent/sessions.ts
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { z as z3 } from "zod";
+var SESSION_FORMAT_VERSION = 3;
+var PREVIEW_MAX_CHARS = 80;
+function defaultDataDir() {
+  return path.join(os.homedir(), ".xlyra-agent");
+}
+function defaultSessionsDir() {
+  return path.join(defaultDataDir(), "sessions");
+}
+var sessionHeaderSchema = z3.object({
+  type: z3.literal("session").default("session"),
+  version: z3.number().default(SESSION_FORMAT_VERSION),
+  session_id: z3.string(),
+  created_at: z3.string()
+});
+var sessionMessageEntrySchema = z3.object({
+  type: z3.literal("message").default("message"),
+  uuid: z3.string(),
+  parent_uuid: z3.string().nullish(),
+  timestamp: z3.string(),
+  message: chatMessageSchema,
+  /** 以下仅 assistant 消息携带（运行元数据，不属于 message 本身，放信封层） */
+  model: z3.string().nullish(),
+  usage: tokenUsageSchema.nullish(),
+  finish_reason: z3.string().nullish()
+});
+var sessionCompactionEntrySchema = z3.object({
+  type: z3.literal("compaction").default("compaction"),
+  uuid: z3.string(),
+  parent_uuid: z3.string().nullish(),
+  timestamp: z3.string(),
+  summary: z3.string(),
+  replacement_history: z3.array(chatMessageSchema),
+  tokens_before: z3.number().nullish(),
+  tokens_after: z3.number().nullish()
+});
+var sessionEscalationEntrySchema = z3.object({
+  type: z3.literal("escalation").default("escalation"),
+  uuid: z3.string(),
+  parent_uuid: z3.string().nullish(),
+  timestamp: z3.string(),
+  requested_path: z3.string(),
+  resolved_path: z3.string(),
+  tool_name: z3.string(),
+  resource_type: z3.enum(["path", "command"]).default("path"),
+  requested_command: z3.array(z3.string()).nullish(),
+  /** 旧记录可能省略待确认状态；读取时统一规范化为 null。 */
+  granted: z3.boolean().nullish().default(null)
+});
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function entryUuid() {
+  return crypto.randomUUID().replaceAll("-", "").slice(0, 12);
+}
+function isMessageEntry(e) {
+  return e.type === "message";
+}
+function isCompactionEntry(e) {
+  return e.type === "compaction";
+}
+function isEscalationEntry(e) {
+  return e.type === "escalation";
+}
+function lastCompactionIndex(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (isCompactionEntry(entries[i])) return i;
+  }
+  return -1;
+}
+function messagesAfterLastCompaction(entries) {
+  const last = lastCompactionIndex(entries);
+  return entries.slice(last + 1).filter(isMessageEntry).map((e) => e.message);
+}
+var AgentSessionStore = class {
+  root;
+  /** session_id → 最后一条 entry 的 uuid（避免每次 append 都重读文件） */
+  leafCache = /* @__PURE__ */ new Map();
+  constructor(root) {
+    this.root = path.resolve(root ?? defaultSessionsDir());
+  }
+  get rootDir() {
+    return this.root;
+  }
+  pathOf(sessionId) {
+    return path.join(this.root, `${sessionId}.jsonl`);
+  }
+  exists(sessionId) {
+    return fs.existsSync(this.pathOf(sessionId));
+  }
+  // ------------------------------------------------------------------
+  // 写入
+  // ------------------------------------------------------------------
+  /** 新建会话文件并写入头行，返回头信息 */
+  create(sessionId) {
+    const header = {
+      type: "session",
+      version: SESSION_FORMAT_VERSION,
+      session_id: sessionId ?? crypto.randomUUID().replaceAll("-", ""),
+      created_at: nowIso()
+    };
+    fs.mkdirSync(this.root, { recursive: true });
+    fs.writeFileSync(this.pathOf(header.session_id), JSON.stringify(header) + "\n", { flag: "wx" });
+    this.leafCache.set(header.session_id, null);
+    return header;
+  }
+  /** 追加一条定稿消息，自动接到当前链尾，返回写入的 entry */
+  append(sessionId, message, meta) {
+    const parent = this.currentLeaf(sessionId);
+    const entry = {
+      type: "message",
+      uuid: entryUuid(),
+      parent_uuid: parent,
+      timestamp: nowIso(),
+      message,
+      model: meta?.model ?? null,
+      usage: meta?.usage ?? null,
+      finish_reason: meta?.finish_reason ?? null
+    };
+    this.appendLine(sessionId, stripNulls(entry));
+    this.leafCache.set(sessionId, entry.uuid);
+    return entry;
+  }
+  /** 追加一条压缩行，与 append 同款接到当前链尾（parent 链线性穿过压缩行） */
+  appendCompaction(sessionId, result) {
+    const parent = this.currentLeaf(sessionId);
+    const entry = {
+      type: "compaction",
+      uuid: entryUuid(),
+      parent_uuid: parent,
+      timestamp: nowIso(),
+      summary: result.summary,
+      replacement_history: result.replacement_history,
+      tokens_before: result.tokens_before,
+      tokens_after: result.tokens_after
+    };
+    this.appendLine(sessionId, stripNulls(entry));
+    this.leafCache.set(sessionId, entry.uuid);
+    return entry;
+  }
+  /** 追加一条提权请求行（granted=null 待确认） */
+  appendEscalation(sessionId, info) {
+    const parent = this.currentLeaf(sessionId);
+    const entry = {
+      type: "escalation",
+      uuid: info.escalation_id,
+      parent_uuid: parent,
+      timestamp: nowIso(),
+      requested_path: info.requested_path,
+      resolved_path: info.resolved_path,
+      tool_name: info.tool_name,
+      resource_type: info.resource_type ?? "path",
+      requested_command: info.requested_command,
+      granted: null
+    };
+    this.appendLine(sessionId, stripNulls(entry));
+    this.leafCache.set(sessionId, entry.uuid);
+    return entry;
+  }
+  /** 标记提权请求的确认结果（granted=true 授权 / false 拒绝）。
+   *  这是 append-only 原则的第二个例外（另一个是 discardFromUserMessage）：
+   *  提权行的 granted 字段需要就地更新，否则确认状态无法在回放时保留。
+   *  实现上仍是整文件原子重写（tmp + rename），与 discard 同款安全保证。 */
+  resolveEscalation(sessionId, escalationId, granted) {
+    const { header, entries } = this.read(sessionId);
+    const index = entries.findIndex((e) => isEscalationEntry(e) && e.uuid === escalationId);
+    if (index === -1) return false;
+    const target = entries[index];
+    if (!isEscalationEntry(target)) return false;
+    entries[index] = { ...target, granted };
+    const filePath = this.pathOf(sessionId);
+    const tmp = `${filePath}.tmp`;
+    const lines = [JSON.stringify(header), ...entries.map((e) => JSON.stringify(stripNulls(e)))];
+    fs.writeFileSync(tmp, lines.join("\n") + "\n");
+    fs.renameSync(tmp, filePath);
+    return true;
+  }
+  /**
+   * 中断收尾：给没有结果的 tool_call 补写错误回执，返回补写条数。
+   *
+   * 保证文件里 assistant 的 tool_calls 与 tool 消息任何时刻都配对完整，
+   * resume 直接回喂 API 不需要修复逻辑（在写入侧一次做对）。
+   * 只检查最后一条压缩行之后的消息：更早的往返已被压缩挡在上下文之外，
+   * 给死上下文补回执毫无意义。
+   */
+  sealPendingToolCalls(sessionId) {
+    const { entries } = this.read(sessionId);
+    const messages = messagesAfterLastCompaction(entries);
+    const answered = new Set(
+      messages.filter((m) => m.role === "tool").map((m) => m.tool_call_id)
+    );
+    let sealed = 0;
+    for (const message of messages) {
+      for (const tc of message.tool_calls ?? []) {
+        if (answered.has(tc.id)) continue;
+        this.append(sessionId, {
+          role: "tool",
+          content: "\u64CD\u4F5C\u5DF2\u88AB\u4E2D\u65AD\uFF0C\u5DE5\u5177\u672A\u6267\u884C\u5B8C\u6210\u3002",
+          tool_call_id: tc.id,
+          name: tc.name,
+          is_error: true
+        });
+        sealed += 1;
+      }
+    }
+    return sealed;
+  }
+  /**
+   * 删除指定 user message 及其之后的全部 entry，返回删除条数。
+   *
+   * 这是本模块唯一改写历史行的方法，与「append-only」约定相悖，属于刻意的
+   * 例外：用户要的就是「这些记录不该再存在」。整文件重写，写临时文件后
+   * rename 原子换入：中途崩溃要么旧文件完好、要么新文件完整。
+   * 只允许从 user message 切：从 assistant/tool 中间切会留下没有回执的
+   * tool_call，重建出的上下文喂回模型直接 400。
+   */
+  discardFromUserMessage(sessionId, messageId) {
+    const { header, entries } = this.read(sessionId);
+    const index = entries.findIndex((e) => e.uuid === messageId);
+    if (index === -1) throw new Error("\u4F1A\u8BDD\u4E2D\u6CA1\u6709\u8FD9\u6761\u8BB0\u5F55\uFF0C\u53EF\u80FD\u5DF2\u88AB\u6539\u5199");
+    const target = entries[index];
+    if (!isMessageEntry(target) || target.message.role !== "user") {
+      throw new Error("\u53EA\u80FD\u91CD\u8BD5\u7528\u6237\u6D88\u606F");
+    }
+    const kept = entries.slice(0, index);
+    const filePath = this.pathOf(sessionId);
+    const tmp = `${filePath}.tmp`;
+    const lines = [JSON.stringify(header), ...kept.map((e) => JSON.stringify(stripNulls(e)))];
+    fs.writeFileSync(tmp, lines.join("\n") + "\n");
+    fs.renameSync(tmp, filePath);
+    this.leafCache.set(sessionId, kept.length > 0 ? kept[kept.length - 1].uuid : null);
+    return entries.length - kept.length;
+  }
+  /** 删除会话文件（幂等） */
+  delete(sessionId) {
+    fs.rmSync(this.pathOf(sessionId), { force: true });
+    this.leafCache.delete(sessionId);
+  }
+  // ------------------------------------------------------------------
+  // 读取
+  // ------------------------------------------------------------------
+  /** 读取整个会话（头 + 全部 entry，含压缩行），坏行静默跳过 */
+  read(sessionId) {
+    const filePath = this.pathOf(sessionId);
+    if (!fs.existsSync(filePath)) throw new Error("\u4F1A\u8BDD\u4E0D\u5B58\u5728\u6216\u8F6C\u5F55\u6587\u4EF6\u5DF2\u88AB\u5220\u9664");
+    const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+    let header = null;
+    const entries = [];
+    let bad = 0;
+    for (const [lineNo, raw] of lines.entries()) {
+      const line = raw.trim();
+      if (!line) continue;
+      if (lineNo === 0) {
+        header = sessionHeaderSchema.parse(JSON.parse(line));
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(line);
+        const type = parsed.type;
+        entries.push(
+          type === "compaction" ? sessionCompactionEntrySchema.parse(parsed) : type === "escalation" ? sessionEscalationEntrySchema.parse(parsed) : sessionMessageEntrySchema.parse(parsed)
+        );
+      } catch {
+        bad += 1;
+      }
+    }
+    if (!header) throw new Error("\u4F1A\u8BDD\u6587\u4EF6\u4E3A\u7A7A\u6216\u5934\u8BB0\u5F55\u635F\u574F");
+    if (bad > 0) {
+      console.warn(`\u4F1A\u8BDD\u6587\u4EF6\u5B58\u5728 ${bad} \u884C\u65E0\u6CD5\u89E3\u6790\u7684\u8BB0\u5F55\uFF0C\u5DF2\u8DF3\u8FC7\uFF08\u53EF\u80FD\u6765\u81EA\u5F02\u5E38\u9000\u51FA\uFF09\uFF1A${filePath}`);
+    }
+    return { header, entries, badLines: bad };
+  }
+  /**
+   * 把会话重建成模型上下文消息列表（resume 喂回模型用）。
+   * 有压缩行时，从最后一条压缩行的替换历史起步、只追加其后的增量消息；
+   * system 提示词不入库（随代码版本演进），由 runner 每次运行时重新拼装。
+   */
+  buildHistory(sessionId) {
+    const { entries } = this.read(sessionId);
+    const last = lastCompactionIndex(entries);
+    if (last < 0) return entries.filter(isMessageEntry).map((e) => e.message);
+    const compaction = entries[last];
+    return [
+      ...compaction.replacement_history,
+      ...entries.slice(last + 1).filter(isMessageEntry).map((e) => e.message)
+    ];
+  }
+  /**
+   * 重建提权中断前的上下文：保留原始 user 输入，但丢弃被中断的
+   * assistant/tool 往返，授权后由 runner 从原输入继续推理。
+   */
+  buildHistoryBeforeEscalation(sessionId, escalationId) {
+    const { entries } = this.read(sessionId);
+    const escalationIndex = entries.findIndex(
+      (entry) => isEscalationEntry(entry) && entry.uuid === escalationId
+    );
+    if (escalationIndex < 0) return this.buildHistory(sessionId);
+    const escalation = entries[escalationIndex];
+    const assistantIndex = entries.findIndex(
+      (entry) => entry.uuid === escalation.parent_uuid && isMessageEntry(entry) && entry.message.role === "assistant"
+    );
+    const cut = assistantIndex >= 0 ? assistantIndex : escalationIndex;
+    const last = lastCompactionIndex(entries);
+    if (last >= 0 && last < cut) {
+      const compaction = entries[last];
+      return [
+        ...compaction.replacement_history,
+        ...entries.slice(last + 1, cut).filter(isMessageEntry).map((e) => e.message)
+      ];
+    }
+    return entries.slice(0, cut).filter(isMessageEntry).map((e) => e.message);
+  }
+  /** 扫描单个会话文件生成索引摘要 */
+  summarize(sessionId) {
+    const { header, entries } = this.read(sessionId);
+    const userTexts = entries.filter(isMessageEntry).filter((e) => e.message.role === "user" && (e.message.content ?? "").trim()).map((e) => (e.message.content ?? "").trim());
+    const last = entries[entries.length - 1];
+    return {
+      session_id: header.session_id,
+      created_at: header.created_at,
+      entry_count: entries.length,
+      leaf_uuid: last?.uuid ?? null,
+      title: userTexts[0]?.slice(0, PREVIEW_MAX_CHARS) ?? null,
+      last_prompt: userTexts[userTexts.length - 1]?.slice(0, PREVIEW_MAX_CHARS) ?? null,
+      last_timestamp: last?.timestamp ?? header.created_at
+    };
+  }
+  /** 遍历目录下全部会话文件生成摘要（索引整体重建用；单文件损坏只跳过） */
+  scanAll() {
+    if (!fs.existsSync(this.root)) return [];
+    const summaries = [];
+    for (const name of fs.readdirSync(this.root).sort()) {
+      if (!name.endsWith(".jsonl")) continue;
+      const sessionId = name.slice(0, -".jsonl".length);
+      try {
+        summaries.push(this.summarize(sessionId));
+      } catch (err) {
+        console.warn(`\u4F1A\u8BDD\u6587\u4EF6\u65E0\u6CD5\u89E3\u6790\uFF0C\u91CD\u5EFA\u7D22\u5F15\u65F6\u5DF2\u8DF3\u8FC7\uFF1A${name}\uFF08${err instanceof Error ? err.message : err}\uFF09`);
+      }
+    }
+    return summaries;
+  }
+  // ------------------------------------------------------------------
+  currentLeaf(sessionId) {
+    if (!this.leafCache.has(sessionId)) {
+      const { entries } = this.read(sessionId);
+      this.leafCache.set(sessionId, entries[entries.length - 1]?.uuid ?? null);
+    }
+    return this.leafCache.get(sessionId) ?? null;
+  }
+  appendLine(sessionId, entry) {
+    const filePath = this.pathOf(sessionId);
+    if (!fs.existsSync(filePath)) throw new Error("\u4F1A\u8BDD\u4E0D\u5B58\u5728\u6216\u8F6C\u5F55\u6587\u4EF6\u5DF2\u88AB\u5220\u9664");
+    fs.appendFileSync(filePath, JSON.stringify(entry) + "\n");
+  }
+};
+function stripNulls(obj) {
+  return JSON.parse(
+    JSON.stringify(obj, (_key, value) => value === null || value === void 0 ? void 0 : value)
+  );
+}
+
+// src/agent/runner.ts
+import crypto2 from "crypto";
+
+// src/tools/types.ts
+var TOOL_OUTPUT_MAX_BYTES = 5e4;
+function truncateMiddle2(text, maxBytes = TOOL_OUTPUT_MAX_BYTES) {
+  const data = Buffer.from(text, "utf-8");
+  if (data.length <= maxBytes) return text;
+  const half = Math.floor(maxBytes / 2);
+  const head = data.subarray(0, half).toString("utf-8");
+  const tail = data.subarray(data.length - half).toString("utf-8");
+  const omitted = Math.floor((data.length - maxBytes) / 4);
+  return `${head}
+\u2026\uFF08\u4E2D\u95F4\u7EA6 ${omitted} token \u5DF2\u622A\u65AD\uFF09\u2026
+${tail}`;
+}
+
+// src/agent/escalation.ts
+var COMMAND_EXECUTION_GRANT = "capability://exec_command";
+var EscalationRequiredError = class extends Error {
+  constructor(requestedPath, resolvedPath, message, resourceType = "path", requestedCommand) {
+    super(message ?? (resourceType === "command" ? "\u6267\u884C\u672C\u673A\u547D\u4EE4\u9700\u8981\u7528\u6237\u6388\u6743" : `\u8DEF\u5F84\u8D85\u51FA\u5DE5\u4F5C\u533A\u8303\u56F4\uFF0C\u9700\u8981\u7528\u6237\u6388\u6743\uFF1A${resolvedPath}`));
+    this.requestedPath = requestedPath;
+    this.resolvedPath = resolvedPath;
+    this.resourceType = resourceType;
+    this.requestedCommand = requestedCommand;
+    this.name = "EscalationRequiredError";
+  }
+  requestedPath;
+  resolvedPath;
+  resourceType;
+  requestedCommand;
+};
+var EscalationGrants = class {
+  grants = /* @__PURE__ */ new Map();
+  grant(sessionId, resolvedPath) {
+    let set = this.grants.get(sessionId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.grants.set(sessionId, set);
+    }
+    set.add(resolvedPath);
+  }
+  grantCapability(sessionId, capability) {
+    this.grant(sessionId, capability);
+  }
+  /** 已授权路径或其子路径视为已放开 */
+  isGranted(sessionId, resolvedPath) {
+    const set = this.grants.get(sessionId);
+    if (!set) return false;
+    for (const prefix of set) {
+      if (resolvedPath === prefix || resolvedPath.startsWith(prefix + "/")) return true;
+    }
+    return false;
+  }
+  isCapabilityGranted(sessionId, capability) {
+    return this.grants.get(sessionId)?.has(capability) ?? false;
+  }
+  /** 会话删除时清掉授权（授权随会话生命周期） */
+  drop(sessionId) {
+    this.grants.delete(sessionId);
+  }
+};
+
+// src/agent/runner.ts
+var EVENT_OUTPUT_LIMIT = 2e3;
+var AgentRunner = class {
+  protocol;
+  resolver;
+  tools;
+  toolsByName;
+  maxSteps;
+  onMessage;
+  onCompaction;
+  onEscalation;
+  logger;
+  /** 提权事件里展示的工作区根（用户判断边界用）；由构造方从工具配置传入 */
+  workdirHint;
+  constructor(opts) {
+    if (!opts.protocol && !opts.resolver) {
+      throw new Error("AgentRunner \u9700\u8981 protocol \u6216 resolver \u4E4B\u4E00");
+    }
+    this.protocol = opts.protocol;
+    this.resolver = opts.resolver;
+    this.tools = opts.tools ?? [];
+    this.toolsByName = new Map(this.tools.map((t) => [t.definition.name, t]));
+    this.maxSteps = opts.maxSteps ?? 200;
+    this.onMessage = opts.onMessage;
+    this.onCompaction = opts.onCompaction;
+    this.onEscalation = opts.onEscalation;
+    this.logger = opts.logger ?? console;
+    this.workdirHint = opts.workdirHint ?? "";
+  }
+  async *start(params, runOpts = {}) {
+    const runId = runOpts.runId ?? crypto2.randomUUID().replaceAll("-", "").slice(0, 12);
+    const started = Date.now();
+    let protocol;
+    let providerName;
+    let modelId;
+    let contextWindow;
+    try {
+      if (this.resolver) {
+        const resolved = this.resolver.resolve(params.model ?? "");
+        protocol = resolved.protocol;
+        providerName = resolved.endpoint.name;
+        modelId = resolved.modelId;
+        contextWindow = resolved.contextWindow;
+      } else {
+        protocol = this.protocol;
+        providerName = protocol.name;
+        modelId = params.model ?? "";
+        contextWindow = void 0;
+      }
+    } catch (err) {
+      if (err instanceof LlmError) {
+        yield { type: "agent_error", run_id: runId, error: err.message };
+        return;
+      }
+      throw err;
+    }
+    if (!contextWindow) {
+      this.logger.info(`\u6A21\u578B\u672A\u58F0\u660E\u4E0A\u4E0B\u6587\u7A97\u53E3\uFF0C\u81EA\u52A8\u538B\u7F29\u505C\u7528 model=${modelId}`);
+    }
+    const history = (params.history ?? []).map((m) => chatMessageSchema.parse(m));
+    const settings = modelSettingsSchema.parse(params.settings ?? {});
+    const definitions = this.tools.map((t) => t.definition);
+    const availableToolsPrompt = buildAvailableToolsPrompt(
+      definitions.map(({ name, description }) => ({ name, description }))
+    );
+    const messages = [
+      {
+        role: "system",
+        content: params.system_prompt ? `${params.system_prompt.trim()}
+
+${availableToolsPrompt}` : buildSystemPrompt({ availableTools: definitions.map(({ name, description }) => ({ name, description })) })
+      },
+      ...history,
+      ...params.include_input === false ? [] : [{ role: "user", content: params.input }]
+    ];
+    yield { type: "agent_start", run_id: runId, provider: providerName, model: modelId };
+    const preCompact = await this.maybeCompact(
+      protocol,
+      runId,
+      modelId,
+      messages,
+      estimateTokens(messages),
+      contextWindow,
+      settings
+    );
+    if (preCompact) yield preCompact;
+    let usage = emptyUsage();
+    for (let step = 1; step <= this.maxSteps; step++) {
+      if (runOpts.signal?.aborted) return;
+      let final = null;
+      for await (const event of protocol.chatStream({
+        model: modelId,
+        messages,
+        tools: definitions.length ? definitions : void 0,
+        settings,
+        signal: runOpts.signal
+      })) {
+        if (event.type === "thinking_delta") {
+          yield { type: "thinking_delta", run_id: runId, delta: event.delta };
+        } else if (event.type === "text_delta") {
+          yield { type: "text_delta", run_id: runId, delta: event.delta };
+        } else if (event.type === "toolcall_start") {
+          yield { type: "tool_call_start", run_id: runId, tool_call: event.tool_call };
+        } else if (event.type === "toolcall_delta") {
+          yield {
+            type: "tool_call_delta",
+            run_id: runId,
+            delta: event.delta,
+            tool_call_id: event.tool_call.id
+          };
+        } else if (event.type === "toolcall_end") {
+          yield { type: "tool_call", run_id: runId, tool_call: event.tool_call };
+        } else if (event.type === "error") {
+          this.logger.warn(`Agent \u8FD0\u884C\u5931\u8D25 run=${runId}\uFF1A${event.error}`);
+          yield { type: "agent_error", run_id: runId, error: event.error || "\u6A21\u578B\u8C03\u7528\u5931\u8D25\uFF0C\u539F\u56E0\u672A\u77E5" };
+          return;
+        } else if (event.type === "done") {
+          final = event.response;
+        }
+      }
+      if (runOpts.signal?.aborted) return;
+      if (!final) {
+        yield { type: "agent_error", run_id: runId, error: "\u6A21\u578B\u6D41\u5F02\u5E38\u7EC8\u6B62\uFF0C\u672A\u8FD4\u56DE\u7ED3\u679C" };
+        return;
+      }
+      usage = addUsage(usage, final.usage);
+      if (final.tool_calls.length === 0) {
+        await this.notify(responseToMessage(final), final);
+        const result = {
+          text: final.content,
+          thinking: final.thinking,
+          finish_reason: final.finish_reason,
+          usage,
+          steps: step,
+          model: final.model,
+          provider: final.provider,
+          elapsed_ms: Date.now() - started
+        };
+        yield { type: "agent_done", run_id: runId, result };
+        return;
+      }
+      messages.push(responseToMessage(final));
+      await this.notify(responseToMessage(final), final);
+      const stepToolMessages = [];
+      let callIndex = 0;
+      while (callIndex < final.tool_calls.length) {
+        const firstCall = final.tool_calls[callIndex];
+        const firstTool = this.toolsByName.get(firstCall.name);
+        const canRunParallel = firstTool?.annotations?.readOnly === true && firstTool.annotations.parallelSafe === true;
+        const batch = [firstCall];
+        callIndex += 1;
+        if (canRunParallel) {
+          while (callIndex < final.tool_calls.length) {
+            const candidate = final.tool_calls[callIndex];
+            const tool = this.toolsByName.get(candidate.name);
+            if (tool?.annotations?.readOnly !== true || tool.annotations.parallelSafe !== true) break;
+            batch.push(candidate);
+            callIndex += 1;
+          }
+        }
+        const settled = await Promise.allSettled(
+          batch.map((tc) => this.executeTool(tc, definitions, {
+            signal: runOpts.signal,
+            runId
+          }))
+        );
+        for (const [index, outcome] of settled.entries()) {
+          const tc = batch[index];
+          let result;
+          if (outcome.status === "rejected") {
+            const err = outcome.reason;
+            if (err instanceof EscalationRequiredError) {
+              const escalation = {
+                escalation_id: crypto2.randomUUID().replaceAll("-", "").slice(0, 12),
+                requested_path: err.requestedPath,
+                resolved_path: err.resolvedPath,
+                tool_name: tc.name,
+                workdir: this.workdirHint,
+                resource_type: err.resourceType,
+                requested_command: err.requestedCommand
+              };
+              await this.notifyEscalation(escalation);
+              yield { type: "escalation_request", run_id: runId, escalation };
+              yield { type: "agent_cancelled", run_id: runId };
+              return;
+            }
+            throw err;
+          } else {
+            result = outcome.value;
+          }
+          const toolResult = {
+            tool_call_id: result.tool_call_id,
+            name: result.name,
+            output: result.output.slice(0, EVENT_OUTPUT_LIMIT),
+            is_error: result.is_error,
+            elapsed_ms: result.elapsed_ms
+          };
+          yield { type: "tool_result", run_id: runId, tool_result: toolResult };
+          const toolMessage = {
+            role: "tool",
+            content: result.output,
+            tool_call_id: tc.id,
+            name: tc.name,
+            ...result.is_error ? { is_error: true } : {}
+          };
+          messages.push(toolMessage);
+          stepToolMessages.push(toolMessage);
+          await this.notify(toolMessage, null);
+        }
+      }
+      const stepUsage = final.usage.prompt_tokens + final.usage.completion_tokens;
+      const contextTokens = stepUsage > 0 ? stepUsage + estimateTokens(stepToolMessages) : estimateTokens(messages);
+      const midCompact = await this.maybeCompact(
+        protocol,
+        runId,
+        modelId,
+        messages,
+        contextTokens,
+        contextWindow,
+        settings
+      );
+      if (midCompact) yield midCompact;
+    }
+    this.logger.warn(`Agent \u8FBE\u5230\u6700\u5927\u6B65\u6570\u4E0A\u9650 run=${runId} steps=${this.maxSteps}`);
+    yield {
+      type: "agent_error",
+      run_id: runId,
+      error: `\u5DF2\u8FBE\u5230\u6700\u5927\u6267\u884C\u6B65\u6570\u4E0A\u9650\uFF08${this.maxSteps} \u6B65\uFF09\u4ECD\u672A\u5B8C\u6210\uFF0C\u8FD0\u884C\u7EC8\u6B62\u3002\u8BF7\u628A\u4EFB\u52A1\u62C6\u5C0F\u540E\u91CD\u8BD5\uFF0C\u6216\u68C0\u67E5\u662F\u5426\u9677\u5165\u4E86\u5FAA\u73AF\u3002`
+    };
+  }
+  /** 达到水位线时压缩上下文并原地替换 messages，返回压缩事件。
+   *  任何失败都降级为「本次不压缩」：记日志后照常返回 null，运行继续。 */
+  async maybeCompact(protocol, runId, modelId, messages, contextTokens, contextWindow, settings) {
+    if (!shouldCompact(contextTokens, contextWindow)) return null;
+    let result = null;
+    try {
+      result = await compact(protocol, modelId, messages, settings);
+    } catch (err) {
+      this.logger.warn(`\u4E0A\u4E0B\u6587\u538B\u7F29\u53D1\u751F\u610F\u5916\u9519\u8BEF\uFF0C\u672C\u6B21\u8DF3\u8FC7\u538B\u7F29 run=${runId}\uFF1A${err instanceof Error ? err.message : err}`);
+      return null;
+    }
+    if (!result) return null;
+    messages.splice(0, messages.length, messages[0], ...result.replacement_history);
+    await this.notifyCompaction(result);
+    this.logger.info(
+      `\u4E0A\u4E0B\u6587\u5DF2\u538B\u7F29 run=${runId} tokens=${result.tokens_before}\u2192${result.tokens_after}`
+    );
+    return {
+      type: "context_compacted",
+      run_id: runId,
+      compaction: {
+        summary: result.summary,
+        tokens_before: result.tokens_before,
+        tokens_after: result.tokens_after
+      }
+    };
+  }
+  async notifyCompaction(result) {
+    if (!this.onCompaction) return;
+    try {
+      await this.onCompaction(result);
+    } catch (err) {
+      this.logger.warn(`\u538B\u7F29\u8BB0\u5F55\u6301\u4E45\u5316\u56DE\u8C03\u5931\u8D25\uFF08\u672C\u6B21\u538B\u7F29\u53EF\u80FD\u672A\u843D\u76D8\uFF09\uFF1A${err instanceof Error ? err.message : err}`);
+    }
+  }
+  async notifyEscalation(info) {
+    if (!this.onEscalation) return;
+    try {
+      await this.onEscalation(info);
+    } catch (err) {
+      this.logger.warn(`\u63D0\u6743\u8BF7\u6C42\u6301\u4E45\u5316\u56DE\u8C03\u5931\u8D25\uFF08\u672C\u6B21\u8BF7\u6C42\u53EF\u80FD\u672A\u843D\u76D8\uFF09\uFF1A${err instanceof Error ? err.message : err}`);
+    }
+  }
+  async notify(message, response) {
+    if (!this.onMessage) return;
+    try {
+      await this.onMessage(message, response);
+    } catch (err) {
+      this.logger.warn(`Agent \u6D88\u606F\u6301\u4E45\u5316\u56DE\u8C03\u5931\u8D25\uFF08\u672C\u6761\u6D88\u606F\u53EF\u80FD\u672A\u843D\u76D8\uFF09\uFF1A${err instanceof Error ? err.message : err}`);
+    }
+  }
+  /** 执行单个工具调用：校验 → 执行；任何失败都转为回喂文本，不抛异常 */
+  async executeTool(tc, definitions, context = {}) {
+    const started = Date.now();
+    const { args, error } = validateToolCall(definitions, tc);
+    let output;
+    let isError;
+    if (error !== null) {
+      output = error;
+      isError = true;
+    } else {
+      const tool = this.toolsByName.get(tc.name);
+      try {
+        const handled = await tool.handler(args, context);
+        output = truncateMiddle2(typeof handled === "string" ? handled : handled.content);
+        isError = typeof handled === "string" ? false : handled.isError ?? false;
+      } catch (err) {
+        if (err instanceof EscalationRequiredError) throw err;
+        this.logger.warn(`\u5DE5\u5177\u6267\u884C\u5931\u8D25 tool=${tc.name}\uFF1A${err instanceof Error ? err.message : err}`);
+        output = `\u5DE5\u5177\u6267\u884C\u5931\u8D25\uFF1A${err instanceof Error ? err.message : err}`;
+        isError = true;
+      }
+    }
+    return {
+      tool_call_id: tc.id,
+      name: tc.name,
+      output,
+      is_error: isError,
+      elapsed_ms: Date.now() - started
+    };
+  }
+};
+
+// src/tools/workdir.ts
+import fs2 from "fs";
+import path2 from "path";
+function resolveSandboxed(workdir, raw, opts = {}) {
+  const baseReal = fs2.realpathSync(workdir);
+  const candidate = path2.resolve(path2.isAbsolute(raw) ? raw : path2.join(baseReal, raw));
+  if (opts.allowOutsideWorkdir) return candidate;
+  let existing = candidate;
+  const missing = [];
+  while (!fs2.existsSync(existing)) {
+    missing.unshift(path2.basename(existing));
+    const parent = path2.dirname(existing);
+    if (parent === existing) break;
+    existing = parent;
+  }
+  const existingReal = fs2.realpathSync(existing);
+  const realTarget = path2.join(existingReal, ...missing);
+  if (realTarget !== baseReal && !realTarget.startsWith(baseReal + path2.sep)) {
+    if (opts.grants && opts.sessionId && opts.grants.isGranted(opts.sessionId, realTarget)) {
+      return realTarget;
+    }
+    throw new EscalationRequiredError(raw, realTarget);
+  }
+  return realTarget;
+}
+
+// src/tools/apply-patch.ts
+import crypto3 from "crypto";
+import fs3 from "fs";
+import path3 from "path";
+import { z as z4 } from "zod";
+var argsSchema = z4.object({ patch: z4.string().min(1) });
+function makeApplyPatchTool(workdir, sandbox = {}) {
+  return {
+    definition: {
+      name: "apply_patch",
+      description: "\u5E94\u7528 Codex \u98CE\u683C\u7684\u591A\u6587\u4EF6\u8865\u4E01\u3002\u8F93\u5165\u987B\u4EE5 *** Begin Patch \u5F00\u59CB\u3001*** End Patch \u7ED3\u675F\uFF0C\u652F\u6301 *** Add File\u3001*** Update File\u3001*** Delete File\u3002\u6240\u6709\u6587\u4EF6\u5148\u6821\u9A8C\uFF0C\u4EFB\u4F55\u4E00\u5904\u5931\u8D25\u90FD\u4E0D\u4F1A\u5199\u5165\u3002",
+      parameters: z4.toJSONSchema(argsSchema)
+    },
+    annotations: { readOnly: false, parallelSafe: false },
+    handler: async (args) => {
+      const { patch } = argsSchema.parse(args);
+      const operations = parsePatch(patch, workdir, sandbox);
+      const writes = [];
+      const deletes = [];
+      for (const operation of operations) {
+        if (operation.kind === "add") {
+          if (fs3.existsSync(operation.file)) throw new Error(`\u65B0\u589E\u6587\u4EF6\u5DF2\u5B58\u5728\uFF1A${operation.rawPath}`);
+          writes.push({ ...operation, kind: "add" });
+        } else if (operation.kind === "delete") {
+          assertRegularFile(operation.rawPath, operation.file);
+          deletes.push(operation);
+        } else {
+          assertRegularFile(operation.rawPath, operation.file);
+          let content = fs3.readFileSync(operation.file, "utf-8");
+          for (const hunk of operation.hunks) content = applyHunk(content, hunk, operation.rawPath);
+          writes.push({ kind: "update", rawPath: operation.rawPath, file: operation.file, content });
+        }
+      }
+      const staged = [];
+      try {
+        for (const write of writes) staged.push(stageWrite(write));
+      } catch (err) {
+        for (const item of staged) fs3.rmSync(item.tmp, { force: true });
+        throw err;
+      }
+      const backups = /* @__PURE__ */ new Map();
+      const installedAdds = [];
+      try {
+        for (const item of staged) {
+          if (item.kind === "update") {
+            const backup = backupPath(item.file);
+            fs3.renameSync(item.file, backup);
+            backups.set(item.file, backup);
+          } else {
+            installedAdds.push(item.file);
+          }
+          fs3.mkdirSync(path3.dirname(item.file), { recursive: true });
+          fs3.renameSync(item.tmp, item.file);
+        }
+        for (const deletion of deletes) {
+          const backup = backupPath(deletion.file);
+          fs3.renameSync(deletion.file, backup);
+          backups.set(deletion.file, backup);
+        }
+      } catch (err) {
+        for (const item of staged) fs3.rmSync(item.tmp, { force: true });
+        for (const file of installedAdds) fs3.rmSync(file, { force: true });
+        for (const [file, backup] of [...backups].reverse()) {
+          fs3.rmSync(file, { force: true });
+          if (fs3.existsSync(backup)) fs3.renameSync(backup, file);
+        }
+        throw err;
+      }
+      for (const backup of backups.values()) fs3.rmSync(backup, { force: true });
+      const summary = operations.map((operation) => `${operation.kind} ${operation.rawPath}`).join("\n");
+      return `\u8865\u4E01\u5DF2\u5E94\u7528\uFF08${operations.length} \u4E2A\u6587\u4EF6\uFF09\uFF1A
+${summary}`;
+    }
+  };
+}
+function parsePatch(patch, workdir, sandbox) {
+  const lines = patch.replace(/\r\n/g, "\n").split("\n");
+  if (lines[0] !== "*** Begin Patch") throw new Error("\u8865\u4E01\u5FC5\u987B\u4EE5 *** Begin Patch \u5F00\u59CB");
+  const end = lines.lastIndexOf("*** End Patch");
+  if (end < 0) throw new Error("\u8865\u4E01\u7F3A\u5C11 *** End Patch");
+  if (lines.slice(end + 1).some((line) => line.trim())) throw new Error("*** End Patch \u540E\u4E0D\u80FD\u6709\u5185\u5BB9");
+  const operations = [];
+  const seen = /* @__PURE__ */ new Set();
+  let index = 1;
+  while (index < end) {
+    if (!lines[index]) {
+      index += 1;
+      continue;
+    }
+    const header = lines[index];
+    const matched = header.match(/^\*\*\* (Add|Update|Delete) File: (.+)$/);
+    if (!matched) throw new Error(`\u65E0\u6CD5\u8BC6\u522B\u7684\u8865\u4E01\u884C ${index + 1}\uFF1A${header}`);
+    const kind = matched[1].toLowerCase();
+    const rawPath = matched[2].trim();
+    if (!rawPath) throw new Error(`\u8865\u4E01\u7B2C ${index + 1} \u884C\u7F3A\u5C11\u6587\u4EF6\u8DEF\u5F84`);
+    const file = resolveSandboxed(workdir, rawPath, sandbox);
+    if (seen.has(file)) throw new Error(`\u540C\u4E00\u8865\u4E01\u4E0D\u80FD\u591A\u6B21\u64CD\u4F5C\u6587\u4EF6\uFF1A${rawPath}`);
+    seen.add(file);
+    index += 1;
+    const body = [];
+    while (index < end && !lines[index].startsWith("*** ")) {
+      body.push(lines[index]);
+      index += 1;
+    }
+    if (kind === "add") {
+      if (body.some((line) => !line.startsWith("+"))) {
+        throw new Error(`\u65B0\u589E\u6587\u4EF6 ${rawPath} \u7684\u6BCF\u4E00\u884C\u90FD\u5FC5\u987B\u4EE5 + \u5F00\u5934`);
+      }
+      operations.push({ kind, rawPath, file, content: body.map((line) => line.slice(1)).join("\n") });
+    } else if (kind === "delete") {
+      if (body.some((line) => line.length > 0)) throw new Error(`\u5220\u9664\u6587\u4EF6 ${rawPath} \u4E0D\u63A5\u53D7\u8865\u4E01\u6B63\u6587`);
+      operations.push({ kind, rawPath, file });
+    } else {
+      const hunks = parseHunks(body, rawPath);
+      operations.push({ kind, rawPath, file, hunks });
+    }
+  }
+  if (operations.length === 0) throw new Error("\u8865\u4E01\u4E0D\u5305\u542B\u4EFB\u4F55\u6587\u4EF6\u64CD\u4F5C");
+  return operations;
+}
+function parseHunks(lines, rawPath) {
+  const hunks = [];
+  let current = null;
+  for (const line of lines) {
+    if (line.startsWith("@@")) {
+      current = { before: [], after: [] };
+      hunks.push(current);
+      continue;
+    }
+    if (!current) throw new Error(`\u66F4\u65B0\u6587\u4EF6 ${rawPath} \u7684\u6B63\u6587\u5FC5\u987B\u4ECE @@ \u5F00\u59CB`);
+    const marker = line[0];
+    const text = line.slice(1);
+    if (marker === " ") {
+      current.before.push(text);
+      current.after.push(text);
+    } else if (marker === "-") {
+      current.before.push(text);
+    } else if (marker === "+") {
+      current.after.push(text);
+    } else {
+      throw new Error(`\u66F4\u65B0\u6587\u4EF6 ${rawPath} \u5305\u542B\u975E\u6CD5\u8865\u4E01\u884C\uFF1A${line}`);
+    }
+  }
+  if (hunks.length === 0) throw new Error(`\u66F4\u65B0\u6587\u4EF6 ${rawPath} \u7F3A\u5C11 @@ hunk`);
+  return hunks;
+}
+function applyHunk(content, hunk, rawPath) {
+  const before = hunk.before.join("\n");
+  const after = hunk.after.join("\n");
+  if (!before) throw new Error(`\u66F4\u65B0\u6587\u4EF6 ${rawPath} \u7684 hunk \u7F3A\u5C11\u4E0A\u4E0B\u6587\u6216\u5220\u9664\u884C`);
+  const first = content.indexOf(before);
+  if (first < 0) throw new Error(`\u66F4\u65B0\u6587\u4EF6 ${rawPath} \u65F6\u672A\u627E\u5230 hunk \u4E0A\u4E0B\u6587`);
+  if (content.indexOf(before, first + before.length) >= 0) {
+    throw new Error(`\u66F4\u65B0\u6587\u4EF6 ${rawPath} \u7684 hunk \u4E0A\u4E0B\u6587\u4E0D\u552F\u4E00`);
+  }
+  return content.slice(0, first) + after + content.slice(first + before.length);
+}
+function assertRegularFile(rawPath, file) {
+  if (!fs3.existsSync(file)) throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${rawPath}`);
+  if (!fs3.statSync(file).isFile()) throw new Error(`${rawPath} \u4E0D\u662F\u666E\u901A\u6587\u4EF6`);
+}
+function stageWrite(write) {
+  fs3.mkdirSync(path3.dirname(write.file), { recursive: true });
+  const tmp = path3.join(path3.dirname(write.file), `.xlyra-tmp-${crypto3.randomUUID()}${path3.extname(write.file)}`);
+  fs3.writeFileSync(tmp, write.content);
+  return { ...write, tmp };
+}
+function backupPath(file) {
+  return path3.join(path3.dirname(file), `.xlyra-backup-${crypto3.randomUUID()}${path3.extname(file)}`);
+}
+
+// src/tools/create.ts
+import fs4 from "fs";
+import path4 from "path";
+import { z as z5 } from "zod";
+var argsSchema2 = z5.object({
+  path: z5.string(),
+  content: z5.string()
+});
+function makeCreateTool(workdir, sandbox = {}) {
+  return {
+    definition: {
+      name: "create",
+      description: "\u65B0\u5EFA\u6587\u4EF6\u5E76\u5199\u5165\u5185\u5BB9\uFF08\u81EA\u52A8\u521B\u5EFA\u7236\u76EE\u5F55\uFF09\u3002\u76EE\u6807\u5DF2\u5B58\u5728\u65F6\u5931\u8D25\u2014\u2014\u5982\u9700\u4FEE\u6539\u5DF2\u6709\u6587\u4EF6\u8BF7\u7528 write \u5DE5\u5177\u3002",
+      parameters: z5.toJSONSchema(argsSchema2)
+    },
+    annotations: { readOnly: false, parallelSafe: false },
+    handler: async (args) => {
+      const { path: rawPath, content } = argsSchema2.parse(args);
+      const file = resolveSandboxed(workdir, rawPath, sandbox);
+      fs4.mkdirSync(path4.dirname(file), { recursive: true });
+      try {
+        fs4.writeFileSync(file, content, { flag: "wx" });
+      } catch (err) {
+        if (err.code === "EEXIST") {
+          throw new Error(`\u6587\u4EF6\u5DF2\u5B58\u5728\uFF1A${rawPath}\uFF1B\u5982\u9700\u4FEE\u6539\u8BF7\u7528 write \u5DE5\u5177`);
+        }
+        throw err;
+      }
+      return `\u5DF2\u521B\u5EFA ${rawPath}\uFF08${content.length} \u5B57\u7B26\uFF0C${content.split("\n").length} \u884C\uFF09`;
+    }
+  };
+}
+
+// src/tools/edit.ts
+import crypto4 from "crypto";
+import fs5 from "fs";
+import path5 from "path";
+import { z as z6 } from "zod";
+var argsSchema3 = z6.object({
+  path: z6.string(),
+  old_text: z6.string().min(1),
+  new_text: z6.string(),
+  replace_all: z6.boolean().default(false)
+});
+function makeEditTool(workdir, sandbox = {}) {
+  return {
+    definition: {
+      name: "edit",
+      description: "\u7CBE\u786E\u4FEE\u6539\u5DF2\u6709\u6587\u672C\u6587\u4EF6\u3002\u9ED8\u8BA4\u8981\u6C42 old_text \u5728\u6587\u4EF6\u4E2D\u6070\u597D\u51FA\u73B0\u4E00\u6B21\uFF1B\u672A\u547D\u4E2D\u6216\u591A\u6B21\u547D\u4E2D\u90FD\u4F1A\u5931\u8D25\u3002\u786E\u9700\u66FF\u6362\u5168\u90E8\u5339\u914D\u65F6\u4F20 replace_all=true\u3002",
+      parameters: z6.toJSONSchema(argsSchema3)
+    },
+    annotations: { readOnly: false, parallelSafe: false },
+    handler: async (args) => {
+      const { path: rawPath, old_text: oldText, new_text: newText, replace_all: replaceAll } = argsSchema3.parse(args);
+      const file = resolveSandboxed(workdir, rawPath, sandbox);
+      if (!fs5.existsSync(file)) throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${rawPath}`);
+      if (fs5.statSync(file).isDirectory()) throw new Error(`${rawPath} \u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6`);
+      const original = fs5.readFileSync(file, "utf-8");
+      const matches = countMatches(original, oldText);
+      if (matches === 0) throw new Error(`\u672A\u627E\u5230\u8981\u66FF\u6362\u7684 old_text\uFF1A${rawPath}`);
+      if (!replaceAll && matches !== 1) {
+        throw new Error(
+          `old_text \u5728 ${rawPath} \u4E2D\u51FA\u73B0 ${matches} \u6B21\uFF1B\u8BF7\u63D0\u4F9B\u66F4\u957F\u7684\u552F\u4E00\u4E0A\u4E0B\u6587\uFF0C\u6216\u660E\u786E\u4F20 replace_all=true`
+        );
+      }
+      const first = original.indexOf(oldText);
+      const updated = replaceAll ? original.split(oldText).join(newText) : original.slice(0, first) + newText + original.slice(first + oldText.length);
+      atomicReplace(file, updated);
+      return `\u5DF2\u7F16\u8F91 ${rawPath}\uFF08\u66FF\u6362 ${replaceAll ? matches : 1} \u5904\uFF09`;
+    }
+  };
+}
+function countMatches(text, needle) {
+  let count = 0;
+  let cursor = 0;
+  while (true) {
+    const index = text.indexOf(needle, cursor);
+    if (index < 0) return count;
+    count += 1;
+    cursor = index + needle.length;
+  }
+}
+function atomicReplace(file, content) {
+  const tmp = path5.join(path5.dirname(file), `.xlyra-tmp-${crypto4.randomUUID()}${path5.extname(file)}`);
+  try {
+    fs5.writeFileSync(tmp, content);
+    fs5.renameSync(tmp, file);
+  } catch (err) {
+    fs5.rmSync(tmp, { force: true });
+    throw err;
+  }
+}
+
+// src/tools/process-manager.ts
+import crypto5 from "crypto";
+import { spawn } from "child_process";
+var TRANSCRIPT_MAX_CHARS = 2e5;
+var COMPLETED_SESSION_RETENTION_MS = 60 * 60 * 1e3;
+var MAX_SESSIONS = 128;
+var ProcessManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  start(options) {
+    this.prune();
+    if (this.sessions.size >= MAX_SESSIONS) {
+      const completed = [...this.sessions.values()].filter((session2) => session2.completedAt !== null).sort((a, b) => a.completedAt - b.completedAt);
+      for (const session2 of completed) {
+        this.sessions.delete(session2.id);
+        if (this.sessions.size < MAX_SESSIONS) break;
+      }
+    }
+    if (this.sessions.size >= MAX_SESSIONS) {
+      throw new Error(`\u8FDB\u7A0B\u4F1A\u8BDD\u5DF2\u8FBE\u5230\u4E0A\u9650\uFF08${MAX_SESSIONS}\uFF09\uFF1B\u8BF7\u7B49\u5F85\u5DF2\u6709\u547D\u4EE4\u7ED3\u675F\u540E\u91CD\u8BD5`);
+    }
+    const id = crypto5.randomUUID().replaceAll("-", "").slice(0, 12);
+    const child = spawn(options.command[0], options.command.slice(1), {
+      cwd: options.cwd,
+      env: process.env,
+      stdio: "pipe",
+      shell: false
+    });
+    let resolveDone = () => {
+    };
+    const done = new Promise((resolve) => {
+      resolveDone = resolve;
+    });
+    const session = {
+      id,
+      child,
+      output: "",
+      readCursor: 0,
+      exitCode: null,
+      exitSignal: null,
+      error: null,
+      completedAt: null,
+      done,
+      resolveDone,
+      timeout: setTimeout(() => this.terminate(id, "\u547D\u4EE4\u6267\u884C\u8D85\u65F6"), options.timeoutMs),
+      abortSignal: options.signal
+    };
+    session.timeout.unref?.();
+    this.sessions.set(id, session);
+    const append = (chunk) => {
+      session.output += chunk.toString("utf-8");
+      if (session.output.length > TRANSCRIPT_MAX_CHARS) {
+        const removed = session.output.length - TRANSCRIPT_MAX_CHARS;
+        session.output = session.output.slice(removed);
+        session.readCursor = Math.max(0, session.readCursor - removed);
+      }
+    };
+    child.stdout.on("data", append);
+    child.stderr.on("data", append);
+    child.once("error", (err) => {
+      session.error = err.message;
+      this.finish(session, child.exitCode, child.signalCode);
+    });
+    child.once("close", (code, signal) => this.finish(session, code, signal));
+    if (options.signal) {
+      const onAbort = () => this.terminate(id, "\u547D\u4EE4\u5DF2\u53D6\u6D88");
+      session.abortListener = onAbort;
+      if (options.signal.aborted) onAbort();
+      else options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    return id;
+  }
+  async poll(sessionId, yieldTimeMs, maxOutputBytes) {
+    const session = this.require(sessionId);
+    if (session.child.exitCode === null && session.exitSignal === null && !session.error) {
+      await Promise.race([
+        session.done,
+        new Promise((resolve) => {
+          const timer = setTimeout(resolve, yieldTimeMs);
+          timer.unref?.();
+        })
+      ]);
+    }
+    const unread = session.output.slice(session.readCursor);
+    session.readCursor = session.output.length;
+    return {
+      sessionId,
+      output: truncateMiddle2(unread, maxOutputBytes),
+      running: session.child.exitCode === null && session.exitSignal === null && !session.error,
+      exitCode: session.exitCode,
+      exitSignal: session.exitSignal,
+      error: session.error
+    };
+  }
+  write(sessionId, chars) {
+    const session = this.require(sessionId);
+    if (session.child.exitCode !== null || session.exitSignal !== null || session.error) {
+      throw new Error(`\u8FDB\u7A0B\u4F1A\u8BDD\u5DF2\u7ED3\u675F\uFF1A${sessionId}`);
+    }
+    session.child.stdin.write(chars);
+  }
+  require(sessionId) {
+    this.prune();
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`\u8FDB\u7A0B\u4F1A\u8BDD\u4E0D\u5B58\u5728\uFF1A${sessionId}`);
+    return session;
+  }
+  terminate(sessionId, reason) {
+    const session = this.sessions.get(sessionId);
+    if (!session || session.completedAt !== null) return;
+    session.error = reason;
+    session.child.kill("SIGTERM");
+    const force = setTimeout(() => session.child.kill("SIGKILL"), 1e3);
+    force.unref?.();
+  }
+  finish(session, code, signal) {
+    if (session.completedAt !== null) return;
+    clearTimeout(session.timeout);
+    session.exitCode = code;
+    session.exitSignal = signal;
+    session.completedAt = Date.now();
+    if (session.abortSignal && session.abortListener) {
+      session.abortSignal.removeEventListener("abort", session.abortListener);
+    }
+    session.resolveDone();
+  }
+  prune() {
+    const cutoff = Date.now() - COMPLETED_SESSION_RETENTION_MS;
+    for (const [id, session] of this.sessions) {
+      if (session.completedAt !== null && session.completedAt <= cutoff) this.sessions.delete(id);
+    }
+  }
+};
+
+// src/tools/exec-command.ts
+import fs6 from "fs";
+import { z as z7 } from "zod";
+var argsSchema4 = z7.object({
+  command: z7.array(z7.string()).min(1),
+  cwd: z7.string().default("."),
+  timeout_ms: z7.number().int().min(100).max(3e5).default(3e4),
+  yield_time_ms: z7.number().int().min(0).max(3e4).default(1e4),
+  max_output_bytes: z7.number().int().min(1e3).max(1e5).default(5e4)
+});
+function makeExecCommandTool(workdir, manager, sandbox = {}) {
+  return {
+    definition: {
+      name: "exec_command",
+      description: '\u76F4\u63A5\u6267\u884C\u547D\u4EE4 argv\uFF0C\u4E0D\u7ECF\u8FC7 shell\u3002command \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4\uFF0C\u4F8B\u5982 ["pnpm","test"]\u3002\u547D\u4EE4\u8D85\u8FC7 yield_time_ms \u4ECD\u5728\u8FD0\u884C\u65F6\u8FD4\u56DE session_id\uFF0C\u540E\u7EED\u7528 write_stdin \u8BFB\u53D6\u8F93\u51FA\u6216\u8F93\u5165\u5185\u5BB9\u3002\u6267\u884C\u524D\u53EF\u80FD\u9700\u8981\u7528\u6237\u6388\u6743\u3002',
+      parameters: z7.toJSONSchema(argsSchema4)
+    },
+    annotations: { readOnly: false, parallelSafe: false },
+    handler: async (args, context) => {
+      const parsed = argsSchema4.parse(args);
+      const commandAllowed = sandbox.commandExecutionEnabled === true || sandbox.grants !== void 0 && sandbox.sessionId !== void 0 && sandbox.grants.isCapabilityGranted(sandbox.sessionId, COMMAND_EXECUTION_GRANT);
+      if (!commandAllowed) {
+        throw new EscalationRequiredError(
+          parsed.command.join(" "),
+          COMMAND_EXECUTION_GRANT,
+          "\u6267\u884C\u672C\u673A\u547D\u4EE4\u9700\u8981\u7528\u6237\u6388\u6743",
+          "command",
+          parsed.command
+        );
+      }
+      const cwd = resolveSandboxed(workdir, parsed.cwd, sandbox);
+      if (!fs6.existsSync(cwd)) throw new Error(`\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${parsed.cwd}`);
+      if (!fs6.statSync(cwd).isDirectory()) throw new Error(`cwd \u4E0D\u662F\u76EE\u5F55\uFF1A${parsed.cwd}`);
+      const sessionId = manager.start({
+        command: parsed.command,
+        cwd,
+        timeoutMs: parsed.timeout_ms,
+        signal: context?.signal
+      });
+      const result = await manager.poll(sessionId, parsed.yield_time_ms, parsed.max_output_bytes);
+      return formatProcessResult(result);
+    }
+  };
+}
+function formatProcessResult(result) {
+  const sections = [
+    `session_id: ${result.sessionId}`,
+    result.running ? "status: running" : `status: exited${result.exitCode !== null ? `
+exit_code: ${result.exitCode}` : ""}${result.exitSignal ? `
+exit_signal: ${result.exitSignal}` : ""}`
+  ];
+  if (result.output) sections.push(`output:
+${result.output}`);
+  else sections.push("output: \uFF08\u6682\u65E0\u65B0\u8F93\u51FA\uFF09");
+  if (result.error) sections.push(`error: ${result.error}`);
+  return {
+    content: sections.join("\n"),
+    isError: Boolean(result.error) || !result.running && result.exitCode !== null && result.exitCode !== 0
+  };
+}
+
+// src/tools/list.ts
+import fs7 from "fs";
+import path6 from "path";
+import { z as z8 } from "zod";
+var MAX_ENTRIES = 500;
+var IGNORE_NAMES = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  ".next",
+  "out",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "__pycache__",
+  ".venv"
+]);
+var argsSchema5 = z8.object({
+  path: z8.string().default("."),
+  recursive: z8.boolean().default(false),
+  pattern: z8.string().optional()
+});
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(//g, ".*");
+  return new RegExp(`(^|/)${escaped}$|^${escaped}$`);
+}
+function makeListTool(workdir, sandbox = {}) {
+  return {
+    definition: {
+      name: "list",
+      description: `\u5217\u51FA\u76EE\u5F55\u5185\u5BB9\uFF08\u6587\u4EF6\u4E0E\u5B50\u76EE\u5F55\uFF0C\u76EE\u5F55\u5E26 / \u540E\u7F00\uFF09\u3002\u9ED8\u8BA4\u53EA\u5217\u4E00\u5C42\uFF0Crecursive=true \u9012\u5F52\u5217\u51FA\u3002\u5185\u7F6E\u5FFD\u7565 .git\u3001node_modules \u7B49\u76EE\u5F55\u3002\u5355\u6B21\u6700\u591A\u8FD4\u56DE ${MAX_ENTRIES} \u6761\uFF0C\u8D85\u51FA\u65F6\u63D0\u793A\u7701\u7565\u6570\u91CF\u3002`,
+      parameters: z8.toJSONSchema(argsSchema5)
+    },
+    annotations: { readOnly: true, parallelSafe: true },
+    handler: async (args) => {
+      const { path: rawPath, recursive, pattern } = argsSchema5.parse(args);
+      const dir = resolveSandboxed(workdir, rawPath, sandbox);
+      if (!fs7.existsSync(dir)) throw new Error(`\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${rawPath}`);
+      if (!fs7.statSync(dir).isDirectory()) throw new Error(`${rawPath} \u662F\u6587\u4EF6\u4E0D\u662F\u76EE\u5F55\uFF1B\u8BFB\u53D6\u6587\u4EF6\u8BF7\u7528 read \u5DE5\u5177`);
+      const matcher = pattern ? globToRegExp(pattern) : null;
+      const results = [];
+      let omitted = 0;
+      const walk = (current) => {
+        if (results.length >= MAX_ENTRIES) {
+          omitted += countRemaining(current, recursive);
+          return;
+        }
+        let entries;
+        try {
+          entries = fs7.readdirSync(current, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+          if (IGNORE_NAMES.has(entry.name)) continue;
+          const full = path6.join(current, entry.name);
+          const rel = path6.relative(dir, full);
+          const display = entry.isDirectory() ? `${rel}/` : rel;
+          if (!matcher || matcher.test(display)) {
+            if (results.length < MAX_ENTRIES) results.push(display);
+            else omitted += 1;
+          }
+          if (recursive && entry.isDirectory()) walk(full);
+        }
+      };
+      walk(dir);
+      const header = `\u76EE\u5F55 ${rawPath} \u7684\u5185\u5BB9\uFF1A`;
+      if (results.length === 0) return `${header}
+\uFF08\u7A7A\u76EE\u5F55\u6216\u65E0\u5339\u914D\u9879\uFF09`;
+      const body = results.join("\n");
+      return omitted > 0 ? `${header}
+${body}
+\uFF08\u5171 ${results.length + omitted} \u6761\uFF0C\u5DF2\u7701\u7565 ${omitted} \u6761\uFF1B\u53EF\u7528 pattern \u7F29\u5C0F\u8303\u56F4\uFF09` : `${header}
+${body}`;
+    }
+  };
+}
+function countRemaining(dir, recursive) {
+  let count = 0;
+  let entries;
+  try {
+    entries = fs7.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    if (IGNORE_NAMES.has(entry.name)) continue;
+    count += 1;
+    if (recursive && entry.isDirectory()) count += countRemaining(path6.join(dir, entry.name), true);
+  }
+  return count;
+}
+
+// src/tools/read.ts
+import fs8 from "fs";
+import path7 from "path";
+import { z as z9 } from "zod";
+var MAX_LINES = 2e3;
+var MAX_BYTES = 5e4;
+var IMAGE_SUFFIXES = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".svg"]);
+var argsSchema6 = z9.object({
+  path: z9.string(),
+  offset: z9.number().int().min(1).default(1),
+  limit: z9.number().int().min(1).optional()
+});
+function makeReadTool(workdir, sandbox = {}) {
+  return {
+    definition: {
+      name: "read",
+      description: "\u8BFB\u53D6\u6587\u672C\u6587\u4EF6\u5185\u5BB9\u3002\u5355\u6B21\u6700\u591A\u8FD4\u56DE 2000 \u884C\u6216 50KB\uFF08\u5148\u5230\u4E3A\u51C6\uFF09\uFF0C\u5927\u6587\u4EF6\u7528 offset/limit \u5206\u6BB5\u8BFB\u53D6\uFF0C\u76F4\u5230\u8BFB\u5B8C\u4E3A\u6B62\u3002\u4E0D\u652F\u6301\u56FE\u7247\u3002",
+      parameters: z9.toJSONSchema(argsSchema6)
+    },
+    annotations: { readOnly: true, parallelSafe: true },
+    handler: async (args) => {
+      const { path: rawPath, offset, limit } = argsSchema6.parse(args);
+      const file = resolveSandboxed(workdir, rawPath, sandbox);
+      if (!fs8.existsSync(file)) throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${rawPath}`);
+      if (fs8.statSync(file).isDirectory()) {
+        throw new Error(`${rawPath} \u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6\uFF1B\u67E5\u770B\u76EE\u5F55\u5185\u5BB9\u8BF7\u7528 list \u5DE5\u5177`);
+      }
+      if (IMAGE_SUFFIXES.has(path7.extname(file).toLowerCase())) {
+        throw new Error("\u6682\u4E0D\u652F\u6301\u8BFB\u53D6\u56FE\u7247\u6587\u4EF6\uFF0C\u53EA\u652F\u6301\u6587\u672C\u6587\u4EF6");
+      }
+      const lines = fs8.readFileSync(file, "utf-8").split("\n");
+      const total = lines.length;
+      if (offset > total && total > 0) {
+        throw new Error(`offset \u8D85\u51FA\u8303\u56F4\uFF1A\u6587\u4EF6\u5171 ${total} \u884C\uFF0Coffset=${offset}`);
+      }
+      const cap = Math.min(limit ?? MAX_LINES, MAX_LINES);
+      const window = lines.slice(offset - 1, offset - 1 + cap);
+      const picked = [];
+      let size = 0;
+      for (const line of window) {
+        size += Buffer.byteLength(line, "utf-8") + 1;
+        if (picked.length > 0 && size > MAX_BYTES) break;
+        picked.push(line);
+      }
+      const end = offset - 1 + picked.length;
+      let body = picked.join("\n");
+      if (end < total) {
+        body += `
+\uFF08\u6587\u4EF6\u5171 ${total} \u884C\uFF0C\u672C\u6B21\u8FD4\u56DE\u7B2C ${offset}-${end} \u884C\uFF1B\u7EE7\u7EED\u8BFB\u53D6\u8BF7\u4F20 offset=${end + 1}\uFF09`;
+      }
+      return body || "\uFF08\u7A7A\u6587\u4EF6\uFF09";
+    }
+  };
+}
+
+// src/tools/search.ts
+import fs9 from "fs";
+import path8 from "path";
+import { z as z10 } from "zod";
+var MAX_FILE_BYTES = 2 * 1024 * 1024;
+var HARD_MAX_RESULTS = 500;
+var IGNORE_NAMES2 = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  ".next",
+  "out",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "__pycache__",
+  ".venv"
+]);
+var argsSchema7 = z10.object({
+  query: z10.string().min(1),
+  path: z10.string().default("."),
+  glob: z10.string().optional(),
+  case_sensitive: z10.boolean().default(false),
+  max_results: z10.number().int().min(1).max(HARD_MAX_RESULTS).default(100)
+});
+function makeSearchTool(workdir, sandbox = {}) {
+  return {
+    definition: {
+      name: "search",
+      description: "\u5728\u5DE5\u4F5C\u533A\u6587\u672C\u6587\u4EF6\u4E2D\u641C\u7D22\u5185\u5BB9\uFF0C\u8FD4\u56DE path:line:match\u3002\u53EF\u7528 glob \u6309\u6587\u4EF6\u8DEF\u5F84\u7B5B\u9009\uFF0C\u4F8B\u5982 **/*.ts\uFF1B\u9ED8\u8BA4\u5FFD\u7565 .git\u3001node_modules\u3001dist \u7B49\u76EE\u5F55\u548C\u4E8C\u8FDB\u5236\u6587\u4EF6\u3002",
+      parameters: z10.toJSONSchema(argsSchema7)
+    },
+    annotations: { readOnly: true, parallelSafe: true },
+    handler: async (args, context) => {
+      const parsed = argsSchema7.parse(args);
+      const target = resolveSandboxed(workdir, parsed.path, sandbox);
+      if (!fs9.existsSync(target)) throw new Error(`\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF1A${parsed.path}`);
+      const matcher = parsed.glob ? globToRegExp2(parsed.glob) : null;
+      const needle = parsed.case_sensitive ? parsed.query : parsed.query.toLocaleLowerCase();
+      const results = [];
+      let truncated = false;
+      const visit = (entryPath) => {
+        if (context?.signal?.aborted || results.length >= parsed.max_results) {
+          truncated = results.length >= parsed.max_results;
+          return;
+        }
+        const lstat = fs9.lstatSync(entryPath);
+        if (lstat.isSymbolicLink()) return;
+        const stat = lstat;
+        if (stat.isDirectory()) {
+          for (const entry of fs9.readdirSync(entryPath, { withFileTypes: true })) {
+            if (IGNORE_NAMES2.has(entry.name)) continue;
+            visit(path8.join(entryPath, entry.name));
+            if (results.length >= parsed.max_results || context?.signal?.aborted) break;
+          }
+          return;
+        }
+        const relative = path8.relative(workdir, entryPath) || path8.basename(entryPath);
+        const portable = relative.split(path8.sep).join("/");
+        if (matcher && !matcher.test(portable)) return;
+        if (stat.size > MAX_FILE_BYTES || isBinary(entryPath)) return;
+        let text;
+        try {
+          text = fs9.readFileSync(entryPath, "utf-8");
+        } catch {
+          return;
+        }
+        for (const [index, line] of text.split("\n").entries()) {
+          const haystack = parsed.case_sensitive ? line : line.toLocaleLowerCase();
+          if (!haystack.includes(needle)) continue;
+          results.push(`${portable}:${index + 1}:${line}`);
+          if (results.length >= parsed.max_results) {
+            truncated = true;
+            break;
+          }
+        }
+      };
+      visit(target);
+      if (context?.signal?.aborted) throw new Error("\u641C\u7D22\u5DF2\u53D6\u6D88");
+      if (results.length === 0) return `\u672A\u627E\u5230\u5339\u914D\uFF1A${parsed.query}`;
+      return results.join("\n") + (truncated ? `
+\uFF08\u7ED3\u679C\u5DF2\u622A\u65AD\u5230 ${parsed.max_results} \u6761\uFF1B\u8BF7\u7F29\u5C0F path \u6216 glob\uFF09` : "");
+    }
+  };
+}
+function isBinary(file) {
+  const fd = fs9.openSync(file, "r");
+  try {
+    const buffer = Buffer.alloc(4096);
+    const read = fs9.readSync(fd, buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, read).includes(0);
+  } finally {
+    fs9.closeSync(fd);
+  }
+}
+function globToRegExp2(glob) {
+  let source = "";
+  for (let index = 0; index < glob.length; index += 1) {
+    const char = glob[index];
+    if (char === "*") {
+      if (glob[index + 1] === "*") {
+        if (glob[index + 2] === "/") {
+          source += "(?:.*/)?";
+          index += 2;
+        } else {
+          source += ".*";
+          index += 1;
+        }
+      } else {
+        source += "[^/]*";
+      }
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += char.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+// src/tools/write.ts
+import fs10 from "fs";
+import path9 from "path";
+import crypto6 from "crypto";
+import { z as z11 } from "zod";
+var argsSchema8 = z11.object({
+  path: z11.string(),
+  content: z11.string()
+});
+function makeWriteTool(workdir, sandbox = {}) {
+  return {
+    definition: {
+      name: "write",
+      description: "\u6574\u4F53\u8986\u76D6\u5DF2\u6709\u6587\u4EF6\u7684\u5185\u5BB9\u3002\u76EE\u6807\u4E0D\u5B58\u5728\u65F6\u5931\u8D25\u2014\u2014\u65B0\u5EFA\u6587\u4EF6\u8BF7\u7528 create \u5DE5\u5177\u3002",
+      parameters: z11.toJSONSchema(argsSchema8)
+    },
+    annotations: { readOnly: false, parallelSafe: false },
+    handler: async (args) => {
+      const { path: rawPath, content } = argsSchema8.parse(args);
+      const file = resolveSandboxed(workdir, rawPath, sandbox);
+      if (!fs10.existsSync(file)) {
+        throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${rawPath}\uFF1B\u65B0\u5EFA\u6587\u4EF6\u8BF7\u7528 create \u5DE5\u5177`);
+      }
+      if (fs10.statSync(file).isDirectory()) {
+        throw new Error(`${rawPath} \u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6`);
+      }
+      const tmp = path9.join(
+        path9.dirname(file),
+        `.xlyra-tmp-${crypto6.randomUUID()}${path9.extname(file)}`
+      );
+      try {
+        fs10.writeFileSync(tmp, content);
+        fs10.renameSync(tmp, file);
+      } catch (err) {
+        fs10.rmSync(tmp, { force: true });
+        throw err;
+      }
+      return `\u5DF2\u8986\u76D6 ${rawPath}\uFF08${content.length} \u5B57\u7B26\uFF0C${content.split("\n").length} \u884C\uFF09`;
+    }
+  };
+}
+
+// src/tools/write-stdin.ts
+import { z as z12 } from "zod";
+var argsSchema9 = z12.object({
+  session_id: z12.string().min(1),
+  chars: z12.string().optional(),
+  yield_time_ms: z12.number().int().min(0).max(3e4).default(5e3),
+  max_output_bytes: z12.number().int().min(1e3).max(1e5).default(5e4)
+});
+function makeWriteStdinTool(manager, sandbox = {}) {
+  return {
+    definition: {
+      name: "write_stdin",
+      description: "\u7EE7\u7EED\u8BFB\u53D6 exec_command \u8FD4\u56DE\u7684\u8FDB\u7A0B\u4F1A\u8BDD\uFF1B\u63D0\u4F9B chars \u65F6\u5148\u5411\u8FDB\u7A0B\u6807\u51C6\u8F93\u5165\u5199\u5165\u5185\u5BB9\u3002\u4EA4\u4E92\u5F0F\u8F93\u5165\u901A\u5E38\u9700\u8981\u81EA\u884C\u9644\u52A0\u6362\u884C\u7B26\u3002\u4F7F\u7528\u524D\u53EF\u80FD\u9700\u8981\u7528\u6237\u6388\u6743\u3002",
+      parameters: z12.toJSONSchema(argsSchema9)
+    },
+    annotations: { readOnly: false, parallelSafe: false },
+    handler: async (args) => {
+      const parsed = argsSchema9.parse(args);
+      const commandAllowed = sandbox.commandExecutionEnabled === true || sandbox.grants !== void 0 && sandbox.sessionId !== void 0 && sandbox.grants.isCapabilityGranted(sandbox.sessionId, COMMAND_EXECUTION_GRANT);
+      if (!commandAllowed) {
+        throw new EscalationRequiredError(
+          `exec_command session ${parsed.session_id}`,
+          COMMAND_EXECUTION_GRANT,
+          "\u7EE7\u7EED\u547D\u4EE4\u4F1A\u8BDD\u9700\u8981\u7528\u6237\u6388\u6743",
+          "command"
+        );
+      }
+      if (parsed.chars !== void 0) manager.write(parsed.session_id, parsed.chars);
+      const result = await manager.poll(parsed.session_id, parsed.yield_time_ms, parsed.max_output_bytes);
+      return formatProcessResult(result);
+    }
+  };
+}
+
+// src/tools/index.ts
+import fs11 from "fs";
+import path10 from "path";
+function builtinTools(opts) {
+  const workdir = path10.resolve(opts.workdir);
+  fs11.mkdirSync(workdir, { recursive: true });
+  const sandbox = {
+    allowOutsideWorkdir: opts.allowOutsideWorkdir ?? false,
+    grants: opts.grants,
+    sessionId: opts.sessionId
+  };
+  const tools = [
+    makeListTool(workdir, sandbox),
+    makeReadTool(workdir, sandbox),
+    makeSearchTool(workdir, sandbox),
+    makeCreateTool(workdir, sandbox),
+    makeEditTool(workdir, sandbox),
+    makeWriteTool(workdir, sandbox),
+    makeApplyPatchTool(workdir, sandbox)
+  ];
+  const commandSandbox = { ...sandbox, commandExecutionEnabled: opts.enableCommandExecution ?? false };
+  const processes = new ProcessManager();
+  tools.push(
+    makeExecCommandTool(workdir, processes, commandSandbox),
+    makeWriteStdinTool(processes, commandSandbox)
+  );
+  return tools;
+}
+
+// src/server/config.ts
+import fs12 from "fs";
+import path11 from "path";
+import { z as z13 } from "zod";
+var endpointSchema = z13.object({
+  name: z13.string().min(1, "\u7AEF\u70B9\u540D\u4E0D\u80FD\u4E3A\u7A7A"),
+  protocol: z13.enum(["openai-responses", "anthropic-messages"]),
+  base_url: z13.string().min(1, "base_url \u4E0D\u80FD\u4E3A\u7A7A"),
+  api_key: z13.string().min(1, "api_key \u4E0D\u80FD\u4E3A\u7A7A\uFF08\u53EF\u7528 ${ENV_VAR} \u5F15\u7528\u73AF\u5883\u53D8\u91CF\uFF09"),
+  models: z13.record(z13.string(), z13.object({ context_window: z13.number().positive().optional() })).optional(),
+  default_model: z13.string().optional()
+});
+var appConfigSchema = z13.object({
+  endpoints: z13.array(endpointSchema).min(1, "endpoints \u4E3A\u7A7A\uFF1A\u81F3\u5C11\u914D\u7F6E\u4E00\u4E2A\u6A21\u578B\u7AEF\u70B9"),
+  server: z13.object({
+    port: z13.number().int().positive().optional(),
+    token: z13.string().optional()
+  }).optional(),
+  agent: z13.object({
+    workdir: z13.string().optional(),
+    agent_name: z13.string().optional(),
+    persona: z13.string().optional(),
+    /** 本机命令可访问当前用户权限范围内的系统资源，必须显式开启。 */
+    enable_command_execution: z13.boolean().optional()
+  }).optional()
+});
+function defaultConfigPath() {
+  return path11.join(defaultDataDir(), "config.json");
+}
+function loadConfig(configPath) {
+  const file = configPath ?? defaultConfigPath();
+  if (!fs12.existsSync(file)) {
+    throw new Error(
+      `\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${file}
+\u5148\u8FD0\u884C xlyra config init \u4EA4\u4E92\u5F0F\u521B\u5EFA\uFF0C\u6216\u53C2\u8003 README \u624B\u5DE5\u7F16\u5199\u3002`
+    );
+  }
+  let raw;
+  try {
+    raw = JSON.parse(fs12.readFileSync(file, "utf-8"));
+  } catch (err) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${file}\uFF08${err instanceof Error ? err.message : err}\uFF09`);
+  }
+  const parsed = appConfigSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".") || "(\u6839)"}\uFF1A${i.message}`).join("\n");
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6\u6821\u9A8C\u5931\u8D25\uFF1A${file}
+${issues}`);
+  }
+  for (const endpoint of parsed.data.endpoints) {
+    endpoint.api_key = interpolateEnv(endpoint.api_key, file);
+  }
+  return parsed.data;
+}
+function saveConfig(config, configPath) {
+  const file = configPath ?? defaultConfigPath();
+  fs12.mkdirSync(path11.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp`;
+  fs12.writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n");
+  fs12.renameSync(tmp, file);
+}
+function configExists(configPath) {
+  return fs12.existsSync(configPath ?? defaultConfigPath());
+}
+function upsertEndpoint(endpoint, configPath) {
+  const file = configPath ?? defaultConfigPath();
+  let config;
+  if (fs12.existsSync(file)) {
+    const raw = JSON.parse(fs12.readFileSync(file, "utf-8"));
+    config = appConfigSchema.parse({ ...raw, endpoints: raw.endpoints ?? [] });
+  } else {
+    config = { endpoints: [] };
+  }
+  const idx = config.endpoints.findIndex((e) => e.name === endpoint.name);
+  if (idx >= 0) {
+    config.endpoints[idx] = endpoint;
+  } else {
+    config.endpoints.push(endpoint);
+  }
+  const validated = appConfigSchema.parse(config);
+  saveConfig(validated, file);
+  return validated;
+}
+function removeEndpoint(name, configPath) {
+  const file = configPath ?? defaultConfigPath();
+  if (!fs12.existsSync(file)) return false;
+  const raw = JSON.parse(fs12.readFileSync(file, "utf-8"));
+  const endpoints = (raw.endpoints ?? []).filter((e) => e.name !== name);
+  if (endpoints.length === (raw.endpoints ?? []).length) return false;
+  if (endpoints.length === 0) {
+    throw new Error(`\u4E0D\u80FD\u5220\u9664\u6700\u540E\u4E00\u4E2A\u7AEF\u70B9\uFF08\u914D\u7F6E\u5FC5\u987B\u4FDD\u7559\u81F3\u5C11\u4E00\u4E2A\u6A21\u578B\u7AEF\u70B9\uFF09\uFF1A${file}`);
+  }
+  saveConfig({ ...raw, endpoints }, file);
+  return true;
+}
+function interpolateEnv(value, file) {
+  return value.replace(/\$\{([A-Z0-9_]+)\}/g, (whole, name) => {
+    const v = process.env[name];
+    if (v === void 0) {
+      throw new Error(`\u914D\u7F6E\u6587\u4EF6 ${file} \u5F15\u7528\u4E86\u672A\u8BBE\u7F6E\u7684\u73AF\u5883\u53D8\u91CF ${name}\uFF08\u6765\u81EA "${whole}"\uFF09`);
+    }
+    return v;
+  });
+}
+
+// src/server/run-registry.ts
+import crypto7 from "crypto";
+var DEFAULT_RETENTION_MS = 24 * 60 * 60 * 1e3;
+var RunRegistry = class {
+  retentionMs;
+  runs = /* @__PURE__ */ new Map();
+  latestBySession = /* @__PURE__ */ new Map();
+  closing = false;
+  constructor(opts = {}) {
+    this.retentionMs = opts.retentionMs ?? DEFAULT_RETENTION_MS;
+  }
+  /** 分配运行编号并把 runner 放入后台执行，立即返回编号 */
+  start(runner, params, opts) {
+    if (this.closing) throw new Error("\u8FD0\u884C\u6CE8\u518C\u8868\u6B63\u5728\u5173\u95ED\uFF0C\u65E0\u6CD5\u521B\u5EFA\u65B0\u8FD0\u884C");
+    this.pruneExpired();
+    const runId = crypto7.randomUUID().replaceAll("-", "").slice(0, 12);
+    const run = {
+      runId,
+      sessionId: opts.sessionId,
+      events: [],
+      terminal: false,
+      completedAt: null,
+      controller: new AbortController(),
+      waiters: /* @__PURE__ */ new Set(),
+      onTerminal: opts.onTerminal ?? null
+    };
+    this.runs.set(runId, run);
+    this.latestBySession.set(opts.sessionId, runId);
+    void this.execute(run, runner, params);
+    return runId;
+  }
+  /** 按公开会话编号读取当前（或最近一轮）事件 */
+  async getSessionEvents(sessionId, afterSequence, timeoutSeconds) {
+    return this.getEvents(this.sessionRun(sessionId).runId, afterSequence, timeoutSeconds);
+  }
+  /**
+   * 返回游标后的事件；暂无事件时等待通知，超时返回空列表供 SSE 发心跳。
+   * 调用方应先发送本批事件，再在 terminal=true 且批次已追平时关闭连接。
+   */
+  async getEvents(runId, afterSequence, timeoutSeconds) {
+    if (afterSequence < 0) throw new HttpError(400, "SSE \u4E8B\u4EF6\u6E38\u6807\u4E0D\u80FD\u4E3A\u8D1F\u6570");
+    const run = this.getRun(runId);
+    if (afterSequence > run.events.length) {
+      throw new HttpError(400, `SSE \u4E8B\u4EF6\u6E38\u6807 ${afterSequence} \u8D85\u51FA\u5F53\u524D\u4E8B\u4EF6\u8303\u56F4`);
+    }
+    if (afterSequence === run.events.length && !run.terminal && timeoutSeconds > 0) {
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          run.waiters.delete(wake);
+          resolve();
+        }, timeoutSeconds * 1e3);
+        const wake = () => {
+          clearTimeout(timer);
+          run.waiters.delete(wake);
+          resolve();
+        };
+        run.waiters.add(wake);
+      });
+    }
+    return { events: run.events.slice(afterSequence), terminal: run.terminal };
+  }
+  /**
+   * 幂等取消一次运行：**先落可回放的 agent_cancelled 终态事件，再 abort**。
+   * 顺序很重要：运行刚创建、事件循环尚未开始消费时，直接 abort 会让 runner
+   * 一次都不执行，订阅者会永久等待——先落终态事件保证任何情况下订阅者
+   * 都能看到收尾。
+   */
+  async cancel(runId) {
+    const run = this.getRun(runId);
+    if (run.terminal) return;
+    await this.publish(run, { type: "agent_cancelled", run_id: run.runId });
+    run.controller.abort();
+  }
+  async cancelSession(sessionId) {
+    await this.cancel(this.sessionRun(sessionId).runId);
+  }
+  /** 应用关闭时取消全部活动运行 */
+  async close() {
+    this.closing = true;
+    for (const run of this.runs.values()) {
+      if (!run.terminal) await this.cancel(run.runId);
+    }
+    this.runs.clear();
+    this.latestBySession.clear();
+  }
+  /** 消费 runner 事件并写入日志，兜住所有退出路径补齐终态 */
+  async execute(run, runner, params) {
+    try {
+      for await (const event of runner.start(params, {
+        runId: run.runId,
+        signal: run.controller.signal
+      })) {
+        await this.publish(run, event);
+      }
+      if (!run.terminal) {
+        await this.publish(run, {
+          type: "agent_error",
+          run_id: run.runId,
+          error: "Agent \u8FD0\u884C\u5F02\u5E38\u7ED3\u675F\uFF0C\u672A\u8FD4\u56DE\u7EC8\u6001\u4E8B\u4EF6"
+        });
+      }
+    } catch (err) {
+      if (!run.terminal) {
+        await this.publish(run, {
+          type: "agent_error",
+          run_id: run.runId,
+          error: `Agent \u8FD0\u884C\u53D1\u751F\u672A\u77E5\u9519\u8BEF\uFF1A${err instanceof Error ? err.message : err}`
+        });
+      }
+    }
+  }
+  /** 原子追加事件并广播唤醒；终态之后的迟到事件直接忽略 */
+  async publish(run, event) {
+    if (run.terminal) return;
+    run.events.push({ sequence: run.events.length + 1, event });
+    let becameTerminal = false;
+    if (TERMINAL_EVENT_TYPES.has(event.type)) {
+      run.terminal = true;
+      run.completedAt = Date.now();
+      becameTerminal = true;
+    }
+    for (const wake of [...run.waiters]) wake();
+    if (becameTerminal && run.onTerminal) {
+      try {
+        await run.onTerminal(event);
+      } catch (err) {
+        console.error(`Agent \u8FD0\u884C\u7EC8\u6001\u94A9\u5B50\u6267\u884C\u5931\u8D25 run=${run.runId}\uFF1A${err instanceof Error ? err.message : err}`);
+      }
+    }
+  }
+  getRun(runId) {
+    this.pruneExpired();
+    const run = this.runs.get(runId);
+    if (!run) throw new HttpError(404, "Agent \u8FD0\u884C\u4E0D\u5B58\u5728\u6216\u4E8B\u4EF6\u5386\u53F2\u5DF2\u8FC7\u671F");
+    return run;
+  }
+  sessionRun(sessionId) {
+    this.pruneExpired();
+    const runId = this.latestBySession.get(sessionId);
+    const run = runId ? this.runs.get(runId) : void 0;
+    if (!run) throw new HttpError(404, "\u4F1A\u8BDD\u6CA1\u6709\u53EF\u8DDF\u968F\u6216\u505C\u6B62\u7684\u8FD0\u884C");
+    return run;
+  }
+  /** 惰性清理超过保留期的终态运行；活动运行永不在这里删除 */
+  pruneExpired() {
+    const cutoff = Date.now() - this.retentionMs;
+    for (const [runId, run] of [...this.runs]) {
+      if (run.completedAt !== null && run.completedAt <= cutoff) {
+        this.runs.delete(runId);
+        if (this.latestBySession.get(run.sessionId) === runId) {
+          this.latestBySession.delete(run.sessionId);
+        }
+      }
+    }
+  }
+};
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "HttpError";
+  }
+  status;
+};
+
+// src/server/recorder.ts
+var HEARTBEAT_INTERVAL_MS = 1e4;
+var AgentRunRecorder = class {
+  store;
+  index;
+  sessionId;
+  /** 运行开始时会话已有的 entry 数；之后每次落盘递增，避免反复重读文件 */
+  entryCount;
+  heartbeatTimer = null;
+  /** begin 与 onTerminal 分别由路由层和后台任务并发调用：用同一根 Promise
+   *  链串行化，防「极速结束的运行被误标为永远运行中」的竞态 */
+  lifecycle = Promise.resolve();
+  terminated = false;
+  constructor(store, index, sessionId, entryCount) {
+    this.store = store;
+    this.index = index;
+    this.sessionId = sessionId;
+    this.entryCount = entryCount;
+  }
+  /** 运行启动：标记 running 并开启心跳。运行已先一步终态时跳过。 */
+  async begin(runId) {
+    this.lifecycle = this.lifecycle.then(() => {
+      if (this.terminated) return;
+      this.index.markRunning(this.sessionId, runId);
+      this.heartbeatTimer = setInterval(() => {
+        try {
+          this.index.heartbeat(this.sessionId);
+        } catch (err) {
+          console.warn(`\u4F1A\u8BDD\u5FC3\u8DF3\u5237\u65B0\u5931\u8D25 session=${this.sessionId}\uFF1A${err instanceof Error ? err.message : err}`);
+        }
+      }, HEARTBEAT_INTERVAL_MS);
+      this.heartbeatTimer.unref?.();
+    });
+    await this.lifecycle;
+  }
+  /** 落盘 user message，刷新标题（仅首条）与最后提示预览，返回 message id */
+  async recordUserMessage(text) {
+    const entry = this.store.append(this.sessionId, { role: "user", content: text });
+    this.entryCount += 1;
+    const preview = text.trim().slice(0, PREVIEW_MAX_CHARS);
+    this.index.touchAfterAppend(this.sessionId, {
+      leaf_uuid: entry.uuid,
+      entry_count: this.entryCount,
+      last_prompt: preview,
+      title: preview
+    });
+    return entry.uuid;
+  }
+  /** runner 定稿消息回调：assistant 带响应元数据，tool 结果不带 */
+  onMessage = async (message, response) => {
+    const entry = this.store.append(this.sessionId, message, {
+      ...response?.model ? { model: response.model } : {},
+      ...response?.usage ? { usage: response.usage } : {},
+      ...response?.finish_reason ? { finish_reason: response.finish_reason } : {}
+    });
+    this.entryCount += 1;
+    this.index.touchAfterAppend(this.sessionId, {
+      leaf_uuid: entry.uuid,
+      entry_count: this.entryCount
+    });
+  };
+  /** runner 压缩定稿回调：压缩行落盘并刷新索引（与 onMessage 同一节奏） */
+  onCompaction = async (result) => {
+    const entry = this.store.appendCompaction(this.sessionId, result);
+    this.entryCount += 1;
+    this.index.touchAfterAppend(this.sessionId, {
+      leaf_uuid: entry.uuid,
+      entry_count: this.entryCount
+    });
+  };
+  /** runner 提权请求回调：提权行落盘并刷新索引（回放时前端渲染确认卡片） */
+  onEscalation = async (info) => {
+    const entry = this.store.appendEscalation(this.sessionId, {
+      escalation_id: info.escalation_id,
+      requested_path: info.requested_path,
+      resolved_path: info.resolved_path,
+      tool_name: info.tool_name,
+      resource_type: info.resource_type,
+      requested_command: info.requested_command
+    });
+    this.entryCount += 1;
+    this.index.touchAfterAppend(this.sessionId, {
+      leaf_uuid: entry.uuid,
+      entry_count: this.entryCount
+    });
+  };
+  /** 运行终态收尾（done / error / cancelled 统一路径） */
+  onTerminal = async (_event) => {
+    this.lifecycle = this.lifecycle.then(() => {
+      this.terminated = true;
+      if (this.heartbeatTimer !== null) {
+        clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+      }
+      let sealed = 0;
+      try {
+        sealed = this.store.sealPendingToolCalls(this.sessionId);
+      } catch (err) {
+        console.warn(`\u4F1A\u8BDD\u4E2D\u65AD\u6536\u5C3E\u5931\u8D25 session=${this.sessionId}\uFF1A${err instanceof Error ? err.message : err}`);
+      }
+      if (sealed > 0) {
+        this.entryCount += sealed;
+        const { entries } = this.store.read(this.sessionId);
+        this.index.touchAfterAppend(this.sessionId, {
+          leaf_uuid: entries[entries.length - 1]?.uuid ?? "",
+          entry_count: this.entryCount
+        });
+      }
+      this.index.finishRun(this.sessionId);
+    });
+    await this.lifecycle;
+  };
+};
+
+// src/server/routes.ts
+import { Hono } from "hono";
+import { z as z14 } from "zod";
+function ok(data, message = "") {
+  return { success: true, code: 0, message, data };
+}
+function fail(status, message) {
+  throw new HttpError(status, message);
+}
+var startPayloadSchema = z14.object({
+  content: z14.string().min(1, "\u6D88\u606F\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A"),
+  session_id: z14.string().optional(),
+  model: z14.string().default("")
+});
+var retryPayloadSchema = z14.object({
+  message_id: z14.string().min(1),
+  content: z14.string().optional(),
+  model: z14.string().default("")
+});
+function createAgentRoutes(ctx) {
+  const app = new Hono();
+  app.onError((err, c) => {
+    if (err instanceof HttpError) {
+      return c.json({ success: false, code: err.status, message: err.message }, err.status);
+    }
+    console.error(`\u8BF7\u6C42\u5904\u7406\u5931\u8D25\uFF1A${err instanceof Error ? err.stack ?? err.message : err}`);
+    return c.json({ success: false, code: 500, message: "\u670D\u52A1\u5185\u90E8\u9519\u8BEF" }, 500);
+  });
+  if (ctx.token) {
+    app.use("*", async (c, next) => {
+      const header = c.req.header("authorization") ?? "";
+      if (header !== `Bearer ${ctx.token}`) {
+        return c.json({ success: false, code: 401, message: "\u672A\u6388\u6743\uFF1A\u7F3A\u5C11\u6216\u9519\u8BEF\u7684 Bearer token" }, 401);
+      }
+      await next();
+    });
+  }
+  const buildSystem = () => buildSystemPrompt({ agentName: ctx.agentName, persona: ctx.persona });
+  async function launchUserMessage(args) {
+    const recorder = new AgentRunRecorder(ctx.store, ctx.index, args.sessionId, args.entryCount);
+    const messageId = args.recordUser === false ? "" : await recorder.recordUserMessage(args.content);
+    const runner = new AgentRunner({
+      resolver: ctx.resolver,
+      tools: ctx.makeTools(args.sessionId),
+      onMessage: recorder.onMessage,
+      onCompaction: recorder.onCompaction,
+      onEscalation: recorder.onEscalation,
+      workdirHint: ctx.workdir
+    });
+    const runId = ctx.registry.start(
+      runner,
+      {
+        input: args.content,
+        include_input: args.recordUser !== false,
+        history: args.history,
+        model: args.model,
+        system_prompt: args.systemPrompt ?? buildSystem()
+      },
+      { sessionId: args.sessionId, onTerminal: recorder.onTerminal }
+    );
+    await recorder.begin(runId);
+    return { sessionId: args.sessionId, messageId };
+  }
+  app.post("/sessions", async (c) => {
+    const payload = startPayloadSchema.parse(await c.req.json());
+    ctx.resolver.resolve(payload.model);
+    let sessionId;
+    let history;
+    let entryCount;
+    if (payload.session_id) {
+      sessionId = payload.session_id;
+      if (!ctx.store.exists(sessionId)) fail(404, "\u4F1A\u8BDD\u4E0D\u5B58\u5728");
+      if (ctx.index.isRunning(sessionId)) {
+        fail(400, "\u8BE5\u4F1A\u8BDD\u5DF2\u6709\u6B63\u5728\u8FDB\u884C\u7684\u8FD0\u884C\uFF0C\u8BF7\u5148\u505C\u6B62\u6216\u7B49\u5F85\u5B8C\u6210");
+      }
+      history = ctx.store.buildHistory(sessionId);
+      entryCount = ctx.store.read(sessionId).entries.length;
+    } else {
+      const header = ctx.store.create();
+      sessionId = header.session_id;
+      ctx.index.create(sessionId);
+      history = [];
+      entryCount = 0;
+    }
+    const { messageId } = await launchUserMessage({
+      sessionId,
+      content: payload.content,
+      model: payload.model,
+      history,
+      entryCount
+    });
+    return c.json(ok({ session_id: sessionId, message_id: messageId }, "\u7528\u6237\u6D88\u606F\u5DF2\u63D0\u4EA4"), 202);
+  });
+  app.get("/sessions", (c) => {
+    const limit = Math.min(Number(c.req.query("limit") ?? 50), 200);
+    const offset = Math.max(Number(c.req.query("offset") ?? 0), 0);
+    const list = ctx.index.list(limit, offset).map((meta) => ({
+      ...meta,
+      running: ctx.index.isRunning(meta.session_id)
+    }));
+    return c.json(ok(list));
+  });
+  app.get("/sessions/:id/transcript", (c) => {
+    const sessionId = c.req.param("id");
+    if (!ctx.store.exists(sessionId)) fail(404, "\u4F1A\u8BDD\u4E0D\u5B58\u5728");
+    const { entries } = ctx.store.read(sessionId);
+    return c.json(
+      ok({
+        session: ctx.index.get(sessionId) ?? null,
+        entries: entries.map(
+          (e) => isCompactionEntry(e) ? {
+            type: "compaction",
+            compaction_id: e.uuid,
+            parent_id: e.parent_uuid,
+            timestamp: e.timestamp,
+            summary: e.summary,
+            replacement_history: e.replacement_history,
+            tokens_before: e.tokens_before,
+            tokens_after: e.tokens_after
+          } : isEscalationEntry(e) ? {
+            type: "escalation",
+            escalation_id: e.uuid,
+            parent_id: e.parent_uuid,
+            timestamp: e.timestamp,
+            requested_path: e.requested_path,
+            resolved_path: e.resolved_path,
+            tool_name: e.tool_name,
+            resource_type: e.resource_type,
+            requested_command: e.requested_command,
+            workdir: ctx.workdir,
+            granted: e.granted
+          } : {
+            type: "message",
+            message_id: e.uuid,
+            parent_id: e.parent_uuid,
+            timestamp: e.timestamp,
+            message: e.message,
+            model: e.model,
+            usage: e.usage,
+            finish_reason: e.finish_reason
+          }
+        )
+      })
+    );
+  });
+  app.patch("/sessions/:id", async (c) => {
+    const sessionId = c.req.param("id");
+    const { title } = z14.object({ title: z14.string().min(1) }).parse(await c.req.json());
+    if (!ctx.store.exists(sessionId)) fail(404, "\u4F1A\u8BDD\u4E0D\u5B58\u5728");
+    ctx.index.rename(sessionId, title);
+    return c.json(ok(ctx.index.get(sessionId), "\u4F1A\u8BDD\u5DF2\u91CD\u547D\u540D"));
+  });
+  app.post("/sessions/:id/compact-context", async (c) => {
+    const sessionId = c.req.param("id");
+    if (!ctx.store.exists(sessionId)) fail(404, "\u4F1A\u8BDD\u4E0D\u5B58\u5728");
+    if (ctx.index.isRunning(sessionId)) fail(400, "\u8BE5\u4F1A\u8BDD\u6B63\u5728\u8FD0\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5F85\u5B8C\u6210\u540E\u518D\u538B\u7F29");
+    const history = ctx.store.buildHistory(sessionId);
+    if (history.length === 0) fail(400, "\u4F1A\u8BDD\u6CA1\u6709\u53EF\u538B\u7F29\u7684\u5185\u5BB9");
+    const { entries } = ctx.store.read(sessionId);
+    const lastModel = [...entries].reverse().find((e) => isMessageEntry(e) && e.model);
+    const modelRef = lastModel && isMessageEntry(lastModel) && lastModel.model || "";
+    const resolved = ctx.resolver.resolve(modelRef);
+    const result = await compact(
+      resolved.protocol,
+      resolved.modelId,
+      [{ role: "system", content: buildSystem() }, ...history],
+      {}
+    );
+    if (!result) fail(502, "\u538B\u7F29\u5931\u8D25\uFF1A\u6A21\u578B\u672A\u80FD\u751F\u6210\u6458\u8981\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+    const entry = ctx.store.appendCompaction(sessionId, result);
+    ctx.index.touchAfterAppend(sessionId, {
+      leaf_uuid: entry.uuid,
+      entry_count: entries.length + 1
+    });
+    return c.json(
+      ok(
+        {
+          summary: result.summary,
+          tokens_before: result.tokens_before,
+          tokens_after: result.tokens_after,
+          compaction_id: entry.uuid
+        },
+        "\u4F1A\u8BDD\u4E0A\u4E0B\u6587\u5DF2\u538B\u7F29"
+      )
+    );
+  });
+  app.post("/sessions/:id/retry", async (c) => {
+    const sessionId = c.req.param("id");
+    const payload = retryPayloadSchema.parse(await c.req.json());
+    if (!ctx.store.exists(sessionId)) fail(404, "\u4F1A\u8BDD\u4E0D\u5B58\u5728");
+    if (ctx.index.isRunning(sessionId)) fail(400, "\u8BE5\u4F1A\u8BDD\u6B63\u5728\u8FD0\u884C\u4E2D\uFF0C\u8BF7\u5148\u505C\u6B62\u8FD0\u884C\u518D\u91CD\u8BD5");
+    const { entries } = ctx.store.read(sessionId);
+    const target = entries.find((e) => e.uuid === payload.message_id);
+    if (!target) fail(404, "\u4F1A\u8BDD\u4E2D\u6CA1\u6709\u8FD9\u6761\u8BB0\u5F55\uFF0C\u53EF\u80FD\u5DF2\u88AB\u6539\u5199");
+    if (!isMessageEntry(target) || target.message.role !== "user") {
+      fail(400, "\u53EA\u80FD\u91CD\u8BD5\u7528\u6237\u6D88\u606F");
+    }
+    const content = payload.content ?? (target.message.content ?? "");
+    ctx.resolver.resolve(payload.model);
+    ctx.store.discardFromUserMessage(sessionId, payload.message_id);
+    const history = ctx.store.buildHistory(sessionId);
+    const remaining = ctx.store.read(sessionId).entries.length;
+    const { messageId } = await launchUserMessage({
+      sessionId,
+      content,
+      model: payload.model,
+      history,
+      entryCount: remaining
+    });
+    return c.json(ok({ session_id: sessionId, message_id: messageId }, "\u5DF2\u91CD\u65B0\u63D0\u4EA4"), 202);
+  });
+  app.post("/sessions/:id/grant-access", async (c) => {
+    const sessionId = c.req.param("id");
+    const { escalation_id, granted, resolved_path } = z14.object({
+      escalation_id: z14.string().min(1),
+      granted: z14.boolean(),
+      resolved_path: z14.string().min(1)
+    }).parse(await c.req.json());
+    if (!ctx.store.exists(sessionId)) fail(404, "\u4F1A\u8BDD\u4E0D\u5B58\u5728");
+    if (ctx.index.isRunning(sessionId)) fail(400, "\u8BE5\u4F1A\u8BDD\u6B63\u5728\u8FD0\u884C\u4E2D");
+    const { entries } = ctx.store.read(sessionId);
+    const esc = entries.find(
+      (e) => e.type === "escalation" && e.uuid === escalation_id
+    );
+    if (!esc || esc.type !== "escalation") fail(404, "\u63D0\u6743\u8BF7\u6C42\u4E0D\u5B58\u5728\u6216\u5DF2\u8FC7\u671F");
+    if (esc.resolved_path !== resolved_path) fail(400, "\u6388\u6743\u8DEF\u5F84\u4E0E\u63D0\u6743\u8BF7\u6C42\u4E0D\u4E00\u81F4");
+    if (esc.granted !== null && esc.granted !== void 0) fail(400, "\u8BE5\u63D0\u6743\u8BF7\u6C42\u5DF2\u5904\u7406\u8FC7");
+    ctx.store.resolveEscalation(sessionId, escalation_id, granted);
+    if (!granted) {
+      return c.json(ok({ granted: false }, "\u5DF2\u62D2\u7EDD\u6388\u6743"));
+    }
+    if (esc.resource_type === "command") {
+      ctx.grants.grantCapability(sessionId, resolved_path);
+    } else {
+      ctx.grants.grant(sessionId, resolved_path);
+    }
+    const lastUser = [...entries].reverse().find(
+      (e) => isMessageEntry(e) && e.message.role === "user"
+    );
+    if (!lastUser || !isMessageEntry(lastUser)) fail(400, "\u4F1A\u8BDD\u4E2D\u6CA1\u6709\u53EF\u7EED\u8DD1\u7684\u7528\u6237\u6D88\u606F");
+    ctx.resolver.resolve("");
+    const history = ctx.store.buildHistoryBeforeEscalation(sessionId, escalation_id);
+    const { messageId } = await launchUserMessage({
+      sessionId,
+      content: "",
+      model: "",
+      history,
+      entryCount: entries.length,
+      recordUser: false
+    });
+    return c.json(
+      ok({ session_id: sessionId, message_id: messageId, granted_path: resolved_path }, "\u5DF2\u6388\u6743\u5E76\u7EE7\u7EED\u6267\u884C"),
+      202
+    );
+  });
+  app.delete("/sessions/:id", (c) => {
+    const sessionId = c.req.param("id");
+    if (!ctx.store.exists(sessionId)) fail(404, "\u4F1A\u8BDD\u4E0D\u5B58\u5728");
+    if (ctx.index.isRunning(sessionId)) fail(400, "\u8BE5\u4F1A\u8BDD\u6B63\u5728\u8FD0\u884C\u4E2D\uFF0C\u8BF7\u5148\u505C\u6B62\u8FD0\u884C\u518D\u5220\u9664");
+    ctx.store.delete(sessionId);
+    ctx.index.remove(sessionId);
+    ctx.grants.drop(sessionId);
+    return c.json(ok({}, "\u4F1A\u8BDD\u5DF2\u5220\u9664"));
+  });
+  app.get("/sessions/:id/events", async (c) => {
+    const sessionId = c.req.param("id");
+    const cursor = Number(c.req.header("last-event-id") ?? 0);
+    const initial = await ctx.registry.getSessionEvents(sessionId, cursor, 0);
+    const stream = new ReadableStream({
+      async start(controller) {
+        const encoder = new TextEncoder();
+        let current = cursor;
+        let { events, terminal } = initial;
+        try {
+          for (; ; ) {
+            for (const stored of events) {
+              current = stored.sequence;
+              const { run_id: _omit, ...payload } = stored.event;
+              controller.enqueue(
+                encoder.encode(
+                  `id: ${stored.sequence}
+event: ${stored.event.type}
+data: ${JSON.stringify(payload)}
+
+`
+                )
+              );
+            }
+            if (terminal) return;
+            ({ events, terminal } = await ctx.registry.getSessionEvents(sessionId, current, 15));
+            if (events.length === 0 && !terminal) {
+              controller.enqueue(encoder.encode(": heartbeat\n\n"));
+            }
+          }
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive",
+        "x-accel-buffering": "no"
+      }
+    });
+  });
+  app.post("/sessions/:id/stop", async (c) => {
+    await ctx.registry.cancelSession(c.req.param("id"));
+    return c.json(ok({}, "\u5DF2\u8BF7\u6C42\u505C\u6B62\u4F1A\u8BDD"));
+  });
+  app.get("/health", (c) => c.json(ok({ status: "ok" })));
+  return app;
+}
+
+// src/server/session-index.ts
+import fs13 from "fs";
+import path12 from "path";
+var HEARTBEAT_TIMEOUT_MS = 3e4;
+var SessionIndex = class {
+  file;
+  metas = /* @__PURE__ */ new Map();
+  constructor(indexFile) {
+    this.file = indexFile;
+    this.load();
+  }
+  /** 启动时加载；文件不存在/损坏则从空开始（rebuild 会补齐） */
+  load() {
+    try {
+      const raw = JSON.parse(fs13.readFileSync(this.file, "utf-8"));
+      for (const meta of raw.sessions ?? []) this.metas.set(meta.session_id, meta);
+    } catch {
+      this.metas.clear();
+    }
+  }
+  /** 从事实源整体重建（启动自愈）：扫描结果单向覆盖索引 */
+  rebuild(summaries) {
+    for (const s of summaries) {
+      const existing = this.metas.get(s.session_id);
+      this.metas.set(s.session_id, {
+        session_id: s.session_id,
+        created_at: s.created_at,
+        // 已有人工标题时保留（文件里不存标题，扫描回填的是首条 user 消息）
+        title: existing?.title ?? s.title,
+        last_prompt: s.last_prompt,
+        entry_count: s.entry_count,
+        leaf_uuid: s.leaf_uuid,
+        last_active: s.last_timestamp,
+        running: null
+        // 进程刚启动，任何「运行中」都是上一世的残留
+      });
+    }
+    this.persist();
+  }
+  create(sessionId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.metas.set(sessionId, {
+      session_id: sessionId,
+      created_at: now,
+      title: null,
+      last_prompt: null,
+      entry_count: 0,
+      leaf_uuid: null,
+      last_active: now,
+      running: null
+    });
+    this.persist();
+  }
+  get(sessionId) {
+    return this.metas.get(sessionId);
+  }
+  /** 每次追加 entry 后刷新链尾/计数/预览；title 仅在传入时更新（首条消息） */
+  touchAfterAppend(sessionId, update) {
+    const meta = this.metas.get(sessionId);
+    if (!meta) return;
+    meta.leaf_uuid = update.leaf_uuid;
+    meta.entry_count = update.entry_count;
+    meta.last_active = (/* @__PURE__ */ new Date()).toISOString();
+    if (update.last_prompt !== void 0) {
+      meta.last_prompt = update.last_prompt.slice(0, PREVIEW_MAX_CHARS);
+    }
+    if (update.title !== void 0 && meta.title === null) {
+      meta.title = update.title.slice(0, PREVIEW_MAX_CHARS);
+    }
+    this.persist();
+  }
+  rename(sessionId, title) {
+    const meta = this.metas.get(sessionId);
+    if (!meta) return false;
+    meta.title = title.slice(0, PREVIEW_MAX_CHARS);
+    this.persist();
+    return true;
+  }
+  markRunning(sessionId, runId) {
+    const meta = this.metas.get(sessionId);
+    if (!meta) return;
+    meta.running = { run_id: runId, last_heartbeat: Date.now() };
+    this.persist();
+  }
+  heartbeat(sessionId) {
+    const meta = this.metas.get(sessionId);
+    if (!meta?.running) return;
+    meta.running.last_heartbeat = Date.now();
+    this.persist();
+  }
+  finishRun(sessionId) {
+    const meta = this.metas.get(sessionId);
+    if (!meta) return;
+    meta.running = null;
+    this.persist();
+  }
+  /** 是否有正在进行的消息处理：运行标记存在且心跳未超时 */
+  isRunning(sessionId) {
+    const running = this.metas.get(sessionId)?.running;
+    if (!running) return false;
+    return Date.now() - running.last_heartbeat < HEARTBEAT_TIMEOUT_MS;
+  }
+  /** 按最后活跃时间倒序分页 */
+  list(limit, offset) {
+    return [...this.metas.values()].sort((a, b) => b.last_active.localeCompare(a.last_active)).slice(offset, offset + limit);
+  }
+  remove(sessionId) {
+    this.metas.delete(sessionId);
+    this.persist();
+  }
+  persist() {
+    const dir = path12.dirname(this.file);
+    fs13.mkdirSync(dir, { recursive: true });
+    const tmp = `${this.file}.tmp`;
+    fs13.writeFileSync(tmp, JSON.stringify({ sessions: [...this.metas.values()] }, null, 2));
+    fs13.renameSync(tmp, this.file);
+  }
+};
+
+// src/server/index.ts
+import path13 from "path";
+import { serve } from "@hono/node-server";
+
+// src/server/config-routes.ts
+import { Hono as Hono2 } from "hono";
+import { z as z15 } from "zod";
+function maskApiKey(key) {
+  if (key.includes("${")) return key;
+  if (key.length <= 8) return "****";
+  return `${key.slice(0, 4)}\u2026${key.slice(-4)}`;
+}
+function maskedConfig(config) {
+  return {
+    ...config,
+    endpoints: config.endpoints.map((e) => ({ ...e, api_key: maskApiKey(e.api_key) }))
+  };
+}
+var putPayloadSchema = z15.object({
+  endpoints: z15.array(
+    z15.object({
+      name: z15.string().min(1),
+      protocol: z15.enum(["openai-responses", "anthropic-messages"]),
+      base_url: z15.string().min(1),
+      api_key: z15.string().min(1),
+      models: z15.record(z15.string(), z15.object({ context_window: z15.number().positive().optional() })).optional(),
+      default_model: z15.string().optional()
+    })
+  ).min(1, "endpoints \u4E3A\u7A7A\uFF1A\u81F3\u5C11\u914D\u7F6E\u4E00\u4E2A\u6A21\u578B\u7AEF\u70B9"),
+  server: z15.object({ port: z15.number().int().positive().optional(), token: z15.string().optional() }).optional(),
+  agent: z15.object({
+    workdir: z15.string().optional(),
+    agent_name: z15.string().optional(),
+    persona: z15.string().optional(),
+    enable_command_execution: z15.boolean().optional()
+  }).optional()
+});
+function createConfigRoutes(ctx) {
+  const app = new Hono2();
+  app.onError((err, c) => {
+    if (err instanceof HttpError) {
+      return c.json({ success: false, code: err.status, message: err.message }, err.status);
+    }
+    console.error(`\u914D\u7F6E\u63A5\u53E3\u5904\u7406\u5931\u8D25\uFF1A${err instanceof Error ? err.message : err}`);
+    return c.json({ success: false, code: 500, message: err instanceof Error ? err.message : "\u670D\u52A1\u5185\u90E8\u9519\u8BEF" }, 500);
+  });
+  app.get("/config", (c) => {
+    const config = loadConfig(ctx.configPath);
+    return c.json({ success: true, code: 0, message: "", data: maskedConfig(config) });
+  });
+  app.put("/config", async (c) => {
+    const payload = putPayloadSchema.parse(await c.req.json());
+    const current = loadConfig(ctx.configPath);
+    const endpoints = payload.endpoints.map((incoming) => {
+      const existing = current.endpoints.find((e) => e.name === incoming.name);
+      if (existing && incoming.api_key === maskApiKey(existing.api_key)) {
+        return { ...incoming, api_key: existing.api_key };
+      }
+      return incoming;
+    });
+    const next = {
+      endpoints,
+      ...payload.server ? { server: payload.server } : {},
+      ...payload.agent ? { agent: payload.agent } : {}
+    };
+    saveConfig(next, ctx.configPath);
+    return c.json({ success: true, code: 0, message: "\u914D\u7F6E\u5DF2\u4FDD\u5B58\uFF08\u90E8\u5206\u542F\u52A8\u671F\u88C5\u914D\u9879\u9700\u91CD\u542F\u670D\u52A1\u540E\u751F\u6548\uFF09", data: maskedConfig(next) });
+  });
+  app.post("/config/test", async (c) => {
+    const { name } = z15.object({ name: z15.string().min(1) }).parse(await c.req.json());
+    const config = loadConfig(ctx.configPath);
+    const endpoint = config.endpoints.find((e) => e.name === name);
+    if (!endpoint) throw new HttpError(404, `\u7AEF\u70B9\u4E0D\u5B58\u5728\uFF1A${name}`);
+    const model = endpoint.default_model ?? Object.keys(endpoint.models ?? {})[0];
+    if (!model) throw new HttpError(400, `\u7AEF\u70B9 ${name} \u672A\u914D\u7F6E default_model \u6216 models\uFF0C\u65E0\u6CD5\u6D4B\u8BD5`);
+    const protocol = endpoint.protocol === "anthropic-messages" ? new AnthropicMessagesProtocol({ baseUrl: endpoint.base_url, apiKey: endpoint.api_key, providerName: endpoint.name }) : new OpenAIResponsesProtocol({ baseUrl: endpoint.base_url, apiKey: endpoint.api_key, providerName: endpoint.name });
+    const started = Date.now();
+    for await (const event of protocol.chatStream({
+      model,
+      messages: [{ role: "user", content: "ping" }],
+      settings: { max_tokens: endpoint.protocol === "anthropic-messages" ? 16 : 16 }
+    })) {
+      if (event.type === "error") {
+        return c.json({ success: false, code: 502, message: `\u8FDE\u901A\u6027\u6D4B\u8BD5\u5931\u8D25\uFF1A${event.error}`, data: null }, 502);
+      }
+      if (event.type === "done") {
+        return c.json({
+          success: true,
+          code: 0,
+          message: `\u7AEF\u70B9 ${name} \u8FDE\u901A\u6B63\u5E38\uFF08${Date.now() - started}ms\uFF09`,
+          data: { elapsed_ms: Date.now() - started, model: event.response.model || model }
+        });
+      }
+    }
+    return c.json({ success: false, code: 502, message: "\u8FDE\u901A\u6027\u6D4B\u8BD5\u5931\u8D25\uFF1A\u6D41\u5F02\u5E38\u7EC8\u6B62", data: null }, 502);
+  });
+  return app;
+}
+
+// src/server/index.ts
+function createAgentServer(config, opts = {}) {
+  const dataDir = path13.resolve(opts.dataDir ?? defaultDataDir());
+  const configPath = opts.configPath ?? path13.join(dataDir, "config.json");
+  const resolver = new EndpointResolver(config.endpoints);
+  const store = new AgentSessionStore(path13.join(dataDir, "sessions"));
+  const index = new SessionIndex(path13.join(dataDir, "index.json"));
+  index.rebuild(store.scanAll());
+  const registry = new RunRegistry();
+  const workdir = path13.resolve(config.agent?.workdir ?? path13.join(dataDir, "workspace"));
+  const grants = new EscalationGrants();
+  const app = createAgentRoutes({
+    resolver,
+    store,
+    index,
+    registry,
+    grants,
+    makeTools: (sessionId) => builtinTools({
+      workdir,
+      grants,
+      sessionId,
+      enableCommandExecution: config.agent?.enable_command_execution ?? false
+    }),
+    workdir,
+    ...config.agent?.agent_name ? { agentName: config.agent.agent_name } : {},
+    ...config.agent?.persona ? { persona: config.agent.persona } : {},
+    ...config.server?.token ? { token: config.server.token } : {}
+  });
+  const configRoutes = createConfigRoutes({ configPath });
+  if (config.server?.token) {
+    configRoutes.use("*", async (c, next) => {
+      const header = c.req.header("authorization") ?? "";
+      if (header !== `Bearer ${config.server.token}`) {
+        return c.json({ success: false, code: 401, message: "\u672A\u6388\u6743\uFF1A\u7F3A\u5C11\u6216\u9519\u8BEF\u7684 Bearer token" }, 401);
+      }
+      await next();
+    });
+  }
+  app.route("/", configRoutes);
+  return { app, registry, store, index };
+}
+function serveFromConfig(opts) {
+  const configPath = opts.configPath ?? path13.join(defaultDataDir(), "config.json");
+  const config = loadConfig(configPath);
+  const { app } = createAgentServer(config, { configPath });
+  const port = opts.port ?? config.server?.port ?? 3210;
+  serve({ fetch: app.fetch, port }, (info) => {
+    console.log(`xlyra-agent \u670D\u52A1\u5DF2\u542F\u52A8\uFF1Ahttp://127.0.0.1:${info.port}`);
+    console.log(`\u6570\u636E\u76EE\u5F55\uFF1A${defaultDataDir()}\uFF08sessions/ \u4F1A\u8BDD\u8F6C\u5F55\uFF0Cworkspace/ \u5DE5\u5177\u5DE5\u4F5C\u533A\uFF09`);
+    if (!config.server?.token) {
+      console.warn("\u26A0 \u672A\u914D\u7F6E server.token\uFF0C\u63A5\u53E3\u65E0\u9274\u6743\u2014\u2014\u8BF7\u52FF\u66B4\u9732\u5230\u516C\u7F51");
+    }
+  });
+}
+
+export {
+  toolCallSchema,
+  chatMessageSchema,
+  messageText,
+  tokenUsageSchema,
+  emptyUsage,
+  addUsage,
+  modelSettingsSchema,
+  responseToMessage,
+  LlmError,
+  parseSse,
+  ToolCallBuffer,
+  AnthropicMessagesProtocol,
+  OpenAIResponsesProtocol,
+  builtinContextWindow,
+  EndpointResolver,
+  validateToolCall,
+  agentStartParamsSchema,
+  agentToolResultSchema,
+  agentCompactionSchema,
+  agentEscalationSchema,
+  agentDoneSchema,
+  agentEventSchema,
+  TERMINAL_EVENT_TYPES,
+  SUMMARY_PREFIX,
+  COMPACT_PROMPT,
+  buildAvailableToolsPrompt,
+  buildSystemPrompt,
+  COMPACT_TRIGGER_RATIO,
+  RETAINED_USER_TOKEN_BUDGET,
+  APPROX_BYTES_PER_TOKEN,
+  estimateTokens,
+  shouldCompact,
+  isSummaryMessage,
+  buildReplacementHistory,
+  compact,
+  SESSION_FORMAT_VERSION,
+  PREVIEW_MAX_CHARS,
+  defaultDataDir,
+  defaultSessionsDir,
+  isMessageEntry,
+  isCompactionEntry,
+  isEscalationEntry,
+  AgentSessionStore,
+  AgentRunner,
+  resolveSandboxed,
+  makeApplyPatchTool,
+  makeCreateTool,
+  makeEditTool,
+  ProcessManager,
+  makeExecCommandTool,
+  formatProcessResult,
+  makeListTool,
+  makeReadTool,
+  makeSearchTool,
+  makeWriteTool,
+  makeWriteStdinTool,
+  builtinTools,
+  defaultConfigPath,
+  loadConfig,
+  saveConfig,
+  configExists,
+  upsertEndpoint,
+  removeEndpoint,
+  RunRegistry,
+  HttpError,
+  AgentRunRecorder,
+  createAgentRoutes,
+  SessionIndex,
+  createAgentServer,
+  serveFromConfig
+};
+//# sourceMappingURL=chunk-QH6SEOO6.js.map