dsh-grok-subscription 1.1.3 → 2.0.0

package/lib/index.js

@@ -7,7 +7,6 @@ var DISPLAY_NAME_ZH = "Grok \u8BA2\u9605";
 var SETTINGS_NAMESPACE = "grokSubscription";
 var CREDENTIAL_REF_NAME = "GROK_BUILD_ACCESS_TOKEN";
 var PROXY_BASE_URL = "https://cli-chat-proxy.grok.com/v1";
-var RESPONSES_URL = "https://cli-chat-proxy.grok.com/v1/responses";
 var MODELS_V2_URL = "https://cli-chat-proxy.grok.com/v1/models-v2";
 var BILLING_CREDITS_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
 var TOKEN_AUTH_HEADER = "X-XAI-Token-Auth";
@@ -418,31 +417,6 @@ function toPiModels(models) {
     };
   });
 }
-function reasoningInfoOf(model) {
-  if (model?.reasoning === false) return void 0;
-  const efforts = Array.isArray(model?.reasoningEfforts) && model.reasoningEfforts.length ? model.reasoningEfforts : ["low", "medium", "high", "xhigh"];
-  const title = (id) => `${id.charAt(0).toUpperCase()}${id.slice(1)}`;
-  const preferred = model?.defaultEffort && efforts.includes(model.defaultEffort) ? model.defaultEffort : efforts.includes("high") ? "high" : efforts[efforts.length - 1];
-  return {
-    efforts: efforts.map((id) => ({ id, name: title(id) })),
-    defaultEffort: preferred
-  };
-}
-function toLlmModels(models) {
-  return models.map((model) => {
-    const info = {
-      provider: PROVIDER_ID,
-      id: model.id,
-      name: model.name,
-      // The bundled adapter inlines images through the host attachment store,
-      // so it advertises the same modality map as the official pi-ai path.
-      inputModalities: supportsImageInput(model.id) ? ["text", "image"] : ["text"]
-    };
-    const reasoning = reasoningInfoOf(model);
-    if (reasoning) info.reasoning = reasoning;
-    return info;
-  });
-}
 async function fetchLiveCatalog(accessToken, options = {}) {
   const fetchImpl = options.fetch ?? globalThis.fetch;
   const signal = options.signal ?? AbortSignal.timeout(options.timeoutMs ?? CATALOG_TIMEOUT_MS);
@@ -909,81 +883,7 @@ async function optionalImport(specifier, options = {}) {
   }
   return void 0;
 }
-function textOf(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content.map((block) => {
-    if (typeof block === "string") return block;
-    if (block?.type === "text") return block.text ?? "";
-    if (block?.type === "reasoning") return "";
-    if (block?.type === "tool-result") {
-      return typeof block.content === "string" ? block.content : textOf(block.content);
-    }
-    return "";
-  }).join("");
-}
-function imagePlaceholderText(ref) {
-  const name2 = typeof ref?.name === "string" && ref.name.trim() ? ` ${JSON.stringify(ref.name.trim())}` : "";
-  return `[attached image${name2} could not be included in this request]`;
-}
-async function collectImageParts(options, resolveAttachments, policy = {}) {
-  const parts = /* @__PURE__ */ new Map();
-  const refs = [];
-  for (const message of options.messages ?? []) {
-    for (const block of message?.content ?? []) {
-      if (block?.type !== "image" || !block.attachment) continue;
-      const id = block.attachment.attachmentId;
-      if (typeof id !== "string" || !id || parts.has(id)) continue;
-      parts.set(id, void 0);
-      refs.push(block.attachment);
-    }
-  }
-  if (refs.length === 0) return parts;
-  let store;
-  try {
-    store = resolveAttachments?.();
-  } catch {
-    store = void 0;
-  }
-  if (!store?.readImageRequest) return parts;
-  const request = {
-    maxPixels: policy.maxPixels ?? REQUEST_IMAGE_PIXEL_BUDGET,
-    maxBytes: policy.maxBytes ?? REQUEST_IMAGE_MAX_BYTES
-  };
-  await Promise.all(refs.map(async (ref) => {
-    try {
-      const version = await store.readImageRequest(ref, request);
-      if (!version?.data || typeof version.mediaType !== "string" || !version.mediaType) return;
-      parts.set(ref.attachmentId, {
-        mediaType: version.mediaType,
-        base64: Buffer.from(version.data).toString("base64")
-      });
-    } catch {
-    }
-  }));
-  return parts;
-}
-function imageContentParts(blocks, imageParts) {
-  const parts = [];
-  const text = textOf(blocks);
-  if (text) parts.push({ type: "input_text", text });
-  for (const block of blocks ?? []) {
-    if (block?.type !== "image" || !block.attachment) continue;
-    const resolved = imageParts?.get(block.attachment.attachmentId);
-    if (resolved) {
-      parts.push({
-        type: "input_image",
-        image_url: `data:${resolved.mediaType};base64,${resolved.base64}`
-      });
-    } else {
-      parts.push({ type: "input_text", text: imagePlaceholderText(block.attachment) });
-    }
-  }
-  return parts;
-}
 var PROMPT_CACHE_KEY_MAX_LENGTH = 64;
