@1outres/dsh-plugin-claude-subscription 0.0.0-stage → 0.3.0

package/lib/index.js

@@ -0,0 +1,1735 @@
+// ../dsh-plugin-claude-subscription/src/adapter.ts
+import {
+  LlmAdapter
+} from "@deepseek-ai/dsh-llm";
+
+// ../dsh-plugin-claude-subscription/src/errors.ts
+import {
+  CONTEXT_WINDOW_EXCEEDED_CODE,
+  EMPTY_RESPONSE_CODE,
+  isContextWindowExceededError,
+  isQuotaExceededError,
+  LlmError,
+  QUOTA_EXCEEDED_CODE
+} from "@deepseek-ai/dsh-llm";
+var LOGIN_MESSAGE = "Not logged in to Claude. Run `claude login` in a terminal, then try again.";
+var API_KEY_REJECTED_CODE = "API_KEY_SOURCE_REJECTED";
+var ACCOUNT_ERRORS = /* @__PURE__ */ new Set([
+  "oauth_org_not_allowed",
+  "account_on_hold",
+  "verification_required"
+]);
+var CONTEXT_TERMINAL_REASONS = /* @__PURE__ */ new Set(["blocking_limit", "prompt_too_long"]);
+var USAGE_LIMIT_WORDING = /hit your|usage limit|usage credits|credits required/i;
+var TIMEOUT_WORDING = /timed? ?out|timeout/i;
+var TRANSPORT_WORDING = /connection|network|socket|fetch failed|econn|enotfound|eai_again/i;
+function loginRequiredError() {
+  return new LlmError(LOGIN_MESSAGE, "MISSING_CREDENTIAL");
+}
+function refusalError(explanation) {
+  const base = "The model declined to answer this request.";
+  return new LlmError(explanation ? `${base} ${explanation}` : base, "REFUSAL");
+}
+function emptyResponseError() {
+  return new LlmError("Claude returned no output.", EMPTY_RESPONSE_CODE);
+}
+function unsupportedOptionError(option) {
+  return new LlmError(
+    `The Claude subscription route does not support GenerateOptions.${option}.`,
+    "UNSUPPORTED_OPTION"
+  );
+}
+function apiKeyBlockedError(source) {
+  return new LlmError(
+    `Claude Code would use an API key from "${source}" instead of your claude login. No request was sent.`,
+    API_KEY_REJECTED_CODE
+  );
+}
+function apiKeyDuringStepError(source) {
+  return new LlmError(
+    `Claude Code reported an API key from "${source}" instead of your claude login, so the call was stopped. One request may already have gone out and been billed to the API.`,
+    API_KEY_REJECTED_CODE
+  );
+}
+function notSubscriptionLoginError(provider) {
+  return new LlmError(
+    `Claude Code would use the provider "${provider}" instead of your claude login. No request was sent.`,
+    "NOT_SUBSCRIPTION_LOGIN"
+  );
+}
+function loginCheckTimeoutError() {
+  return new LlmError("Claude Code did not report its login state in time.", "TIMEOUT");
+}
+function loginRefreshTimeoutError() {
+  return new LlmError("Claude Code did not renew the login in time.", "TIMEOUT");
+}
+function pluginDisposedError() {
+  return new LlmError("The Claude subscription plugin has stopped.", "PLUGIN_DISPOSED");
+}
+function isExpiredLogin(facts) {
+  if (facts.assistantError !== "authentication_failed") return false;
+  return facts.status === 401 || /session expired/i.test(facts.text);
+}
+function mapStepFailure(facts) {
+  const { assistantError: kind, text } = facts;
+  const options = errorOptions(facts);
+  if (kind === "authentication_failed") return loginRequiredError();
+  if (kind !== void 0 && ACCOUNT_ERRORS.has(kind)) {
+    return new LlmError(text, "CLAUDE_ACCOUNT", options);
+  }
+  if (isContextFailure(facts)) return new LlmError(text, CONTEXT_WINDOW_EXCEEDED_CODE, options);
+  const rateLimited = kind === "rate_limit" || facts.status === 429;
+  if (kind === "billing_error" || rateLimited && isUsageLimit(facts)) {
+    return new LlmError(usageLimitMessage(facts), QUOTA_EXCEEDED_CODE, options);
+  }
+  if (rateLimited) return new LlmError(text, "RATE_LIMIT", options);
+  if (kind === "model_not_found") {
+    return new LlmError(`${text} Your plan may not include this model.`, "UNKNOWN_MODEL", options);
+  }
+  if (kind === "server_error" || kind === "overloaded") {
+    return new LlmError(text, "SERVER", options);
+  }
+  return new LlmError(text, codeFromStatusOrWording(facts), options);
+}
+function mapThrownError(error) {
+  if (error instanceof LlmError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new LlmError(message || "Claude Code stopped without a reason.", "CLAUDE_CODE_PROCESS", {
+    cause: error
+  });
+}
+function codeFromStatusOrWording({ assistantError: kind, status, text }) {
+  if (status === 408) return "TIMEOUT";
+  if (status === 429) return "RATE_LIMIT";
+  if (status !== null && status >= 500) return "SERVER";
+  if (status !== null && status >= 400) return "INVALID_REQUEST";
+  if (kind === "invalid_request") return "INVALID_REQUEST";
+  if (TIMEOUT_WORDING.test(text)) return "TIMEOUT";
+  if (TRANSPORT_WORDING.test(text)) return "TRANSPORT";
+  return "CLAUDE_CODE_ERROR";
+}
+function isContextFailure({ terminalReason, text }) {
+  if (terminalReason !== null && CONTEXT_TERMINAL_REASONS.has(terminalReason)) return true;
+  return isContextWindowExceededError(text) || /prompt is too long/i.test(text);
+}
+function isUsageLimit({ rateLimit, text }) {
+  return rateLimit?.status === "rejected" || USAGE_LIMIT_WORDING.test(text) || isQuotaExceededError(text);
+}
+function usageLimitMessage({ rateLimit, text }) {
+  const base = `Claude usage limit reached: ${text}`;
+  if (rateLimit?.resetsAt === void 0) return base;
+  return `${base} It resets at ${new Date(rateLimit.resetsAt * 1e3).toISOString()}.`;
+}
+function errorOptions({ status }) {
+  return status !== null && status >= 100 && status <= 599 ? { status } : {};
+}
+
+// ../dsh-plugin-claude-subscription/src/login-check.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+
+// ../dsh-plugin-claude-subscription/src/child-env.ts
+var FORWARDED_NAMES = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LANG",
+  "LC_ALL",
+  // Where `claude login` stored the login, when it is not the default dir.
+  "CLAUDE_CONFIG_DIR",
+  // The CLI reads these directly. Without them it cannot reach the API behind a proxy.
+  "HTTPS_PROXY",
+  "https_proxy",
+  "HTTP_PROXY",
+  "http_proxy",
+  "ALL_PROXY",
+  "all_proxy",
+  "NO_PROXY",
+  "no_proxy",
+  // The root certificate of a proxy that re-signs TLS traffic.
+  "NODE_EXTRA_CA_CERTS"
+];
+var FIXED_VALUES = {
+  ENABLE_CLAUDEAI_MCP_SERVERS: "0",
+  DISABLE_AUTO_COMPACT: "1",
+  CLAUDE_CODE_DISABLE_ATTACHMENTS: "1",
+  CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
+  CLAUDE_CODE_DISABLE_ADVISOR_TOOL: "1",
+  CLAUDE_CODE_DISABLE_CLAUDE_MDS: "1",
+  CLAUDE_AGENT_SDK_DISABLE_BUILTIN_AGENTS: "1",
+  CLAUDE_AGENT_SDK_MCP_NO_PREFIX: "1",
+  CLAUDE_CODE_DISABLE_REFUSAL_RETRY: "1",
+  CLAUDE_CODE_DISABLE_REFUSAL_FALLBACK: "1",
+  // A non-streaming fallback sends no stream events, so a tool call would never reach the
+  // message_delta that stops the step, and the never-settling handler would hang it.
+  CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK: "1"
+};
+function buildChildEnv(processEnv, options) {
+  const env = {};
+  for (const name2 of FORWARDED_NAMES) {
+    const value = processEnv[name2];
+    if (value !== void 0) env[name2] = value;
+  }
+  return {
+    ...env,
+    ...FIXED_VALUES,
+    TMPDIR: options.tempDir,
+    CLAUDE_CODE_MAX_RETRIES: String(options.maxRetries),
+    ...options.maxOutputTokens === void 0 ? {} : { CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(options.maxOutputTokens) }
+  };
+}
+
+// ../dsh-plugin-claude-subscription/src/private-temp-dir.ts
+import { lstatSync, mkdirSync, mkdtempSync, readdirSync, readlinkSync, rmSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { isAbsolute, join } from "node:path";
+var ROOT_NAME = "dsh-plugin-claude-subscription";
+var PROCESS_DIR_NAME = /^(\d+)-(.+)-(\d+)-[A-Za-z0-9]{6}$/;
+var NO_PID_NAMESPACE = "0";
+var FOREIGN_NAMESPACE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function defaultTempRoot(env = process.env, home = homedir()) {
+  const cacheHome = env.XDG_CACHE_HOME;
+  return join(cacheHome && isAbsolute(cacheHome) ? cacheHome : join(home, ".cache"), ROOT_NAME);
+}
+function createPrivateTempDir(options = {}) {
+  const root = options.root ?? defaultTempRoot();
+  const pid = options.pid ?? process.pid;
+  const host = options.hostname ?? hostname();
+  const namespace = options.pidNamespace ?? readPidNamespace();
+  const removeDir = options.removeDir ?? removeDirTree;
+  mkdirSync(root, { recursive: true, mode: 448 });
+  assertPrivateRoot(root);
+  removeLeftovers(root, {
+    host,
+    namespace,
+    isAlive: options.isProcessAlive ?? isProcessAlive,
+    now: options.now ?? Date.now
+  });
+  const path = mkdtempSync(join(root, `${pid}-${host}-${namespace}-`));
+  const remove = () => {
+    try {
+      removeDir(path);
+    } catch (error) {
+      options.onRemoveFailed?.(error);
+    }
+  };
+  process.once("exit", remove);
+  return {
+    path,
+    redirectSdkTempDir: () => redirectTmpdir(path),
+    dispose() {
+      process.removeListener("exit", remove);
+      remove();
+    }
+  };
+}
+function removeDirTree(path) {
+  rmSync(path, { recursive: true, force: true });
+}
+function readPidNamespace() {
+  try {
+    return /\[(\d+)\]/.exec(readlinkSync("/proc/self/ns/pid"))?.[1] ?? NO_PID_NAMESPACE;
+  } catch {
+    return NO_PID_NAMESPACE;
+  }
+}
+function assertPrivateRoot(root) {
+  const stat = lstatSync(root);
+  const ownedByUser = process.getuid === void 0 || stat.uid === process.getuid();
+  if (!stat.isDirectory() || !ownedByUser || (stat.mode & 63) !== 0) {
+    throw new Error(`The temp root ${root} is not private. It must be a mode 700 dir you own.`);
+  }
+}
+function removeLeftovers(root, here) {
+  for (const name2 of readdirSync(root)) {
+    const match = PROCESS_DIR_NAME.exec(name2);
+    if (match === null || match[2] !== here.host) continue;
+    const path = join(root, name2);
+    const leftover = match[3] === here.namespace ? !here.isAlive(Number(match[1])) : here.now() - lstatSync(path).mtimeMs > FOREIGN_NAMESPACE_MAX_AGE_MS;
+    if (leftover) removeDirTree(path);
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+var hostTmpdir;
+var redirectsInFlight = 0;
+function redirectTmpdir(path) {
+  if (redirectsInFlight === 0) hostTmpdir = process.env.TMPDIR;
+  redirectsInFlight += 1;
+  process.env.TMPDIR = path;
+  setImmediate(() => {
+    redirectsInFlight -= 1;
+    if (redirectsInFlight > 0) return;
+    if (hostTmpdir === void 0) delete process.env.TMPDIR;
+    else process.env.TMPDIR = hostTmpdir;
+  });
+}
+
+// ../dsh-plugin-claude-subscription/src/query-lifecycle.ts
+var DRAIN_DEADLINE_MS = 5e3;
+var CHILD_EXIT_DEADLINE_MS = 5e3;
+var CHILD_EXIT_POLL_MS = 50;
+var QueryHandle = class {
+  constructor(query4, abortController, tracker) {
+    this.query = query4;
+    this.abortController = abortController;
+    this.tracker = tracker;
+    this.iterator = query4[Symbol.asyncIterator]();
+    tracker.add(this);
+  }
+  query;
+  abortController;
+  tracker;
+  iterator;
+  pending;
+  teardown;
+  stopped = false;
+  /** True once `hardStop` has ended this query from outside the step. */
+  get hardStopped() {
+    return this.stopped;
+  }
+  next() {
+    const pending = this.iterator.next();
+    this.pending = pending;
+    return pending;
+  }
+  /** Ends the query in the background. Later calls keep the first mode. */
+  settle(mode) {
+    if (this.teardown !== void 0) return;
+    if (mode === "interrupt") {
+      this.query.interrupt().catch(() => {
+      });
+    }
+    this.teardown = this.drainThenClose();
+  }
+  /**
+   * Aborts and closes the query at once. The child can stay alive for about two
+   * more seconds, and a request it has already started is not called back.
+   */
+  hardStop() {
+    this.stopped = true;
+    this.abortController.abort();
+    this.query.close();
+    this.settle("drain");
+    return this.teardown;
+  }
+  async drainThenClose() {
+    let timer;
+    const deadline = new Promise((resolve) => {
+      timer = setTimeout(resolve, DRAIN_DEADLINE_MS);
+      timer.unref?.();
+    });
+    await Promise.race([this.drain(), deadline]);
+    clearTimeout(timer);
+    this.query.close();
+    this.tracker.remove(this);
+  }
+  async drain() {
+    try {
+      await this.pending;
+      while (!(await this.iterator.next()).done) {
+      }
+    } catch {
+    }
+  }
+};
+var QueryTracker = class {
+  handles = /* @__PURE__ */ new Set();
+  children = /* @__PURE__ */ new Set();
+  closingController = new AbortController();
+  isAlive;
+  kill;
+  childExitDeadlineMs;
+  constructor(options = {}) {
+    this.isAlive = options.isAlive ?? isProcessAlive;
+    this.kill = options.kill ?? ((pid) => process.kill(pid, "SIGKILL"));
+    this.childExitDeadlineMs = options.childExitDeadlineMs ?? CHILD_EXIT_DEADLINE_MS;
+  }
+  /** Fires when disposal starts. */
+  get closing() {
+    return this.closingController.signal;
+  }
+  /**
+   * Query options that report each child's PID. SDK 0.3.318 calls this hook, but its types do not
+   * list it. The end of a query does not say when the child is gone: a busy child gets SIGTERM
+   * after 2 seconds, the SDK removes its temp dir at that moment, and the child then writes its
+   * transcript there while it exits, which makes the dir again.
+   */
+  childOptions() {
+    const onProcessSpawned = (pid) => {
+      this.forgetExitedChildren();
+      this.children.add(pid);
+    };
+    return { onProcessSpawned };
+  }
+  /** Call this right before `query()`: a child started after disposal would outlive the plugin. */
+  assertOpen() {
+    if (this.closing.aborted) throw pluginDisposedError();
+  }
+  add(handle) {
+    this.handles.add(handle);
+  }
+  remove(handle) {
+    this.handles.delete(handle);
+  }
+  /** Ends every query, then waits for the children to exit. One still alive at the deadline is killed. */
+  async dispose() {
+    this.closingController.abort();
+    await Promise.all([...this.handles].map((handle) => handle.hardStop()));
+    const deadline = performance.now() + this.childExitDeadlineMs;
+    this.forgetExitedChildren();
+    while (this.children.size > 0 && performance.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, CHILD_EXIT_POLL_MS));
+      this.forgetExitedChildren();
+    }
+    for (const pid of this.children) {
+      try {
+        this.kill(pid);
+      } catch {
+      }
+    }
+  }
+  forgetExitedChildren() {
+    for (const pid of this.children) {
+      if (!this.isAlive(pid)) this.children.delete(pid);
+    }
+  }
+};
+
+// ../dsh-plugin-claude-subscription/src/tool-server.ts
+var SERVER_NAME = "dsh";
+var JSON_RPC_METHOD_NOT_FOUND = -32601;
+function createToolServer(tools) {
+  const listedTools = tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.parameters,
+    _meta: { "anthropic/alwaysLoad": true }
+  }));
+  function reply(request) {
+    switch (request.method) {
+      case "initialize":
+        return {
+          result: {
+            protocolVersion: request.params?.protocolVersion,
+            capabilities: { tools: {} },
+            serverInfo: { name: SERVER_NAME, version: "1.0.0" }
+          }
+        };
+      case "tools/list":
+        return { result: { tools: listedTools } };
+      case "ping":
+        return { result: {} };
+      case "tools/call":
+        return void 0;
+      default:
+        return {
+          error: { code: JSON_RPC_METHOD_NOT_FOUND, message: `Unknown method ${request.method}` }
+        };
+    }
+  }
+  const instance = {
+    async connect(transport) {
+      transport.onmessage = (request) => {
+        if (request.id === void 0) return;
+        const answer = reply(request);
+        if (answer === void 0) return;
+        transport.send({ jsonrpc: "2.0", id: request.id, ...answer }).catch(() => {
+        });
+      };
+      await transport.start?.();
+    },
+    async close() {
+    }
+  };
+  return {
+    type: "sdk",
+    name: SERVER_NAME,
+    instance
+  };
+}
+
+// ../dsh-plugin-claude-subscription/src/query-options.ts
+var REFRESH_PROMPT = "Reply with the word ok.";
+var REFRESH_MODEL = "claude-haiku-5-5";
+var LOGIN_CHECK_MODEL = "claude-haiku-5-5";
+function buildStepOptions(input) {
+  return {
+    ...isolationOptions(input.cwd, input.env),
+    model: input.model,
+    abortController: input.abortController,
+    systemPrompt: { type: "custom", prompt: input.systemPrompt, snapshot: false },
+    includePartialMessages: true,
+    resume: input.sessionId,
+    sessionStore: {
+      load: transcriptLoader(input),
+      append: async (_key, entries) => {
+        input.onAppend(entries);
+      }
+    },
+    sessionStoreFlush: "eager",
+    thinking: { type: "adaptive", display: "summarized" },
+    ...input.effort === void 0 ? {} : { effort: input.effort },
+    ...input.tools.length === 0 ? {} : {
+      mcpServers: { [SERVER_NAME]: createToolServer(input.tools) },
+      allowedTools: [`mcp__${SERVER_NAME}`]
+    }
+  };
+}
+function buildRefreshOptions(input) {
+  return {
+    ...isolationOptions(input.cwd, input.env),
+    model: REFRESH_MODEL,
+    systemPrompt: { type: "custom", prompt: "", snapshot: false },
+    persistSession: false,
+    maxTurns: 1,
+    thinking: { type: "disabled" }
+  };
+}
+function buildLoginCheckOptions(input) {
+  return {
+    ...isolationOptions(input.cwd, input.env),
+    model: LOGIN_CHECK_MODEL,
+    abortController: input.abortController,
+    resume: input.sessionId,
+    sessionStore: { load: transcriptLoader(input), append: async () => {
+    } }
+  };
+}
+function isolationOptions(cwd, env) {
+  return { cwd, env, tools: [], settingSources: [], strictMcpConfig: true, skills: [] };
+}
+function transcriptLoader(input) {
+  return async (key) => {
+    if (key.subpath !== void 0 || input.abortController.signal.aborted) return null;
+    input.onLoad();
+    return [...input.entries];
+  };
+}
+function attachmentsToReplay(appended) {
+  return appended.filter((entry) => {
+    if (entry.type !== "attachment") return false;
+    const attachment = entry.attachment;
+    return entry.rendered !== void 0 || attachment?.type === "credential_org";
+  });
+}
+
+// ../dsh-plugin-claude-subscription/src/shared-run.ts
+var ABORTED = /* @__PURE__ */ Symbol("aborted");
+var SharedRun = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  active;
+  join(signal) {
+    if (signal?.aborted) return Promise.resolve(ABORTED);
+    const active = this.active ?? this.begin();
+    active.waiters += 1;
+    return new Promise((resolve, reject) => {
+      const leave = () => {
+        signal?.removeEventListener("abort", onAbort);
+        active.waiters -= 1;
+      };
+      const onAbort = () => {
+        leave();
+        if (active.waiters === 0) this.stopActive(active);
+        resolve(ABORTED);
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      active.promise.then(
+        (value) => {
+          leave();
+          resolve(value);
+        },
+        (error) => {
+          leave();
+          reject(error);
+        }
+      );
+    });
+  }
+  begin() {
+    const stop = new AbortController();
+    let timer;
+    const deadline = new Promise((resolve) => {
+      timer = setTimeout(() => resolve(this.options.onDeadline()), this.options.deadlineMs);
+      timer.unref?.();
+    });
+    const active = {
+      stop,
+      waiters: 0,
+      promise: Promise.race([this.options.run(stop.signal), deadline]).finally(() => {
+        clearTimeout(timer);
+        this.stopActive(active);
+      })
+    };
+    this.active = active;
+    return active;
+  }
+  stopActive(active) {
+    if (this.active === active) this.active = void 0;
+    active.stop.abort();
+  }
+};
+
+// ../dsh-plugin-claude-subscription/src/transcript.ts
+import { randomUUID } from "node:crypto";
+import {
+  LlmError as LlmError2
+} from "@deepseek-ai/dsh-llm";
+
+// ../dsh-plugin-claude-subscription/src/replay-state.ts
+var REPLAY_KIND = "claude-subscription";
+var REPLAY_VERSION = 1;
+var REPLAY_BLOCK_TYPES = /* @__PURE__ */ new Set(["thinking", "redacted_thinking", "text", "tool_use", "dropped"]);
+function createReplayEnvelope(input) {
+  const envelope = {
+    response: {
+      kind: REPLAY_KIND,
+      version: REPLAY_VERSION,
+      model: input.model,
+      messageId: input.messageId,
+      stopReason: input.stopReason,
+      attachments: input.attachments,
+      ...input.healedErrors.length > 0 ? { healedErrors: input.healedErrors } : {}
+    },
+    blocks: input.blocks
+  };
+  return envelope;
+}
+function readReplayEnvelope(value) {
+  if (!isRecord(value) || !isRecord(value.response) || !Array.isArray(value.blocks)) {
+    return void 0;
+  }
+  const { kind, version, model, attachments } = value.response;
+  if (kind !== REPLAY_KIND || version !== REPLAY_VERSION) return void 0;
+  if (typeof model !== "string" || !Array.isArray(attachments)) return void 0;
+  if (!value.blocks.every(isReplayBlock)) return void 0;
+  return value;
+}
+function isReplayBlock(block) {
+  return isRecord(block) && typeof block.type === "string" && REPLAY_BLOCK_TYPES.has(block.type);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// ../dsh-plugin-claude-subscription/src/transcript.ts
+var SEAL_TEXT = "<local-command-stdout></local-command-stdout>";
+function splitSystemPrompt(options) {
+  const parts = [options.system];
+  let end = 0;
+  for (const message of options.messages) {
+    if (message.role !== "system") break;
+    parts.push(systemText(message.content));
+    end += 1;
+  }
+  return {
+    systemPrompt: parts.filter(Boolean).join("\n\n"),
+    messages: options.messages.slice(end)
+  };
+}
+function buildTranscript(messages, options) {
+  const rows = [];
+  let index = 0;
+  while (index < messages.length) {
+    const message = messages[index];
+    index += 1;
+    if (message.role !== "assistant") {
+      appendUserSide(rows, message, options);
+      continue;
+    }
+    const toolCalls = appendAssistant(rows, message, options);
+    if (toolCalls.length === 0) continue;
+    const turn = collectToolTurn(messages, index, toolCalls);
+    appendToolResults(rows, toolCalls, turn.results, options);
+    for (const held of turn.held) appendUserSide(rows, held, options);
+    index = turn.nextIndex;
+  }
+  const last = rows.at(-1);
+  if (last === void 0 || !("isMeta" in last)) {
+    throw new LlmError2(
+      "A Claude request must end with a user message or tool results.",
+      "INVALID_REQUEST"
+    );
+  }
+  return withIdentity(rows, options);
+}
+function withIdentity(rows, options) {
+  const newUuid = options.newUuid ?? randomUUID;
+  const timestamp = (options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))();
+  let parentUuid = null;
+  return rows.map((row) => {
+    const replayed = row;
+    const uuid = replayed.uuid ?? newUuid();
+    const entry = {
+      ...row,
+      uuid,
+      parentUuid,
+      timestamp: replayed.timestamp ?? timestamp
+    };
+    parentUuid = uuid;
+    return entry;
+  });
+}
+function appendUserSide(rows, message, options) {
+  switch (message.role) {
+    case "user": {
+      const content = contentBlocks(message.content, options);
+      if (content.length > 0) appendSealedUser(rows, content);
+      return;
+    }
+    case "tool":
+      appendSealedUser(rows, [toToolResult(message, options)]);
+      return;
+    case "system":
+      return;
+    case "developer":
+      throw new LlmError2(
+        "The Claude subscription route cannot read developer messages.",
+        "UNSUPPORTED_CONTENT"
+      );
+  }
+}
+function appendSealedUser(rows, content) {
+  rows.push({ type: "user", message: { role: "user", content } });
+  rows.push({
+    type: "user",
+    isMeta: true,
+    message: { role: "user", content: [{ type: "text", text: SEAL_TEXT }] }
+  });
+}
+function appendAssistant(rows, message, options) {
+  const replay = replayOf(message, options);
+  if (replay !== void 0) rows.push(...replay.attachments);
+  const content = replay?.blocks ?? convertAssistantBlocks(message.content);
+  if (content.length > 0) {
+    rows.push({
+      type: "assistant",
+      // The CLI drops signed thinking from an entry with no message.model.
+      message: { role: "assistant", model: replay?.model ?? options.model, content }
+    });
+  }
+  return content.filter((block) => block.type === "tool_use");
+}
+function replayOf(message, options) {
+  const state = message.source.replayState;
+  if (state === void 0) return void 0;
+  const envelope = readReplayEnvelope(state);
+  if (envelope === void 0) {
+    options.onReplayDegraded?.("the replay state has an unknown shape");
+    return void 0;
+  }
+  if (envelope.blocks.length !== message.content.length) {
+    options.onReplayDegraded?.("the replay state does not line up with the message blocks");
+    return void 0;
+  }
+  return {
+    model: envelope.response.model,
+    attachments: envelope.response.attachments,
+    blocks: envelope.blocks.filter(
+      (block) => block.type !== "dropped"
+    )
+  };
+}
+function convertAssistantBlocks(blocks) {
+  const converted = [];
+  for (const block of blocks) {
+    switch (block.type) {
+      case "text":
+        if (block.text.trim().length > 0) converted.push({ type: "text", text: block.text });
+        break;
+      case "reasoning":
+        break;
+      case "tool-call":
+        converted.push({
+          type: "tool_use",
+          id: normalizeToolCallId(block.id),
+          name: block.name,
+          input: parseToolInput(block.arguments)
+        });
+        break;
+      default:
+        throw unsupportedBlock(block.type);
+    }
+  }
+  return converted;
+}
+function parseToolInput(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    return {};
+  }
+  return {};
+}
+function normalizeToolCallId(id) {
+  return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+function collectToolTurn(messages, start, toolCalls) {
+  const ids = new Set(toolCalls.map((call) => call.id));
+  const results = /* @__PURE__ */ new Map();
+  const held = [];
+  let index = start;
+  while (index < messages.length) {
+    const message = messages[index];
+    if (message.role === "assistant") break;
+    const id = message.role === "tool" ? normalizeToolCallId(message.toolCallId) : void 0;
+    if (message.role === "tool" && id !== void 0 && ids.has(id)) results.set(id, message);
+    else held.push(message);
+    index += 1;
+  }
+  return { results, held, nextIndex: index };
+}
+function appendToolResults(rows, toolCalls, results, options) {
+  const content = [];
+  const movedImages = [];
+  for (const call of toolCalls) {
+    const result = results.get(call.id);
+    if (result === void 0) {
+      content.push({
+        type: "tool_result",
+        tool_use_id: call.id,
+        is_error: true,
+        content: [{ type: "text", text: "No result provided" }]
+      });
+      continue;
+    }
+    content.push(toToolResult(result, options));
+    movedImages.push(...movedErrorImages(result, call.name, options));
+  }
+  appendSealedUser(rows, [...content, ...movedImages]);
+}
+function toToolResult(message, options) {
+  const toolUseId = normalizeToolCallId(message.toolCallId);
+  const blocks = message.isError ? contentBlocks(withoutErrorImages(message.content), options) : contentBlocks(message.content, options);
+  return {
+    type: "tool_result",
+    tool_use_id: toolUseId,
+    content: blocks.length > 0 ? blocks : [{ type: "text", text: "(no output)" }],
+    ...message.isError ? { is_error: true } : {}
+  };
+}
+function withoutErrorImages(blocks) {
+  return blocks.map(
+    (block) => block.type === "image" ? { type: "text", text: "(image attached after the tool results)" } : block
+  );
+}
+function movedErrorImages(message, toolName, options) {
+  if (!message.isError) return [];
+  const images = message.content.filter((block) => block.type === "image");
+  if (images.length === 0) return [];
+  return [
+    {
+      type: "text",
+      text: `Images from the error result of tool call ${message.toolCallId} (${toolName}):`
+    },
+    ...images.flatMap((block) => options.renderImage(block.attachment))
+  ];
+}
+function contentBlocks(blocks, options) {
+  const content = [];
+  for (const block of blocks) {
+    switch (block.type) {
+      case "text":
+        if (block.text.trim().length > 0) content.push({ type: "text", text: block.text });
+        break;
+      case "image":
+        content.push(...options.renderImage(block.attachment));
+        break;
+      default:
+        throw unsupportedBlock(block.type);
+    }
+  }
+  return content;
+}
+function systemText(blocks) {
+  return blocks.map((block) => {
+    if (block.type !== "text") throw unsupportedBlock(block.type);
+    return block.text;
+  }).join("");
+}
+function unsupportedBlock(type) {
+  return new LlmError2(
+    `The Claude subscription route cannot send a "${type}" block here.`,
+    "UNSUPPORTED_CONTENT"
+  );
+}
+
+// ../dsh-plugin-claude-subscription/src/login-check.ts
+var LOGIN_CHECK_DEADLINE_MS = 3e4;
+var LOGIN_CHECK_MAX_RETRIES = 0;
+function classifyAccount(account) {
+  if (account.apiKeySource !== void 0 && account.apiKeySource !== "none") {
+    return apiKeyBlockedError(account.apiKeySource);
+  }
+  if (account.apiProvider !== "firstParty") {
+    return notSubscriptionLoginError(account.apiProvider ?? "unknown");
+  }
+  if (account.subscriptionType === void 0) return loginRequiredError();
+  return void 0;
+}
+function idlePrompt() {
+  let release = () => {
+  };
+  const released = new Promise((resolve) => {
+    release = resolve;
+  });
+  return {
+    prompt: {
+      [Symbol.asyncIterator]: () => ({
+        next: async () => {
+          await released;
+          return { done: true, value: void 0 };
+        }
+      })
+    },
+    release
+  };
+}
+var LoginCheck = class {
+  constructor(services) {
+    this.services = services;
+    this.shared = new SharedRun({
+      deadlineMs: LOGIN_CHECK_DEADLINE_MS,
+      onDeadline: loginCheckTimeoutError,
+      run: (stop) => this.run(stop)
+    });
+  }
+  services;
+  passed = false;
+  shared;
+  async check(signal) {
+    if (this.passed) return void 0;
+    const result = await this.shared.join(signal);
+    if (result === void 0) this.passed = true;
+    return result;
+  }
+  async run(stop) {
+    const { tracker, cwd, processEnv, tempDir } = this.services;
+    tracker.assertOpen();
+    const abortController = new AbortController();
+    const idle = idlePrompt();
+    const running = query({
+      prompt: idle.prompt,
+      options: {
+        ...buildLoginCheckOptions({
+          sessionId: randomUUID2(),
+          entries: loginCheckEntries(),
+          cwd: cwd(),
+          env: buildChildEnv(processEnv, {
+            tempDir: tempDir.path,
+            maxRetries: LOGIN_CHECK_MAX_RETRIES
+          }),
+          abortController,
+          onLoad: tempDir.redirectSdkTempDir
+        }),
+        ...tracker.childOptions()
+      }
+    });
+    const handle = new QueryHandle(running, abortController, tracker);
+    try {
+      const answer = await raceAbort(
+        running.initializationResult(),
+        AbortSignal.any([stop, tracker.closing])
+      );
+      tracker.assertOpen();
+      if (answer === ABORTED) return loginCheckTimeoutError();
+      return classifyAccount(answer.account);
+    } catch (error) {
+      tracker.assertOpen();
+      return mapThrownError(error);
+    } finally {
+      void handle.hardStop();
+      idle.release();
+    }
+  }
+};
+function loginCheckEntries() {
+  return buildTranscript([{ role: "user", content: [{ type: "text", text: "Login check." }] }], {
+    model: LOGIN_CHECK_MODEL,
+    renderImage: () => []
+  });
+}
+function raceAbort(work, signal) {
+  return new Promise((resolve, reject) => {
+    const onAbort = () => resolve(ABORTED);
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+    work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+
+// ../dsh-plugin-claude-subscription/src/login-refresh.ts
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+var REFRESH_MAX_RETRIES = 2;
+var REFRESH_DEADLINE_MS = 6e4;
+var LoginRefresher = class {
+  constructor(services) {
+    this.services = services;
+    this.shared = new SharedRun({
+      deadlineMs: REFRESH_DEADLINE_MS,
+      onDeadline: loginRefreshTimeoutError,
+      run: (stop) => this.run(stop)
+    });
+  }
+  services;
+  shared;
+  refresh(signal) {
+    return this.shared.join(signal);
+  }
+  async run(stop) {
+    this.services.tracker.assertOpen();
+    const abortController = new AbortController();
+    const handle = new QueryHandle(
+      query2({
+        prompt: REFRESH_PROMPT,
+        options: {
+          ...buildRefreshOptions({
+            cwd: this.services.cwd(),
+            env: buildChildEnv(this.services.processEnv, {
+              tempDir: this.services.tempDir.path,
+              maxRetries: REFRESH_MAX_RETRIES
+            })
+          }),
+          abortController,
+          ...this.services.tracker.childOptions()
+        }
+      }),
+      abortController,
+      this.services.tracker
+    );
+    const onStop = () => void handle.hardStop();
+    stop.addEventListener("abort", onStop, { once: true });
+    try {
+      while (true) {
+        const next = await handle.next();
+        if (next.done) return void 0;
+        const message = next.value;
+        if (message.type === "system" && message.subtype === "init") {
+          if (message.apiKeySource !== "none") {
+            void handle.hardStop();
+            return apiKeyDuringStepError(message.apiKeySource);
+          }
+        }
+        if (message.type === "assistant" && message.error === "authentication_failed") {
+          return loginRequiredError();
+        }
+        if (message.type === "result") return void 0;
+      }
+    } catch {
+      return void 0;
+    } finally {
+      stop.removeEventListener("abort", onStop);
+      handle.settle("drain");
+    }
+  }
+};
+
+// ../dsh-plugin-claude-subscription/src/models.ts
+import {
+  LlmError as LlmError3,
+  ReasoningEffortId
+} from "@deepseek-ai/dsh-llm";
+var PROVIDER_ID = "claude-subscription";
+var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+var CLAUDE_MODELS = [
+  { id: "claude-fable-5-1", name: "Claude Fable 5.1", contextWindow: 1e6 },
+  { id: "claude-opus-5-5", name: "Claude Opus 5.5", contextWindow: 1e6 },
+  { id: "claude-sonnet-5-5", name: "Claude Sonnet 5.5", contextWindow: 1e6 },
+  { id: "claude-haiku-5-5", name: "Claude Haiku 5.5", contextWindow: 1e6 }
+];
+var EFFORTS = [
+  { id: ReasoningEffortId("low"), name: "Low" },
+  { id: ReasoningEffortId("medium"), name: "Medium" },
+  { id: ReasoningEffortId("high"), name: "High" },
+  { id: ReasoningEffortId("xhigh"), name: "Extra high" },
+  { id: ReasoningEffortId("max"), name: "Max" }
+];
+function findClaudeModel(id) {
+  return CLAUDE_MODELS.find((model) => model.id === id);
+}
+function requireClaudeModel(id) {
+  const model = findClaudeModel(id);
+  if (model === void 0) {
+    throw new LlmError3(`The ${PROVIDER_ID} route has no model named "${id}".`, "UNKNOWN_MODEL");
+  }
+  return model;
+}
+function listModelInfo() {
+  return CLAUDE_MODELS.map((model) => ({
+    provider: PROVIDER_ID,
+    id: model.id,
+    name: model.name,
+    inputModalities: ["text", "image"]
+  }));
+}
+function resolveModelInfo(id) {
+  const model = requireClaudeModel(id);
+  return {
+    provider: PROVIDER_ID,
+    id: model.id,
+    name: model.name,
+    inputModalities: ["text", "image"],
+    context: { contextWindow: model.contextWindow },
+    reasoning: { efforts: EFFORTS }
+  };
+}
+function parseEffort(effort) {
+  if (effort === void 0) return void 0;
+  const level = EFFORT_LEVELS.find((candidate) => candidate === String(effort));
+  if (level === void 0) {
+    throw new LlmError3(
+      `The ${PROVIDER_ID} route has no effort named "${String(effort)}".`,
+      "UNSUPPORTED_REASONING_EFFORT"
+    );
+  }
+  return level;
+}
+
+// ../dsh-plugin-claude-subscription/src/request-images.ts
+import { requestImageDimensions } from "@deepseek-ai/dsh-attachment";
+import {
+  contentHasImage,
+  IMAGE_OFFLOAD_REQUIRED_CODE,
+  LlmError as LlmError4,
+  offloadedImageText,
+  projectOffloadedImages,
+  requestImageHandleText,
+  requiredImageOffload,
+  resolveImageAttachmentAccess
+} from "@deepseek-ai/dsh-llm";
+var MAX_REQUEST_IMAGE_PIXELS = 2048 * 2048;
+var MAX_REQUEST_IMAGE_BYTES = 1024 * 1024;
+var MAX_REQUEST_BASE64_BYTES = 20 * 1024 * 1024;
+function imageRequestTarget(image) {
+  return {
+    ...requestImageDimensions(image.width, image.height, MAX_REQUEST_IMAGE_PIXELS),
+    maxBytes: MAX_REQUEST_IMAGE_BYTES
+  };
+}
+async function prepareRequestImages(messages, services, signal) {
+  if (!messages.some((message) => contentHasImage(message.content))) {
+    return { messages, renderImage: renderWithoutService };
+  }
+  const attachments = services.attachments();
+  if (attachments === void 0) {
+    throw new LlmError4(
+      "Sending an image to Claude needs the DSH attachment service.",
+      "UNSUPPORTED_CONTENT"
+    );
+  }
+  const versions = await readRetainedImages(messages, attachments, signal);
+  assertRequestFits(messages, versions);
+  const access = (ref) => resolveImageAttachmentAccess(attachments, services.mapHostPath, ref);
+  return {
+    messages: projectOffloadedImages(messages, (ref) => offloadedImageText(ref, access(ref))),
+    renderImage(ref) {
+      const version = versions.get(ref.attachmentId);
+      return [
+        { type: "text", text: requestImageHandleText(ref, version, access(ref)) },
+        {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: version.mediaType,
+            data: Buffer.from(version.data).toString("base64")
+          }
+        }
+      ];
+    }
+  };
+}
+async function readRetainedImages(messages, attachments, signal) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const block of message.content) {
+      if (block.type === "image" && block.offloaded !== true) {
+        refs.set(block.attachment.attachmentId, block.attachment);
+      }
+    }
+  }
+  const versions = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...refs.values()].map(async (ref) => {
+      versions.set(
+        ref.attachmentId,
+        await attachments.readImageRequest(ref, imageRequestTarget(ref), signal)
+      );
+    })
+  );
+  return versions;
+}
+function assertRequestFits(messages, versions) {
+  const offloadImages = requiredImageOffload(
+    messages,
+    { representation: "base64", maxBytes: MAX_REQUEST_BASE64_BYTES },
+    (block) => versions.get(block.attachment.attachmentId).bytes
+  );
+  if (offloadImages > 0) {
+    throw new LlmError4(
+      `Request images exceed ${MAX_REQUEST_BASE64_BYTES} base64 bytes. ${offloadImages} more of the oldest must be offloaded.`,
+      IMAGE_OFFLOAD_REQUIRED_CODE,
+      { offloadImages }
+    );
+  }
+}
+function renderWithoutService() {
+  throw new Error("renderImage was called for a history with no images");
+}
+
+// ../dsh-plugin-claude-subscription/src/step.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import {
+  query as query3
+} from "@anthropic-ai/claude-agent-sdk";
+import { LlmError as LlmError6 } from "@deepseek-ai/dsh-llm";
+
+// ../dsh-plugin-claude-subscription/src/stream-mapper.ts
+import {
+  CONTEXT_WINDOW_EXCEEDED_CODE as CONTEXT_WINDOW_EXCEEDED_CODE2,
+  LlmError as LlmError5,
+  ToolCallId
+} from "@deepseek-ai/dsh-llm";
+var REDACTED_THINKING_TEXT = "[Reasoning redacted]";
+function needsInterrupt(stopReason) {
+  return stopReason !== "end_turn" && stopReason !== "stop_sequence";
+}
+function createStreamMapper() {
+  const blocks = /* @__PURE__ */ new Map();
+  let messageId = null;
+  let stopReason = null;
+  let stopExplanation;
+  let usage;
+  function mergeUsage(next) {
+    if (next !== void 0) usage = { ...usage, ...next };
+  }
+  function onBlockStart(index, start) {
+    const block = openBlock(blocks.size, start);
+    blocks.set(index, block);
+    const chunks = [
+      {
+        type: "block-start",
+        index: block.dshIndex,
+        blockType: block.kind === "text" ? "text" : block.kind === "tool" ? "tool-call" : "reasoning"
+      }
+    ];
+    if (block.kind === "text" && block.text.length > 0) {
+      chunks.push({ type: "text-delta", index: block.dshIndex, text: block.text });
+    }
+    return chunks;
+  }
+  function onBlockDelta(index, delta) {
+    const block = blocks.get(index);
+    if (block === void 0) return [];
+    switch (delta.type) {
+      case "text_delta":
+        if (block.kind !== "text" || delta.text === void 0) return [];
+        block.text += delta.text;
+        return [{ type: "text-delta", index: block.dshIndex, text: delta.text }];
+      case "thinking_delta":
+        if (block.kind !== "thinking" || !delta.thinking) return [];
+        block.thinking += delta.thinking;
+        return [{ type: "reasoning-delta", index: block.dshIndex, text: delta.thinking }];
+      case "signature_delta":
+        if (block.kind === "thinking" && delta.signature !== void 0) {
+          block.signature = delta.signature;
+        }
+        return [];
+      case "input_json_delta":
+        if (block.kind !== "tool" || delta.partial_json === void 0) return [];
+        block.json += delta.partial_json;
+        return [
+          {
+            type: "tool-call-delta",
+            index: block.dshIndex,
+            id: ToolCallId(block.id),
+            name: block.name,
+            argumentsDelta: delta.partial_json
+          }
+        ];
+      default:
+        return [];
+    }
+  }
+  function onBlockStop(index) {
+    const block = blocks.get(index);
+    return block === void 0 ? [] : [closeBlock(block)];
+  }
+  return {
+    onEvent(event) {
+      switch (event.type) {
+        case "message_start":
+          if (messageId !== null) {
+            throw new LlmError5("Claude Code restarted a response mid-stream.", "TRANSPORT");
+          }
+          messageId = event.message.id;
+          mergeUsage(event.message.usage);
+          return [];
+        case "content_block_start":
+          return onBlockStart(event.index, event.content_block);
+        case "content_block_delta":
+          return onBlockDelta(event.index, event.delta);
+        case "content_block_stop":
+          return onBlockStop(event.index);
+        case "message_delta":
+          stopReason = event.delta.stop_reason;
+          stopExplanation = event.delta.stop_details?.explanation;
+          mergeUsage(event.usage);
+          return [];
+        default:
+          return [];
+      }
+    },
+    get stopReason() {
+      return stopReason;
+    },
+    usageChunks() {
+      return usage === void 0 ? [] : [{ type: "usage", usage: toTokenUsage(usage) }];
+    },
+    finish(context) {
+      if (stopReason === null) throw new Error("finish() needs a stop reason");
+      const ordered = [...blocks.values()].sort((a, b) => a.dshIndex - b.dshIndex);
+      const closing = ordered.flatMap(
+        (block) => (
+          // A tool call cut off by the output limit stays open: the assembler drops it.
+          block.closed || block.kind === "tool" ? [] : [closeBlock(block)]
+        )
+      );
+      const reason = finishReason(stopReason, stopExplanation, ordered);
+      const succeeded = reason.kind !== "error";
+      return [
+        ...closing,
+        ...this.usageChunks(),
+        {
+          type: "finish",
+          reason,
+          ...succeeded ? {
+            replayState: createReplayEnvelope({
+              model: context.model,
+              messageId,
+              stopReason,
+              attachments: context.attachments,
+              healedErrors: context.healedErrors,
+              blocks: ordered.map(toReplayBlock)
+            })
+          } : {}
+        }
+      ];
+    }
+  };
+}
+function openBlock(dshIndex, start) {
+  const base = { dshIndex, closed: false };
+  switch (start.type) {
+    case "text":
+      return { ...base, kind: "text", text: start.text ?? "" };
+    case "thinking":
+      return {
+        ...base,
+        kind: "thinking",
+        thinking: start.thinking ?? "",
+        signature: start.signature ?? ""
+      };
+    case "redacted_thinking":
+      return { ...base, kind: "redacted", data: start.data ?? "" };
+    case "tool_use":
+      return { ...base, kind: "tool", id: start.id ?? "", name: start.name ?? "", json: "" };
+    default:
+      throw new LlmError5(
+        `Claude Code sent a content block of type "${start.type}", which this plugin cannot read.`,
+        "INVALID_RESPONSE"
+      );
+  }
+}
+function closeBlock(block) {
+  block.closed = true;
+  const index = block.dshIndex;
+  switch (block.kind) {
+    case "text":
+      return { type: "block-end", index, block: { type: "text", text: block.text } };
+    case "thinking":
+      return { type: "block-end", index, block: { type: "reasoning", text: block.thinking } };
+    case "redacted":
+      return {
+        type: "block-end",
+        index,
+        block: { type: "reasoning", text: REDACTED_THINKING_TEXT }
+      };
+    case "tool": {
+      const json = block.json.length > 0 ? block.json : "{}";
+      block.input = parseToolInput2(json);
+      return {
+        type: "block-end",
+        index,
+        block: { type: "tool-call", id: ToolCallId(block.id), name: block.name, arguments: json }
+      };
+    }
+  }
+}
+function parseToolInput2(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (cause) {
+    throw new LlmError5("Claude sent tool arguments that are not valid JSON.", "INVALID_RESPONSE", {
+      cause
+    });
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new LlmError5("Claude sent tool arguments that are not an object.", "INVALID_RESPONSE");
+  }
+  return parsed;
+}
+function finishReason(stopReason, explanation, blocks) {
+  const hasToolCall = blocks.some((block) => block.kind === "tool" && block.closed);
+  const hasText = blocks.some((block) => block.kind === "text" && block.text.length > 0);
+  switch (stopReason) {
+    case "end_turn":
+    case "stop_sequence":
+    case "pause_turn":
+      return hasText || hasToolCall ? { kind: "stop" } : failed(emptyResponseError().failure);
+    case "tool_use":
+      return hasToolCall ? { kind: "tool-calls" } : failed(emptyResponseError().failure);
+    case "max_tokens":
+      return { kind: "max-tokens" };
+    case "refusal":
+      return failed(refusalError(explanation).failure);
+    case "model_context_window_exceeded":
+      return failed({
+        message: "Claude reached the end of its context window.",
+        code: CONTEXT_WINDOW_EXCEEDED_CODE2
+      });
+    default:
+      return failed({
+        message: `Claude stopped with an unknown reason: ${stopReason}.`,
+        code: "UNKNOWN_STOP_REASON"
+      });
+  }
+}
+function failed(failure) {
+  return { kind: "error", failure };
+}
+function toReplayBlock(block) {
+  switch (block.kind) {
+    case "text":
+      return block.text.length > 0 ? { type: "text", text: block.text } : { type: "dropped" };
+    case "thinking":
+      return block.signature.length > 0 ? { type: "thinking", thinking: block.thinking, signature: block.signature } : { type: "dropped" };
+    case "redacted":
+      return { type: "redacted_thinking", data: block.data };
+    case "tool":
+      return block.input === void 0 ? { type: "dropped" } : { type: "tool_use", id: block.id, name: block.name, input: block.input };
+  }
+}
+function toTokenUsage(usage) {
+  const inputTokens = usage.input_tokens ?? 0;
+  const outputTokens = usage.output_tokens ?? 0;
+  const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+  const cacheWriteTokens = usage.cache_creation_input_tokens ?? 0;
+  const reasoningTokens = usage.output_tokens_details?.thinking_tokens ?? 0;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens,
+    ...cacheReadTokens > 0 ? { cacheReadTokens } : {},
+    ...cacheWriteTokens > 0 ? { cacheWriteTokens } : {},
+    ...reasoningTokens > 0 ? { reasoningTokens } : {}
+  };
+}
+
+// ../dsh-plugin-claude-subscription/src/step.ts
+var STEP_MAX_RETRIES = 0;
+async function* runStep(request, services) {
+  const appended = [];
+  const abortController = new AbortController();
+  const handle = new QueryHandle(
+    startQuery(request, services, abortController, (entries) => appended.push(...entries)),
+    abortController,
+    services.tracker
+  );
+  const mapper = createStreamMapper();
+  const frames = new FrameFacts();
+  const aborted = abortedPromise(request.signal);
+  let emittedOutput = false;
+  const fail = (error, expiredLogin = false) => {
+    handle.settle("drain");
+    return { kind: "failed", error, expiredLogin, emittedOutput };
+  };
+  try {
+    while (true) {
+      let next;
+      try {
+        next = await Promise.race([handle.next(), aborted.promise]);
+      } catch (error) {
+        if (!request.signal?.aborted && !handle.hardStopped) return fail(mapThrownError(error));
+        next = ABORTED;
+      }
+      if (next === ABORTED || next.done && handle.hardStopped) {
+        handle.settle("interrupt");
+        yield* abortedChunks(mapper);
+        return { kind: "completed" };
+      }
+      if (next.done) {
+        return fail(new LlmError6("Claude Code ended the stream with no result.", "STREAM_CLOSED"));
+      }
+      const message = next.value;
+      if (message.type === "system" && message.subtype === "init") {
+        if (message.apiKeySource !== "none") {
+          void handle.hardStop();
+          return fail(apiKeyDuringStepError(message.apiKeySource));
+        }
+      } else if (message.type === "result") {
+        if (!message.is_error) return fail(emptyResponseError());
+        const failure = frames.failureFrom(message);
+        return fail(mapStepFailure(failure), isExpiredLogin(failure));
+      } else if (message.type === "stream_event") {
+        if (message.parent_tool_use_id !== null) continue;
+        let chunks;
+        try {
+          chunks = mapper.onEvent(message.event);
+        } catch (error) {
+          handle.settle("interrupt");
+          return fail(mapThrownError(error));
+        }
+        for (const chunk of chunks) {
+          emittedOutput = true;
+          yield chunk;
+        }
+        if (mapper.stopReason !== null) {
+          handle.settle(needsInterrupt(mapper.stopReason) ? "interrupt" : "drain");
+          yield* finishChunks(mapper, request.model, appended, frames.assistantErrors, services);
+          return { kind: "completed" };
+        }
+      } else {
+        frames.observe(message);
+      }
+    }
+  } finally {
+    aborted.dispose();
+    handle.settle("interrupt");
+  }
+}
+function* abortedChunks(mapper) {
+  if (mapper !== void 0) yield* mapper.usageChunks();
+  yield {
+    type: "finish",
+    reason: { kind: "aborted", failure: { message: "The request was aborted.", code: "ABORTED" } }
+  };
+}
+function startQuery(request, services, abortController, onAppend) {
+  return query3({
+    // Empty on purpose: the whole history is in the transcript, and an empty prompt adds no text.
+    prompt: "",
+    options: {
+      ...buildStepOptions({
+        model: request.model,
+        systemPrompt: request.systemPrompt,
+        tools: request.tools,
+        sessionId: randomUUID3(),
+        entries: request.entries,
+        cwd: services.cwd(),
+        env: buildChildEnv(services.processEnv, {
+          tempDir: services.tempDir.path,
+          maxRetries: STEP_MAX_RETRIES,
+          ...request.maxOutputTokens === void 0 ? {} : { maxOutputTokens: request.maxOutputTokens }
+        }),
+        abortController,
+        ...request.effort === void 0 ? {} : { effort: request.effort },
+        onAppend,
+        onLoad: services.tempDir.redirectSdkTempDir
+      }),
+      ...services.tracker.childOptions()
+    }
+  });
+}
+var FrameFacts = class {
+  /** An error that ends the step, or, when the step still succeeds, a problem the CLI healed. */
+  assistantErrors = [];
+  rateLimit;
+  observe(message) {
+    if (message.type === "rate_limit_event") {
+      this.rateLimit = message.rate_limit_info;
+    } else if (message.type === "assistant" && message.error !== void 0 && message.parent_tool_use_id === null) {
+      this.assistantErrors.push({
+        kind: message.error,
+        text: message.message.content.map((block) => block.type === "text" ? block.text : "").join("")
+      });
+    }
+  }
+  failureFrom(result) {
+    const text = "result" in result ? result.result : result.errors.join("; ");
+    const status = "api_error_status" in result ? result.api_error_status : null;
+    return {
+      ...this.assistantErrors.length > 0 ? { assistantError: this.assistantErrors.at(-1)?.kind } : {},
+      status: status ?? null,
+      terminalReason: result.terminal_reason ?? null,
+      text: text || result.subtype,
+      ...this.rateLimit === void 0 ? {} : { rateLimit: this.rateLimit }
+    };
+  }
+};
+function* finishChunks(mapper, model, appended, healedErrors, services) {
+  const chunks = mapper.finish({
+    model,
+    attachments: attachmentsToReplay(appended),
+    healedErrors
+  });
+  const finish = chunks.at(-1);
+  if (finish?.type === "finish" && finish.reason.kind !== "error") {
+    for (const healed of healedErrors) {
+      services.logger.warn(
+        `claude-subscription: Claude Code recovered from a problem on ${model}: ${healed.text}`
+      );
+    }
+  }
+  yield* chunks;
+}
+function abortedPromise(signal) {
+  if (signal === void 0) return { promise: new Promise(() => {
+  }), dispose() {
+  } };
+  let onAbort = () => {
+  };
+  const promise = new Promise((resolve) => {
+    onAbort = () => resolve(ABORTED);
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  });
+  return { promise, dispose: () => signal.removeEventListener("abort", onAbort) };
+}
+
+// ../dsh-plugin-claude-subscription/src/adapter.ts
+var ClaudeSubscriptionAdapter = class extends LlmAdapter {
+  constructor(services) {
+    super();
+    this.services = services;
+    this.stepServices = { ...services, tracker: this.tracker };
+    this.loginCheck = new LoginCheck(this.stepServices);
+    this.refresher = new LoginRefresher(this.stepServices);
+  }
+  services;
+  tracker = new QueryTracker();
+  stepServices;
+  loginCheck;
+  refresher;
+  providerInfo(provider) {
+    return { id: provider, name: "Claude (subscription)" };
+  }
+  imageRequestTarget(_provider, _model, image) {
+    return imageRequestTarget(image);
+  }
+  async listModels(_provider) {
+    return listModelInfo();
+  }
+  async resolveModel(_provider, model) {
+    return resolveModelInfo(model);
+  }
+  async *stream(options) {
+    const { signal } = options;
+    this.tracker.assertOpen();
+    if (signal?.aborted) {
+      yield* abortedChunks();
+      return;
+    }
+    const request = await this.buildStepRequest(options);
+    this.tracker.assertOpen();
+    const loginProblem = await this.loginCheck.check(signal);
+    if (loginProblem === ABORTED) {
+      yield* abortedChunks();
+      return;
+    }
+    if (loginProblem !== void 0) throw loginProblem;
+    let refreshed = false;
+    while (true) {
+      this.tracker.assertOpen();
+      if (signal?.aborted) {
+        yield* abortedChunks();
+        return;
+      }
+      const outcome = yield* runStep(request, this.stepServices);
+      if (outcome.kind === "completed") return;
+      if (!outcome.expiredLogin) throw outcome.error;
+      if (refreshed || outcome.emittedOutput) throw loginRequiredError();
+      refreshed = true;
+      const refreshProblem = await this.refresher.refresh(signal);
+      if (refreshProblem === ABORTED) {
+        yield* abortedChunks();
+        return;
+      }
+      if (refreshProblem !== void 0) throw refreshProblem;
+    }
+  }
+  /** Ends every query still running. No step can start after this. */
+  dispose() {
+    return this.tracker.dispose();
+  }
+  async buildStepRequest(options) {
+    if (options.temperature !== void 0) throw unsupportedOptionError("temperature");
+    if (options.stop !== void 0) throw unsupportedOptionError("stop");
+    const model = requireClaudeModel(options.model);
+    const effort = parseEffort(options.reasoningEffort);
+    const { systemPrompt, messages } = splitSystemPrompt(options);
+    const images = await prepareRequestImages(messages, this.services, options.signal);
+    const entries = buildTranscript(images.messages, {
+      model: model.id,
+      renderImage: images.renderImage,
+      onReplayDegraded: (reason) => {
+        this.services.logger.warn(
+          `claude-subscription: sending an assistant message without its thinking: ${reason}`
+        );
+      }
+    });
+    return {
+      model: model.id,
+      systemPrompt,
+      entries,
+      tools: options.tools ?? [],
+      ...effort === void 0 ? {} : { effort },
+      ...options.maxTokens === void 0 ? {} : { maxOutputTokens: options.maxTokens },
+      ...options.signal === void 0 ? {} : { signal: options.signal }
+    };
+  }
+};
+
+// ../dsh-plugin-claude-subscription/src/index.ts
+var name = "claude-subscription";
+var inject = ["llm"];
+function apply(ctx) {
+  const tempDir = createPrivateTempDir({
+    onRemoveFailed: (error) => ctx.logger.warn(`claude-subscription: could not remove the private temp dir: ${error}`)
+  });
+  const adapter = new ClaudeSubscriptionAdapter({
+    processEnv: process.env,
+    cwd: () => process.cwd(),
+    tempDir,
+    logger: { warn: (message) => ctx.logger.warn(message) },
+    attachments: () => ctx.get("attachments"),
+    mapHostPath: (hostPath) => ctx.get("fs")?.processPathFromHostPath(hostPath)
+  });
+  ctx.llm.registerAdapter([PROVIDER_ID], adapter);
+  ctx.effect(
+    () => async () => {
+      await adapter.dispose();
+      tempDir.dispose();
+    },
+    "claude-subscription: running queries and temp dir"
+  );
+}
+export {
+  apply,
+  inject,
+  name
+};