@yachiyo-5i/xlyra-agent 1.0.2 → 1.1.1

package/dist/{chunk-QH6SEOO6.js → chunk-3DOSX63Z.js}

@@ -58,6 +58,176 @@ var LlmError = class extends Error {
   }
 };
 
+// src/llm/credential.ts
+var StaticCredentialProvider = class {
+  constructor(credential) {
+    this.credential = credential;
+  }
+  credential;
+  getCredential() {
+    return Promise.resolve(this.credential);
+  }
+};
+var XlyraCallbackCredentialProvider = class {
+  constructor(url, opts) {
+    this.url = url;
+    this.fetchImpl = opts?.fetchImpl ?? fetch;
+  }
+  url;
+  context = null;
+  /** runId → 当前有效 token */
+  tokensByRun = /* @__PURE__ */ new Map();
+  /** runId → 进行中的 callback（并发去重） */
+  inflight = /* @__PURE__ */ new Map();
+  fetchImpl;
+  /** 更新当前 run 上下文。token 按 runId 隔离，切换 run 不影响其他 run 的 token */
+  setRunContext(context) {
+    this.context = context;
+  }
+  async getCredential() {
+    const context = this.requireContext();
+    const cached = this.tokensByRun.get(context.runId);
+    if (cached) return cached;
+    const refreshed = await this.refreshCredential("initial");
+    if (!refreshed) {
+      throw new LlmError("xLyra LLM \u8C03\u7528\u51ED\u8BC1\u4E0D\u53EF\u7528\uFF1Arun \u5DF2\u7ED3\u675F\u6216 callback \u672A\u7B7E\u53D1 token");
+    }
+    return refreshed;
+  }
+  /**
+   * 按 run 取凭证（并发安全）：chatStream 在请求开始时调用一次并全程使用
+   * 返回值——并发 run 各自的 token 互不干扰（setRunContext 只影响下一次
+   * 请求开始时的解析）。
+   */
+  async getCredentialFor(runId) {
+    const cached = this.tokensByRun.get(runId);
+    if (cached) return cached;
+    const refreshed = await this.refreshCredentialFor(runId, "initial");
+    if (!refreshed) {
+      throw new LlmError("xLyra LLM \u8C03\u7528\u51ED\u8BC1\u4E0D\u53EF\u7528\uFF1Arun \u5DF2\u7ED3\u675F\u6216 callback \u672A\u7B7E\u53D1 token");
+    }
+    return refreshed;
+  }
+  /** 按 run 刷新（401 重试用）：与 getCredentialFor 相同的并发去重 */
+  refreshCredentialFor(runId, reason) {
+    const context = this.requireContext();
+    if (context.runId !== runId) return Promise.resolve(null);
+    return this.refreshCredential(reason);
+  }
+  /**
+   * 调用 xLyra credential callback 取新 token（并发去重：同一 run 的并发
+   * 调用合并为一次 in-flight 请求）。
+   * 返回 null：run inactive（active: false）或 callback 失败——调用方不得重试。
+   * token 不进入任何日志/错误信息。
+   */
+  refreshCredential(reason) {
+    const context = this.requireContext();
+    const pending = this.inflight.get(context.runId);
+    if (pending) return pending;
+    const task = this.doRefresh(context, reason).finally(() => {
+      this.inflight.delete(context.runId);
+    });
+    this.inflight.set(context.runId, task);
+    return task;
+  }
+  requireContext() {
+    if (!this.context) {
+      throw new LlmError("xLyra LLM \u51ED\u8BC1\u7F3A\u5C11 run \u4E0A\u4E0B\u6587\uFF08agent_instance_id/session_id/run_id\uFF09");
+    }
+    return this.context;
+  }
+  async doRefresh(context, reason) {
+    let res;
+    try {
+      res = await this.fetchImpl(this.url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          agent_instance_id: context.agentInstanceId,
+          session_id: context.sessionId,
+          run_id: context.runId,
+          model: context.model,
+          reason
+        })
+      });
+    } catch {
+      return null;
+    }
+    if (!res.ok) return null;
+    let payload;
+    try {
+      payload = await res.json();
+    } catch {
+      return null;
+    }
+    if (payload.active !== true || typeof payload.token !== "string" || !payload.token) {
+      return null;
+    }
+    const credential = {
+      kind: "temporary-bearer",
+      headerName: "authorization",
+      headerValue: `Bearer ${payload.token}`
+    };
+    this.tokensByRun.set(context.runId, credential);
+    if (this.tokensByRun.size > 64) {
+      const oldest = this.tokensByRun.keys().next().value;
+      if (oldest !== void 0) this.tokensByRun.delete(oldest);
+    }
+    return credential;
+  }
+};
+function resolveCredentialProvider(endpoint) {
+  if (endpoint.mode === "remote-xlyra") {
+    if (endpoint.credential?.type === "xlyra-callback") {
+      return new XlyraCallbackCredentialProvider(endpoint.credential.url);
+    }
+    const token = endpoint.credential?.token;
+    if (!token) throw new LlmError(`\u7AEF\u70B9 ${endpoint.name} \u672A\u914D\u7F6E\u4E34\u65F6 LLM \u51ED\u8BC1`);
+    return new StaticCredentialProvider({
+      kind: "temporary-bearer",
+      headerName: "authorization",
+      headerValue: `Bearer ${token}`
+    });
+  }
+  if (!endpoint.api_key) {
+    throw new LlmError(`\u7AEF\u70B9 ${endpoint.name} \u672A\u914D\u7F6E api_key`);
+  }
+  return new StaticCredentialProvider(
+    endpoint.protocol === "anthropic-messages" ? { kind: "api-key", headerName: "x-api-key", headerValue: endpoint.api_key } : {
+      kind: "api-key",
+      headerName: "authorization",
+      headerValue: `Bearer ${endpoint.api_key}`
+    }
+  );
+}
+function isRefreshable(provider) {
+  return provider instanceof XlyraCallbackCredentialProvider;
+}
+
+// src/llm/http-error.ts
+async function httpErrorSummary(res, secrets = []) {
+  const raw = await res.text().catch(() => "");
+  let msg = "";
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      const j = parsed;
+      const candidate = j.error?.message ?? j.message;
+      if (typeof candidate === "string") msg = candidate;
+    }
+  } catch {
+  }
+  msg = msg.slice(0, 200);
+  for (const secret of secrets) {
+    if (secret) msg = msg.split(secret).join("***");
+  }
+  return `\u8BF7\u6C42\u5931\u8D25\uFF08HTTP ${res.status}\uFF09\uFF1A${msg || res.statusText}`;
+}
+function credentialSecrets(cred) {
+  const bare = cred.headerValue.startsWith("Bearer ") ? cred.headerValue.slice("Bearer ".length) : cred.headerValue;
+  return bare === cred.headerValue ? [cred.headerValue] : [cred.headerValue, bare];
+}
+
 // src/llm/sse.ts
 async function* parseSse(body) {
   const reader = body.getReader();
@@ -200,17 +370,50 @@ function toAnthropicTools(tools) {
 var AnthropicMessagesProtocol = class {
   name = "anthropic-messages";
   baseUrl;
-  apiKey;
+  credential;
   provider;
   apiVersion;
   fetchImpl;
+  runContext = null;
   constructor(opts) {
     this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
-    this.apiKey = opts.apiKey;
+    if (opts.credential) {
+      this.credential = opts.credential;
+    } else if (opts.apiKey) {
+      this.credential = new StaticCredentialProvider({
+        kind: "api-key",
+        headerName: "x-api-key",
+        headerValue: opts.apiKey
+      });
+    } else {
+      throw new LlmError("AnthropicMessagesProtocol \u7F3A\u5C11\u51ED\u8BC1\uFF08credential \u6216 apiKey\uFF09");
+    }
     this.provider = opts.providerName ?? "anthropic";
     this.apiVersion = opts.apiVersion ?? "2023-06-01";
     this.fetchImpl = opts.fetchImpl ?? fetch;
   }
+  /** 更新 run 上下文：仅 xlyra-callback 凭证消费；静态凭证为 no-op */
+  setRunContext(context) {
+    this.runContext = context;
+    if (isRefreshable(this.credential)) this.credential.setRunContext(context);
+  }
+  /**
+   * 请求开始时解析本次 run 的凭证：xlyra-callback 按 runId 定向取
+   * （并发 run 各自独立），静态凭证直接返回。
+   */
+  resolveRequestCredential() {
+    if (isRefreshable(this.credential) && this.runContext) {
+      return this.credential.getCredentialFor(this.runContext.runId);
+    }
+    return this.credential.getCredential();
+  }
+  /** 401 后按本次 run 定向刷新（run 上下文缺失时无法刷新） */
+  refreshRequestCredential() {
+    if (isRefreshable(this.credential) && this.runContext) {
+      return this.credential.refreshCredentialFor(this.runContext.runId, "unauthorized");
+    }
+    return Promise.resolve(null);
+  }
   async *chatStream(req) {
     const { system, messages } = toAnthropicMessages(req.messages);
     const maxTokens = req.settings.max_tokens ?? DEFAULT_MAX_TOKENS;
@@ -222,29 +425,59 @@ var AnthropicMessagesProtocol = class {
       const budget = Math.min(THINKING_BUDGET[req.settings.reasoning_effort], maxTokens - 1);
       if (budget >= 1024) body.thinking = { type: "enabled", budget_tokens: budget };
     }
+    let cred;
+    try {
+      cred = await this.resolveRequestCredential();
+    } catch (err) {
+      yield { type: "error", error: errMsg(err) };
+      return;
+    }
+    const doFetch = (c) => this.fetchImpl(`${this.baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        [c.headerName]: c.headerValue,
+        "anthropic-version": this.apiVersion
+      },
+      body: JSON.stringify(body),
+      signal: req.signal ?? null
+    });
     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
-      });
+      res = await doFetch(cred);
     } 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.status === 401 && isRefreshable(this.credential)) {
+      await res.body?.cancel().catch(() => {
+      });
+      let refreshed = null;
+      try {
+        refreshed = await this.refreshRequestCredential();
+      } catch (err) {
+        yield { type: "error", error: errMsg(err) };
+        return;
+      }
+      if (!refreshed) {
+        yield {
+          type: "error",
+          error: "xLyra LLM \u8C03\u7528\u51ED\u8BC1\u5DF2\u8FC7\u671F\uFF0C\u4E14 xLyra \u672A\u7B7E\u53D1\u65B0 token\uFF08run \u5DF2\u7ED3\u675F\u6216\u4E0D\u53EF\u7528\uFF09\uFF08HTTP 401\uFF09"
+        };
+        return;
+      }
+      cred = refreshed;
+      try {
+        res = await doFetch(cred);
+      } 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}`
-      };
+      yield { type: "error", error: await httpErrorSummary(res, credentialSecrets(cred)) };
       return;
     }
     const blockKinds = /* @__PURE__ */ new Map();
@@ -438,15 +671,48 @@ function responseFromCompleted(response, provider) {
 var OpenAIResponsesProtocol = class {
   name = "openai-responses";
   baseUrl;
-  apiKey;
+  credential;
   provider;
   fetchImpl;
+  runContext = null;
   constructor(opts) {
     this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
-    this.apiKey = opts.apiKey;
+    if (opts.credential) {
+      this.credential = opts.credential;
+    } else if (opts.apiKey) {
+      this.credential = new StaticCredentialProvider({
+        kind: "api-key",
+        headerName: "authorization",
+        headerValue: `Bearer ${opts.apiKey}`
+      });
+    } else {
+      throw new LlmError("OpenAIResponsesProtocol \u7F3A\u5C11\u51ED\u8BC1\uFF08credential \u6216 apiKey\uFF09");
+    }
     this.provider = opts.providerName ?? "openai";
     this.fetchImpl = opts.fetchImpl ?? fetch;
   }
+  /** 更新 run 上下文：仅 xlyra-callback 凭证消费；静态凭证为 no-op */
+  setRunContext(context) {
+    this.runContext = context;
+    if (isRefreshable(this.credential)) this.credential.setRunContext(context);
+  }
+  /**
+   * 请求开始时解析本次 run 的凭证：xlyra-callback 按 runId 定向取
+   * （并发 run 各自独立），静态凭证直接返回。
+   */
+  resolveRequestCredential() {
+    if (isRefreshable(this.credential) && this.runContext) {
+      return this.credential.getCredentialFor(this.runContext.runId);
+    }
+    return this.credential.getCredential();
+  }
+  /** 401 后按本次 run 定向刷新（run 上下文缺失时无法刷新） */
+  refreshRequestCredential() {
+    if (isRefreshable(this.credential) && this.runContext) {
+      return this.credential.refreshCredentialFor(this.runContext.runId, "unauthorized");
+    }
+    return Promise.resolve(null);
+  }
   async *chatStream(req) {
     const { instructions, input } = toResponsesInput(req.messages);
     const body = { model: req.model, input, stream: true };
@@ -458,28 +724,58 @@ var OpenAIResponsesProtocol = class {
       body.reasoning = { effort: req.settings.reasoning_effort, summary: "auto" };
       body.include = ["reasoning.encrypted_content"];
     }
+    let cred;
+    try {
+      cred = await this.resolveRequestCredential();
+    } catch (err) {
+      yield { type: "error", error: errMsg2(err) };
+      return;
+    }
+    const doFetch = (c) => this.fetchImpl(`${this.baseUrl}/responses`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        [c.headerName]: c.headerValue
+      },
+      body: JSON.stringify(body),
+      signal: req.signal ?? null
+    });
     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
-      });
+      res = await doFetch(cred);
     } 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.status === 401 && isRefreshable(this.credential)) {
+      await res.body?.cancel().catch(() => {
+      });
+      let refreshed = null;
+      try {
+        refreshed = await this.refreshRequestCredential();
+      } catch (err) {
+        yield { type: "error", error: errMsg2(err) };
+        return;
+      }
+      if (!refreshed) {
+        yield {
+          type: "error",
+          error: "xLyra LLM \u8C03\u7528\u51ED\u8BC1\u5DF2\u8FC7\u671F\uFF0C\u4E14 xLyra \u672A\u7B7E\u53D1\u65B0 token\uFF08run \u5DF2\u7ED3\u675F\u6216\u4E0D\u53EF\u7528\uFF09\uFF08HTTP 401\uFF09"
+        };
+        return;
+      }
+      cred = refreshed;
+      try {
+        res = await doFetch(cred);
+      } 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}`
-      };
+      yield { type: "error", error: await httpErrorSummary(res, credentialSecrets(cred)) };
       return;
     }
     const calls = new ToolCallBuffer();
@@ -635,7 +931,7 @@ var EndpointResolver = class {
     if (!protocol) {
       const opts = {
         baseUrl: endpoint.base_url,
-        apiKey: endpoint.api_key,
+        credential: resolveCredentialProvider(endpoint),
         providerName: endpoint.name
       };
       protocol = endpoint.protocol === "anthropic-messages" ? new AnthropicMessagesProtocol(opts) : new OpenAIResponsesProtocol(opts);
@@ -1325,6 +1621,7 @@ ${tail}`;
 }
 
 // src/agent/escalation.ts
