@rebon/cli-darwin-arm64 0.17.2 → 0.18.0

package/bin/compose-runtime/payload/vendor/dsh/llm-deepseek.js

@@ -0,0 +1,672 @@
+var __knownSymbol = (name2, symbol) => (symbol = Symbol[name2]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name2);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+
+// packages/llm/llm-deepseek/src/index.ts
+import z from "@deepseek-ai/schemastery";
+import { assertUsableApiKey, LlmError as LlmError5, resolveRetryPolicy, RetryPolicySchema } from "@deepseek-ai/dsh-llm";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+import { deepEqualJson, installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { MAX_TIMER_DELAY_MS } from "@deepseek-ai/dsh-timeout";
+import { getOrCreateAnonymousUserId } from "@deepseek-ai/dsh-anonymous-user-id";
+
+// packages/llm/llm-deepseek/src/adapter.ts
+import { attributionHeaders, CONTEXT_WINDOW_EXCEEDED_CODE, isContextWindowExceededError, isQuotaExceededError, LlmAdapter, LlmError as LlmError4, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId } from "@deepseek-ai/dsh-llm";
+import { idleWatchdog, timeoutOf } from "@deepseek-ai/dsh-timeout";
+
+// packages/llm/llm-deepseek/src/serialize.ts
+import { contentHasImage, LlmError } from "@deepseek-ai/dsh-llm";
+function reasoningEffort(effort) {
+  if (effort === "off" || effort === "high" || effort === "max") {
+    return effort;
+  }
+  throw new LlmError(
+    `DeepSeek does not support reasoning effort "${effort}"`,
+    "UNSUPPORTED_REASONING_EFFORT"
+  );
+}
+function resolveThinking(options, defaults) {
+  if (options.purpose === "session-title") return { thinking: "disabled" };
+  const effort = options.reasoningEffort === void 0 ? defaults.reasoningEffort : reasoningEffort(options.reasoningEffort);
+  if (defaults.thinking === "disabled" && effort !== void 0 && effort !== "off") {
+    throw new LlmError(
+      `DeepSeek deployment does not support reasoning effort "${effort}"`,
+      "UNSUPPORTED_REASONING_EFFORT"
+    );
+  }
+  if (effort === "off") return { thinking: "disabled" };
+  if (effort === "high" || effort === "max") {
+    return { thinking: "enabled", reasoningEffort: effort };
+  }
+  return defaults.thinking === void 0 ? {} : { thinking: defaults.thinking };
+}
+function flattenText(blocks) {
+  return blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+function assertTextOnly(blocks) {
+  if (contentHasImage(blocks)) {
+    throw new LlmError("The DeepSeek chat-completions adapter does not support image content.", "UNSUPPORTED_CONTENT");
+  }
+}
+function serializeAssistant(message) {
+  const text = flattenText(message.content);
+  const reasoning = message.content.filter((block) => block.type === "reasoning").map((block) => block.text).join("");
+  const toolCalls = message.content.filter((block) => block.type === "tool-call").map((block) => ({
+    id: block.id,
+    type: "function",
+    function: { name: block.name, arguments: block.arguments }
+  }));
+  return {
+    role: "assistant",
+    // Text-less turns send "" — NEVER null. Pure tool-call turns: the
+    // official samples replay message.content verbatim (which is "") and
+    // some gateways reject null outright. Reasoning-ONLY turns (the model
+    // can answer entirely in the reasoning channel, e.g. a v4-flash
+    // greeting): the live API rejects null-content/no-tool_calls assistant
+    // messages with a 400 ("content or tool_calls must be set"), and since
+    // the message sits durably in the session log, a null here bricks every
+    // later turn of that session.
+    content: text,
+    // Official passback rule (guides/thinking_mode.mdx): reasoning_content
+    // must return on tool-call turns; it is ignored on plain turns, so we
+    // drop it there to save tokens.
+    ...toolCalls.length > 0 && reasoning.length > 0 ? { reasoning_content: reasoning } : {},
+    ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+  };
+}
+function serializeMessages(messages) {
+  const wire = [];
+  for (const message of messages) {
+    assertTextOnly(message.content);
+    if (message.role === "system") {
+      wire.push({ role: "system", content: flattenText(message.content) });
+      continue;
+    }
+    if (message.role === "assistant") {
+      wire.push(serializeAssistant(message));
+      continue;
+    }
+    const toolResults = message.content.filter((block) => block.type === "tool-result");
+    const text = flattenText(message.content);
+    if (text.length > 0 || toolResults.length === 0) {
+      wire.push({ role: "user", content: text });
+    }
+    for (const result of toolResults) {
+      wire.push({
+        role: "tool",
+        tool_call_id: result.toolCallId,
+        // Empty tool output still needs SOME content on the wire.
+        content: flattenText(result.content) || "(no output)"
+      });
+    }
+  }
+  return wire;
+}
+function serializeRequest(options, defaults = {}) {
+  const messages = [];
+  if (options.system !== void 0) {
+    messages.push({ role: "system", content: options.system });
+  }
+  messages.push(...serializeMessages(options.messages));
+  const tools = options.tools?.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  }));
+  const resolvedThinking = resolveThinking(options, defaults);
+  return {
+    model: options.model,
+    messages,
+    stream: true,
+    stream_options: { include_usage: true },
+    ...resolvedThinking.thinking !== void 0 ? { thinking: { type: resolvedThinking.thinking } } : {},
+    ...resolvedThinking.reasoningEffort !== void 0 ? { reasoning_effort: resolvedThinking.reasoningEffort } : {},
+    ...tools !== void 0 && tools.length > 0 ? { tools } : {},
+    ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+    ...options.maxTokens === void 0 ? {} : { max_tokens: options.maxTokens },
+    ...options.stop !== void 0 ? { stop: options.stop } : {}
+  };
+}
+
+// packages/llm/llm-deepseek/src/sse.ts
+import { EventSourceParserStream } from "eventsource-parser/stream";
+import { LlmError as LlmError2 } from "@deepseek-ai/dsh-llm";
+var DONE = "[DONE]";
+async function* parseSse(stream, onComment) {
+  const events = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream({ onComment }));
+  for await (const { data } of events) {
+    yield data;
+    if (data === DONE) return;
+  }
+  throw new LlmError2("SSE stream ended without [DONE]", "STREAM_CLOSED");
+}
+
+// packages/llm/llm-deepseek/src/translate.ts
+import { CallId, EMPTY_RESPONSE_CODE, LlmError as LlmError3 } from "@deepseek-ai/dsh-llm";
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return { kind: "stop" };
+    case "tool_calls":
+      return { kind: "tool-calls" };
+    case "length":
+      return { kind: "max-tokens" };
+    default:
+      return {
+        kind: "error",
+        failure: { message: `model stopped: ${reason}`, code: reason.toUpperCase() }
+      };
+  }
+}
+function mapUsage(usage) {
+  const cacheRead = usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_cache_hit_tokens;
+  const reasoning = usage.completion_tokens_details?.reasoning_tokens;
+  return {
+    inputTokens: usage.prompt_tokens - (cacheRead ?? 0),
+    outputTokens: usage.completion_tokens,
+    ...cacheRead !== void 0 ? { cacheReadTokens: cacheRead } : {},
+    ...reasoning !== void 0 ? { reasoningTokens: reasoning } : {}
+  };
+}
+function closeBlock(block) {
+  switch (block.kind) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "reasoning":
+      return { type: "reasoning", text: block.text };
+    case "tool-call":
+      return {
+        type: "tool-call",
+        id: CallId(block.callId ?? ""),
+        name: block.name ?? "",
+        arguments: block.text
+      };
+  }
+}
+async function* translate(payloads) {
+  let nextIndex = 0;
+  let textBlock;
+  let reasoningBlock;
+  const toolBlocks = /* @__PURE__ */ new Map();
+  const order = [];
+  let pendingFinish;
+  let pendingUsage;
+  function open(kind) {
+    const block = { index: nextIndex++, kind, text: "" };
+    order.push(block);
+    return block;
+  }
+  for await (const payload of payloads) {
+    if (payload === DONE) {
+      for (const block of order) {
+        yield { type: "block-end", index: block.index, block: closeBlock(block) };
+      }
+      if (pendingUsage) yield { type: "usage", usage: pendingUsage };
+      const reason = pendingFinish ?? { kind: "stop" };
+      yield {
+        type: "finish",
+        reason: reason.kind === "stop" && order.length === 0 ? {
+          kind: "error",
+          failure: { message: "model returned a completed response with no content", code: EMPTY_RESPONSE_CODE }
+        } : reason
+      };
+      return;
+    }
+    let chunk;
+    try {
+      chunk = JSON.parse(payload);
+    } catch {
+      throw new LlmError3(`malformed SSE payload: ${payload.slice(0, 120)}`, "MALFORMED_RESPONSE");
+    }
+    for (const choice of chunk.choices ?? []) {
+      const delta = choice.delta;
+      const reasoning = delta?.reasoning_content;
+      if (typeof reasoning === "string" && reasoning.length > 0) {
+        if (!reasoningBlock) {
+          reasoningBlock = open("reasoning");
+          yield { type: "block-start", index: reasoningBlock.index, blockType: "reasoning" };
+        }
+        reasoningBlock.text += reasoning;
+        yield { type: "reasoning-delta", index: reasoningBlock.index, text: reasoning };
+      }
+      const content = delta?.content;
+      if (typeof content === "string" && content.length > 0) {
+        if (!textBlock) {
+          textBlock = open("text");
+          yield { type: "block-start", index: textBlock.index, blockType: "text" };
+        }
+        textBlock.text += content;
+        yield { type: "text-delta", index: textBlock.index, text: content };
+      }
+      for (const call of delta?.tool_calls ?? []) {
+        let block = toolBlocks.get(call.index);
+        if (!block) {
+          block = open("tool-call");
+          toolBlocks.set(call.index, block);
+          yield { type: "block-start", index: block.index, blockType: "tool-call" };
+        }
+        if (call.id !== void 0) block.callId = call.id;
+        if (call.function?.name !== void 0) block.name = call.function.name;
+        const fragment = call.function?.arguments ?? "";
+        block.text += fragment;
+        yield {
+          type: "tool-call-delta",
+          index: block.index,
+          id: CallId(block.callId ?? ""),
+          ...block.name !== void 0 ? { name: block.name } : {},
+          argumentsDelta: fragment
+        };
+      }
+      if (typeof choice.finish_reason === "string") {
+        pendingFinish = mapFinishReason(choice.finish_reason);
+      }
+    }
+    if (chunk.usage) pendingUsage = mapUsage(chunk.usage);
+  }
+  throw new LlmError3("SSE payload stream ended without [DONE]", "STREAM_CLOSED");
+}
+
+// packages/llm/llm-deepseek/src/adapter.ts
+var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
+var DEFAULT_CONTEXT_WINDOW = 1e6;
+var DEFAULT_MAX_TOKENS = 256e3;
+var STREAM_IDLE_TIMEOUT_CODE = "LLM_STREAM_IDLE_TIMEOUT";
+var OFF_REASONING_EFFORT = ReasoningEffortId("off");
+var HIGH_REASONING_EFFORT = ReasoningEffortId("high");
+var MAX_REASONING_EFFORT = ReasoningEffortId("max");
+var REASONING_EFFORTS = [
+  { id: OFF_REASONING_EFFORT, name: "Off" },
+  { id: HIGH_REASONING_EFFORT, name: "High" },
+  { id: MAX_REASONING_EFFORT, name: "Max" }
+];
+var OFF_ONLY_REASONING_EFFORTS = [
+  { id: OFF_REASONING_EFFORT, name: "Off" }
+];
+function modelInfo(provider, model) {
+  return {
+    provider,
+    id: model.id,
+    name: model.name ?? model.id,
+    ...model.description === void 0 ? {} : { description: model.description },
+    inputModalities: ["text"]
+  };
+}
+function providerRetryAfterMs(value) {
+  if (value === null) return void 0;
+  if (/^\d+$/.test(value)) {
+    const delay2 = Number(value) * 1e3;
+    return Number.isFinite(delay2) && delay2 > 0 ? delay2 : void 0;
+  }
+  const delay = Date.parse(value) - Date.now();
+  return Number.isFinite(delay) && delay > 0 ? delay : void 0;
+}
+function requestId(headers) {
+  const value = headers.get("x-request-id") ?? headers.get("x-deepseek-request-id");
+  return value === null || value.length === 0 ? void 0 : ProviderRequestId(value);
+}
+function httpErrorCode(status, error) {
+  if (status === 401 || status === 403) return "AUTH";
+  const detail = [error?.code, error?.type, error?.message].filter(Boolean).join(" ");
+  if (isQuotaExceededError(detail)) return QUOTA_EXCEEDED_CODE;
+  if (status === 429) return "RATE_LIMIT";
+  if (status === 400) {
+    if (isContextWindowExceededError(detail)) return CONTEXT_WINDOW_EXCEEDED_CODE;
+    return "INVALID_REQUEST";
+  }
+  if (status >= 500) return "SERVER";
+  return `HTTP_${status}`;
+}
+var DeepSeekAdapter = class extends LlmAdapter {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  config;
+  providerInfo(provider) {
+    return { id: provider, name: "DeepSeek" };
+  }
+  providerRetryPolicy(_provider) {
+    return this.config.options().retryPolicy;
+  }
+  listModels(provider) {
+    return Promise.resolve(this.config.options().models.map((model) => modelInfo(provider, model)));
+  }
+  resolveModel(provider, model, _signal) {
+    const connection = this.config.options();
+    const configured = connection.models.find((entry) => entry.id === model);
+    const contextWindow = configured?.contextWindow ?? connection.defaultContextWindow;
+    return Promise.resolve({
+      // The chat-completions wire route is text-only regardless of catalog
+      // membership, so the uncatalogued fallback declares the same negative
+      // capability — "unknown" here would let the host accept and persist
+      // images the serializer must then reject.
+      ...configured === void 0 ? { provider, id: model, name: model, inputModalities: ["text"] } : modelInfo(provider, configured),
+      context: { contextWindow },
+      defaultMaxTokens: configured?.maxTokens ?? connection.maxTokens,
+      ...connection.defaults.thinking === "disabled" ? {
+        reasoning: {
+          efforts: OFF_ONLY_REASONING_EFFORTS,
+          defaultEffort: OFF_REASONING_EFFORT
+        }
+      } : {
+        reasoning: {
+          efforts: REASONING_EFFORTS,
+          defaultEffort: connection.defaults.reasoningEffort === "off" ? OFF_REASONING_EFFORT : connection.defaults.reasoningEffort === "max" ? MAX_REASONING_EFFORT : HIGH_REASONING_EFFORT
+        }
+      }
+    });
+  }
+  async *stream(options) {
+    var _stack = [];
+    try {
+      const connection = this.config.options();
+      const apiKey = await this.config.resolveApiKey(connection);
+      const userId = this.config.resolveUserId();
+      const consumer = new AbortController();
+      const upstream = options.signal === void 0 ? consumer.signal : AbortSignal.any([options.signal, consumer.signal]);
+      const watchdog = __using(_stack, idleWatchdog(upstream, connection.streamIdleTimeoutMs, STREAM_IDLE_TIMEOUT_CODE));
+      const iterator = this.request(
+        options,
+        watchdog.signal,
+        connection,
+        apiKey,
+        userId,
+        () => {
+          watchdog.pulse();
+        }
+      )[Symbol.asyncIterator]();
+      let exhausted = false;
+      try {
+        while (true) {
+          const result = await watchdog.next(iterator);
+          if (result.done) {
+            exhausted = true;
+            return;
+          }
+          yield result.value;
+        }
+      } catch (error) {
+        if (timeoutOf(watchdog.signal, STREAM_IDLE_TIMEOUT_CODE) !== void 0) {
+          throw new LlmError4(
+            `DeepSeek stream idle timeout after ${connection.streamIdleTimeoutMs}ms`,
+            "TIMEOUT",
+            { cause: error }
+          );
+        }
+        if (options.signal?.aborted) {
+          throw new LlmError4("DeepSeek request aborted by caller", "ABORTED", { cause: error });
+        }
+        if (error instanceof LlmError4) throw error;
+        throw new LlmError4(`DeepSeek API stream from ${connection.baseURL} failed`, "TRANSPORT", { cause: error });
+      } finally {
+        consumer.abort("DeepSeek stream consumer stopped");
+        if (!exhausted && iterator.return !== void 0) {
+          try {
+            await iterator.return();
+          } catch (_abortedTransportTeardown) {
+          }
+        }
+      }
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  async *request(options, signal, connection, apiKey, userId, onComment) {
+    const body = serializeRequest(options, connection.defaults);
+    const payload = JSON.stringify(body);
+    const headers = {
+      "authorization": `Bearer ${apiKey}`,
+      "content-type": "application/json",
+      "accept": "text/event-stream",
+      ...attributionHeaders(),
+      "x-deepseek-harness-user-id": String(userId),
+      ...options.sessionId !== void 0 ? { "x-deepseek-harness-session-id": String(options.sessionId) } : {},
+      ...options.purpose === "compaction" ? { "x-deepseek-harness-compact": "1" } : {}
+    };
+    let response;
+    try {
+      response = await fetch(`${connection.baseURL}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: payload,
+        signal
+      });
+    } catch (error) {
+      if (signal.aborted) throw error;
+      throw new LlmError4(
+        `DeepSeek API request to ${connection.baseURL} failed`,
+        "TRANSPORT",
+        { cause: error }
+      );
+    }
+    if (!response.ok) {
+      let message = `DeepSeek API error (HTTP ${response.status})`;
+      let providerError;
+      try {
+        const parsed = await response.json();
+        providerError = parsed.error;
+        if (providerError?.message) message = providerError.message;
+      } catch {
+      }
+      const delay = providerRetryAfterMs(response.headers.get("retry-after"));
+      const id = requestId(response.headers);
+      throw new LlmError4(message, httpErrorCode(response.status, providerError), {
+        status: response.status,
+        ...delay === void 0 ? {} : { providerRetryAfterMs: delay },
+        ...id === void 0 ? {} : { requestId: id }
+      });
+    }
+    if (!response.body) {
+      throw new LlmError4("DeepSeek API returned no response body", "EMPTY_RESPONSE");
+    }
+    yield* translate(parseSse(response.body, onComment));
+  }
+};
+
+// packages/llm/llm-deepseek/src/index.ts
+var name = "llm-deepseek";
+var inject = ["llm"];
+var NS = settingsNamespace("llm-deepseek");
+var DEFAULT_API_KEY_ENV = "DEEPSEEK_API_KEY";
+var PROVIDER = "deepseek-official";
+var DEFAULT_MODELS = [
+  { id: "deepseek-v4-flash", name: "DeepSeek-V4-Flash", contextWindow: DEFAULT_CONTEXT_WINDOW },
+  { id: "deepseek-v4-pro", name: "DeepSeek-V4-Pro", contextWindow: DEFAULT_CONTEXT_WINDOW }
+];
+var catalogModel = z.object({
+  id: z.string().required(),
+  name: z.string(),
+  description: z.string(),
+  contextWindow: z.number().step(1).min(1),
+  maxTokens: z.number().step(1).min(1)
+});
+var Config = z.object({
+  apiKeyEnv: z.string().role("credential-ref").default(DEFAULT_API_KEY_ENV),
+  baseURL: z.string(),
+  thinking: z.union(["enabled", "disabled"]),
+  reasoningEffort: z.union(["off", "high", "max"]),
+  maxTokens: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER).default(DEFAULT_MAX_TOKENS),
+  defaultContextWindow: z.number().step(1).min(1).default(DEFAULT_CONTEXT_WINDOW),
+  models: z.array(catalogModel).default(DEFAULT_MODELS),
+  streamIdleTimeoutMs: z.number().min(Number.MIN_VALUE).max(MAX_TIMER_DELAY_MS).default(DEFAULT_STREAM_IDLE_TIMEOUT_MS),
+  retryPolicy: RetryPolicySchema
+});
+var PUBLIC_BASE_URL = "https://api.deepseek.com";
+var BASE_URL_ENV = "DEEPSEEK_BASE_URL";
+function resolveModels(models) {
+  const seen = /* @__PURE__ */ new Set();
+  return (models ?? DEFAULT_MODELS).map((model) => {
+    if (model.id.length === 0) throw new Error("llm-deepseek: catalog model ids must be non-empty");
+    if (model.name !== void 0 && model.name.length === 0) {
+      throw new Error(`llm-deepseek: catalog model "${model.id}" has an empty name`);
+    }
+    if (model.contextWindow !== void 0 && (!Number.isInteger(model.contextWindow) || model.contextWindow <= 0)) {
+      throw new Error(
+        `llm-deepseek: catalog model "${model.id}" contextWindow must be a positive integer`
+      );
+    }
+    if (model.maxTokens !== void 0 && (!Number.isInteger(model.maxTokens) || model.maxTokens <= 0)) {
+      throw new Error(
+        `llm-deepseek: catalog model "${model.id}" maxTokens must be a positive integer`
+      );
+    }
+    if (seen.has(model.id)) throw new Error(`llm-deepseek: duplicate catalog model "${model.id}"`);
+    seen.add(model.id);
+    return {
+      id: model.id,
+      ...model.name === void 0 ? {} : { name: model.name },
+      ...model.description === void 0 ? {} : { description: model.description },
+      ...model.contextWindow === void 0 ? {} : { contextWindow: model.contextWindow },
+      ...model.maxTokens === void 0 ? {} : { maxTokens: model.maxTokens }
+    };
+  });
+}
+function resolveAdapterOptions(config, environment) {
+  if (config.thinking === "disabled" && config.reasoningEffort !== void 0 && config.reasoningEffort !== "off") {
+    throw new Error('llm-deepseek: only reasoningEffort "off" can be configured when thinking is disabled');
+  }
+  if (config.defaultContextWindow !== void 0 && (!Number.isInteger(config.defaultContextWindow) || config.defaultContextWindow <= 0)) {
+    throw new Error("llm-deepseek: defaultContextWindow must be a positive integer");
+  }
+  if (config.maxTokens !== void 0 && (!Number.isSafeInteger(config.maxTokens) || config.maxTokens <= 0)) {
+    throw new Error("llm-deepseek: maxTokens must be a positive safe integer");
+  }
+  const streamIdleTimeoutMs = config.streamIdleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+  if (!Number.isFinite(streamIdleTimeoutMs) || streamIdleTimeoutMs <= 0 || streamIdleTimeoutMs > MAX_TIMER_DELAY_MS) {
+    throw new Error(
+      `llm-deepseek: streamIdleTimeoutMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`
+    );
+  }
+  return {
+    apiKeyEnv: credentialRef(config.apiKeyEnv ?? DEFAULT_API_KEY_ENV),
+    baseURL: config.baseURL ?? environment?.get(BASE_URL_ENV)?.value ?? PUBLIC_BASE_URL,
+    defaults: {
+      thinking: config.thinking,
+      reasoningEffort: config.reasoningEffort
+    },
+    maxTokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
+    defaultContextWindow: config.defaultContextWindow ?? DEFAULT_CONTEXT_WINDOW,
+    models: resolveModels(config.models),
+    streamIdleTimeoutMs,
+    retryPolicy: resolveRetryPolicy(config.retryPolicy, "llm-deepseek: retryPolicy")
+  };
+}
+function apply(ctx, config) {
+  let current = () => config;
+  let lastRaw;
+  let lastGood;
+  const options = () => {
+    const raw = current();
+    if (raw === lastRaw && lastGood !== void 0) return lastGood;
+    try {
+      const next = resolveAdapterOptions(raw, launchEnvironmentOf(ctx));
+      lastRaw = raw;
+      lastGood = next;
+      return next;
+    } catch (error) {
+      if (lastGood === void 0) throw error;
+      lastRaw = raw;
+      ctx.logger.error("llm-deepseek: keeping the last good configuration after an invalid settings section");
+      ctx.logger.error(error);
+      return lastGood;
+    }
+  };
+  options();
+  const resolveApiKey = async (connection) => {
+    const ref = connection.apiKeyEnv;
+    const credentials = ctx.get("credentials");
+    if (credentials !== void 0) {
+      const hit = await credentials.resolve(ref);
+      if (hit !== void 0) return assertUsableApiKey(hit.value, "llm-deepseek", ref);
+    } else {
+      const ambient = launchEnvironmentOf(ctx).get(ref);
+      if (ambient !== void 0 && ambient.value.length > 0) {
+        return assertUsableApiKey(ambient.value, "llm-deepseek", ref);
+      }
+    }
+    throw new LlmError5(
+      `llm-deepseek: no API key for provider route "${PROVIDER}"; store ${ref} through the credentials service (the web Models page writes it), or export ${ref} in the launching environment`,
+      "MISSING_CREDENTIAL"
+    );
+  };
+  let userId;
+  const resolveUserId = () => userId ??= getOrCreateAnonymousUserId();
+  const adapter = new DeepSeekAdapter({ options, resolveApiKey, resolveUserId });
+  ctx.llm.registerConfigurableProviders([
+    { provider: PROVIDER, displayName: "DeepSeek", settingsNs: NS, settingsPath: [] }
+  ]);
+  const registration = ctx.llm.registerAdapter([PROVIDER], adapter);
+  let registeredPolicy = options().retryPolicy;
+  const ensureRegistrationFacts = () => {
+    const policy = options().retryPolicy;
+    if (deepEqualJson(policy, registeredPolicy)) return;
+    registration.replace([PROVIDER]);
+    registeredPolicy = policy;
+  };
+  installSettingsSection(ctx, NS, Config, config, {
+    setSource: (source) => {
+      current = source;
+    },
+    onChange: ensureRegistrationFacts
+  });
+}
+export {
+  Config,
+  DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_TOKENS,
+  DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+  DeepSeekAdapter,
+  PUBLIC_BASE_URL,
+  apply,
+  inject,
+  name,
+  resolveAdapterOptions
+};