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

package/lib/index.js

@@ -0,0 +1,3773 @@
+// src/index.ts
+import { fileURLToPath } from "node:url";
+
+// src/errors.ts
+var FailureCode = {
+  aborted: "ABORTED",
+  contextWindowExceeded: "CONTEXT_WINDOW_EXCEEDED",
+  emptyResponse: "EMPTY_RESPONSE",
+  imageOffloadRequired: "IMAGE_OFFLOAD_REQUIRED",
+  invalidCredential: "INVALID_CREDENTIAL",
+  quota: "QUOTA",
+  rateLimit: "RATE_LIMIT",
+  timeout: "TIMEOUT",
+  server: "SERVER",
+  transport: "TRANSPORT",
+  claudeCodeMissing: "CLAUDE_CODE_MISSING",
+  conflictingEnvironment: "CONFLICTING_ENVIRONMENT",
+  invalidRequest: "INVALID_REQUEST",
+  nativeProtocol: "NATIVE_PROTOCOL",
+  upstreamError: "UPSTREAM_ERROR",
+  relayError: "RELAY_ERROR"
+};
+var REQUEST_ID = /^req_[A-Za-z0-9_-]{1,124}$/;
+var NativeFailure = class extends Error {
+  code;
+  failure;
+  constructor(message, code, facts = {}) {
+    const requestId = facts.requestId !== void 0 && REQUEST_ID.test(facts.requestId) ? facts.requestId : void 0;
+    const text = requestId === void 0 ? message : `${message} (request_id=${requestId})`;
+    super(text, facts.cause === void 0 ? void 0 : { cause: facts.cause });
+    this.name = "NativeFailure";
+    this.code = code;
+    this.failure = {
+      message: text,
+      code,
+      ...facts.status === void 0 ? {} : { status: facts.status },
+      ...facts.providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs: facts.providerRetryAfterMs },
+      ...requestId === void 0 ? {} : { requestId },
+      ...facts.offloadImages === void 0 ? {} : { offloadImages: facts.offloadImages }
+    };
+  }
+};
+
+// src/response/finish.ts
+var CONTENT_FILTER_CODE = "CONTENT_FILTER";
+var CUT_OFF_STOP_REASONS = /* @__PURE__ */ new Set(["max_tokens", "model_context_window_exceeded"]);
+function isRefusal(assistants) {
+  return assistants.some((message) => message.stop_reason === "refusal");
+}
+function isCutOff(assistants) {
+  return assistants.some((message) => CUT_OFF_STOP_REASONS.has(message.stop_reason ?? ""));
+}
+function refusalFailure(assistants) {
+  const details = assistants.find((message) => message.stop_details !== void 0)?.stop_details;
+  return { code: CONTENT_FILTER_CODE, message: refusalMessage(details) };
+}
+function refusalMessage(details) {
+  const explanation = details?.explanation;
+  if (typeof explanation === "string" && explanation.trim() !== "") return explanation.trim();
+  const category = details?.category;
+  if (typeof category === "string" && category !== "") {
+    return `provider refusal category: ${category}`;
+  }
+  return "The provider refused this request.";
+}
+function usageOf(usage) {
+  const cacheRead = usage.cache_read_input_tokens;
+  const cacheWrite = usage.cache_creation_input_tokens;
+  const reasoning = usage.output_tokens_details?.thinking_tokens;
+  return {
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    totalTokens: usage.input_tokens + usage.output_tokens + (cacheRead ?? 0) + (cacheWrite ?? 0),
+    ...cacheRead === void 0 ? {} : { cacheReadTokens: cacheRead },
+    ...cacheWrite === void 0 ? {} : { cacheWriteTokens: cacheWrite },
+    ...reasoning === void 0 ? {} : { reasoningTokens: reasoning }
+  };
+}
+
+// src/response/lossless.ts
+var OBJECT_PROTOTYPE = Object.prototype;
+var ARRAY_PROTOTYPE = Array.prototype;
+function isLosslessNumber(value) {
+  return Number.isFinite(value) && !Object.is(value, -0);
+}
+function isLosslessArray(value, ancestors) {
+  if (Object.getPrototypeOf(value) !== ARRAY_PROTOTYPE) return false;
+  if (Reflect.ownKeys(value).length !== value.length + 1) return false;
+  return value.every(
+    (_item, index) => Object.hasOwn(value, index) && isLossless(value[index], ancestors)
+  );
+}
+function isLosslessObject(value, ancestors) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== OBJECT_PROTOTYPE && prototype !== null) return false;
+  const keys = Reflect.ownKeys(value);
+  return keys.every(
+    (key) => typeof key === "string" && Object.prototype.propertyIsEnumerable.call(value, key) && isLossless(value[key], ancestors)
+  );
+}
+function isLossless(value, ancestors) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") return true;
+  if (typeof value === "number") return isLosslessNumber(value);
+  if (typeof value !== "object" || ancestors.has(value)) return false;
+  ancestors.add(value);
+  const lossless = Array.isArray(value) ? isLosslessArray(value, ancestors) : isLosslessObject(value, ancestors);
+  ancestors.delete(value);
+  return lossless;
+}
+function isLosslessJson(value) {
+  return isLossless(value, /* @__PURE__ */ new Set());
+}
+
+// src/contract.ts
+var PROVIDER_ID = "claude-subscription";
+var MCP_SERVER_NAME = "dsh";
+var TOOL_PREFIX = `mcp__${MCP_SERVER_NAME}__`;
+
+// src/response/tool-names.ts
+function invertToolNames(toolNames) {
+  return new Map([...toolNames].map(([dshName, nativeName]) => [nativeName, dshName]));
+}
+function dshToolName(nativeName, names) {
+  const bare = nativeName.startsWith(TOOL_PREFIX) ? nativeName.slice(TOOL_PREFIX.length) : nativeName;
+  return names.get(bare) ?? bare;
+}
+function withOfferedToolNames(message, names) {
+  return {
+    ...message,
+    content: message.content.map(
+      (block) => block.type === "tool_use" && typeof block.name === "string" && names.has(block.name) ? { ...block, name: `${TOOL_PREFIX}${block.name}` } : block
+    )
+  };
+}
+
+// src/response/chunks.ts
+var ChunkTranslator = class {
+  names;
+  projectionOf;
+  streamed = /* @__PURE__ */ new Map();
+  settled = /* @__PURE__ */ new Map();
+  nextIndex = 0;
+  constructor(options) {
+    this.names = invertToolNames(options.toolNames);
+    this.projectionOf = options.projectionOf;
+  }
+  event(event) {
+    switch (event.type) {
+      case "content_block_start":
+        return this.startBlock(event);
+      case "content_block_delta":
+        return this.applyDelta(event);
+      case "content_block_stop":
+        return this.stopBlock(event);
+      default:
+        return [];
+    }
+  }
+  /** @throws NativeFailure when the final message contradicts what was streamed. */
+  complete(completion) {
+    const { assistants } = completion;
+    const usage = { type: "usage", usage: usageOf(completion.usage) };
+    if (isRefusal(assistants)) {
+      return [usage, finishChunk({ kind: "error", failure: refusalFailure(assistants) })];
+    }
+    const blocks = assistants.flatMap((message) => message.content);
+    const hasToolUse = blocks.some(isToolUse);
+    const display = this.settleDisplay(blocks);
+    if (isCutOff(assistants)) {
+      const replayState = hasToolUse ? void 0 : this.replayState(completion);
+      return [...display, usage, finishChunk({ kind: "max-tokens" }, replayState)];
+    }
+    const toolCalls = this.settleToolCalls(blocks);
+    if (!hasToolUse && !hasVisibleText(blocks)) {
+      return [...display, usage, finishChunk({ kind: "error", failure: EMPTY_RESPONSE })];
+    }
+    const reason = { kind: hasToolUse ? "tool-calls" : "stop" };
+    return [...display, ...toolCalls, usage, finishChunk(reason, this.replayState(completion))];
+  }
+  startBlock(event) {
+    const nativeIndex = blockIndexOf(event);
+    if (this.streamed.has(nativeIndex)) malformed(`block ${nativeIndex} started twice`);
+    const block = objectField(event, "content_block");
+    switch (block.type) {
+      case "text":
+        return this.startDisplay(nativeIndex, "text", block.text);
+      case "thinking":
+        return this.startDisplay(nativeIndex, "reasoning", block.thinking);
+      case "tool_use":
+        return this.startToolCall(nativeIndex, block);
+      default:
+        this.streamed.set(nativeIndex, { kind: "hidden" });
+        return [];
+    }
+  }
+  startDisplay(nativeIndex, kind, initial) {
+    const block = newDisplayBlock(kind);
+    this.streamed.set(nativeIndex, block);
+    return typeof initial === "string" ? this.appendDisplay(block, initial) : [];
+  }
+  startToolCall(nativeIndex, block) {
+    const id = stringField(block, "id");
+    const name2 = dshToolName(stringField(block, "name"), this.names);
+    const index = this.takeIndex();
+    this.streamed.set(nativeIndex, { kind: "tool-call", index, id, name: name2 });
+    return [
+      { type: "block-start", index, blockType: "tool-call" },
+      { type: "tool-call-delta", index, id: toolCallId(id), name: name2, argumentsDelta: "" }
+    ];
+  }
+  applyDelta(event) {
+    const nativeIndex = blockIndexOf(event);
+    const block = this.streamed.get(nativeIndex);
+    if (block === void 0) malformed(`delta for block ${nativeIndex}, which never started`);
+    if (block.kind === "hidden") return [];
+    const delta = objectField(event, "delta");
+    switch (delta.type) {
+      case "text_delta":
+        if (block.kind !== "text") malformed(`text delta for a ${block.kind} block`);
+        return this.appendDisplay(block, stringField(delta, "text"));
+      case "thinking_delta":
+        if (block.kind !== "reasoning") malformed(`thinking delta for a ${block.kind} block`);
+        return this.appendDisplay(block, stringField(delta, "thinking"));
+      case "input_json_delta":
+        if (block.kind !== "tool-call") malformed(`tool input delta for a ${block.kind} block`);
+        return [
+          {
+            type: "tool-call-delta",
+            index: block.index,
+            id: toolCallId(block.id),
+            argumentsDelta: stringField(delta, "partial_json")
+          }
+        ];
+      default:
+        return [];
+    }
+  }
+  appendDisplay(block, text) {
+    if (text === "") return [];
+    const chunks = [];
+    if (block.index === void 0) {
+      block.index = this.takeIndex();
+      chunks.push({ type: "block-start", index: block.index, blockType: block.kind });
+    }
+    block.text += text;
+    chunks.push(
+      block.kind === "text" ? { type: "text-delta", index: block.index, text } : { type: "reasoning-delta", index: block.index, text }
+    );
+    return chunks;
+  }
+  stopBlock(event) {
+    const block = this.streamed.get(blockIndexOf(event));
+    if (block === void 0) malformed("stop for a block that never started");
+    return block.kind === "text" || block.kind === "reasoning" ? this.closeDisplay(block) : [];
+  }
+  closeDisplay(block) {
+    if (block.index === void 0 || block.closed) return [];
+    block.closed = true;
+    const content = displayContent(block.kind, block.text);
+    this.settled.set(block.index, content);
+    return [{ type: "block-end", index: block.index, block: content }];
+  }
+  settleDisplay(blocks) {
+    const finals = blocks.flatMap(displayOf);
+    const streamed = [...this.streamed.values()].filter(isDisplayBlock);
+    const lost = streamed.slice(finals.length).find((block) => block.text !== "");
+    if (lost !== void 0) malformed(`the final message lost streamed ${lost.kind}`);
+    return finals.flatMap((final, position) => {
+      const block = streamed[position] ?? newDisplayBlock(final.kind);
+      if (block.kind !== final.kind) malformed("final block kinds differ from the stream");
+      return this.settleOneDisplay(block, final.text);
+    });
+  }
+  settleOneDisplay(block, final) {
+    const matches = block.closed ? block.text === final : final.startsWith(block.text);
+    if (!matches && block.kind === "text") {
+      malformed("the final text differs from the incremental stream");
+    }
+    if (block.closed) return [];
+    const chunks = matches ? this.appendDisplay(block, final.slice(block.text.length)) : [];
+    if (!matches) block.text = final;
+    return [...chunks, ...this.closeDisplay(block)];
+  }
+  settleToolCalls(blocks) {
+    const calls = blocks.filter(isToolUse);
+    const finalIds = new Set(calls.map((call) => stringField(call, "id")));
+    const streamed = [...this.streamed.values()].filter(isToolCallStream);
+    const lost = streamed.find((call) => !finalIds.has(call.id));
+    if (lost !== void 0) malformed(`the tool call to ${lost.name} has no complete arguments`);
+    return calls.flatMap((call) => {
+      const id = stringField(call, "id");
+      const name2 = dshToolName(stringField(call, "name"), this.names);
+      const args = JSON.stringify(inputObjectOf(call));
+      const open = streamed.find((candidate) => candidate.id === id);
+      const index = open?.index ?? this.takeIndex();
+      const content = {
+        type: "tool-call",
+        id: toolCallId(id),
+        name: name2,
+        arguments: args
+      };
+      this.settled.set(index, content);
+      const opening = open !== void 0 ? [] : [
+        { type: "block-start", index, blockType: "tool-call" },
+        { type: "tool-call-delta", index, id: toolCallId(id), name: name2, argumentsDelta: args }
+      ];
+      return [...opening, { type: "block-end", index, block: content }];
+    });
+  }
+  replayState(completion) {
+    const messages = completion.assistants.map(
+      (message) => withOfferedToolNames(message, this.names)
+    );
+    if (!isReplayable(messages)) return void 0;
+    const carrier = {
+      kind: "claude-subscription",
+      version: 1,
+      messages,
+      projection: this.projectionOf(this.settledInOrder())
+    };
+    return isLosslessJson(carrier) ? { response: carrier } : void 0;
+  }
+  settledInOrder() {
+    return [...this.settled.entries()].sort(([a], [b]) => a - b).map(([, block]) => block);
+  }
+  takeIndex() {
+    const index = this.nextIndex;
+    this.nextIndex += 1;
+    return index;
+  }
+};
+function failureChunk(failure, signal) {
+  const aborted = failure.code === FailureCode.aborted || signal?.aborted === true;
+  return {
+    type: "finish",
+    reason: { kind: aborted ? "aborted" : "error", failure: failure.failure }
+  };
+}
+var EMPTY_RESPONSE = {
+  code: FailureCode.emptyResponse,
+  message: "The model finished with no text and no tool call."
+};
+function finishChunk(reason, replayState) {
+  return { type: "finish", reason, ...replayState === void 0 ? {} : { replayState } };
+}
+function newDisplayBlock(kind) {
+  return { kind, index: void 0, text: "", closed: false };
+}
+function displayContent(kind, text) {
+  return { type: kind, text };
+}
+function displayOf(block) {
+  if (block.type === "text") return [{ kind: "text", text: stringOrEmpty(block.text) }];
+  if (block.type === "thinking") return [{ kind: "reasoning", text: stringOrEmpty(block.thinking) }];
+  return [];
+}
+function isReplayable(messages) {
+  const blocks = messages.flatMap((message) => message.content);
+  const hasAnswer = blocks.some(
+    (block) => isToolUse(block) || block.type === "text" && stringOrEmpty(block.text) !== ""
+  );
+  const unsigned = blocks.some(
+    (block) => block.type === "thinking" && stringOrEmpty(block.signature) === ""
+  );
+  return hasAnswer && !unsigned;
+}
+function stringOrEmpty(value) {
+  return typeof value === "string" ? value : "";
+}
+function hasVisibleText(blocks) {
+  return blocks.some((block) => block.type === "text" && stringOrEmpty(block.text) !== "");
+}
+function inputObjectOf(call) {
+  const { input } = call;
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    malformed(`the tool call to ${String(call.name)} has no input object`);
+  }
+  return input;
+}
+function isToolUse(block) {
+  return block.type === "tool_use";
+}
+function isDisplayBlock(block) {
+  return block.kind === "text" || block.kind === "reasoning";
+}
+function isToolCallStream(block) {
+  return block.kind === "tool-call";
+}
+function toolCallId(id) {
+  return id;
+}
+function blockIndexOf(event) {
+  const index = event.index;
+  if (typeof index !== "number" || !Number.isInteger(index)) malformed("event with no block index");
+  return index;
+}
+function objectField(source, field2) {
+  const value = source[field2];
+  if (typeof value !== "object" || value === null) malformed(`event with no ${field2}`);
+  return value;
+}
+function stringField(source, field2) {
+  const value = source[field2];
+  if (typeof value !== "string") malformed(`block with no ${field2}`);
+  return value;
+}
+function malformed(detail) {
+  throw new NativeFailure(`Malformed Claude Code stream: ${detail}`, FailureCode.nativeProtocol);
+}
+
+// src/adapter.ts
+var ClaudeSubscriptionAdapter = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  discovery;
+  providerInfo(provider) {
+    return { id: provider, name: "Claude Subscription" };
+  }
+  providerRetryPolicy(_provider) {
+    return void 0;
+  }
+  imageRequestPricing(_provider, _model) {
+    return void 0;
+  }
+  imageRequestTarget(_provider, _model, image) {
+    return this.deps.imageTarget(image);
+  }
+  async listModels(provider) {
+    const models = await this.discovered();
+    return models.map((model) => this.modelRow(provider, model));
+  }
+  resolveModel(provider, model, _signal) {
+    return Promise.resolve(this.deps.modelInfo(provider, model));
+  }
+  async prepareCall(provider, model, signal) {
+    return {
+      model: await this.resolveModel(provider, model, signal),
+      stream: (options) => this.stream(options)
+    };
+  }
+  async *stream(options) {
+    try {
+      const prepared = await this.deps.prepare(options);
+      yield* this.runPrepared(prepared, options.signal);
+    } catch (error) {
+      if (!(error instanceof NativeFailure)) throw error;
+      yield failureChunk(error, options.signal);
+    }
+  }
+  async *runPrepared(prepared, signal) {
+    const translator = new ChunkTranslator({
+      toolNames: prepared.toolNames,
+      projectionOf: this.deps.projectionOf
+    });
+    const events = this.deps.run(prepared, signal, this.deps.native);
+    let completion;
+    try {
+      while (completion === void 0) {
+        const next = await events.next();
+        if (next.done) completion = next.value;
+        else yield* translator.event(next.value);
+      }
+    } finally {
+      if (completion === void 0) await events.return(void 0);
+    }
+    this.warnIfUnrestored(completion);
+    yield* translator.complete(completion);
+  }
+  warnIfUnrestored(completion) {
+    if (completion.unrestored === null) return;
+    this.deps.warn(`The queried turn stayed as Claude Code built it: ${completion.unrestored}`);
+  }
+  modelRow(provider, model) {
+    const { inputModalities } = this.deps.modelInfo(provider, model.id);
+    return {
+      provider,
+      id: model.id,
+      name: model.name,
+      ...model.description === void 0 ? {} : { description: model.description },
+      ...inputModalities === void 0 ? {} : { inputModalities }
+    };
+  }
+  discovered() {
+    const key = JSON.stringify(this.deps.native.settings());
+    if (this.discovery?.key === key) return this.discovery.models;
+    const models = Promise.resolve().then(() => this.discover(key));
+    this.discovery = { key, models };
+    return models;
+  }
+  async discover(key) {
+    try {
+      const models = await this.deps.discover(this.deps.native);
+      if (this.discovery?.key === key) this.deps.reportDiscovery(void 0);
+      return models;
+    } catch (error) {
+      if (this.discovery?.key === key) {
+        this.discovery = void 0;
+        this.deps.reportDiscovery(error instanceof Error ? error.message : String(error));
+      }
+      throw error;
+    }
+  }
+};
+
+// src/config.ts
+import z from "@deepseek-ai/schemastery";
+var MAX_TIMER_SECONDS = 2147483;
+var Config = z.object({
+  command: z.string().pattern(/\S/).default("claude").description("Name or absolute path of the Claude Code executable.").volatile(),
+  claudeConfigDir: z.string().default("").description("Claude Code config directory. Empty means the CLI's own default lookup.").volatile(),
+  claudeCodeTelemetry: z.boolean().default(true).description("Let Claude Code send telemetry and fetch feature flags. Flags unlock models.").volatile(),
+  readIdleTimeoutSeconds: z.number().min(1).max(MAX_TIMER_SECONDS).default(1800).description("Seconds of silence from Claude Code before a call fails.").volatile()
+});
+function readSettings(config) {
+  return {
+    command: config.command.get(),
+    claudeConfigDir: config.claudeConfigDir.get(),
+    claudeCodeTelemetry: config.claudeCodeTelemetry.get(),
+    readIdleTimeoutSeconds: config.readIdleTimeoutSeconds.get()
+  };
+}
+
+// src/native/argv.ts
+function inertMcpConfig(deps, files) {
+  return JSON.stringify({
+    mcpServers: {
+      [MCP_SERVER_NAME]: { command: deps.nodePath, args: [deps.inertMcpPath, files.tools] }
+    }
+  });
+}
+function turnArgv(executable, request, files, deps) {
+  return [
+    executable,
+    "-p",
+    "--model",
+    request.nativeModel,
+    "--input-format",
+    "stream-json",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--include-partial-messages",
+    "--tools",
+    "",
+    "--system-prompt-file",
+    files.system,
+    "--settings",
+    files.settings,
+    "--setting-sources",
+    "",
+    "--strict-mcp-config",
+    "--disable-slash-commands",
+    "--max-turns",
+    "1",
+    "--permission-mode",
+    "dontAsk",
+    "--no-session-persistence",
+    "--mcp-config",
+    inertMcpConfig(deps, files),
+    // The CLI adds a per-turn effort message at its own level unless told, and that message
+    // overrides `output_config.effort` from the extra body.
+    ...request.effort === void 0 ? [] : ["--effort", request.effort],
+    // One CLI session per conversation: the session id names a scratchpad directory near the top
+    // of every request, so a new id per spawn would move the cache prefix.
+    "--session-id",
+    request.sessionId
+  ];
+}
+
+// src/native/failures.ts
+var INSTALL_HINT = "Claude Code is not installed. Install it with `npm install -g @anthropic-ai/claude-code`, or set the `command` plugin setting to the binary.";
+var LOGIN_HINT = "Claude Code is installed but not logged in. Run `claude auth login`, then select this provider again.";
+var LOGGED_OUT_HINT = "Claude Code is installed but has no usable login where DSH runs it. Run `claude auth login` as the user DSH runs as, or point the `claudeConfigDir` plugin setting at a logged-in config directory, then try again.";
+var STDERR_LINES = 40;
+var STDERR_CHARS = 400;
+var UPSTREAM_TEXT_CHARS = 500;
+var NATIVE_ANSWERS = {
+  rate_limit: { code: FailureCode.rateLimit, status: 429 },
+  billing_error: { code: FailureCode.quota, status: 402 },
+  authentication_failed: { code: FailureCode.invalidCredential, status: 401 },
+  overloaded: { code: FailureCode.server, status: 529 },
+  // The CLI uses this code for capacity, 5xx and login-refresh races. All of them are transient.
+  server_error: { code: FailureCode.server, status: 503 }
+};
+var STREAM_ERRORS = /* @__PURE__ */ new Map([
+  ["overloaded_error", { code: FailureCode.server, status: 529 }],
+  ["rate_limit_error", { code: FailureCode.rateLimit, status: 429 }],
+  ["api_error", { code: FailureCode.server, status: 500 }],
+  ["authentication_error", { code: FailureCode.invalidCredential, status: 401 }]
+]);
+var CONTEXT_WINDOW_MESSAGES = [
+  /prompt is too long/i,
+  /\bexceed(?:s|ed)?\s+(?:the\s+)?(?:model(?:'s)?\s+)?context\s+(?:limit|length|window)\b/i,
+  /\bcontext[\s_-](?:length|window)[\s_-](?:exceed(?:ed|s)?|overflow(?:ed)?|limit[\s_-]exceeded)\b/i,
+  /\b(?:maximum|max)(?:\s+(?:allowed|supported))?\s+context\s+(?:length|window)\b/i,
+  /\btoo\s+(?:large|long)\s+for\s+(?:(?:this|the)\s+)?(?:model(?:'s)?\s+)?context\b/i
+];
+function isContextWindowMessage(text) {
+  return CONTEXT_WINDOW_MESSAGES.some((pattern) => pattern.test(text));
+}
+function withoutRelayRoute(text, relayUrl) {
+  return text.replaceAll(relayUrl, "<relay>");
+}
+function abortedFailure(cause) {
+  return new NativeFailure(
+    "Claude request cancelled",
+    FailureCode.aborted,
+    cause === void 0 ? {} : { cause }
+  );
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted === true) throw abortedFailure();
+}
+function timeoutFailure() {
+  return new NativeFailure("Claude request timed out", FailureCode.timeout);
+}
+function stderrSuffix(stderr) {
+  const lines = stderr.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  const text = lines.slice(-STDERR_LINES).join(" ").slice(0, STDERR_CHARS);
+  return text === "" ? "" : ` (native stderr: ${text})`;
+}
+function nativeAnswerFailure(code, text, stderrTail) {
+  const message = `Native API error: ${text}${stderrTail}`;
+  if (isContextWindowMessage(text)) {
+    return new NativeFailure(message, FailureCode.contextWindowExceeded);
+  }
+  const shape = code === void 0 ? void 0 : NATIVE_ANSWERS[code];
+  if (shape === void 0) return new NativeFailure(message, FailureCode.nativeProtocol);
+  const facts = shape.status === void 0 ? {} : { status: shape.status };
+  return new NativeFailure(message, shape.code, facts);
+}
+function loggedOutFailure(detail, stderrTail) {
+  const suffix = detail === "" ? "" : ` (native: ${detail})`;
+  return new NativeFailure(
+    `${LOGGED_OUT_HINT}${suffix}${stderrTail}`,
+    FailureCode.invalidCredential,
+    {
+      status: 401
+    }
+  );
+}
+function codeForStatus(status, upstreamText) {
+  if (isContextWindowMessage(upstreamText)) return FailureCode.contextWindowExceeded;
+  if (status === 429) return FailureCode.rateLimit;
+  if (status === 401 || status === 403) return FailureCode.invalidCredential;
+  if (status === 402) return FailureCode.quota;
+  if (status >= 500) return FailureCode.server;
+  return FailureCode.upstreamError;
+}
+function firstAttemptSummary(relay, upstreamText) {
+  const capture = relay.capture.complete ? "complete" : "incomplete";
+  const parts = [`status ${relay.status ?? "none"}`, `capture ${capture}`];
+  if (relay.failure !== null) parts.push(`relay failure ${relay.failure}`);
+  parts.push(`native retries denied: ${relay.denied}`);
+  if (upstreamText !== "") parts.push(`upstream said: ${upstreamText}`);
+  return `first upstream attempt: ${parts.join(", ")}`;
+}
+function streamErrorShape(type, text) {
+  if (type === "invalid_request_error") {
+    const code = isContextWindowMessage(text) ? FailureCode.contextWindowExceeded : FailureCode.upstreamError;
+    return { code, status: 400 };
+  }
+  return STREAM_ERRORS.get(type) ?? { code: FailureCode.transport };
+}
+function upstreamFailure(relay, nativeError) {
+  const requestId = relay.requestId === null ? {} : { requestId: relay.requestId };
+  const retryAfter = relay.retryAfterMs === null ? {} : { providerRetryAfterMs: relay.retryAfterMs };
+  const streamError = relay.capture.error;
+  if (streamError !== null) {
+    const text = streamError.message.slice(0, UPSTREAM_TEXT_CHARS);
+    const { code, status } = streamErrorShape(streamError.type, text);
+    return new NativeFailure(text, code, {
+      ...status === void 0 ? {} : { status },
+      ...requestId,
+      ...retryAfter
+    });
+  }
+  const upstreamText = relay.errorText().slice(0, UPSTREAM_TEXT_CHARS);
+  const suffix = nativeError === null || nativeError === "" ? "" : `: ${nativeError}`;
+  const message = `Incomplete upstream response (${firstAttemptSummary(relay, upstreamText)})${suffix}`;
+  if (relay.status === null || relay.status === 200) {
+    return new NativeFailure(message, FailureCode.transport, { ...requestId, ...retryAfter });
+  }
+  return new NativeFailure(message, codeForStatus(relay.status, upstreamText), {
+    status: relay.status,
+    ...requestId,
+    ...retryAfter
+  });
+}
+
+// src/native/channel.ts
+var SHOWN_LINE_CHARS = 300;
+function parseLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return { kind: "event", event: parsed };
+    }
+  } catch {
+    return { kind: "malformed", line };
+  }
+  return { kind: "malformed", line };
+}
+function endOf(stream) {
+  if (stream === void 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    stream.once("end", resolve);
+    stream.once("close", resolve);
+  });
+}
+var NativeChannel = class {
+  #handle;
+  #idleMs;
+  #signal;
+  #redact;
+  #items = [];
+  #waiter = null;
+  #partialLine = "";
+  #discarding = false;
+  #outcome = null;
+  constructor(handle, options) {
+    this.#handle = handle;
+    this.#idleMs = options.idleMs;
+    this.#signal = options.signal;
+    this.#redact = options.redact;
+    handle.stdin?.on("error", () => {
+    });
+    handle.stdout?.setEncoding("utf8");
+    handle.stdout?.on("data", (chunk) => this.#onOutput(chunk));
+    handle.stdout?.on("error", () => {
+    });
+    this.#watchEnd();
+  }
+  /** The exit code, known once `receive` has returned null. */
+  get exitCode() {
+    return this.#outcome?.exitCode ?? null;
+  }
+  /** Suffix for a failure message, from the CLI's stderr. */
+  stderrTail() {
+    return stderrSuffix(this.#redact(this.#handle.collected.stderr?.readFrom(0).text ?? ""));
+  }
+  /** The next stream-json object, or null when the process and its stdout have ended. */
+  async receive() {
+    if (this.#signal?.aborted === true) throw abortedFailure();
+    const item = await this.#bounded(this.#nextItem());
+    switch (item.kind) {
+      case "event":
+        return item.event;
+      case "ended":
+        return null;
+      case "malformed":
+        throw new NativeFailure(
+          `Invalid native stream-json output: ${JSON.stringify(this.#redact(item.line).slice(0, SHOWN_LINE_CHARS))}${this.stderrTail()}`,
+          FailureCode.nativeProtocol
+        );
+      case "failed":
+        throw new NativeFailure(
+          `Native process failed: ${item.error instanceof Error ? item.error.message : String(item.error)}${this.stderrTail()}`,
+          FailureCode.nativeProtocol,
+          { cause: item.error }
+        );
+    }
+  }
+  /**
+   * Writes one line to stdin and waits until the pipe took it. A child that is gone leaves
+   * nothing to write to: what it printed, read by `receive`, is the better diagnosis.
+   */
+  async write(line) {
+    const { stdin } = this.#handle;
+    if (stdin === void 0 || stdin.destroyed) return;
+    await this.#bounded(new Promise((resolve) => stdin.write(line, () => resolve())));
+  }
+  async endInput() {
+    const { stdin } = this.#handle;
+    if (stdin === void 0 || stdin.destroyed) return;
+    await this.#bounded(new Promise((resolve) => stdin.end(() => resolve())));
+  }
+  /** Keeps stdout flowing with nobody reading, so a draining child never blocks on it. */
+  discardOutput() {
+    this.#discarding = true;
+    this.#items.length = 0;
+    this.#waiter = null;
+  }
+  /** Releases the pipes. Call once the process has gone. */
+  close() {
+    this.#handle.stdin?.destroy();
+    this.#handle.stdout?.destroy();
+  }
+  #watchEnd() {
+    Promise.all([endOf(this.#handle.stdout), this.#handle.done]).then(
+      ([, outcome]) => {
+        this.#outcome = outcome;
+        this.#flushPartialLine();
+        this.#push({ kind: "ended" });
+      },
+      (error) => this.#push({ kind: "failed", error })
+    );
+  }
+  #onOutput(chunk) {
+    if (this.#discarding) return;
+    const lines = `${this.#partialLine}${chunk}`.split("\n");
+    this.#partialLine = lines.pop() ?? "";
+    for (const line of lines) this.#pushLine(line);
+  }
+  #flushPartialLine() {
+    this.#pushLine(this.#partialLine);
+    this.#partialLine = "";
+  }
+  #pushLine(line) {
+    if (line.trim() !== "") this.#push(parseLine(line));
+  }
+  #push(item) {
+    if (this.#discarding) return;
+    if (this.#waiter === null) {
+      this.#items.push(item);
+      return;
+    }
+    const waiter = this.#waiter;
+    this.#waiter = null;
+    waiter(item);
+  }
+  #nextItem() {
+    const queued = this.#items.shift();
+    if (queued !== void 0) return Promise.resolve(queued);
+    return new Promise((resolve) => {
+      this.#waiter = resolve;
+    });
+  }
+  #bounded(work) {
+    const signal = this.#signal;
+    return new Promise((resolve, reject) => {
+      const onAbort = () => finish(() => reject(abortedFailure()));
+      const timer = setTimeout(() => finish(() => reject(timeoutFailure())), this.#idleMs);
+      const finish = (settle) => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        settle();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      work.then(
+        (value) => finish(() => resolve(value)),
+        (error) => finish(() => reject(error))
+      );
+    });
+  }
+};
+
+// src/native/drain.ts
+import { setTimeout as sleep } from "node:timers/promises";
+var DRAIN_GRACE_MS = 1e4;
+var TERMINATE_WAIT_MS = 5e3;
+async function settledWithin(work, limitMs) {
+  const limit = new AbortController();
+  const settled = work.then(
+    () => void 0,
+    () => void 0
+  );
+  const timer = sleep(limitMs, void 0, { signal: limit.signal, ref: false }).catch(
+    () => void 0
+  );
+  await Promise.race([settled, timer]);
+  limit.abort();
+}
+async function drainAfterAnswer(handle, relay, graceMs = DRAIN_GRACE_MS) {
+  await settledWithin(handle.done, graceMs);
+  handle.terminate();
+  await settledWithin(handle.done, TERMINATE_WAIT_MS);
+  await relay.close();
+}
+
+// src/native/env.ts
+import { homedir, userInfo } from "node:os";
+import { join } from "node:path";
+var BACKEND_URL = "ANTHROPIC_BASE_URL";
+var LOOPBACK = "127.0.0.1";
+var BACKEND_SWITCHES = [
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "CLAUDE_CODE_USE_FOUNDRY"
+];
+var SWITCHED_OFF = /* @__PURE__ */ new Set(["", "0", "false", "no", "off"]);
+var FOREIGN_CREDENTIALS = [
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_FOUNDRY_API_KEY"
+];
+var INHERITED_REQUEST_SETTINGS = ["CLAUDE_CODE_EXTRA_BODY", "CLAUDE_CODE_EFFORT_LEVEL"];
+var QUIET_TRAFFIC = {
+  CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+  DISABLE_TELEMETRY: "1",
+  DISABLE_ERROR_REPORTING: "1"
+};
+var ALWAYS_QUIET = {
+  DISABLE_AUTOUPDATER: "1",
+  DISABLE_FEEDBACK_COMMAND: "1",
+  // This also stops the CLI's own session-title request, which would race the turn for the one
+  // upstream request that the relay admits (upstream #116).
+  CLAUDE_CODE_DISABLE_TERMINAL_TITLE: "1"
+};
+var CALLER_IDENTITY = {
+  CLAUDE_CODE_ENTRYPOINT: "deepseek-harness",
+  CLAUDE_CODE_DISABLE_ARTIFACT: "1"
+};
+var TURN_POLICY = {
+  ENABLE_TOOL_SEARCH: "false",
+  CLAUDE_CODE_MAX_RETRIES: "0",
+  DISABLE_AUTO_COMPACT: "1",
+  DISABLE_COMPACT: "1",
+  // DSH owns the budgets, and the CLI's replayed reminder would break the cached history.
+  CLAUDE_CODE_TOTAL_TOKENS_REMINDER: "off",
+  // The CLI adds this note to the history after quiet tool turns. A DSH turn did not ask for it, and
+  // its time-based form could move the cached prefix.
+  CLAUDE_CODE_SILENT_TURN_REMINDER: "0",
+  // DSH owns memory and instructions. `--setting-sources ""` does not stop these two, and the CLI
+  // would put them inside the user's turn (upstream #195).
+  CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
+  CLAUDE_CODE_DISABLE_CLAUDE_MDS: "1"
+};
+function isSwitchedOn(value) {
+  return value !== void 0 && !SWITCHED_OFF.has(value.trim().toLowerCase());
+}
+function backendOverrides(processEnv) {
+  const conflicts = processEnv[BACKEND_URL] ? [BACKEND_URL] : [];
+  return [...conflicts, ...BACKEND_SWITCHES.filter((name2) => isSwitchedOn(processEnv[name2]))];
+}
+function assertNoBackendOverride(processEnv) {
+  const conflicts = backendOverrides(processEnv);
+  if (conflicts.length === 0) return;
+  throw new NativeFailure(
+    `The Claude subscription provider refuses these inherited backend overrides: ${conflicts.join(", ")}. Unset them where DSH runs.`,
+    FailureCode.conflictingEnvironment
+  );
+}
+function expandHome(path, processEnv) {
+  if (path !== "~" && !path.startsWith("~/")) return path;
+  return join(processEnv.HOME || homedir(), path.slice(1));
+}
+function configDirEntry(settings, processEnv) {
+  const chosen = settings.claudeConfigDir.trim() || processEnv.CLAUDE_CONFIG_DIR;
+  return chosen ? { CLAUDE_CONFIG_DIR: expandHome(chosen, processEnv) } : {};
+}
+function osUsername() {
+  try {
+    return userInfo().username;
+  } catch {
+    return void 0;
+  }
+}
+function loginIdentity(processEnv) {
+  const user = processEnv.USER || processEnv.LOGNAME || osUsername();
+  if (user === void 0) return {};
+  return { USER: processEnv.USER || user, LOGNAME: processEnv.LOGNAME || user };
+}
+function loopbackProxyBypass(processEnv) {
+  const inherited = processEnv.no_proxy || processEnv.NO_PROXY;
+  const exceptions = inherited ? `${inherited},${LOOPBACK}` : LOOPBACK;
+  return { NO_PROXY: exceptions, no_proxy: exceptions };
+}
+function removed(names) {
+  return Object.fromEntries(names.map((name2) => [name2, void 0]));
+}
+function probeEnv(settings, processEnv) {
+  return {
+    ...removed([...FOREIGN_CREDENTIALS, BACKEND_URL]),
+    ...loginIdentity(processEnv),
+    ...configDirEntry(settings, processEnv),
+    ...loopbackProxyBypass(processEnv),
+    ...ALWAYS_QUIET,
+    ...CALLER_IDENTITY,
+    ...settings.claudeCodeTelemetry ? {} : QUIET_TRAFFIC
+  };
+}
+function nativeEnv(settings, processEnv) {
+  return {
+    ...probeEnv(settings, processEnv),
+    ...removed(INHERITED_REQUEST_SETTINGS),
+    ...TURN_POLICY
+  };
+}
+
+// src/native/executable.ts
+var NOT_FOUND_ERROR = "SubprocessExecutableNotFoundError";
+async function resolveClaude(deps, signal) {
+  const { command } = deps.settings();
+  try {
+    return await deps.subprocess.resolveExecutable(command, void 0, signal);
+  } catch (error) {
+    if (signal?.aborted === true) throw abortedFailure(error);
+    if (error instanceof Error && error.name === NOT_FOUND_ERROR) {
+      throw new NativeFailure(INSTALL_HINT, FailureCode.claudeCodeMissing, {
+        status: 503,
+        cause: error
+      });
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new NativeFailure(
+      `The \`command\` plugin setting cannot be used: ${detail}`,
+      FailureCode.nativeProtocol,
+      { cause: error }
+    );
+  }
+}
+
+// src/native/request-files.ts
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+async function writeRequestFiles(request) {
+  const directory = await mkdtemp(join2(tmpdir(), "claude-subscription-"));
+  const files = {
+    directory,
+    system: join2(directory, "system.md"),
+    settings: join2(directory, "settings.json"),
+    tools: join2(directory, "tools.json")
+  };
+  const settings = { env: { CLAUDE_CODE_EXTRA_BODY: JSON.stringify(request.extraBody) } };
+  const writes = await Promise.allSettled([
+    writeFile(files.system, request.system),
+    writeFile(files.settings, JSON.stringify(settings)),
+    writeFile(files.tools, JSON.stringify(request.manifest))
+  ]);
+  const failed = writes.find((write) => write.status === "rejected");
+  if (failed !== void 0) {
+    await removeRequestFiles(files).catch(() => {
+    });
+    throw failed.reason;
+  }
+  return files;
+}
+async function removeRequestFiles(files) {
+  await rm(files.directory, { recursive: true, force: true });
+}
+
+// src/native/turn.ts
+function newTurnState() {
+  return { assistants: [], results: [], stopped: false, streamedText: "", nativeError: null };
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function protocolFailure(what, stderrTail) {
+  return new NativeFailure(`${what}${stderrTail}`, FailureCode.nativeProtocol);
+}
+function blocksOf(message) {
+  return Array.isArray(message.content) ? message.content : [];
+}
+function textOf(blocks) {
+  return blocks.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("");
+}
+function recordAssistant(state, event, stderrTail) {
+  const { message } = event;
+  if (!isObject(message) || !Array.isArray(message.content)) {
+    throw protocolFailure("Native assistant event holds no message", stderrTail());
+  }
+  if (event.error || message.error) {
+    const code = typeof event.error === "string" ? event.error : void 0;
+    state.nativeError = {
+      code,
+      text: blocksOf(message).filter((block) => block.type === "text").map((block) => String(block.text ?? "")).join("\n")
+    };
+    return;
+  }
+  state.assistants.push(message);
+}
+function recordStreamEvent(state, event, stderrTail) {
+  const inner = event.event;
+  if (!isObject(inner) || typeof inner.type !== "string") {
+    throw protocolFailure("Native stream_event holds no event", stderrTail());
+  }
+  if (inner.type === "message_stop") state.stopped = true;
+  const { delta } = inner;
+  if (isObject(delta) && delta.type === "text_delta" && typeof delta.text === "string") {
+    state.streamedText += delta.text;
+  }
+  return inner;
+}
+function recordEvent(state, event, stderrTail) {
+  switch (event.type) {
+    case "assistant":
+      recordAssistant(state, event, stderrTail);
+      return null;
+    case "result":
+      state.results.push(event);
+      return null;
+    case "stream_event":
+      return recordStreamEvent(state, event, stderrTail);
+    default:
+      return null;
+  }
+}
+function endedWithToolCall(result, blocks) {
+  return result.subtype === "error_max_turns" && blocks.some((block) => block.type === "tool_use");
+}
+function fastEligible(result, relay, state) {
+  const message = relay.capture.message;
+  if (message === null) return false;
+  const admittedCleanly = relay.used && relay.status === 200 && relay.capture.complete && relay.denied === 0;
+  if (!admittedCleanly || !state.stopped || state.nativeError !== null) return false;
+  if (message.stop_reason === "refusal") return false;
+  const succeeded = result.subtype === "success" && !result.is_error;
+  return succeeded || endedWithToolCall(result, message.content);
+}
+function isUsage(value) {
+  return isObject(value) && typeof value.input_tokens === "number" && typeof value.output_tokens === "number";
+}
+function assertTextMatches(streamed, blocks, tail) {
+  if (!textOf(blocks).startsWith(streamed)) {
+    throw protocolFailure("Native final text differs from the incremental stream", tail);
+  }
+}
+function asCaptured(message, usage) {
+  return {
+    ...message,
+    role: "assistant",
+    content: blocksOf(message),
+    usage: isUsage(message.usage) ? message.usage : usage
+  };
+}
+function finalAnswer(state, relay, nativeError) {
+  if (!relay.used) {
+    return {
+      messages: state.assistants,
+      stopped: state.stopped,
+      usageOf: (result) => result.usage
+    };
+  }
+  const message = relay.capture.message;
+  if (relay.status !== 200 || !relay.capture.complete || message === null) {
+    throw upstreamFailure(relay, nativeError);
+  }
+  return { messages: [message], stopped: true, usageOf: () => message.usage };
+}
+function failureOfNativeError(error, relay, stderrTail) {
+  if (error.code === "authentication_failed" && !relay.used) {
+    return loggedOutFailure(error.text, stderrTail);
+  }
+  return nativeAnswerFailure(error.code, error.text, stderrTail);
+}
+function assertProcessSucceeded(result, blocks, ending, stderrTail) {
+  const exitCode = ending.fast ? 0 : ending.exitCode;
+  const atTurnLimit = endedWithToolCall(result, blocks) && (ending.fast || ending.exitCode === 1);
+  if (atTurnLimit) return;
+  if (exitCode !== 0 || result.is_error || result.subtype !== "success") {
+    throw protocolFailure(`Native request failed: ${String(result.subtype)}`, stderrTail);
+  }
+}
+function finishTurn(state, relay, ending, stderrTail) {
+  const nativeError = state.nativeError === null ? null : { ...state.nativeError, text: withoutRelayRoute(state.nativeError.text, relay.url) };
+  const answer = finalAnswer(state, relay, nativeError?.text ?? null);
+  const refused2 = relay.used && answer.messages[0]?.stop_reason === "refusal";
+  const relayAnswerStands = relay.denied > 0 || refused2;
+  if (nativeError !== null && !relayAnswerStands) {
+    throw failureOfNativeError(nativeError, relay, stderrTail);
+  }
+  const [result] = state.results;
+  if (state.results.length !== 1 || result === void 0 || answer.messages.length === 0 || !answer.stopped) {
+    throw protocolFailure(
+      "Incomplete native response: assistant, message_stop and one result required",
+      stderrTail
+    );
+  }
+  const blocks = answer.messages.flatMap(blocksOf);
+  if (!relayAnswerStands) assertProcessSucceeded(result, blocks, ending, stderrTail);
+  const usage = answer.usageOf(result);
+  if (!isUsage(usage))
+    throw protocolFailure("Native result missing complete token usage", stderrTail);
+  assertTextMatches(state.streamedText, blocks, stderrTail);
+  return {
+    assistants: answer.messages.map((message) => asCaptured(message, usage)),
+    usage,
+    requestId: relay.requestId,
+    blockedRequests: relay.denied,
+    unrestored: relay.unrestored
+  };
+}
+
+// src/native/workdir.ts
+import {
+  closeSync,
+  constants,
+  fchmodSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  statSync,
+  utimesSync
+} from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join3 } from "node:path";
+var OPEN_TO_OTHERS = 63;
+var WRITABLE_BY_OTHERS = 18;
+var STICKY_BIT = 512;
+function refused(path, why, cause) {
+  return new NativeFailure(
+    `The working directory ${path} was refused: ${why}.`,
+    FailureCode.nativeProtocol,
+    cause === void 0 ? {} : { cause }
+  );
+}
+function assertSafeParent(parent, path) {
+  const { mode } = statSync(parent);
+  if ((mode & WRITABLE_BY_OTHERS) !== 0 && (mode & STICKY_BIT) === 0) {
+    throw refused(path, "others can rename it out of its parent directory");
+  }
+}
+function isExisting(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+function tighten(path) {
+  const descriptor = openSync(
+    path,
+    constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW
+  );
+  try {
+    fchmodSync(descriptor, 448);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+function createPrivate(path) {
+  try {
+    mkdirSync(path, { mode: 448 });
+  } catch (error) {
+    if (isExisting(error)) return;
+    throw error;
+  }
+  tighten(path);
+}
+function assertPrivate(path, uid) {
+  const info = lstatSync(path);
+  if (!info.isDirectory()) throw refused(path, "it is not a real directory");
+  if (info.uid !== uid) throw refused(path, "another user owns it");
+  if ((info.mode & OPEN_TO_OTHERS) !== 0) throw refused(path, "it is open to other users");
+}
+function sharedWorkdir() {
+  const uid = process.getuid?.();
+  const parent = tmpdir2();
+  const path = join3(parent, `claude-subscription-cwd-${uid}`);
+  if (uid === void 0) throw refused(path, "this platform has no user id");
+  try {
+    assertSafeParent(parent, path);
+    createPrivate(path);
+    assertPrivate(path, uid);
+    const now = /* @__PURE__ */ new Date();
+    utimesSync(path, now, now);
+  } catch (error) {
+    if (error instanceof NativeFailure) throw error;
+    throw refused(path, error instanceof Error ? error.message : String(error), error);
+  }
+  return path;
+}
+
+// src/native/run.ts
+var ANTHROPIC_API = "https://api.anthropic.com";
+var GRACE_MS = 2e3;
+var STDERR_BYTES = 16384;
+var STOP_WAIT_MS = GRACE_MS + 3e3;
+function queriedBlocks(request) {
+  const last = request.frames.at(-1);
+  if (last === void 0) {
+    throw new NativeFailure("The request holds no frame to query", FailureCode.invalidRequest);
+  }
+  return last.message.content;
+}
+async function openRelay(request, context) {
+  try {
+    return await context.deps.createRelay({
+      upstream: ANTHROPIC_API,
+      timeoutMs: context.idleMs,
+      queried: context.queried,
+      oneShot: request.oneShot,
+      env: context.processEnv
+    });
+  } catch (error) {
+    if (error instanceof NativeFailure) throw error;
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new NativeFailure(`The relay could not open: ${detail}`, FailureCode.relayError, {
+      cause: error
+    });
+  }
+}
+var ProcessAbort = class {
+  #controller = new AbortController();
+  #source;
+  #forward = () => this.#controller.abort();
+  constructor(source) {
+    this.#source = source;
+    if (source?.aborted === true) this.#controller.abort();
+    source?.addEventListener("abort", this.#forward, { once: true });
+  }
+  get signal() {
+    return this.#controller.signal;
+  }
+  release() {
+    this.#source?.removeEventListener("abort", this.#forward);
+  }
+};
+function spawnClaude(context, env, signal) {
+  const { request, deps, executable, files, cwd } = context;
+  try {
+    return deps.subprocess.spawn({
+      argv: turnArgv(executable, request, files, deps),
+      cwd,
+      env,
+      graceMs: GRACE_MS,
+      signal,
+      stdio: { stdin: "pipe", stdout: "pipe", stderr: { maxBytes: STDERR_BYTES } }
+    });
+  } catch (error) {
+    if (signal.aborted) throw abortedFailure(error);
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new NativeFailure(`Claude Code could not start: ${detail}`, FailureCode.nativeProtocol, {
+      cause: error
+    });
+  }
+}
+function frameLine(frame, replayed) {
+  return `${JSON.stringify(replayed ? { ...frame, shouldQuery: false } : frame)}
+`;
+}
+async function awaitReplayAcknowledgment(channel, stderrTail) {
+  while (true) {
+    const event = await channel.receive();
+    if (event === null) {
+      throw new NativeFailure(
+        `Native exited before replay acknowledgment (exit=${channel.exitCode})${stderrTail()}`,
+        FailureCode.nativeProtocol
+      );
+    }
+    if (event.type !== "result") continue;
+    if (event.num_turns !== 0 || event.is_error) {
+      throw new NativeFailure(
+        `Native history replay not supported: expected zero-turn acknowledgment${stderrTail()}`,
+        FailureCode.nativeProtocol
+      );
+    }
+    return;
+  }
+}
+async function sendFrames(channel, frames, stderrTail) {
+  for (const [index, frame] of frames.entries()) {
+    const replayed = frame.type === "user" && index < frames.length - 1;
+    await channel.write(frameLine(frame, replayed));
+    if (replayed) await awaitReplayAcknowledgment(channel, stderrTail);
+  }
+  await channel.endInput();
+}
+function startDrain(handle, relay, channel) {
+  channel.discardOutput();
+  void drainAfterAnswer(handle, relay).catch(() => {
+  }).finally(() => channel.close());
+}
+async function stopProcess(handle, relay, channel) {
+  handle.terminate();
+  relay.abort();
+  await settledWithin(handle.done, STOP_WAIT_MS);
+  channel.close();
+  await relay.close().catch(() => {
+  });
+}
+function childEnv(context, relay) {
+  const { settings, processEnv, request } = context;
+  return {
+    ...nativeEnv(settings, processEnv),
+    ANTHROPIC_BASE_URL: relay.url,
+    ...request.maxOutputTokens === void 0 ? {} : { CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(request.maxOutputTokens) }
+  };
+}
+async function* runProcess(context, relay) {
+  const { request, signal } = context;
+  const processAbort = new ProcessAbort(signal);
+  const abortRelay = () => relay.abort();
+  processAbort.signal.addEventListener("abort", abortRelay, { once: true });
+  const stopWatching = () => {
+    processAbort.release();
+    processAbort.signal.removeEventListener("abort", abortRelay);
+  };
+  let handle;
+  try {
+    handle = spawnClaude(context, childEnv(context, relay), processAbort.signal);
+  } catch (error) {
+    stopWatching();
+    await relay.close().catch(() => {
+    });
+    throw error;
+  }
+  const channel = new NativeChannel(handle, {
+    idleMs: context.idleMs,
+    signal,
+    redact: (text) => withoutRelayRoute(text, relay.url)
+  });
+  const stderrTail = () => channel.stderrTail();
+  let handedOff = false;
+  try {
+    await sendFrames(channel, request.frames, stderrTail);
+    const state = newTurnState();
+    let ending = null;
+    while (ending === null) {
+      const event = await channel.receive();
+      if (event === null) {
+        ending = { fast: false, exitCode: channel.exitCode };
+        break;
+      }
+      const streamEvent = recordEvent(state, event, stderrTail);
+      if (streamEvent !== null) yield streamEvent;
+      if (event.type === "result" && fastEligible(event, relay, state)) ending = { fast: true };
+    }
+    if (ending.fast) {
+      stopWatching();
+      handedOff = true;
+      startDrain(handle, relay, channel);
+    } else {
+      throwIfAborted(signal);
+    }
+    return finishTurn(state, relay, ending, stderrTail());
+  } finally {
+    stopWatching();
+    if (!handedOff) await stopProcess(handle, relay, channel);
+  }
+}
+var runNative = async function* (request, signal, deps) {
+  throwIfAborted(signal);
+  const processEnv = deps.processEnv();
+  assertNoBackendOverride(processEnv);
+  const settings = deps.settings();
+  const queried = queriedBlocks(request);
+  const cwd = sharedWorkdir();
+  const executable = await resolveClaude(deps, signal);
+  const files = await writeRequestFiles(request);
+  const idleMs = settings.readIdleTimeoutSeconds * 1e3;
+  const context = {
+    request,
+    signal,
+    deps,
+    settings,
+    processEnv,
+    idleMs,
+    cwd,
+    executable,
+    files,
+    queried
+  };
+  try {
+    const relay = await openRelay(request, context);
+    if (signal?.aborted === true) {
+      await relay.close().catch(() => {
+      });
+      throw abortedFailure();
+    }
+    return yield* runProcess(context, relay);
+  } finally {
+    await removeRequestFiles(files).catch(() => {
+    });
+  }
+};
+
+// src/catalog.ts
+var LONG_CONTEXT_SUFFIX = "[1m]";
+var LONG_CONTEXT_WINDOW = 1e6;
+var DEFAULT_WINDOW = 2e5;
+var CONTEXT_WINDOWS = {
+  "claude-sonnet-5-5": LONG_CONTEXT_WINDOW,
+  "claude-sonnet-5": LONG_CONTEXT_WINDOW,
+  "claude-haiku-5-5": LONG_CONTEXT_WINDOW,
+  "claude-haiku-4-5-20251001": DEFAULT_WINDOW,
+  "claude-opus-5-5": LONG_CONTEXT_WINDOW,
+  "claude-opus-5": LONG_CONTEXT_WINDOW,
+  "claude-opus-4-8": LONG_CONTEXT_WINDOW,
+  "claude-fable-5-1": LONG_CONTEXT_WINDOW,
+  "claude-mythos-5-1": LONG_CONTEXT_WINDOW
+};
+var ACCESS_GATED = /* @__PURE__ */ new Set(["claude-mythos-5-1"]);
+var ALIASES = {
+  sonnet: "claude-sonnet-5-5",
+  haiku: "claude-haiku-5-5",
+  "claude-haiku-4-5": "claude-haiku-4-5-20251001",
+  opus: "claude-opus-5-5",
+  fable: "claude-fable-5-1"
+};
+var MANDATORY_THINKING_PREFIXES = [
+  "claude-fable",
+  "claude-opus-5-5",
+  "claude-sonnet-5-5",
+  "claude-haiku-5-5",
+  "claude-mythos"
+];
+var NO_ADAPTIVE_THINKING = /* @__PURE__ */ new Set(["claude-haiku-4-5-20251001"]);
+function lookup(table, key) {
+  return Object.hasOwn(table, key) ? table[key] : void 0;
+}
+function isCatalogued(name2) {
+  return lookup(ALIASES, name2) !== void 0 || lookup(CONTEXT_WINDOWS, name2) !== void 0;
+}
+function routeBase(name2) {
+  if (isCatalogued(name2)) return name2;
+  const dotted = name2.replaceAll(".", "-");
+  if (dotted !== name2) return routeBase(dotted);
+  const vendored = `claude-${name2.startsWith("claude-") ? name2.slice("claude-".length) : name2}`;
+  return isCatalogued(vendored) ? vendored : name2;
+}
+function resolveRoute(model) {
+  const longContextRequested = model.endsWith(LONG_CONTEXT_SUFFIX);
+  const bare = longContextRequested ? model.slice(0, -LONG_CONTEXT_SUFFIX.length) : model;
+  const base = routeBase(bare);
+  return { canonical: lookup(ALIASES, base) ?? base, longContextRequested };
+}
+function nativeModel(model) {
+  const { canonical, longContextRequested } = resolveRoute(model);
+  const window = lookup(CONTEXT_WINDOWS, canonical);
+  if (window === LONG_CONTEXT_WINDOW) return `${canonical}${LONG_CONTEXT_SUFFIX}`;
+  if (window === void 0) return model;
+  if (longContextRequested) {
+    throw new NativeFailure(
+      "Haiku 4.5 does not support a 1M context window",
+      FailureCode.invalidRequest
+    );
+  }
+  return canonical;
+}
+function contextWindowOf(model) {
+  const { canonical, longContextRequested } = resolveRoute(model);
+  const pinned = lookup(CONTEXT_WINDOWS, canonical);
+  if (longContextRequested) return pinned === LONG_CONTEXT_WINDOW ? pinned : void 0;
+  return pinned ?? DEFAULT_WINDOW;
+}
+function canonicalOf(model) {
+  return resolveRoute(model).canonical;
+}
+function acceptsThinkingDisable(model) {
+  const canonical = canonicalOf(model);
+  return !MANDATORY_THINKING_PREFIXES.some((prefix) => canonical.startsWith(prefix));
+}
+function supportsAdaptiveThinking(model) {
+  return !NO_ADAPTIVE_THINKING.has(canonicalOf(model));
+}
+function pickerRoutes() {
+  return Object.keys(CONTEXT_WINDOWS).filter((canonical) => !ACCESS_GATED.has(canonical)).map(nativeModel);
+}
+var PICKER_ROUTES = pickerRoutes();
+
+// src/native/picker.ts
+var LONG_CONTEXT_SUFFIX2 = "[1m]";
+var USAGE_CREDITS = "usage credits";
+var UNPINNED = "unpinned";
+var SEPARATOR = " \xB7 ";
+var CREDIT_BILLED_MODELS = /* @__PURE__ */ new Set(["claude-fable-5", "claude-fable-5-1"]);
+function billingRuleOf(plan) {
+  const lower = plan.toLowerCase();
+  if (lower.includes("pro")) return { models: CREDIT_BILLED_MODELS, note: USAGE_CREDITS };
+  if (lower.includes("team") || lower.includes("enterprise")) {
+    return { models: CREDIT_BILLED_MODELS, note: `${USAGE_CREDITS} on standard seats` };
+  }
+  return { models: /* @__PURE__ */ new Set(), note: USAGE_CREDITS };
+}
+function textOf2(value) {
+  return typeof value === "string" ? value : "";
+}
+function withoutLongContext(model) {
+  return model.endsWith(LONG_CONTEXT_SUFFIX2) ? model.slice(0, -LONG_CONTEXT_SUFFIX2.length) : model;
+}
+function isPinned(route) {
+  return Object.hasOwn(CONTEXT_WINDOWS, withoutLongContext(route));
+}
+function announcedModel(row) {
+  return textOf2(row.resolvedModel) || textOf2(row.value);
+}
+function nameOf(row, route) {
+  const display = textOf2(row.displayName).trim();
+  const beforeParenthesis = display.split("(")[0] ?? "";
+  const namesVersion = /\d/.test(beforeParenthesis) && !display.toLowerCase().startsWith("default");
+  if (namesVersion) return display;
+  return textOf2(row.description).split("\xB7")[0]?.trim() || route;
+}
+function catalogName(canonical) {
+  const [family = "", ...rest] = canonical.replace(/^claude-/, "").split("-");
+  const version = rest.filter((part) => /^\d{1,7}$/.test(part)).join(".");
+  const title = `${family.charAt(0).toUpperCase()}${family.slice(1)}`;
+  return version === "" ? title : `${title} ${version}`;
+}
+function routeOf(row, base, longContext) {
+  const route = nativeModel(base);
+  if (isPinned(route)) return route;
+  if (textOf2(row.resolvedModel) === "") return null;
+  return longContext.has(base) ? `${base}${LONG_CONTEXT_SUFFIX2}` : route;
+}
+function isDefaultRow(row) {
+  return textOf2(row.value) === "default";
+}
+function newEntry(row, route) {
+  return {
+    id: route,
+    name: nameOf(row, route),
+    note: isPinned(route) ? "" : UNPINNED,
+    namedByDefaultRow: isDefaultRow(row)
+  };
+}
+function applyRowName(entry, row) {
+  if (!entry.namedByDefaultRow || isDefaultRow(row)) return;
+  entry.name = nameOf(row, entry.id);
+  entry.namedByDefaultRow = false;
+}
+function applyBillingNote(entry, row, base, rule) {
+  const described = textOf2(row.description).toLowerCase().includes("usage credit");
+  if (!described && !rule.models.has(base)) return;
+  const warning = described ? USAGE_CREDITS : rule.note;
+  entry.note = isPinned(entry.id) ? warning : `${warning}${SEPARATOR}${UNPINNED}`;
+}
+function advertisedEntries(rows, rule) {
+  const announced = rows.map(announcedModel);
+  const longContext = new Set(
+    announced.filter((model) => model.endsWith(LONG_CONTEXT_SUFFIX2)).map(withoutLongContext)
+  );
+  const entries = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const base = withoutLongContext(announcedModel(row));
+    if (base === "") continue;
+    const route = routeOf(row, base, longContext);
+    if (route === null) continue;
+    const entry = entries.get(route) ?? newEntry(row, route);
+    entries.set(route, entry);
+    applyRowName(entry, row);
+    applyBillingNote(entry, row, base, rule);
+  }
+  return entries;
+}
+function appendPinnedRoutes(entries, rule) {
+  for (const route of PICKER_ROUTES) {
+    if (entries.has(route)) continue;
+    const canonical = withoutLongContext(route);
+    entries.set(route, {
+      id: route,
+      name: catalogName(canonical),
+      note: rule.models.has(canonical) ? rule.note : "",
+      namedByDefaultRow: false
+    });
+  }
+}
+function toDiscovered({ id, name: name2, note }) {
+  return note === "" ? { id, name: name2 } : { id, name: name2, description: note };
+}
+function mergePicker(rows, plan) {
+  const rule = billingRuleOf(plan);
+  const entries = advertisedEntries(rows, rule);
+  if (entries.size === 0) return [];
+  appendPinnedRoutes(entries, rule);
+  return [...entries.values()].map(toDiscovered);
+}
+
+// src/native/probe.ts
+import { mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join4 } from "node:path";
+var GRACE_MS2 = 2e3;
+var OUTPUT_BYTES = 8 * 1024 * 1024;
+var STDERR_BYTES2 = 16 * 1024;
+function startFailure(error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  return new NativeFailure(`Claude Code could not start: ${detail}`, FailureCode.nativeProtocol, {
+    cause: error
+  });
+}
+function collectedText(handle, stream) {
+  return handle.collected[stream]?.readFrom(0).text ?? "";
+}
+async function runProbe(deps, spec) {
+  throwIfAborted(spec.signal);
+  const deadline = AbortSignal.timeout(spec.timeoutMs);
+  const classify = (error) => {
+    if (spec.signal?.aborted === true) return abortedFailure(error);
+    if (deadline.aborted) return timeoutFailure();
+    return startFailure(error);
+  };
+  let handle;
+  try {
+    handle = deps.subprocess.spawn({
+      argv: spec.argv,
+      cwd: spec.cwd,
+      env: spec.env,
+      graceMs: GRACE_MS2,
+      signal: AbortSignal.any(spec.signal === void 0 ? [deadline] : [deadline, spec.signal]),
+      stdio: {
+        stdin: spec.stdin,
+        stdout: { maxBytes: OUTPUT_BYTES },
+        stderr: { maxBytes: STDERR_BYTES2 }
+      }
+    });
+  } catch (error) {
+    throw classify(error);
+  }
+  try {
+    const { exitCode } = await handle.done;
+    throwIfAborted(spec.signal);
+    if (deadline.aborted) throw timeoutFailure();
+    return {
+      stdout: collectedText(handle, "stdout"),
+      stderr: collectedText(handle, "stderr"),
+      exitCode
+    };
+  } catch (error) {
+    if (error instanceof NativeFailure) throw error;
+    throw classify(error);
+  } finally {
+    handle.terminate();
+  }
+}
+async function withProbeDirectory(work) {
+  const cwd = await mkdtemp2(join4(tmpdir3(), "claude-subscription-probe-"));
+  try {
+    return await work(cwd);
+  } finally {
+    await rm2(cwd, { recursive: true, force: true });
+  }
+}
+
+// src/native/setup.ts
+var AUTH_STATUS_TIMEOUT_MS = 2e4;
+var HANDSHAKE_TIMEOUT_MS = 4e4;
+var ANTHROPIC_API2 = "https://api.anthropic.com";
+var HANDSHAKE_REQUEST = `${JSON.stringify({
+  type: "control_request",
+  request_id: "dsh-picker",
+  request: { subtype: "initialize" }
+})}
+`;
+var HANDSHAKE_ARGS = [
+  "-p",
+  "--model",
+  "sonnet",
+  "--input-format",
+  "stream-json",
+  "--output-format",
+  "stream-json",
+  "--verbose",
+  "--tools",
+  "",
+  "--setting-sources",
+  "",
+  "--strict-mcp-config",
+  "--mcp-config",
+  '{"mcpServers":{}}',
+  "--disable-slash-commands",
+  "--no-session-persistence"
+];
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function protocolFailure2(what, output, cause) {
+  return new NativeFailure(
+    `${what}${stderrSuffix(output.stderr)}`,
+    FailureCode.nativeProtocol,
+    cause === void 0 ? {} : { cause }
+  );
+}
+function planLabel(raw) {
+  if (raw.toLowerCase().startsWith("claude")) return raw;
+  const words = raw.split("_").map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`);
+  return `Claude ${words.join(" ")}`;
+}
+function parseAuthStatus(output) {
+  const text = output.stdout.trim();
+  try {
+    const parsed = JSON.parse(text);
+    if (isJsonObject(parsed)) return parsed;
+  } catch (error) {
+    throw protocolFailure2(unreadableAuth(text), output, error);
+  }
+  throw protocolFailure2(unreadableAuth(text), output);
+}
+function unreadableAuth(text) {
+  return `Could not read \`claude auth status\`: ${JSON.stringify(text.slice(0, 300))}`;
+}
+function statusFrom(auth) {
+  const plan = typeof auth.subscriptionType === "string" ? auth.subscriptionType.trim() : "";
+  const loggedIn = auth.loggedIn === true;
+  return {
+    installed: true,
+    loggedIn,
+    ...plan === "" ? {} : { subscriptionType: planLabel(plan) },
+    ...loggedIn ? {} : { detail: LOGIN_HINT }
+  };
+}
+async function resolveOrMissing(deps, signal) {
+  try {
+    return await resolveClaude(deps, signal);
+  } catch (error) {
+    if (error instanceof NativeFailure && error.code === FailureCode.claudeCodeMissing) return null;
+    throw error;
+  }
+}
+async function setupStatus(deps, signal) {
+  throwIfAborted(signal);
+  const executable = await resolveOrMissing(deps, signal);
+  if (executable === null) return { installed: false, loggedIn: false, detail: INSTALL_HINT };
+  const output = await withProbeDirectory(
+    (cwd) => runProbe(deps, {
+      argv: [executable, "auth", "status"],
+      stdin: "ignore",
+      env: probeEnv(deps.settings(), deps.processEnv()),
+      cwd,
+      timeoutMs: AUTH_STATUS_TIMEOUT_MS,
+      ...signal === void 0 ? {} : { signal }
+    })
+  );
+  return statusFrom(parseAuthStatus(output));
+}
+async function assertLoggedIn(deps, signal) {
+  const status = await setupStatus(deps, signal);
+  if (!status.installed) {
+    throw new NativeFailure(INSTALL_HINT, FailureCode.claudeCodeMissing, { status: 503 });
+  }
+  if (!status.loggedIn) {
+    throw new NativeFailure(LOGGED_OUT_HINT, FailureCode.invalidCredential, { status: 401 });
+  }
+}
+function parseRows(output) {
+  const lines = output.stdout.split("\n").filter((line) => line.startsWith("{"));
+  try {
+    return lines.map((line) => JSON.parse(line));
+  } catch (error) {
+    throw protocolFailure2("Invalid output from the Claude Code handshake", output, error);
+  }
+}
+function field(value, name2) {
+  return isJsonObject(value) ? value[name2] : void 0;
+}
+function parseHandshake(output) {
+  const answer = parseRows(output).find((row) => row.type === "control_response");
+  if (answer === void 0) {
+    throw protocolFailure2("Claude Code did not answer the model handshake", output);
+  }
+  const body = field(answer.response, "response");
+  const rows = field(body, "models");
+  if (!Array.isArray(rows) || !rows.every(isJsonObject)) {
+    throw protocolFailure2("The model handshake holds no list of models", output);
+  }
+  const plan = field(field(body, "account"), "subscriptionType");
+  return { rows, plan: typeof plan === "string" ? plan : "", output };
+}
+function handshakeRelay(deps, processEnv) {
+  if (backendOverrides(processEnv).length === 0) return Promise.resolve(null);
+  return deps.createRelay({
+    upstream: ANTHROPIC_API2,
+    timeoutMs: HANDSHAKE_TIMEOUT_MS,
+    queried: [],
+    oneShot: false,
+    env: processEnv
+  });
+}
+async function runHandshake(deps, executable, signal) {
+  const processEnv = deps.processEnv();
+  const relay = await handshakeRelay(deps, processEnv);
+  try {
+    const env = probeEnv(deps.settings(), processEnv);
+    if (relay !== null) env.ANTHROPIC_BASE_URL = relay.url;
+    const raw = await withProbeDirectory(
+      (cwd) => runProbe(deps, {
+        argv: [executable, ...HANDSHAKE_ARGS],
+        stdin: { data: HANDSHAKE_REQUEST },
+        env,
+        cwd,
+        timeoutMs: HANDSHAKE_TIMEOUT_MS,
+        ...signal === void 0 ? {} : { signal }
+      })
+    );
+    const output = relay === null ? raw : { ...raw, stderr: withoutRelayRoute(raw.stderr, relay.url) };
+    if (relay?.used === true) {
+      throw protocolFailure2("The model handshake sent a model request", output);
+    }
+    return parseHandshake(output);
+  } finally {
+    await relay?.close();
+  }
+}
+async function discoverModels(deps, signal) {
+  await assertLoggedIn(deps, signal);
+  const executable = await resolveClaude(deps, signal);
+  const answer = await runHandshake(deps, executable, signal);
+  const models = mergePicker(answer.rows, answer.plan);
+  if (models.length === 0) {
+    throw protocolFailure2("The model handshake advertised no model", answer.output);
+  }
+  return models;
+}
+
+// src/relay/relay.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { once as once2 } from "node:events";
+import { createServer } from "node:http";
+
+// src/relay/rewrite/payload.ts
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonObject(payload) {
+  try {
+    const value = JSON.parse(utf8.decode(payload));
+    return isObject2(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function serializeBody(body) {
+  return Buffer.from(JSON.stringify(body), "utf8");
+}
+function readMessages(body) {
+  const { messages } = body;
+  return Array.isArray(messages) && messages.every(isObject2) ? messages : void 0;
+}
+function jsonEqual(left, right) {
+  if (left === right) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => jsonEqual(item, right[index]));
+  }
+  if (!isObject2(left) || !isObject2(right)) return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && jsonEqual(left[key], right[key]));
+}
+function lastAssistantIndex(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index]?.role === "assistant") return index;
+  }
+  return -1;
+}
+
+// src/relay/capture.ts
+var CaptureError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CaptureError";
+  }
+};
+var FRAME_END = /\r?\n\r?\n/;
+var LINE_BREAK = /\r\n|\n|\r/;
+var LEADING_SPACES = /^ +/;
+var TEXT_FIELDS = /* @__PURE__ */ new Map([
+  ["text_delta", "text"],
+  ["thinking_delta", "thinking"],
+  ["signature_delta", "signature"]
+]);
+var BLANK_CHARACTERS = new Set(
+  "	\n\v\f\r \x85\xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000"
+);
+function isBlank(text) {
+  return [...text].every((character) => BLANK_CHARACTERS.has(character));
+}
+function storableNumber(_key, value) {
+  if (typeof value !== "number") return value;
+  if (!Number.isFinite(value))
+    throw new RangeError("a tool input holds a number that is not finite");
+  return Object.is(value, -0) ? 0 : value;
+}
+function hasType(value) {
+  return isObject2(value) && typeof value.type === "string";
+}
+function isCapturedMessage(value) {
+  return isObject2(value) && value.role === "assistant" && Array.isArray(value.content) && isObject2(value.usage) && typeof value.usage.input_tokens === "number" && typeof value.usage.output_tokens === "number";
+}
+function readIndex(event) {
+  const { index } = event;
+  if (typeof index !== "number" || !Number.isInteger(index) || index < 0) {
+    throw new CaptureError(`${event.type} has no valid index`);
+  }
+  return index;
+}
+function readObject(event, field2) {
+  const value = event[field2];
+  if (!isObject2(value)) throw new CaptureError(`${event.type} has no ${field2} object`);
+  return value;
+}
+function mergeFields(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    Object.defineProperty(target, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  }
+}
+function appendText(block, field2, addition) {
+  const current = block[field2] ?? "";
+  if (typeof current !== "string" || typeof addition !== "string") {
+    throw new CaptureError(`a ${block.type} block cannot take a text delta for ${field2}`);
+  }
+  block[field2] = current + addition;
+}
+function addCitation(block, citation) {
+  const citations = block.citations ?? [];
+  if (!Array.isArray(citations) || citation === void 0) {
+    throw new CaptureError(`a ${block.type} block cannot take a citation`);
+  }
+  block.citations = [...citations, structuredClone(citation)];
+}
+var EventStreamParser = class {
+  #pending = "";
+  #decoder = new TextDecoder("utf-8", { fatal: true });
+  parse(chunk) {
+    const frames = (this.#pending + this.#decode(chunk)).split(FRAME_END);
+    this.#pending = frames.pop() ?? "";
+    return frames.map(frameData).filter((data) => data !== "").map(parseEvent);
+  }
+  #decode(chunk) {
+    try {
+      return this.#decoder.decode(chunk, { stream: true });
+    } catch (cause) {
+      throw new CaptureError("the event stream is not valid UTF-8", { cause });
+    }
+  }
+};
+function frameData(frame) {
+  return frame.split(LINE_BREAK).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).replace(LEADING_SPACES, "")).join("\n");
+}
+function parseEvent(data) {
+  let value;
+  try {
+    value = JSON.parse(data);
+  } catch (cause) {
+    throw new CaptureError("an event does not hold valid JSON", { cause });
+  }
+  if (!hasType(value)) throw new CaptureError("an event has no type");
+  return value;
+}
+function readError(event) {
+  const { type, message } = readObject(event, "error");
+  if (typeof type !== "string" || typeof message !== "string") {
+    throw new CaptureError("error has no type and message");
+  }
+  return { type, message };
+}
+var MessageAssembler = class {
+  #message = null;
+  #complete = false;
+  #error = null;
+  #partialInputs = /* @__PURE__ */ new Map();
+  #unparsedInputs = /* @__PURE__ */ new Set();
+  get message() {
+    return this.#message;
+  }
+  get complete() {
+    return this.#complete;
+  }
+  get error() {
+    return this.#error;
+  }
+  apply(event) {
+    switch (event.type) {
+      case "message_start":
+        this.#start(event);
+        break;
+      case "content_block_start":
+        this.#startBlock(event);
+        break;
+      case "content_block_delta":
+        this.#applyDelta(event);
+        break;
+      case "content_block_stop":
+        this.#stopBlock(event);
+        break;
+      case "message_delta":
+        this.#updateMessage(event);
+        break;
+      case "message_stop":
+        this.#stop(event);
+        break;
+      case "error":
+        this.#error ??= readError(event);
+        break;
+    }
+  }
+  #started(event) {
+    if (this.#message === null) throw new CaptureError(`${event.type} came before message_start`);
+    return this.#message;
+  }
+  #blockAt(event, index) {
+    const block = this.#started(event).content[index];
+    if (block === void 0) throw new CaptureError(`${event.type} points at a missing block`);
+    return block;
+  }
+  #start(event) {
+    const { message } = event;
+    if (!isCapturedMessage(message)) throw new CaptureError("message_start has no valid message");
+    this.#message = structuredClone(message);
+  }
+  #startBlock(event) {
+    const block = event.content_block;
+    if (!hasType(block)) throw new CaptureError("content_block_start has no typed block");
+    this.#started(event).content.push(structuredClone(block));
+  }
+  #applyDelta(event) {
+    const index = readIndex(event);
+    const block = this.#blockAt(event, index);
+    const delta = event.delta;
+    if (!hasType(delta)) throw new CaptureError("content_block_delta has no typed delta");
+    const field2 = TEXT_FIELDS.get(delta.type);
+    if (field2 !== void 0) {
+      appendText(block, field2, delta[field2]);
+    } else if (delta.type === "input_json_delta") {
+      this.#appendInput(index, delta.partial_json);
+    } else if (delta.type === "citations_delta") {
+      addCitation(block, delta.citation);
+    }
+  }
+  #appendInput(index, partialJson) {
+    if (typeof partialJson !== "string") throw new CaptureError("input_json_delta has no text");
+    this.#partialInputs.set(index, (this.#partialInputs.get(index) ?? "") + partialJson);
+  }
+  #stopBlock(event) {
+    const index = readIndex(event);
+    const raw = this.#partialInputs.get(index);
+    if (raw === void 0) return;
+    this.#partialInputs.delete(index);
+    const block = this.#blockAt(event, index);
+    if (isBlank(raw)) {
+      block.input = {};
+      return;
+    }
+    try {
+      block.input = JSON.parse(raw, storableNumber);
+    } catch {
+      this.#unparsedInputs.add(index);
+    }
+  }
+  #updateMessage(event) {
+    const message = this.#started(event);
+    if (event.delta !== void 0) mergeFields(message, readObject(event, "delta"));
+    if (event.usage !== void 0) mergeFields(message.usage, readObject(event, "usage"));
+  }
+  #stop(event) {
+    const message = this.#started(event);
+    for (const index of [...this.#unparsedInputs].sort((a, b) => b - a)) {
+      message.content.splice(index, 1);
+    }
+    this.#unparsedInputs.clear();
+    this.#complete = Boolean(message.stop_reason) && this.#partialInputs.size === 0;
+  }
+};
+var SseCapture = class {
+  #parser = new EventStreamParser();
+  #assembler = new MessageAssembler();
+  get message() {
+    return this.#assembler.message;
+  }
+  get complete() {
+    return this.#assembler.complete;
+  }
+  get error() {
+    return this.#assembler.error;
+  }
+  feed(chunk) {
+    for (const event of this.#parser.parse(chunk)) this.#assembler.apply(event);
+  }
+};
+
+// src/relay/retry-after.ts
+var SECONDS = /^\d+$/;
+function retryAfterMs(header, now) {
+  if (typeof header !== "string") return null;
+  const value = header.trim();
+  const wait = SECONDS.test(value) ? Number(value) * 1e3 : Date.parse(value) - now;
+  return Number.isSafeInteger(wait) && wait > 0 ? wait : null;
+}
+
+// src/relay/rewrite/blocks.ts
+var MARK = "cache_control";
+var PLAIN_TEXT_KEYS = /* @__PURE__ */ new Set(["type", "text", MARK]);
+var UNCACHEABLE_TYPES = /* @__PURE__ */ new Set(["thinking", "redacted_thinking"]);
+function hasMark(block) {
+  return Object.hasOwn(block, MARK);
+}
+function takeMark(block) {
+  const mark = block[MARK];
+  delete block[MARK];
+  return mark;
+}
+function setMarkIfAbsent(block, mark) {
+  if (!hasMark(block)) block[MARK] = mark;
+}
+function isCacheable(block) {
+  return typeof block.type !== "string" || !UNCACHEABLE_TYPES.has(block.type);
+}
+function isUncacheable(value) {
+  return isObject2(value) && !isCacheable(value);
+}
+function withoutMark(block) {
+  if (!isObject2(block)) return block;
+  const { [MARK]: _mark, ...rest } = block;
+  return rest;
+}
+function countMarks(value) {
+  if (Array.isArray(value)) return value.reduce((sum, item) => sum + countMarks(item), 0);
+  if (!isObject2(value)) return 0;
+  return Object.entries(value).reduce(
+    (sum, [key, item]) => sum + (key === MARK ? 1 : countMarks(item)),
+    0
+  );
+}
+function isPlainText(block) {
+  return isObject2(block) && block.type === "text" && Object.keys(block).every((key) => PLAIN_TEXT_KEYS.has(key));
+}
+function leadingLength(blocks, frame) {
+  const wanted = frame.map(withoutMark);
+  const starts = [];
+  for (let start = 0; start + wanted.length <= blocks.length; start += 1) {
+    const window = blocks.slice(start, start + wanted.length).map(withoutMark);
+    if (jsonEqual(window, wanted)) starts.push(start);
+  }
+  return starts.length === 1 ? starts[0] ?? 0 : 0;
+}
+function dropLeadingText(blocks, count) {
+  const leading = blocks.slice(0, count);
+  if (!leading.every(isPlainText)) return false;
+  const mark = leading.find(hasMark)?.[MARK];
+  blocks.splice(0, count);
+  const head = blocks[0];
+  if (mark !== void 0 && mark !== null && isObject2(head)) setMarkIfAbsent(head, mark);
+  return true;
+}
+
+// src/relay/rewrite/breakpoints.ts
+var LOOKBACK = 20;
+var MAX_BREAKPOINTS = 4;
+function isBefore(left, right) {
+  return left.message < right.message || left.message === right.message && left.index < right.index;
+}
+function placedBlocks(messages) {
+  return messages.flatMap(
+    (message, messageIndex) => Array.isArray(message.content) ? message.content.flatMap(
+      (block, index) => isObject2(block) ? [{ message: messageIndex, index, block }] : []
+    ) : []
+  );
+}
+function markedBlocks(messages) {
+  return placedBlocks(messages).filter(({ block }) => hasMark(block));
+}
+function lastCacheable(blocks) {
+  for (let index = blocks.length - 1; index >= 0; index -= 1) {
+    const placed = blocks[index];
+    if (placed !== void 0 && isCacheable(placed.block)) return placed;
+  }
+  return void 0;
+}
+function dropOpeningContext(messages, queried) {
+  if (messages.some((message) => message.role === "assistant")) return false;
+  const first = messages.find((message) => message.role === "user");
+  if (first === void 0 || !Array.isArray(first.content)) return false;
+  const count = leadingLength(first.content, queried);
+  return count > 0 && dropLeadingText(first.content, count);
+}
+function queriedPrefix(messages, turn, queried) {
+  const newest = messages[turn];
+  if (newest?.role !== "user" || !Array.isArray(newest.content)) return [];
+  const prefix = [];
+  for (let index = 0; index < Math.min(newest.content.length, queried.length); index += 1) {
+    const sent = newest.content[index];
+    if (!isObject2(sent) || !jsonEqual(withoutMark(sent), withoutMark(queried[index]))) break;
+    prefix.push({ message: turn, index, block: sent });
+  }
+  const next = newest.content[prefix.length];
+  return isObject2(next) && next.type === "tool_result" ? [] : prefix;
+}
+function foldMarks(target, later) {
+  const [moved] = later.map(({ block }) => takeMark(block));
+  setMarkIfAbsent(target.block, moved);
+}
+function opensTurn(message) {
+  if (message.role !== "user") return false;
+  const { content } = message;
+  if (typeof content === "string") return true;
+  return Array.isArray(content) && content.some((block) => !isObject2(block) || block.type !== "tool_result");
+}
+function holdsThinking(message) {
+  return message.role === "assistant" && Array.isArray(message.content) && message.content.some(isUncacheable);
+}
+function lastIndexWhere(items, from, test) {
+  for (let index = from; index >= 0; index -= 1) {
+    if (test(items[index])) return index;
+  }
+  return void 0;
+}
+function firstIndexWhere(items, from, to, test) {
+  for (let index = from; index <= to; index += 1) {
+    if (test(items[index])) return index;
+  }
+  return void 0;
+}
+function countBlocks(messages) {
+  return messages.reduce(
+    (sum, message) => sum + (Array.isArray(message.content) ? message.content.length : 1),
+    0
+  );
+}
+function turnStartSpot(messages, lastAssistant) {
+  const opening = lastIndexWhere(messages, lastAssistant - 1, opensTurn);
+  if (opening === void 0) return void 0;
+  const thought = firstIndexWhere(messages, opening + 1, lastAssistant, holdsThinking);
+  if (thought === void 0) return void 0;
+  const frame = lastIndexWhere(messages, thought - 1, (message) => message.role === "user");
+  const content = frame === void 0 ? void 0 : messages[frame]?.content;
+  if (frame === void 0 || !Array.isArray(content)) return void 0;
+  const index = lastIndexWhere(
+    content,
+    content.length - 1,
+    (block2) => isObject2(block2) && isCacheable(block2)
+  );
+  const block = index === void 0 ? void 0 : content[index];
+  return index !== void 0 && isObject2(block) ? { message: frame, index, block } : void 0;
+}
+function keepTurnMark(body, messages, lastAssistant, target) {
+  const spot = turnStartSpot(messages, lastAssistant);
+  if (spot === void 0 || hasMark(spot.block) || !isBefore(spot, target)) return false;
+  const span = countBlocks(messages.slice(spot.message, target.message));
+  if (span - spot.index + target.index + 1 <= LOOKBACK) return false;
+  const later = markedBlocks(messages).filter((marked) => isBefore(spot, marked));
+  const [firstLater] = later;
+  if (firstLater === void 0) return false;
+  if (countMarks(body) < MAX_BREAKPOINTS) {
+    spot.block.cache_control = structuredClone(firstLater.block.cache_control);
+    return true;
+  }
+  const spare = later.find((marked) => isBefore(marked, target));
+  if (spare === void 0 || !hasMark(target.block)) return false;
+  spot.block.cache_control = takeMark(spare.block);
+  return true;
+}
+function pinMessageBreakpoint(payload, queried) {
+  if (queried.length === 0) return payload;
+  const body = parseJsonObject(payload);
+  const messages = body === void 0 ? void 0 : readMessages(body);
+  if (body === void 0 || messages === void 0) return payload;
+  const trimmedOpening = dropOpeningContext(messages, queried);
+  const marked = markedBlocks(messages);
+  if (marked.length === 0 && !trimmedOpening) return payload;
+  const lastAssistant = lastAssistantIndex(messages);
+  const recurring = [
+    ...placedBlocks(messages).filter(({ message }) => message <= lastAssistant),
+    ...queriedPrefix(messages, lastAssistant + 1, queried)
+  ];
+  const target = lastCacheable(recurring);
+  const later = target === void 0 ? [] : marked.filter((mark) => isBefore(target, mark));
+  const folded = target !== void 0 && later.length > 0;
+  if (folded) foldMarks(target, later);
+  const pinnedTurn = target !== void 0 && keepTurnMark(body, messages, lastAssistant, target);
+  return trimmedOpening || folded || pinnedTurn ? serializeBody(body) : payload;
+}
+function dropMessageBreakpoints(payload) {
+  const body = parseJsonObject(payload);
+  const messages = body === void 0 ? void 0 : readMessages(body);
+  if (body === void 0 || messages === void 0) return payload;
+  let dropped = false;
+  for (const { content } of messages) {
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (!isObject2(block)) continue;
+      const mark = takeMark(block);
+      if (mark !== void 0 && mark !== null) dropped = true;
+    }
+  }
+  return dropped ? serializeBody(body) : payload;
+}
+
+// src/relay/rewrite/restore.ts
+var QUERIED_TURN_MISMATCH = "Native request does not uniquely match the DSH tool results";
+var QueriedTurnMismatch = class extends Error {
+  constructor() {
+    super(QUERIED_TURN_MISMATCH);
+    this.name = "QueriedTurnMismatch";
+  }
+};
+var IGNORED_RESULT_KEYS = /* @__PURE__ */ new Set(["content", "is_error", "cache_control"]);
+function isToolResult(block) {
+  return isObject2(block) && block.type === "tool_result";
+}
+function isBareText(block) {
+  return isObject2(block) && block.type === "text" && typeof block.text === "string" && Object.keys(block).length === 2;
+}
+function joinText(blocks) {
+  return blocks.map((block) => block.text).join("");
+}
+function leadingBareText(blocks, start) {
+  const run = [];
+  for (let index = start; index < blocks.length; index += 1) {
+    const block = blocks[index];
+    if (!isBareText(block)) break;
+    run.push(block);
+  }
+  return run;
+}
+function without(block, keys) {
+  return Object.fromEntries(Object.entries(block).filter(([key]) => !keys.has(key)));
+}
+function flatText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value) && value.every(isBareText)) return joinText(value);
+  return void 0;
+}
+function errorFlag(block) {
+  return Object.hasOwn(block, "is_error") ? block.is_error : false;
+}
+function restoreContent(sent, host) {
+  if (typeof host === "string" || typeof sent === "string") {
+    const sentText = flatText(sent);
+    const hostText = flatText(host);
+    if (sentText === void 0 || hostText === void 0 || !sentText.startsWith(hostText)) {
+      throw new QueriedTurnMismatch();
+    }
+    return structuredClone(host);
+  }
+  if (Array.isArray(sent) && Array.isArray(host)) return restoreSequence(sent, host);
+  if (!jsonEqual(sent, host)) throw new QueriedTurnMismatch();
+  return structuredClone(host);
+}
+function restoreToolResult(sent, host, restored) {
+  const sentError = errorFlag(sent);
+  const hostError = errorFlag(host);
+  if (typeof sentError !== "boolean" || typeof hostError !== "boolean" || sentError !== hostError) {
+    throw new QueriedTurnMismatch();
+  }
+  if (!jsonEqual(without(sent, IGNORED_RESULT_KEYS), without(host, IGNORED_RESULT_KEYS))) {
+    throw new QueriedTurnMismatch();
+  }
+  if (Object.hasOwn(sent, "content") !== Object.hasOwn(host, "content")) {
+    throw new QueriedTurnMismatch();
+  }
+  if (Object.hasOwn(host, "content")) restored.content = restoreContent(sent.content, host.content);
+}
+function restoreBlock(sent, host) {
+  if (!isObject2(sent) || !isObject2(host)) throw new QueriedTurnMismatch();
+  const restored = structuredClone(host);
+  if (host.type === "tool_result") {
+    restoreToolResult(sent, host, restored);
+  } else if (!jsonEqual(withoutMark(sent), withoutMark(host))) {
+    throw new QueriedTurnMismatch();
+  }
+  if (hasMark(sent)) {
+    if (hasMark(host) && !jsonEqual(sent.cache_control, host.cache_control)) {
+      throw new QueriedTurnMismatch();
+    }
+    restored.cache_control = structuredClone(sent.cache_control);
+  }
+  return restored;
+}
+function restoreSequence(sent, host) {
+  const restored = [];
+  let hostAt = 0;
+  let sentAt = 0;
+  while (hostAt < host.length) {
+    if (sentAt >= sent.length) throw new QueriedTurnMismatch();
+    const hostRun = leadingBareText(host, hostAt);
+    const sentRun = leadingBareText(sent, sentAt);
+    if (hostRun.length > 0 && sentRun.length > 0) {
+      const original = joinText(hostRun);
+      const actual = joinText(sentRun);
+      const reachesEnd = hostAt + hostRun.length === host.length;
+      if (!(reachesEnd ? actual.startsWith(original) : actual === original)) {
+        throw new QueriedTurnMismatch();
+      }
+      restored.push(...structuredClone(hostRun));
+      hostAt += hostRun.length;
+      sentAt += sentRun.length;
+    } else {
+      restored.push(restoreBlock(sent[sentAt], host[hostAt]));
+      hostAt += 1;
+      sentAt += 1;
+    }
+  }
+  if (!sent.slice(sentAt).every(isBareText)) throw new QueriedTurnMismatch();
+  return restored;
+}
+function resultIds(blocks) {
+  return blocks.filter(isToolResult).map((block) => block.tool_use_id);
+}
+function assertSameResultIds(native, queried) {
+  const queriedIds = resultIds(queried);
+  const usable = queriedIds.every((id) => typeof id === "string" && id !== "");
+  if (!usable || new Set(queriedIds).size !== queriedIds.length) throw new QueriedTurnMismatch();
+  if (!jsonEqual(queriedIds, resultIds(native))) throw new QueriedTurnMismatch();
+}
+function restoreQueriedTurn(payload, queried) {
+  if (!queried.some(isToolResult)) return payload;
+  const body = parseJsonObject(payload);
+  const messages = body === void 0 ? void 0 : readMessages(body);
+  if (body === void 0 || messages === void 0) throw new QueriedTurnMismatch();
+  const newest = messages.at(lastAssistantIndex(messages) + 1);
+  const native = newest?.role === "user" ? newest.content : void 0;
+  if (newest === void 0 || !Array.isArray(native)) throw new QueriedTurnMismatch();
+  assertSameResultIds(native, queried);
+  const restored = restoreSequence(native, queried);
+  if (jsonEqual(native, restored)) return payload;
+  newest.content = restored;
+  return serializeBody(body);
+}
+
+// src/relay/rewrite/stable-context.ts
+var DATE_LINE = /^Today's date is [0-9]{4}-[0-9]{2}-[0-9]{2}\.$/;
+var ROLES = /* @__PURE__ */ new Set(["system", "user", "assistant"]);
+function isTextBlock(block) {
+  return block.type === "text" && typeof block.text === "string";
+}
+function isWellFormedBlock(block) {
+  return isObject2(block) && typeof block.type === "string" && (block.type !== "text" || typeof block.text === "string");
+}
+function isMessage(message) {
+  const { role, content } = message;
+  return typeof role === "string" && ROLES.has(role) && (typeof content === "string" || Array.isArray(content) && content.every(isWellFormedBlock));
+}
+function soleText(content) {
+  if (typeof content === "string") return { type: "text", text: content };
+  const [only] = content;
+  return content.length === 1 && only !== void 0 && isTextBlock(only) ? only : void 0;
+}
+function appendToEnvironment(environment, date) {
+  const addition = `
+
+${date}`;
+  const { content } = environment;
+  if (typeof content === "string") {
+    if (content.endsWith(date)) return false;
+    environment.content = content + addition;
+    return true;
+  }
+  const last = content[content.length - 1];
+  if (last === void 0 || !isTextBlock(last) || last.text.endsWith(date)) return false;
+  last.text += addition;
+  return true;
+}
+function returnDateLine(messages) {
+  const last = messages[messages.length - 1];
+  const environment = messages.slice(0, -1).find((message) => message.role === "system");
+  if (last === void 0 || last.role !== "system" || environment === void 0) return false;
+  const date = soleText(last.content);
+  if (date === void 0 || !DATE_LINE.test(date.text)) return false;
+  if (!appendToEnvironment(environment, date.text)) return false;
+  const mark = Object.hasOwn(date, "cache_control") ? date.cache_control : last.cache_control;
+  messages.pop();
+  const previous = messages[messages.length - 1]?.content;
+  if (mark !== void 0 && mark !== null && Array.isArray(previous) && previous.length > 0) {
+    setMarkIfAbsent(previous[previous.length - 1], mark);
+  }
+  return true;
+}
+function newestUser(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index]?.role === "user") return messages[index];
+  }
+  return void 0;
+}
+function dropNewestTurnContext(messages, queried) {
+  if (!queried.some((block) => block.type !== "tool_result")) return false;
+  if (!messages.some((message) => message.role === "assistant")) return false;
+  const newest = newestUser(messages);
+  if (newest === void 0 || !Array.isArray(newest.content)) return false;
+  const count = leadingLength(newest.content, queried);
+  return count > 0 && dropLeadingText(newest.content, count);
+}
+function stableRequestContext(payload, queried) {
+  const body = parseJsonObject(payload);
+  const messages = body === void 0 ? void 0 : readMessages(body);
+  if (body === void 0 || messages === void 0 || !messages.every(isMessage)) return payload;
+  const movedDate = returnDateLine(messages);
+  const droppedContext = dropNewestTurnContext(messages, queried);
+  return movedDate || droppedContext ? serializeBody(body) : payload;
+}
+
+// src/relay/rewrite/tool-input.ts
+var FLAG = "eager_input_streaming";
+function isUnflaggedTool(tool) {
+  return isObject2(tool) && !Object.hasOwn(tool, FLAG);
+}
+function streamToolInput(payload) {
+  const body = parseJsonObject(payload);
+  if (body === void 0 || !Array.isArray(body.tools)) return payload;
+  const unflagged = body.tools.filter(isUnflaggedTool);
+  if (unflagged.length === 0) return payload;
+  for (const tool of unflagged) tool[FLAG] = true;
+  return serializeBody(body);
+}
+
+// src/relay/upstream.ts
+import { randomBytes, randomInt } from "node:crypto";
+import { once } from "node:events";
+import { request as httpRequest } from "node:http";
+import { isIP, connect as netConnect } from "node:net";
+import { connect as tlsConnect } from "node:tls";
+import { promisify } from "node:util";
+import { gzip } from "node:zlib";
+var UPSTREAM_IDLE_LIMIT_MS = 18e4;
+var KEEPALIVE_INITIAL_DELAY_MS = 15e3;
+var GZIP_MIN_BYTES = 4096;
+var GZIP_MAX_PAD_BYTES = 256;
+var GZIP_OFF_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+var CUSTOM_CA_VARIABLES = [
+  "SSL_CERT_FILE",
+  "SSL_CERT_DIR",
+  "REQUESTS_CA_BUNDLE",
+  "CURL_CA_BUNDLE",
+  "NODE_EXTRA_CA_CERTS"
+];
+var REQUEST_FIELDS_OWNED_BY_THIS_HOP = /* @__PURE__ */ new Set([
+  "host",
+  "connection",
+  "content-length",
+  "transfer-encoding",
+  "proxy-authorization",
+  "proxy-connection",
+  "accept-encoding"
+]);
+var RESPONSE_FIELDS_OWNED_BY_THIS_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "transfer-encoding",
+  "server",
+  "date"
+]);
+var INVALID_UPSTREAM = "Native upstream must be HTTPS or a loopback HTTP fixture";
+var UNSUPPORTED_PROXY = "Unusable proxy for the relay: only an http://host[:port] CONNECT proxy is supported, not SOCKS or TLS to the proxy";
+var DEFAULT_UPSTREAM_POLICY = {
+  gzipOrigins: ["https://api.anthropic.com"],
+  tls: {}
+};
+var LocalFailure = class extends Error {
+  constructor(name2) {
+    super(name2);
+    this.name = name2;
+  }
+};
+function idleLimitMs(timeoutMs) {
+  return Math.min(timeoutMs, UPSTREAM_IDLE_LIMIT_MS);
+}
+function parseUrl(raw) {
+  return URL.canParse(raw) ? new URL(raw) : null;
+}
+function withoutBrackets(hostname) {
+  return hostname.startsWith("[") ? hostname.slice(1, -1) : hostname;
+}
+function isLoopback(hostname) {
+  if (hostname === "localhost") return true;
+  const version = isIP(hostname);
+  if (version === 4) return hostname.startsWith("127.");
+  return version === 6 && hostname === "::1";
+}
+function hasOnlySchemeHostAndPath(url) {
+  return url.username === "" && url.password === "" && url.search === "" && url.hash === "";
+}
+function parseUpstreamUrl(raw) {
+  const url = parseUrl(raw);
+  if (url === null || !hasOnlySchemeHostAndPath(url)) {
+    throw new NativeFailure(INVALID_UPSTREAM, FailureCode.relayError);
+  }
+  const hostname = withoutBrackets(url.hostname);
+  const secure = url.protocol === "https:";
+  if (!secure && !(url.protocol === "http:" && isLoopback(hostname))) {
+    throw new NativeFailure(INVALID_UPSTREAM, FailureCode.relayError);
+  }
+  const port = url.port === "" ? secure ? 443 : 80 : Number(url.port);
+  return {
+    secure,
+    origin: url.origin,
+    hostname,
+    port,
+    host: url.host,
+    tunnelAuthority: `${url.hostname}:${port}`,
+    basePath: url.pathname.replace(/\/+$/, "")
+  };
+}
+function proxyVariables(env) {
+  const entries = Object.entries(env).filter(
+    (entry) => entry[1] !== void 0 && entry[0].length > 6 && entry[0].slice(-6).toLowerCase() === "_proxy"
+  );
+  const proxies = /* @__PURE__ */ new Map();
+  for (const [name2, value] of entries) {
+    if (value !== "") proxies.set(name2.slice(0, -6).toLowerCase(), value);
+  }
+  if (env.REQUEST_METHOD !== void 0) proxies.delete("http");
+  for (const [name2, value] of entries) {
+    if (!name2.endsWith("_proxy")) continue;
+    const key = name2.slice(0, -6).toLowerCase();
+    if (value === "") proxies.delete(key);
+    else proxies.set(key, value);
+  }
+  return proxies;
+}
+function bypassesProxy(target, noProxy) {
+  if (noProxy === void 0) return false;
+  const list = noProxy.replaceAll(" ", ",");
+  if (list === "*") return true;
+  const hostname = target.hostname.toLowerCase();
+  const hostAndPort = `${hostname}:${target.port}`;
+  return list.split(",").map((entry) => entry.trim().replace(/^\.+/, "").toLowerCase()).filter((name2) => name2 !== "").some(
+    (name2) => hostname === name2 || hostAndPort === name2 || hostname.endsWith(`.${name2}`) || hostAndPort.endsWith(`.${name2}`)
+  );
+}
+function percentDecode(text) {
+  return text.replace(
+    /(?:%[0-9a-f]{2})+/gi,
+    (run) => Buffer.from(run.replaceAll("%", ""), "hex").toString("utf8")
+  );
+}
+function proxyAuthorization(proxy) {
+  if (proxy.username === "" && proxy.password === "") return void 0;
+  const credentials = `${percentDecode(proxy.username)}:${percentDecode(proxy.password)}`;
+  return `Basic ${Buffer.from(credentials).toString("base64")}`;
+}
+function parseProxy(raw) {
+  const url = parseUrl(raw.includes("://") ? raw : `http://${raw}`);
+  if (url === null || url.protocol !== "http:" || url.hostname === "") {
+    throw new NativeFailure(UNSUPPORTED_PROXY, FailureCode.relayError);
+  }
+  const authorization = proxyAuthorization(url);
+  return {
+    host: withoutBrackets(url.hostname),
+    port: url.port === "" ? 80 : Number(url.port),
+    ...authorization === void 0 ? {} : { authorization }
+  };
+}
+function selectProxy(target, env) {
+  if (!target.secure) return null;
+  const proxies = proxyVariables(env);
+  if (bypassesProxy(target, proxies.get("no"))) return null;
+  const raw = proxies.get("https") ?? proxies.get("http");
+  return raw === void 0 ? null : parseProxy(raw);
+}
+function gzipEligible(facts) {
+  const setting = facts.env.CLAUDE_CODE_GZIP_REQUEST_BODIES?.toLowerCase() ?? "";
+  return facts.gzipOrigins.includes(facts.target.origin) && facts.proxy === null && CUSTOM_CA_VARIABLES.every((name2) => facts.env[name2] === void 0) && !GZIP_OFF_VALUES.has(setting) && facts.payloadBytes >= GZIP_MIN_BYTES && facts.contentEncoding === void 0;
+}
+function gzipPadding(padBytes) {
+  const noise = randomBytes(padBytes);
+  const pad = Buffer.alloc(padBytes + 1);
+  pad[0] = 10;
+  noise.forEach((byte, index) => {
+    pad[index + 1] = byte % 2 === 0 ? 32 : 9;
+  });
+  return pad;
+}
+var gzipAsync = promisify(gzip);
+async function gzipRequestBody(payload, padBytes = randomInt(GZIP_MAX_PAD_BYTES + 1)) {
+  return gzipAsync(Buffer.concat([payload, gzipPadding(padBytes)]), { level: 3 });
+}
+function rawHeaderPairs(rawHeaders) {
+  const pairs = [];
+  for (let index = 0; index + 1 < rawHeaders.length; index += 2) {
+    pairs.push([rawHeaders[index], rawHeaders[index + 1]]);
+  }
+  return pairs;
+}
+function upstreamRequestHeaders(rawHeaders, facts) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const [name2, value] of rawHeaderPairs(rawHeaders)) {
+    const key = name2.toLowerCase();
+    if (REQUEST_FIELDS_OWNED_BY_THIS_HOP.has(key)) continue;
+    const field2 = fields.get(key);
+    if (field2 === void 0) fields.set(key, { name: name2, values: [value] });
+    else field2.values.push(value);
+  }
+  const headers = {};
+  for (const { name: name2, values } of fields.values()) {
+    headers[name2] = values.length === 1 ? values[0] : values;
+  }
+  headers.Host = facts.target.host;
+  headers["Accept-Encoding"] = "identity";
+  headers["Content-Length"] = String(facts.bodyBytes);
+  if (facts.gzip) headers["Content-Encoding"] = "gzip";
+  return headers;
+}
+function clientResponseHeaders(rawHeaders) {
+  const kept = rawHeaderPairs(rawHeaders).filter(
+    ([name2]) => !RESPONSE_FIELDS_OWNED_BY_THIS_HOP.has(name2.toLowerCase())
+  );
+  return [...kept.flat(), "Connection", "close"];
+}
+function ignoreError() {
+}
+function tieToCall(socket, control) {
+  socket.on("error", (error) => control.abort(error));
+  control.signal.addEventListener("abort", () => socket.destroy(), { once: true });
+}
+async function openTcp(host, port, control) {
+  const socket = netConnect({ host, port });
+  tieToCall(socket, control);
+  socket.setKeepAlive(true, KEEPALIVE_INITIAL_DELAY_MS);
+  await once(socket, "connect", { signal: control.signal });
+  return socket;
+}
+async function openTunnel(socket, proxy, target, signal) {
+  const request = httpRequest({
+    method: "CONNECT",
+    path: target.tunnelAuthority,
+    headers: {
+      Host: target.tunnelAuthority,
+      // Without an agent Node sends "close", which is wrong for a tunnel that must stay open.
+      Connection: "keep-alive",
+      ...proxy.authorization === void 0 ? {} : { "Proxy-Authorization": proxy.authorization }
+    },
+    createConnection: () => socket
+  });
+  request.on("error", ignoreError);
+  request.end();
+  const [response, tunnel, head] = await once(request, "connect", { signal });
+  if (response.statusCode !== 200) throw new LocalFailure("ProxyTunnelRefused");
+  if (head.length > 0) tunnel.unshift(head);
+  return tunnel;
+}
+async function startTls(socket, route, control) {
+  const { hostname } = route.target;
+  const secure = tlsConnect({
+    socket,
+    host: hostname,
+    // TLS does not allow an IP address as a server name.
+    ...isIP(hostname) === 0 ? { servername: hostname } : {},
+    ALPNProtocols: ["http/1.1"],
+    ...route.tls
+  });
+  tieToCall(secure, control);
+  await once(secure, "secureConnect", { signal: control.signal });
+  return secure;
+}
+async function connectToUpstream(route, control) {
+  const deadline = setTimeout(
+    () => control.abort(new LocalFailure("UpstreamTimeout")),
+    route.timeoutMs
+  );
+  try {
+    const { proxy, target } = route;
+    const first = proxy === null ? await openTcp(target.hostname, target.port, control) : await openTcp(proxy.host, proxy.port, control);
+    const path = proxy === null ? first : await openTunnel(first, proxy, target, control.signal);
+    return target.secure ? await startTls(path, route, control) : path;
+  } finally {
+    clearTimeout(deadline);
+  }
+}
+var SilenceLimit = class {
+  #socket;
+  #limitMs = 0;
+  #failure = "";
+  constructor(socket, control) {
+    this.#socket = socket;
+    socket.on("timeout", () => control.abort(new LocalFailure(this.#failure)));
+  }
+  start(limitMs, failure) {
+    this.#limitMs = limitMs;
+    this.#failure = failure;
+    this.resume();
+  }
+  /** While the client holds back the stream, upstream silence means nothing. */
+  suspend() {
+    this.#socket.setTimeout(0);
+  }
+  resume() {
+    if (!this.#socket.destroyed) this.#socket.setTimeout(this.#limitMs);
+  }
+};
+async function exchangeHeaders(socket, upstream, signal) {
+  const request = httpRequest({
+    method: "POST",
+    path: upstream.path,
+    headers: upstream.headers,
+    createConnection: () => socket
+  });
+  request.on("error", ignoreError);
+  request.end(upstream.body);
+  const [response] = await once(request, "response", { signal });
+  response.on("error", ignoreError);
+  return response;
+}
+async function openUpstream(route, upstream, control) {
+  control.signal.throwIfAborted();
+  const socket = await connectToUpstream(route, control);
+  const silence = new SilenceLimit(socket, control);
+  silence.start(route.timeoutMs, "UpstreamTimeout");
+  const response = await exchangeHeaders(socket, upstream, control.signal);
+  silence.start(idleLimitMs(route.timeoutMs), "UpstreamIdle");
+  return { response, silence };
+}
+
+// src/relay/relay.ts
+var MESSAGES_PATH = "/v1/messages";
+var ERROR_BODY_LIMIT = 65536;
+var DENIAL_BODY = JSON.stringify({
+  type: "error",
+  error: { type: "invalid_request_error", message: "DSH_MODEL_ADMISSION_CONSUMED" }
+});
+var RelayRecord = class {
+  used = false;
+  denied = 0;
+  cancelled = false;
+  status = null;
+  requestId = null;
+  retryAfterMs = null;
+  failure = null;
+  unrestored = null;
+  errorBody = Buffer.alloc(0);
+  keepErrorBytes(chunk) {
+    const room = ERROR_BODY_LIMIT - this.errorBody.length;
+    if (room > 0) this.errorBody = Buffer.concat([this.errorBody, chunk.subarray(0, room)]);
+  }
+};
+function restoreQueried(payload, options) {
+  try {
+    return { payload: restoreQueriedTurn(payload, options.queried), unrestored: null };
+  } catch (error) {
+    if (!(error instanceof QueriedTurnMismatch)) throw error;
+    return { payload, unrestored: error.message };
+  }
+}
+function rewriteAdmitted(received, options) {
+  const start = options.oneShot ? dropMessageBreakpoints(received) : received;
+  const { payload: restored, unrestored } = restoreQueried(start, options);
+  const stable = stableRequestContext(restored, options.queried);
+  const pinned = pinMessageBreakpoint(stable, options.queried);
+  return { payload: streamToolInput(pinned), unrestored };
+}
+function upstreamErrorText(body) {
+  const text = body.toString("utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return text;
+  }
+  const message = parsed?.error?.message;
+  return typeof message === "string" ? message : text;
+}
+function failureName(error) {
+  if (error instanceof LocalFailure) return error.name;
+  const code = error?.code;
+  if (typeof code === "string" && /^[A-Z][A-Z0-9_]*$/.test(code)) return code;
+  return error instanceof Error && /^\w+$/.test(error.name) ? error.name : "UnknownRelayFailure";
+}
+function splitRequestTarget(requestUrl = "") {
+  const start = requestUrl.indexOf("?");
+  return start < 0 ? { path: requestUrl, query: "" } : { path: requestUrl.slice(0, start), query: requestUrl.slice(start) };
+}
+function classifyRequest(request, messagesRoute) {
+  if (request.method !== "POST") return "unsupportedMethod";
+  const { path } = splitRequestTarget(request.url);
+  return path === messagesRoute && !request.headers.origin ? "messages" : "unknownRoute";
+}
+function ignoreError2() {
+}
+function answerLocally(request, response, status, body = "") {
+  request.once("end", () => {
+    response.writeHead(status, {
+      ...body === "" ? {} : { "Content-Type": "application/json" },
+      "Content-Length": Buffer.byteLength(body),
+      Connection: "close"
+    });
+    response.end(body);
+  });
+  request.resume();
+}
+async function readBody(request, control, stallMs) {
+  const onStall = () => {
+    control.abort(new LocalFailure("ClientStalled"));
+    request.destroy();
+  };
+  request.socket.setTimeout(stallMs, onStall);
+  try {
+    const chunks = [];
+    for await (const chunk of request) chunks.push(chunk);
+    return Buffer.concat(chunks);
+  } finally {
+    request.socket.setTimeout(0);
+    request.socket.off("timeout", onStall);
+  }
+}
+async function waitForDrain(response, silence, control, stallMs) {
+  silence.suspend();
+  const stall = setTimeout(() => control.abort(new LocalFailure("ClientStalled")), stallMs);
+  try {
+    await once2(response, "drain", { signal: control.signal });
+  } finally {
+    clearTimeout(stall);
+  }
+  silence.resume();
+}
+var LoopbackRelay = class {
+  #capture = new SseCapture();
+  #record = new RelayRecord();
+  #connections = /* @__PURE__ */ new Set();
+  #options;
+  #route;
+  #gzipOrigins;
+  #prefix = `/admit/${randomBytes2(32).toString("base64url")}`;
+  #server;
+  #url = "";
+  #call = null;
+  #exchange = null;
+  #closing = null;
+  constructor(options, route, gzipOrigins) {
+    this.#options = options;
+    this.#route = route;
+    this.#gzipOrigins = gzipOrigins;
+    const receiveLimitMs = Math.ceil(options.timeoutMs);
+    this.#server = createServer(
+      { headersTimeout: receiveLimitMs, requestTimeout: receiveLimitMs },
+      (request, response) => this.#onRequest(request, response)
+    );
+    this.#server.on("connection", (socket) => this.#onConnection(socket));
+    this.#server.on("clientError", (_error, socket) => socket.destroy());
+  }
+  async listen() {
+    this.#server.listen(0, "127.0.0.1");
+    await once2(this.#server, "listening");
+    this.#server.on("error", ignoreError2);
+    const { port } = this.#server.address();
+    this.#url = `http://127.0.0.1:${port}${this.#prefix}`;
+  }
+  get url() {
+    return this.#url;
+  }
+  get used() {
+    return this.#record.used;
+  }
+  get denied() {
+    return this.#record.denied;
+  }
+  get status() {
+    return this.#record.status;
+  }
+  get failure() {
+    return this.#record.failure;
+  }
+  get requestId() {
+    return this.#record.requestId;
+  }
+  get retryAfterMs() {
+    return this.#record.retryAfterMs;
+  }
+  get unrestored() {
+    return this.#record.unrestored;
+  }
+  get capture() {
+    return this.#capture;
+  }
+  errorText() {
+    return upstreamErrorText(this.#record.errorBody);
+  }
+  abort() {
+    this.#record.cancelled = true;
+    this.#call?.abort(new LocalFailure("RelayAborted"));
+    for (const socket of this.#connections) socket.destroy();
+  }
+  close() {
+    this.#closing ??= this.#shutDown();
+    return this.#closing;
+  }
+  async #shutDown() {
+    this.abort();
+    await new Promise((resolve) => {
+      this.#server.close(() => resolve());
+      this.#server.closeAllConnections();
+    });
+    await this.#exchange;
+  }
+  #onConnection(socket) {
+    socket.on("error", ignoreError2);
+    if (this.#record.cancelled) {
+      socket.destroy();
+      return;
+    }
+    this.#connections.add(socket);
+    socket.once("close", () => this.#connections.delete(socket));
+  }
+  #onRequest(request, response) {
+    request.on("error", ignoreError2);
+    response.on("error", ignoreError2);
+    const kind = classifyRequest(request, `${this.#prefix}${MESSAGES_PATH}`);
+    if (kind === "unsupportedMethod") {
+      answerLocally(request, response, 501);
+    } else if (kind === "unknownRoute") {
+      answerLocally(request, response, 404);
+    } else if (this.#record.cancelled || this.#record.used) {
+      this.#record.denied += 1;
+      answerLocally(request, response, 400, DENIAL_BODY);
+    } else {
+      this.#record.used = true;
+      this.#exchange = this.#serveAdmitted(request, response);
+    }
+  }
+  /** Never rejects: a rejection here would crash the host process. */
+  async #serveAdmitted(request, response) {
+    const control = new AbortController();
+    this.#call = control;
+    response.once("close", () => {
+      if (!response.writableFinished) control.abort(new LocalFailure("ClientDisconnected"));
+    });
+    try {
+      const received = await readBody(request, control, this.#options.timeoutMs);
+      const upstream = await this.#buildUpstreamRequest(request, received);
+      const call = await openUpstream(this.#route, upstream, control);
+      await this.#forwardResponse(call, response, control);
+      control.signal.throwIfAborted();
+      response.end();
+    } catch (error) {
+      this.#recordFailure(control.signal.aborted ? control.signal.reason : error);
+      response.destroy();
+    } finally {
+      control.abort();
+    }
+  }
+  async #buildUpstreamRequest(request, received) {
+    const { payload, unrestored } = rewriteAdmitted(received, this.#options);
+    this.#record.unrestored = unrestored;
+    const { target, proxy } = this.#route;
+    const gzip2 = gzipEligible({
+      target,
+      proxy,
+      env: this.#options.env,
+      gzipOrigins: this.#gzipOrigins,
+      payloadBytes: payload.length,
+      contentEncoding: request.headers["content-encoding"]
+    });
+    const body = gzip2 ? await gzipRequestBody(payload) : payload;
+    return {
+      path: `${target.basePath}${MESSAGES_PATH}${splitRequestTarget(request.url).query}`,
+      headers: upstreamRequestHeaders(request.rawHeaders, {
+        target,
+        bodyBytes: body.length,
+        gzip: gzip2
+      }),
+      body
+    };
+  }
+  async #forwardResponse(call, response, control) {
+    const upstream = call.response;
+    const status = upstream.statusCode;
+    const requestId = upstream.headers["request-id"] || upstream.headers["x-request-id"];
+    this.#record.status = status;
+    this.#record.requestId = typeof requestId === "string" ? requestId : null;
+    this.#record.retryAfterMs = retryAfterMs(upstream.headers["retry-after"], Date.now());
+    response.writeHead(status, upstream.statusMessage, clientResponseHeaders(upstream.rawHeaders));
+    response.flushHeaders();
+    for await (const chunk of upstream) {
+      if (status === 200) this.#capture.feed(chunk);
+      else this.#record.keepErrorBytes(chunk);
+      if (!response.write(chunk)) {
+        await waitForDrain(response, call.silence, control, this.#options.timeoutMs);
+      }
+    }
+  }
+  #recordFailure(reason) {
+    if (!this.#capture.complete) this.#record.failure ??= failureName(reason);
+  }
+};
+async function startRelay(options, policy) {
+  const target = parseUpstreamUrl(options.upstream);
+  const proxy = selectProxy(target, options.env);
+  const route = { target, proxy, tls: policy.tls, timeoutMs: options.timeoutMs };
+  const relay = new LoopbackRelay(options, route, policy.gzipOrigins);
+  try {
+    await relay.listen();
+  } catch (error) {
+    throw new NativeFailure("Could not start the local relay", FailureCode.relayError, {
+      cause: error
+    });
+  }
+  return relay;
+}
+var createRelay = (options) => startRelay(options, DEFAULT_UPSTREAM_POLICY);
+
+// src/request/images.ts
+var MAX_REQUEST_IMAGE_PIXELS = 2048 * 2048;
+var MAX_REQUEST_IMAGE_BYTES = 1024 * 1024;
+var MAX_REQUEST_IMAGES_BASE64_BYTES = 20 * 1024 * 1024;
+var EXTENSIONS = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/webp": ".webp",
+  "image/gif": ".gif"
+};
+function scaledDimensions(width, height) {
+  const scale = Math.min(1, Math.sqrt(MAX_REQUEST_IMAGE_PIXELS / (width * height)));
+  if (scale === 1) return { width, height };
+  const longSide = Math.max(width, height);
+  const shortSide = Math.min(width, height);
+  let long = Math.max(1, Math.floor(longSide * scale));
+  let short = Math.max(1, Math.round(long * shortSide / longSide));
+  while (long * short > MAX_REQUEST_IMAGE_PIXELS && long > 1) {
+    long -= 1;
+    short = Math.max(1, Math.round(long * shortSide / longSide));
+  }
+  return width >= height ? { width: long, height: short } : { width: short, height: long };
+}
+function imageRequestTarget(ref) {
+  return { ...scaledDimensions(ref.width, ref.height), maxBytes: MAX_REQUEST_IMAGE_BYTES };
+}
+function imageIdentity(ref) {
+  return ref.name === void 0 ? String(ref.attachmentId) : `${JSON.stringify(ref.name)} (${ref.attachmentId})`;
+}
+function accessText(ref, access) {
+  return ` Normalized copy (read-only; may be resized or re-encoded): ${JSON.stringify(access.readonlyPath)} (${ref.width}x${ref.height}px, ${ref.mediaType}). Source dimensions, format, and byte size may differ. Copy to a writable path ending in ${EXTENSIONS[ref.mediaType]} before editing.`;
+}
+function imageHandleText(ref, version, access) {
+  const preview = `Image ${imageIdentity(ref)}; request preview ${version.width}x${version.height}px.`;
+  if (access !== void 0) return preview + accessText(ref, access);
+  return `${preview} It may be resized or re-encoded; source dimensions, format, and byte size may differ.`;
+}
+function offloadedImageText(ref, access) {
+  const identity = `image omitted to fit request image limits; ${imageIdentity(ref)}.`;
+  if (access !== void 0) return `[${identity}${accessText(ref, access)}]`;
+  return `[${identity} No local normalized image path is available; ask the user to attach it again if needed.]`;
+}
+function requestVersionOf(block, images) {
+  const version = images.get(String(block.attachment.attachmentId));
+  if (version === void 0) {
+    throw new NativeFailure("An image of the request was not read", FailureCode.invalidRequest);
+  }
+  return version;
+}
+function imageBlocksOf(message) {
+  return message.content.filter((block) => block.type === "image");
+}
+function retainedImageBlocks(messages) {
+  return messages.filter((message) => message.role === "user" || message.role === "tool").flatMap(imageBlocksOf).filter((block) => block.offloaded !== true);
+}
+async function readRequestImages(messages, reader, signal) {
+  const blocks = messages.flatMap(imageBlocksOf);
+  if (blocks.length === 0) return /* @__PURE__ */ new Map();
+  if (reader === void 0) {
+    throw new NativeFailure(
+      "Images need the attachment service, which is not available",
+      FailureCode.invalidRequest
+    );
+  }
+  const refs = /* @__PURE__ */ new Map();
+  for (const block of retainedImageBlocks(messages)) {
+    refs.set(String(block.attachment.attachmentId), block.attachment);
+  }
+  const entries = await Promise.all(
+    [...refs].map(async ([id, ref]) => {
+      const version = await reader.readImageRequest(ref, imageRequestTarget(ref), signal);
+      return [id, version];
+    })
+  );
+  return new Map(entries);
+}
+function base64Length(bytes) {
+  return Math.ceil(bytes / 3) * 4;
+}
+function requiredImageOffload(messages, images) {
+  const lengths = retainedImageBlocks(messages).map(
+    (block) => base64Length(requestVersionOf(block, images).data.byteLength)
+  );
+  const excess = lengths.reduce((sum, length) => sum + length, 0) - MAX_REQUEST_IMAGES_BASE64_BYTES;
+  if (excess <= 0) return 0;
+  let removed2 = 0;
+  let count = 0;
+  for (const length of lengths) {
+    if (removed2 >= excess) break;
+    removed2 += length;
+    count += 1;
+  }
+  return count;
+}
+function assertImagesFit(messages, images) {
+  const offloadImages = requiredImageOffload(messages, images);
+  if (offloadImages === 0) return;
+  throw new NativeFailure(
+    `Request images exceed the ${MAX_REQUEST_IMAGES_BASE64_BYTES}-byte base64 bound; ${offloadImages} more oldest occurrence(s) must be offloaded.`,
+    FailureCode.imageOffloadRequired,
+    { offloadImages }
+  );
+}
+
+// src/request/generation.ts
+var OFF_EFFORT = "off";
+var REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+var LOWEST_EFFORT = REASONING_EFFORTS[0];
+function invalid(message) {
+  return new NativeFailure(message, FailureCode.invalidRequest);
+}
+function isKnownEffort(effort) {
+  return effort === OFF_EFFORT || REASONING_EFFORTS.includes(effort);
+}
+function reasoningOff(model) {
+  if (acceptsThinkingDisable(model)) {
+    return {
+      body: { thinking: { type: "disabled" }, context_management: { edits: [] } }
+    };
+  }
+  return { body: { output_config: { effort: LOWEST_EFFORT } }, effort: LOWEST_EFFORT };
+}
+function reasoningOn(model, effort) {
+  const body = {};
+  if (supportsAdaptiveThinking(model)) {
+    body.thinking = { type: "adaptive", display: "summarized" };
+  }
+  if (effort !== void 0) body.output_config = { effort };
+  return effort === void 0 ? { body } : { body, effort };
+}
+function reasoningOf(model, effort) {
+  if (effort !== void 0 && !isKnownEffort(effort)) {
+    throw invalid(`Unsupported reasoning effort: ${effort}`);
+  }
+  return effort === OFF_EFFORT ? reasoningOff(model) : reasoningOn(model, effort);
+}
+function checkTemperature(temperature) {
+  if (!Number.isFinite(temperature) || temperature < 0 || temperature > 1) {
+    throw invalid("temperature must be finite and between zero and one");
+  }
+}
+function checkMaxTokens(maxTokens) {
+  if (!Number.isInteger(maxTokens) || maxTokens < 1) {
+    throw invalid("maxTokens must be a positive integer");
+  }
+}
+function checkStop(stop) {
+  if (stop.some((sequence) => sequence === "")) {
+    throw invalid("stop must be a list of nonempty strings");
+  }
+}
+function generationOf(input) {
+  const reasoning = reasoningOf(input.model, input.reasoningEffort);
+  const body = { ...reasoning.body };
+  if (input.temperature !== void 0) checkTemperature(input.temperature);
+  if (input.maxTokens !== void 0) {
+    checkMaxTokens(input.maxTokens);
+    body.max_tokens = input.maxTokens;
+  }
+  if (input.stop !== void 0) {
+    checkStop(input.stop);
+    body.stop_sequences = [...input.stop];
+  }
+  return {
+    body,
+    ...reasoning.effort === void 0 ? {} : { effort: reasoning.effort },
+    ...input.maxTokens === void 0 ? {} : { maxOutputTokens: input.maxTokens }
+  };
+}
+
+// src/request/model-info.ts
+var EFFORT_NAMES = {
+  [OFF_EFFORT]: "Off",
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra high",
+  max: "Max"
+};
+function effortInfo(id) {
+  return { id, name: EFFORT_NAMES[id] ?? id };
+}
+function effortsOf(model) {
+  const ids = acceptsThinkingDisable(model) ? [OFF_EFFORT, ...REASONING_EFFORTS] : REASONING_EFFORTS;
+  return ids.map(effortInfo);
+}
+function modelInfo(provider, model) {
+  const contextWindow = contextWindowOf(model);
+  return {
+    provider,
+    id: model,
+    name: model,
+    inputModalities: ["text", "image"],
+    ...contextWindow === void 0 ? {} : { context: { contextWindow } },
+    reasoning: { efforts: effortsOf(model) }
+  };
+}
+
+// src/request/replay.ts
+import { isDeepStrictEqual } from "node:util";
+var CARRIER_KIND = "claude-subscription";
+var CARRIER_VERSION = 1;
+function parseToolArguments(toolName, raw) {
+  try {
+    return JSON.parse(raw);
+  } catch (cause) {
+    throw new NativeFailure(
+      `Arguments of the tool call to ${toolName} are not valid JSON`,
+      FailureCode.invalidRequest,
+      { cause }
+    );
+  }
+}
+function projectionOf(content) {
+  const text = content.flatMap((block) => block.type === "text" ? [block.text] : []);
+  const toolCalls = content.flatMap(
+    (block) => block.type === "tool-call" ? [{ id: block.id, name: block.name, input: parseToolArguments(block.name, block.arguments) }] : []
+  );
+  return { content: text.join("").trim(), toolCalls };
+}
+function isObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isReplayCarrier(value) {
+  return isObject3(value) && value.kind === CARRIER_KIND && value.version === CARRIER_VERSION && Array.isArray(value.messages) && isObject3(value.projection);
+}
+function replayableTurns(message, requestModel) {
+  const state = message.source.replayState;
+  const carrier = isObject3(state) ? state.response : void 0;
+  if (!isReplayCarrier(carrier)) return void 0;
+  if (nativeModel(message.source.model) !== requestModel) return void 0;
+  return isDeepStrictEqual(carrier.projection, projectionOf(message.content)) ? carrier.messages : void 0;
+}
+
+// src/request/history.ts
+function invalid2(message) {
+  return new NativeFailure(message, FailureCode.invalidRequest);
+}
+function textBlock(text) {
+  return { type: "text", text };
+}
+function imageBlocks(block, ctx) {
+  const access = ctx.imageAccess(block.attachment);
+  if (block.offloaded === true) return [textBlock(offloadedImageText(block.attachment, access))];
+  const version = requestVersionOf(block, ctx.images);
+  return [
+    textBlock(imageHandleText(block.attachment, version, access)),
+    {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: version.mediaType,
+        data: Buffer.from(version.data).toString("base64")
+      }
+    }
+  ];
+}
+function inputBlocks(content, ctx) {
+  return content.flatMap((block) => {
+    if (block.type === "text") return block.text.length > 0 ? [textBlock(block.text)] : [];
+    if (block.type === "image") return imageBlocks(block, ctx);
+    throw invalid2(`Content of type ${block.type} cannot be sent`);
+  });
+}
+function developerBlocks(message) {
+  return message.content.flatMap((block) => {
+    if (block.type === "text") return block.text.length > 0 ? [textBlock(block.text)] : [];
+    if (block.type === "tool-addition" || block.type === "tool-removal") return [];
+    throw invalid2(`Developer content of type ${block.type} cannot be sent`);
+  });
+}
+function toolResultBlock(message, ctx) {
+  const parts = inputBlocks(message.content, ctx);
+  const onlyText = parts.every((part) => part.type === "text");
+  const content = onlyText ? parts.map((part) => String(part.text)).join("") : parts;
+  return {
+    type: "tool_result",
+    tool_use_id: message.toolCallId,
+    content,
+    ...message.isError === true ? { is_error: true } : {}
+  };
+}
+function nativeNameOf(name2, toolNames) {
+  const nativeName = toolNames.get(name2);
+  return nativeName === void 0 ? name2 : `${TOOL_PREFIX}${nativeName}`;
+}
+function canonicalBlocks(message, toolNames) {
+  return message.content.flatMap((block) => {
+    switch (block.type) {
+      case "text":
+        return block.text.length > 0 ? [textBlock(block.text)] : [];
+      case "tool-call":
+        return [
+          {
+            type: "tool_use",
+            id: block.id,
+            name: nativeNameOf(block.name, toolNames),
+            input: parseToolArguments(block.name, block.arguments)
+          }
+        ];
+      case "image":
+        throw invalid2("An image in an assistant message cannot be sent");
+      default:
+        return [];
+    }
+  });
+}
+function replayedFrame(turn) {
+  const { usage: _usage, ...message } = structuredClone(turn);
+  return { type: "assistant", message };
+}
+function assistantFrames(message, ctx) {
+  const turns = replayableTurns(message, ctx.nativeModel);
+  if (turns !== void 0) return turns.map(replayedFrame);
+  const content = canonicalBlocks(message, ctx.toolNames);
+  return content.length === 0 ? [] : [{ type: "assistant", message: { role: "assistant", content } }];
+}
+function appendUserBlocks(frames, blocks) {
+  if (blocks.length === 0) return;
+  const last = frames.at(-1);
+  if (last?.type === "user") last.message.content.push(...blocks);
+  else frames.push({ type: "user", message: { role: "user", content: blocks } });
+}
+function shieldFromCommandParsing(frame) {
+  if (frame.type !== "user") return;
+  const { content } = frame.message;
+  const last = content.at(-1);
+  if (last?.type !== "text" || !String(last.text).startsWith("/")) return;
+  content[content.length - 1] = { ...last, text: ` ${last.text}` };
+}
+function framesOf(messages, ctx) {
+  const frames = [];
+  for (const message of messages) {
+    switch (message.role) {
+      case "assistant":
+        frames.push(...assistantFrames(message, ctx));
+        break;
+      case "tool":
+        appendUserBlocks(frames, [toolResultBlock(message, ctx)]);
+        break;
+      case "developer":
+        appendUserBlocks(frames, developerBlocks(message));
+        break;
+      case "user":
+        appendUserBlocks(frames, inputBlocks(message.content, ctx));
+        break;
+      case "system":
+        throw invalid2("System messages must come before the conversation history");
+    }
+  }
+  frames.forEach(shieldFromCommandParsing);
+  return frames;
+}
+
+// src/request/session-id.ts
+import { createHash } from "node:crypto";
+var VERSION_4 = 64;
+var VARIANT_RFC_4122 = 128;
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function formatUuid(bytes) {
+  const hex = Buffer.from(bytes).toString("hex");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20)
+  ].join("-");
+}
+function conversationSessionId(system, frames) {
+  const first = frames[0]?.message ?? null;
+  const digest = createHash("sha256").update(canonicalJson([system, first]), "utf8").digest();
+  const bytes = digest.subarray(0, 16);
+  bytes[6] = (bytes[6] ?? 0) & 15 | VERSION_4;
+  bytes[8] = (bytes[8] ?? 0) & 63 | VARIANT_RFC_4122;
+  return formatUuid(bytes);
+}
+
+// src/request/tools.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// src/request/schema.ts
+var UNION_KEYS = ["anyOf", "oneOf"];
+var UNION_META_KEYS = ["title", "description", "default", "examples"];
+var BANNED_TOP_LEVEL_KEYS = ["oneOf", "allOf", "anyOf"];
+function isObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rewrite(node, visit) {
+  if (Array.isArray(node)) return node.map((item) => rewrite(item, visit));
+  if (!isObject4(node)) return node;
+  const children = Object.fromEntries(
+    Object.entries(node).map(([key, value]) => [key, rewrite(value, visit)])
+  );
+  return visit(children);
+}
+function isNullBranch(branch) {
+  return isObject4(branch) && branch.type === "null";
+}
+function carryUnionMeta(outer, replacement) {
+  for (const key of UNION_META_KEYS) {
+    if (!Object.hasOwn(outer, key) || Object.hasOwn(replacement, key)) continue;
+    if (key === "default" && Object.hasOwn(replacement, "$ref")) continue;
+    replacement[key] = outer[key];
+  }
+}
+function collapseNullableUnion(union) {
+  for (const key of UNION_KEYS) {
+    const variants = union[key];
+    if (!Array.isArray(variants)) continue;
+    const nonNull = variants.filter((branch) => !isNullBranch(branch));
+    if (nonNull.length !== 1 || nonNull.length === variants.length) continue;
+    const survivor = nonNull[0];
+    const replacement = isObject4(survivor) ? { ...survivor } : {};
+    carryUnionMeta(union, replacement);
+    return rewrite(replacement, collapseNullableUnion);
+  }
+  return union;
+}
+function stripNullableUnions(schema) {
+  return rewrite(schema, collapseNullableUnion);
+}
+function normalizeInputSchema(schema) {
+  let normalized = stripNullableUnions(schema);
+  if (BANNED_TOP_LEVEL_KEYS.some((key) => key in normalized)) {
+    normalized = Object.fromEntries(
+      Object.entries(normalized).filter(
+        ([key]) => !BANNED_TOP_LEVEL_KEYS.includes(key)
+      )
+    );
+    if (!("type" in normalized)) normalized.type = "object";
+  }
+  if (normalized.type === "object" && !isObject4(normalized.properties)) {
+    normalized = { ...normalized, properties: {} };
+  }
+  return normalized;
+}
+
+// src/request/tools.ts
+var VALID_NAME = /^[A-Za-z0-9_-]{1,64}$/;
+var MAX_NATIVE_NAME_LENGTH = 50;
+var ALIAS_STEM_LENGTH = 41;
+var ALIAS_DIGEST_LENGTH = 8;
+function nativeNameOf2(name2) {
+  if (name2.length <= MAX_NATIVE_NAME_LENGTH) return name2;
+  const digest = createHash2("sha256").update(name2).digest("hex").slice(0, ALIAS_DIGEST_LENGTH);
+  return `${name2.slice(0, ALIAS_STEM_LENGTH)}_${digest}`;
+}
+function declareTools(tools) {
+  const names = /* @__PURE__ */ new Map();
+  const owners = /* @__PURE__ */ new Map();
+  const manifest = [];
+  const wire = [];
+  for (const tool of tools) {
+    if (!VALID_NAME.test(tool.name) || names.has(tool.name)) {
+      throw new NativeFailure(
+        "Tool names must be unique ASCII identifiers of at most 64 characters",
+        FailureCode.invalidRequest
+      );
+    }
+    const nativeName = nativeNameOf2(tool.name);
+    const owner = owners.get(nativeName);
+    if (owner !== void 0) {
+      throw new NativeFailure(
+        `Tool name collision: ${JSON.stringify(tool.name)} and ${JSON.stringify(owner)} map to ${JSON.stringify(nativeName)}`,
+        FailureCode.invalidRequest
+      );
+    }
+    names.set(tool.name, nativeName);
+    owners.set(nativeName, tool.name);
+    const inputSchema = normalizeInputSchema(tool.parameters);
+    manifest.push({ name: nativeName, description: tool.description, inputSchema });
+    wire.push({
+      name: `${TOOL_PREFIX}${nativeName}`,
+      description: tool.description,
+      input_schema: inputSchema
+    });
+  }
+  return { manifest, wire, names };
+}
+
+// src/request/prepare.ts
+function invalid3(message) {
+  return new NativeFailure(message, FailureCode.invalidRequest);
+}
+function systemText(message) {
+  return message.content.map((block) => {
+    if (block.type !== "text") throw invalid3("System messages must contain text only");
+    return block.text;
+  }).join("");
+}
+function splitSystemPrompt(options) {
+  const texts = [options.system];
+  let end = 0;
+  for (const message of options.messages) {
+    if (message.role !== "system") break;
+    texts.push(systemText(message));
+    end += 1;
+  }
+  return {
+    system: texts.filter((text) => text !== void 0 && text !== "").join("\n\n"),
+    history: options.messages.slice(end)
+  };
+}
+function assertEndsWithUserTurn(frames) {
+  const last = frames.at(-1);
+  if (last?.type !== "user" || last.message.content.length === 0) {
+    throw invalid3("History must end in a nonempty user or tool-result message");
+  }
+}
+async function prepareRequest(options, deps) {
+  if (options.model === "") throw invalid3("A model is required");
+  const model = nativeModel(options.model);
+  const generation = generationOf(options);
+  const { system, history } = splitSystemPrompt(options);
+  const declarations = declareTools(options.tools ?? []);
+  const images = await readRequestImages(history, deps.attachments(), options.signal);
+  assertImagesFit(history, images);
+  const frames = framesOf(history, {
+    nativeModel: model,
+    toolNames: declarations.names,
+    images,
+    imageAccess: deps.imageAccess
+  });
+  assertEndsWithUserTurn(frames);
+  return {
+    nativeModel: model,
+    system,
+    frames,
+    extraBody: { ...generation.body, tools: declarations.wire },
+    ...generation.effort === void 0 ? {} : { effort: generation.effort },
+    ...generation.maxOutputTokens === void 0 ? {} : { maxOutputTokens: generation.maxOutputTokens },
+    manifest: declarations.manifest,
+    toolNames: declarations.names,
+    sessionId: conversationSessionId(system, frames),
+    oneShot: options.purpose !== void 0 && declarations.manifest.length === 0 && frames.length === 1
+  };
+}
+
+// src/index.ts
+var name = PROVIDER_ID;
+var inject = ["llm", "subprocess"];
+var DISPLAY_NAME = "Claude Subscription";
+function settingsNamespace(ctx) {
+  const id = ctx.fiber.entry?.options?.id;
+  if (typeof id !== "string" || id === "") {
+    throw new Error(
+      `${PROVIDER_ID}: the loader gave this plugin no entry id, so its settings row cannot be found`
+    );
+  }
+  return id;
+}
+function imageAccessOf(ctx, ref) {
+  const hostPath = ctx.get("attachments")?.imageHostPath(ref);
+  if (hostPath === void 0) return void 0;
+  const mapper = ctx.get("fs");
+  const readonlyPath = mapper?.processPathFromHostPath(hostPath);
+  return readonlyPath === void 0 ? void 0 : { readonlyPath };
+}
+function apply(ctx, config) {
+  const native = {
+    subprocess: ctx.subprocess,
+    createRelay,
+    settings: () => readSettings(config),
+    processEnv: () => process.env,
+    inertMcpPath: fileURLToPath(new URL("./inert-mcp.js", import.meta.url)),
+    nodePath: process.execPath
+  };
+  const entry = {
+    provider: PROVIDER_ID,
+    displayName: DISPLAY_NAME,
+    settingsNs: settingsNamespace(ctx),
+    settingsPath: []
+  };
+  const directory = ctx.llm.registerConfigurableProviders([entry]);
+  let reported;
+  ctx.llm.registerAdapter(
+    [PROVIDER_ID],
+    new ClaudeSubscriptionAdapter({
+      prepare: (options) => prepareRequest(options, {
+        attachments: () => ctx.get("attachments"),
+        imageAccess: (ref) => imageAccessOf(ctx, ref)
+      }),
+      run: runNative,
+      discover: discoverModels,
+      modelInfo,
+      imageTarget: imageRequestTarget,
+      projectionOf,
+      native,
+      reportDiscovery: (error) => {
+        if (error === reported) return;
+        reported = error;
+        directory.replace([error === void 0 ? entry : { ...entry, error }]);
+      },
+      warn: (message) => ctx.logger.warn(message)
+    })
+  );
+}
+export {
+  Config,
+  apply,
+  inject,
+  name
+};