+import path2 from "path";
 var COMMAND_EXECUTION_GRANT = "capability://exec_command";
 var EscalationRequiredError = class extends Error {
   constructor(requestedPath, resolvedPath, message, resourceType = "path", requestedCommand) {
@@ -1358,7 +1655,8 @@ var EscalationGrants = class {
     const set = this.grants.get(sessionId);
     if (!set) return false;
     for (const prefix of set) {
-      if (resolvedPath === prefix || resolvedPath.startsWith(prefix + "/")) return true;
+      const relative = path2.relative(prefix, resolvedPath);
+      if (relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative)) return true;
     }
     return false;
   }
@@ -1430,6 +1728,14 @@ var AgentRunner = class {
     if (!contextWindow) {
       this.logger.info(`\u6A21\u578B\u672A\u58F0\u660E\u4E0A\u4E0B\u6587\u7A97\u53E3\uFF0C\u81EA\u52A8\u538B\u7F29\u505C\u7528 model=${modelId}`);
     }
+    if (runOpts.sessionId) {
+      protocol.setRunContext?.({
+        agentInstanceId: runOpts.agentInstanceId ?? "default",
+        sessionId: runOpts.sessionId,
+        runId,
+        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);
@@ -1686,22 +1992,22 @@ ${availableToolsPrompt}` : buildSystemPrompt({ availableTools: definitions.map((
 
 // src/tools/workdir.ts
 import fs2 from "fs";
-import path2 from "path";
+import path3 from "path";
 function resolveSandboxed(workdir, raw, opts = {}) {
   const baseReal = fs2.realpathSync(workdir);
-  const candidate = path2.resolve(path2.isAbsolute(raw) ? raw : path2.join(baseReal, raw));
+  const candidate = path3.resolve(path3.isAbsolute(raw) ? raw : path3.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);
+    missing.unshift(path3.basename(existing));
+    const parent = path3.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)) {
+  const realTarget = path3.join(existingReal, ...missing);
+  if (realTarget !== baseReal && !realTarget.startsWith(baseReal + path3.sep)) {
     if (opts.grants && opts.sessionId && opts.grants.isGranted(opts.sessionId, realTarget)) {
       return realTarget;
     }
@@ -1713,7 +2019,7 @@ function resolveSandboxed(workdir, raw, opts = {}) {
 // src/tools/apply-patch.ts
 import crypto3 from "crypto";
 import fs3 from "fs";
-import path3 from "path";
+import path4 from "path";
 import { z as z4 } from "zod";
 var argsSchema = z4.object({ patch: z4.string().min(1) });
 function makeApplyPatchTool(workdir, sandbox = {}) {
@@ -1761,7 +2067,7 @@ function makeApplyPatchTool(workdir, sandbox = {}) {
           } else {
             installedAdds.push(item.file);
           }
-          fs3.mkdirSync(path3.dirname(item.file), { recursive: true });
+          fs3.mkdirSync(path4.dirname(item.file), { recursive: true });
           fs3.renameSync(item.tmp, item.file);
         }
         for (const deletion of deletes) {
@@ -1872,18 +2178,18 @@ function assertRegularFile(rawPath, file) {
   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.mkdirSync(path4.dirname(write.file), { recursive: true });
+  const tmp = path4.join(path4.dirname(write.file), `.xlyra-tmp-${crypto3.randomUUID()}${path4.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)}`);
+  return path4.join(path4.dirname(file), `.xlyra-backup-${crypto3.randomUUID()}${path4.extname(file)}`);
 }
 
 // src/tools/create.ts
 import fs4 from "fs";
-import path4 from "path";
+import path5 from "path";
 import { z as z5 } from "zod";
 var argsSchema2 = z5.object({
   path: z5.string(),
@@ -1900,7 +2206,7 @@ function makeCreateTool(workdir, sandbox = {}) {
     handler: async (args) => {
       const { path: rawPath, content } = argsSchema2.parse(args);
       const file = resolveSandboxed(workdir, rawPath, sandbox);
-      fs4.mkdirSync(path4.dirname(file), { recursive: true });
+      fs4.mkdirSync(path5.dirname(file), { recursive: true });
       try {
         fs4.writeFileSync(file, content, { flag: "wx" });
       } catch (err) {
@@ -1917,7 +2223,7 @@ function makeCreateTool(workdir, sandbox = {}) {
 // src/tools/edit.ts
 import crypto4 from "crypto";
 import fs5 from "fs";
-import path5 from "path";
+import path6 from "path";
 import { z as z6 } from "zod";
 var argsSchema3 = z6.object({
   path: z6.string(),
@@ -1964,7 +2270,7 @@ function countMatches(text, needle) {
   }
 }
 function atomicReplace(file, content) {
-  const tmp = path5.join(path5.dirname(file), `.xlyra-tmp-${crypto4.randomUUID()}${path5.extname(file)}`);
+  const tmp = path6.join(path6.dirname(file), `.xlyra-tmp-${crypto4.randomUUID()}${path6.extname(file)}`);
   try {
     fs5.writeFileSync(tmp, content);
     fs5.renameSync(tmp, file);
@@ -2170,7 +2476,7 @@ ${result.output}`);
 
 // src/tools/list.ts
 import fs7 from "fs";
-import path6 from "path";
+import path7 from "path";
 import { z as z8 } from "zod";
 var MAX_ENTRIES = 500;
 var IGNORE_NAMES = /* @__PURE__ */ new Set([
@@ -2224,8 +2530,8 @@ function makeListTool(workdir, sandbox = {}) {
         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 full = path7.join(current, entry.name);
+          const rel = path7.relative(dir, full);
           const display = entry.isDirectory() ? `${rel}/` : rel;
           if (!matcher || matcher.test(display)) {
             if (results.length < MAX_ENTRIES) results.push(display);
@@ -2257,14 +2563,14 @@ function countRemaining(dir, recursive) {
   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);
+    if (recursive && entry.isDirectory()) count += countRemaining(path7.join(dir, entry.name), true);
   }
   return count;
 }
 
 // src/tools/read.ts
 import fs8 from "fs";
-import path7 from "path";
+import path8 from "path";
 import { z as z9 } from "zod";
 var MAX_LINES = 2e3;
 var MAX_BYTES = 5e4;
@@ -2289,7 +2595,7 @@ function makeReadTool(workdir, sandbox = {}) {
       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())) {
+      if (IMAGE_SUFFIXES.has(path8.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");
@@ -2319,7 +2625,7 @@ function makeReadTool(workdir, sandbox = {}) {
 
 // src/tools/search.ts
 import fs9 from "fs";
-import path8 from "path";
+import path9 from "path";
 import { z as z10 } from "zod";
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
 var HARD_MAX_RESULTS = 500;
@@ -2369,13 +2675,13 @@ function makeSearchTool(workdir, sandbox = {}) {
         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));
+            visit(path9.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("/");
+        const relative = path9.relative(workdir, entryPath) || path9.basename(entryPath);
+        const portable = relative.split(path9.sep).join("/");
         if (matcher && !matcher.test(portable)) return;
         if (stat.size > MAX_FILE_BYTES || isBinary(entryPath)) return;
         let text;
@@ -2439,7 +2745,7 @@ function globToRegExp2(glob) {
 
 // src/tools/write.ts
 import fs10 from "fs";
-import path9 from "path";
+import path10 from "path";
 import crypto6 from "crypto";
 import { z as z11 } from "zod";
 var argsSchema8 = z11.object({
@@ -2463,9 +2769,9 @@ function makeWriteTool(workdir, sandbox = {}) {
       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)}`
+      const tmp = path10.join(
+        path10.dirname(file),
+        `.xlyra-tmp-${crypto6.randomUUID()}${path10.extname(file)}`
       );
       try {
         fs10.writeFileSync(tmp, content);
@@ -2515,9 +2821,9 @@ function makeWriteStdinTool(manager, sandbox = {}) {
 
 // src/tools/index.ts
 import fs11 from "fs";
-import path10 from "path";
+import path11 from "path";
 function builtinTools(opts) {
-  const workdir = path10.resolve(opts.workdir);
+  const workdir = path11.resolve(opts.workdir);
   fs11.mkdirSync(workdir, { recursive: true });
   const sandbox = {
     allowOutsideWorkdir: opts.allowOutsideWorkdir ?? false,
@@ -2544,15 +2850,59 @@ function builtinTools(opts) {
 
 // src/server/config.ts
 import fs12 from "fs";
-import path11 from "path";
+import path12 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"),
+  /** 省略时按 direct 处理（兼容旧配置） */
+  mode: z13.enum(["direct", "remote-xlyra"]).default("direct"),
+  base_url: z13.url("base_url \u5FC5\u987B\u662F\u5408\u6CD5 URL"),
+  api_key: z13.string().min(1, "api_key \u4E0D\u80FD\u4E3A\u7A7A\uFF08\u53EF\u7528 ${ENV_VAR} \u5F15\u7528\u73AF\u5883\u53D8\u91CF\uFF09").optional(),
+  credential: z13.discriminatedUnion("type", [
+    z13.object({
+      type: z13.literal("temporary-bearer"),
+      token: z13.string().min(1, "credential.token \u4E0D\u80FD\u4E3A\u7A7A\uFF08\u53EF\u7528 ${ENV_VAR} \u5F15\u7528\u73AF\u5883\u53D8\u91CF\uFF09")
+    }),
+    z13.object({
+      type: z13.literal("xlyra-callback"),
+      url: z13.url("credential.url \u5FC5\u987B\u662F\u5408\u6CD5 URL")
+    })
+  ]).optional(),
   models: z13.record(z13.string(), z13.object({ context_window: z13.number().positive().optional() })).optional(),
   default_model: z13.string().optional()
+}).superRefine((endpoint, ctx) => {
+  if (endpoint.mode === "remote-xlyra") {
+    if (!endpoint.credential) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["credential"],
+        message: "remote-xlyra \u6A21\u5F0F\u5FC5\u987B\u914D\u7F6E\u4E34\u65F6\u51ED\u8BC1\uFF08temporary-bearer \u6216 xlyra-callback\uFF09"
+      });
+    }
+    if (endpoint.api_key !== void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["api_key"],
+        message: "remote-xlyra \u6A21\u5F0F\u4E0D\u5141\u8BB8\u914D\u7F6E api_key"
+      });
+    }
+    return;
+  }
+  if (!endpoint.api_key) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["api_key"],
+      message: "direct \u6A21\u5F0F\u5FC5\u987B\u914D\u7F6E api_key"
+    });
+  }
+  if (endpoint.credential !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["credential"],
+      message: "direct \u6A21\u5F0F\u4E0D\u5141\u8BB8\u914D\u7F6E credential"
+    });
+  }
 });
 var appConfigSchema = z13.object({
   endpoints: z13.array(endpointSchema).min(1, "endpoints \u4E3A\u7A7A\uFF1A\u81F3\u5C11\u914D\u7F6E\u4E00\u4E2A\u6A21\u578B\u7AEF\u70B9"),
@@ -2564,12 +2914,14 @@ var appConfigSchema = z13.object({
     workdir: z13.string().optional(),
     agent_name: z13.string().optional(),
     persona: z13.string().optional(),
+    /** 部署方注入的 agent 实例标识（xlyra-callback 凭证用），run 启动参数可覆盖 */
+    agent_instance_id: z13.string().optional(),
     /** 本机命令可访问当前用户权限范围内的系统资源，必须显式开启。 */
     enable_command_execution: z13.boolean().optional()
   }).optional()
 });
 function defaultConfigPath() {
-  return path11.join(defaultDataDir(), "config.json");
+  return path12.join(defaultDataDir(), "config.json");
 }
 function loadConfig(configPath) {
   const file = configPath ?? defaultConfigPath();
@@ -2592,16 +2944,23 @@ function loadConfig(configPath) {
 ${issues}`);
   }
   for (const endpoint of parsed.data.endpoints) {
-    endpoint.api_key = interpolateEnv(endpoint.api_key, file);
+    if (endpoint.api_key !== void 0) {
+      endpoint.api_key = interpolateEnv(endpoint.api_key, file);
+    }
+    if (endpoint.credential?.type === "temporary-bearer") {
+      endpoint.credential.token = interpolateEnv(endpoint.credential.token, file);
+    }
   }
   return parsed.data;
 }
 function saveConfig(config, configPath) {
   const file = configPath ?? defaultConfigPath();
-  fs12.mkdirSync(path11.dirname(file), { recursive: true });
+  const validated = appConfigSchema.parse(config);
+  fs12.mkdirSync(path12.dirname(file), { recursive: true, mode: 448 });
   const tmp = `${file}.tmp`;
-  fs12.writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n");
+  fs12.writeFileSync(tmp, JSON.stringify(validated, null, 2) + "\n", { mode: 384 });
   fs12.renameSync(tmp, file);
+  fs12.chmodSync(file, 384);
 }
 function configExists(configPath) {
   return fs12.existsSync(configPath ?? defaultConfigPath());
@@ -2616,10 +2975,11 @@ function upsertEndpoint(endpoint, configPath) {
     config = { endpoints: [] };
   }
   const idx = config.endpoints.findIndex((e) => e.name === endpoint.name);
+  const parsedEndpoint = endpointSchema.parse(endpoint);
   if (idx >= 0) {
-    config.endpoints[idx] = endpoint;
+    config.endpoints[idx] = parsedEndpoint;
   } else {
-    config.endpoints.push(endpoint);
+    config.endpoints.push(parsedEndpoint);
   }
   const validated = appConfigSchema.parse(config);
   saveConfig(validated, file);
@@ -2675,7 +3035,7 @@ var RunRegistry = class {
     };
     this.runs.set(runId, run);
     this.latestBySession.set(opts.sessionId, runId);
-    void this.execute(run, runner, params);
+    void this.execute(run, runner, params, opts.agentInstanceId);
     return runId;
   }
   /** 按公开会话编号读取当前（或最近一轮）事件 */
@@ -2733,11 +3093,13 @@ var RunRegistry = class {
     this.latestBySession.clear();
   }
   /** 消费 runner 事件并写入日志，兜住所有退出路径补齐终态 */
-  async execute(run, runner, params) {
+  async execute(run, runner, params, agentInstanceId) {
     try {
       for await (const event of runner.start(params, {
         runId: run.runId,
-        signal: run.controller.signal
+        signal: run.controller.signal,
+        sessionId: run.sessionId,
+        ...agentInstanceId ? { agentInstanceId } : {}
       })) {
         await this.publish(run, event);
       }
@@ -2938,12 +3300,15 @@ function fail(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("")
+  model: z14.string().default(""),
+  /** 部署方注入的 agent 实例标识（xlyra-callback 凭证用），缺省用服务级配置 */
+  agent_instance_id: z14.string().optional()
 });
 var retryPayloadSchema = z14.object({
   message_id: z14.string().min(1),
   content: z14.string().optional(),
-  model: z14.string().default("")
+  model: z14.string().default(""),
+  agent_instance_id: z14.string().optional()
 });
 function createAgentRoutes(ctx) {
   const app = new Hono();
@@ -2984,10 +3349,14 @@ function createAgentRoutes(ctx) {
         model: args.model,
         system_prompt: args.systemPrompt ?? buildSystem()
       },
-      { sessionId: args.sessionId, onTerminal: recorder.onTerminal }
+      {
+        sessionId: args.sessionId,
+        onTerminal: recorder.onTerminal,
+        ...args.agentInstanceId ?? ctx.agentInstanceId ? { agentInstanceId: args.agentInstanceId ?? ctx.agentInstanceId } : {}
+      }
     );
     await recorder.begin(runId);
-    return { sessionId: args.sessionId, messageId };
+    return { sessionId: args.sessionId, messageId, runId };
   }
   app.post("/sessions", async (c) => {
     const payload = startPayloadSchema.parse(await c.req.json());
@@ -3010,14 +3379,15 @@ function createAgentRoutes(ctx) {
       history = [];
       entryCount = 0;
     }
-    const { messageId } = await launchUserMessage({
+    const { messageId, runId } = await launchUserMessage({
       sessionId,
       content: payload.content,
       model: payload.model,
       history,
-      entryCount
+      entryCount,
+      ...payload.agent_instance_id ? { agentInstanceId: payload.agent_instance_id } : {}
     });
-    return c.json(ok({ session_id: sessionId, message_id: messageId }, "\u7528\u6237\u6D88\u606F\u5DF2\u63D0\u4EA4"), 202);
+    return c.json(ok({ session_id: sessionId, message_id: messageId, run_id: runId }, "\u7528\u6237\u6D88\u606F\u5DF2\u63D0\u4EA4"), 202);
   });
   app.get("/sessions", (c) => {
     const limit = Math.min(Number(c.req.query("limit") ?? 50), 200);
@@ -3128,14 +3498,15 @@ function createAgentRoutes(ctx) {
     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({
+    const { messageId, runId } = await launchUserMessage({
       sessionId,
       content,
       model: payload.model,
       history,
-      entryCount: remaining
+      entryCount: remaining,
+      ...payload.agent_instance_id ? { agentInstanceId: payload.agent_instance_id } : {}
     });
-    return c.json(ok({ session_id: sessionId, message_id: messageId }, "\u5DF2\u91CD\u65B0\u63D0\u4EA4"), 202);
+    return c.json(ok({ session_id: sessionId, message_id: messageId, run_id: runId }, "\u5DF2\u91CD\u65B0\u63D0\u4EA4"), 202);
   });
   app.post("/sessions/:id/grant-access", async (c) => {
     const sessionId = c.req.param("id");
@@ -3168,7 +3539,7 @@ function createAgentRoutes(ctx) {
     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({
+    const { messageId, runId } = await launchUserMessage({
       sessionId,
       content: "",
       model: "",
@@ -3177,7 +3548,7 @@ function createAgentRoutes(ctx) {
       recordUser: false
     });
     return c.json(
-      ok({ session_id: sessionId, message_id: messageId, granted_path: resolved_path }, "\u5DF2\u6388\u6743\u5E76\u7EE7\u7EED\u6267\u884C"),
+      ok({ session_id: sessionId, message_id: messageId, run_id: runId, granted_path: resolved_path }, "\u5DF2\u6388\u6743\u5E76\u7EE7\u7EED\u6267\u884C"),
       202
     );
   });
@@ -3244,7 +3615,7 @@ data: ${JSON.stringify(payload)}
 
 // src/server/session-index.ts
 import fs13 from "fs";
-import path12 from "path";
+import path13 from "path";
 var HEARTBEAT_TIMEOUT_MS = 3e4;
 var SessionIndex = class {
   file;
@@ -3353,7 +3724,7 @@ var SessionIndex = class {
     this.persist();
   }
   persist() {
-    const dir = path12.dirname(this.file);
+    const dir = path13.dirname(this.file);
     fs13.mkdirSync(dir, { recursive: true });
     const tmp = `${this.file}.tmp`;
     fs13.writeFileSync(tmp, JSON.stringify({ sessions: [...this.metas.values()] }, null, 2));
@@ -3362,42 +3733,71 @@ var SessionIndex = class {
 };
 
 // src/server/index.ts
-import path13 from "path";
+import path14 from "path";
 import { serve } from "@hono/node-server";
 
 // src/server/config-routes.ts
 import { Hono as Hono2 } from "hono";
+import fs14 from "fs";
 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 maskCredential(credential) {
+  if (credential.type === "temporary-bearer") {
+    return { type: credential.type, token: maskApiKey(credential.token) };
+  }
+  return { type: credential.type, url: credential.url, configured: true };
+}
 function maskedConfig(config) {
   return {
     ...config,
-    endpoints: config.endpoints.map((e) => ({ ...e, api_key: maskApiKey(e.api_key) }))
+    endpoints: config.endpoints.map((e) => ({
+      ...e,
+      ...e.api_key !== void 0 ? { api_key: maskApiKey(e.api_key) } : {},
+      ...e.credential ? { credential: maskCredential(e.credential) } : {}
+    }))
   };
 }
+function retainSecret(incoming, existingRaw, existingResolved) {
+  if (incoming === void 0 || existingRaw === void 0) return incoming;
+  if (incoming === existingRaw) return existingRaw;
+  if (existingResolved !== void 0 && incoming === maskApiKey(existingResolved)) return existingRaw;
+  return incoming;
+}
+function retainCredential(incoming, existingRaw, existingResolved) {
+  const prevRaw = existingRaw?.credential;
+  const prevResolved = existingResolved?.credential;
+  if (!incoming || !prevRaw) return incoming;
+  if (prevRaw.type === "temporary-bearer" && incoming.type === "temporary-bearer") {
+    const resolvedToken = prevResolved?.type === "temporary-bearer" ? prevResolved.token : void 0;
+    const token = retainSecret(incoming.token, prevRaw.token, resolvedToken);
+    return token === void 0 ? incoming : { type: "temporary-bearer", token };
+  }
+  if (prevRaw.type === "xlyra-callback" && incoming.type === "xlyra-callback" && incoming.url === prevRaw.url) {
+    return prevRaw;
+  }
+  return incoming;
+}
 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"),
+  endpoints: z15.array(endpointSchema).min(1, "endpoints \u4E3A\u7A7A\uFF1A\u81F3\u5C11\u914D\u7F6E\u4E00\u4E2A\u6A21\u578B\u7AEF\u70B9"),
+  /** 显式确认修改 remote-xlyra 端点的 base_url/callback 地址（SSRF 防护闸） */
+  allow_remote_endpoint_override: z15.boolean().optional(),
   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(),
+    agent_instance_id: z15.string().optional(),
     enable_command_execution: z15.boolean().optional()
   }).optional()
 });
+function loadRawConfig(configPath) {
+  const raw = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
+  return appConfigSchema.parse(raw);
+}
 function createConfigRoutes(ctx) {
   const app = new Hono2();
   app.onError((err, c) => {
@@ -3413,19 +3813,34 @@ function createConfigRoutes(ctx) {
   });
   app.put("/config", async (c) => {
     const payload = putPayloadSchema.parse(await c.req.json());
-    const current = loadConfig(ctx.configPath);
+    const current = loadRawConfig(ctx.configPath);
+    const resolved = 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 };
+      const existingRaw = current.endpoints.find((e) => e.name === incoming.name);
+      const existingResolved = resolved.endpoints.find((e) => e.name === incoming.name);
+      const apiKey = retainSecret(incoming.api_key, existingRaw?.api_key, existingResolved?.api_key);
+      const credential = retainCredential(incoming.credential, existingRaw, existingResolved);
+      const merged = { ...incoming, credential };
+      if (apiKey !== void 0) merged.api_key = apiKey;
+      else delete merged.api_key;
+      if (incoming.mode === "remote-xlyra" && existingRaw?.mode === "remote-xlyra") {
+        const callbackUrlChanged = incoming.credential?.type === "xlyra-callback" && existingRaw.credential?.type === "xlyra-callback" && incoming.credential.url !== existingRaw.credential.url;
+        if (incoming.base_url !== existingRaw.base_url || callbackUrlChanged) {
+          if (payload.allow_remote_endpoint_override !== true) {
+            throw new HttpError(
+              400,
+              `\u7AEF\u70B9 ${incoming.name} \u662F remote-xlyra \u6A21\u5F0F\uFF0Cbase_url/callback \u5730\u5740\u53EA\u80FD\u7531 runner \u6216\u53D7\u4FE1\u4EFB\u7BA1\u7406\u63A5\u53E3\u4FEE\u6539\uFF08PUT \u9700\u5E26 allow_remote_endpoint_override: true \u663E\u5F0F\u786E\u8BA4\uFF09`
+            );
+          }
+        }
       }
-      return incoming;
+      return merged;
     });
-    const next = {
+    const next = appConfigSchema.parse({
       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) });
   });
@@ -3434,9 +3849,13 @@ function createConfigRoutes(ctx) {
     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}`);
+    if (endpoint.mode === "remote-xlyra" && endpoint.credential?.type === "xlyra-callback") {
+      throw new HttpError(400, `\u7AEF\u70B9 ${name} \u4F7F\u7528 xlyra-callback \u51ED\u8BC1\uFF0C\u9700\u5728 run \u4E0A\u4E0B\u6587\u4E2D\u6D4B\u8BD5\uFF08\u6B64\u5904\u65E0\u6D3B\u52A8 run\uFF09`);
+    }
     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 credential = resolveCredentialProvider(endpoint);
+    const protocol = endpoint.protocol === "anthropic-messages" ? new AnthropicMessagesProtocol({ baseUrl: endpoint.base_url, credential, providerName: endpoint.name }) : new OpenAIResponsesProtocol({ baseUrl: endpoint.base_url, credential, providerName: endpoint.name });
     const started = Date.now();
     for await (const event of protocol.chatStream({
       model,
@@ -3462,14 +3881,14 @@ function createConfigRoutes(ctx) {
 
 // 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 dataDir = path14.resolve(opts.dataDir ?? defaultDataDir());
+  const configPath = opts.configPath ?? path14.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"));
+  const store = new AgentSessionStore(path14.join(dataDir, "sessions"));
+  const index = new SessionIndex(path14.join(dataDir, "index.json"));
   index.rebuild(store.scanAll());
   const registry = new RunRegistry();
-  const workdir = path13.resolve(config.agent?.workdir ?? path13.join(dataDir, "workspace"));
+  const workdir = path14.resolve(config.agent?.workdir ?? path14.join(dataDir, "workspace"));
   const grants = new EscalationGrants();
   const app = createAgentRoutes({
     resolver,
@@ -3486,6 +3905,7 @@ function createAgentServer(config, opts = {}) {
     workdir,
     ...config.agent?.agent_name ? { agentName: config.agent.agent_name } : {},
     ...config.agent?.persona ? { persona: config.agent.persona } : {},
+    ...config.agent?.agent_instance_id ? { agentInstanceId: config.agent.agent_instance_id } : {},
     ...config.server?.token ? { token: config.server.token } : {}
   });
   const configRoutes = createConfigRoutes({ configPath });
@@ -3502,7 +3922,7 @@ function createAgentServer(config, opts = {}) {
   return { app, registry, store, index };
 }
 function serveFromConfig(opts) {
-  const configPath = opts.configPath ?? path13.join(defaultDataDir(), "config.json");
+  const configPath = opts.configPath ?? path14.join(defaultDataDir(), "config.json");
   const config = loadConfig(configPath);
   const { app } = createAgentServer(config, { configPath });
   const port = opts.port ?? config.server?.port ?? 3210;
@@ -3525,6 +3945,12 @@ export {
   modelSettingsSchema,
   responseToMessage,
   LlmError,
+  StaticCredentialProvider,
+  XlyraCallbackCredentialProvider,
+  resolveCredentialProvider,
+  isRefreshable,
+  httpErrorSummary,
+  credentialSecrets,
   parseSse,
   ToolCallBuffer,
   AnthropicMessagesProtocol,
@@ -3587,4 +4013,4 @@ export {
   createAgentServer,
   serveFromConfig
 };
-//# sourceMappingURL=chunk-QH6SEOO6.js.map
+//# sourceMappingURL=chunk-3DOSX63Z.js.map