@amir83nasr/10router 0.1.14 → 0.1.15

package/open-sse/handlers/chatCore/sseToJsonHandler.js

@@ -10,7 +10,12 @@ import {
   saveUsageStats,
   formatDoneLine,
 } from "./requestDetail.js";
-import { ROLE, RESPONSES_ITEM } from "../../translator/schema/index.js";
+import { ROLE, RESPONSES_ITEM, CLAUDE_BLOCK } from "../../translator/schema/index.js";
+import {
+  chatCompletionToClaudeMessage,
+  claudeMessageToChatCompletion,
+  parseClaudeSSEToMessage,
+} from "./claudeMessageBody.js";
 
 // Responses-API providers (e.g. codex) may emit SSE without content-type + use Responses output shape
 const isResponsesProvider = (p) => PROVIDERS[p]?.format === FORMATS.OPENAI_RESPONSES;
@@ -227,10 +232,15 @@ export async function handleForcedSSEToJson({
   log,
 }) {
   const contentType = providerResponse.headers.get("content-type") || "";
+  // Responses-API providers (codex) are known to stream without a content type;
+  // for every other provider an absent header means the body is not a stream we
+  // may consume here — returning null leaves it intact for the JSON handler.
   const isSSE =
     contentType.includes("text/event-stream") ||
     (contentType === "" && isResponsesProvider(provider));
-  if (!isSSE) return null; // not handled here
+  // Not an aggregated stream — the caller falls back to the JSON handler. The
+  // pending counter must stay untouched here: this handler did not serve it.
+  if (!isSSE) return null;
 
   trackDone();
 
@@ -251,6 +261,15 @@ export async function handleForcedSSEToJson({
   if (isCodexResponsesApi) {
     try {
       const jsonResponse = await convertResponsesStreamToJson(providerResponse.body);
+      // A `response.failed` event is the upstream's own failure signal; an empty
+      // "successful" body would hide it from the client.
+      if (jsonResponse.status === "failed") {
+        appendLog({ status: `FAILED ${HTTP_STATUS.BAD_GATEWAY}` });
+        return createErrorResult(
+          HTTP_STATUS.BAD_GATEWAY,
+          "Upstream Responses stream reported failure",
+        );
+      }
       if (onRequestSuccess) await onRequestSuccess();
 
       const usage = jsonResponse.usage || {};
@@ -345,7 +364,36 @@ export async function handleForcedSSEToJson({
       }));
       const hasToolCalls = toolCalls.length > 0;
 
-      if (sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI) {
+      if (sourceFormat === FORMATS.CLAUDE) {
+        // The client speaks Anthropic Messages: reuse the same conversion a
+        // chat-native upstream gets, so both forced-stream upstream dialects
+        // produce one identical Claude body.
+        finalResp = chatCompletionToClaudeMessage({
+          id: jsonResponse.id,
+          created: jsonResponse.created_at,
+          model: jsonResponse.model || model,
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: ROLE.ASSISTANT,
+                content: textContent,
+                ...(hasToolCalls ? { tool_calls: toolCalls } : {}),
+              },
+              finish_reason: hasToolCalls
+                ? "tool_calls"
+                : jsonResponse.status === "completed" || jsonResponse.status === "done"
+                  ? "stop"
+                  : jsonResponse.status || "stop",
+            },
+          ],
+          usage: {
+            prompt_tokens: inTokens,
+            completion_tokens: outTokens,
+            ...cacheDetails,
+          },
+        });
+      } else if (sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI) {
         finalResp = {
           response: {
             candidates: [
@@ -406,6 +454,94 @@ export async function handleForcedSSEToJson({
   // Standard Chat Completions SSE path
   try {
     const sseText = await providerResponse.text();
+
+    // A provider that speaks Claude on the wire (opencode's `union-alpha`, any
+    // anthropic-compatible endpoint) streams Anthropic events, which the chat
+    // aggregator cannot fold — it would produce an empty message. Aggregate in
+    // the format the upstream actually used.
+    //
+    // `targetFormat` is what we asked for, not proof of what came back: some
+    // providers answer their Claude transport in OpenAI dialect. The aggregator
+    // returns null when no Anthropic event was seen, and the standard chat path
+    // below then handles the body it really is.
+    const isClaudeUpstream =
+      targetFormat === FORMATS.CLAUDE || /"type"\s*:\s*"message_start"/.test(sseText);
+    const claudeMessage = isClaudeUpstream ? parseClaudeSSEToMessage(sseText, model) : null;
+    if (claudeMessage) {
+      const message = claudeMessage;
+      if (message.error) {
+        const upstreamCode = String(message.error.code || "");
+        const status =
+          message.error.type === "invalid_request_error" ||
+          upstreamCode === "context_length_exceeded" ||
+          upstreamCode === "bad_request"
+            ? HTTP_STATUS.BAD_REQUEST
+            : HTTP_STATUS.BAD_GATEWAY;
+        return createErrorResult(status, message.error.message || "Upstream SSE stream failed");
+      }
+
+      if (onRequestSuccess) await onRequestSuccess();
+
+      const usage = message.usage || {};
+      appendLog({ tokens: usage, status: "200 OK" });
+      saveUsageStats({
+        provider,
+        model,
+        tokens: usage,
+        connectionId,
+        apiKey,
+        endpoint: clientRawRequest?.endpoint,
+        silent: true,
+      });
+      if (log?.line)
+        log.line(
+          reqTag,
+          "DONE",
+          formatDoneLine({ usage, latency: { total: Date.now() - requestStartTime } }),
+        );
+
+      const totalLatency = Date.now() - requestStartTime;
+      const textBlocks = (message.content || []).filter((b) => b.type === CLAUDE_BLOCK.TEXT);
+      const thinkingBlocks = (message.content || []).filter(
+        (b) => b.type === CLAUDE_BLOCK.THINKING,
+      );
+      saveRequestDetail(
+        buildRequestDetail(
+          {
+            ...ctx,
+            latency: { ttft: totalLatency, total: totalLatency },
+            tokens: {
+              prompt_tokens: usage.input_tokens || 0,
+              completion_tokens: usage.output_tokens || 0,
+            },
+            response: {
+              content: textBlocks.map((b) => b.text || "").join("") || null,
+              thinking: thinkingBlocks.map((b) => b.thinking || "").join("") || null,
+              finish_reason: message.stop_reason || "unknown",
+            },
+            status: "success",
+          },
+          { endpoint: clientRawRequest?.endpoint || null },
+        ),
+      ).catch(() => {});
+
+      // Claude → chat conversion only when the client asked for chat; a Claude
+      // client (or any other) receives the aggregated message unchanged.
+      const finalBody =
+        sourceFormat === FORMATS.CLAUDE
+          ? message
+          : sourceFormat === FORMATS.OPENAI
+            ? claudeMessageToChatCompletion(message)
+            : message;
+
+      return {
+        success: true,
+        response: new Response(JSON.stringify(restoreToolNames(finalBody, toolNameMap)), {
+          headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+        }),
+      };
+    }
+
     const parsed = parseSSEToOpenAIResponse(sseText, model);
     if (!parsed)
       return createErrorResult(
@@ -491,10 +627,17 @@ export async function handleForcedSSEToJson({
     // lost on the non-streaming return path. Inlined (not imported from
     // nonStreamingHandler.js) to avoid a circular import: nonStreamingHandler
     // already imports parseSSEToOpenAIResponse from this module.
+    // A Claude-format client gets an Anthropic `message`, never a raw
+    // `chat.completion`. Every non-streaming /v1/messages request lands here
+    // when the provider forces streaming (opencode, codex, zed, openai), and
+    // Claude Code reads `message.content[]` — an OpenAI body throws a TypeError
+    // inside the client, which auto mode reports as "classifier unavailable".
     const finalBody =
       sourceFormat === FORMATS.OPENAI_RESPONSES
         ? chatCompletionToResponses(parsed, customToolNames)
-        : parsed;
+        : sourceFormat === FORMATS.CLAUDE
+          ? chatCompletionToClaudeMessage(parsed)
+          : parsed;
 
     return {
       success: true,

package/open-sse/handlers/chatCore.js

@@ -177,10 +177,24 @@ export async function handleChatCore({
     }
   }
 
+  // Client preference (what the response must look like) is independent of the
+  // transport a provider needs. `stream` below is the upstream flag; the
+  // client-facing decision is `clientWantsJson` further down.
+  const acceptHeader = clientRawRequest?.headers?.accept || "";
+  const clientPrefersJson = acceptHeader.includes("application/json");
+  const clientPrefersSSE = acceptHeader.includes("text/event-stream");
   const clientRequestedStreaming =
     body.stream === true || sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI;
   const providerRequiresStreaming = PROVIDERS[provider]?.forceStream === true;
-  let stream = providerRequiresStreaming ? true : body.stream !== false;
+  // Anthropic Messages defaults to a JSON body when `stream` is omitted; OpenAI
+  // chat callers have historically been served SSE in that case here. An
+  // explicit Accept: text/event-stream still opts a Claude client into SSE.
+  const sourceDefaultsToJson = sourceFormat === FORMATS.CLAUDE && !clientPrefersSSE;
+  let stream = providerRequiresStreaming
+    ? true
+    : body.stream === undefined
+      ? !sourceDefaultsToJson
+      : body.stream !== false;
 
   // Image generation models require non-streaming (Google v1internal:generateContent)
   const modelType = getModelType(alias, model);
@@ -197,9 +211,8 @@ export async function handleChatCore({
 
   // Check client Accept header preference for non-streaming requests
   // This fixes AI SDK compatibility where clients send Accept: application/json
-  const acceptHeader = clientRawRequest?.headers?.accept || "";
-  const clientPrefersJson = acceptHeader.includes("application/json");
-  const clientPrefersSSE = acceptHeader.includes("text/event-stream");
+  // (`acceptHeader`, `clientPrefersJson` and `clientPrefersSSE` are resolved
+  // with the stream negotiation above so both decisions share one reading.)
   if (
     clientPrefersJson &&
     !clientPrefersSSE &&
@@ -293,6 +306,21 @@ export async function handleChatCore({
     stripContinuityFields(translatedBody);
   }
 
+  // Reasoning depth is a model capability, so a model that cannot reason silently
+  // loses the client's effort selection inside applyThinking. Report that drop
+  // once per request: without it an ignored effort looks like a provider quirk.
+  const requestedThinking = extractThinking(body);
+  if (requestedThinking && requestedThinking.mode !== "none") {
+    const thinkingCaps = getCapabilitiesForModel(provider, stripThinkingSuffix(upstreamModel));
+    if (!thinkingCaps.reasoning) {
+      const requested = log?.fmtThink?.(requestedThinking) || requestedThinking.mode;
+      log?.warn?.(
+        "THINKING",
+        `${provider}/${model} cannot reason — requested ${requested} omitted`,
+      );
+    }
+  }
+
   // Dedupe duplicate built-in tools when equivalent MCP tools are present (Claude clients only).
   if (clientTool === "claude" && Array.isArray(translatedBody.tools)) {
     const { tools: deduped, stripped } = dedupeTools(translatedBody.tools);
@@ -687,9 +715,20 @@ export async function handleChatCore({
     appendRequestLog({ model, provider, connectionId, ...extra }).catch(() => {});
   const trackDone = () => trackPendingRequest(model, provider, connectionId, false);
 
-  // Provider forced streaming but client wants JSON
-  if (!clientRequestedStreaming && providerRequiresStreaming) {
-    const result = await handleForcedSSEToJson({
+  // The client did not ask for SSE: either the provider only streams, or the
+  // request was negotiated as JSON. Aggregating the upstream stream is tried
+  // first; it declines a non-SSE body so a provider that ignored `stream` — or
+  // one that answered JSON on a forced-stream endpoint — still reaches the
+  // ordinary non-streaming handler instead of being written as an SSE response.
+  const clientWantsJson =
+    !stream ||
+    (providerRequiresStreaming && !clientRequestedStreaming && !clientPrefersSSE) ||
+    // Source-format contract: an Anthropic Messages client that did not ask to
+    // stream keeps a JSON body even if its provider forces streaming upstream.
+    (sourceFormat === FORMATS.CLAUDE && body.stream !== true && !clientPrefersSSE);
+
+  if (clientWantsJson) {
+    const forcedResult = await handleForcedSSEToJson({
       ...sharedCtx,
       providerResponse,
       sourceFormat,
@@ -699,14 +738,11 @@ export async function handleChatCore({
       trackDone,
       appendLog,
     });
-    if (result) {
+    if (forcedResult) {
       streamController.handleComplete();
-      return result;
+      return forcedResult;
     }
-  }
 
-  // True non-streaming response
-  if (!stream) {
     const result = await handleNonStreamingResponse({
       ...sharedCtx,
       providerResponse,

package/open-sse/translator/concerns/classifier.js

@@ -0,0 +1,70 @@
+// Claude Code auto-mode safety classifier detection.
+//
+// The classifier is an ordinary non-streaming /v1/messages call, but it sends
+// `stop_sequences: ["</severity>"]` (current schema) or `["</block>"]` (legacy)
+// to end its verdict early. Providers that implement `stop` by trimming the
+// matched text from the completion return `<severity>0` instead of
+// `<severity>0</severity>`, and the client cannot parse that verdict — auto
+// mode then fails closed for every action.
+//
+// Detection is structural, never model-based: the classifier is the only
+// utility call that carries a `<transcript>` block, asks for the verdict tag in
+// its system prompt, and declares no tools. User content alone can never opt a
+// request into this policy.
+
+import { ROLE } from "../schema/index.js";
+
+const TRANSCRIPT_MARKER = "<transcript>";
+const SEVERITY_INSTRUCTION = "Output <severity>N</severity>";
+const LEGACY_YES = "yes</block>";
+const LEGACY_NO = "no</block>";
+
+const SEVERITY_STOP = "</severity>";
+const LEGACY_STOP = "</block>";
+
+/** Concatenate the text of a Claude content value (string or block array). */
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((block) => typeof block?.text === "string")
+    .map((block) => block.text)
+    .join("");
+}
+
+/**
+ * Return the stop sequence a known auto-mode classifier owns, or null.
+ *
+ * @param {object} body - Claude Messages request body.
+ * @returns {string|null} `"</severity>"`, `"</block>"`, or null.
+ */
+export function detectClassifierStopSequence(body) {
+  if (!body || typeof body !== "object") return null;
+  if (Array.isArray(body.tools) && body.tools.length > 0) return null;
+
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  const transcript = messages
+    .filter((message) => message?.role !== ROLE.SYSTEM)
+    .map((message) => textOf(message?.content))
+    .join("\n");
+  if (!transcript.includes(TRANSCRIPT_MARKER)) return null;
+
+  const systemText = [
+    textOf(body.system),
+    ...messages.filter((message) => message?.role === ROLE.SYSTEM).map((m) => textOf(m.content)),
+  ].join("\n");
+
+  // Current schema wins when both known instructions appear.
+  if (systemText.includes(SEVERITY_INSTRUCTION)) return SEVERITY_STOP;
+  if (systemText.includes(LEGACY_YES) || systemText.includes(LEGACY_NO)) return LEGACY_STOP;
+  return null;
+}
+
+/**
+ * Drop the classifier-owned stop hint from a `stop_sequences` array.
+ * Every other sequence passes through untouched.
+ */
+export function withoutClassifierStop(stopSequences, classifierStop) {
+  if (!Array.isArray(stopSequences) || !classifierStop) return stopSequences;
+  return stopSequences.filter((sequence) => sequence !== classifierStop);
+}

package/open-sse/translator/concerns/thinkingUnified.js

@@ -276,7 +276,12 @@ function applyFormat(fmt, body, cfg, caps, supportedLevels, display) {
         break;
       }
       const level = toLevel(eff);
-      if (level) body.reasoning_effort = normalizeOpenAILevel(level, supportedLevels);
+      // "auto" (adaptive thinking, no explicit effort) is not a member of the
+      // OpenAI reasoning_effort enum. Omitting the field is the only way to say
+      // "provider default" — every declared enum value names a specific depth.
+      if (level && level !== "auto") {
+        body.reasoning_effort = normalizeOpenAILevel(level, supportedLevels);
+      }
       break;
     }
     case "claude-adaptive": {
@@ -335,13 +340,17 @@ function applyFormat(fmt, body, cfg, caps, supportedLevels, display) {
         const zaiLvl = toLevel(eff);
         // GLM-5.3 only accepts exactly low|high|max (anything else errors); GLM-5.2 accepts
         // a wider set but z.ai maps low/medium->high and xhigh->max server-side anyway, so
-        // this 3-value mapping matches both.
-        body.reasoning_effort =
+        // this 3-value mapping matches both. No explicit effort ("auto") omits the field:
+        // the fallback below would otherwise turn "let the model decide" into max.
+        const mapped =
           zaiLvl === "low" || zaiLvl === "minimal"
             ? "low"
             : zaiLvl === "high" || zaiLvl === "medium"
               ? "high"
-              : "max";
+              : zaiLvl === "xhigh" || zaiLvl === "max"
+                ? "max"
+                : null;
+        if (mapped) body.reasoning_effort = mapped;
       }
       break;
     }
@@ -394,7 +403,9 @@ function applyFormat(fmt, body, cfg, caps, supportedLevels, display) {
     case "step": {
       if (none && canDisable) break;
       const level = toLevel(eff);
-      if (level) body.reasoning_effort = level === "xhigh" || level === "max" ? "high" : level;
+      // "auto" is not in Step's low|medium|high enum — omit and take the default.
+      if (level && level !== "auto")
+        body.reasoning_effort = level === "xhigh" || level === "max" ? "high" : level;
       break;
     }
     case "tokenrouter": {
@@ -416,7 +427,8 @@ function applyFormat(fmt, body, cfg, caps, supportedLevels, display) {
         break;
       }
       const level = toLevel(eff);
-      if (level) body.params.reasoning_effort = level;
+      // Native CLI accepts named levels only; "auto" means "no preference" → omit.
+      if (level && level !== "auto") body.params.reasoning_effort = level;
       break;
     }
     default:

package/open-sse/translator/request/claude-to-openai.js

@@ -4,6 +4,7 @@ import { adjustMaxTokens } from "../formats/maxTokens.js";
 import { encodeDataUri } from "../concerns/image.js";
 import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK, EMPTY_TOOL_RESULT } from "../schema/index.js";
 import { collapseTextParts } from "../concerns/message.js";
+import { detectClassifierStopSequence, withoutClassifierStop } from "../concerns/classifier.js";
 
 function stripAnthropicBillingHeader(text) {
   if (typeof text !== "string") return "";
@@ -28,6 +29,25 @@ export function claudeToOpenAIRequest(model, body, stream) {
     result.temperature = body.temperature;
   }
 
+  // Sampling. Only top_p: `top_k` has no OpenAI equivalent, and strict
+  // OpenAI-dialect upstreams reject unknown body fields with a 400.
+  if (body.top_p !== undefined) result.top_p = body.top_p;
+
+  // stop_sequences → stop. The wires name the same thing, so an ordinary
+  // caller's terminators carry over unchanged.
+  //
+  // One exception: Claude Code's auto-mode classifier asks for a structural
+  // verdict (<severity>N</severity> / <block>yes</block>) and also sends the
+  // closing tag as its own stop hint. OpenAI-dialect `stop` implementations
+  // trim the matched text, leaving "<severity>0" — a verdict the client cannot
+  // parse, so auto mode fails closed. Drop only that owned hint; the model then
+  // finishes the tag it was asked for.
+  const classifierStop = detectClassifierStopSequence(body);
+  const forwardedStop = withoutClassifierStop(body.stop_sequences, classifierStop);
+  if (Array.isArray(forwardedStop) && forwardedStop.length > 0) {
+    result.stop = forwardedStop;
+  }
+
   // System message
   if (body.system) {
     const systemContent = Array.isArray(body.system)

package/open-sse/translator/request/openai-to-claude.js

@@ -31,6 +31,17 @@ export function openaiToClaudeRequest(model, body, stream) {
     result.temperature = body.temperature;
   }
 
+  if (body.top_p !== undefined) result.top_p = body.top_p;
+
+  // stop → stop_sequences. OpenAI accepts a single string or an array; Claude
+  // only takes an array. Round-tripping this keeps a stop-terminated answer
+  // identical in both directions.
+  if (typeof body.stop === "string" && body.stop) {
+    result.stop_sequences = [body.stop];
+  } else if (Array.isArray(body.stop) && body.stop.length > 0) {
+    result.stop_sequences = body.stop;
+  }
+
   // Messages
   result.messages = [];
   const systemParts = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amir83nasr/10router",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Amir83Nasr/10Router.git"

package/src/app/(dashboard)/dashboard/cli-tools/components/cards/ClaudeToolCard.tsx

@@ -250,6 +250,12 @@ export default function ClaudeToolCard({
         // model ids never match, so the escape-hatch flag must ride along.
         env[tool.envVars.todoTools] = "1";
       }
+      if (tool.envVars?.autoModeServer) {
+        // Auto mode asks the Anthropic API to review actions in-band. A gateway
+        // cannot provide that review, so declaring it skips the dead round-trip
+        // and the classifier billing notice; the local classifier still runs.
+        env[tool.envVars.autoModeServer] = "0";
+      }
       const res = await fetch("/api/cli-tools/claude-settings", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -331,6 +337,12 @@ export default function ClaudeToolCard({
       // model ids never match, so the escape-hatch flag must ride along.
       env[tool.envVars.todoTools] = "1";
     }
+    if (tool.envVars?.autoModeServer) {
+      // Auto mode asks the Anthropic API to review actions in-band. A gateway
+      // cannot provide that review, so declaring it skips the dead round-trip
+      // and the classifier billing notice; the local classifier still runs.
+      env[tool.envVars.autoModeServer] = "0";
+    }
 
     return [
       {

package/src/app/api/cli-tools/claude-settings/route.js

@@ -191,6 +191,15 @@ export async function POST(request) {
     const todoToolsKey = CLI_TOOLS.claude.envVars.todoTools;
     if (todoToolsKey) newSettings.env[todoToolsKey] = "1";
 
+    // CLAUDE_CODE_AUTO_MODE_SERVER=0 — auto mode asks the Anthropic API to
+    // review actions in-band (`safeguards` + the dangerous-tool-use beta). Behind
+    // this gateway that request never gets reviewed, so Claude Code spends one
+    // dead round-trip per session, shows the classifier billing notice, and then
+    // uses its own classifier regardless. Saying so up front keeps auto mode the
+    // same on every launch and keeps the notice out of the session.
+    const autoModeServerKey = CLI_TOOLS.claude.envVars.autoModeServer;
+    if (autoModeServerKey) newSettings.env[autoModeServerKey] = "0";
+
     // Write new settings
     await fs.writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
 
@@ -219,6 +228,7 @@ const RESET_ENV_KEYS = [
   "API_TIMEOUT_MS",
   "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
   "CLAUDE_CODE_ENABLE_TODO_TOOLS",
+  "CLAUDE_CODE_AUTO_MODE_SERVER",
 ];
 
 // DELETE - Reset settings (remove env fields)

package/src/shared/constants/cliTools.js

@@ -19,6 +19,14 @@ export const CLI_TOOLS = {
       // as `oc/...` or a combo name never match, so the task list disappears.
       // This flag is the CLI's documented escape hatch for that gate.
       todoTools: "CLAUDE_CODE_ENABLE_TODO_TOOLS",
+      // Auto mode's server-side classifier review asks the Anthropic API to
+      // review actions as part of the session's own requests (`safeguards` body
+      // field + `dangerous-tool-use` beta). A gateway cannot provide that review,
+      // so Claude Code prints the "this session isn't eligible" billing notice on
+      // the first checked action and falls back to its own classifier anyway.
+      // Declaring the gateway up front skips the notice: auto mode uses the local
+      // classifier for every session, with no dead round-trip first.
+      autoModeServer: "CLAUDE_CODE_AUTO_MODE_SERVER",
     },
     modelAliases: ["default", "sonnet", "opus", "fable", "haiku", "opusplan"],
     settingsFile: "~/.claude/settings.json",