dskcode 0.1.9 → 0.1.11

package/dist/chunk-FODNQIT4.js

@@ -0,0 +1,626 @@
+import {
+  estimateTokens,
+  getModelMeta
+} from "./chunk-DIZMSV5H.js";
+
+// src/provider/errors.ts
+var ProviderError = class extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "ProviderError";
+  }
+  code;
+  statusCode;
+};
+var AuthError = class extends ProviderError {
+  constructor(message, statusCode) {
+    super(message, "AUTH_ERROR", statusCode);
+    this.name = "AuthError";
+  }
+};
+var RateLimitError = class extends ProviderError {
+  /** 建议等待的毫秒数 */
+  retryAfterMs;
+  constructor(message, retryAfterMs) {
+    super(message, "RATE_LIMIT", 429);
+    this.name = "RateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var ServerError = class extends ProviderError {
+  constructor(message, statusCode) {
+    super(message, "SERVER_ERROR", statusCode);
+    this.name = "ServerError";
+  }
+};
+var NetworkError = class extends ProviderError {
+  /** 导致网络错误的底层错误 */
+  originalError;
+  constructor(message, originalError) {
+    super(message, "NETWORK_ERROR");
+    this.name = "NetworkError";
+    this.originalError = originalError;
+  }
+};
+var TimeoutError = class extends ProviderError {
+  /** 触发超时的等待时间（毫秒） */
+  timeoutMs;
+  constructor(message, timeoutMs) {
+    super(message, "TIMEOUT");
+    this.name = "TimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var StreamIdleTimeoutError = class extends ProviderError {
+  /** 触发空闲超时的最大间隔（毫秒） */
+  idleMs;
+  constructor(message, idleMs) {
+    super(message, "STREAM_IDLE_TIMEOUT");
+    this.name = "StreamIdleTimeoutError";
+    this.idleMs = idleMs;
+  }
+};
+var ModelNotSupportedError = class extends ProviderError {
+  constructor(model) {
+    super(
+      `\u4E0D\u652F\u6301\u7684\u6A21\u578B: "${model}"\u3002dskcode \u4EC5\u652F\u6301: deepseek-v4-flash, deepseek-v4-pro`,
+      "MODEL_NOT_SUPPORTED"
+    );
+    this.name = "ModelNotSupportedError";
+  }
+};
+function mapHttpError(status, body) {
+  switch (status) {
+    case 401:
+    case 403:
+      return new AuthError(
+        `\u8BA4\u8BC1\u5931\u8D25\uFF1A\u8BF7\u68C0\u67E5 API Key \u662F\u5426\u6B63\u786E\u3002(${status})`,
+        status
+      );
+    case 429: {
+      let retryAfterMs;
+      try {
+        const parsed = JSON.parse(body);
+        const msg = parsed.error?.message ?? "";
+        const match = /(\d+)\s*second/i.exec(msg);
+        if (match?.[1]) {
+          retryAfterMs = Number(match[1]) * 1e3;
+        }
+      } catch {
+      }
+      return new RateLimitError(
+        `\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002${retryAfterMs ? `\u5EFA\u8BAE\u7B49\u5F85 ${Math.ceil(retryAfterMs / 1e3)} \u79D2\u3002` : ""}`,
+        retryAfterMs
+      );
+    }
+    case 400: {
+      let detail = "";
+      try {
+        const parsed = JSON.parse(body);
+        detail = parsed.error?.message ?? "";
+      } catch {
+      }
+      return new ProviderError(
+        `\u8BF7\u6C42\u53C2\u6570\u9519\u8BEF${detail ? `: ${detail}` : ""}`,
+        "BAD_REQUEST",
+        status
+      );
+    }
+    default:
+      if (status >= 500) {
+        return new ServerError(
+          `\u670D\u52A1\u7AEF\u9519\u8BEF (${status})\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002`,
+          status
+        );
+      }
+      return new ProviderError(`\u8BF7\u6C42\u5931\u8D25 (${status})`, "UNKNOWN_ERROR", status);
+  }
+}
+function isRetryableError(err) {
+  return err instanceof RateLimitError || err instanceof ServerError || err instanceof NetworkError;
+}
+
+// src/provider/retry.ts
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 3e4
+};
+function computeBackoffDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exp = Math.pow(2, attempt - 1);
+  const jitter = Math.random() * (baseDelayMs / 2);
+  const delay = baseDelayMs * exp + jitter;
+  return Math.min(delay, maxDelayMs);
+}
+async function withRetry(fn, options = {}) {
+  const maxRetries = options.maxRetries ?? DEFAULT_RETRY_OPTIONS.maxRetries;
+  const baseDelayMs = options.baseDelayMs ?? DEFAULT_RETRY_OPTIONS.baseDelayMs;
+  const maxDelayMs = options.maxDelayMs ?? DEFAULT_RETRY_OPTIONS.maxDelayMs;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!(err instanceof ProviderError) || !isRetryableError(err)) {
+        throw err;
+      }
+      if (attempt >= maxRetries) break;
+      let delayMs;
+      if (err instanceof RateLimitError && err.retryAfterMs !== void 0) {
+        delayMs = Math.min(err.retryAfterMs, maxDelayMs);
+      } else {
+        delayMs = computeBackoffDelay(attempt + 1, baseDelayMs, maxDelayMs);
+      }
+      options.onRetry?.(attempt + 1, err, delayMs);
+      await sleep(delayMs);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("withRetry: \u672A\u77E5\u9519\u8BEF");
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/provider/client.ts
+var DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
+var HttpClient = class {
+  #connectTimeoutMs;
+  #maxRetries;
+  #retryBaseDelayMs;
+  #retryMaxDelayMs;
+  constructor(config = {}) {
+    this.#connectTimeoutMs = config.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+    this.#maxRetries = config.maxRetries ?? 3;
+    this.#retryBaseDelayMs = config.retryBaseDelayMs ?? 1e3;
+    this.#retryMaxDelayMs = config.retryMaxDelayMs ?? 3e4;
+  }
+  /**
+   * 发起单次 HTTP 请求（带连接超时，不重试）。
+   *
+   * - 自动附加 `Content-Type: application/json`（若 body 是字符串）
+   * - 非 2xx 响应：抛出 mapHttpError 映射后的 ProviderError
+   * - 网络错误：抛出 NetworkError
+   * - 超时：抛出 TimeoutError
+   *
+   * @param url  请求 URL
+   * @param init fetch 初始化（method/headers/body）
+   * @param options 请求级选项（超时、中止信号）
+   * @returns 成功（2xx）的 Response
+   */
+  async request(url, init = {}, options = {}) {
+    const timeoutMs = options.connectTimeoutMs === void 0 ? this.#connectTimeoutMs : options.connectTimeoutMs;
+    const headers = new Headers(init.headers);
+    if (init.body && typeof init.body === "string" && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    const { signal, cleanup } = this.#mergeSignals(
+      options.signal,
+      timeoutMs
+    );
+    let response;
+    try {
+      response = await fetch(url, {
+        ...init,
+        headers,
+        signal
+      });
+    } catch (err) {
+      if (options.signal?.aborted) {
+        throw new ProviderError("\u8BF7\u6C42\u5DF2\u53D6\u6D88", "ABORTED");
+      }
+      if (signal?.aborted && !options.signal?.aborted) {
+        throw new TimeoutError(
+          `\u8FDE\u63A5\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09: ${url}`,
+          timeoutMs
+        );
+      }
+      throw new NetworkError(
+        `\u7F51\u7EDC\u9519\u8BEF\uFF1A\u65E0\u6CD5\u8FDE\u63A5\u5230 ${url}`,
+        err instanceof Error ? err : void 0
+      );
+    } finally {
+      cleanup();
+    }
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw mapHttpError(response.status, body);
+    }
+    return response;
+  }
+  /**
+   * 发起带重试的 HTTP 请求。
+   *
+   * 等价于 request，但用 withRetry 包装：429 / 5xx / 网络错误会自动重试。
+   * 流式响应一旦获得 2xx，重试即停止，剩余流式稳定性交给 SSE 解析器。
+   */
+  async requestWithRetry(url, init = {}, options = {}) {
+    const retryOptions = options.retry === false ? { maxRetries: 0 } : options.retry ?? {
+      maxRetries: this.#maxRetries,
+      baseDelayMs: this.#retryBaseDelayMs,
+      maxDelayMs: this.#retryMaxDelayMs
+    };
+    return withRetry(() => this.request(url, init, options), retryOptions);
+  }
+  /**
+   * 合并外部 signal 与连接超时 signal。
+   *
+   * 策略：
+   * - 若 timeoutMs <= 0 且无外部 signal → 不使用 signal
+   * - 若已有外部 signal 且无超时 → 直接使用外部 signal
+   * - 否则用 AbortSignal.any([外部, 超时]) 合并（Node 20+ 原生支持）
+   *
+   * @returns { signal, cleanup } 调用方应在 finally 调用 cleanup 取消监听
+   */
+  #mergeSignals(external, timeoutMs) {
+    const useTimeout = timeoutMs > 0;
+    if (!external && !useTimeout) {
+      return { signal: void 0, cleanup: () => {
+      } };
+    }
+    if (!useTimeout) {
+      return { signal: external, cleanup: () => {
+      } };
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const onExternalAbort = () => controller.abort();
+    if (external) {
+      if (external.aborted) controller.abort();
+      else external.addEventListener("abort", onExternalAbort, { once: true });
+    }
+    return {
+      signal: controller.signal,
+      cleanup: () => {
+        clearTimeout(timer);
+        if (external) {
+          external.removeEventListener("abort", onExternalAbort);
+        }
+      }
+    };
+  }
+};
+
+// src/provider/sse.ts
+async function* parseSSE(response, options = {}) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("SSE \u54CD\u5E94\u4F53\u4E3A\u7A7A\uFF0C\u65E0\u6CD5\u89E3\u6790");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let pendingData = [];
+  let pendingEvent;
+  let pendingId;
+  let pendingRetry;
+  const idleMs = options.idleTimeoutMs ?? 6e4;
+  const shouldStopOnDone = options.stopOnDone !== false;
+  let streamDone = false;
+  function* flush() {
+    if (pendingData.length === 0) {
+      pendingEvent = void 0;
+      pendingId = void 0;
+      pendingRetry = void 0;
+      return;
+    }
+    const evt = { data: pendingData.join("\n") };
+    if (pendingEvent) evt.event = pendingEvent;
+    if (pendingId) evt.id = pendingId;
+    if (pendingRetry !== void 0) evt.retry = pendingRetry;
+    pendingData = [];
+    pendingEvent = void 0;
+    pendingId = void 0;
+    pendingRetry = void 0;
+    if (shouldStopOnDone && evt.data === "[DONE]") {
+      streamDone = true;
+    }
+    yield evt;
+  }
+  function* processLine(rawLine) {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (line === "") {
+      yield* flush();
+      return;
+    }
+    if (line.startsWith(":")) return;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) {
+      applyField(line, "");
+      return;
+    }
+    const field = line.slice(0, colonIdx);
+    let value = line.slice(colonIdx + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    applyField(field, value);
+  }
+  function applyField(field, value) {
+    switch (field) {
+      case "event":
+        pendingEvent = value;
+        break;
+      case "data":
+        pendingData.push(value);
+        break;
+      case "id":
+        pendingId = value;
+        break;
+      case "retry": {
+        const n = Number(value);
+        if (Number.isFinite(n)) pendingRetry = n;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  try {
+    while (true) {
+      if (options.signal?.aborted) return;
+      const readResult = await readWithTimeout(reader, idleMs, options.signal);
+      if (readResult === null) return;
+      const { done, value } = readResult;
+      if (done) {
+        buffer += decoder.decode();
+        if (buffer.length > 0) {
+          const line = buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer;
+          if (line !== "") yield* processLine(line);
+          buffer = "";
+        }
+        yield* flush();
+        if (streamDone) return;
+        return;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        yield* processLine(line);
+        if (streamDone) return;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function readWithTimeout(reader, idleMs, signal) {
+  if (signal?.aborted) return Promise.resolve(null);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      reject(new StreamIdleTimeoutError(`\u6D41\u5F0F\u7A7A\u95F2\u8D85\u65F6\uFF08${idleMs}ms \u65E0\u6570\u636E\uFF09`, idleMs));
+    }, idleMs);
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(null);
+    };
+    if (signal) signal.addEventListener("abort", onAbort, { once: true });
+    reader.read().then((result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (signal) signal.removeEventListener("abort", onAbort);
+      resolve(result);
+    }).catch((err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (signal) signal.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+  });
+}
+
+// src/provider/deepseek.ts
+var DeepSeekProvider = class {
+  #apiKey;
+  #baseUrl;
+  #model;
+  #client;
+  #idleTimeoutMs;
+  name = "deepseek";
+  constructor(config) {
+    this.#apiKey = config.apiKey;
+    this.#baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.#model = config.model;
+    this.#idleTimeoutMs = config.idleTimeoutMs ?? 6e4;
+    this.#client = new HttpClient({
+      connectTimeoutMs: config.connectTimeoutMs,
+      maxRetries: config.maxRetries,
+      retryBaseDelayMs: config.retryBaseDelayMs,
+      retryMaxDelayMs: config.retryMaxDelayMs
+    });
+  }
+  model() {
+    return this.#model;
+  }
+  countTokens(text) {
+    return estimateTokens(text);
+  }
+  /**
+   * 查询账户余额。
+   *
+   * 调用 DeepSeek /user/balance 接口，返回各币种的余额信息。
+   * 可用于在启动前检查 API Key 有效性和余额状态。
+   */
+  async getBalance() {
+    const url = `${this.#baseUrl}/user/balance`;
+    const response = await this.#client.request(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${this.#apiKey}` }
+    });
+    const data = await response.json();
+    return {
+      isAvailable: data.is_available,
+      balances: data.balance_infos.map((b) => ({
+        currency: b.currency,
+        totalBalance: Number(b.total_balance),
+        grantedBalance: Number(b.granted_balance),
+        toppedUpBalance: Number(b.topped_up_balance)
+      }))
+    };
+  }
+  /**
+   * 发起聊天补全请求（流式）。
+   *
+   * 通过 HttpClient 发起请求（自动连接超时 + 429/5xx 指数退避重试），
+   * 用 parseSSE 解析事件流，逐块映射为 ChatChunk 并 yield。
+   */
+  async *chat(messages, opts) {
+    const url = `${this.#baseUrl}/chat/completions`;
+    const meta = getModelMeta(this.#model);
+    const apiMessages = this.#mapMessages(messages);
+    const body = {
+      model: this.#model,
+      messages: apiMessages,
+      stream: true,
+      max_tokens: opts?.maxTokens,
+      temperature: opts?.temperature
+    };
+    for (const key of Object.keys(body)) {
+      if (body[key] === void 0) {
+        delete body[key];
+      }
+    }
+    const requestOptions = {};
+    if (opts?.signal) requestOptions.signal = opts.signal;
+    const response = await this.#client.requestWithRetry(
+      url,
+      {
+        method: "POST",
+        headers: { Authorization: `Bearer ${this.#apiKey}` },
+        body: JSON.stringify(body)
+      },
+      requestOptions
+    );
+    yield* this.#parseStream(response, opts?.signal);
+  }
+  // -----------------------------------------------------------------------
+  // 内部方法
+  // -----------------------------------------------------------------------
+  /**
+   * 将内部 ChatMessage 数组映射为 DeepSeek API 的请求消息格式。
+   */
+  #mapMessages(messages) {
+    return messages.map((msg) => {
+      const mapped = {
+        role: msg.role,
+        content: msg.content || null
+      };
+      if (msg.name) {
+        mapped.name = msg.name;
+      }
+      if (msg.toolCallId) {
+        mapped.tool_call_id = msg.toolCallId;
+      }
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        mapped.tool_calls = msg.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.name,
+            arguments: tc.arguments
+          }
+        }));
+      }
+      return mapped;
+    });
+  }
+  /**
+   * 解析 SSE 事件流并映射为 ChatChunk。
+   *
+   * 策略：
+   * - 文本内容增量立即 yield（支持实时流式渲染）
+   * - 工具调用在多个 SSE 块中逐步到达，内部累积拼接
+   * - 当 finishReason 为 "tool_calls" 时，yield 完整的工具调用列表
+   * - 最后一个块通常包含 usage 统计信息
+   */
+  async *#parseStream(response, signal) {
+    const toolCallAccumulator = /* @__PURE__ */ new Map();
+    for await (const evt of parseSSE(response, {
+      idleTimeoutMs: this.#idleTimeoutMs,
+      signal
+    })) {
+      if (evt.data === "[DONE]") return;
+      let chunk;
+      try {
+        chunk = JSON.parse(evt.data);
+      } catch {
+        continue;
+      }
+      const choice = chunk.choices?.[0];
+      if (!choice) continue;
+      const delta = choice.delta;
+      const content = delta?.content ?? "";
+      const finishReason = choice.finish_reason;
+      if (delta?.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index ?? 0;
+          const existing = toolCallAccumulator.get(idx);
+          if (!existing) {
+            toolCallAccumulator.set(idx, {
+              id: tc.id ?? "",
+              name: tc.function?.name ?? "",
+              arguments: tc.function?.arguments ?? ""
+            });
+          } else {
+            if (tc.id) existing.id = tc.id;
+            if (tc.function?.name) existing.name = tc.function.name;
+            if (tc.function?.arguments) {
+              existing.arguments += tc.function.arguments;
+            }
+          }
+        }
+      }
+      let usage;
+      if (chunk.usage) {
+        usage = {
+          promptTokens: chunk.usage.prompt_tokens,
+          completionTokens: chunk.usage.completion_tokens,
+          cachedPromptTokens: chunk.usage.prompt_cache_hit_tokens
+        };
+      }
+      const mappedFinishReason = this.#mapFinishReason(finishReason);
+      const shouldYieldToolCalls = mappedFinishReason === "tool_calls" && toolCallAccumulator.size > 0;
+      if (!content && mappedFinishReason === null && !shouldYieldToolCalls && !usage) {
+        continue;
+      }
+      yield {
+        content,
+        finishReason: mappedFinishReason,
+        ...shouldYieldToolCalls ? {
+          toolCalls: [...toolCallAccumulator.values()]
+        } : {},
+        ...usage ? { usage } : {}
+      };
+      if (shouldYieldToolCalls) {
+        toolCallAccumulator.clear();
+      }
+    }
+  }
+  /**
+   * 将 DeepSeek API 的 finish_reason 映射为内部类型。
+   */
+  #mapFinishReason(reason) {
+    switch (reason) {
+      case "stop":
+        return "stop";
+      case "tool_calls":
+        return "tool_calls";
+      case "length":
+        return "length";
+      default:
+        return null;
+    }
+  }
+};
+
+export {
+  ModelNotSupportedError,
+  DeepSeekProvider
+};
+//# sourceMappingURL=chunk-FODNQIT4.js.map