hiwork-core 0.0.24 → 0.0.30

package/lib/index.js

@@ -3137,7 +3137,7 @@ function isUnloading(ctx) {
 }
 
 // src/version.ts
-var PKG_VERSION = false ? "dev" : "0.0.24";
+var PKG_VERSION = false ? "dev" : "0.0.30";
 
 // src/ai-router-client.ts
 var AUTH_AUTHORIZE_PATH = "/api/auth/authorize";
@@ -3157,6 +3157,19 @@ var ME_SKILL_PACKAGES_PATH = "/api/me/skill-packages";
 var ME_WORKBENCH_APPS_PATH = "/api/me/workbench-apps";
 var ME_OFFICE_CONFIG_PATH = "/api/me/office-config";
 var ME_OFFICE_RELAY_DOCUMENTS_PATH = "/api/me/office-relay/documents";
+var ME_VOICE_CONFIG_PATH = "/api/me/voice-config";
+var ME_VOICE_TRANSCRIBE_PATH = "/api/me/voice-transcribe";
+var VOICE_TRANSCRIBE_TIMEOUT_MS = 6e4;
+var VOICE_CONFIG_FALLBACK_MAX_SECONDS = 60;
+var VOICE_ERROR_FALLBACK_MESSAGE = {
+  VOICE_DISABLED: "\u672C\u90E8\u7F72\u672A\u542F\u7528\u8BED\u97F3\u8BC6\u522B\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458",
+  VOICE_NOT_CONFIGURED: "\u672C\u90E8\u7F72\u5C1A\u672A\u914D\u7F6E\u8BED\u97F3\u8BC6\u522B\u670D\u52A1\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458",
+  VOICE_LIMIT_REACHED: "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+  VOICE_AUDIO_TOO_LARGE: "\u5F55\u97F3\u8FC7\u957F\u6216\u6587\u4EF6\u8FC7\u5927\uFF0C\u8BF7\u7F29\u77ED\u540E\u91CD\u8BD5",
+  VOICE_BAD_REQUEST: "\u5F55\u97F3\u6570\u636E\u4E0D\u5408\u6CD5\uFF0C\u8BF7\u91CD\u65B0\u5F55\u5236",
+  VOICE_UPSTREAM: "\u8BED\u97F3\u8BC6\u522B\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5"
+};
+var VOICE_ERROR_DEFAULT_MESSAGE = "\u8BED\u97F3\u8BC6\u522B\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
 var DEFAULT_CLIENT_ID = "hiwork-desktop";
 var DEFAULT_REDIRECT_URI = "hiwork://auth/callback";
 var GatewayError = class extends Error {
@@ -3548,6 +3561,81 @@ var AiRouterClient = class {
     if (!res.ok) throw new GatewayError("GATEWAY_UNREACHABLE", `\u7F51\u5173\u8FD4\u56DE\u9519\u8BEF\uFF08HTTP ${res.status}\uFF09`, res.status);
     return await parseMeJson(res);
   }
+  /**
+   * GET /api/me/voice-config：当前账号的语音识别开关与录音时长上限。
+   *
+   * 与每日一句的 `getMyDailyQuote` 同款，**这两个方法不在 {@link GatewayClient} 接口上**：
+   * 那个接口是编排层的端口，「语音识别」与它无关，加进去只会逼着每处编排层假网关
+   * （tests/orchestration.spec.ts 里一堆）都补两个用不到的桩。频道侧改用结构子集
+   * `VoiceGatewayPort`（见 `src/voice-rpc.ts`），与 usage / daily 三处一致。
+   *
+   * 与 {@link getMyMcpAssignments} 同样的理由**不复用 `getMeJson`**：那条路径把 403 映射成
+   * `NO_KEY_ASSIGNED`（「尚未被分配虚拟 KEY」），而本端点的鉴权只有会话——一个还没被分配
+   * Key 的账号照样应该有语音识别（分能力与分 Key 是两件事）。沿用它的文案会把「没有 Key」
+   * 错报成原因。
+   *
+   * 本端点契约**恒 200**（开关开与关都是 200 + `enabled` 布尔），因此除 401 以外没有任何
+   * 需要单独解释的拒绝语义：403 / 404 / 5xx / 反代错误页一律收敛成 `GATEWAY_UNREACHABLE`。
+   *
+   * 形状收敛（**本层负责**，消费方拿到的永远是一个合法的 {@link GatewayVoiceConfig}）：
+   * 网关线上是 snake_case `max_audio_seconds`，这里转 camelCase；字段缺失 / 类型不符
+   * 按「禁用 + 60 秒」处理——配置读不出来时话筒本就该消失，用一个 undefined 让消费方
+   * 去猜是把形状问题推给下游。真正的「读不到就回落」再往上一层（`src/voice-rpc.ts`）。
+   */
+  async getMyVoiceConfig(sessionCookie) {
+    const res = await this.requestOrUnreachable(ME_VOICE_CONFIG_PATH, { method: "GET", sessionCookie });
+    if (res.status === 401) throw new GatewayError("SESSION_EXPIRED", "\u7F51\u5173\u4F1A\u8BDD\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55", 401);
+    if (!res.ok) throw new GatewayError("GATEWAY_UNREACHABLE", `\u7F51\u5173\u8FD4\u56DE\u9519\u8BEF\uFF08HTTP ${res.status}\uFF09`, res.status);
+    const data = await parseMeJson(res);
+    const seconds = data.max_audio_seconds;
+    return {
+      enabled: data.enabled === true,
+      maxDurationSeconds: typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0 ? seconds : VOICE_CONFIG_FALLBACK_MAX_SECONDS
+    };
+  }
+  /**
+   * POST /api/me/voice-transcribe：把一段录音（base64）交给网关转发上游做识别。
+   *
+   * 状态码映射与服务端 handler 一一对应，**不许合并**：
+   *  - 401 = 会话过期（唯一一条能让人做点什么——重新登录——的拒绝）；
+   *  - 503 = 网关自己发的「功能不可用」，再按响应体 `code` 细分：
+   *    `VOICE_NOT_CONFIGURED`（部署没配上游）/ `VOICE_DISABLED`（管理员把开关关了）。
+   *    两者给的提示不同（该找管理员配服务 vs 该找管理员开开关）。
+   *    ⚠️ 响应体没有 `code`（非 JSON / 反代错误页）也归 `VOICE_DISABLED`——这条路由的
+   *    503 语义就是「没开」，而**上游故障走 502**（见下），不会伪装成 503；
+   *  - 429 / 413 / 400 = 配额 / 超长 / 请求体不合法，三种不同的事，分开映射（合并后
+   *    客户端只会看到一句「识别失败」，413 的人不知道该录短一点）；
+   *  - 其余（含 502 = 上游出错）→ `VOICE_UPSTREAM`。
+   *
+   * message 一律取网关响应体里的 `message`（网关侧是冻结的中文文案，会直接展示给用户）；
+   * 响应体不是合法 JSON / 缺 message 时退回本地兜底文案。**绝不把上游 / 网关原文回显**：
+   * 读取响应体走 {@link readVoiceError}（解析失败即空对象），与 `parseMeJson` 不回显原文同源。
+   *
+   * 超时**单独放宽到 60s**（见 {@link VOICE_TRANSCRIBE_TIMEOUT_MS}）：这条要上传录音 +
+   * 等上游识别，构造时的 10s 默认值在这里是误报源。
+   */
+  async transcribeVoice(sessionCookie, audioBase64) {
+    const res = await this.requestOrUnreachable(ME_VOICE_TRANSCRIBE_PATH, {
+      method: "POST",
+      sessionCookie,
+      body: { audio_base64: audioBase64 },
+      timeoutMs: VOICE_TRANSCRIBE_TIMEOUT_MS
+    });
+    if (res.status === 401) throw new GatewayError("SESSION_EXPIRED", "\u7F51\u5173\u4F1A\u8BDD\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55", 401);
+    if (!res.ok) {
+      const body = await readVoiceError(res);
+      if (res.status === 503) {
+        const code = body.code === "VOICE_NOT_CONFIGURED" ? "VOICE_NOT_CONFIGURED" : "VOICE_DISABLED";
+        throw new GatewayError(code, voiceMessage(code, body), 503);
+      }
+      if (res.status === 429) throw new GatewayError("VOICE_LIMIT_REACHED", voiceMessage("VOICE_LIMIT_REACHED", body), 429);
+      if (res.status === 413) throw new GatewayError("VOICE_AUDIO_TOO_LARGE", voiceMessage("VOICE_AUDIO_TOO_LARGE", body), 413);
+      if (res.status === 400) throw new GatewayError("VOICE_BAD_REQUEST", voiceMessage("VOICE_BAD_REQUEST", body), 400);
+      throw new GatewayError("VOICE_UPSTREAM", voiceMessage("VOICE_UPSTREAM", body), res.status);
+    }
+    const data = await parseMeJson(res);
+    return { text: typeof data.text === "string" ? data.text : "" };
+  }
   /**
    * /api/me 自助端点的 GET 公共路径：网络异常 → GATEWAY_UNREACHABLE，
    * 401/403/400 映射为稳定 code，响应体非 JSON 时不把原文带进异常。
@@ -3584,7 +3672,7 @@ var AiRouterClient = class {
     const init = {
       method: opts.method,
       headers,
-      signal: AbortSignal.timeout(this.timeoutMs)
+      signal: AbortSignal.timeout(opts.timeoutMs ?? this.timeoutMs)
     };
     if (opts.rawBody !== void 0) {
       init.body = opts.rawBody.buffer.slice(
@@ -3652,6 +3740,18 @@ async function parseMeJson(res) {
   }
   return data;
 }
+async function readVoiceError(res) {
+  const data = await readJson(res);
+  if (typeof data !== "object" || data === null) return {};
+  const record = data;
+  return {
+    ...typeof record.code === "string" && record.code !== "" ? { code: record.code } : {},
+    ...typeof record.message === "string" && record.message.trim() !== "" ? { message: record.message.trim() } : {}
+  };
+}
+function voiceMessage(code, body) {
+  return body.message ?? VOICE_ERROR_FALLBACK_MESSAGE[code] ?? VOICE_ERROR_DEFAULT_MESSAGE;
+}
 function isInvalidGrant(payload) {
   return typeof payload === "object" && payload !== null && payload.error === "invalid_grant";
 }
@@ -4218,8 +4318,8 @@ function parseAppVersionPayload(raw) {
   if (keys.length > 0) throw new AppVersionRequestError("bad-request", `\u684C\u9762\u7AEF\u7248\u672C\u8BF7\u6C42\u5305\u542B\u672A\u77E5\u5B57\u6BB5 '${keys[0]}'\u3002`);
 }
 function normalizedVersion(raw) {
-  const version = typeof raw === "string" ? raw.trim() : "";
-  return version === "" ? null : version;
+  const version2 = typeof raw === "string" ? raw.trim() : "";
+  return version2 === "" ? null : version2;
 }
 async function handleAppVersionEndpoint(endpoint, rawPayload, deps, signal) {
   try {
@@ -4652,6 +4752,123 @@ function registerUsageRpc(ctx, deps) {
   };
 }
 
+// src/voice-rpc.ts
+var VOICE_RPC_CHANNEL = "/hiwork-voice";
+var VOICE_RPC_ENDPOINTS = ["status", "transcribe"];
+var VoiceRequestError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "VoiceRequestError";
+  }
+};
+var VOICE_MESSAGE_FALLBACK = {
+  SESSION_EXPIRED: "\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55",
+  GATEWAY_UNREACHABLE: "\u7F51\u5173\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5",
+  VOICE_DISABLED: "\u672C\u90E8\u7F72\u672A\u542F\u7528\u8BED\u97F3\u8BC6\u522B\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458",
+  VOICE_NOT_CONFIGURED: "\u672C\u90E8\u7F72\u5C1A\u672A\u914D\u7F6E\u8BED\u97F3\u8BC6\u522B\u670D\u52A1\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458",
+  VOICE_LIMIT_REACHED: "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+  VOICE_AUDIO_TOO_LARGE: "\u5F55\u97F3\u8FC7\u957F\uFF0C\u8BF7\u7F29\u77ED\u540E\u91CD\u8BD5",
+  VOICE_BAD_REQUEST: "\u5F55\u97F3\u6570\u636E\u4E0D\u5408\u6CD5\uFF0C\u8BF7\u91CD\u65B0\u5F55\u5236",
+  VOICE_UPSTREAM: "\u8BED\u97F3\u8BC6\u522B\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5",
+  RATE_LIMITED: "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+  AUTH_FAILED: "\u767B\u5F55\u72B6\u6001\u5F02\u5E38\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55"
+};
+var VOICE_GENERIC_FAILURE_MESSAGE = "\u8BED\u97F3\u8BC6\u522B\u6682\u65F6\u65E0\u6CD5\u4F7F\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var VOICE_SESSION_EXPIRED_MESSAGE = "\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55";
+var VOICE_FALLBACK_CONFIG = { enabled: false, maxDurationSeconds: 60 };
+function displayVoiceGatewayMessage(code, message) {
+  const text = typeof message === "string" ? message.trim() : "";
+  if (text === "") return VOICE_MESSAGE_FALLBACK[code] ?? VOICE_GENERIC_FAILURE_MESSAGE;
+  const leaksImplementationDetail = /https?:\/\//i.test(text) || /\bHTTP\s*\d{3}\b/i.test(text) || /\bbaseURL\b/i.test(text);
+  if (leaksImplementationDetail) return VOICE_MESSAGE_FALLBACK[code] ?? VOICE_GENERIC_FAILURE_MESSAGE;
+  return text;
+}
+function parseVoicePayload(endpoint, raw) {
+  if (raw === void 0 || raw === null) {
+    if (endpoint === "transcribe") throw new VoiceRequestError("bad-request", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u7F3A\u5C11 audioBase64\u3002");
+    return {};
+  }
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new VoiceRequestError("bad-request", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u53C2\u6570\u4E0D\u5408\u6CD5\u3002");
+  }
+  const record = raw;
+  const keys = Object.keys(record);
+  if (endpoint === "status") {
+    if (keys.length > 0) throw new VoiceRequestError("bad-request", `\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u5305\u542B\u672A\u77E5\u5B57\u6BB5 '${keys[0]}'\u3002`);
+    return {};
+  }
+  for (const key of keys) {
+    if (key !== "audioBase64") throw new VoiceRequestError("bad-request", `\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u5305\u542B\u672A\u77E5\u5B57\u6BB5 '${key}'\u3002`);
+  }
+  const rawAudio = record["audioBase64"];
+  if (typeof rawAudio !== "string" || rawAudio.trim() === "") {
+    throw new VoiceRequestError("bad-request", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u7684 audioBase64 \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u3002");
+  }
+  return { audioBase64: rawAudio };
+}
+function isVoiceRpcEndpoint(endpoint) {
+  return VOICE_RPC_ENDPOINTS.includes(endpoint);
+}
+function isAborted4(signal) {
+  return signal?.aborted === true;
+}
+async function handleVoiceEndpoint(endpoint, rawPayload, deps, signal) {
+  try {
+    if (isAborted4(signal)) return failure4("cancelled", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (!isVoiceRpcEndpoint(endpoint)) {
+      throw new VoiceRequestError("bad-request", `\u672A\u77E5\u7684\u8BED\u97F3\u8BC6\u522B\u7AEF\u70B9 '${endpoint}'`);
+    }
+    const payload = parseVoicePayload(endpoint, rawPayload);
+    const sessionCookie = await deps.resolveSession();
+    if (sessionCookie === void 0 || sessionCookie === "") {
+      return failure4("SESSION_EXPIRED", VOICE_SESSION_EXPIRED_MESSAGE);
+    }
+    const gateway = deps.gateway();
+    if (gateway === void 0) {
+      return failure4("GATEWAY_UNREACHABLE", "\u7F51\u5173\u5730\u5740\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u5728\u300C\u7F51\u5173\u6A21\u578B\u300D\u91CC\u5B8C\u6210\u767B\u5F55");
+    }
+    if (isAborted4(signal)) return failure4("cancelled", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (endpoint === "status") return { ok: true, value: await readVoiceConfig(gateway, sessionCookie, deps.log) };
+    return { ok: true, value: await transcribe(gateway, sessionCookie, payload) };
+  } catch (error) {
+    if (error instanceof VoiceRequestError) return failure4(error.code, error.message);
+    if (error instanceof GatewayError) {
+      return failure4(error.code, displayVoiceGatewayMessage(error.code, error.message));
+    }
+    deps.log?.(`hiwork-core: \u8BED\u97F3\u8BC6\u522B RPC '${endpoint}' \u5931\u8D25\uFF08${error instanceof Error ? error.name : typeof error}\uFF09`);
+    return failure4("internal", VOICE_GENERIC_FAILURE_MESSAGE);
+  }
+}
+async function readVoiceConfig(gateway, sessionCookie, log) {
+  try {
+    const config = await gateway.getMyVoiceConfig(sessionCookie);
+    return {
+      enabled: config.enabled === true,
+      maxDurationSeconds: config.maxDurationSeconds > 0 ? config.maxDurationSeconds : VOICE_FALLBACK_CONFIG.maxDurationSeconds
+    };
+  } catch (error) {
+    log?.(`hiwork-core: \u8BED\u97F3\u914D\u7F6E\u8BFB\u53D6\u5931\u8D25\uFF0C\u6309\u7981\u7528\u56DE\u843D\uFF08${error instanceof Error ? error.name : typeof error}\uFF09`);
+    return { ...VOICE_FALLBACK_CONFIG };
+  }
+}
+async function transcribe(gateway, sessionCookie, payload) {
+  const audioBase64 = payload.audioBase64;
+  if (audioBase64 === void 0) throw new VoiceRequestError("bad-request", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u7F3A\u5C11 audioBase64\u3002");
+  const result = await gateway.transcribeVoice(sessionCookie, audioBase64);
+  return { text: result.text };
+}
+function failure4(code, message) {
+  return { ok: false, error: { code, message, details: {} } };
+}
+function registerVoiceRpc(ctx, deps) {
+  const handler = (endpoint, payload, signal) => handleVoiceEndpoint(endpoint, payload, deps, signal);
+  const remove = ctx.connection.rpc.handle(VOICE_RPC_CHANNEL, handler, { authority: "loopback" });
+  return async () => {
+    await remove();
+  };
+}
+
 // src/managed-mcp.ts
 var MANAGED_MCP_RPC_CHANNEL = "/hiwork-managed-mcp";
 var MANAGED_MCP_RPC_ENDPOINTS = ["snapshot", "refresh", "assertion"];
@@ -4816,12 +5033,12 @@ var ManagedMcpStore = class {
     }
   }
 };
-function isAborted4(signal) {
+function isAborted5(signal) {
   return signal?.aborted === true;
 }
 async function handleManagedMcpEndpoint(endpoint, rawPayload, deps, store, signal) {
   try {
-    if (isAborted4(signal)) return failure4("cancelled", "MCP \u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (isAborted5(signal)) return failure5("cancelled", "MCP \u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
     if (!isManagedMcpRpcEndpoint(endpoint)) {
       throw new ManagedMcpRequestError("bad-request", `\u672A\u77E5\u7684 MCP \u6E05\u5355\u7AEF\u70B9 '${endpoint}'`);
     }
@@ -4842,19 +5059,19 @@ async function handleManagedMcpEndpoint(endpoint, rawPayload, deps, store, signa
 async function handleAssertion(assignmentId, deps, signal) {
   const sessionCookie = await deps.resolveSession();
   if (sessionCookie === void 0 || sessionCookie === "") {
-    return failure4("SESSION_EXPIRED", MANAGED_MCP_SESSION_EXPIRED_MESSAGE);
+    return failure5("SESSION_EXPIRED", MANAGED_MCP_SESSION_EXPIRED_MESSAGE);
   }
   const gateway = deps.gateway();
   if (gateway === void 0) {
-    return failure4("GATEWAY_UNREACHABLE", "\u7F51\u5173\u5730\u5740\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u5728\u300C\u7F51\u5173\u6A21\u578B\u300D\u91CC\u5B8C\u6210\u767B\u5F55");
+    return failure5("GATEWAY_UNREACHABLE", "\u7F51\u5173\u5730\u5740\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u5728\u300C\u7F51\u5173\u6A21\u578B\u300D\u91CC\u5B8C\u6210\u767B\u5F55");
   }
-  if (isAborted4(signal)) return failure4("cancelled", "MCP \u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+  if (isAborted5(signal)) return failure5("cancelled", "MCP \u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
   const ticket = await gateway.issueMyMcpAssertion(sessionCookie, assignmentId);
   const assertion = textOrUndefined(ticket?.assertion);
   const mintUrl = textOrUndefined(ticket?.mintUrl);
   if (assertion === void 0 || mintUrl === void 0) {
     deps.log?.("hiwork-core: \u53D6\u65AD\u8A00\u6536\u5230\u65E0\u6548\u54CD\u5E94\uFF08\u7F3A assertion / mintUrl\uFF09");
-    return failure4("internal", MANAGED_MCP_GENERIC_FAILURE_MESSAGE);
+    return failure5("internal", MANAGED_MCP_GENERIC_FAILURE_MESSAGE);
   }
   return {
     ok: true,
@@ -4867,7 +5084,7 @@ async function handleAssertion(assignmentId, deps, signal) {
     }
   };
 }
-function failure4(code, message) {
+function failure5(code, message) {
   return { ok: false, error: { code, message, details: {} } };
 }
 function registerManagedMcpRpc(ctx, deps, store) {
@@ -5098,12 +5315,12 @@ var ManagedSkillsStore = class {
     }
   }
 };
-function isAborted5(signal) {
+function isAborted6(signal) {
   return signal?.aborted === true;
 }
 async function handleManagedSkillsEndpoint(endpoint, rawPayload, deps, store, signal) {
   try {
-    if (isAborted5(signal)) return failure5("cancelled", "\u6280\u80FD\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (isAborted6(signal)) return failure6("cancelled", "\u6280\u80FD\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
     if (!isManagedSkillsRpcEndpoint(endpoint)) {
       throw new ManagedSkillsRequestError("bad-request", `\u672A\u77E5\u7684\u6280\u80FD\u6E05\u5355\u7AEF\u70B9 '${endpoint}'`);
     }
@@ -5124,24 +5341,24 @@ async function handleManagedSkillsEndpoint(endpoint, rawPayload, deps, store, si
 async function handlePackage(assignmentId, deps, signal) {
   const sessionCookie = await deps.resolveSession();
   if (sessionCookie === void 0 || sessionCookie === "") {
-    return failure5("SESSION_EXPIRED", MANAGED_SKILLS_SESSION_EXPIRED_MESSAGE);
+    return failure6("SESSION_EXPIRED", MANAGED_SKILLS_SESSION_EXPIRED_MESSAGE);
   }
   const gateway = deps.gateway();
   if (gateway === void 0) {
-    return failure5("GATEWAY_UNREACHABLE", "\u7F51\u5173\u5730\u5740\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u5728\u300C\u7F51\u5173\u6A21\u578B\u300D\u91CC\u5B8C\u6210\u767B\u5F55");
+    return failure6("GATEWAY_UNREACHABLE", "\u7F51\u5173\u5730\u5740\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u5728\u300C\u7F51\u5173\u6A21\u578B\u300D\u91CC\u5B8C\u6210\u767B\u5F55");
   }
-  if (isAborted5(signal)) return failure5("cancelled", "\u6280\u80FD\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+  if (isAborted6(signal)) return failure6("cancelled", "\u6280\u80FD\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
   const pkg = await gateway.getMySkillPackage(sessionCookie, assignmentId);
   const bytes = pkg?.bytes;
   const skillName = textOrUndefined2(pkg?.skillName);
   const contentSha256 = textOrUndefined2(pkg?.contentSha256);
   if (!(bytes instanceof Uint8Array) || bytes.byteLength === 0 || skillName === void 0 || contentSha256 === void 0) {
     deps.log?.("hiwork-core: \u53D6\u6280\u80FD\u5305\u6536\u5230\u65E0\u6548\u54CD\u5E94\uFF08\u7F3A skillName / contentSha256 \u6216\u7A7A\u5305\u4F53\uFF09");
-    return failure5("internal", MANAGED_SKILLS_GENERIC_FAILURE_MESSAGE);
+    return failure6("internal", MANAGED_SKILLS_GENERIC_FAILURE_MESSAGE);
   }
   if (bytes.byteLength > MAX_MANAGED_SKILL_ARCHIVE_BYTES) {
     deps.log?.("hiwork-core: \u6280\u80FD\u5305\u8D85\u8FC7\u5927\u5C0F\u4E0A\u9650\uFF0C\u5DF2\u62D2\u7EDD\u642C\u8FD0");
-    return failure5(MANAGED_SKILLS_PACKAGE_TOO_LARGE_CODE, MANAGED_SKILLS_PACKAGE_TOO_LARGE_MESSAGE);
+    return failure6(MANAGED_SKILLS_PACKAGE_TOO_LARGE_CODE, MANAGED_SKILLS_PACKAGE_TOO_LARGE_MESSAGE);
   }
   return {
     ok: true,
@@ -5155,7 +5372,7 @@ async function handlePackage(assignmentId, deps, signal) {
     }
   };
 }
-function failure5(code, message) {
+function failure6(code, message) {
   return { ok: false, error: { code, message, details: {} } };
 }
 function registerManagedSkillsRpc(ctx, deps, store) {
@@ -5297,7 +5514,7 @@ function failureOf3(error) {
 function normalizeSession2(sessionCookie) {
   return sessionCookie === void 0 || sessionCookie === "" ? void 0 : sessionCookie;
 }
-function isAborted6(signal) {
+function isAborted7(signal) {
   return signal?.aborted === true;
 }
 var WorkbenchStore = class {
@@ -5422,7 +5639,7 @@ var WorkbenchStore = class {
 };
 async function handleWorkbenchEndpoint(endpoint, rawPayload, deps, store, signal) {
   try {
-    if (isAborted6(signal)) return failure6("cancelled", "\u5DE5\u4F5C\u53F0\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (isAborted7(signal)) return failure7("cancelled", "\u5DE5\u4F5C\u53F0\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
     if (!isWorkbenchRpcEndpoint(endpoint)) {
       throw new WorkbenchRequestError("bad-request", `\u672A\u77E5\u7684\u5DE5\u4F5C\u53F0\u6E05\u5355\u7AEF\u70B9 '${endpoint}'`);
     }
@@ -5435,7 +5652,7 @@ async function handleWorkbenchEndpoint(endpoint, rawPayload, deps, store, signal
     return { ok: false, error: failureOf3(error) };
   }
 }
-function failure6(code, message) {
+function failure7(code, message) {
   return { ok: false, error: { code, message, details: {} } };
 }
 function registerWorkbenchRpc(ctx, deps, store) {
@@ -5695,6 +5912,10 @@ var PmsClient = class {
    * 必须与其余调用逐字相同**（spec §7：统一 10s、令牌只在有身份时发），所以两条路共用这一处，
    * 而不是各抄一份、将来各自漂移。
    *
+   * **重定向自己跟**（`redirect: 'manual'` + {@link redirectTargetOf}）：`fetch` 的默认 `follow` 会把
+   * 重定向后的请求按 fetch 语义**把 POST 改成 GET**，于是请求落在一个只认 POST 的映射上、拿到一个
+   * 「200 + 业务错误信封」，看上去像上游坏了。判据与修法见 {@link PMS_MAX_REDIRECTS}。
+   *
    * @param url - 相对路径（拼 {@link PmsClient.baseURL}）或**绝对 URL**（原样使用）。
    * @param opts - 方法 / 可选 JSON 体 / 可选 Bearer 令牌。
    * @returns 原始 `Response`：状态码由调用方判定，本方法不把任何状态码当成错误。
@@ -5710,10 +5931,19 @@ var PmsClient = class {
       const init = {
         method: opts.method,
         headers,
-        signal: AbortSignal.timeout(this.timeoutMs)
+        // 手动跟随：默认的 `follow` 会把重定向后的 POST 降级成 GET（见本方法的抬头）。
+        redirect: "manual"
       };
       if (opts.body !== void 0) init.body = JSON.stringify(opts.body);
-      return await fetch(isAbsoluteUrl(url) ? url : `${this.baseURL}${url}`, init);
+      const deadline = Date.now() + this.timeoutMs;
+      let target = isAbsoluteUrl(url) ? url : `${this.baseURL}${url}`;
+      let response = await fetchWithinDeadline(target, init, deadline);
+      for (let hop = 0; ; hop += 1) {
+        const next = redirectTargetOf(target, response, hop);
+        if (next === void 0) return response;
+        target = next;
+        response = await fetchWithinDeadline(target, init, deadline);
+      }
     } catch {
       throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE);
     }
@@ -5767,6 +5997,30 @@ function isRecord3(value) {
 function isAbsoluteUrl(url) {
   return /^https?:\/\//i.test(url);
 }
+var PMS_MAX_REDIRECTS = 2;
+var METHOD_PRESERVING_REDIRECTS = /* @__PURE__ */ new Set([301, 302, 307, 308]);
+function redirectTargetOf(current, response, hop) {
+  if (!METHOD_PRESERVING_REDIRECTS.has(response.status)) return void 0;
+  if (hop >= PMS_MAX_REDIRECTS) return void 0;
+  const location = response.headers.get("location");
+  if (location === null || location.trim() === "") return void 0;
+  let from2;
+  let next;
+  try {
+    from2 = new URL(current);
+    next = new URL(location.trim(), current);
+  } catch {
+    return void 0;
+  }
+  if (next.protocol !== "https:" && next.protocol !== from2.protocol) return void 0;
+  if (next.hostname !== from2.hostname) return void 0;
+  return next.toString();
+}
+async function fetchWithinDeadline(target, init, deadline) {
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) throw new Error("pms request deadline exceeded");
+  return await fetch(target, { ...init, signal: AbortSignal.timeout(remaining) });
+}
 function expiresAtOr(value, fallbackMs) {
   if (typeof value === "string" && value !== "" && Number.isFinite(Date.parse(value))) return value;
   return new Date(fallbackMs).toISOString();
@@ -6297,7 +6551,7 @@ var PmsTodoStore = class {
 };
 async function handlePmsTodoEndpoint(endpoint, rawPayload, deps, store, signal) {
   try {
-    if (signal?.aborted === true) return failure7("BAD_REQUEST", PMS_TODO_CANCELLED_MESSAGE);
+    if (signal?.aborted === true) return failure8("BAD_REQUEST", PMS_TODO_CANCELLED_MESSAGE);
     if (!isPmsTodoRpcEndpoint(endpoint)) {
       throw new PmsTodoRequestError(`\u672A\u77E5\u7684 PMS \u5F85\u529E\u7AEF\u70B9 '${endpoint}'`);
     }
@@ -6321,7 +6575,7 @@ async function handlePmsTodoEndpoint(endpoint, rawPayload, deps, store, signal)
     return { ok: false, error: pmsTodoErrorOf(error) };
   }
 }
-function failure7(code, message) {
+function failure8(code, message) {
   return { ok: false, error: { code, message, details: {} } };
 }
 function registerPmsTodoRpc(ctx, deps, store) {
@@ -6352,7 +6606,7 @@ function isRecord4(value) {
 function textOrUndefined4(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
-function isAborted7(signal) {
+function isAborted8(signal) {
   return signal?.aborted === true;
 }
 function parsePluginUpdatesPayload(endpoint, raw) {
@@ -6395,7 +6649,7 @@ function toSnapshot(raw) {
 }
 async function handlePluginUpdatesEndpoint(endpoint, rawPayload, deps, signal) {
   try {
-    if (isAborted7(signal)) return failure8("cancelled", "\u63D2\u4EF6\u66F4\u65B0\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (isAborted8(signal)) return failure9("cancelled", "\u63D2\u4EF6\u66F4\u65B0\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
     if (!isPluginUpdatesRpcEndpoint(endpoint)) {
       throw new PluginUpdatesRequestError("bad-request", `\u672A\u77E5\u7684\u63D2\u4EF6\u66F4\u65B0\u7AEF\u70B9 '${endpoint}'`);
     }
@@ -6411,12 +6665,12 @@ async function handlePluginUpdatesEndpoint(endpoint, rawPayload, deps, signal) {
     await plugins.applyNow();
     return { ok: true, value: { requested: true } };
   } catch (error) {
-    if (error instanceof PluginUpdatesRequestError) return failure8(error.code, error.message);
+    if (error instanceof PluginUpdatesRequestError) return failure9(error.code, error.message);
     deps.log?.(`hiwork-core: \u63D2\u4EF6\u66F4\u65B0 RPC '${endpoint}' \u5931\u8D25\uFF08${error instanceof Error ? error.name : typeof error}\uFF09`);
-    return failure8("internal", PLUGIN_UPDATES_GENERIC_FAILURE_MESSAGE);
+    return failure9("internal", PLUGIN_UPDATES_GENERIC_FAILURE_MESSAGE);
   }
 }
-function failure8(code, message) {
+function failure9(code, message) {
   return { ok: false, error: { code, message, details: {} } };
 }
 function registerPluginUpdatesRpc(ctx, deps) {
@@ -6487,16 +6741,15 @@ function provideIdentity(ctx, deps) {
   };
 }
 
-// src/memory-config.ts
-var HIWORK_MEMORY_SERVICE = "hiworkMemory";
-var ME_MEMORY_CONFIG_PATH = "/api/me/memory-config";
-var MEMORY_CONFIG_TTL_MS = 5 * 60 * 1e3;
-var MEMORY_CONFIG_TIMEOUT_MS = 1e4;
-var MESSAGE_NOT_CONFIGURED = "\u7BA1\u7406\u5458\u8FD8\u6CA1\u5F00\u542F\u56E2\u961F\u8BB0\u5FC6\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u5F00\u901A";
+// src/knowledge-config.ts
+var HIWORK_KNOWLEDGE_SERVICE = "hiworkKnowledge";
+var ME_KNOWLEDGE_CONFIG_PATH = "/api/me/knowledge-config";
+var KNOWLEDGE_CONFIG_TTL_MS = 5 * 60 * 1e3;
+var KNOWLEDGE_CONFIG_TIMEOUT_MS = 1e4;
+var MESSAGE_NOT_CONFIGURED = "\u7BA1\u7406\u5458\u8FD8\u6CA1\u5F00\u542F\u77E5\u8BC6\u5E93\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u5F00\u901A";
 var MESSAGE_UNAUTHENTICATED = "\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55";
-var MESSAGE_UNREACHABLE = "\u8BB0\u5FC6\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
-var MESSAGE_NO_GATEWAY = "\u8FD8\u6CA1\u8FDE\u4E0A\u4F01\u4E1A\u7F51\u5173\uFF0C\u8BF7\u5148\u767B\u5F55\u540E\u518D\u8BD5";
-var MESSAGE_GENERIC = "\u8BB0\u5FC6\u914D\u7F6E\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var MESSAGE_UNREACHABLE = "\u77E5\u8BC6\u5E93\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var MESSAGE_GENERIC = "\u77E5\u8BC6\u5E93\u914D\u7F6E\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
 function messageFor(reason) {
   switch (reason) {
     case "not-configured":
@@ -6509,7 +6762,7 @@ function messageFor(reason) {
       return MESSAGE_GENERIC;
   }
 }
-function failure9(reason, message) {
+function failure10(reason, message) {
   return { ok: false, reason, message: message ?? messageFor(reason) };
 }
 function textOrUndefined6(value) {
@@ -6517,19 +6770,172 @@ function textOrUndefined6(value) {
   const text = value.trim();
   return text === "" ? void 0 : text;
 }
+function projectKnowledgeConfig(body) {
+  const baseUrl = textOrUndefined6(body["base_url"] ?? body["baseUrl"]);
+  const apiKey = textOrUndefined6(body["api_key"] ?? body["apiKey"]);
+  if (baseUrl === void 0 || apiKey === void 0) return void 0;
+  return {
+    ok: true,
+    baseUrl,
+    apiKey,
+    agentId: textOrUndefined6(body["agent_id"] ?? body["agentId"]) ?? "",
+    chatModelId: textOrUndefined6(body["chat_model_id"] ?? body["chatModelId"]) ?? "",
+    tenantId: textOrUndefined6(body["tenant_id"] ?? body["tenantId"]) ?? ""
+  };
+}
+function errorName2(error) {
+  return error instanceof Error ? error.name : typeof error;
+}
+function reasonOfErrorCode(error) {
+  const code = error?.code;
+  if (typeof code !== "string") return void 0;
+  switch (code) {
+    case "SESSION_EXPIRED":
+      return "unauthenticated";
+    case "KNOWLEDGE_NOT_CONFIGURED":
+      return "not-configured";
+    case "KNOWLEDGE_UNREACHABLE":
+    case "GATEWAY_UNREACHABLE":
+      return "unreachable";
+    default:
+      return void 0;
+  }
+}
+function reasonOfStatus(status) {
+  if (status === 401) return "unauthenticated";
+  if (status === 503) return "not-configured";
+  if (status === 504) return "unreachable";
+  return "error";
+}
+var KnowledgeConfigProvider = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  cached;
+  async config(opts) {
+    const force = opts?.force === true;
+    let sessionCookie;
+    try {
+      sessionCookie = await this.deps.resolveSession();
+    } catch (error) {
+      this.deps.log?.(`hiwork-core: \u77E5\u8BC6\u5E93\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName2(error)}\uFF09`);
+      return failure10("error");
+    }
+    if (sessionCookie === void 0 || sessionCookie === "") return failure10("unauthenticated");
+    if (!force) {
+      const hit = this.cached;
+      if (hit !== void 0 && hit.sessionCookie === sessionCookie && this.now() - hit.at < KNOWLEDGE_CONFIG_TTL_MS) {
+        return hit.view;
+      }
+    }
+    const gateway = this.deps.gateway();
+    if (gateway === void 0) return failure10("unreachable");
+    let outcome;
+    try {
+      outcome = await gateway.getMyKnowledgeConfig(sessionCookie);
+    } catch (error) {
+      const mapped = reasonOfErrorCode(error);
+      if (mapped !== void 0) return failure10(mapped);
+      this.deps.log?.(`hiwork-core: \u77E5\u8BC6\u5E93\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName2(error)}\uFF09`);
+      return failure10("error");
+    }
+    if (!outcome.ok) {
+      if (outcome.kind === "network") return failure10("unreachable");
+      if (outcome.kind === "http") return failure10(reasonOfStatus(outcome.status));
+      return failure10("error");
+    }
+    const view = projectKnowledgeConfig(outcome.body);
+    if (view === void 0) {
+      this.deps.log?.("hiwork-core: \u7F51\u5173\u8FD4\u56DE\u7684 knowledge-config \u4E0D\u5B8C\u6574\uFF08\u7F3A base_url / api_key \u4E4B\u4E00\uFF09");
+      return failure10("error");
+    }
+    this.cached = { sessionCookie, view, at: this.now() };
+    return view;
+  }
+  now() {
+    return (this.deps.now ?? Date.now)();
+  }
+};
+function provideKnowledgeConfig(ctx, deps) {
+  const service = new KnowledgeConfigProvider(deps);
+  const dispose = ctx.provide(HIWORK_KNOWLEDGE_SERVICE, service);
+  return typeof dispose === "function" ? dispose : () => {
+  };
+}
+function createKnowledgeConfigGateway(baseURL, opts = {}) {
+  const root = baseURL.replace(/\/+$/, "");
+  const timeoutMs = opts.timeoutMs ?? KNOWLEDGE_CONFIG_TIMEOUT_MS;
+  const doFetch = opts.fetchImpl ?? fetch;
+  return {
+    async getMyKnowledgeConfig(sessionCookie) {
+      try {
+        const res = await doFetch(`${root}${ME_KNOWLEDGE_CONFIG_PATH}`, {
+          method: "GET",
+          headers: {
+            "user-agent": `hiwork-core/${PKG_VERSION}`,
+            cookie: sessionCookie
+          },
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+        if (!res.ok) return { ok: false, kind: "http", status: res.status };
+        let body;
+        try {
+          body = await res.json();
+        } catch {
+          return { ok: false, kind: "invalid" };
+        }
+        if (body === null || typeof body !== "object") return { ok: false, kind: "invalid" };
+        return { ok: true, body };
+      } catch {
+        return { ok: false, kind: "network" };
+      }
+    }
+  };
+}
+
+// src/memory-config.ts
+var HIWORK_MEMORY_SERVICE = "hiworkMemory";
+var ME_MEMORY_CONFIG_PATH = "/api/me/memory-config";
+var MEMORY_CONFIG_TTL_MS = 5 * 60 * 1e3;
+var MEMORY_CONFIG_TIMEOUT_MS = 1e4;
+var MESSAGE_NOT_CONFIGURED2 = "\u7BA1\u7406\u5458\u8FD8\u6CA1\u5F00\u542F\u56E2\u961F\u8BB0\u5FC6\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u5F00\u901A";
+var MESSAGE_UNAUTHENTICATED2 = "\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55";
+var MESSAGE_UNREACHABLE2 = "\u8BB0\u5FC6\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var MESSAGE_NO_GATEWAY = "\u8FD8\u6CA1\u8FDE\u4E0A\u4F01\u4E1A\u7F51\u5173\uFF0C\u8BF7\u5148\u767B\u5F55\u540E\u518D\u8BD5";
+var MESSAGE_GENERIC2 = "\u8BB0\u5FC6\u914D\u7F6E\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+function messageFor2(reason) {
+  switch (reason) {
+    case "not-configured":
+      return MESSAGE_NOT_CONFIGURED2;
+    case "unauthenticated":
+      return MESSAGE_UNAUTHENTICATED2;
+    case "unreachable":
+      return MESSAGE_UNREACHABLE2;
+    case "error":
+      return MESSAGE_GENERIC2;
+  }
+}
+function failure11(reason, message) {
+  return { ok: false, reason, message: message ?? messageFor2(reason) };
+}
+function textOrUndefined7(value) {
+  if (typeof value !== "string") return void 0;
+  const text = value.trim();
+  return text === "" ? void 0 : text;
+}
 function teamIdsOf(value) {
   if (!Array.isArray(value)) return [];
   const ids = [];
   for (const item of value) {
-    const text = textOrUndefined6(item);
+    const text = textOrUndefined7(item);
     if (text !== void 0) ids.push(text);
   }
   return ids;
 }
 function projectMemoryConfig(body) {
-  const panelUrl = textOrUndefined6(body["panel_url"] ?? body["panelUrl"]);
-  const serviceId = textOrUndefined6(body["service_id"] ?? body["serviceId"]);
-  const apiKey = textOrUndefined6(body["api_key"] ?? body["apiKey"] ?? body["userKey"]);
+  const panelUrl = textOrUndefined7(body["panel_url"] ?? body["panelUrl"]);
+  const serviceId = textOrUndefined7(body["service_id"] ?? body["serviceId"]);
+  const apiKey = textOrUndefined7(body["api_key"] ?? body["apiKey"] ?? body["userKey"]);
   if (panelUrl === void 0 || serviceId === void 0 || apiKey === void 0) return void 0;
   return {
     ok: true,
@@ -6539,10 +6945,10 @@ function projectMemoryConfig(body) {
     apiKey
   };
 }
-function errorName2(error) {
+function errorName3(error) {
   return error instanceof Error ? error.name : typeof error;
 }
-function reasonOfErrorCode(error) {
+function reasonOfErrorCode2(error) {
   const code = error?.code;
   if (typeof code !== "string") return void 0;
   switch (code) {
@@ -6557,7 +6963,7 @@ function reasonOfErrorCode(error) {
       return void 0;
   }
 }
-function reasonOfStatus(status) {
+function reasonOfStatus2(status) {
   if (status === 401) return "unauthenticated";
   if (status === 503) return "not-configured";
   if (status === 504) return "unreachable";
@@ -6574,10 +6980,10 @@ var MemoryConfigProvider = class {
     try {
       sessionCookie = await this.deps.resolveSession();
     } catch (error) {
-      this.deps.log?.(`hiwork-core: \u8BB0\u5FC6\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName2(error)}\uFF09`);
-      return failure9("error");
+      this.deps.log?.(`hiwork-core: \u8BB0\u5FC6\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName3(error)}\uFF09`);
+      return failure11("error");
     }
-    if (sessionCookie === void 0 || sessionCookie === "") return failure9("unauthenticated");
+    if (sessionCookie === void 0 || sessionCookie === "") return failure11("unauthenticated");
     if (!force) {
       const hit = this.cached;
       if (hit !== void 0 && hit.sessionCookie === sessionCookie && this.now() - hit.at < MEMORY_CONFIG_TTL_MS) {
@@ -6585,25 +6991,25 @@ var MemoryConfigProvider = class {
       }
     }
     const gateway = this.deps.gateway();
-    if (gateway === void 0) return failure9("unreachable", MESSAGE_NO_GATEWAY);
+    if (gateway === void 0) return failure11("unreachable", MESSAGE_NO_GATEWAY);
     let outcome;
     try {
       outcome = await gateway.getMyMemoryConfig(sessionCookie);
     } catch (error) {
-      const mapped = reasonOfErrorCode(error);
-      if (mapped !== void 0) return failure9(mapped);
-      this.deps.log?.(`hiwork-core: \u8BB0\u5FC6\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName2(error)}\uFF09`);
-      return failure9("error");
+      const mapped = reasonOfErrorCode2(error);
+      if (mapped !== void 0) return failure11(mapped);
+      this.deps.log?.(`hiwork-core: \u8BB0\u5FC6\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName3(error)}\uFF09`);
+      return failure11("error");
     }
     if (!outcome.ok) {
-      if (outcome.kind === "network") return failure9("unreachable");
-      if (outcome.kind === "http") return failure9(reasonOfStatus(outcome.status));
-      return failure9("error");
+      if (outcome.kind === "network") return failure11("unreachable");
+      if (outcome.kind === "http") return failure11(reasonOfStatus2(outcome.status));
+      return failure11("error");
     }
     const view = projectMemoryConfig(outcome.body);
     if (view === void 0) {
       this.deps.log?.("hiwork-core: \u7F51\u5173\u8FD4\u56DE\u7684 memory-config \u4E0D\u5B8C\u6574\uFF08\u7F3A panel_url / service_id / api_key \u4E4B\u4E00\uFF09");
-      return failure9("error");
+      return failure11("error");
     }
     this.cached = { sessionCookie, view, at: this.now() };
     return view;
@@ -6796,31 +7202,1374 @@ function provideOfficeRelay(ctx, deps) {
   };
 }
 
-// src/index.ts
-var name = "hiwork-core";
-var inject = ["settings", "credentials", "workspaceRegistry", "connection"];
-var NS = "ai-router";
-var PI_AI_NS = "llm-pi-ai";
-var lastErrorSchema = Schema.object({ code: Schema.string().required(), message: Schema.string().required() }).default(void 0);
-var Config = Schema.object({
-  baseURL: Schema.string(),
-  keyId: Schema.string(),
-  username: Schema.string(),
-  displayName: Schema.string(),
-  lastLogin: Schema.object({ at: Schema.string().required(), modelCount: Schema.number().required(), gatewayName: Schema.string().required() }).default(void 0),
-  lastError: lastErrorSchema,
-  pendingLogin: Schema.object({ username: Schema.string().required(), passwordRef: Schema.string().required() }).default(void 0),
-  rememberPassword: Schema.boolean().default(false),
-  refreshRequest: Schema.object({ at: Schema.string().required() }).default(void 0),
-  logoutRequest: Schema.object({ at: Schema.string().required() }).default(void 0),
-  browserLoginRequest: Schema.object({ at: Schema.string().required() }).default(void 0),
-  browserLogin: Schema.object({ authorizeUrl: Schema.string().required(), startedAt: Schema.string().required() }).default(void 0),
-  // 三值枚举：非法值写入直接被 schema 拒绝（客户端还会再归一一次，双保险）。
-  loginMode: Schema.union([Schema.const("browser"), Schema.const("form"), Schema.const("both")]),
-  passwordLogin: Schema.boolean(),
-  budgets: Schema.array(Schema.object({
-    model_name: Schema.string().required(),
-    total_budget: Schema.number(),
+// node_modules/.pnpm/@deepseek-ai+dsh-llm@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2/node_modules/@deepseek-ai/dsh-llm/lib/index.js
+import { createRequire } from "node:module";
+
+// node_modules/.pnpm/@deepseek-ai+dsh-typert-protocol@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2/node_modules/@deepseek-ai/dsh-typert-protocol/lib/index.js
+var RemoteError = class extends Error {
+  code;
+  details;
+  /** Structural marker: cross-realm/bundle identification never uses instanceof. */
+  isDSHRemoteError = true;
+  /**
+  * @param code - stable failure code declared in {@link RemoteErrorDetailsMap}.
+  * @param message - human diagnostic carried across the wire.
+  * @param details - structured payload typed by the code.
+  * @param options - standard Error options (`cause` survives in-process only).
+  */
+  constructor(code, message, details, options) {
+    super(message, options);
+    this.code = code;
+    this.details = details;
+    this.name = "RemoteError";
+  }
+};
+var TYPERT_REMOTE_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
+function isTypertRemoteSegment(value) {
+  return value !== "." && value !== ".." && TYPERT_REMOTE_SEGMENT_PATTERN.test(value);
+}
+var REMOTE_METHOD_DESCRIPTOR = "@deepseek-ai/dsh-typert-protocol/remote-methods";
+function bindTypertRemote(service, serviceKey, options = {}) {
+  validateName("service key", serviceKey);
+  const namespace = options.namespace ?? serviceKey;
+  validateName("namespace", namespace);
+  return Object.freeze({
+    service,
+    serviceKey,
+    namespace
+  });
+}
+var TypertRemoteService = class extends Service {
+  /** Visible binding consumed by the Gateway's source-mode discovery. */
+  typertRemote;
+  /**
+  * Register the Service and bind the same key to Typert Gateway.
+  * @param ctx - owning Cordis Context.
+  * @param serviceKey - exact Cordis service key and default wire namespace.
+  * @param options - optional distinct wire namespace.
+  */
+  constructor(ctx, serviceKey, options = {}) {
+    super(ctx, serviceKey);
+    this.typertRemote = bindTypertRemote(this, this.name, options);
+  }
+};
+function Remote(methodExportOrOptions, context) {
+  if (typeof methodExportOrOptions === "string") {
+    validateName("Remote export name", methodExportOrOptions);
+    return remoteDecorator({ kind: "direct" }, void 0, methodExportOrOptions);
+  }
+  if (typeof methodExportOrOptions === "object") {
+    if (remoteOptionMode(methodExportOrOptions) !== "stream" || Reflect.ownKeys(methodExportOrOptions).length !== 1) throw new TypeError('typert-protocol: Remote options must contain exactly mode: "stream"');
+    return remoteDecorator({ kind: "direct" }, "stream");
+  }
+  if (context === void 0) throw new TypeError("typert-protocol: Remote decorator context is missing");
+  addMarkerInitializer(context, { kind: "direct" });
+}
+function remoteOptionMode(options) {
+  return Reflect.get(options, "mode");
+}
+function remoteDecorator(invocation, mode, exportName) {
+  return function(_method, context) {
+    addMarkerInitializer(context, invocation, mode, exportName);
+  };
+}
+function readRemoteMethodDescriptor(prototype) {
+  const property2 = Object.getOwnPropertyDescriptor(prototype, REMOTE_METHOD_DESCRIPTOR);
+  if (property2 === void 0) return void 0;
+  const descriptor = property2.value;
+  if (descriptor === null || typeof descriptor !== "object") throw new TypeError("typert-protocol: Remote method descriptor must be an object");
+  const version2 = Reflect.get(descriptor, "version");
+  if (version2 !== 1) throw new TypeError(`typert-protocol: unsupported Remote method descriptor version ${String(version2)}`);
+  const methods = Reflect.get(descriptor, "methods");
+  if (!Array.isArray(methods)) throw new TypeError("typert-protocol: Remote method descriptor methods must be an array");
+  return descriptor;
+}
+function addMarkerInitializer(context, invocation, mode, exportName) {
+  if (context.private || context.static || typeof context.name !== "string") throw new TypeError("typert-protocol: Remote decorators require a public instance method with a string name");
+  const method = context.name;
+  context.addInitializer(function() {
+    const prototype = Object.getPrototypeOf(this);
+    if (prototype === null) throw new TypeError(`typert-protocol: cannot mark Remote method "${method}" on an object without a prototype`);
+    mark(prototype, method, invocation, mode, exportName);
+  });
+}
+function mark(prototype, method, invocation, mode, exportName) {
+  const descriptor = readRemoteMethodDescriptor(prototype);
+  const marker = Object.freeze({
+    method,
+    ...exportName === void 0 || exportName === method ? {} : { exportName },
+    ...mode === void 0 ? {} : { mode },
+    invocation: Object.freeze(invocation)
+  });
+  const current = descriptor?.methods.find((candidate) => candidate.method === method);
+  if (current !== void 0) {
+    if (current.exportName === marker.exportName && current.mode === marker.mode && sameInvocation(current.invocation, invocation)) return;
+    throw new Error(`typert-protocol: Remote method "${method}" has conflicting invocation markers`);
+  }
+  Object.defineProperty(prototype, REMOTE_METHOD_DESCRIPTOR, {
+    configurable: true,
+    value: Object.freeze({
+      version: 1,
+      methods: Object.freeze([...descriptor?.methods ?? [], marker])
+    })
+  });
+}
+function sameInvocation(left, right) {
+  if (left.kind === "direct") return right.kind === "direct";
+  if (right.kind === "direct") return false;
+  return left.context === right.context;
+}
+function validateName(subject, value) {
+  if (!isTypertRemoteSegment(value)) throw new TypeError(`typert-protocol: ${subject} must contain only RPC endpoint segment characters`);
+}
+
+// node_modules/.pnpm/@deepseek-ai+dsh-timeout@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2/node_modules/@deepseek-ai/dsh-timeout/lib/index.js
+var MAX_TIMER_DELAY_MS = 2147483647;
+
+// node_modules/.pnpm/@deepseek-ai+dsh-llm@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2/node_modules/@deepseek-ai/dsh-llm/lib/index.js
+function freezeMessage(message) {
+  return deepFreeze(structuredClone(message));
+}
+var HarnessError = class extends Error {
+  /** Stable machine-routable failure class (e.g. `RATE_LIMIT`); route on this, never by parsing `message`. */
+  code;
+  constructor(message, code, options) {
+    super(message, options);
+    this.code = code;
+    this.name = new.target.name;
+  }
+};
+var EMPTY_RESPONSE_CODE = "EMPTY_RESPONSE";
+var STRUCTURED_CONTEXT_OVERFLOW = new RegExp(String.raw`(?:^|[^a-z0-9])context[\s_-](?:length|window)[\s_-]` + String.raw`(?:exceed(?:ed|s)?|overflow(?:ed)?|limit[\s_-]exceeded)(?:$|[^a-z0-9])`, "i");
+var TOO_LARGE_FOR_CONTEXT = new RegExp(String.raw`\b(?:request|prompt|input|messages?)\s+(?:is\s+|are\s+)?` + String.raw`too\s+(?:large|long)\s+for\s+(?:(?:this|the)\s+)?` + String.raw`(?:model(?:'s)?\s+)?context(?:\s+window)?\b`, "i");
+var EXCEEDS_MODEL_CONTEXT = new RegExp(String.raw`\b(?:input|prompt|request|messages?)\b.{0,40}` + String.raw`\b(?:exceed(?:s|ed)?|overflows?|is\s+larger\s+than)\b.{0,40}` + String.raw`\b(?:the\s+)?(?:model(?:'s)?\s+)?context(?:\s+(?:length|window))?\b`, "i");
+var DEFAULT_MAX_RETRIES = 5;
+var DEFAULT_INITIAL_DELAY_MS = 500;
+var DEFAULT_MAX_DELAY_MS = 1e4;
+var DEFAULT_JITTER_RATIO = 0.1;
+var DEFAULT_RETRYABLE_CODES = Object.freeze([
+  EMPTY_RESPONSE_CODE,
+  "RATE_LIMIT",
+  "SERVER",
+  "TIMEOUT",
+  "TRANSPORT"
+]);
+var backoffSchema = Schema.object({
+  initialDelayMs: Schema.number().max(MAX_TIMER_DELAY_MS).default(DEFAULT_INITIAL_DELAY_MS),
+  maxDelayMs: Schema.number().max(MAX_TIMER_DELAY_MS).default(DEFAULT_MAX_DELAY_MS),
+  jitterRatio: Schema.number().min(0).max(1).default(DEFAULT_JITTER_RATIO)
+});
+var normalPolicySchema = Schema.object({
+  mode: Schema.const("normal").required(),
+  maxRetries: Schema.number().step(1).min(0).max(Number.MAX_SAFE_INTEGER).default(DEFAULT_MAX_RETRIES),
+  retryableCodes: Schema.array(Schema.string()).default([...DEFAULT_RETRYABLE_CODES]),
+  backoff: backoffSchema
+});
+var alwaysPolicySchema = Schema.object({
+  mode: Schema.const("always").required(),
+  backoff: backoffSchema
+});
+var RetryPolicySchema = Schema.union([normalPolicySchema, alwaysPolicySchema]);
+var NORMAL_POLICY_KEYS = /* @__PURE__ */ new Set([
+  "mode",
+  "maxRetries",
+  "retryableCodes",
+  "backoff"
+]);
+var ALWAYS_POLICY_KEYS = /* @__PURE__ */ new Set([
+  "mode",
+  "maxRetries",
+  "retryableCodes",
+  "backoff"
+]);
+var BACKOFF_KEYS = /* @__PURE__ */ new Set([
+  "initialDelayMs",
+  "maxDelayMs",
+  "jitterRatio"
+]);
+function validateKeys(value, allowed, path) {
+  for (const key of Object.keys(value)) if (!allowed.has(key)) throw new Error(`${path}: unknown key "${key}"`);
+}
+function resolveBackoff(config, path) {
+  if (config !== void 0) validateKeys(config, BACKOFF_KEYS, path);
+  const initialDelayMs = config?.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+  const maxDelayMs = config?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  const jitterRatio = config?.jitterRatio ?? DEFAULT_JITTER_RATIO;
+  if (!Number.isFinite(initialDelayMs) || initialDelayMs <= 0 || initialDelayMs > MAX_TIMER_DELAY_MS) throw new Error(`${path}.initialDelayMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+  if (!Number.isFinite(maxDelayMs) || maxDelayMs <= 0 || maxDelayMs > MAX_TIMER_DELAY_MS) throw new Error(`${path}.maxDelayMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+  if (initialDelayMs > maxDelayMs) throw new Error(`${path}.initialDelayMs must be less than or equal to maxDelayMs`);
+  if (!Number.isFinite(jitterRatio) || jitterRatio < 0 || jitterRatio > 1) throw new Error(`${path}.jitterRatio must be between 0 and 1`);
+  return Object.freeze({
+    initialDelayMs,
+    maxDelayMs,
+    jitterRatio
+  });
+}
+function resolveRetryPolicy(config, path) {
+  if (config === void 0) return Object.freeze({
+    mode: "normal",
+    maxRetries: DEFAULT_MAX_RETRIES,
+    retryableCodes: DEFAULT_RETRYABLE_CODES,
+    ...resolveBackoff(void 0, `${path}.backoff`)
+  });
+  switch (config.mode) {
+    case "normal": {
+      validateKeys(config, NORMAL_POLICY_KEYS, path);
+      const maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+      const retryableCodes = config.retryableCodes ?? [...DEFAULT_RETRYABLE_CODES];
+      if (!Number.isSafeInteger(maxRetries) || maxRetries < 0) throw new Error(`${path}.maxRetries must be a non-negative safe integer`);
+      if (retryableCodes.length === 0) throw new Error(`${path}.retryableCodes must not be empty`);
+      if (retryableCodes.some((code) => typeof code !== "string" || code.length === 0)) throw new Error(`${path}.retryableCodes must contain only non-empty strings`);
+      if (new Set(retryableCodes).size !== retryableCodes.length) throw new Error(`${path}.retryableCodes must not contain duplicates`);
+      return Object.freeze({
+        mode: "normal",
+        maxRetries,
+        retryableCodes: Object.freeze([...retryableCodes]),
+        ...resolveBackoff(config.backoff, `${path}.backoff`)
+      });
+    }
+    case "always":
+      validateKeys(config, ALWAYS_POLICY_KEYS, path);
+      return Object.freeze({
+        mode: "always",
+        ...resolveBackoff(config.backoff, `${path}.backoff`)
+      });
+    default:
+      throw new Error(`${path}.mode must be "normal" or "always"`);
+  }
+}
+function callConfigEquals(a, b) {
+  if (a.provider !== b.provider || a.model !== b.model || a.reasoningEffort !== b.reasoningEffort || a.temperature !== b.temperature || a.maxTokens !== b.maxTokens) return false;
+  if (a.stop === void 0 || b.stop === void 0) return a.stop === b.stop;
+  return a.stop.length === b.stop.length && a.stop.every((s, i) => s === b.stop?.[i]);
+}
+function normalizeLlmFailure(value) {
+  const error = value instanceof Error ? value : new HarnessError(thrownMessage(value), "UNKNOWN", { cause: value });
+  const carried = ownFailureSnapshot(error);
+  if (carried !== void 0 && carried.code === ownErrorCode(error)) return carried;
+  return Object.freeze({
+    message: errorMessage(error),
+    code: harnessErrorCode(error)
+  });
+}
+function thrownMessage(value) {
+  try {
+    const message = String(value);
+    return message.length > 0 ? message : "LLM adapter failed";
+  } catch (_hostileThrownValue) {
+    return "LLM adapter failed";
+  }
+}
+function ownErrorCode(error) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(error, "code");
+    return descriptor !== void 0 && "value" in descriptor ? descriptor.value : void 0;
+  } catch (_sdkPropertyTrap) {
+    return;
+  }
+}
+function ownFailureSnapshot(error) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(error, "failure");
+    return descriptor !== void 0 && "value" in descriptor ? failureSnapshot(descriptor.value) : void 0;
+  } catch (_sdkPropertyTrap) {
+    return;
+  }
+}
+function failureSnapshot(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  try {
+    const candidate = value;
+    const message = candidate.message;
+    const code = candidate.code;
+    const status = candidate.status;
+    const providerRetryAfterMs = candidate.providerRetryAfterMs;
+    const requestId = candidate.requestId;
+    if (typeof message !== "string" || message.length === 0 || typeof code !== "string" || code.length === 0 || status !== void 0 && (!Number.isInteger(status) || status < 100 || status > 599) || providerRetryAfterMs !== void 0 && (!Number.isFinite(providerRetryAfterMs) || providerRetryAfterMs <= 0) || requestId !== void 0 && (typeof requestId !== "string" || requestId.length === 0)) return void 0;
+    return Object.freeze({
+      message,
+      code,
+      ...status === void 0 ? {} : { status },
+      ...providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs },
+      ...requestId === void 0 ? {} : { requestId }
+    });
+  } catch (_sdkFailureGetter) {
+    return;
+  }
+}
+function errorMessage(error) {
+  try {
+    const message = error.message;
+    if (typeof message === "string" && message.length > 0) return message;
+  } catch (_sdkMessageGetter) {
+  }
+  return "LLM adapter failed";
+}
+function harnessErrorCode(error) {
+  return error instanceof HarnessError ? error.code : "UNKNOWN";
+}
+function quoted(value) {
+  return JSON.stringify(value);
+}
+function textOnlyImageText(ref) {
+  return `[image omitted because this model accepts text only; attachment sha256:${String(ref.attachmentId).slice(7, 15)}]`;
+}
+function contentHasImage(content) {
+  return content.some((block) => block.type === "image" || block.type === "tool-result" && contentHasImage(block.content));
+}
+function contentHasFile(content) {
+  for (const block of content) if (block.type === "file" || block.type === "tool-result" && contentHasFile(block.content)) return true;
+  return false;
+}
+function fileHandleText(ref, readonlyPath) {
+  const digest = String(ref.attachmentId).slice(7, 15);
+  const identity = `File ${quoted(ref.name)} (${ref.bytes} bytes, sha256:${digest})`;
+  if (readonlyPath === void 0) return `[${identity} was uploaded, but the current execution environment cannot access a readable path. Report that limitation if its contents are needed; do not claim to have read it.]`;
+  return `[${identity}: verbatim read-only copy saved at ${quoted(readonlyPath)}. Read that path with your file tools when its contents are needed; copy it to a writable location before modifying it. When delegating file work, include this saved path in the delegation prompt; only subagents sharing this execution environment can read it.]`;
+}
+function replaceFilesWithHandles(blocks, resolvePath) {
+  let next;
+  for (const [index, block] of blocks.entries()) {
+    if (block.type === "file") {
+      next ??= blocks.slice(0, index);
+      next.push({
+        type: "text",
+        text: fileHandleText(block.attachment, resolvePath(block.attachment))
+      });
+      continue;
+    }
+    if (block.type === "tool-result") {
+      const content = replaceFilesWithHandles(block.content, resolvePath);
+      if (content !== block.content) {
+        next ??= blocks.slice(0, index);
+        next.push({
+          ...block,
+          content
+        });
+        continue;
+      }
+    }
+    next?.push(block);
+  }
+  return next ?? blocks;
+}
+function projectFilesToText(messages, resolvePath) {
+  if (!messages.some((message) => contentHasFile(message.content))) return messages;
+  return messages.map((message) => {
+    const content = replaceFilesWithHandles(message.content, resolvePath);
+    return content === message.content ? message : {
+      ...message,
+      content
+    };
+  });
+}
+function replaceImagesForTextModel(blocks) {
+  let next;
+  for (const [index, block] of blocks.entries()) {
+    if (block.type === "image") {
+      next ??= blocks.slice(0, index);
+      next.push({
+        type: "text",
+        text: textOnlyImageText(block.attachment)
+      });
+      continue;
+    }
+    if (block.type === "tool-result") {
+      const content = replaceImagesForTextModel(block.content);
+      if (content !== block.content) {
+        next ??= blocks.slice(0, index);
+        next.push({
+          ...block,
+          content
+        });
+        continue;
+      }
+    }
+    next?.push(block);
+  }
+  return next ?? blocks;
+}
+function projectImagesForTextModel(messages) {
+  if (!messages.some((message) => contentHasImage(message.content))) return messages;
+  return messages.map((message) => {
+    const content = replaceImagesForTextModel(message.content);
+    return content === message.content ? message : {
+      ...message,
+      content
+    };
+  });
+}
+var { version } = createRequire(import.meta.url)("../package.json");
+var __runInitializers = function(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context = {};
+    for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+    context.addInitializer = function(f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? {
+      get: descriptor.get,
+      set: descriptor.set
+    } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+      if (_ = accept(result.get)) descriptor.get = _;
+      if (_ = accept(result.set)) descriptor.set = _;
+      if (_ = accept(result.init)) initializers.unshift(_);
+    } else if (_ = accept(result)) if (kind === "field") initializers.unshift(_);
+    else descriptor[key] = _;
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+};
+var LlmError = class extends HarnessError {
+  /** Serializable facts retained beside this live Error. */
+  failure;
+  /**
+  * @param message - non-empty human-readable failure summary.
+  * @param code - non-empty stable provider-neutral machine code.
+  * @param options - optional cause and validated serializable provider facts.
+  */
+  constructor(message, code, options) {
+    if (typeof message !== "string" || message.length === 0) throw new Error("LlmError message must be a non-empty string");
+    if (typeof code !== "string" || code.length === 0) throw new Error("LlmError code must be a non-empty string");
+    if (options?.status !== void 0 && (!Number.isInteger(options.status) || options.status < 100 || options.status > 599)) throw new Error("LlmError status must be an integer from 100 through 599");
+    if (options?.providerRetryAfterMs !== void 0 && (!Number.isFinite(options.providerRetryAfterMs) || options.providerRetryAfterMs <= 0)) throw new Error("LlmError providerRetryAfterMs must be a positive finite number");
+    if (options?.requestId !== void 0 && (typeof options.requestId !== "string" || options.requestId.length === 0)) throw new Error("LlmError requestId must be a non-empty string");
+    super(message, code, options);
+    this.name = "LlmError";
+    this.failure = Object.freeze({
+      message,
+      code,
+      ...options?.status === void 0 ? {} : { status: options.status },
+      ...options?.providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs: options.providerRetryAfterMs },
+      ...options?.requestId === void 0 ? {} : { requestId: options.requestId }
+    });
+  }
+};
+var LlmRuntime = (() => {
+  let _classSuper = TypertRemoteService;
+  let _instanceExtraInitializers = [];
+  let _listProviders_decorators;
+  let _listConfigurableProviders_decorators;
+  let _remoteDiscoverModels_decorators;
+  return class LlmRuntime extends _classSuper {
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _listProviders_decorators = [Remote];
+      _listConfigurableProviders_decorators = [Remote];
+      _remoteDiscoverModels_decorators = [Remote("discoverModels")];
+      __esDecorate(this, null, _listProviders_decorators, {
+        kind: "method",
+        name: "listProviders",
+        static: false,
+        private: false,
+        access: {
+          has: (obj) => "listProviders" in obj,
+          get: (obj) => obj.listProviders
+        },
+        metadata: _metadata
+      }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _listConfigurableProviders_decorators, {
+        kind: "method",
+        name: "listConfigurableProviders",
+        static: false,
+        private: false,
+        access: {
+          has: (obj) => "listConfigurableProviders" in obj,
+          get: (obj) => obj.listConfigurableProviders
+        },
+        metadata: _metadata
+      }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _remoteDiscoverModels_decorators, {
+        kind: "method",
+        name: "remoteDiscoverModels",
+        static: false,
+        private: false,
+        access: {
+          has: (obj) => "remoteDiscoverModels" in obj,
+          get: (obj) => obj.remoteDiscoverModels
+        },
+        metadata: _metadata
+      }, null, _instanceExtraInitializers);
+      if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: _metadata
+      });
+    }
+    adapters = (__runInitializers(this, _instanceExtraInitializers), /* @__PURE__ */ new Map());
+    directory = /* @__PURE__ */ new Map();
+    discoveries = /* @__PURE__ */ new Map();
+    constructor(ctx) {
+      super(ctx, "llm");
+    }
+    /** Notify topology observers without letting one broken listener veto the commit. */
+    emitAdaptersUpdated() {
+      let invariantFailure;
+      for (const listener of this.ctx.events.dispatch("emit", ["llm/adapters-updated"])) try {
+        const returned = listener();
+        if (returned != null && typeof returned.then === "function") Promise.resolve(returned).then(void 0, (error) => {
+          this.warnAdaptersListenerFailure(error);
+        });
+      } catch (error) {
+        if (error?.code === "INVARIANT") {
+          invariantFailure ??= error;
+          continue;
+        }
+        this.warnAdaptersListenerFailure(error);
+      }
+      if (invariantFailure !== void 0) throw invariantFailure;
+    }
+    /** Contained-listener diagnostic shared by the sync and async failure paths. */
+    warnAdaptersListenerFailure(error) {
+      this.ctx.logger.warn("llm: an llm/adapters-updated listener failed");
+      this.ctx.logger.warn(error);
+    }
+    /**
+    * Register an adapter for the given provider routes. Throws `LlmError` with code
+    * `DUPLICATE_ADAPTER` if any provider already has an adapter (all-or-nothing).
+    * Disposed with the fiber.
+    * @param providers - every provider route this adapter should serve.
+    * @param adapter - the adapter that streams calls for those providers.
+    * @returns the disposer, carrying {@link AdapterRegistrationHandle.replace}.
+    */
+    registerAdapter(providers, adapter) {
+      const owned = /* @__PURE__ */ new Set();
+      let released = false;
+      const dispose = this.ctx.effect(function* () {
+        if (providers.length === 0) throw new LlmError("an adapter must register at least one provider", "INVALID_ADAPTER");
+        this.commitRoutes(owned, this.prepareRoutes(providers, adapter, owned));
+        yield () => {
+          released = true;
+          for (const provider of owned) this.adapters.delete(provider);
+          owned.clear();
+          this.emitAdaptersUpdated();
+        };
+      }.bind(this), "llm.registerAdapter()");
+      const handle = () => void dispose();
+      handle.replace = (next) => {
+        if (released) throw new LlmError("a disposed adapter registration cannot replace its routes", "REGISTRATION_DISPOSED");
+        this.commitRoutes(owned, this.prepareRoutes(next, adapter, owned));
+      };
+      return handle;
+    }
+    /**
+    * Validate one candidate route set for `adapter`, treating routes this
+    * registration already holds as available. Nothing is mutated: a rejected
+    * candidate leaves the registry exactly as it was.
+    */
+    prepareRoutes(providers, adapter, owned) {
+      const unique = /* @__PURE__ */ new Set();
+      const registrations = [];
+      for (const provider of providers) {
+        if (provider.length === 0) throw new LlmError("adapter provider names must be non-empty", "INVALID_ADAPTER");
+        if (unique.has(provider) || this.adapters.has(provider) && !owned.has(provider)) throw new LlmError(`an adapter for provider "${provider}" is already registered`, "DUPLICATE_ADAPTER");
+        const info = adapter.providerInfo(provider);
+        if (typeof info.id !== "string" || info.id !== provider || typeof info.name !== "string" || info.name.length === 0) throw new LlmError(`adapter metadata for provider "${provider}" must preserve its id and have a non-empty name`, "INVALID_ADAPTER");
+        unique.add(provider);
+        const retryPolicy = adapter.providerRetryPolicy(provider) ?? resolveRetryPolicy(void 0, `llm: provider "${provider}" retryPolicy`);
+        registrations.push({
+          adapter,
+          provider: {
+            id: info.id,
+            name: info.name
+          },
+          retryPolicy
+        });
+      }
+      return registrations;
+    }
+    /**
+    * Swap this registration's routes for the prepared ones in one synchronous
+    * section, so no observer can see the registry between the release and the
+    * re-registration. The route set's one mutation point is also where
+    * `llm/adapters-updated` is published, so a `replace` announces itself
+    * exactly like a first registration.
+    */
+    commitRoutes(owned, registrations) {
+      for (const provider of owned) this.adapters.delete(provider);
+      owned.clear();
+      for (const registration of registrations) {
+        this.adapters.set(registration.provider.id, registration);
+        owned.add(registration.provider.id);
+      }
+      this.emitAdaptersUpdated();
+    }
+    /**
+    * Describe provider routes with a registered adapter.
+    * @returns detached provider metadata in registration order.
+    */
+    listProviders() {
+      return [...this.adapters.values()].map(({ provider }) => ({ ...provider }));
+    }
+    /**
+    * Declare provider routes an adapter plugin can activate through
+    * configuration. Registration is all-or-nothing: an empty list, invalid
+    * entry, or a provider already declared by any registration throws
+    * `LlmError` without registering the rest. Disposed with the fiber.
+    * @param entries - every configurable provider this plugin owns.
+    * @returns a handle that withdraws all of them, and can atomically replace them.
+    */
+    registerConfigurableProviders(entries) {
+      let held = [];
+      let disposed = false;
+      const commit = (candidates) => {
+        const detached = [];
+        const own = new Set(held.map((entry) => entry.provider));
+        for (const entry of candidates) {
+          if (entry.provider.length === 0 || entry.displayName.length === 0 || entry.settingsNs.length === 0) throw new LlmError("configurable providers need a non-empty provider, displayName, and settingsNs", "INVALID_DIRECTORY");
+          if (entry.settingsPath.some((segment) => segment.length === 0)) throw new LlmError(`configurable provider "${entry.provider}" has an empty settingsPath segment`, "INVALID_DIRECTORY");
+          if (this.directory.has(entry.provider) && !own.has(entry.provider) || detached.some((seen) => seen.provider === entry.provider)) throw new LlmError(`configurable provider "${entry.provider}" is already declared`, "DUPLICATE_DIRECTORY");
+          detached.push({
+            ...entry,
+            settingsPath: [...entry.settingsPath]
+          });
+        }
+        for (const entry of held) this.directory.delete(entry.provider);
+        for (const entry of detached) this.directory.set(entry.provider, entry);
+        held = detached;
+        this.emitAdaptersUpdated();
+      };
+      const dispose = this.ctx.effect(function* () {
+        if (entries.length === 0) throw new LlmError("a configurable-provider registration must declare at least one provider", "INVALID_DIRECTORY");
+        commit(entries);
+        yield () => {
+          disposed = true;
+          for (const entry of held) this.directory.delete(entry.provider);
+          held = [];
+          this.emitAdaptersUpdated();
+        };
+      }.bind(this), "llm.registerConfigurableProviders()");
+      const handle = () => void dispose();
+      handle.replace = (next) => {
+        if (disposed) throw new LlmError("this configurable-provider registration was disposed", "REGISTRATION_DISPOSED");
+        commit(next);
+      };
+      return handle;
+    }
+    /**
+    * List every declared configurable provider, registered or dormant.
+    * @returns detached directory entries in declaration order.
+    */
+    listConfigurableProviders() {
+      return [...this.directory.values()].map((entry) => ({
+        ...entry,
+        settingsPath: [...entry.settingsPath]
+      }));
+    }
+    /**
+    * Offer to interrogate provider endpoints on behalf of the settings
+    * namespace this plugin owns. The namespace is the key because that is what
+    * a configuration surface already holds from the configurable-provider
+    * directory, and because a provider being *added* has no route to name yet.
+    * Disposed with the fiber.
+    * @param settingsNs - the namespace whose profiles this discovery serves.
+    * @param discover - interrogates one endpoint and must honor the supplied signal.
+    * @returns the disposer that withdraws the offer.
+    */
+    registerModelDiscovery(settingsNs, discover) {
+      const dispose = this.ctx.effect(function* () {
+        if (settingsNs.length === 0) throw new LlmError("model discovery needs a non-empty settings namespace", "INVALID_DISCOVERY");
+        if (this.discoveries.has(settingsNs)) throw new LlmError(`model discovery for "${settingsNs}" is already registered`, "DUPLICATE_DISCOVERY");
+        this.discoveries.set(settingsNs, discover);
+        yield () => {
+          this.discoveries.delete(settingsNs);
+        };
+      }.bind(this), "llm.registerModelDiscovery()");
+      return () => void dispose();
+    }
+    /**
+    * Interrogate one provider endpoint for the models it advertises. The
+    * request describes a draft, not a stored route, so nothing here reads or
+    * writes settings or credentials — the caller owns both, and the reply is
+    * candidate metadata a surface may offer for adoption.
+    * @param settingsNs - namespace whose registered discovery serves this draft.
+    * @param request - the endpoint, protocol, and one-shot credential to use.
+    * @param signal - caller cancellation.
+    * @returns the advertised models, deduplicated in endpoint order.
+    */
+    async discoverModels(settingsNs, request, signal) {
+      const discover = this.discoveries.get(settingsNs);
+      if (discover === void 0) throw new LlmError(`no model discovery is registered for "${settingsNs}"`, "NO_DISCOVERY");
+      if ((request.provider ?? "").length === 0 && (request.baseURL ?? "").length === 0) throw new LlmError("model discovery needs a provider route or a baseURL", "INVALID_DISCOVERY");
+      const discovered = signal === void 0 ? await discover(request) : await discover(request, signal);
+      const seen = /* @__PURE__ */ new Set();
+      const models = [];
+      for (const model of discovered) {
+        if (typeof model.id !== "string" || model.id.length === 0 || seen.has(model.id)) continue;
+        seen.add(model.id);
+        models.push({
+          id: model.id,
+          ...model.name === void 0 ? {} : { name: model.name },
+          ...model.contextWindow === void 0 ? {} : { contextWindow: model.contextWindow },
+          ...model.maxTokens === void 0 ? {} : { maxTokens: model.maxTokens }
+        });
+      }
+      return models;
+    }
+    /**
+    * Remote adapter for one draft provider interrogation.
+    * @param settingsNs - namespace whose registered discovery serves this draft.
+    * @param request - endpoint, protocol, and one-shot credential to use.
+    * @param signal - caller cancellation supplied by the Remote carrier.
+    * @returns advertised models in endpoint order.
+    * @throws RemoteError with `llm/model-discovery-rejected` when discovery refuses or fails.
+    */
+    async remoteDiscoverModels(settingsNs, request, signal) {
+      try {
+        return await this.discoverModels(settingsNs, request, signal);
+      } catch (error) {
+        throw new RemoteError("llm/model-discovery-rejected", error instanceof Error ? error.message : String(error), {
+          settingsNs,
+          ...request.baseURL === void 0 ? {} : { baseURL: request.baseURL }
+        }, { cause: error });
+      }
+    }
+    /**
+    * Resolve the retry policy captured when one provider route was registered.
+    * @param provider - registered provider route to inspect.
+    * @returns the provider-owned policy, with normal defaults already resolved.
+    */
+    providerRetryPolicy(provider) {
+      return this.registration(provider).retryPolicy;
+    }
+    /**
+    * Resolve provider-side request-image pricing for one exact route, or
+    * `undefined` when the provider is unregistered or declares none. Unknown
+    * providers degrade to `undefined` rather than throwing because callers
+    * price durable history whose route may no longer be mounted.
+    * @param provider - provider route named by a request header.
+    * @param model - exact model id named by the same header.
+    * @returns the owning adapter's image pricing for the route, when declared.
+    */
+    imageRequestPricing(provider, model) {
+      return this.adapters.get(provider)?.adapter.imageRequestPricing(provider, model);
+    }
+    /**
+    * Resolve the exact text one durable file occurrence contributes to every
+    * provider request in the current execution environment.
+    * @param ref - durable verbatim file reference from model history.
+    * @returns the same deterministic handle text used at adapter dispatch.
+    */
+    fileRequestText(ref) {
+      return fileHandleText(ref, this.fileReadPath(ref));
+    }
+    /** Detach typed adapter-owned modality metadata. */
+    detachedModalities(modalities) {
+      return modalities === void 0 ? void 0 : [...modalities];
+    }
+    /**
+    * Discover models advertised by one registered provider. Catalog membership
+    * is advisory and never changes routing or request validation.
+    * @param provider - registered provider route to inspect.
+    * @returns detached model metadata in adapter-preferred order.
+    */
+    async listModels(provider) {
+      const models = await this.registration(provider).adapter.listModels(provider);
+      const seen = /* @__PURE__ */ new Set();
+      return models.map((model) => {
+        if (typeof model.provider !== "string" || model.provider !== provider || typeof model.id !== "string" || model.id.length === 0 || typeof model.name !== "string" || model.name.length === 0 || model.description !== void 0 && typeof model.description !== "string" || seen.has(model.id)) throw new LlmError(`adapter returned invalid or duplicate model metadata for provider "${provider}"`, "INVALID_CATALOG");
+        seen.add(model.id);
+        const inputModalities = this.detachedModalities(model.inputModalities);
+        return {
+          provider: model.provider,
+          id: model.id,
+          name: model.name,
+          ...model.description === void 0 ? {} : { description: model.description },
+          ...inputModalities === void 0 ? {} : { inputModalities }
+        };
+      });
+    }
+    /**
+    * Resolve and validate all metadata from the adapter that owns one exact
+    * route. The result is detached from adapter-owned objects; catalog
+    * membership remains advisory and does not control request routing.
+    * @param provider - registered provider route to inspect.
+    * @param model - exact model id passed to the adapter.
+    * @param signal - optional cancellation for adapter-owned asynchronous lookup.
+    * @returns exact model identity plus available context and reasoning metadata.
+    */
+    async resolveModelInfo(provider, model, signal) {
+      return this.resolveModelInfoFor(this.registration(provider), model, signal);
+    }
+    async resolveModelInfoFor(registration, model, signal) {
+      const resolved = await registration.adapter.resolveModel(registration.provider.id, model, signal);
+      return this.normalizeModelInfo(registration, model, resolved);
+    }
+    /** Validate and detach one adapter-returned exact model result. */
+    normalizeModelInfo(registration, model, resolved) {
+      const provider = registration.provider.id;
+      if (typeof resolved.provider !== "string" || resolved.provider !== provider || typeof resolved.id !== "string" || resolved.id !== model || typeof resolved.name !== "string" || resolved.name.length === 0 || resolved.description !== void 0 && typeof resolved.description !== "string") throw new LlmError(`adapter returned invalid exact model metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_INFO");
+      const context = resolved.context;
+      if (context !== void 0 && (!Number.isInteger(context.contextWindow) || context.contextWindow <= 0)) throw new LlmError(`adapter returned invalid context metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_CONTEXT");
+      const inputModalities = this.detachedModalities(resolved.inputModalities);
+      const systemPromptUpdate = resolved.systemPromptUpdate;
+      if (systemPromptUpdate !== void 0 && systemPromptUpdate !== "in-history") throw new LlmError(`adapter returned invalid system prompt update mode for provider "${provider}" model "${model}"`, "INVALID_MODEL_INFO");
+      const defaultMaxTokens = resolved.defaultMaxTokens;
+      if (defaultMaxTokens !== void 0 && (!Number.isSafeInteger(defaultMaxTokens) || defaultMaxTokens <= 0)) throw new LlmError(`adapter returned invalid default maxTokens for provider "${provider}" model "${model}"`, "INVALID_MODEL_MAX_TOKENS");
+      const info = {
+        provider,
+        id: model,
+        name: resolved.name,
+        ...resolved.description === void 0 ? {} : { description: resolved.description },
+        ...inputModalities === void 0 ? {} : { inputModalities },
+        ...context === void 0 ? {} : { context: { contextWindow: context.contextWindow } },
+        ...defaultMaxTokens === void 0 ? {} : { defaultMaxTokens },
+        ...resolved.systemPromptUpdate === void 0 ? {} : { systemPromptUpdate: resolved.systemPromptUpdate }
+      };
+      const reasoning = resolved.reasoning;
+      if (reasoning === void 0) return info;
+      if (reasoning.efforts.length === 0) throw new LlmError(`adapter returned invalid reasoning metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_REASONING");
+      const seen = /* @__PURE__ */ new Set();
+      const efforts = reasoning.efforts.map((effort) => {
+        if (typeof effort.id !== "string" || effort.id.length === 0 || typeof effort.name !== "string" || effort.name.length === 0 || effort.description !== void 0 && typeof effort.description !== "string" || seen.has(effort.id)) throw new LlmError(`adapter returned invalid or duplicate reasoning effort metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_REASONING");
+        seen.add(effort.id);
+        return {
+          id: effort.id,
+          name: effort.name,
+          ...effort.description === void 0 ? {} : { description: effort.description }
+        };
+      });
+      if (reasoning.defaultEffort !== void 0 && !seen.has(reasoning.defaultEffort)) throw new LlmError(`adapter returned an unknown default reasoning effort for provider "${provider}" model "${model}"`, "INVALID_MODEL_REASONING");
+      return {
+        ...info,
+        reasoning: {
+          efforts,
+          ...reasoning.defaultEffort === void 0 ? {} : { defaultEffort: reasoning.defaultEffort }
+        }
+      };
+    }
+    /**
+    * Validate a conversation call config against its exact model capability and
+    * materialize adapter-configured defaults. Unsupported explicit efforts
+    * reject before provider I/O; no clamping or aliasing is performed. This
+    * standalone query does not bind a later dispatch; use {@link prepareCall}
+    * when logging and streaming must share one adapter registration.
+    * @param config - provider/model route and optional request controls.
+    * @param signal - optional cancellation for adapter-owned capability lookup.
+    * @returns a detached config only when a default must be materialized.
+    */
+    async resolveCallConfig(config, signal) {
+      return (await this.resolveCallFor(this.registration(config.provider), config, signal)).config;
+    }
+    async resolveCallFor(registration, config, signal) {
+      const info = await this.resolveModelInfoFor(registration, config.model, signal);
+      return this.resolveCallWithInfo(config, info);
+    }
+    /** Validate request controls against one already-bound exact model result. */
+    resolveCallWithInfo(config, info) {
+      const defaulted = config.maxTokens === void 0 && info.defaultMaxTokens !== void 0 ? {
+        ...config,
+        maxTokens: info.defaultMaxTokens
+      } : config;
+      const reasoning = info.reasoning;
+      const requested = defaulted.reasoningEffort;
+      let resolvedConfig = defaulted;
+      if (reasoning === void 0) {
+        if (requested !== void 0) throw new LlmError(`provider "${config.provider}" model "${config.model}" does not support reasoning effort "${requested}"`, "UNSUPPORTED_REASONING_EFFORT");
+      } else {
+        const effective = requested ?? reasoning.defaultEffort;
+        if (effective !== void 0) {
+          if (!reasoning.efforts.some((effort) => effort.id === effective)) throw new LlmError(`provider "${config.provider}" model "${config.model}" does not support reasoning effort "${effective}"`, "UNSUPPORTED_REASONING_EFFORT");
+          if (requested !== effective) resolvedConfig = {
+            ...defaulted,
+            reasoningEffort: effective
+          };
+        }
+      }
+      return {
+        config: resolvedConfig,
+        ...info.context === void 0 ? {} : { context: info.context },
+        modelInfo: info
+      };
+    }
+    /**
+    * Resolve one call under its current adapter registration. The returned
+    * one-shot handle keeps that registration across header logging and dispatch,
+    * so HMR cannot combine one adapter's capability result with another adapter.
+    * @param config - provider/model route and optional request controls.
+    * @param signal - optional cancellation for adapter-owned capability lookup.
+    * @returns a prepared config and its registration-bound stream entry point.
+    */
+    async prepareCall(config, signal) {
+      const registration = this.registration(config.provider);
+      const adapterCall = await registration.adapter.prepareCall(config.provider, config.model, signal);
+      const modelInfo = this.normalizeModelInfo(registration, config.model, adapterCall.model);
+      const resolved = this.resolveCallWithInfo(config, modelInfo);
+      const resolvedConfig = deepFreeze(structuredClone(resolved.config));
+      const context = resolved.context === void 0 ? void 0 : deepFreeze(structuredClone(resolved.context));
+      const adapterDefaults = deepFreeze({
+        ...config.reasoningEffort === void 0 && resolvedConfig.reasoningEffort !== void 0 ? { reasoningEffort: true } : {},
+        ...config.maxTokens === void 0 && resolvedConfig.maxTokens !== void 0 ? { maxTokens: true } : {}
+      });
+      let dispatched = false;
+      return Object.freeze({
+        config: resolvedConfig,
+        retryPolicy: registration.retryPolicy,
+        adapterDefaults,
+        ...context === void 0 ? {} : { context },
+        ...modelInfo.inputModalities === void 0 ? {} : { inputModalities: Object.freeze([...modelInfo.inputModalities]) },
+        ...modelInfo.systemPromptUpdate === void 0 ? {} : { systemPromptUpdate: modelInfo.systemPromptUpdate },
+        stream: (options) => {
+          if (dispatched) throw new LlmError("a prepared LLM call can only be dispatched once", "INVALID_PREPARED_CALL");
+          if (!callConfigEquals(options, resolvedConfig)) throw new LlmError("prepared LLM call config changed before adapter dispatch", "INVALID_PREPARED_CALL");
+          dispatched = true;
+          return this.streamWithRegistration(options, {
+            registration,
+            config: resolvedConfig,
+            modelInfo,
+            dispatch: (options2) => adapterCall.stream(options2)
+          });
+        }
+      });
+    }
+    registration(provider) {
+      const registration = this.adapters.get(provider);
+      if (!registration) throw new LlmError(`no adapter registered for provider "${provider}"`, "NO_ADAPTER");
+      return registration;
+    }
+    /** Remove replay state whose historical route is owned by another adapter. */
+    forAdapter(options, adapter) {
+      const messages = options.messages.map((message) => {
+        const source = message.source;
+        if (message.role !== "assistant" || source.kind !== "model" || source.replayState === void 0) return message;
+        if (this.adapters.get(source.provider)?.adapter === adapter) return message;
+        return freezeMessage({
+          ...message,
+          source: {
+            kind: "model",
+            provider: source.provider,
+            model: source.model
+          }
+        });
+      });
+      if (messages.every((message, index) => message === options.messages[index])) return options;
+      const filtered = {
+        ...options,
+        messages
+      };
+      return Object.isFrozen(options) ? deepFreeze(filtered) : filtered;
+    }
+    /**
+    * Resolve the current execution-world read path of one durable file
+    * reference through the mounted attachment and filesystem providers.
+    */
+    fileReadPath(ref) {
+      let hostPath;
+      try {
+        hostPath = this.ctx.get("attachments")?.fileHostPath(ref);
+      } catch {
+        return;
+      }
+      if (hostPath === void 0) return void 0;
+      return this.ctx.get("fs")?.processPathFromHostPath(hostPath);
+    }
+    /**
+    * Final adapter boundary. Adapter selection, dispatch, iterator construction,
+    * and iteration failures become one terminal failure chunk. Middleware and
+    * downstream consumer failures remain thrown plugin or consumer errors.
+    */
+    async *adapterStream(options, prepared) {
+      let iterator;
+      try {
+        const registration = prepared?.registration ?? this.registration(options.provider);
+        const adapter = registration.adapter;
+        let modelInfo;
+        let resolvedConfig;
+        let dispatch;
+        if (prepared === void 0) {
+          const adapterCall = await adapter.prepareCall(options.provider, options.model, options.signal);
+          modelInfo = this.normalizeModelInfo(registration, options.model, adapterCall.model);
+          resolvedConfig = this.resolveCallWithInfo(options, modelInfo).config;
+          dispatch = (options2) => adapterCall.stream(options2);
+        } else {
+          modelInfo = prepared.modelInfo;
+          resolvedConfig = prepared.config;
+          dispatch = prepared.dispatch;
+        }
+        if (prepared !== void 0 && !callConfigEquals(options, resolvedConfig)) throw new LlmError("prepared LLM call config changed before adapter dispatch", "INVALID_PREPARED_CALL");
+        const resolvedOptions = callConfigEquals(options, resolvedConfig) ? options : Object.isFrozen(options) ? deepFreeze({
+          ...options,
+          ...resolvedConfig
+        }) : {
+          ...options,
+          ...resolvedConfig
+        };
+        let projectedMessages = resolvedOptions.messages;
+        if (projectedMessages.some((message) => contentHasFile(message.content))) projectedMessages = projectFilesToText(projectedMessages, (ref) => this.fileReadPath(ref));
+        if (modelInfo.inputModalities !== void 0 && !modelInfo.inputModalities.includes("image") && projectedMessages.some((message) => contentHasImage(message.content))) projectedMessages = projectImagesForTextModel(projectedMessages);
+        const projectedOptions = projectedMessages === resolvedOptions.messages ? resolvedOptions : Object.isFrozen(resolvedOptions) ? deepFreeze({
+          ...resolvedOptions,
+          messages: projectedMessages
+        }) : {
+          ...resolvedOptions,
+          messages: projectedMessages
+        };
+        iterator = dispatch(this.forAdapter(projectedOptions, adapter))[Symbol.asyncIterator]();
+      } catch (error) {
+        yield adapterFailureChunk(error, options.signal);
+        return;
+      }
+      let completed = false;
+      try {
+        while (true) {
+          let item;
+          try {
+            const next = await iterator.next();
+            item = next.done ? { done: true } : {
+              done: false,
+              value: next.value
+            };
+          } catch (error) {
+            completed = true;
+            yield adapterFailureChunk(error, options.signal);
+            return;
+          }
+          if (item.done) {
+            completed = true;
+            return;
+          }
+          yield item.value;
+        }
+      } finally {
+        if (!completed) {
+          const close = iterator.return?.bind(iterator);
+          if (close) await close();
+        }
+      }
+    }
+    /**
+    * Stream one model call as raw chunks (token-level deltas). Replay state is
+    * retained only when the same adapter instance owns its historical provider
+    * and the target provider. Final adapter selection remains fixed through
+    * asynchronous exact-model resolution and dispatch. Adapter selection,
+    * dispatch, and iteration failures become terminal `error` or `aborted`
+    * finish chunks; middleware, nested-call, cleanup, and consumer failures
+    * remain thrown.
+    * @param options - the full request; `options.provider` selects the adapter.
+    * @returns the chunk stream, possibly wrapped by `llm/stream` listeners.
+    */
+    stream(options) {
+      return this.streamWithRegistration(options);
+    }
+    streamWithRegistration(options, prepared) {
+      return this.ctx.waterfall(this, "llm/stream", options, () => this.adapterStream(options, prepared));
+    }
+  };
+})();
+function adapterFailureChunk(error, signal) {
+  const failure12 = normalizeLlmFailure(error);
+  return {
+    type: "finish",
+    reason: signal?.aborted || failure12.code === "ABORTED" ? {
+      kind: "aborted",
+      failure: failure12
+    } : {
+      kind: "error",
+      failure: failure12
+    }
+  };
+}
+
+// node_modules/.pnpm/@deepseek-ai+dsh-web@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2_@deepseek-ai+dsh-llm@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2_/node_modules/@deepseek-ai/dsh-web/lib/index.js
+var WebError = class extends HarnessError {
+};
+var WebRuntime = class extends Service {
+  /**
+  * Provider selection config. Operational env overrides feed the SAME fields:
+  * `$DSH_WEB_SEARCH_PROVIDER` / `$DSH_WEB_FETCH_PROVIDER` are equivalent to
+  * `searchProvider` / `fetchProvider` and are NOT a hidden priority chain.
+  */
+  static Config = Schema.object({
+    searchProvider: Schema.string(),
+    fetchProvider: Schema.string()
+  });
+  searchProviders = /* @__PURE__ */ new Map();
+  fetchProviders = /* @__PURE__ */ new Map();
+  searchProviderId;
+  fetchProviderId;
+  constructor(ctx, config = {}) {
+    super(ctx, "web");
+    this.searchProviderId = config.searchProvider ?? process.env.DSH_WEB_SEARCH_PROVIDER;
+    this.fetchProviderId = config.fetchProvider ?? process.env.DSH_WEB_FETCH_PROVIDER;
+  }
+  /**
+  * Register a search provider. Throws {@link WebError} `WEB_DUPLICATE_PROVIDER`
+  * if its id is already registered for search. Returns a disposer; disposed
+  * with the calling fiber.
+  * @param provider - the provider; its `id` is the registry key.
+  * @returns the disposer that unregisters the provider.
+  */
+  registerSearchProvider(provider) {
+    return this.registerProvider(this.searchProviders, provider);
+  }
+  /**
+  * Register a fetch provider. Throws {@link WebError} `WEB_DUPLICATE_PROVIDER`
+  * if its id is already registered for fetch. Returns a disposer; disposed
+  * with the calling fiber.
+  * @param provider - the provider; its `id` is the registry key.
+  * @returns the disposer that unregisters the provider.
+  */
+  registerFetchProvider(provider) {
+    return this.registerProvider(this.fetchProviders, provider);
+  }
+  registerProvider(store, provider) {
+    if (store.has(provider.id)) throw new WebError(`a web provider with id "${provider.id}" is already registered`, "WEB_DUPLICATE_PROVIDER");
+    const dispose = this.ctx.effect(function* () {
+      store.set(provider.id, provider);
+      yield () => store.delete(provider.id);
+    }, "web.registerProvider()");
+    return () => void dispose();
+  }
+  /**
+  * Run one search through the selected provider. Resolves the provider at call
+  * time with the selection rules above; throws {@link WebError} when the
+  * capability cannot run. The seam enforces `request.maxResults` on the result:
+  * if the provider over-returns, `sources[]` is truncated and `truncated` set.
+  * @param request - the query and optional result limit.
+  * @param signal - optional cancellation signal forwarded to the provider.
+  * @returns the provider's results, capped to `request.maxResults`.
+  */
+  async search(request, signal) {
+    return capSources(await resolveProvider({
+      providers: this.searchProviders,
+      ...this.searchProviderId !== void 0 ? { configuredId: this.searchProviderId } : {}
+    }).search(request, signal), request.maxResults);
+  }
+  /**
+  * Retrieve one URL through the selected provider. Resolves the provider at
+  * call time with the selection rules above; throws {@link WebError} when the
+  * capability cannot run. A non-2xx response is a result, not a throw.
+  * @param request - the URL plus retrieval options.
+  * @param signal - optional cancellation signal forwarded to the provider.
+  * @returns the retrieval outcome; non-2xx responses resolve descriptively.
+  */
+  async fetch(request, signal) {
+    return resolveProvider({
+      providers: this.fetchProviders,
+      ...this.fetchProviderId !== void 0 ? { configuredId: this.fetchProviderId } : {}
+    }).fetch(request, signal);
+  }
+};
+function resolveProvider(selection) {
+  const { configuredId, providers } = selection;
+  if (configuredId !== void 0) {
+    const provider = providers.get(configuredId);
+    if (!provider) throw new WebError(`configured web provider "${configuredId}" is not registered`, "WEB_PROVIDER_CONFIGURED_MISSING");
+    if (!provider.available()) throw new WebError(`configured web provider "${configuredId}" is registered but unavailable`, "WEB_PROVIDER_CONFIGURED_UNAVAILABLE");
+    return provider;
+  }
+  const usable = [...providers.values()].filter((provider) => provider.available());
+  const [single] = usable;
+  if (single === void 0) throw new WebError("no usable web provider is registered", "WEB_PROVIDER_UNAVAILABLE");
+  if (usable.length > 1) throw new WebError(`multiple usable web providers are registered (${usable.map((provider) => provider.id).join(", ")}); configure one explicitly`, "WEB_PROVIDER_AMBIGUOUS");
+  return single;
+}
+function capSources(result, maxResults) {
+  if (maxResults === void 0 || result.sources.length <= maxResults) return result;
+  return {
+    ...result,
+    sources: result.sources.slice(0, maxResults),
+    truncated: true
+  };
+}
+
+// src/web-search.ts
+var HIWORK_SEARCH_PROVIDER_ID = "hiwork-managed-search";
+var ME_WEB_SEARCH_PATH = "/api/me/web-search";
+var WEB_SEARCH_TIMEOUT_MS = 12e3;
+var HiworkSearchProvider = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  id = HIWORK_SEARCH_PROVIDER_ID;
+  available() {
+    return true;
+  }
+  async search(request, signal) {
+    if (signal?.aborted) throw aborted();
+    let sessionCookie;
+    try {
+      sessionCookie = await this.deps.resolveSession();
+    } catch (error) {
+      this.deps.log?.(`hiwork-core: \u8054\u7F51\u641C\u7D22\u4F1A\u8BDD\u89E3\u6790\u5931\u8D25\uFF08${errorName4(error)}\uFF09`);
+      throw new WebError("\u8054\u7F51\u641C\u7D22\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", HIWORK_SEARCH_UNREACHABLE, { cause: error });
+    }
+    if (sessionCookie === void 0 || sessionCookie === "") {
+      throw new WebError("\u767B\u5F55\u540E\u624D\u80FD\u4F7F\u7528\u8054\u7F51\u641C\u7D22", HIWORK_SEARCH_UNAUTHENTICATED);
+    }
+    const gateway = this.deps.gateway();
+    if (gateway === void 0) {
+      throw new WebError("\u8054\u7F51\u641C\u7D22\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", HIWORK_SEARCH_UNREACHABLE);
+    }
+    const outcome = await gateway.searchWeb(
+      sessionCookie,
+      // maxResults 是 tool-web 传进来的上限，透传给网关少拉数据（费用按次不按条，
+      // 但少拉条数能压响应体）。seam 仍会在结果侧强制截断，这里只是配合。
+      { query: request.query, ...request.maxResults !== void 0 ? { max_results: request.maxResults } : {} },
+      signal
+    );
+    if (!outcome.ok) {
+      throw outcomeToError(outcome);
+    }
+    const view = projectWebSearch(outcome.body);
+    if (view === void 0) {
+      this.deps.log?.("hiwork-core: \u7F51\u5173\u8FD4\u56DE\u7684 web-search \u54CD\u5E94\u4E0D\u7B26\u5408\u5951\u7EA6\uFF08results \u7F3A\u5931\u6216\u5F62\u72B6\u4E0D\u5BF9\uFF09");
+      throw new WebError("\u8054\u7F51\u641C\u7D22\u8FD4\u56DE\u4E86\u65E0\u6CD5\u89E3\u6790\u7684\u7ED3\u679C", "WEB_PROVIDER_ERROR");
+    }
+    return view;
+  }
+};
+var HIWORK_SEARCH_UNAUTHENTICATED = "HIWORK_SEARCH_UNAUTHENTICATED";
+var HIWORK_SEARCH_DISABLED = "HIWORK_SEARCH_DISABLED";
+var HIWORK_SEARCH_NOT_CONFIGURED = "HIWORK_SEARCH_NOT_CONFIGURED";
+var HIWORK_SEARCH_LIMIT = "HIWORK_SEARCH_LIMIT";
+var HIWORK_SEARCH_UNREACHABLE = "HIWORK_SEARCH_UNREACHABLE";
+var HIWORK_SEARCH_UPSTREAM = "HIWORK_SEARCH_UPSTREAM";
+function aborted() {
+  return new WebError("\u8054\u7F51\u641C\u7D22\u5DF2\u53D6\u6D88", "WEB_ABORTED");
+}
+function outcomeToError(outcome) {
+  switch (outcome.kind) {
+    case "aborted":
+      return aborted();
+    case "network":
+      return new WebError("\u8054\u7F51\u641C\u7D22\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", HIWORK_SEARCH_UNREACHABLE);
+    case "invalid":
+      return new WebError("\u8054\u7F51\u641C\u7D22\u8FD4\u56DE\u4E86\u65E0\u6CD5\u89E3\u6790\u7684\u7ED3\u679C", "WEB_PROVIDER_ERROR");
+    case "http":
+      return httpOutcomeToError(outcome.status, outcome.code);
+  }
+}
+function httpOutcomeToError(status, code) {
+  if (status === 401) return new WebError("\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55", HIWORK_SEARCH_UNAUTHENTICATED);
+  if (code === "SEARCH_DISABLED") return new WebError("\u7BA1\u7406\u5458\u8FD8\u6CA1\u5F00\u542F\u8054\u7F51\u641C\u7D22", HIWORK_SEARCH_DISABLED);
+  if (code === "SEARCH_NOT_CONFIGURED") return new WebError("\u8054\u7F51\u641C\u7D22\u8FD8\u6CA1\u6709\u914D\u7F6E\u597D\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458", HIWORK_SEARCH_NOT_CONFIGURED);
+  if (status === 429 || code === "SEARCH_LIMIT_EXCEEDED") return new WebError("\u4ECA\u5929\u7684\u8054\u7F51\u641C\u7D22\u6B21\u6570\u5DF2\u7528\u5B8C\uFF0C\u660E\u5929\u518D\u6765", HIWORK_SEARCH_LIMIT);
+  if (status === 502 || code === "SEARCH_UPSTREAM_ERROR") return new WebError("\u641C\u7D22\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", HIWORK_SEARCH_UPSTREAM);
+  return new WebError("\u8054\u7F51\u641C\u7D22\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", "WEB_PROVIDER_ERROR");
+}
+function textOrUndefined8(value) {
+  if (typeof value !== "string") return void 0;
+  const text = value.trim();
+  return text === "" ? void 0 : text;
+}
+function projectWebSearch(body) {
+  const raw = body["results"];
+  if (!Array.isArray(raw)) return void 0;
+  const sources = [];
+  for (const item of raw) {
+    if (item === null || typeof item !== "object") continue;
+    const record = item;
+    const url = textOrUndefined8(record["url"]);
+    if (url === void 0) continue;
+    const title = textOrUndefined8(record["title"]);
+    const snippet = textOrUndefined8(record["snippet"]) ?? textOrUndefined8(record["content"]);
+    const publishedAt = textOrUndefined8(record["published_at"]);
+    sources.push({
+      url,
+      ...title !== void 0 ? { title } : {},
+      ...snippet !== void 0 ? { snippet } : {},
+      ...publishedAt !== void 0 ? { publishedAt } : {}
+    });
+  }
+  return { sources, truncated: false };
+}
+function errorName4(error) {
+  return error instanceof Error ? error.name : typeof error;
+}
+function createWebSearchGateway(baseURL, opts = {}) {
+  const root = baseURL.replace(/\/+$/, "");
+  const timeoutMs = opts.timeoutMs ?? WEB_SEARCH_TIMEOUT_MS;
+  const doFetch = opts.fetchImpl ?? fetch;
+  return {
+    async searchWeb(sessionCookie, body, signal) {
+      const signals = [AbortSignal.timeout(timeoutMs)];
+      if (signal !== void 0) signals.push(signal);
+      const merged = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+      let res;
+      try {
+        res = await doFetch(`${root}${ME_WEB_SEARCH_PATH}`, {
+          method: "POST",
+          headers: {
+            "user-agent": `hiwork-core/${PKG_VERSION}`,
+            cookie: sessionCookie,
+            "content-type": "application/json"
+          },
+          body: JSON.stringify(body),
+          signal: merged
+        });
+      } catch (error) {
+        if (signal?.aborted) return { ok: false, kind: "aborted" };
+        return { ok: false, kind: "network" };
+      }
+      if (!res.ok) {
+        let code;
+        try {
+          const parsed2 = await res.json();
+          if (typeof parsed2?.code === "string" && parsed2.code !== "") code = parsed2.code;
+        } catch {
+        }
+        return { ok: false, kind: "http", status: res.status, ...code !== void 0 ? { code } : {} };
+      }
+      let parsed;
+      try {
+        parsed = await res.json();
+      } catch {
+        return { ok: false, kind: "invalid" };
+      }
+      if (parsed === null || typeof parsed !== "object") return { ok: false, kind: "invalid" };
+      return { ok: true, body: parsed };
+    }
+  };
+}
+function registerManagedSearchProvider(web, deps) {
+  return web.registerSearchProvider(new HiworkSearchProvider(deps));
+}
+
+// src/index.ts
+var name = "hiwork-core";
+var inject = ["settings", "credentials", "workspaceRegistry", "connection", "web"];
+var NS = "ai-router";
+var PI_AI_NS = "llm-pi-ai";
+var lastErrorSchema = Schema.object({ code: Schema.string().required(), message: Schema.string().required() }).default(void 0);
+var Config = Schema.object({
+  baseURL: Schema.string(),
+  keyId: Schema.string(),
+  username: Schema.string(),
+  displayName: Schema.string(),
+  lastLogin: Schema.object({ at: Schema.string().required(), modelCount: Schema.number().required(), gatewayName: Schema.string().required() }).default(void 0),
+  lastError: lastErrorSchema,
+  pendingLogin: Schema.object({ username: Schema.string().required(), passwordRef: Schema.string().required() }).default(void 0),
+  rememberPassword: Schema.boolean().default(false),
+  refreshRequest: Schema.object({ at: Schema.string().required() }).default(void 0),
+  logoutRequest: Schema.object({ at: Schema.string().required() }).default(void 0),
+  browserLoginRequest: Schema.object({ at: Schema.string().required() }).default(void 0),
+  browserLogin: Schema.object({ authorizeUrl: Schema.string().required(), startedAt: Schema.string().required() }).default(void 0),
+  // 三值枚举：非法值写入直接被 schema 拒绝（客户端还会再归一一次，双保险）。
+  loginMode: Schema.union([Schema.const("browser"), Schema.const("form"), Schema.const("both")]),
+  passwordLogin: Schema.boolean(),
+  budgets: Schema.array(Schema.object({
+    model_name: Schema.string().required(),
+    total_budget: Schema.number(),
     consumed_budget: Schema.number(),
     remaining_budget: Schema.number()
   })).default(void 0),
@@ -6921,14 +8670,14 @@ function parseDeviceInfo(message) {
   const id = deviceId.value?.trim();
   if (id === void 0 || id === "") return void 0;
   const name2 = deviceName.value?.trim();
-  const version = appVersion.value?.trim();
+  const version2 = appVersion.value?.trim();
   return {
     deviceId: id,
     ...name2 === void 0 || name2 === "" ? {} : { deviceName: name2 },
-    ...version === void 0 || version === "" ? {} : { appVersion: version }
+    ...version2 === void 0 || version2 === "" ? {} : { appVersion: version2 }
   };
 }
-function errorName3(error) {
+function errorName5(error) {
   return error instanceof Error ? error.name : typeof error;
 }
 function registerIpcMessageHandler(ports) {
@@ -6955,12 +8704,12 @@ function registerIpcMessageHandler(ports) {
       authInFlight = true;
       try {
         void Promise.resolve(ports.complete(input)).catch((error) => {
-          log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5904\u7406\u5F02\u5E38\uFF08${errorName3(error)}\uFF09`);
+          log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5904\u7406\u5F02\u5E38\uFF08${errorName5(error)}\uFF09`);
         }).finally(() => {
           authInFlight = false;
         });
       } catch (error) {
-        log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5206\u53D1\u5931\u8D25\uFF08${errorName3(error)}\uFF09`);
+        log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5206\u53D1\u5931\u8D25\uFF08${errorName5(error)}\uFF09`);
         authInFlight = false;
       }
       return;
@@ -7008,12 +8757,12 @@ async function projectLoginMode(opts) {
       }
     }
   } catch (error) {
-    opts.log?.(`hiwork-core: \u5BA2\u6237\u7AEF\u7B56\u7565\u62C9\u53D6\u5931\u8D25\uFF0C\u767B\u5F55\u65B9\u5F0F\u56DE\u9000 both\uFF08${errorName3(error)}\uFF09`);
+    opts.log?.(`hiwork-core: \u5BA2\u6237\u7AEF\u7B56\u7565\u62C9\u53D6\u5931\u8D25\uFF0C\u767B\u5F55\u65B9\u5F0F\u56DE\u9000 both\uFF08${errorName5(error)}\uFF09`);
   }
   try {
     await opts.state.patch({ set: { loginMode, passwordLogin } });
   } catch (error) {
-    opts.log?.(`hiwork-core: \u5BA2\u6237\u7AEF\u7B56\u7565\u5199\u5165\u5931\u8D25\uFF08${errorName3(error)}\uFF09`);
+    opts.log?.(`hiwork-core: \u5BA2\u6237\u7AEF\u7B56\u7565\u5199\u5165\u5931\u8D25\uFF08${errorName5(error)}\uFF09`);
   }
   return loginMode;
 }
@@ -7151,6 +8900,16 @@ function apply(ctx, config) {
       ctx.logger.warn(message);
     }
   }), "hiwork-core: daily rpc");
+  ctx.effect(() => registerVoiceRpc({ connection, logger: ctx.logger }, {
+    resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
+    gateway: () => {
+      const baseURL = current().baseURL;
+      return baseURL === void 0 || baseURL === "" ? void 0 : gatewayFor(baseURL);
+    },
+    log: (message) => {
+      ctx.logger.warn(message);
+    }
+  }), "hiwork-core: voice rpc");
   const managedMcpDeps = {
     resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
     gateway: () => {
@@ -7283,6 +9042,16 @@ function apply(ctx, config) {
       ctx.logger.warn(message);
     }
   }), "hiwork-core: memory config service");
+  ctx.effect(() => provideKnowledgeConfig(ctx, {
+    resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
+    gateway: () => {
+      const baseURL = current().baseURL;
+      return baseURL === void 0 || baseURL === "" ? void 0 : createKnowledgeConfigGateway(baseURL);
+    },
+    log: (message) => {
+      ctx.logger.warn(message);
+    }
+  }), "hiwork-core: knowledge config service");
   ctx.effect(() => provideOfficeRelay(ctx, {
     resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
     gateway: () => {
@@ -7293,6 +9062,19 @@ function apply(ctx, config) {
       ctx.logger.warn(message);
     }
   }), "hiwork-core: office relay");
+  const web = ctx.get("web");
+  if (web !== void 0) {
+    registerManagedSearchProvider(web, {
+      resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
+      gateway: () => {
+        const baseURL = current().baseURL;
+        return baseURL === void 0 || baseURL === "" ? void 0 : createWebSearchGateway(baseURL);
+      },
+      log: (message) => {
+        ctx.logger.warn(message);
+      }
+    });
+  }
   ctx.effect(() => registerAppVersionRpc({ connection, logger: ctx.logger }, {
     appVersion: () => pushedAppVersion(),
     log: (message) => {