-var REPLAY_KIND = "grok-build-responses";
-var REPLAY_VERSION = 1;
 function promptCacheKey(options) {
   const sessionId = typeof options?.sessionId === "string" ? options.sessionId.trim() : "";
   if (!sessionId) return void 0;
@@ -991,455 +891,10 @@ function promptCacheKey(options) {
   const key = `grok${suffix}:${sessionId}`;
   return key.length <= PROMPT_CACHE_KEY_MAX_LENGTH ? key : key.slice(0, PROMPT_CACHE_KEY_MAX_LENGTH);
 }
-function cacheStableTools(tools) {
-  if (!Array.isArray(tools) || tools.length === 0) return [];
-  return tools.map((tool, index) => ({ tool, index })).sort((left, right) => {
-    const byName = String(left.tool?.name ?? "").localeCompare(String(right.tool?.name ?? ""));
-    return byName === 0 ? left.index - right.index : byName;
-  }).map(({ tool }) => ({
-    type: "function",
-    name: tool.name,
-    description: tool.description,
-    parameters: tool.parameters
-  }));
-}
-function replayEnvelope(message) {
-  const state = message?.source?.replayState;
-  return state?.response?.kind === REPLAY_KIND && state.response.version === REPLAY_VERSION && Array.isArray(state.blocks) ? state : void 0;
-}
-function replayReasoningItem(message, contentIndex) {
-  const entry = replayEnvelope(message)?.blocks[contentIndex];
-  const item = entry?.type === "reasoning" ? entry.item : void 0;
-  return item?.type === "reasoning" && typeof item.encrypted_content === "string" && item.encrypted_content ? item : void 0;
-}
-function responsesInput(options, imageParts) {
-  const input = [];
-  const system = typeof options.system === "string" && options.system ? options.system : void 0;
-  if (system) input.push({ role: "system", content: system });
-  for (const message of options.messages ?? []) {
-    const role = message.role === "assistant" ? "assistant" : message.role === "system" ? "system" : "user";
-    const toolCalls = (message.content ?? []).filter((block) => block?.type === "tool-call");
-    const toolResults = (message.content ?? []).filter((block) => block?.type === "tool-result");
-    if (toolResults.length) {
-      for (const block of toolResults) {
-        input.push({
-          type: "function_call_output",
-          call_id: block.toolCallId ?? block.id,
-          output: textOf(block.content)
-        });
-      }
-      continue;
-    }
-    if (role === "assistant" && toolCalls.length) {
-      const content = message.content ?? [];
-      for (let index = 0; index < content.length; index++) {
-        const block = content[index];
-        if (block?.type === "reasoning") {
-          const item = replayReasoningItem(message, index);
-          if (item) input.push(item);
-          continue;
-        }
-        if (block?.type !== "tool-call") continue;
-        input.push({
-          type: "function_call",
-          call_id: block.id,
-          name: block.name,
-          arguments: typeof block.arguments === "string" ? block.arguments : JSON.stringify(block.arguments ?? {})
-        });
-      }
-      const text2 = textOf(message.content);
-      if (text2) input.push({ role: "assistant", content: text2 });
-      continue;
-    }
-    const hasImage = (message.content ?? []).some((block) => block?.type === "image");
-    if (role === "user" && hasImage) {
-      const parts = imageContentParts(message.content, imageParts);
-      if (parts.length > 0) input.push({ role, content: parts });
-      continue;
-    }
-    if (role === "assistant") {
-      const content = message.content ?? [];
-      const output = [];
-      let text2 = "";
-      for (let index = 0; index < content.length; index++) {
-        const block = content[index];
-        if (block?.type === "reasoning") {
-          const item = replayReasoningItem(message, index);
-          if (item) output.push(item);
-        } else if (block?.type === "text" && block.text) {
-          text2 += block.text;
-        }
-      }
-      if (text2) output.push({ role: "assistant", content: text2 });
-      input.push(...output);
-      continue;
-    }
-    const text = textOf(message.content);
-    if (!text) continue;
-    input.push({ role, content: text });
-  }
-  return input;
-}
-function mapFinish(reason) {
-  if (reason === "toolUse" || reason === "tool_calls") return { kind: "tool-calls" };
-  if (reason === "length" || reason === "max_tokens") return { kind: "max-tokens" };
-  return { kind: "stop" };
-}
-function finiteOr(value, fallback) {
-  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-}
-function jsonSafeChunk(value) {
-  if (value === null) return null;
-  const type = typeof value;
-  if (type === "string" || type === "boolean") return value;
-  if (type === "number") return Number.isFinite(value) && !Object.is(value, -0) ? value : void 0;
-  if (type !== "object") return void 0;
-  if (Array.isArray(value)) {
-    const list = [];
-    for (const item of value) {
-      const safe = jsonSafeChunk(item);
-      if (safe !== void 0) list.push(safe);
-    }
-    return list;
-  }
-  const out = {};
-  for (const [key, item] of Object.entries(value)) {
-    const safe = jsonSafeChunk(item);
-    if (safe !== void 0) out[key] = safe;
-  }
-  return out;
-}
-async function* streamResponsesUnsafe(options, token) {
-  const headers = {
-    Accept: "text/event-stream",
-    "Content-Type": "application/json",
-    ...buildProxyHeaders(token)
-  };
-  try {
-    const llm = await optionalImport("@deepseek-ai/dsh-llm");
-    if (typeof llm?.attributionHeaders === "function") Object.assign(headers, llm.attributionHeaders());
-  } catch {
-  }
-  const body = {
-    model: options.model,
-    input: responsesInput(options, await collectImageParts(options, options.resolveAttachments)),
-    stream: true,
-    // grok-4.7 returns ciphertext by default, but naming it keeps replay explicit
-    // for every reasoning model on this proxy.
-    include: ["reasoning.encrypted_content"]
-  };
-  const cacheKey = promptCacheKey(options);
-  if (cacheKey) body.prompt_cache_key = cacheKey;
-  if (typeof options.maxTokens === "number") body.max_output_tokens = options.maxTokens;
-  if (typeof options.temperature === "number") body.temperature = options.temperature;
-  const tools = cacheStableTools(options.tools);
-  if (tools.length) body.tools = tools;
-  if (options.reasoningEffort) body.reasoning = { effort: options.reasoningEffort };
-  const response = await fetch(RESPONSES_URL, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-    redirect: "error",
-    signal: options.signal
-  });
-  if (!response.ok) {
-    const error = new Error(`Grok Build proxy returned HTTP ${response.status}`);
-    error.status = response.status;
-    throw error;
-  }
-  if (!response.body) throw new Error("Grok Build proxy returned an empty body");
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let textIndex;
-  let reasoningIndex;
-  let textContent = "";
-  let reasoningContent = "";
-  let nextIndex = 0;
-  const emittedBlocks = [];
-  const toolBlocks = /* @__PURE__ */ new Map();
-  const toolNames = /* @__PURE__ */ new Map();
-  let usage;
-  let finish = { kind: "stop" };
-  const toolIdOf = (payload) => {
-    const id = payload?.item_id ?? payload?.call_id ?? payload?.id;
-    return typeof id === "string" && id ? id : void 0;
-  };
-  const learnToolName = (id, name2) => {
-    if (typeof id !== "string" || !id || typeof name2 !== "string" || !name2) return;
-    toolNames.set(id, name2);
-    const tool = toolBlocks.get(id);
-    if (tool) tool.name = name2;
-  };
-  const adoptToolArguments = (id, value) => {
-    if (typeof id !== "string" || typeof value !== "string" || !value) return;
-    const tool = toolBlocks.get(id);
-    if (tool && value.length > tool.arguments.length) tool.arguments = value;
-  };
-  const flushSse = function* (raw) {
-    const lines = raw.split("\n");
-    let event = "message";
-    const data = [];
-    for (const line of lines) {
-      if (line.startsWith("event:")) event = line.slice(6).trim();
-      else if (line.startsWith("data:")) data.push(line.slice(5).trim());
-    }
-    const payloadText = data.join("\n");
-    if (!payloadText || payloadText === "[DONE]") return;
-    let payload;
-    try {
-      payload = JSON.parse(payloadText);
-    } catch {
-      return;
-    }
-    const type = payload.type ?? event;
-    if (type === "response.output_text.delta" || type === "response.text.delta") {
-      const delta = payload.delta ?? payload.text ?? "";
-      if (!delta) return;
-      if (textIndex === void 0) {
-        textIndex = nextIndex++;
-        emittedBlocks[textIndex] = { type: "text" };
-        yield { type: "block-start", index: textIndex, blockType: "text" };
-      }
-      textContent += delta;
-      yield { type: "text-delta", index: textIndex, text: String(delta) };
-      return;
-    }
-    if (type === "response.reasoning_text.delta" || type === "response.reasoning.delta" || type === "response.reasoning_summary_text.delta") {
-      const delta = payload.delta ?? payload.text ?? "";
-      if (!delta) return;
-      if (reasoningIndex === void 0) {
-        reasoningIndex = nextIndex++;
-        emittedBlocks[reasoningIndex] = { type: "reasoning" };
-        yield { type: "block-start", index: reasoningIndex, blockType: "reasoning" };
-      }
-      reasoningContent += delta;
-      yield { type: "reasoning-delta", index: reasoningIndex, text: String(delta) };
-      return;
-    }
-    if (type === "response.output_item.added" || type === "response.output_item.done") {
-      const item = payload.item;
-      if (item?.type === "reasoning" && typeof item.encrypted_content === "string" && item.encrypted_content) {
-        if (reasoningIndex === void 0) {
-          reasoningIndex = nextIndex++;
-          emittedBlocks[reasoningIndex] = { type: "reasoning" };
-          yield { type: "block-start", index: reasoningIndex, blockType: "reasoning" };
-        }
-        emittedBlocks[reasoningIndex] = { type: "reasoning", item };
-      }
-      if (item?.type === "function_call") {
-        learnToolName(item.id, item.name);
-        learnToolName(item.call_id, item.name);
-        adoptToolArguments(item.id, item.arguments);
-      }
-      return;
-    }
-    if (type === "response.function_call_arguments.done") {
-      const id = toolIdOf(payload);
-      learnToolName(id, payload.name);
-      adoptToolArguments(id, payload.arguments);
-      return;
-    }
-    if (type === "response.function_call_arguments.delta") {
-      const id = toolIdOf(payload);
-      if (!id) return;
-      let tool = toolBlocks.get(id);
-      if (!tool) {
-        tool = {
-          index: nextIndex++,
-          id,
-          // Never leave this undefined: an unserializable chunk aborts the turn.
-          name: toolNames.get(id) ?? "tool",
-          arguments: ""
-        };
-        emittedBlocks[tool.index] = { type: "tool-call" };
-        toolBlocks.set(id, tool);
-        yield { type: "block-start", index: tool.index, blockType: "tool-call" };
-      }
-      const delta = payload.delta ?? payload.arguments ?? "";
-      tool.arguments += delta;
-      yield { type: "tool-call-delta", index: tool.index, id, name: tool.name, argumentsDelta: String(delta) };
-      return;
-    }
-    if (type === "response.completed") {
-      for (const item of payload.response?.output ?? []) {
-        if (item?.type !== "function_call") continue;
-        learnToolName(item.id, item.name);
-        learnToolName(item.call_id, item.name);
-        const id = typeof item.id === "string" && item.id ? item.id : void 0;
-        if (id && !toolBlocks.has(id)) {
-          const tool = { index: nextIndex++, id, name: toolNames.get(id) ?? "tool", arguments: "" };
-          toolBlocks.set(id, tool);
-          emittedBlocks[tool.index] = { type: "tool-call" };
-          yield { type: "block-start", index: tool.index, blockType: "tool-call" };
-        }
-        adoptToolArguments(id, item.arguments);
-      }
-      const responseUsage = payload.response?.usage ?? payload.usage;
-      if (responseUsage) {
-        const details = responseUsage.input_tokens_details ?? responseUsage.prompt_tokens_details ?? {};
-        const cachedTokens = finiteOr(details.cached_tokens, 0);
-        const cacheWriteTokens = finiteOr(details.cache_write_tokens, 0);
-        const promptTotal = finiteOr(
-          responseUsage.input_tokens ?? responseUsage.prompt_tokens,
-          0
-        );
-        const outputTokens = finiteOr(
-          responseUsage.output_tokens ?? responseUsage.completion_tokens,
-          0
-        );
-        usage = {
-          // The provider folds cache hits into the prompt count, while DSH's
-          // fields are disjoint: billed input = inputTokens + cacheRead +
-          // cacheWrite. Subtracting is what makes the host's "cache hit" figure
-          // real instead of a permanent 0%. Both cache fields stay numeric so
-          // consumers can always add them up.
-          inputTokens: Math.max(0, promptTotal - cachedTokens - cacheWriteTokens),
-          outputTokens,
-          cacheReadTokens: cachedTokens,
-          cacheWriteTokens
-        };
-        const reasoningTokens = finiteOr(responseUsage.output_tokens_details?.reasoning_tokens, void 0);
-        if (reasoningTokens !== void 0) usage.reasoningTokens = reasoningTokens;
-        usage.totalTokens = finiteOr(responseUsage.total_tokens, promptTotal + outputTokens);
-      }
-      finish = mapFinish(payload.response?.status === "incomplete" ? "length" : "stop");
-      if (toolBlocks.size) finish = { kind: "tool-calls" };
-    }
-    if (type === "response.failed" || type === "error") {
-      const raw2 = payload.error?.message ?? payload.message;
-      const failure = {
-        message: typeof raw2 === "string" && raw2 ? raw2 : "Grok Build stream failed",
-        code: "PROVIDER"
-      };
-      const status = finiteOr(payload.error?.status, void 0);
-      if (status !== void 0) failure.status = status;
-      finish = { kind: "error", failure };
-    }
-  };
-  for await (const chunk of response.body) {
-    buffer += decoder.decode(chunk, { stream: true });
-    let separator;
-    while ((separator = buffer.indexOf("\n\n")) !== -1) {
-      const raw = buffer.slice(0, separator);
-      buffer = buffer.slice(separator + 2);
-      yield* flushSse(raw);
-    }
-  }
-  if (buffer.trim()) yield* flushSse(buffer);
-  if (reasoningIndex !== void 0) {
-    yield { type: "block-end", index: reasoningIndex, block: { type: "reasoning", text: reasoningContent } };
-  }
-  if (textIndex !== void 0) {
-    yield { type: "block-end", index: textIndex, block: { type: "text", text: textContent } };
-  }
-  for (const tool of toolBlocks.values()) {
-    yield {
-      type: "block-end",
-      index: tool.index,
-      block: { type: "tool-call", id: tool.id, name: tool.name ?? "tool", arguments: tool.arguments }
-    };
-  }
-  if (usage) yield { type: "usage", usage };
-  const finishChunk = { type: "finish", reason: finish };
-  if (finish.kind !== "error" && finish.kind !== "aborted" && emittedBlocks.length === nextIndex) {
-    finishChunk.replayState = {
-      response: { kind: REPLAY_KIND, version: REPLAY_VERSION },
-      blocks: emittedBlocks
-    };
-  }
-  yield finishChunk;
-}
-async function* streamResponses(options, token) {
-  for await (const chunk of streamResponsesUnsafe(options, token)) {
-    const safe = jsonSafeChunk(chunk);
-    if (safe) yield safe;
-  }
-}
 function visiblePiModels(session) {
   if (session.publicAccount()?.signedIn !== true) return [];
   return toPiModels(session.models()).map((model) => model.provider === PROVIDER_ID ? model : { ...model, provider: PROVIDER_ID });
 }
