@acosmi/sdk-ts 1.0.0

package/dist/node/index.js

@@ -0,0 +1,3950 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types.ts
+function tokenSetIsExpired(t) {
+  const expiresAt = new Date(t.expires_at).getTime();
+  return Date.now() > expiresAt - 3e4;
+}
+function bucketInfoIsCommercial(b) {
+  if (!b) return false;
+  return b.bucketClass.toLowerCase() === BucketClassCommercial.toLowerCase();
+}
+function bucketRowIsCommercial(r) {
+  if (!r) return false;
+  return r.bucketClass.toLowerCase() === BucketClassCommercial.toLowerCase();
+}
+function newThinkingConfig(level) {
+  if (level === "" || level === ThinkingOff) {
+    return { type: "disabled" };
+  }
+  return { type: "adaptive", level };
+}
+function newWebSearchTool(cfg) {
+  const st = {
+    type: ServerToolTypeWebSearch,
+    name: "web_search"
+  };
+  if (cfg) {
+    if ((cfg.allowed_domains?.length ?? 0) > 0 && (cfg.blocked_domains?.length ?? 0) > 0) {
+      throw new Error("web search: allowed_domains and blocked_domains are mutually exclusive");
+    }
+    const m = {};
+    if (cfg.max_uses && cfg.max_uses > 0) m["max_uses"] = cfg.max_uses;
+    if (cfg.allowed_domains?.length) m["allowed_domains"] = cfg.allowed_domains;
+    if (cfg.blocked_domains?.length) m["blocked_domains"] = cfg.blocked_domains;
+    if (cfg.user_location) m["user_location"] = cfg.user_location;
+    if (Object.keys(m).length > 0) st.config = m;
+  }
+  return st;
+}
+function parseSourcesEvent(ev) {
+  let wrapper;
+  try {
+    wrapper = JSON.parse(ev.data);
+  } catch {
+    return null;
+  }
+  if (wrapper.type !== "sources" && ev.event !== "sources") {
+    return null;
+  }
+  if (!wrapper.sources || wrapper.sources.length === 0) {
+    return null;
+  }
+  return { sources: wrapper.sources, session_id: wrapper.session_id };
+}
+function anthropicResponseTextContent(r) {
+  const parts = [];
+  for (const b of r.content) {
+    if (b.type === "text" && b.text) parts.push(b.text);
+  }
+  return parts.join("");
+}
+function anthropicResponseThinkingContent(r) {
+  const parts = [];
+  for (const b of r.content) {
+    if (b.type === "thinking" && b.thinking) parts.push(b.thinking);
+  }
+  return parts.join("");
+}
+function anthropicResponseToolUseBlocks(r) {
+  return r.content.filter((b) => b.type === "tool_use");
+}
+function parseSettlement(ev) {
+  if (ev.event !== "settled" && ev.event !== "pending_settle") {
+    return null;
+  }
+  let s;
+  try {
+    s = JSON.parse(ev.data);
+  } catch {
+    return null;
+  }
+  return {
+    requestId: s.requestId ?? "",
+    consumeStatus: s.consumeStatus ?? "",
+    inputTokens: s.inputTokens ?? 0,
+    outputTokens: s.outputTokens ?? 0,
+    totalTokens: s.totalTokens ?? 0,
+    tokenRemaining: s.tokenRemaining ?? -1,
+    callRemaining: s.callRemaining ?? -1
+  };
+}
+function apiResponseGetMessage(r) {
+  return r.message ?? r.msg ?? "";
+}
+function apiResponseBusinessError(r) {
+  if (r.code !== 0) {
+    return new BusinessError(r.code, apiResponseGetMessage(r));
+  }
+  return null;
+}
+function parseNotificationEvent(ev) {
+  if (ev.type !== "event" || ev.topic !== "system") {
+    return null;
+  }
+  if (ev.data == null) return null;
+  let n;
+  try {
+    if (typeof ev.data === "string") {
+      n = JSON.parse(ev.data);
+    } else {
+      n = ev.data;
+    }
+  } catch {
+    return null;
+  }
+  if (!n.id) return null;
+  return n;
+}
+var BucketClassCommercial, BucketClassGeneric, ThinkingOff, ThinkingHigh, ThinkingMax, ThinkingHighMinMaxTokens, ThinkingMaxFallbackMaxTokens, ServerToolTypeWebSearch, RateLimitError, BusinessError, OrderTerminalError, ModelNotFoundError, HTTPError, NetworkError, StreamError;
+var init_types = __esm({
+  "src/types.ts"() {
+    BucketClassCommercial = "COMMERCIAL";
+    BucketClassGeneric = "GENERIC";
+    ThinkingOff = "off";
+    ThinkingHigh = "high";
+    ThinkingMax = "max";
+    ThinkingHighMinMaxTokens = 32e3;
+    ThinkingMaxFallbackMaxTokens = 128e3;
+    ServerToolTypeWebSearch = "web_search_20250305";
+    RateLimitError = class extends Error {
+      retryAfter;
+      raw;
+      constructor(message, retryAfter, raw) {
+        super(message);
+        this.name = "RateLimitError";
+        this.retryAfter = retryAfter;
+        this.raw = raw;
+      }
+    };
+    BusinessError = class extends Error {
+      code;
+      constructor(code, message) {
+        super(`API error (code=${code}): ${message}`);
+        this.name = "BusinessError";
+        this.code = code;
+      }
+    };
+    OrderTerminalError = class extends Error {
+      orderId;
+      status;
+      constructor(orderId, status) {
+        super(`order ${orderId} terminated: ${status}`);
+        this.name = "OrderTerminalError";
+        this.orderId = orderId;
+        this.status = status;
+      }
+    };
+    ModelNotFoundError = class extends Error {
+      modelId;
+      constructor(modelId) {
+        super(`managed model "${modelId}" not found (list models to refresh cache, or verify model id)`);
+        this.name = "ModelNotFoundError";
+        this.modelId = modelId;
+      }
+    };
+    HTTPError = class extends Error {
+      statusCode;
+      /** anthropic.error.type / openai.error.type, 缺失为空 */
+      type;
+      /** Retry-After 头解析的秒数, 0 表示未提供或解析失败 */
+      retryAfter;
+      /** 原始响应体 (截断到 maxErrorBodySize) */
+      body;
+      constructor(statusCode, opts = {}) {
+        let msg;
+        if (opts.type) {
+          msg = `HTTP ${statusCode}: [${opts.type}] ${opts.message ?? ""}`;
+        } else if (opts.message) {
+          msg = `HTTP ${statusCode}: ${opts.message}`;
+        } else if (opts.body) {
+          msg = `HTTP ${statusCode}: ${opts.body}`;
+        } else {
+          msg = `HTTP ${statusCode}`;
+        }
+        super(msg);
+        this.name = "HTTPError";
+        this.statusCode = statusCode;
+        this.type = opts.type ?? "";
+        this.retryAfter = opts.retryAfter ?? 0;
+        this.body = opts.body ?? "";
+      }
+    };
+    NetworkError = class extends Error {
+      /** 操作描述, e.g. "POST /v1/messages" */
+      op;
+      /** 请求 URL (脱敏后) */
+      url;
+      cause;
+      timeout;
+      eof;
+      constructor(op, url, cause, opts = {}) {
+        const causeMsg = cause instanceof Error ? cause.message : cause != null ? String(cause) : "network error";
+        super(`${op} ${url}: ${causeMsg}`);
+        this.name = "NetworkError";
+        this.op = op;
+        this.url = url;
+        this.cause = cause;
+        this.timeout = opts.timeout ?? false;
+        this.eof = opts.eof ?? false;
+      }
+      isTimeout() {
+        return this.timeout;
+      }
+      isEOF() {
+        return this.eof;
+      }
+    };
+    StreamError = class extends Error {
+      /** 例: "empty_response" / "rate_limit" / "overloaded" / "" */
+      code;
+      /** 例: "provider" / "settlement" */
+      stage;
+      /** 用户友好提示 (中文); 历史字段, 与 rawError 区分 */
+      userMessage;
+      /** gateway 原始 error 字符串 */
+      rawError;
+      /** 客户端是否值得重试 */
+      retryable;
+      constructor(opts = {}) {
+        const code = opts.code ?? "";
+        const stage = opts.stage ?? "";
+        const userMessage = opts.message ?? "";
+        const rawError = opts.rawError ?? "";
+        const retryable = opts.retryable ?? false;
+        const body = rawError !== "" ? rawError : userMessage;
+        const msg = stage !== "" ? `stream failed: ${stage}: ${body}` : `stream failed: ${body}`;
+        super(msg);
+        this.name = "StreamError";
+        this.code = code;
+        this.stage = stage;
+        this.userMessage = userMessage;
+        this.rawError = rawError;
+        this.retryable = retryable;
+      }
+    };
+  }
+});
+
+// src/betas.ts
+function buildBetas(caps, req) {
+  const betas = [];
+  if (caps.supports_isp) {
+    betas.push(betaInterleavedThinking);
+    betas.push(betaContextManagement);
+  }
+  if (caps.supports_redact_thinking && req.thinking && req.thinking.display === "summary") {
+    betas.push(betaRedactThinking);
+  }
+  if (caps.supports_1m_context) {
+    betas.push(betaContext1M);
+  }
+  const hasStructuredOutput = caps.supports_structured_output && req.outputConfig != null;
+  if (hasStructuredOutput) {
+    betas.push(betaStructuredOutputs);
+  } else if (caps.supports_token_efficient) {
+    betas.push(betaTokenEfficientTools);
+  }
+  if (caps.supports_tool_search) {
+    betas.push(betaAdvancedToolUse);
+  }
+  const needsEffort = req.effort != null || req.thinking != null && req.thinking.level && req.thinking.level !== ThinkingOff;
+  if (caps.supports_effort && needsEffort) {
+    betas.push(betaEffort);
+  }
+  if (caps.supports_fast_mode && req.speed === "fast") {
+    betas.push(betaFastMode);
+  }
+  if (caps.supports_prompt_cache) {
+    betas.push(betaPromptCachingScope);
+  }
+  return uniqueMerge(betas, req.betas ?? []);
+}
+function uniqueMerge(base, extra) {
+  if (extra.length === 0) return base;
+  const seen = new Set(base);
+  for (const s of extra) {
+    if (!seen.has(s)) {
+      base.push(s);
+      seen.add(s);
+    }
+  }
+  return base;
+}
+var betaInterleavedThinking, betaContext1M, betaContextManagement, betaStructuredOutputs, betaAdvancedToolUse, betaEffort, betaPromptCachingScope, betaFastMode, betaRedactThinking, betaTokenEfficientTools;
+var init_betas = __esm({
+  "src/betas.ts"() {
+    init_types();
+    betaInterleavedThinking = "interleaved-thinking-2025-05-14";
+    betaContext1M = "context-1m-2025-08-07";
+    betaContextManagement = "context-management-2025-06-27";
+    betaStructuredOutputs = "structured-outputs-2025-11-13";
+    betaAdvancedToolUse = "advanced-tool-use-2025-11-20";
+    betaEffort = "effort-2025-11-24";
+    betaPromptCachingScope = "prompt-caching-scope-2026-01-05";
+    betaFastMode = "fast-mode-2026-02-01";
+    betaRedactThinking = "redact-thinking-2026-02-12";
+    betaTokenEfficientTools = "token-efficient-tools-2025-02-19";
+  }
+});
+
+// src/adapters/anthropic.ts
+function resolveThinkingLevel(body, req, caps) {
+  const level = req.thinking?.level ?? "";
+  if (level === ThinkingOff) {
+    body["thinking"] = { type: "disabled" };
+    return;
+  }
+  if (!caps.supports_adaptive_thinking && !caps.supports_thinking) {
+    return;
+  }
+  let maxTokens = req.max_tokens ?? 0;
+  if (maxTokens <= 0) {
+    maxTokens = ThinkingHighMinMaxTokens;
+  }
+  if (level === ThinkingMax) {
+    let modelMax = caps.max_output_tokens;
+    if (modelMax <= 0) modelMax = ThinkingMaxFallbackMaxTokens;
+    if (maxTokens < modelMax) maxTokens = modelMax;
+  } else {
+    if (maxTokens < ThinkingHighMinMaxTokens) maxTokens = ThinkingHighMinMaxTokens;
+  }
+  body["max_tokens"] = maxTokens;
+  if (caps.supports_adaptive_thinking) {
+    const thinking = { type: "adaptive" };
+    if (req.thinking?.display) thinking["display"] = req.thinking.display;
+    body["thinking"] = thinking;
+  } else if (caps.supports_thinking) {
+    let budget = maxTokens - 1;
+    if (budget < 1024) budget = 1024;
+    const thinking = {
+      type: "enabled",
+      budget_tokens: budget
+    };
+    if (req.thinking?.display) thinking["display"] = req.thinking.display;
+    body["thinking"] = thinking;
+  }
+  if (caps.supports_effort) {
+    let effortLevel = "high";
+    if (level === ThinkingMax && caps.supports_max_effort) {
+      effortLevel = "max";
+    }
+    body["effort"] = { level: effortLevel };
+  }
+  delete body["temperature"];
+}
+var AnthropicAdapter;
+var init_anthropic = __esm({
+  "src/adapters/anthropic.ts"() {
+    init_types();
+    init_betas();
+    init_adapters();
+    AnthropicAdapter = class {
+      format() {
+        return 0 /* Anthropic */;
+      }
+      endpointSuffix() {
+        return "/anthropic";
+      }
+      /**
+       * 构建 Anthropic 格式请求体
+       * 逻辑等同于原 buildChatRequest, 包含完整的 betas/tools/serverTools/extraBody 处理
+       */
+      buildRequestBody(caps, req) {
+        const body = {};
+        if (req.rawMessages != null) {
+          body["messages"] = req.rawMessages;
+        } else if ((req.messages?.length ?? 0) > 0) {
+          body["messages"] = req.messages;
+        }
+        body["stream"] = req.stream === true;
+        if (req.max_tokens && req.max_tokens > 0) {
+          body["max_tokens"] = req.max_tokens;
+        }
+        if (req.system != null) {
+          body["system"] = req.system;
+        }
+        if (req.temperature != null) {
+          body["temperature"] = req.temperature;
+        }
+        if (req.thinking && req.thinking.level && req.thinking.level !== "") {
+          resolveThinkingLevel(body, req, caps);
+        } else {
+          if (req.thinking) {
+            body["thinking"] = req.thinking;
+          }
+          if (req.effort) {
+            body["effort"] = req.effort;
+          }
+        }
+        if (req.metadata) {
+          body["metadata"] = req.metadata;
+        }
+        const allTools = [];
+        if (req.tools != null) {
+          try {
+            const parsed = JSON.parse(JSON.stringify(req.tools));
+            if (Array.isArray(parsed)) {
+              for (const t of parsed) allTools.push(t);
+            }
+          } catch {
+          }
+        }
+        for (const st of req.serverTools ?? []) {
+          const schema = {
+            type: st.type,
+            name: st.name
+          };
+          if (st.config) {
+            for (const [k, v] of Object.entries(st.config)) {
+              schema[k] = v;
+            }
+          }
+          allTools.push(schema);
+        }
+        if (allTools.length > 0) {
+          body["tools"] = allTools;
+        }
+        if (req.speed && req.speed !== "") {
+          body["speed"] = req.speed;
+        }
+        if (req.outputConfig) {
+          body["output_config"] = req.outputConfig;
+        }
+        const betas = buildBetas(caps, req);
+        if (betas.length > 0) {
+          body["betas"] = betas;
+        }
+        if (req.extraBody) {
+          for (const [k, v] of Object.entries(req.extraBody)) {
+            body[k] = v;
+          }
+        }
+        return body;
+      }
+      /**
+       * 解析 Anthropic 格式同步响应
+       * 兼容 APIResponse 包装 {"code":0,"data":{...}} 和裸 Anthropic JSON 两种格式
+       */
+      parseResponse(bodyInput) {
+        const bodyStr = typeof bodyInput === "string" ? bodyInput : new TextDecoder().decode(bodyInput);
+        let raw = bodyStr;
+        try {
+          const wrapper = JSON.parse(bodyStr);
+          if (wrapper.data != null && wrapper.data !== null) {
+            if ((wrapper.code ?? 0) !== 0) {
+              throw new BusinessError(wrapper.code ?? 0, wrapper.message ?? "");
+            }
+            raw = JSON.stringify(wrapper.data);
+          }
+        } catch (e) {
+          if (e instanceof BusinessError) throw e;
+        }
+        let resp;
+        try {
+          resp = JSON.parse(raw);
+        } catch (e) {
+          throw new Error(
+            `decode anthropic response: ${e instanceof Error ? e.message : String(e)}`
+          );
+        }
+        resp.tokenRemaining = -1;
+        resp.callRemaining = -1;
+        resp.modelTokenRemaining = -1;
+        resp.modelTokenRemainingETU = -1;
+        return resp;
+      }
+      /**
+       * 解析 Anthropic SSE 行
+       *
+       * Anthropic 原生协议无 [DONE] (message_stop 后上游关闭连接),
+       * 但 Nexus Gateway 的 ChatStream 路径会追加 [DONE] 哨兵, 此处一并处理。
+       */
+      parseStreamLine(eventType, data) {
+        if (data === "[DONE]") {
+          return { event: { event: "", data: "" }, done: true };
+        }
+        return { event: { event: eventType, data }, done: false };
+      }
+    };
+  }
+});
+
+// src/adapters/openai.ts
+var openai_exports = {};
+__export(openai_exports, {
+  OpenAIAdapter: () => OpenAIAdapter,
+  OpenAIStreamConverter: () => OpenAIStreamConverter,
+  newOpenAIStreamConverter: () => newOpenAIStreamConverter,
+  parseOpenAIResponseToAnthropic: () => parseOpenAIResponseToAnthropic,
+  resolveOpenAIReasoningEffort: () => resolveOpenAIReasoningEffort,
+  resolveOpenAIResponseFormat: () => resolveOpenAIResponseFormat
+});
+function resolveOpenAIReasoningEffort(req) {
+  if (req.effort && req.effort.level !== "") {
+    switch (req.effort.level) {
+      case "low":
+      case "medium":
+      case "high":
+        return req.effort.level;
+      case "max":
+        return "high";
+    }
+  }
+  if (req.thinking) {
+    switch (req.thinking.level) {
+      case ThinkingHigh:
+        return "high";
+      case ThinkingMax:
+        return "high";
+      case ThinkingOff:
+        return "";
+    }
+  }
+  return "";
+}
+function resolveOpenAIResponseFormat(req) {
+  if (!req.outputConfig) return null;
+  switch (req.outputConfig.format) {
+    case "json_schema": {
+      const js = {};
+      if (req.outputConfig.schema != null) {
+        js["schema"] = req.outputConfig.schema;
+      }
+      js["strict"] = true;
+      return {
+        type: "json_schema",
+        json_schema: js
+      };
+    }
+    case "json_object":
+      return { type: "json_object" };
+    case "":
+    case void 0:
+      return null;
+    default:
+      return { type: req.outputConfig.format };
+  }
+}
+function convertOpenAIToChatResponse(oai) {
+  const resp = {
+    id: oai.id,
+    type: "message",
+    model: oai.model,
+    role: "assistant",
+    content: [],
+    stop_reason: "",
+    usage: {
+      input_tokens: oai.usage.prompt_tokens,
+      output_tokens: oai.usage.completion_tokens
+    },
+    tokenRemaining: -1,
+    callRemaining: -1,
+    modelTokenRemaining: -1,
+    modelTokenRemainingETU: -1
+  };
+  if (oai.choices.length > 0) {
+    const choice = oai.choices[0];
+    switch (choice.finish_reason) {
+      case "stop":
+        resp.stop_reason = "end_turn";
+        break;
+      case "tool_calls":
+        resp.stop_reason = "tool_use";
+        break;
+      case "length":
+        resp.stop_reason = "max_tokens";
+        break;
+      default:
+        resp.stop_reason = choice.finish_reason;
+    }
+    if (choice.message.reasoning_content && choice.message.reasoning_content !== "") {
+      resp.content.push({
+        type: "thinking",
+        thinking: choice.message.reasoning_content
+      });
+    }
+    if (choice.message.content && choice.message.content !== "") {
+      resp.content.push({
+        type: "text",
+        text: choice.message.content
+      });
+    }
+    for (const tc of choice.message.tool_calls ?? []) {
+      resp.content.push({
+        type: "tool_use",
+        id: tc.id,
+        name: tc.function.name,
+        // Anthropic 协议 input 是 raw JSON value; OpenAI 给的 arguments 是 string,
+        // Go 侧用 json.RawMessage(arguments) 直透(原始字节). TS 我们尝试解析:
+        input: tryParseJSON(tc.function.arguments)
+      });
+    }
+  }
+  return resp;
+}
+function tryParseJSON(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return s;
+  }
+}
+function parseOpenAIResponseToAnthropic(raw) {
+  const rawStr = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+  let data = rawStr;
+  try {
+    const wrapper = JSON.parse(rawStr);
+    if (wrapper.data != null && wrapper.data !== null) {
+      if ((wrapper.code ?? 0) !== 0) {
+        throw new BusinessError(wrapper.code ?? 0, wrapper.message ?? "");
+      }
+      data = JSON.stringify(wrapper.data);
+    }
+  } catch (e) {
+    if (e instanceof BusinessError) throw e;
+  }
+  let oaiResp;
+  try {
+    oaiResp = JSON.parse(data);
+  } catch (e) {
+    throw new Error(`decode openai response: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const resp = {
+    id: oaiResp.id,
+    type: "message",
+    role: "assistant",
+    content: [],
+    model: oaiResp.model,
+    stop_reason: "",
+    usage: {
+      input_tokens: oaiResp.usage.prompt_tokens,
+      output_tokens: oaiResp.usage.completion_tokens
+    }
+  };
+  if (oaiResp.choices.length > 0) {
+    const choice = oaiResp.choices[0];
+    switch (choice.finish_reason) {
+      case "stop":
+        resp.stop_reason = "end_turn";
+        break;
+      case "tool_calls":
+        resp.stop_reason = "tool_use";
+        break;
+      case "length":
+        resp.stop_reason = "max_tokens";
+        break;
+      default:
+        resp.stop_reason = choice.finish_reason;
+    }
+    if (choice.message.reasoning_content && choice.message.reasoning_content !== "") {
+      resp.content.push({
+        type: "thinking",
+        thinking: choice.message.reasoning_content
+      });
+    }
+    if (choice.message.content && choice.message.content !== "") {
+      resp.content.push({
+        type: "text",
+        text: choice.message.content
+      });
+    }
+    for (const tc of choice.message.tool_calls ?? []) {
+      resp.content.push({
+        type: "tool_use",
+        id: tc.id,
+        name: tc.function.name,
+        input: tryParseJSON(tc.function.arguments)
+      });
+    }
+  }
+  return resp;
+}
+function newOpenAIStreamConverter() {
+  return new OpenAIStreamConverter();
+}
+var OpenAIAdapter, OpenAIStreamConverter;
+var init_openai = __esm({
+  "src/adapters/openai.ts"() {
+    init_types();
+    init_adapters();
+    OpenAIAdapter = class {
+      format() {
+        return 1 /* OpenAI */;
+      }
+      endpointSuffix() {
+        return "/chat";
+      }
+      /**
+       * 构建 OpenAI 兼容格式请求体
+       * 不注入 Anthropic betas, 扩展字段 (thinking/effort/speed) 以通用 JSON 传递
+       */
+      buildRequestBody(_caps, req) {
+        const body = {};
+        if (req.rawMessages != null) {
+          body["messages"] = req.rawMessages;
+        } else if ((req.messages?.length ?? 0) > 0) {
+          body["messages"] = req.messages;
+        }
+        body["stream"] = req.stream === true;
+        if (req.max_tokens && req.max_tokens > 0) {
+          body["max_tokens"] = req.max_tokens;
+        }
+        if (req.system != null) {
+          body["system"] = req.system;
+        }
+        if (req.temperature != null) {
+          body["temperature"] = req.temperature;
+        }
+        if (req.tools != null) {
+          body["tools"] = req.tools;
+        }
+        const eff = resolveOpenAIReasoningEffort(req);
+        if (eff !== "") {
+          body["reasoning_effort"] = eff;
+        }
+        if (req.speed && req.speed !== "") {
+          body["speed"] = req.speed;
+        }
+        const rf = resolveOpenAIResponseFormat(req);
+        if (rf) {
+          body["response_format"] = rf;
+        }
+        if (req.metadata) {
+          body["metadata"] = req.metadata;
+        }
+        if (req.parallelToolCalls != null) {
+          body["parallel_tool_calls"] = req.parallelToolCalls;
+        }
+        if (req.extraBody) {
+          for (const [k, v] of Object.entries(req.extraBody)) {
+            body[k] = v;
+          }
+        }
+        if (req.stream === true) {
+          body["stream_options"] = { include_usage: true };
+        }
+        return body;
+      }
+      /**
+       * 解析 OpenAI 格式同步响应为 ChatResponse
+       * 兼容 APIResponse 包装 {"code":0,"data":{...}} 和裸 OpenAI JSON 两种格式
+       */
+      parseResponse(bodyInput) {
+        const bodyStr = typeof bodyInput === "string" ? bodyInput : new TextDecoder().decode(bodyInput);
+        let raw = bodyStr;
+        try {
+          const wrapper = JSON.parse(bodyStr);
+          if (wrapper.data != null && wrapper.data !== null) {
+            if ((wrapper.code ?? 0) !== 0) {
+              throw new BusinessError(wrapper.code ?? 0, wrapper.message ?? "");
+            }
+            raw = JSON.stringify(wrapper.data);
+          }
+        } catch (e) {
+          if (e instanceof BusinessError) throw e;
+        }
+        let oaiResp;
+        try {
+          oaiResp = JSON.parse(raw);
+        } catch (e) {
+          throw new Error(`decode openai response: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        return convertOpenAIToChatResponse(oaiResp);
+      }
+      /**
+       * 解析 OpenAI SSE 行
+       * [DONE] 标记流结束
+       */
+      parseStreamLine(eventType, data) {
+        if (data === "[DONE]") {
+          return { event: { event: "", data: "" }, done: true };
+        }
+        try {
+          JSON.parse(data);
+        } catch (e) {
+          throw new Error(`parse openai stream chunk: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        return { event: { event: eventType, data }, done: false };
+      }
+    };
+    OpenAIStreamConverter = class {
+      messageStarted = false;
+      thinkingStarted = false;
+      thinkingStopped = false;
+      textStarted = false;
+      /** OpenAI tool_call index → Anthropic block index */
+      toolBlockIndex = /* @__PURE__ */ new Map();
+      blockIndex = 0;
+      /**
+       * 将一行 OpenAI SSE data 转换为零或多个 Anthropic 格式 StreamEvent
+       * 返回 { events, done }
+       */
+      convert(data) {
+        if (data === "[DONE]") {
+          return { events: [], done: true };
+        }
+        let chunk;
+        try {
+          chunk = JSON.parse(data);
+        } catch (e) {
+          throw new Error(`parse openai stream chunk: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        const events = [];
+        if (chunk.choices.length === 0) {
+          return { events, done: false };
+        }
+        const choice = chunk.choices[0];
+        if (!this.messageStarted) {
+          this.messageStarted = true;
+          const msgJSON = JSON.stringify({
+            type: "message_start",
+            message: {
+              id: chunk.id,
+              type: "message",
+              role: "assistant",
+              content: [],
+              model: ""
+            }
+          });
+          events.push({ event: "message_start", data: msgJSON });
+        }
+        if (choice.delta.reasoning_content && choice.delta.reasoning_content !== "") {
+          if (!this.thinkingStarted) {
+            this.thinkingStarted = true;
+            const blockJSON = JSON.stringify({
+              type: "content_block_start",
+              index: this.blockIndex,
+              content_block: { type: "thinking", thinking: "" }
+            });
+            events.push({ event: "content_block_start", data: blockJSON });
+          }
+          const deltaJSON = JSON.stringify({
+            type: "content_block_delta",
+            index: this.blockIndex,
+            delta: { type: "thinking_delta", thinking: choice.delta.reasoning_content }
+          });
+          events.push({ event: "content_block_delta", data: deltaJSON });
+        }
+        if (choice.delta.content && choice.delta.content !== "") {
+          if (this.thinkingStarted && !this.thinkingStopped) {
+            this.thinkingStopped = true;
+            const stopJSON = JSON.stringify({
+              type: "content_block_stop",
+              index: this.blockIndex
+            });
+            events.push({ event: "content_block_stop", data: stopJSON });
+            this.blockIndex++;
+          }
+          if (!this.textStarted) {
+            this.textStarted = true;
+            const blockJSON = JSON.stringify({
+              type: "content_block_start",
+              index: this.blockIndex,
+              content_block: { type: "text", text: "" }
+            });
+            events.push({ event: "content_block_start", data: blockJSON });
+          }
+          const deltaJSON = JSON.stringify({
+            type: "content_block_delta",
+            index: this.blockIndex,
+            delta: { type: "text_delta", text: choice.delta.content }
+          });
+          events.push({ event: "content_block_delta", data: deltaJSON });
+        }
+        for (const tc of choice.delta.tool_calls ?? []) {
+          if (!this.toolBlockIndex.has(tc.index)) {
+            if (this.textStarted) {
+              const stopJSON = JSON.stringify({
+                type: "content_block_stop",
+                index: this.blockIndex
+              });
+              events.push({ event: "content_block_stop", data: stopJSON });
+              this.blockIndex++;
+              this.textStarted = false;
+            }
+            this.toolBlockIndex.set(tc.index, this.blockIndex);
+            const blockJSON = JSON.stringify({
+              type: "content_block_start",
+              index: this.blockIndex,
+              content_block: {
+                type: "tool_use",
+                id: tc.id,
+                name: tc.function.name,
+                input: {}
+              }
+            });
+            events.push({ event: "content_block_start", data: blockJSON });
+            this.blockIndex++;
+          }
+          if (tc.function.arguments && tc.function.arguments !== "") {
+            const idx = this.toolBlockIndex.get(tc.index);
+            const deltaJSON = JSON.stringify({
+              type: "content_block_delta",
+              index: idx,
+              delta: {
+                type: "input_json_delta",
+                partial_json: tc.function.arguments
+              }
+            });
+            events.push({ event: "content_block_delta", data: deltaJSON });
+          }
+        }
+        if (choice.finish_reason != null && choice.finish_reason !== "") {
+          if (this.textStarted) {
+            const stopJSON2 = JSON.stringify({
+              type: "content_block_stop",
+              index: this.blockIndex
+            });
+            events.push({ event: "content_block_stop", data: stopJSON2 });
+          } else if (this.thinkingStarted && !this.thinkingStopped) {
+            const stopJSON2 = JSON.stringify({
+              type: "content_block_stop",
+              index: this.blockIndex
+            });
+            events.push({ event: "content_block_stop", data: stopJSON2 });
+          }
+          for (const idx of this.toolBlockIndex.values()) {
+            const stopJSON2 = JSON.stringify({
+              type: "content_block_stop",
+              index: idx
+            });
+            events.push({ event: "content_block_stop", data: stopJSON2 });
+          }
+          let stopReason = "end_turn";
+          switch (choice.finish_reason) {
+            case "tool_calls":
+              stopReason = "tool_use";
+              break;
+            case "length":
+              stopReason = "max_tokens";
+              break;
+          }
+          const deltaJSON = JSON.stringify({
+            type: "message_delta",
+            delta: { stop_reason: stopReason }
+          });
+          events.push({ event: "message_delta", data: deltaJSON });
+          const stopJSON = JSON.stringify({ type: "message_stop" });
+          events.push({ event: "message_stop", data: stopJSON });
+        }
+        return { events, done: false };
+      }
+    };
+  }
+});
+
+// src/adapters/index.ts
+function getAdapter(provider) {
+  const a = adapterRegistry[provider.toLowerCase()];
+  if (a) return a;
+  return defaultOpenAIAdapter;
+}
+function getAdapterForModel(m) {
+  const pref = (m.preferred_format ?? "").trim().toLowerCase();
+  switch (pref) {
+    case "anthropic":
+      return new AnthropicAdapter();
+    case "openai":
+      return new OpenAIAdapter();
+  }
+  let hasAnthropic = false;
+  let hasOpenAI = false;
+  for (const f of m.supported_formats ?? []) {
+    switch (f.trim().toLowerCase()) {
+      case "anthropic":
+        hasAnthropic = true;
+        break;
+      case "openai":
+        hasOpenAI = true;
+        break;
+    }
+  }
+  if (hasAnthropic) return new AnthropicAdapter();
+  if (hasOpenAI) return new OpenAIAdapter();
+  return getAdapter((m.provider ?? "").toLowerCase());
+}
+var ProviderFormat, adapterRegistry, defaultOpenAIAdapter;
+var init_adapters = __esm({
+  "src/adapters/index.ts"() {
+    init_anthropic();
+    init_openai();
+    ProviderFormat = /* @__PURE__ */ ((ProviderFormat2) => {
+      ProviderFormat2[ProviderFormat2["Anthropic"] = 0] = "Anthropic";
+      ProviderFormat2[ProviderFormat2["OpenAI"] = 1] = "OpenAI";
+      return ProviderFormat2;
+    })(ProviderFormat || {});
+    adapterRegistry = {
+      anthropic: new AnthropicAdapter(),
+      /** Acosmi 自有模型走 Anthropic 格式 */
+      acosmi: new AnthropicAdapter()
+    };
+    defaultOpenAIAdapter = new OpenAIAdapter();
+  }
+});
+
+// src/index.ts
+init_types();
+init_adapters();
+
+// src/auth.ts
+var authTimeoutMs = 3e4;
+async function discover(serverURL, signal) {
+  let parsed;
+  try {
+    parsed = new URL(serverURL.replace(/\/+$/, ""));
+  } catch (e) {
+    throw new Error(`discover: invalid server URL: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const origin = `${parsed.protocol}//${parsed.host}`;
+  const endpoint = `${origin}/.well-known/oauth-authorization-server/desktop`;
+  const ctl = withTimeout(authTimeoutMs, signal);
+  let resp;
+  try {
+    resp = await fetch(endpoint, { method: "GET", signal: ctl.signal });
+  } catch (e) {
+    throw new Error(`discover: ${e instanceof Error ? e.message : String(e)}`);
+  } finally {
+    ctl.dispose();
+  }
+  if (!resp.ok) {
+    throw new Error(`discover: HTTP ${resp.status}`);
+  }
+  let meta;
+  try {
+    meta = await resp.json();
+  } catch (e) {
+    throw new Error(`discover: decode: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (!meta.token_endpoint || !meta.authorization_endpoint) {
+    throw new Error(
+      `discover: metadata missing required endpoints (token=${meta.token_endpoint ?? ""}, auth=${meta.authorization_endpoint ?? ""})`
+    );
+  }
+  return meta;
+}
+async function register(meta, appName, signal) {
+  const regReq = {
+    client_name: appName,
+    token_endpoint_auth_method: "none",
+    grant_types: ["authorization_code", "refresh_token"],
+    redirect_uris: ["http://127.0.0.1/callback"],
+    response_types: ["code"]
+  };
+  const ctl = withTimeout(authTimeoutMs, signal);
+  let resp;
+  try {
+    resp = await fetch(meta.registration_endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(regReq),
+      signal: ctl.signal
+    });
+  } catch (e) {
+    throw new Error(`register: ${e instanceof Error ? e.message : String(e)}`);
+  } finally {
+    ctl.dispose();
+  }
+  if (resp.status !== 200 && resp.status !== 201) {
+    throw new Error(`register: HTTP ${resp.status}`);
+  }
+  try {
+    return await resp.json();
+  } catch (e) {
+    throw new Error(`register: decode: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+async function generateCodeVerifier() {
+  const c = await getCrypto();
+  const b = new Uint8Array(32);
+  c.getRandomValues(b);
+  return base64urlNoPad(b);
+}
+async function codeChallenge(verifier) {
+  const c = await getCrypto();
+  const buf = await c.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return base64urlNoPad(new Uint8Array(buf));
+}
+async function getCrypto() {
+  if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.subtle) {
+    return globalThis.crypto;
+  }
+  const nodeCrypto = await import('crypto');
+  return nodeCrypto.webcrypto;
+}
+function base64urlNoPad(b) {
+  let bin = "";
+  for (let i = 0; i < b.length; i++) bin += String.fromCharCode(b[i]);
+  let s;
+  if (typeof btoa === "function") {
+    s = btoa(bin);
+  } else {
+    s = Buffer.from(b).toString("base64");
+  }
+  return s.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+var EventAuthURL = "auth_url";
+var EventComplete = "complete";
+var EventError = "error";
+var ErrDiscovery = "discovery_failed";
+var ErrRegistration = "registration_failed";
+var ErrBrowserOpen = "browser_open_failed";
+var ErrAuthDenied = "auth_denied";
+var ErrTimeout = "auth_timeout";
+var ErrTokenExchange = "token_exchange_failed";
+var ErrSSLProxy = "ssl_proxy_detected";
+function isSSLError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return msg.includes("tls:") || msg.includes("x509:") || msg.includes("certificate");
+}
+async function authorize(meta, clientID, scopes, opts = {}) {
+  if (typeof process === "undefined" || !process.versions || !process.versions.node) {
+    throw new Error("authorize requires Node.js environment (HTTP callback server)");
+  }
+  const handler = opts.handler;
+  const signal = opts.signal;
+  const emit = (e) => {
+    if (handler) handler(e);
+  };
+  const verifier = await generateCodeVerifier();
+  const challenge = await codeChallenge(verifier);
+  const http = await import('http');
+  const server = http.createServer();
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve());
+  });
+  const addr = server.address();
+  const port = addr.port;
+  const redirectURI = `http://127.0.0.1:${port}/callback`;
+  let codeResolver;
+  let codeRejecter;
+  const codePromise = new Promise((resolve, reject) => {
+    codeResolver = resolve;
+    codeRejecter = reject;
+  });
+  server.on("request", (req, res) => {
+    const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+    if (url.pathname !== "/callback") {
+      res.statusCode = 404;
+      res.end();
+      return;
+    }
+    const code = url.searchParams.get("code");
+    if (!code) {
+      const errMsg = url.searchParams.get("error_description") || url.searchParams.get("error") || "";
+      const escaped = htmlEscape(errMsg);
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(
+        `<!DOCTYPE html><html><head><meta charset="utf-8"><title>\u6388\u6743\u5931\u8D25</title></head><body style="font-family:system-ui,sans-serif;text-align:center;padding:60px 20px"><h2>\u6388\u6743\u5931\u8D25</h2><p>${escaped}</p><p style="color:#888;font-size:14px">\u53EF\u4EE5\u5173\u95ED\u6B64\u7A97\u53E3\u3002</p></body></html>`
+      );
+      codeRejecter(new Error(`authorization denied: ${errMsg}`));
+      return;
+    }
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.end(
+      `<!DOCTYPE html><html><head><meta charset="utf-8"><title>\u6388\u6743\u6210\u529F</title></head><body style="font-family:system-ui,sans-serif;text-align:center;padding:60px 20px"><h2>\u6388\u6743\u6210\u529F</h2><p>\u5DF2\u5B8C\u6210\u8EAB\u4EFD\u8BA4\u8BC1, \u8BF7\u8FD4\u56DE\u5E94\u7528\u7EE7\u7EED\u4F7F\u7528\u3002</p><p style="color:#888;font-size:14px">\u6B64\u7A97\u53E3\u5C06\u5728 3 \u79D2\u540E\u81EA\u52A8\u5173\u95ED\u2026</p><script>setTimeout(function(){window.close()},3000)</script></body></html>`
+    );
+    codeResolver(code);
+  });
+  const authURL = new URL(meta.authorization_endpoint);
+  authURL.searchParams.set("client_id", clientID);
+  authURL.searchParams.set("redirect_uri", redirectURI);
+  authURL.searchParams.set("response_type", "code");
+  authURL.searchParams.set("code_challenge", challenge);
+  authURL.searchParams.set("code_challenge_method", "S256");
+  if (scopes.length > 0) {
+    authURL.searchParams.set("scope", scopes.join(" "));
+  }
+  if (opts.loginHint) authURL.searchParams.set("login_hint", opts.loginHint);
+  if (opts.loginMethod) authURL.searchParams.set("login_method", opts.loginMethod);
+  if (opts.orgUUID) authURL.searchParams.set("orgUUID", opts.orgUUID);
+  emit({ type: EventAuthURL, url: authURL.toString() });
+  if (!opts.skipBrowser) {
+    try {
+      await openBrowser(authURL.toString());
+    } catch (e) {
+      emit({
+        type: EventError,
+        err_code: ErrBrowserOpen,
+        url: authURL.toString(),
+        error: e instanceof Error ? e.message : String(e)
+      });
+    }
+  }
+  let abortHandler;
+  try {
+    const code = await Promise.race([
+      codePromise,
+      new Promise((_, reject) => {
+        if (signal) {
+          if (signal.aborted) {
+            reject(new Error("authorization timed out"));
+            return;
+          }
+          abortHandler = () => reject(new Error("authorization timed out"));
+          signal.addEventListener("abort", abortHandler);
+        }
+      })
+    ]);
+    return { result: { code, redirectURI }, verifier };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes("denied")) {
+      emit({ type: EventError, err_code: ErrAuthDenied, error: msg });
+    } else if (msg.includes("timed out")) {
+      emit({ type: EventError, err_code: ErrTimeout, error: msg });
+    } else {
+      emit({ type: EventError, err_code: ErrTokenExchange, error: msg });
+    }
+    throw e;
+  } finally {
+    if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
+    server.close();
+  }
+}
+function htmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+async function exchangeCode(meta, clientID, code, redirectURI, codeVerifier, signal) {
+  const data = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: clientID,
+    code,
+    redirect_uri: redirectURI,
+    code_verifier: codeVerifier
+  });
+  return postToken(meta.token_endpoint, data, signal);
+}
+async function exchangeCodeWithExpiry(meta, clientID, code, redirectURI, codeVerifier, expiresIn, signal) {
+  const data = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: clientID,
+    code,
+    redirect_uri: redirectURI,
+    code_verifier: codeVerifier,
+    expires_in: String(expiresIn)
+  });
+  return postToken(meta.token_endpoint, data, signal);
+}
+async function refreshToken(meta, clientID, refreshTokenValue, signal) {
+  const data = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: clientID,
+    refresh_token: refreshTokenValue
+  });
+  return postToken(meta.token_endpoint, data, signal);
+}
+async function revokeToken(meta, token, signal) {
+  if (!meta.revocation_endpoint || meta.revocation_endpoint === "") {
+    return;
+  }
+  const data = new URLSearchParams({ token });
+  const ctl = withTimeout(authTimeoutMs, signal);
+  try {
+    await fetch(meta.revocation_endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: data,
+      signal: ctl.signal
+    });
+  } catch (e) {
+    throw new Error(`revoke: ${e instanceof Error ? e.message : String(e)}`);
+  } finally {
+    ctl.dispose();
+  }
+}
+async function postToken(endpoint, data, signal) {
+  const ctl = withTimeout(authTimeoutMs, signal);
+  let resp;
+  try {
+    resp = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: data,
+      signal: ctl.signal
+    });
+  } catch (e) {
+    throw new Error(`token request: ${e instanceof Error ? e.message : String(e)}`);
+  } finally {
+    ctl.dispose();
+  }
+  if (!resp.ok) {
+    let errBody = {};
+    try {
+      errBody = await resp.json();
+    } catch {
+    }
+    throw new Error(`token: HTTP ${resp.status}: ${errBody.error_description ?? ""}`);
+  }
+  try {
+    return await resp.json();
+  } catch (e) {
+    throw new Error(`token: decode: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+function newTokenSet(resp, clientID, serverURL) {
+  let expiresIn = resp.expires_in;
+  if (expiresIn < 60) expiresIn = 60;
+  return {
+    access_token: resp.access_token,
+    refresh_token: resp.refresh_token ?? "",
+    expires_at: new Date(Date.now() + expiresIn * 1e3).toISOString(),
+    scope: resp.scope ?? "",
+    client_id: clientID,
+    server_url: serverURL
+  };
+}
+async function openBrowser(url) {
+  const { spawn } = await import('child_process');
+  let cmd;
+  let args;
+  switch (process.platform) {
+    case "darwin":
+      cmd = "open";
+      args = [url];
+      break;
+    case "linux":
+      cmd = "xdg-open";
+      args = [url];
+      break;
+    case "win32":
+      cmd = "rundll32";
+      args = ["url.dll,FileProtocolHandler", url];
+      break;
+    default:
+      throw new Error(`unsupported platform: ${process.platform}`);
+  }
+  return new Promise((resolve, reject) => {
+    try {
+      const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
+      child.on("error", reject);
+      child.unref();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+function withTimeout(ms, parent) {
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), ms);
+  let parentHandler;
+  if (parent) {
+    if (parent.aborted) {
+      ctl.abort();
+    } else {
+      parentHandler = () => ctl.abort();
+      parent.addEventListener("abort", parentHandler);
+    }
+  }
+  return {
+    signal: ctl.signal,
+    dispose() {
+      clearTimeout(timer);
+      if (parentHandler && parent) parent.removeEventListener("abort", parentHandler);
+    }
+  };
+}
+
+// src/scopes.ts
+var ScopeAI = "ai";
+var ScopeSkills = "skills";
+var ScopeAccount = "account";
+var ScopeModels = "models";
+var ScopeModelsChat = "models:chat";
+var ScopeEntitlements = "entitlements";
+var ScopeTokenPackages = "token-packages";
+var ScopeSkillStore = "skill_store";
+var ScopeTools = "tools";
+var ScopeToolsExecute = "tools:execute";
+var ScopeWallet = "wallet";
+var ScopeWalletReadonly = "wallet:readonly";
+var ScopeProfile = "profile";
+function allScopes() {
+  return [ScopeAI, ScopeSkills, ScopeAccount];
+}
+function modelScopes() {
+  return [ScopeAI];
+}
+function commerceScopes() {
+  return [ScopeAI, ScopeAccount];
+}
+function skillScopes() {
+  return [ScopeSkills];
+}
+
+// src/store.ts
+var FileTokenStore = class {
+  path;
+  /** 简单串行化锁 (替代 Go sync.Mutex) */
+  chain = Promise.resolve();
+  constructor(path) {
+    if (typeof process === "undefined" || !process.versions || !process.versions.node) {
+      throw new Error("FileTokenStore requires Node.js environment; use LocalStorageTokenStore or InMemoryTokenStore in browser");
+    }
+    if (path && path !== "") {
+      this.path = path;
+    } else {
+      this.path = "";
+    }
+  }
+  async resolvePath() {
+    if (this.path && this.path !== "") return this.path;
+    const os = await import('os');
+    const path = await import('path');
+    this.path = path.join(os.homedir(), ".acosmi", "tokens.json");
+    return this.path;
+  }
+  withLock(fn) {
+    const next = this.chain.then(fn, fn);
+    this.chain = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  }
+  save(tokens) {
+    return this.withLock(async () => {
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      const p = await this.resolvePath();
+      const dir = path.dirname(p);
+      await fs.mkdir(dir, { recursive: true, mode: 448 });
+      const data = JSON.stringify(tokens, null, 2);
+      await fs.writeFile(p, data, { encoding: "utf8", mode: 384 });
+    });
+  }
+  load() {
+    return this.withLock(async () => {
+      const fs = await import('fs/promises');
+      const p = await this.resolvePath();
+      try {
+        const data = await fs.readFile(p, "utf8");
+        return JSON.parse(data);
+      } catch (e) {
+        if (isNotExistError(e)) return null;
+        throw new Error(
+          `read token file: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    });
+  }
+  clear() {
+    return this.withLock(async () => {
+      const fs = await import('fs/promises');
+      const p = await this.resolvePath();
+      try {
+        await fs.unlink(p);
+      } catch (e) {
+        if (isNotExistError(e)) return;
+        throw e;
+      }
+    });
+  }
+};
+function isNotExistError(e) {
+  if (typeof e === "object" && e !== null && "code" in e) {
+    return e.code === "ENOENT";
+  }
+  return false;
+}
+function newFileTokenStore(path) {
+  return new FileTokenStore(path);
+}
+var LocalStorageTokenStore = class {
+  key;
+  constructor(key = "acosmi.tokens") {
+    if (typeof globalThis.localStorage === "undefined") {
+      throw new Error("LocalStorageTokenStore requires browser environment");
+    }
+    this.key = key;
+  }
+  async save(tokens) {
+    globalThis.localStorage.setItem(this.key, JSON.stringify(tokens));
+  }
+  async load() {
+    const data = globalThis.localStorage.getItem(this.key);
+    if (data == null || data === "") return null;
+    try {
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async clear() {
+    globalThis.localStorage.removeItem(this.key);
+  }
+};
+var InMemoryTokenStore = class {
+  tokens = null;
+  async save(tokens) {
+    this.tokens = tokens;
+  }
+  async load() {
+    return this.tokens;
+  }
+  async clear() {
+    this.tokens = null;
+  }
+};
+
+// src/retry.ts
+init_types();
+var DefaultRetryPolicy = {
+  maxAttempts: 2,
+  backoffMs: 200,
+  backoffMaxMs: 2e3,
+  backoffMul: 2,
+  onRetryable: defaultRetryable,
+  safeToRetry: defaultSafeToRetry
+};
+function defaultSafeToRetry(req) {
+  switch (req.method.toUpperCase()) {
+    case "GET":
+    case "HEAD":
+    case "OPTIONS":
+      return true;
+  }
+  return false;
+}
+function defaultRetryable(err) {
+  if (err == null) return false;
+  if (err instanceof StreamError) return false;
+  if (err instanceof HTTPError) {
+    return err.statusCode >= 500 || err.statusCode === 429;
+  }
+  if (err instanceof NetworkError) {
+    return err.isTimeout() || err.isEOF();
+  }
+  return false;
+}
+function effectivePolicy(p) {
+  if (p == null) return null;
+  const out = {
+    maxAttempts: p.maxAttempts && p.maxAttempts > 0 ? p.maxAttempts : DefaultRetryPolicy.maxAttempts,
+    backoffMs: p.backoffMs && p.backoffMs > 0 ? p.backoffMs : DefaultRetryPolicy.backoffMs,
+    backoffMaxMs: p.backoffMaxMs && p.backoffMaxMs > 0 ? p.backoffMaxMs : DefaultRetryPolicy.backoffMaxMs,
+    backoffMul: p.backoffMul && p.backoffMul > 0 ? p.backoffMul : DefaultRetryPolicy.backoffMul,
+    onRetryable: p.onRetryable ?? defaultRetryable,
+    safeToRetry: p.safeToRetry ?? defaultSafeToRetry
+  };
+  return out;
+}
+var retryAfterUpperBoundMs = 6e4;
+function computeBackoff(p, attempt, err) {
+  if (err instanceof HTTPError && err.retryAfter > 0) {
+    const ms = err.retryAfter * 1e3;
+    return Math.min(ms, retryAfterUpperBoundMs);
+  }
+  let d = p.backoffMs;
+  for (let i = 0; i < attempt; i++) {
+    d = d * p.backoffMul;
+    if (d > p.backoffMaxMs) return p.backoffMaxMs;
+  }
+  return d;
+}
+
+// src/sanitize/index.ts
+var sanitize_exports = {};
+__export(sanitize_exports, {
+  BlockCodeExecutionToolResult: () => BlockCodeExecutionToolResult,
+  BlockContainerUpload: () => BlockContainerUpload,
+  BlockDeniedError: () => BlockDeniedError,
+  BlockDocument: () => BlockDocument,
+  BlockImage: () => BlockImage,
+  BlockMCPToolResult: () => BlockMCPToolResult,
+  BlockMCPToolUse: () => BlockMCPToolUse,
+  BlockRedactedThinking: () => BlockRedactedThinking,
+  BlockSearchResult: () => BlockSearchResult,
+  BlockServerToolUse: () => BlockServerToolUse,
+  BlockText: () => BlockText,
+  BlockThinking: () => BlockThinking,
+  BlockToolReference: () => BlockToolReference,
+  BlockToolResult: () => BlockToolResult,
+  BlockToolUse: () => BlockToolUse,
+  BlockVideo: () => BlockVideo,
+  BlockWebSearchToolResult: () => BlockWebSearchToolResult,
+  DeltaCitations: () => DeltaCitations,
+  DeltaInputJSON: () => DeltaInputJSON,
+  DeltaSignature: () => DeltaSignature,
+  DeltaText: () => DeltaText,
+  DeltaThinking: () => DeltaThinking,
+  EphemeralMarkerField: () => EphemeralMarkerField,
+  ErrBlockDenied: () => ErrBlockDenied,
+  ErrHistoryTooDeep: () => ErrHistoryTooDeep,
+  HistoryTooDeepError: () => HistoryTooDeepError,
+  SizeError: () => SizeError,
+  dropBlocks: () => dropBlocks,
+  sanitize: () => sanitize,
+  stripEphemeral: () => stripEphemeral
+});
+
+// src/sanitize/types.ts
+var BlockText = "text";
+var BlockImage = "image";
+var BlockVideo = "video";
+var BlockDocument = "document";
+var BlockSearchResult = "search_result";
+var BlockThinking = "thinking";
+var BlockRedactedThinking = "redacted_thinking";
+var BlockToolUse = "tool_use";
+var BlockToolResult = "tool_result";
+var BlockToolReference = "tool_reference";
+var BlockServerToolUse = "server_tool_use";
+var BlockWebSearchToolResult = "web_search_tool_result";
+var BlockCodeExecutionToolResult = "code_execution_tool_result";
+var BlockMCPToolUse = "mcp_tool_use";
+var BlockMCPToolResult = "mcp_tool_result";
+var BlockContainerUpload = "container_upload";
+var DeltaText = "text_delta";
+var DeltaInputJSON = "input_json_delta";
+var DeltaThinking = "thinking_delta";
+var DeltaSignature = "signature_delta";
+var DeltaCitations = "citations_delta";
+var EphemeralMarkerField = "acosmi_ephemeral";
+
+// src/sanitize/config.ts
+var HistoryTooDeepError = class extends Error {
+  constructor() {
+    super("sanitize: messages history exceeds configured depth");
+    this.name = "HistoryTooDeepError";
+  }
+};
+var BlockDeniedError = class extends Error {
+  constructor() {
+    super("sanitize: block type permanently denied");
+    this.name = "BlockDeniedError";
+  }
+};
+var SizeError = class extends Error {
+  blockType;
+  actual;
+  limit;
+  constructor(blockType, actual, limit) {
+    super(`sanitize: ${blockType} base64 size ${actual} exceeds limit ${limit}`);
+    this.name = "SizeError";
+    this.blockType = blockType;
+    this.actual = actual;
+    this.limit = limit;
+  }
+};
+var ErrHistoryTooDeep = new HistoryTooDeepError();
+var ErrBlockDenied = new BlockDeniedError();
+
+// src/sanitize/history.ts
+function dropBlocks(messages, pred) {
+  const droppedToolUseIDs = collectDroppedToolUseIDs(messages, pred);
+  const out = [];
+  for (const msg of messages) {
+    if (!isPlainObject(msg)) {
+      out.push(msg);
+      continue;
+    }
+    const content = msg["content"];
+    if (!Array.isArray(content)) {
+      out.push(msg);
+      continue;
+    }
+    const { kept, changed } = filterBlocks(content, pred, droppedToolUseIDs);
+    if (!changed) {
+      out.push(msg);
+      continue;
+    }
+    if (kept.length === 0) {
+      continue;
+    }
+    const newMsg = { ...msg };
+    newMsg["content"] = kept;
+    out.push(newMsg);
+  }
+  return out;
+}
+function collectDroppedToolUseIDs(messages, pred) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (!isPlainObject(msg)) continue;
+    const content = msg["content"];
+    if (!Array.isArray(content)) continue;
+    for (const raw of content) {
+      if (!isPlainObject(raw)) continue;
+      if (!pred(raw)) continue;
+      const t = raw["type"];
+      if (typeof t !== "string") continue;
+      if (t === "tool_use" || t === "server_tool_use" || t === "mcp_tool_use") {
+        const id = raw["id"];
+        if (typeof id === "string" && id !== "") ids.add(id);
+      }
+    }
+  }
+  return ids;
+}
+function filterBlocks(content, pred, droppedToolUseIDs) {
+  const kept = [];
+  let changed = false;
+  for (const raw of content) {
+    if (!isPlainObject(raw)) {
+      kept.push(raw);
+      continue;
+    }
+    if (pred(raw)) {
+      changed = true;
+      continue;
+    }
+    if (droppedToolUseIDs.size > 0) {
+      const t = raw["type"];
+      if (t === "tool_result" || t === "mcp_tool_result") {
+        const id = raw["tool_use_id"];
+        if (typeof id === "string" && id !== "" && droppedToolUseIDs.has(id)) {
+          changed = true;
+          continue;
+        }
+      }
+    }
+    kept.push(raw);
+  }
+  return { kept, changed };
+}
+function stripEphemeral(messages) {
+  return dropBlocks(messages, (b) => {
+    const t = b["type"];
+    if (t === "thinking" || t === "redacted_thinking") {
+      return false;
+    }
+    const v = b[EphemeralMarkerField];
+    return v === true;
+  });
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+// src/sanitize/defensive.ts
+function sanitize(messages, cfg) {
+  if ((cfg.maxMessagesTurns ?? 0) > 0 && messages.length > cfg.maxMessagesTurns) {
+    throw ErrHistoryTooDeep;
+  }
+  if ((cfg.maxImageBytes ?? 0) > 0 || (cfg.maxVideoBytes ?? 0) > 0 || (cfg.maxPDFBytes ?? 0) > 0) {
+    checkMediaSizes(messages, cfg);
+  }
+  if (cfg.permanentDenyBlocks && cfg.permanentDenyBlocks.length > 0) {
+    const denySet = /* @__PURE__ */ new Set();
+    for (const bt of cfg.permanentDenyBlocks) denySet.add(bt);
+    messages = dropBlocks(messages, (b) => {
+      const t = b["type"];
+      return typeof t === "string" && denySet.has(t);
+    });
+  }
+  return messages;
+}
+function checkMediaSizes(messages, cfg) {
+  for (const msg of messages) {
+    if (!isPlainObject2(msg)) continue;
+    const content = msg["content"];
+    if (!Array.isArray(content)) continue;
+    for (const raw of content) {
+      if (!isPlainObject2(raw)) continue;
+      const bt = raw["type"];
+      if (typeof bt !== "string") continue;
+      let limit = 0;
+      switch (bt) {
+        case "image":
+          limit = cfg.maxImageBytes ?? 0;
+          break;
+        case "video":
+          limit = cfg.maxVideoBytes ?? 0;
+          break;
+        case "document":
+          limit = cfg.maxPDFBytes ?? 0;
+          break;
+        default:
+          continue;
+      }
+      if (limit <= 0) continue;
+      const data = extractBase64Data(raw);
+      if (data === "") continue;
+      const actual = base64DecodedLen(data);
+      if (actual > limit) {
+        throw new SizeError(bt, actual, limit);
+      }
+    }
+  }
+}
+function extractBase64Data(block) {
+  const src = block["source"];
+  if (!isPlainObject2(src)) return "";
+  if (src["type"] !== "base64") return "";
+  const dataRaw = src["data"];
+  if (typeof dataRaw !== "string") return "";
+  let data = dataRaw;
+  const i = data.indexOf("base64,");
+  if (i >= 0) {
+    data = data.slice(i + "base64,".length);
+  }
+  return data;
+}
+function base64DecodedLen(b64) {
+  const n = b64.length;
+  let pad = 0;
+  if (n >= 1 && b64[n - 1] === "=") pad++;
+  if (n >= 2 && b64[n - 2] === "=") pad++;
+  return Math.floor(n * 3 / 4) - pad;
+}
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+// src/stream-meta.ts
+function extractAnthropicBlockMeta(eventType, data, blockTypeMap) {
+  switch (eventType) {
+    case "content_block_start": {
+      let payload;
+      try {
+        payload = JSON.parse(data);
+      } catch {
+        return [0, "", false];
+      }
+      const index = payload.index ?? 0;
+      const meta = {
+        type: payload.content_block?.type ?? "",
+        ephemeral: payload.content_block?.acosmi_ephemeral ?? false
+      };
+      blockTypeMap.set(index, meta);
+      return [index, meta.type, meta.ephemeral];
+    }
+    case "content_block_delta": {
+      let payload;
+      try {
+        payload = JSON.parse(data);
+      } catch {
+        return [0, "", false];
+      }
+      const index = payload.index ?? 0;
+      const meta = blockTypeMap.get(index);
+      return [index, meta?.type ?? "", meta?.ephemeral ?? false];
+    }
+    case "content_block_stop": {
+      let payload;
+      try {
+        payload = JSON.parse(data);
+      } catch {
+        return [0, "", false];
+      }
+      const index = payload.index ?? 0;
+      const meta = blockTypeMap.get(index);
+      blockTypeMap.delete(index);
+      return [index, meta?.type ?? "", meta?.ephemeral ?? false];
+    }
+    default:
+      return [0, "", false];
+  }
+}
+
+// src/index.ts
+init_betas();
+
+// src/client.ts
+init_types();
+init_adapters();
+init_openai();
+
+// src/client-helpers.ts
+init_types();
+var maxDownloadSize = 50 * 1024 * 1024;
+var maxErrorBodySize = 1 * 1024 * 1024;
+var maxSSELineSize = 1 * 1024 * 1024;
+var modelCacheTTLMs = 5 * 60 * 1e3;
+var coefCacheTTLMs = 8 * 1e3;
+function parseHTTPErrorWithHeader(statusCode, body, header) {
+  const bodyStr = typeof body === "string" ? body : new TextDecoder().decode(body);
+  let retryAfter = 0;
+  if (header) {
+    const ra = header.get("Retry-After");
+    if (ra) {
+      const sec = parseInt(ra, 10);
+      if (!isNaN(sec) && sec > 0) retryAfter = sec;
+    }
+  }
+  if (bodyStr.length === 0) {
+    return new HTTPError(statusCode, { retryAfter });
+  }
+  let type = "";
+  let message = "";
+  try {
+    const obj = JSON.parse(bodyStr);
+    if (obj && typeof obj === "object") {
+      const errObj = obj.error;
+      if (errObj && typeof errObj === "object") {
+        const e = errObj;
+        if (typeof e.message === "string") message = e.message;
+        if (typeof e.type === "string") type = e.type;
+      }
+    }
+  } catch {
+  }
+  return new HTTPError(statusCode, { type, message, retryAfter, body: bodyStr });
+}
+function classifyTransport(op, urlStr, err) {
+  const ne = new NetworkError(op, urlStr, err);
+  if (err instanceof Error) {
+    if (err.name === "AbortError") {
+      ne.timeout = true;
+      return ne;
+    }
+    const cause = err.cause;
+    if (cause) {
+      if (cause.code === "UND_ERR_CONNECT_TIMEOUT" || cause.code === "UND_ERR_HEADERS_TIMEOUT" || cause.code === "ETIMEDOUT") {
+        ne.timeout = true;
+        return ne;
+      }
+      if (cause.code === "ECONNRESET" || cause.code === "EPIPE" || cause.code === "ECONNREFUSED" || cause.code === "EAI_AGAIN") {
+        ne.eof = true;
+        return ne;
+      }
+    }
+    const msg = err.message;
+    if (msg.includes("EOF") || msg.includes("connection reset") || msg.includes("broken pipe")) {
+      ne.eof = true;
+    }
+  }
+  return ne;
+}
+function parseStreamError(data) {
+  let payload;
+  try {
+    payload = JSON.parse(data);
+  } catch {
+    return new StreamError({ rawError: data });
+  }
+  let code = payload.errorCode ?? "";
+  const stage = payload.stage ?? "";
+  let message = payload.message ?? "";
+  const retryable = payload.retryable ?? false;
+  let rawError = "";
+  if (payload.error != null) {
+    if (typeof payload.error === "string") {
+      rawError = payload.error;
+    } else if (typeof payload.error === "object") {
+      const errObj = payload.error;
+      rawError = JSON.stringify(payload.error);
+      if (message === "" && errObj.message) message = errObj.message;
+      if (code === "" && errObj.type) code = errObj.type;
+    }
+  }
+  return new StreamError({ code, stage, message, rawError, retryable });
+}
+function isOrderSuccess(status) {
+  switch (status) {
+    case "PAID":
+    case "SUCCESS":
+    case "COMPLETED":
+      return true;
+  }
+  return false;
+}
+function isOrderTerminal(status) {
+  switch (status) {
+    case "PAID":
+    case "SUCCESS":
+    case "COMPLETED":
+    case "FAILED":
+    case "CANCELLED":
+    case "CLOSED":
+    case "EXPIRED":
+    case "REFUNDED":
+      return true;
+  }
+  return false;
+}
+async function* iterSSELines(body, maxLineBytes = maxSSELineSize) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buf = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      let nlIdx;
+      while ((nlIdx = buf.indexOf("\n")) >= 0) {
+        let line = buf.slice(0, nlIdx);
+        buf = buf.slice(nlIdx + 1);
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        yield line;
+      }
+      if (buf.length > maxLineBytes) {
+        throw new Error(`SSE line exceeds ${maxLineBytes} bytes`);
+      }
+    }
+    buf += decoder.decode();
+    if (buf.length > 0) {
+      if (buf.endsWith("\r")) buf = buf.slice(0, -1);
+      if (buf !== "") yield buf;
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+async function readLimited(body, maxBytes) {
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (total + value.byteLength > maxBytes) {
+        const remain = maxBytes - total;
+        if (remain > 0) chunks.push(value.subarray(0, remain));
+        break;
+      }
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+  let len = 0;
+  for (const c of chunks) len += c.byteLength;
+  const out = new Uint8Array(len);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.byteLength;
+  }
+  return out;
+}
+async function readLimitedText(body, maxBytes) {
+  const buf = await readLimited(body, maxBytes);
+  return new TextDecoder("utf-8").decode(buf);
+}
+
+// src/client.ts
+var FilterStatusOK = "ok";
+var FilterStatusAdminBypass = "admin-bypass";
+var FilterStatusInternalBypass = "internal-bypass";
+var FilterStatusDisabledByFlag = "disabled-by-flag";
+var FilterStatusFallbackTkdistError = "fallback-tkdist-error";
+var FilterStatusFallbackTkdistSkew = "fallback-tkdist-deployment-skew";
+var FilterStatusFallbackNoBuckets = "fallback-no-buckets";
+var FilterStatusFallbackMissingUser = "fallback-missing-userid";
+var FilterStatusUnknown = "";
+function newDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((r, j) => {
+    resolve = r;
+    reject = j;
+  });
+  return { promise, resolve, reject };
+}
+var Client = class _Client {
+  /** SDK 内部使用 — 业务方法 (mixin) 通过 this.* 访问以下字段 */
+  /** 服务器根地址 (已 trim 尾随 /) */
+  serverURL;
+  /** OAuth metadata (lazy loaded) */
+  meta = null;
+  /** 当前 token (内存) */
+  tokens = null;
+  /** token 持久化 */
+  store;
+  /** fetch 实现 (默认 globalThis.fetch) */
+  fetchImpl;
+  /** 互斥锁 (TS 用 Promise chain 替代 sync.Mutex) */
+  mu = Promise.resolve();
+  /** WebSocket 状态 (实际方法由 ws.ts mixin 维护) */
+  ws = null;
+  /** v0.15.1: token 就绪等待机制 — login 成功后 resolve, 等待方解除阻塞 */
+  tokenReady = newDeferred();
+  /** Login 进行中 — 等待方需等而非 fail-fast */
+  loginInFlight = false;
+  /** 防止 tokenReady 被多次 resolve (替代 Go sync.Once) */
+  tokenReadyResolved = false;
+  /** 模型能力缓存 (CrabCode 扩展) */
+  modelCache = [];
+  modelCacheTimeMs = 0;
+  /** sanitize-bridge 配置 (默认禁用) */
+  defensiveCfg = null;
+  autoStripEphemeral = false;
+  /** L6 (v0.15): 重试策略. null = 禁用 (v0.14.1 行为) */
+  retryPolicy;
+  /** V29 系数缓存 (TTL 8s, listCoefficients 内部用) */
+  coefCacheData = null;
+  coefCacheTimeMs = 0;
+  /** 串行化锁 (替代 Go sync.Mutex) */
+  coefMu = Promise.resolve();
+  constructor(cfg = {}) {
+    this.serverURL = (cfg.serverURL ?? "https://acosmi.com").replace(/\/+$/, "");
+    this.store = cfg.store ?? defaultTokenStore();
+    this.fetchImpl = cfg.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.retryPolicy = effectivePolicy(cfg.retryPolicy ?? null);
+  }
+  /**
+   * 异步初始化 (从 store 加载已有 token)
+   * 替代 Go NewClient (Go 同步 IO, TS 必须 async)
+   */
+  static async create(cfg = {}) {
+    const c = new _Client(cfg);
+    try {
+      const tokens = await c.store.load();
+      if (tokens) {
+        c.tokens = tokens;
+        if (!c.tokenReadyResolved) {
+          c.tokenReadyResolved = true;
+          c.tokenReady.resolve();
+        }
+      }
+    } catch {
+    }
+    return c;
+  }
+  // ===========================================================================
+  // 授权生命周期
+  // ===========================================================================
+  /** 是否已授权 (有可用 token) */
+  isAuthorized() {
+    return this.tokens != null;
+  }
+  /** 当前 token 信息 (用于 CLI whoami 显示) */
+  getTokenSet() {
+    return this.tokens;
+  }
+  getCachedClientID() {
+    return this.tokens?.client_id ?? "";
+  }
+  /**
+   * 完整授权流程: 发现 → 注册 → 授权 → 换 token → 持久化
+   * @param appName 桌面智能体名称 (如 "CrabClaw Desktop")
+   * @param scopes 请求的权限范围 (参考 allScopes / modelScopes / commerceScopes 等预设)
+   */
+  async login(appName, scopes, signal) {
+    return this.loginInternal(appName, scopes, void 0, signal);
+  }
+  /**
+   * 带事件回调的登录流程 — CrabCode 使用
+   *
+   * handler 在以下时刻被调用:
+   *   - EventAuthURL:  授权 URL 已就绪, 调用方可展示/打开浏览器
+   *   - EventComplete: 登录成功, tokens 已持久化
+   *   - EventError:    某步骤失败, 附 ErrCode 分类码
+   *
+   * 当 handler 为 null 时, 行为与 login() 完全一致。
+   */
+  async loginWithHandler(appName, scopes, handler, opts = {}, signal) {
+    return this.loginInternal(appName, scopes, { handler, ...opts }, signal);
+  }
+  async loginInternal(appName, scopes, opts, signal) {
+    const handler = opts?.handler ?? void 0;
+    const emit = (e) => {
+      if (handler) handler(e);
+    };
+    const emitError = (code, err) => {
+      emit({
+        type: EventError,
+        err_code: code,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    };
+    this.loginInFlight = true;
+    try {
+      let meta;
+      try {
+        meta = await discover(this.serverURL, signal);
+      } catch (err) {
+        emitError(ErrDiscovery, err);
+        throw new Error(`discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      this.meta = meta;
+      let clientID = this.getCachedClientID();
+      if (clientID === "") {
+        try {
+          const reg = await register(meta, appName, signal);
+          clientID = reg.client_id;
+        } catch (err) {
+          emitError(ErrRegistration, err);
+          throw new Error(
+            `registration failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      let result;
+      let verifier;
+      try {
+        const r = await authorize(meta, clientID, scopes, { ...opts, handler, signal });
+        result = r.result;
+        verifier = r.verifier;
+      } catch (err) {
+        try {
+          const reg = await register(meta, appName, signal);
+          clientID = reg.client_id;
+        } catch (regErr) {
+          emitError(ErrRegistration, regErr);
+          throw new Error(
+            `authorization failed (retry registration also failed): ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        try {
+          const r = await authorize(meta, clientID, scopes, { ...opts, handler, signal });
+          result = r.result;
+          verifier = r.verifier;
+        } catch (err2) {
+          throw new Error(
+            `authorization failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+          );
+        }
+      }
+      let tokenResp;
+      try {
+        if (opts?.expiresIn && opts.expiresIn > 0) {
+          tokenResp = await exchangeCodeWithExpiry(
+            meta,
+            clientID,
+            result.code,
+            result.redirectURI,
+            verifier,
+            opts.expiresIn,
+            signal
+          );
+        } else {
+          tokenResp = await exchangeCode(
+            meta,
+            clientID,
+            result.code,
+            result.redirectURI,
+            verifier,
+            signal
+          );
+        }
+      } catch (err) {
+        const code = isSSLError(err) ? ErrSSLProxy : ErrTokenExchange;
+        emitError(code, err);
+        throw new Error(
+          `token exchange failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      const tokens = newTokenSet(tokenResp, clientID, this.serverURL);
+      this.tokens = tokens;
+      if (!this.tokenReadyResolved) {
+        this.tokenReadyResolved = true;
+        this.tokenReady.resolve();
+      }
+      try {
+        await this.store.save(tokens);
+      } catch (err) {
+        throw new Error(`save tokens: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      emit({ type: EventComplete });
+    } finally {
+      this.loginInFlight = false;
+    }
+  }
+  /** 吊销 token 并清除本地存储 */
+  async logout(signal) {
+    const tokens = this.tokens;
+    let meta = this.meta;
+    this.tokens = null;
+    this.meta = null;
+    this.tokenReady = newDeferred();
+    this.tokenReadyResolved = false;
+    if (tokens) {
+      if (!meta) {
+        try {
+          meta = await discover(this.serverURL, signal);
+        } catch (e) {
+          console.warn(`[acosmi-sdk] warning: discover for revocation failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+      }
+      if (meta) {
+        try {
+          await revokeToken(meta, tokens.access_token, signal);
+        } catch {
+        }
+        try {
+          await revokeToken(meta, tokens.refresh_token, signal);
+        } catch {
+        }
+      }
+    }
+    await this.store.clear();
+  }
+  // ===========================================================================
+  // Token 管理
+  // ===========================================================================
+  /**
+   * 确保有有效的 access_token, 过期则自动刷新
+   *
+   * v0.15.1: 当 tokens==null 且 login 正在并发进行中时, 阻塞等待 token 就绪,
+   * 避免应用启动期 "login + 多个 API 调用" 并发场景下 4+ 条 "not authorized" 误报.
+   */
+  async ensureToken(signal) {
+    let tokens = this.tokens;
+    const ready = this.tokenReady.promise;
+    const inFlight = this.loginInFlight;
+    if (tokens == null) {
+      if (!inFlight) {
+        throw new Error("not authorized, call login() first");
+      }
+      let abortHandler;
+      try {
+        await Promise.race([
+          ready,
+          new Promise((_, reject) => {
+            if (signal) {
+              if (signal.aborted) reject(new Error(`waiting for token: aborted`));
+              else {
+                abortHandler = () => reject(new Error(`waiting for token: aborted`));
+                signal.addEventListener("abort", abortHandler);
+              }
+            }
+          })
+        ]);
+      } finally {
+        if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
+      }
+      tokens = this.tokens;
+      if (tokens == null) {
+        throw new Error("not authorized, call login() first");
+      }
+    }
+    if (!tokenSetIsExpired(tokens)) {
+      return tokens.access_token;
+    }
+    return this.withMu(async () => {
+      if (this.tokens == null) {
+        throw new Error("not authorized, call login() first");
+      }
+      if (!tokenSetIsExpired(this.tokens)) {
+        return this.tokens.access_token;
+      }
+      if (this.meta == null) {
+        try {
+          this.meta = await discover(this.serverURL, signal);
+        } catch (e) {
+          throw new Error(
+            `discover for refresh: ${e instanceof Error ? e.message : String(e)}`
+          );
+        }
+      }
+      let tokenResp;
+      try {
+        tokenResp = await refreshToken(this.meta, this.tokens.client_id, this.tokens.refresh_token, signal);
+      } catch (e) {
+        throw new Error(`refresh token: ${e instanceof Error ? e.message : String(e)}`);
+      }
+      this.tokens = newTokenSet(tokenResp, this.tokens.client_id, this.serverURL);
+      try {
+        await this.store.save(this.tokens);
+      } catch (e) {
+        console.warn(`[acosmi-sdk] warning: save refreshed token failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+      return this.tokens.access_token;
+    });
+  }
+  /** 强制刷新 token (用于 401 重试) */
+  async forceRefresh(signal) {
+    return this.withMu(async () => {
+      if (this.tokens == null) {
+        throw new Error("no tokens to refresh");
+      }
+      if (this.meta == null) {
+        this.meta = await discover(this.serverURL, signal);
+      }
+      const tokenResp = await refreshToken(
+        this.meta,
+        this.tokens.client_id,
+        this.tokens.refresh_token,
+        signal
+      );
+      this.tokens = newTokenSet(tokenResp, this.tokens.client_id, this.serverURL);
+      try {
+        await this.store.save(this.tokens);
+      } catch (e) {
+        console.warn(
+          `[acosmi-sdk] warning: save refreshed token failed: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    });
+  }
+  /** 互斥锁 helper (替代 Go sync.Mutex) */
+  withMu(fn) {
+    const next = this.mu.then(fn, fn);
+    this.mu = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  }
+  // ===========================================================================
+  // Managed Models
+  // ===========================================================================
+  /**
+   * 获取可用的托管模型列表.
+   *
+   * V30 二轮审计 D-P1-2: 此方法不返回 entitlement-filter-status header.
+   * UI 想根据 fallback 状态显示降级提示, 请改调 listModelsWithStatus.
+   */
+  async listModels(signal) {
+    const r = await this.listModelsWithStatus(signal);
+    return r.models;
+  }
+  /**
+   * 获取可用模型列表, 同时返回 X-Entitlement-Filter-Status header.
+   *
+   * V30 二轮审计 D-P1-2: 老 listModels 丢弃 header 让 SDK 用户无法识别 fail-OPEN 降级状态,
+   * 此方法暴露 status 让 UI 可:
+   *   - status === 'ok' → 正常显示 BucketInfo 余量
+   *   - status === 'fallback-tkdist-error' → 灰显余量 + toast "tk-dist 离线, 模型列表降级"
+   *   - status === 'disabled-by-flag' → 不显示余量 (运维灰度中)
+   *   - status === '' (Unknown) → 老 nexus, 按老 v0.17 行为 (不显示 BucketInfo)
+   */
+  async listModelsWithStatus(signal) {
+    const { result, headers } = await this.doJSONFull(
+      "GET",
+      "/managed-models",
+      null,
+      signal
+    );
+    this.modelCache = result.data;
+    this.modelCacheTimeMs = Date.now();
+    let status = "";
+    if (headers) {
+      const h = headers.get("X-Entitlement-Filter-Status");
+      if (h) status = h;
+    }
+    return { models: result.data, status };
+  }
+  /** 查询当前用户账户级权益总览 (v0.19+) */
+  async getQuotaSummary(signal) {
+    const resp = await this.doJSON(
+      "GET",
+      "/entitlements/quota-summary",
+      null,
+      signal
+    );
+    return resp.data;
+  }
+  /**
+   * 查询单个模型的能力矩阵
+   * 优先从 listModels 缓存读取, miss 时调用 listModels 刷新
+   */
+  async getModelCapabilities(modelID, signal) {
+    let caps = this.getCachedCapabilities(modelID);
+    if (caps) return caps;
+    await this.listModels(signal);
+    caps = this.getCachedCapabilities(modelID);
+    if (caps) return caps;
+    return zeroModelCapabilities();
+  }
+  getCachedCapabilities(modelID) {
+    if (this.modelCache.length === 0 || Date.now() - this.modelCacheTimeMs > modelCacheTTLMs) {
+      return null;
+    }
+    for (const m of this.modelCache) {
+      if (m.id === modelID || m.modelId === modelID) {
+        return m.capabilities;
+      }
+    }
+    return null;
+  }
+  /** 从缓存中查找完整 ManagedModel (未命中返 null) */
+  getCachedModel(modelID) {
+    for (const m of this.modelCache) {
+      if (m.id === modelID || m.modelId === modelID) return m;
+    }
+    return null;
+  }
+  /** 测试辅助: 把占位 ManagedModel 塞入缓存. 仅测试用. */
+  primeModelCacheForTest(...ids) {
+    for (const id of ids) {
+      this.modelCache.push({
+        id,
+        name: "",
+        provider: "anthropic",
+        modelId: id,
+        maxTokens: 0,
+        isEnabled: true,
+        capabilities: zeroModelCapabilities()
+      });
+    }
+    this.modelCacheTimeMs = Date.now();
+  }
+  /**
+   * 确保指定 modelID 的 ManagedModel 已在缓存中。
+   *
+   * 语义:
+   *   1. 若缓存命中 → 直接返回
+   *   2. 若未命中 → 调 listModels 刷新一次
+   *   3. 刷新后仍未命中 → 抛 ModelNotFoundError
+   *
+   * 根因修复: 消除未预热场景下 provider="anthropic" 硬编码回退,
+   * 该回退会让 DashScope/Zhipu/DeepSeek 等 non-anthropic 模型被按 Anthropic
+   * 格式编码并打到错误的 /anthropic 端点。
+   */
+  async ensureModelCached(modelID, signal) {
+    let m = this.getCachedModel(modelID);
+    if (m) return m;
+    await this.listModels(signal);
+    m = this.getCachedModel(modelID);
+    if (m) return m;
+    throw new ModelNotFoundError(modelID);
+  }
+  // ===========================================================================
+  // Chat
+  // ===========================================================================
+  /**
+   * 构建完整的聊天请求体 (v0.5.0 adapter 模式)
+   *
+   * 根据 provider 选择 adapter, 委托 buildRequestBody 构建格式化的请求体。
+   *
+   * v0.13.x: 前置 ensureModelCached, 消除冷缓存硬编码回退。未知 modelID 抛 ModelNotFoundError.
+   */
+  async buildChatRequest(modelID, req, signal) {
+    if (typeof this.applyRequestSanitizers === "function") {
+      this.applyRequestSanitizers(req);
+    }
+    const m = await this.ensureModelCached(modelID, signal);
+    const adapter = getAdapterForModel(m);
+    const caps = this.getCachedCapabilities(modelID) ?? zeroModelCapabilities();
+    const body = adapter.buildRequestBody(caps, req);
+    return { body: JSON.stringify(body), adapter };
+  }
+  /**
+   * 同步聊天 (适合短回复)
+   * 响应的 tokenRemaining / callRemaining 字段来自服务端 Header, 反映结算后余额
+   * v0.5.0: 根据 provider 自动路由到 /anthropic 或 /chat 端点
+   */
+  async chat(modelID, req, signal) {
+    req.stream = false;
+    const ctl = withRequestTimeout(5 * 60 * 1e3, signal);
+    try {
+      const { body, adapter } = await this.buildChatRequest(modelID, req, ctl.signal);
+      const endpoint = `/managed-models/${encodeURIComponent(modelID)}${adapter.endpointSuffix()}`;
+      const { result, headers } = await this.doJSONFullRaw("POST", endpoint, body, ctl.signal);
+      const resp = adapter.parseResponse(result);
+      const v1 = headers.get("X-Token-Remaining");
+      if (v1) {
+        const n = parseInt(v1, 10);
+        if (!isNaN(n)) resp.tokenRemaining = n;
+      }
+      const v2 = headers.get("X-Call-Remaining");
+      if (v2) {
+        const n = parseInt(v2, 10);
+        if (!isNaN(n)) resp.callRemaining = n;
+      }
+      const v3 = headers.get("X-Token-Remaining-Model");
+      if (v3) {
+        const n = parseInt(v3, 10);
+        if (!isNaN(n)) resp.modelTokenRemaining = n;
+      }
+      const v4 = headers.get("X-Token-Remaining-Model-ETU");
+      if (v4) {
+        const n = parseInt(v4, 10);
+        if (!isNaN(n)) resp.modelTokenRemainingETU = n;
+      }
+      return resp;
+    } finally {
+      ctl.dispose();
+    }
+  }
+  /**
+   * Anthropic 原生格式同步聊天
+   * v0.5.0: 根据 provider 自动路由
+   *   Anthropic → chatMessagesAnthropic (现有路径, POST /anthropic)
+   *   其他厂商 → chatMessagesOpenAI (POST /chat, 响应转换为 AnthropicResponse)
+   */
+  async chatMessages(modelID, req, signal) {
+    const m = await this.ensureModelCached(modelID, signal);
+    const adapter = getAdapterForModel(m);
+    if (adapter.format() === 0 /* Anthropic */) {
+      return this.chatMessagesAnthropic(modelID, req, adapter, signal);
+    }
+    return this.chatMessagesOpenAI(modelID, req, adapter, signal);
+  }
+  async chatMessagesAnthropic(modelID, req, adapter, signal) {
+    req.stream = false;
+    const ctl = withRequestTimeout(5 * 60 * 1e3, signal);
+    try {
+      const caps = this.getCachedCapabilities(modelID) ?? zeroModelCapabilities();
+      const body = adapter.buildRequestBody(caps, req);
+      const data = JSON.stringify(body);
+      const { result } = await this.doJSONFullRaw(
+        "POST",
+        `/managed-models/${encodeURIComponent(modelID)}/anthropic`,
+        data,
+        ctl.signal
+      );
+      const rawStr = new TextDecoder().decode(result);
+      try {
+        const wrapper = JSON.parse(rawStr);
+        if (wrapper.data != null && wrapper.data !== null) {
+          const bizErr = apiResponseBusinessError({
+            code: wrapper.code ?? 0,
+            message: wrapper.message,
+            data: wrapper.data
+          });
+          if (bizErr) throw bizErr;
+          return wrapper.data;
+        }
+      } catch (e) {
+        if (e && typeof e === "object" && "name" in e && e.name === "BusinessError") throw e;
+      }
+      try {
+        return JSON.parse(rawStr);
+      } catch (e) {
+        throw new Error(`decode anthropic response: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    } finally {
+      ctl.dispose();
+    }
+  }
+  async chatMessagesOpenAI(modelID, req, adapter, signal) {
+    req.stream = false;
+    const ctl = withRequestTimeout(5 * 60 * 1e3, signal);
+    try {
+      const caps = this.getCachedCapabilities(modelID) ?? zeroModelCapabilities();
+      const body = adapter.buildRequestBody(caps, req);
+      const data = JSON.stringify(body);
+      const endpoint = `/managed-models/${encodeURIComponent(modelID)}${adapter.endpointSuffix()}`;
+      const { result } = await this.doJSONFullRaw("POST", endpoint, data, ctl.signal);
+      const { parseOpenAIResponseToAnthropic: parseOpenAIResponseToAnthropic2 } = await Promise.resolve().then(() => (init_openai(), openai_exports));
+      return parseOpenAIResponseToAnthropic2(result);
+    } finally {
+      ctl.dispose();
+    }
+  }
+  /**
+   * 流式聊天 (SSE), 通过 async generator 返回事件
+   * v0.5.0: 根据 adapter 路由端点
+   */
+  chatStream(modelID, req, signal) {
+    return {
+      [Symbol.asyncIterator]: () => this.chatStreamGen(modelID, req, signal, false)
+    };
+  }
+  /**
+   * Anthropic 原生格式流式聊天 (SSE)
+   * 调用 POST /managed-models/:id/anthropic, SSE 事件为 Anthropic 协议格式
+   * 无 started/settled/failed 自定义事件, 无 data: [DONE], message_stop 为自然结束
+   */
+  chatMessagesStream(modelID, req, signal) {
+    return {
+      [Symbol.asyncIterator]: () => this.chatMessagesStreamGen(modelID, req, signal, false)
+    };
+  }
+  async *chatStreamGen(modelID, req, signal, retried) {
+    req.stream = true;
+    const { body, adapter } = await this.buildChatRequest(modelID, req, signal);
+    const token = await this.ensureToken(signal);
+    const endpoint = `/managed-models/${encodeURIComponent(modelID)}${adapter.endpointSuffix()}`;
+    const url = this.apiURL(endpoint);
+    let resp;
+    try {
+      resp = await this.fetchImpl(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
+        body,
+        signal
+      });
+    } catch (e) {
+      throw classifyTransport("POST " + endpoint, url, e);
+    }
+    if (resp.status === 401 && !retried) {
+      try {
+        await resp.body?.cancel();
+      } catch {
+      }
+      try {
+        await this.forceRefresh(signal);
+      } catch (refreshErr) {
+        throw new Error(
+          `stream: unauthorized and refresh failed: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}`
+        );
+      }
+      yield* this.chatStreamGen(modelID, req, signal, true);
+      return;
+    }
+    if (!resp.ok) {
+      const bodyBytes = await readLimited(resp.body, maxErrorBodySize);
+      throw parseHTTPErrorWithHeader(resp.status, bodyBytes, resp.headers);
+    }
+    if (!resp.body) {
+      throw new Error("stream: empty response body");
+    }
+    let blockTypeMap = null;
+    if (adapter.format() === 0 /* Anthropic */) {
+      blockTypeMap = /* @__PURE__ */ new Map();
+    }
+    let currentEvent = "";
+    for await (const line of iterSSELines(resp.body)) {
+      if (line.startsWith("event:")) {
+        currentEvent = line.slice("event:".length).trim();
+      } else if (line.startsWith("data:")) {
+        const data = line.slice("data:".length).trim();
+        const parsed = adapter.parseStreamLine(currentEvent, data);
+        if (parsed.done) return;
+        const ev = parsed.event;
+        if (blockTypeMap) {
+          const [idx, bt, eph] = extractAnthropicBlockMeta(currentEvent, data, blockTypeMap);
+          if (bt !== "") {
+            ev.blockIndex = idx;
+            ev.blockType = bt;
+            ev.ephemeral = eph;
+          }
+        }
+        yield ev;
+      }
+    }
+  }
+  async *chatMessagesStreamGen(modelID, req, signal, retried) {
+    req.stream = true;
+    const { body, adapter } = await this.buildChatRequest(modelID, req, signal);
+    const token = await this.ensureToken(signal);
+    const endpoint = `/managed-models/${encodeURIComponent(modelID)}${adapter.endpointSuffix()}`;
+    const url = this.apiURL(endpoint);
+    let resp;
+    try {
+      resp = await this.fetchImpl(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
+        body,
+        signal
+      });
+    } catch (e) {
+      throw classifyTransport("POST " + endpoint, url, e);
+    }
+    if (resp.status === 401 && !retried) {
+      try {
+        await resp.body?.cancel();
+      } catch {
+      }
+      try {
+        await this.forceRefresh(signal);
+      } catch (refreshErr) {
+        throw new Error(
+          `messages stream: unauthorized and refresh failed: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}`
+        );
+      }
+      yield* this.chatMessagesStreamGen(modelID, req, signal, true);
+      return;
+    }
+    if (!resp.ok) {
+      const bodyBytes = await readLimited(resp.body, maxErrorBodySize);
+      throw parseHTTPErrorWithHeader(resp.status, bodyBytes, resp.headers);
+    }
+    if (!resp.body) {
+      throw new Error("messages stream: empty response body");
+    }
+    if (adapter.format() === 1 /* OpenAI */) {
+      const converter = newOpenAIStreamConverter();
+      for await (const line of iterSSELines(resp.body)) {
+        if (line.startsWith("event:")) {
+          line.slice("event:".length).trim();
+        } else if (line.startsWith("data:")) {
+          const data = line.slice("data:".length).trim();
+          const { events, done } = converter.convert(data);
+          for (const ev of events) yield ev;
+          if (done) return;
+        }
+      }
+    } else {
+      const blockTypeMap = /* @__PURE__ */ new Map();
+      let currentEvent = "";
+      for await (const line of iterSSELines(resp.body)) {
+        if (line.startsWith("event:")) {
+          currentEvent = line.slice("event:".length).trim();
+        } else if (line.startsWith("data:")) {
+          const data = line.slice("data:".length).trim();
+          const ev = { event: currentEvent, data };
+          const [idx, bt, eph] = extractAnthropicBlockMeta(currentEvent, data, blockTypeMap);
+          if (bt !== "") {
+            ev.blockIndex = idx;
+            ev.blockType = bt;
+            ev.ephemeral = eph;
+          }
+          yield ev;
+        }
+      }
+    }
+  }
+  /**
+   * 流式聊天, 自动解析结算事件和搜索来源
+   *
+   * 返回单一 tagged AsyncIterable, kind 区分 4 种事件:
+   *   - kind='content': 内容增量事件
+   *   - kind='sources': 搜索来源
+   *   - kind='settle':  结算 (token 消耗 + 剩余余额)
+   *
+   * Go 版本 4 channels (eventCh/sourcesCh/settleCh/errCh), 错误抛出取代 errCh。
+   */
+  async *chatStreamWithUsage(modelID, req, signal) {
+    for await (const ev of this.chatStream(modelID, req, signal)) {
+      const s = parseSettlement(ev);
+      if (s) {
+        yield { kind: "settle", event: s };
+        continue;
+      }
+      const src = parseSourcesEvent(ev);
+      if (src) {
+        yield { kind: "sources", event: src };
+        continue;
+      }
+      if (ev.event === "started") continue;
+      if (ev.event === "failed" || ev.event === "error") {
+        throw parseStreamError(ev.data);
+      }
+      yield { kind: "content", event: ev };
+    }
+  }
+  // ===========================================================================
+  // Internal HTTP
+  // ===========================================================================
+  apiURL(path) {
+    let base = this.serverURL;
+    if (!base.endsWith("/api/v4")) {
+      base += "/api/v4";
+    }
+    return base + path;
+  }
+  /** GET/POST/... 通用 JSON 调用 (返回 result 已 typed) */
+  async doJSON(method, path, body, signal) {
+    const r = await this.doJSONFull(method, path, body, signal);
+    return r.result;
+  }
+  /** 与 doJSON 相同, 但返回响应 Headers (用于提取 X-Token-Remaining 等) */
+  async doJSONFull(method, path, body, signal) {
+    return this.doJSONFullInternal(method, path, body, signal, false);
+  }
+  async doJSONFullInternal(method, path, body, signal, retried) {
+    const ctl = withRequestTimeout(3e4, signal);
+    try {
+      const token = await this.ensureToken(ctl.signal);
+      let bodyStr = null;
+      if (body != null) {
+        bodyStr = typeof body === "string" ? body : JSON.stringify(body);
+      }
+      const url = this.apiURL(path);
+      const headers = {
+        Authorization: `Bearer ${token}`
+      };
+      if (bodyStr != null) headers["Content-Type"] = "application/json";
+      const resp = await this.doRequestWithRetry(
+        { method, url, headers, body: bodyStr ?? void 0 },
+        ctl.signal
+      );
+      if (resp.status === 401 && !retried) {
+        try {
+          await resp.body?.cancel();
+        } catch {
+        }
+        try {
+          await this.forceRefresh(ctl.signal);
+        } catch (refreshErr) {
+          throw new Error(
+            `unauthorized and refresh failed: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}`
+          );
+        }
+        return this.doJSONFullInternal(method, path, body, signal, true);
+      }
+      if (resp.status < 200 || resp.status >= 300) {
+        const bodyBytes = await readLimited(resp.body, maxErrorBodySize);
+        throw parseHTTPErrorWithHeader(resp.status, bodyBytes, resp.headers);
+      }
+      const text = await resp.text();
+      const result = JSON.parse(text);
+      if (result && typeof result === "object" && "code" in result) {
+        const bizErr = apiResponseBusinessError(result);
+        if (bizErr) throw bizErr;
+      }
+      return { result, headers: resp.headers };
+    } catch (e) {
+      if (e instanceof Error && e.name === "AbortError") {
+        throw classifyTransport(`${method} ${path}`, this.apiURL(path), e);
+      }
+      throw e;
+    } finally {
+      ctl.dispose();
+    }
+  }
+  /** doJSONFull 的 raw bytes 变体 (chat 用, 不立即 JSON.parse) */
+  async doJSONFullRaw(method, path, body, signal) {
+    return this.doJSONFullRawInternal(method, path, body, signal, false);
+  }
+  async doJSONFullRawInternal(method, path, body, signal, retried) {
+    const ctl = withRequestTimeout(3e4, signal);
+    try {
+      const token = await this.ensureToken(ctl.signal);
+      let bodyStr = null;
+      if (body != null) {
+        bodyStr = typeof body === "string" ? body : JSON.stringify(body);
+      }
+      const url = this.apiURL(path);
+      const headers = {
+        Authorization: `Bearer ${token}`
+      };
+      if (bodyStr != null) headers["Content-Type"] = "application/json";
+      const resp = await this.doRequestWithRetry(
+        { method, url, headers, body: bodyStr ?? void 0 },
+        ctl.signal
+      );
+      if (resp.status === 401 && !retried) {
+        try {
+          await resp.body?.cancel();
+        } catch {
+        }
+        try {
+          await this.forceRefresh(ctl.signal);
+        } catch (refreshErr) {
+          throw new Error(
+            `unauthorized and refresh failed: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}`
+          );
+        }
+        return this.doJSONFullRawInternal(method, path, body, signal, true);
+      }
+      if (resp.status < 200 || resp.status >= 300) {
+        const bodyBytes = await readLimited(resp.body, maxErrorBodySize);
+        throw parseHTTPErrorWithHeader(resp.status, bodyBytes, resp.headers);
+      }
+      const buf = new Uint8Array(await resp.arrayBuffer());
+      return { result: buf, headers: resp.headers };
+    } finally {
+      ctl.dispose();
+    }
+  }
+  /**
+   * 公共端点请求
+   * 有 token 时自动附带 (享受认证用户待遇), 无 token 时匿名请求
+   * 不做 401 重试 (公共端点不应要求认证)
+   */
+  async doPublicJSON(method, path, body, signal) {
+    const ctl = withRequestTimeout(3e4, signal);
+    try {
+      let token = "";
+      try {
+        token = await this.ensureToken(ctl.signal);
+      } catch {
+      }
+      let bodyStr = null;
+      if (body != null) {
+        bodyStr = typeof body === "string" ? body : JSON.stringify(body);
+      }
+      const url = this.apiURL(path);
+      const headers = {};
+      if (token) headers["Authorization"] = `Bearer ${token}`;
+      if (bodyStr != null) headers["Content-Type"] = "application/json";
+      const resp = await this.doRequestWithRetry(
+        { method, url, headers, body: bodyStr ?? void 0 },
+        ctl.signal
+      );
+      if (resp.status < 200 || resp.status >= 300) {
+        const bodyBytes = await readLimited(resp.body, maxErrorBodySize);
+        throw parseHTTPErrorWithHeader(resp.status, bodyBytes, resp.headers);
+      }
+      const text = await resp.text();
+      const result = JSON.parse(text);
+      if (result && typeof result === "object" && "code" in result) {
+        const bizErr = apiResponseBusinessError(result);
+        if (bizErr) throw bizErr;
+      }
+      return result;
+    } finally {
+      ctl.dispose();
+    }
+  }
+  /**
+   * fetch 包装 — 错误经 classifyTransport 转 NetworkError
+   * 6 处原始 fetch() 全部走此 helper
+   */
+  async doRequest(req, signal) {
+    try {
+      return await this.fetchImpl(req.url, {
+        method: req.method,
+        headers: req.headers,
+        body: req.body,
+        signal
+      });
+    } catch (e) {
+      throw classifyTransport(req.method + " " + new URL(req.url).pathname, req.url, e);
+    }
+  }
+  /**
+   * 带 RetryPolicy 的 doRequest 包装 — 仅用于同步 (非流式) 路径.
+   *
+   * 重试触发:
+   *   - transport 层 err (NetworkError isTimeout/isEOF) → 重试
+   *   - HTTP 5xx / 429 → 主动构造 HTTPError 喂给 onRetryable, 默认重试
+   *   - 其他 (HTTP 2xx/3xx/4xx 非 429 / DNS / StreamError) → 不重试
+   *
+   * 流式路径 (chatMessagesStreamGen / chatStreamGen) **不得**调用此函数, 必须直接用 doRequest.
+   */
+  async doRequestWithRetry(req, signal) {
+    const policy = this.retryPolicy;
+    if (!policy || !policy.safeToRetry({ method: req.method, url: req.url })) {
+      return this.doRequest(req, signal);
+    }
+    let lastErr = null;
+    for (let attempt = 0; attempt < policy.maxAttempts; attempt++) {
+      try {
+        const resp = await this.doRequest(req, signal);
+        if (resp.status < 500 && resp.status !== 429) {
+          return resp;
+        }
+        const bodyPeek = await readLimited(resp.body, maxErrorBodySize);
+        lastErr = parseHTTPErrorWithHeader(resp.status, bodyPeek, resp.headers);
+      } catch (e) {
+        lastErr = e;
+      }
+      if (attempt + 1 === policy.maxAttempts) break;
+      if (!policy.onRetryable(lastErr)) break;
+      const backoff = computeBackoff(policy, attempt, lastErr);
+      await sleep(backoff, signal);
+    }
+    throw lastErr;
+  }
+};
+function defaultTokenStore() {
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    try {
+      return new FileTokenStore();
+    } catch {
+      return new InMemoryTokenStore();
+    }
+  }
+  if (typeof globalThis.localStorage !== "undefined") {
+    try {
+      return new LocalStorageTokenStore();
+    } catch {
+      return new InMemoryTokenStore();
+    }
+  }
+  return new InMemoryTokenStore();
+}
+function zeroModelCapabilities() {
+  return {
+    supports_thinking: false,
+    supports_adaptive_thinking: false,
+    supports_isp: false,
+    supports_web_search: false,
+    supports_tool_search: false,
+    supports_structured_output: false,
+    supports_effort: false,
+    supports_max_effort: false,
+    supports_fast_mode: false,
+    supports_auto_mode: false,
+    supports_1m_context: false,
+    supports_prompt_cache: false,
+    supports_cache_editing: false,
+    supports_token_efficient: false,
+    supports_redact_thinking: false,
+    max_input_tokens: 0,
+    max_output_tokens: 0
+  };
+}
+function withRequestTimeout(ms, parent) {
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), ms);
+  let parentHandler;
+  if (parent) {
+    if (parent.aborted) {
+      ctl.abort();
+    } else {
+      parentHandler = () => ctl.abort();
+      parent.addEventListener("abort", parentHandler);
+    }
+  }
+  return {
+    signal: ctl.signal,
+    dispose() {
+      clearTimeout(timer);
+      if (parentHandler && parent) parent.removeEventListener("abort", parentHandler);
+    }
+  };
+}
+async function sleep(ms, signal) {
+  if (ms <= 0) return;
+  if (signal && signal.aborted) throw new Error("aborted");
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => {
+      if (signal && abortHandler) signal.removeEventListener("abort", abortHandler);
+      resolve();
+    }, ms);
+    let abortHandler;
+    if (signal) {
+      abortHandler = () => {
+        clearTimeout(t);
+        signal.removeEventListener("abort", abortHandler);
+        reject(new Error("aborted"));
+      };
+      signal.addEventListener("abort", abortHandler);
+    }
+  });
+}
+
+// src/client/entitlements.ts
+Client.prototype.getBalance = async function(signal) {
+  const resp = await this.doJSON(
+    "GET",
+    "/entitlements/balance",
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.getBalanceDetail = async function(signal) {
+  const resp = await this.doJSON(
+    "GET",
+    "/entitlements/balance-detail",
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.listEntitlements = async function(status, signal) {
+  let path = "/entitlements";
+  if (status !== "") {
+    path += `?status=${encodeURIComponent(status)}`;
+  }
+  const resp = await this.doJSON("GET", path, null, signal);
+  return resp.data;
+};
+Client.prototype.listConsumeRecords = async function(page, pageSize, signal) {
+  const path = `/entitlements/consume-records?page=${page}&pageSize=${pageSize}`;
+  const resp = await this.doJSON("GET", path, null, signal);
+  return resp.data;
+};
+Client.prototype.claimMonthlyFree = async function(signal) {
+  const resp = await this.doJSON(
+    "POST",
+    "/entitlements/claim-monthly",
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.getByModel = async function(modelID, signal) {
+  if (modelID === "") throw new Error("modelID required");
+  const path = `/entitlements/by-model?modelId=${encodeURIComponent(modelID)}`;
+  const resp = await this.doJSON("GET", path, null, signal);
+  return resp.data;
+};
+Client.prototype.listBuckets = async function(signal) {
+  const resp = await this.doJSON(
+    "GET",
+    "/entitlements/buckets",
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.listCoefficients = async function(signal) {
+  if (this.coefCacheData && Date.now() - this.coefCacheTimeMs < coefCacheTTLMs) {
+    return [...this.coefCacheData];
+  }
+  const resp = await this.doJSON(
+    "GET",
+    "/entitlements/coefficients",
+    null,
+    signal
+  );
+  this.coefCacheData = [...resp.data];
+  this.coefCacheTimeMs = Date.now();
+  return resp.data;
+};
+Client.prototype.invalidateCoefficientCache = function() {
+  this.coefCacheData = null;
+  this.coefCacheTimeMs = 0;
+};
+
+// src/client/packages.ts
+init_types();
+Client.prototype.listTokenPackages = async function(signal) {
+  const raw = await this.doJSON("GET", "/token-packages", null, signal);
+  if (raw.data && typeof raw.data === "object" && "list" in raw.data) {
+    const page = raw.data;
+    if (Array.isArray(page.list)) return page.list;
+  }
+  if (Array.isArray(raw.data)) return raw.data;
+  throw new Error("decode token packages: unexpected shape");
+};
+Client.prototype.getTokenPackageDetail = async function(packageID, signal) {
+  const resp = await this.doJSON(
+    "GET",
+    `/token-packages/${encodeURIComponent(packageID)}`,
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.buyTokenPackage = async function(packageID, payload, signal) {
+  const body = payload ?? null;
+  const resp = await this.doJSON(
+    "POST",
+    `/token-packages/${encodeURIComponent(packageID)}/buy`,
+    body,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.getOrderStatus = async function(orderID, signal) {
+  const resp = await this.doJSON(
+    "GET",
+    `/token-packages/orders/${encodeURIComponent(orderID)}/status`,
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.listMyOrders = async function(signal) {
+  const raw = await this.doJSON("GET", "/token-packages/my", null, signal);
+  if (raw.data && typeof raw.data === "object" && "list" in raw.data) {
+    const page = raw.data;
+    if (Array.isArray(page.list)) return page.list;
+  }
+  if (Array.isArray(raw.data)) return raw.data;
+  throw new Error("decode orders: unexpected shape");
+};
+Client.prototype.waitForPayment = async function(orderID, pollIntervalMs, signal) {
+  if (pollIntervalMs <= 0) pollIntervalMs = 2e3;
+  while (true) {
+    const status = await this.getOrderStatus(orderID, signal);
+    if (isOrderTerminal(status.status)) {
+      if (isOrderSuccess(status.status)) return status;
+      throw new OrderTerminalError(orderID, status.status);
+    }
+    await sleepWithSignal(pollIntervalMs, signal);
+  }
+};
+async function sleepWithSignal(ms, signal) {
+  if (ms <= 0) return;
+  if (signal && signal.aborted) throw new Error("aborted");
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => {
+      if (signal && abortHandler) signal.removeEventListener("abort", abortHandler);
+      resolve();
+    }, ms);
+    let abortHandler;
+    if (signal) {
+      abortHandler = () => {
+        clearTimeout(t);
+        signal.removeEventListener("abort", abortHandler);
+        reject(new Error("aborted"));
+      };
+      signal.addEventListener("abort", abortHandler);
+    }
+  });
+}
+
+// src/client/wallet.ts
+Client.prototype.getWalletStats = async function(signal) {
+  const resp = await this.doJSON("GET", "/wallet/stats", null, signal);
+  return resp.data;
+};
+Client.prototype.getWalletTransactions = async function(signal) {
+  const resp = await this.doJSON(
+    "GET",
+    "/wallet/transactions",
+    null,
+    signal
+  );
+  return resp.data;
+};
+
+// src/client/skills.ts
+init_types();
+Client.prototype.browseSkillStore = async function(query, signal) {
+  const resp = await this.browseSkills(
+    1,
+    50,
+    query.category ?? "",
+    query.keyword ?? "",
+    query.tag ?? "",
+    "",
+    signal
+  );
+  return resp.items;
+};
+Client.prototype.browseSkills = async function(page, pageSize, category, keyword, tag, source, signal) {
+  const qv = new URLSearchParams();
+  qv.set("page", String(page));
+  qv.set("pageSize", String(pageSize));
+  if (category) qv.set("category", category);
+  if (keyword) qv.set("keyword", keyword);
+  if (tag) qv.set("tag", tag);
+  if (source) qv.set("source", source);
+  const resp = await this.doPublicJSON(
+    "GET",
+    `/skill-store?${qv.toString()}`,
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.browseSkillsList = async function(page, pageSize, category, keyword, tag, source, signal) {
+  const qv = new URLSearchParams();
+  qv.set("page", String(page));
+  qv.set("pageSize", String(pageSize));
+  qv.set("fields", "minimal");
+  if (category) qv.set("category", category);
+  if (keyword) qv.set("keyword", keyword);
+  if (tag) qv.set("tag", tag);
+  if (source) qv.set("source", source);
+  const resp = await this.doPublicJSON(
+    "GET",
+    `/skill-store?${qv.toString()}`,
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.getSkillDetail = async function(skillID, signal) {
+  const resp = await this.doPublicJSON(
+    "GET",
+    `/skill-store/${encodeURIComponent(skillID)}`,
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.resolveSkill = async function(key, signal) {
+  const resp = await this.doPublicJSON(
+    "GET",
+    `/skill-store/resolve/${encodeURIComponent(key)}`,
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.installSkill = async function(skillID, signal) {
+  const resp = await this.doJSON(
+    "POST",
+    `/skill-store/${encodeURIComponent(skillID)}/install`,
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.downloadSkill = async function(skillID, signal) {
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), 5 * 60 * 1e3);
+  let parentHandler;
+  if (signal) {
+    if (signal.aborted) ctl.abort();
+    else {
+      parentHandler = () => ctl.abort();
+      signal.addEventListener("abort", parentHandler);
+    }
+  }
+  try {
+    const url = this.apiURL(`/skill-store/${encodeURIComponent(skillID)}/download`);
+    const headers = {};
+    let token = "";
+    try {
+      token = await this.ensureToken(ctl.signal);
+    } catch {
+    }
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+    let resp;
+    try {
+      resp = await this.fetchImpl(url, { method: "GET", headers, signal: ctl.signal });
+    } catch (e) {
+      throw classifyTransport(`GET /skill-store/${skillID}/download`, url, e);
+    }
+    if (resp.status === 429) {
+      const bodyText = await readLimitedText(resp.body, maxErrorBodySize);
+      throw new RateLimitError("\u533F\u540D\u4E0B\u8F7D\u5DF2\u8FBE\u9650\u5236", resp.headers.get("Retry-After") ?? "", bodyText);
+    }
+    if (!resp.ok) {
+      const bodyBytes = await readLimited(resp.body, maxErrorBodySize);
+      throw new Error(
+        `download skill: ${parseHTTPErrorWithHeader(resp.status, bodyBytes, resp.headers).message}`
+      );
+    }
+    const data = await readLimited(resp.body, maxDownloadSize + 1);
+    if (data.byteLength > maxDownloadSize) {
+      throw new Error(`download skill: response exceeds ${maxDownloadSize >> 20}MB limit`);
+    }
+    let filename = "skill.zip";
+    const cd = resp.headers.get("Content-Disposition");
+    if (cd) {
+      const idx = cd.indexOf("filename");
+      if (idx !== -1) {
+        const parts = cd.slice(idx).split("=", 2);
+        if (parts.length === 2) {
+          filename = parts[1].trim().replace(/^["' ]+|["' ]+$/g, "");
+        }
+      }
+    }
+    return { data, filename };
+  } finally {
+    clearTimeout(timer);
+    if (parentHandler && signal) signal.removeEventListener("abort", parentHandler);
+  }
+};
+Client.prototype.uploadSkill = async function(zipData, scope, intent, signal) {
+  return uploadSkillInternal(this, zipData, scope, intent, false, signal);
+};
+async function uploadSkillInternal(c, zipData, scope, intent, retried, signal) {
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), 5 * 60 * 1e3);
+  let parentHandler;
+  if (signal) {
+    if (signal.aborted) ctl.abort();
+    else {
+      parentHandler = () => ctl.abort();
+      signal.addEventListener("abort", parentHandler);
+    }
+  }
+  try {
+    const token = await c.ensureToken(ctl.signal);
+    const form = new FormData();
+    form.append("scope", scope);
+    form.append("intent", intent);
+    const blob = new Blob([zipData], { type: "application/zip" });
+    form.append("file", blob, "skill.zip");
+    const url = c.apiURL("/skill-store/upload");
+    let resp;
+    try {
+      resp = await c.fetchImpl(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}` },
+        body: form,
+        signal: ctl.signal
+      });
+    } catch (e) {
+      throw classifyTransport("POST /skill-store/upload", url, e);
+    }
+    if (resp.status === 401 && !retried) {
+      try {
+        await resp.body?.cancel();
+      } catch {
+      }
+      try {
+        await c.forceRefresh(ctl.signal);
+      } catch (refreshErr) {
+        throw new Error(
+          `upload: unauthorized and refresh failed: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}`
+        );
+      }
+      return uploadSkillInternal(c, zipData, scope, intent, true, signal);
+    }
+    if (resp.status < 200 || resp.status >= 300) {
+      const bodyBytes = await readLimited(resp.body, maxErrorBodySize);
+      throw new Error(
+        `upload: ${parseHTTPErrorWithHeader(resp.status, bodyBytes, resp.headers).message}`
+      );
+    }
+    const text = await resp.text();
+    const result = JSON.parse(text);
+    return result.data.skill;
+  } finally {
+    clearTimeout(timer);
+    if (parentHandler && signal) signal.removeEventListener("abort", parentHandler);
+  }
+}
+Client.prototype.getSkillSummary = async function(signal) {
+  const resp = await this.doJSON("GET", "/skills/summary", null, signal);
+  return resp.data;
+};
+Client.prototype.certifySkill = async function(skillID, signal) {
+  await this.doJSON(
+    "POST",
+    `/skill-store/${encodeURIComponent(skillID)}/certify`,
+    null,
+    signal
+  );
+};
+Client.prototype.getCertificationStatus = async function(skillID, signal) {
+  const resp = await this.doJSON(
+    "GET",
+    `/skill-store/${encodeURIComponent(skillID)}/certification`,
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.generateSkill = async function(req, signal) {
+  const resp = await this.doJSON(
+    "POST",
+    "/skill-generator/generate",
+    req,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.optimizeSkill = async function(req, signal) {
+  const resp = await this.doJSON(
+    "POST",
+    "/skill-generator/optimize",
+    req,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.validateSkill = async function(skillName, signal) {
+  await this.doJSON(
+    "POST",
+    "/skill-generator/validate",
+    { skillName },
+    signal
+  );
+};
+
+// src/client/tools.ts
+Client.prototype.listTools = async function(signal) {
+  const resp = await this.doJSON("GET", "/tools", null, signal);
+  return resp.data.skills;
+};
+Client.prototype.getTool = async function(toolID, signal) {
+  const resp = await this.doJSON(
+    "GET",
+    `/tools/${encodeURIComponent(toolID)}`,
+    null,
+    signal
+  );
+  return resp.data;
+};
+
+// src/client/notifications.ts
+Client.prototype.listNotifications = async function(page, pageSize, typeFilter, signal) {
+  let path = `/notifications?page=${page}&pageSize=${pageSize}`;
+  if (typeFilter) path += `&type=${encodeURIComponent(typeFilter)}`;
+  const resp = await this.doJSON("GET", path, null, signal);
+  return resp.data;
+};
+Client.prototype.getUnreadCount = async function(signal) {
+  const resp = await this.doJSON(
+    "GET",
+    "/notifications/unread-count",
+    null,
+    signal
+  );
+  return resp.data.unreadCount;
+};
+Client.prototype.markNotificationRead = async function(id, signal) {
+  await this.doJSON(
+    "PUT",
+    `/notifications/${encodeURIComponent(id)}/read`,
+    null,
+    signal
+  );
+};
+Client.prototype.markAllNotificationsRead = async function(signal) {
+  await this.doJSON("PUT", "/notifications/read-all", null, signal);
+};
+Client.prototype.deleteNotification = async function(id, signal) {
+  await this.doJSON(
+    "DELETE",
+    `/notifications/${encodeURIComponent(id)}`,
+    null,
+    signal
+  );
+};
+Client.prototype.registerDevice = async function(reg, signal) {
+  await this.doJSON("POST", "/devices/register", reg, signal);
+};
+Client.prototype.unregisterDevice = async function(token, signal) {
+  await this.doJSON(
+    "DELETE",
+    `/devices/${encodeURIComponent(token)}`,
+    null,
+    signal
+  );
+};
+Client.prototype.listNotificationPreferences = async function(signal) {
+  const resp = await this.doJSON(
+    "GET",
+    "/notification-preferences",
+    null,
+    signal
+  );
+  return resp.data;
+};
+Client.prototype.updateNotificationPreference = async function(typeCode, pref, signal) {
+  await this.doJSON(
+    "PUT",
+    `/notification-preferences/${encodeURIComponent(typeCode)}`,
+    pref,
+    signal
+  );
+};
+
+// src/sanitize-bridge.ts
+Client.prototype.setDefensiveSanitize = function(cfg) {
+  this.defensiveCfg = cfg;
+};
+Client.prototype.setAutoStripEphemeralHistory = function(on) {
+  this.autoStripEphemeral = on;
+};
+Client.prototype.applyRequestSanitizers = function(req) {
+  const cfg = this.defensiveCfg;
+  const strip = this.autoStripEphemeral;
+  if (cfg == null && !strip) return;
+  if (req.rawMessages != null) {
+    let msgs;
+    try {
+      msgs = normalizeRawMessages(req.rawMessages);
+    } catch (e) {
+      throw new Error(
+        `sanitize: normalize raw messages: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+    if (cfg) {
+      msgs = sanitize(msgs, cfg);
+    }
+    if (strip) {
+      msgs = stripEphemeral(msgs);
+    }
+    req.rawMessages = msgs;
+    return;
+  }
+  if (cfg && (cfg.maxMessagesTurns ?? 0) > 0 && (req.messages?.length ?? 0) > cfg.maxMessagesTurns) {
+    throw ErrHistoryTooDeep;
+  }
+};
+function normalizeRawMessages(rm) {
+  if (Array.isArray(rm)) return rm;
+  let s;
+  try {
+    s = JSON.parse(JSON.stringify(rm));
+  } catch (e) {
+    throw new Error(`raw messages: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (!Array.isArray(s)) {
+    throw new Error("raw messages must be a JSON array");
+  }
+  return s;
+}
+
+// src/ws.ts
+Client.prototype.connect = async function(cfg, signal) {
+  const noop = () => {
+  };
+  const filledCfg = {
+    onEvent: cfg.onEvent ?? noop,
+    onConnect: cfg.onConnect ?? noop,
+    onDisconnect: cfg.onDisconnect ?? noop,
+    topics: cfg.topics ?? [],
+    reconnectMinMs: cfg.reconnectMinMs ?? 2e3,
+    reconnectMaxMs: cfg.reconnectMaxMs ?? 6e4,
+    autoReconnect: cfg.autoReconnect ?? true
+  };
+  let resolveDone;
+  const done = new Promise((r) => {
+    resolveDone = r;
+  });
+  const abort = new AbortController();
+  if (signal) {
+    if (signal.aborted) abort.abort();
+    else signal.addEventListener("abort", () => abort.abort());
+  }
+  const ws = {
+    conn: null,
+    cfg: filledCfg,
+    abort,
+    done,
+    doneResolve: resolveDone,
+    connected: false
+  };
+  await wsConnectOnce(this, ws);
+  this.ws = ws;
+  void wsLoop(this, ws);
+};
+Client.prototype.disconnect = async function() {
+  const ws = this.ws;
+  this.ws = null;
+  if (!ws) return;
+  ws.abort.abort();
+  ws.connected = false;
+  if (ws.conn) {
+    try {
+      ws.conn.close(1e3, "");
+    } catch {
+    }
+  }
+  await Promise.race([
+    ws.done,
+    new Promise((resolve) => setTimeout(resolve, 5e3))
+  ]);
+};
+Client.prototype.isConnected = function() {
+  const ws = this.ws;
+  if (!ws) return false;
+  return ws.connected;
+};
+function wsURL(c) {
+  const base = c.apiURL("/ws");
+  return base.replace(/^http:\/\//, "ws://").replace(/^https:\/\//, "wss://");
+}
+function getWebSocketCtor() {
+  const WSCtor = globalThis.WebSocket;
+  if (!WSCtor) {
+    throw new Error(
+      'WebSocket not available \u2014 on Node \u226421 set globalThis.WebSocket = require("ws") before connect'
+    );
+  }
+  return WSCtor;
+}
+async function wsConnectOnce(c, ws) {
+  const token = await c.ensureToken(ws.abort.signal);
+  const url = wsURL(c);
+  const WSCtor = getWebSocketCtor();
+  const u = new URL(url);
+  u.searchParams.set("token", token);
+  let conn;
+  try {
+    conn = new WSCtor(u.toString());
+  } catch (e) {
+    throw new Error(`dial: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  await new Promise((resolve, reject) => {
+    let opened = false;
+    const handshakeTimer = setTimeout(() => {
+      if (!opened) {
+        try {
+          conn.close();
+        } catch {
+        }
+        reject(new Error("dial: handshake timeout"));
+      }
+    }, 3e4);
+    conn.addEventListener("open", () => {
+      opened = true;
+    });
+    conn.addEventListener("error", (e) => {
+      clearTimeout(handshakeTimer);
+      reject(new Error(`dial: ${e.message ?? "connection error"}`));
+    });
+    conn.addEventListener("message", (e) => {
+      try {
+        const msg = e.data;
+        const welcome = JSON.parse(msg);
+        if (welcome.type !== "welcome") {
+          clearTimeout(handshakeTimer);
+          try {
+            conn.close();
+          } catch {
+          }
+          reject(new Error(`unexpected first message: ${welcome.type}`));
+          return;
+        }
+        clearTimeout(handshakeTimer);
+        ws.conn = conn;
+        ws.connected = true;
+        if (ws.cfg.topics.length > 0) {
+          try {
+            conn.send(
+              JSON.stringify({
+                type: "subscribe",
+                topics: ws.cfg.topics
+              })
+            );
+          } catch (sendErr) {
+            ws.conn = null;
+            ws.connected = false;
+            try {
+              conn.close();
+            } catch {
+            }
+            reject(new Error(`send subscribe: ${sendErr instanceof Error ? sendErr.message : String(sendErr)}`));
+            return;
+          }
+        }
+        ws.cfg.onConnect();
+        console.log(`[acosmi-sdk] websocket connected, connId=${welcome.connId ?? ""}`);
+        resolve();
+      } catch (parseErr) {
+        clearTimeout(handshakeTimer);
+        try {
+          conn.close();
+        } catch {
+        }
+        reject(new Error(`parse welcome: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`));
+      }
+    }, { once: true });
+  });
+}
+async function wsLoop(c, ws) {
+  try {
+    while (true) {
+      await wsReadLoop(ws);
+      if (ws.abort.signal.aborted) return;
+      if (ws.conn) {
+        try {
+          ws.conn.close();
+        } catch {
+        }
+        ws.conn = null;
+      }
+      ws.connected = false;
+      if (!ws.cfg.autoReconnect) return;
+      let delay = ws.cfg.reconnectMinMs;
+      while (true) {
+        if (ws.abort.signal.aborted) return;
+        await sleepWithSignal2(delay, ws.abort.signal).catch(() => {
+        });
+        if (ws.abort.signal.aborted) return;
+        console.log(`[acosmi-sdk] websocket reconnecting (delay=${delay}ms)...`);
+        try {
+          await wsConnectOnce(c, ws);
+          break;
+        } catch (err) {
+          console.log(`[acosmi-sdk] websocket reconnect failed: ${err instanceof Error ? err.message : String(err)}`);
+          delay = Math.min(delay * 2, ws.cfg.reconnectMaxMs);
+        }
+      }
+    }
+  } finally {
+    ws.doneResolve();
+  }
+}
+async function wsReadLoop(ws) {
+  const conn = ws.conn;
+  if (!conn) return;
+  return new Promise((resolve) => {
+    const handleMessage = (e) => {
+      try {
+        const data = e.data;
+        const event = JSON.parse(data);
+        try {
+          ws.cfg.onEvent(event);
+        } catch {
+        }
+      } catch {
+      }
+    };
+    const handleClose = (e) => {
+      conn.removeEventListener("message", handleMessage);
+      conn.removeEventListener("close", handleClose);
+      conn.removeEventListener("error", handleError);
+      try {
+        ws.cfg.onDisconnect(new Error(`closed: code=${e.code} reason=${e.reason}`));
+      } catch {
+      }
+      resolve();
+    };
+    const handleError = (e) => {
+      conn.removeEventListener("message", handleMessage);
+      conn.removeEventListener("close", handleClose);
+      conn.removeEventListener("error", handleError);
+      try {
+        ws.cfg.onDisconnect(e);
+      } catch {
+      }
+      resolve();
+    };
+    conn.addEventListener("message", handleMessage);
+    conn.addEventListener("close", handleClose);
+    conn.addEventListener("error", handleError);
+    if (ws.abort.signal.aborted) {
+      try {
+        conn.close();
+      } catch {
+      }
+    } else {
+      ws.abort.signal.addEventListener(
+        "abort",
+        () => {
+          try {
+            conn.close();
+          } catch {
+          }
+        },
+        { once: true }
+      );
+    }
+  });
+}
+async function sleepWithSignal2(ms, signal) {
+  if (ms <= 0) return;
+  if (signal.aborted) throw new Error("aborted");
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => {
+      signal.removeEventListener("abort", abortHandler);
+      resolve();
+    }, ms);
+    const abortHandler = () => {
+      clearTimeout(t);
+      signal.removeEventListener("abort", abortHandler);
+      reject(new Error("aborted"));
+    };
+    signal.addEventListener("abort", abortHandler);
+  });
+}
+
+// src/bug-report.ts
+Client.prototype.submitBugReport = async function(reportData, signal) {
+  if (reportData == null) {
+    throw new Error("acosmi: reportData required");
+  }
+  let contentStr;
+  try {
+    contentStr = JSON.stringify(reportData);
+  } catch (e) {
+    throw new Error(`acosmi: marshal reportData: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const result = await this.doJSON(
+    "POST",
+    "/crabcode_cli_feedback",
+    { content: contentStr },
+    signal
+  );
+  return result.data;
+};
+Client.prototype.getBugReport = async function(bugID, signal) {
+  const trimmed = bugID.trim();
+  if (trimmed === "") {
+    throw new Error("acosmi: bugID required");
+  }
+  const resp = await this.doPublicJSON(
+    "GET",
+    `/crabcode/bug/${trimmed}`,
+    null,
+    signal
+  );
+  return resp.data;
+};
+
+export { AnthropicAdapter, BucketClassCommercial, BucketClassGeneric, BusinessError, Client, DefaultRetryPolicy, ErrAuthDenied, ErrBrowserOpen, ErrDiscovery, ErrRegistration, ErrSSLProxy, ErrTimeout, ErrTokenExchange, EventAuthURL, EventComplete, EventError, FileTokenStore, FilterStatusAdminBypass, FilterStatusDisabledByFlag, FilterStatusFallbackMissingUser, FilterStatusFallbackNoBuckets, FilterStatusFallbackTkdistError, FilterStatusFallbackTkdistSkew, FilterStatusInternalBypass, FilterStatusOK, FilterStatusUnknown, HTTPError, InMemoryTokenStore, LocalStorageTokenStore, ModelNotFoundError, NetworkError, OpenAIAdapter, OrderTerminalError, ProviderFormat, RateLimitError, ScopeAI, ScopeAccount, ScopeEntitlements, ScopeModels, ScopeModelsChat, ScopeProfile, ScopeSkillStore, ScopeSkills, ScopeTokenPackages, ScopeTools, ScopeToolsExecute, ScopeWallet, ScopeWalletReadonly, ServerToolTypeWebSearch, StreamError, ThinkingHigh, ThinkingHighMinMaxTokens, ThinkingMax, ThinkingMaxFallbackMaxTokens, ThinkingOff, allScopes, anthropicResponseTextContent, anthropicResponseThinkingContent, anthropicResponseToolUseBlocks, apiResponseBusinessError, apiResponseGetMessage, authorize, bucketInfoIsCommercial, bucketRowIsCommercial, buildBetas, commerceScopes, computeBackoff, defaultRetryable, defaultSafeToRetry, discover, effectivePolicy, exchangeCode, extractAnthropicBlockMeta, getAdapter, getAdapterForModel, isSSLError, modelScopes, newFileTokenStore, newThinkingConfig, newTokenSet, newWebSearchTool, parseNotificationEvent, parseSettlement, parseSourcesEvent, refreshToken, register, revokeToken, sanitize_exports as sanitize, skillScopes, tokenSetIsExpired, uniqueMerge };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map