-function createDuckAdapter(session, adapterOptions = {}) {
-  const providerInfo = () => ({ id: PROVIDER_ID, name: DISPLAY_NAME });
-  const list = () => {
-    const signedIn = session.publicAccount()?.signedIn === true;
-    return signedIn ? toLlmModels(session.models()) : [];
-  };
-  return {
-    providerInfo,
-    providerRetryPolicy() {
-      return void 0;
-    },
-    async listModels(provider) {
-      if (provider !== PROVIDER_ID) return [];
-      return list();
-    },
-    async resolveModel(provider, model) {
-      const found = list().find((item) => item.id === model);
-      const raw = session.publicAccount()?.signedIn === true ? session.models().find((item) => item.id === model) : void 0;
-      const info = {
-        provider,
-        id: model,
-        name: found?.name ?? model,
-        // The host gates prompt attachment admission on resolveModelInfo, NOT on
-        // listModels, so this must match the catalog's modality map exactly.
-        inputModalities: supportsImageInput(model) ? ["text", "image"] : ["text"],
-        context: { contextWindow: raw?.contextWindow ?? 5e5 }
-      };
-      const reasoning = reasoningInfoOf(raw);
-      if (reasoning) info.reasoning = reasoning;
-      else if (found?.reasoning) info.reasoning = found.reasoning;
-      return info;
-    },
-    async prepareCall(provider, model, signal) {
-      const resolved = await this.resolveModel(provider, model, signal);
-      return {
-        model: resolved,
-        stream: (options) => this.stream(options)
-      };
-    },
-    async *stream(options) {
-      if (options.provider !== PROVIDER_ID) {
-        yield { type: "finish", reason: { kind: "error", failure: { message: "Unknown provider", code: "NO_ADAPTER" } } };
-        return;
-      }
-      const callOptions = typeof adapterOptions.resolveAttachments === "function" ? { ...options, resolveAttachments: adapterOptions.resolveAttachments } : options;
-      let token = await session.currentToken();
-      if (!token) {
-        yield { type: "finish", reason: { kind: "error", failure: { message: "Grok subscription is not signed in", code: "MISSING_CREDENTIAL" } } };
-        return;
-      }
-      for (let attempt = 0; ; attempt++) {
-        let emitted = false;
-        try {
-          for await (const chunk of streamResponses(callOptions, token, callOptions.resolveAttachments)) {
-            emitted = true;
-            yield chunk;
-          }
-          return;
-        } catch (error) {
-          const aborted = options.signal?.aborted === true;
-          const status = finiteOr(error?.status, void 0);
-          const canRetry = !aborted && !emitted && attempt === 0 && status === 401 && typeof session.refreshToken === "function";
-          if (canRetry) {
-            const renewed = await session.refreshToken();
-            if (renewed && renewed !== token) {
-              token = renewed;
-              continue;
-            }
-          }
-          const failure = {
-            message: status === 401 ? "Grok Build session is expired or unauthorized (HTTP 401). Run grok login, then Pull from Grok CLI." : error instanceof Error ? error.message : "Grok Build request failed",
-            code: aborted ? "ABORTED" : status === 401 ? "UNAUTHORIZED" : "PROVIDER"
-          };
-          if (status !== void 0) failure.status = status;
-          yield { type: "finish", reason: { kind: aborted ? "aborted" : "error", failure } };
-          return;
-        }
-      }
-    }
-  };
-}
 function createStore(session) {
   return {
     async read(providerId) {
@@ -1473,52 +928,23 @@ function buildAuthConfig() {
     }
   };
 }
-function withEncryptedReasoningInclude(api) {
-  const inject2 = (options) => ({
-    ...options,
-    samplingParams: {
-      ...options?.samplingParams,
-      include: ["reasoning.encrypted_content"]
-    }
-  });
+function withGrokRequestSemantics(api) {
+  const inject2 = (options) => {
+    const cacheKey = options?.cacheRetention === "none" ? void 0 : promptCacheKey(options);
+    return {
+      ...options,
+      samplingParams: {
+        ...options?.samplingParams,
+        include: ["reasoning.encrypted_content"],
+        ...cacheKey === void 0 ? {} : { prompt_cache_key: cacheKey }
+      }
+    };
+  };
   return {
     stream: (model, context, options) => api.stream(model, context, inject2(options)),
     streamSimple: (model, context, options) => api.streamSimple(model, context, inject2(options))
   };
 }
-function wrapAsHostAdapter(candidate, dshLlm) {
-  if (!dshLlm?.LlmAdapter || candidate instanceof dshLlm.LlmAdapter) return candidate;
-  class GrokBuildAdapter extends dshLlm.LlmAdapter {
-    providerInfo(provider) {
-      return candidate.providerInfo(provider);
-    }
-    providerRetryPolicy(provider) {
-      return candidate.providerRetryPolicy(provider);
-    }
-    listModels(provider) {
-      return candidate.listModels(provider);
-    }
-    resolveModel(provider, model, signal) {
-      return candidate.resolveModel(provider, model, signal);
-    }
-    prepareCall(provider, model, signal) {
-      return candidate.prepareCall(provider, model, signal);
-    }
-    stream(options) {
-      return candidate.stream(options);
-    }
-  }
-  return new GrokBuildAdapter();
-}
-function createGrokBuildAdapterSync(session, options = {}) {
-  const duck = createDuckAdapter(session, { resolveAttachments: options.resolveAttachments });
-  const dshLlm = options.dshLlm;
-  return {
-    adapter: wrapAsHostAdapter(duck, dshLlm),
-    kind: "custom-mvp",
-    note: "Registered a sync duck Responses adapter; pi-ai upgrade may follow in the background."
-  };
-}
 async function createGrokBuildAdapter(session, options = {}) {
   const importOpts = options.importOptions ?? {};
   const [piAi, dshPi, dshLlm] = await Promise.all([
@@ -1526,13 +952,11 @@ async function createGrokBuildAdapter(session, options = {}) {
     optionalImport("@deepseek-ai/dsh-llm-pi-ai", importOpts),
     optionalImport("@deepseek-ai/dsh-llm", importOpts)
   ]);
-  const duck = createDuckAdapter(session, { resolveAttachments: options.resolveAttachments });
-  const asHostAdapter = (candidate) => wrapAsHostAdapter(candidate, dshLlm);
   if (!piAi?.createProvider || !dshPi?.PiAiAdapter) {
     return {
-      adapter: asHostAdapter(duck),
-      kind: "custom-mvp",
-      note: "PiAiAdapter or @earendil-works/pi-ai is not available in this host; using a documented custom Responses adapter."
+      adapter: void 0,
+      kind: "unavailable",
+      note: "the host pi-ai adapter is unavailable: @earendil-works/pi-ai and @deepseek-ai/dsh-llm-pi-ai must be resolvable from the DSH install"
     };
   }
   let responsesApi;
@@ -1543,9 +967,13 @@ async function createGrokBuildAdapter(session, options = {}) {
     responsesApi = void 0;
   }
   if (!responsesApi) {
-    return { adapter: asHostAdapter(duck), kind: "custom-mvp", note: "openai-responses API module is unavailable; using the custom adapter." };
+    return {
+      adapter: void 0,
+      kind: "unavailable",
+      note: "the pi-ai openai-responses API module is unavailable in this host"
+    };
   }
-  responsesApi = withEncryptedReasoningInclude(responsesApi);
+  responsesApi = withGrokRequestSemantics(responsesApi);
   const store = createStore(session);
   const authModels = piAi.createModels({
     credentials: store,
@@ -2729,31 +2157,17 @@ function apply(ctx, options = {}) {
     logger: ctx.logger,
     onCatalogChange: notifyCatalogChange
   });
-  const adapterState = { kind: "custom-mvp", upgraded: false };
+  const adapterState = { kind: "starting" };
   const pluginManager = options.pluginManager ?? createGrokPluginManager();
   const handler = createRpcHandler(session, {
     pluginManager,
     diagnostics: () => ({
-      adapter: adapterState.upgraded ? "pi-ai" : "fallback",
-      adapterKind: adapterState.kind,
+      adapter: adapterState.kind,
       imageInput: typeof resolveAttachments()?.readImageRequest === "function",
-      hostPeersResolved: adapterState.upgraded
+      hostPeersResolved: adapterState.kind === "pi-ai"
     })
   });
   const resolveAttachments = attachmentResolver(ctx);
-  const createSync = options.createSync ?? createGrokBuildAdapterSync;
-  try {
-    const created = createSync(session, { resolveAttachments });
-    if (created.note) ctx.logger?.debug?.(created.note);
-    adapterState.kind = created.kind;
-    ctx.llm.registerAdapter([PROVIDER_ID], created.adapter);
-    notifyCatalogChange();
-  } catch (error) {
-    ctx.logger?.warn?.(
-      "Grok subscription duck adapter failed to register: %s",
-      error instanceof Error ? error.message : "unknown"
-    );
-  }
   const defer = options.defer ?? scheduleDeferred2;
   defer(() => {
     void deferredBoot(ctx, session, notifyCatalogChange, options, adapterState);
@@ -2788,24 +2202,32 @@ async function deferredBoot(ctx, session, notifyCatalogChange, options = {}, ada
       );
     });
   }
-  if (options.skipUpgrade) return;
-  const createAsync = options.createAsync ?? createGrokBuildAdapter;
+  if (options.skipAdapter) {
+    adapterState.kind = "unavailable";
+    return;
+  }
+  const buildAdapter = options.buildAdapter ?? createGrokBuildAdapter;
   try {
-    const created = await createAsync(session, { ...options.adapterOptions, resolveAttachments: attachmentResolver(ctx) });
-    if (created.kind === "pi-ai") {
-      if (created.note) ctx.logger?.warn?.(created.note);
-      ctx.llm.registerAdapter([PROVIDER_ID], created.adapter);
-      if (adapterState) {
-        adapterState.kind = created.kind;
-        adapterState.upgraded = true;
-      }
-      notifyCatalogChange?.();
-    } else if (created.note) {
-      ctx.logger?.debug?.(created.note);
+    const created = await buildAdapter(session, {
+      ...options.adapterOptions,
+      resolveAttachments: attachmentResolver(ctx)
+    });
+    if (!created?.adapter) {
+      adapterState.kind = "unavailable";
+      ctx.logger?.warn?.(
+        "Grok subscription adapter is unavailable: %s",
+        created?.note ?? "unknown"
+      );
+      return;
     }
+    if (created.note) ctx.logger?.warn?.(created.note);
+    ctx.llm.registerAdapter([PROVIDER_ID], created.adapter);
+    adapterState.kind = created.kind ?? "pi-ai";
+    notifyCatalogChange?.();
   } catch (error) {
+    adapterState.kind = "unavailable";
     ctx.logger?.warn?.(
-      "Grok subscription adapter upgrade failed: %s",
+      "Grok subscription adapter registration failed: %s",
       error instanceof Error ? error.message : "unknown"
     );
   }