feat: add Claude Opus 4.7 support (adaptive-only thinking, sampling param constraints)

.dockerignore

@@ -40,11 +40,26 @@ blob-report
 # Documentation (not needed in container)
 docs
 *.md
-!README.md
 
 # Electron (separate build)
 electron
 
+# Container and CI metadata
+Dockerfile
+docker-compose.yml
+docker-compose.prod.yml
+fly.toml
+sonar-project.properties
+
+# Local engineering metadata
+AGENTS.md
+playwright.config.ts
+vitest.config.ts
+vitest.mcp.config.ts
+eslint.config.mjs
+prettier.config.mjs
+llm.txt
+
 # VS Code extension (separate project)
 vscode-extension
 

.github/workflows/docker-publish.yml

@@ -22,7 +22,7 @@ jobs:
     name: Build and Push Docker (multi-arch)
     runs-on: ubuntu-latest
     env:
-      IMAGE_NAME: diegosouzapw/omniroute
+      IMAGE_NAME: i1hwan/apexroute
     steps:
       - name: Checkout
         uses: actions/checkout@v6
@@ -65,13 +65,13 @@ jobs:
         with:
           context: .
           target: runner-base
-          platforms: linux/amd64,linux/arm64
+          platforms: linux/amd64
           push: true
           tags: |
             ${{ env.IMAGE_NAME }}:${{ steps.version.outputs.version }}
             ${{ env.IMAGE_NAME }}:latest
-            ghcr.io/diegosouzapw/omniroute:${{ steps.version.outputs.version }}
-            ghcr.io/diegosouzapw/omniroute:latest
+            ghcr.io/i1hwan/apexroute:${{ steps.version.outputs.version }}
+            ghcr.io/i1hwan/apexroute:latest
           cache-from: type=gha
           cache-to: type=gha,mode=max
           no-cache: false
@@ -81,12 +81,3 @@ jobs:
       - name: Inspect image
         run: |
           docker buildx imagetools inspect "${{ env.IMAGE_NAME }}:${{ steps.version.outputs.version }}"
-
-      - name: Update Docker Hub description
-        uses: peter-evans/dockerhub-description@v4
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-          repository: diegosouzapw/omniroute
-          short-description: "OmniRoute — Unified AI proxy. Route any LLM through one endpoint."
-          readme-filepath: ./README.md

Dockerfile

@@ -11,7 +11,37 @@ COPY scripts/native-binary-compat.mjs ./scripts/native-binary-compat.mjs
 RUN if [ -f package-lock.json ]; then npm ci --no-audit --no-fund; else npm install --no-audit --no-fund; fi
 
 COPY . ./
-RUN mkdir -p /app/data && npm run build -- --webpack
+RUN mkdir -p /app/data \
+  && npm run build -- --webpack \
+  && rm -f /app/.next/standalone/.env \
+  && rm -rf \
+    /app/.next/standalone/.git \
+    /app/.next/standalone/coverage \
+    /app/.next/standalone/docs \
+    /app/.next/standalone/electron \
+    /app/.next/standalone/images \
+    /app/.next/standalone/logs \
+    /app/.next/standalone/tests \
+  && rm -f \
+    /app/.next/standalone/AGENTS.md \
+    /app/.next/standalone/CHANGELOG.md \
+    /app/.next/standalone/CONTRIBUTING.md \
+    /app/.next/standalone/Dockerfile \
+    /app/.next/standalone/README.md \
+    /app/.next/standalone/SECURITY.md \
+    /app/.next/standalone/docker-compose.yml \
+    /app/.next/standalone/docker-compose.prod.yml \
+    /app/.next/standalone/eslint.config.mjs \
+    /app/.next/standalone/fly.toml \
+    /app/.next/standalone/llm.txt \
+    /app/.next/standalone/playwright.config.ts \
+    /app/.next/standalone/prettier.config.mjs \
+    /app/.next/standalone/sonar-project.properties \
+    /app/.next/standalone/tsconfig.json \
+    /app/.next/standalone/tsconfig.typecheck-core.json \
+    /app/.next/standalone/tsconfig.typecheck-noimplicit-core.json \
+    /app/.next/standalone/vitest.config.ts \
+    /app/.next/standalone/vitest.mcp.config.ts
 
 FROM node:22.22.2-trixie-slim AS runner-base
 WORKDIR /app
@@ -48,6 +78,7 @@ COPY --from=builder /app/scripts/run-standalone.mjs ./run-standalone.mjs
 COPY --from=builder /app/scripts/runtime-env.mjs ./runtime-env.mjs
 COPY --from=builder /app/scripts/bootstrap-env.mjs ./bootstrap-env.mjs
 COPY --from=builder /app/scripts/healthcheck.mjs ./healthcheck.mjs
+COPY --from=builder /app/.env.example ./.env.example
 
 EXPOSE 20128
 

open-sse/config/forwardingKeywordRules.ts

@@ -0,0 +1,207 @@
+type ForwardingKeywordLane = "claude-oauth-prefixed";
+
+type ForwardingKeywordRule = {
+  match: string;
+  replace: string;
+};
+
+type ForwardingTagRule = {
+  open: string;
+  openReplacement: string;
+  close: string;
+  closeReplacement: string;
+};
+
+type ForwardingKeywordRules = {
+  toolNames: ForwardingKeywordRule[];
+  text: ForwardingKeywordRule[];
+  tags: ForwardingTagRule[];
+};
+
+type ForwardingKeywordConfig = Record<ForwardingKeywordLane, ForwardingKeywordRules>;
+
+export const DEFAULT_FORWARDING_KEYWORD_CONFIG: ForwardingKeywordConfig = {
+  "claude-oauth-prefixed": {
+    toolNames: [
+      { match: "background_output", replace: "background_result" },
+      { match: "background_cancel", replace: "background_stop" },
+    ],
+    text: [
+      { match: "background_output", replace: "background_result" },
+      { match: "background_cancel", replace: "background_stop" },
+    ],
+    tags: [
+      {
+        open: "<directories>",
+        openReplacement: "directories:\n",
+        close: "</directories>",
+        closeReplacement: "",
+      },
+    ],
+  },
+};
+
+let forwardingKeywordConfig: ForwardingKeywordConfig = cloneForwardingKeywordConfig(
+  DEFAULT_FORWARDING_KEYWORD_CONFIG
+);
+
+function cloneForwardingKeywordConfig(config: ForwardingKeywordConfig): ForwardingKeywordConfig {
+  return JSON.parse(JSON.stringify(config)) as ForwardingKeywordConfig;
+}
+
+function normalizeNonEmptyString(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const normalizedValue = value.trim();
+  return normalizedValue ? normalizedValue : null;
+}
+
+function normalizeKeywordRule(rule: unknown): ForwardingKeywordRule | null {
+  if (!rule || typeof rule !== "object") return null;
+  const candidate = rule as Record<string, unknown>;
+  const match = normalizeNonEmptyString(candidate.match);
+  if (!match || typeof candidate.replace !== "string") return null;
+  return { match, replace: candidate.replace };
+}
+
+function normalizeTagRule(rule: unknown): ForwardingTagRule | null {
+  if (!rule || typeof rule !== "object") return null;
+  const candidate = rule as Record<string, unknown>;
+  const open = normalizeNonEmptyString(candidate.open);
+  const close = normalizeNonEmptyString(candidate.close);
+  if (
+    !open ||
+    typeof candidate.openReplacement !== "string" ||
+    !close ||
+    typeof candidate.closeReplacement !== "string"
+  ) {
+    return null;
+  }
+
+  return {
+    open,
+    openReplacement: candidate.openReplacement,
+    close,
+    closeReplacement: candidate.closeReplacement,
+  };
+}
+
+function mergeKeywordRules(
+  defaults: ForwardingKeywordRule[],
+  overrides: ForwardingKeywordRule[]
+): ForwardingKeywordRule[] {
+  if (overrides.length === 0) return defaults;
+
+  const merged = new Map(defaults.map((rule) => [rule.match, rule]));
+  for (const override of overrides) {
+    merged.set(override.match, override);
+  }
+
+  return Array.from(merged.values());
+}
+
+function mergeTagRules(
+  defaults: ForwardingTagRule[],
+  overrides: ForwardingTagRule[]
+): ForwardingTagRule[] {
+  if (overrides.length === 0) return defaults;
+
+  const merged = new Map(defaults.map((rule) => [`${rule.open}::${rule.close}`, rule]));
+  for (const override of overrides) {
+    merged.set(`${override.open}::${override.close}`, override);
+  }
+
+  return Array.from(merged.values());
+}
+
+export function normalizeForwardingKeywordConfig(value: unknown): ForwardingKeywordConfig {
+  const normalized = cloneForwardingKeywordConfig(DEFAULT_FORWARDING_KEYWORD_CONFIG);
+  if (!value || typeof value !== "object") return normalized;
+
+  const rawConfig = value as Record<string, unknown>;
+  for (const lane of Object.keys(DEFAULT_FORWARDING_KEYWORD_CONFIG) as ForwardingKeywordLane[]) {
+    const rawLane = rawConfig[lane];
+    if (!rawLane || typeof rawLane !== "object") continue;
+
+    const rawLaneConfig = rawLane as Record<string, unknown>;
+    const toolNameOverrides = Array.isArray(rawLaneConfig.toolNames)
+      ? rawLaneConfig.toolNames.map(normalizeKeywordRule).filter(Boolean)
+      : [];
+    const textOverrides = Array.isArray(rawLaneConfig.text)
+      ? rawLaneConfig.text.map(normalizeKeywordRule).filter(Boolean)
+      : [];
+    const tagOverrides = Array.isArray(rawLaneConfig.tags)
+      ? rawLaneConfig.tags.map(normalizeTagRule).filter(Boolean)
+      : [];
+
+    normalized[lane] = {
+      toolNames: mergeKeywordRules(normalized[lane].toolNames, toolNameOverrides),
+      text: mergeKeywordRules(normalized[lane].text, textOverrides),
+      tags: mergeTagRules(normalized[lane].tags, tagOverrides),
+    };
+  }
+
+  return normalized;
+}
+
+export function setForwardingKeywordConfig(config: unknown) {
+  forwardingKeywordConfig = normalizeForwardingKeywordConfig(config);
+}
+
+export function applyForwardingKeywordSettings(settings: Record<string, unknown>) {
+  if (Object.prototype.hasOwnProperty.call(settings, "forwardingKeywordRules")) {
+    setForwardingKeywordConfig(settings.forwardingKeywordRules);
+    return;
+  }
+
+  setForwardingKeywordConfig(getDefaultForwardingKeywordConfig());
+}
+
+export function getForwardingKeywordConfig(): ForwardingKeywordConfig {
+  return cloneForwardingKeywordConfig(forwardingKeywordConfig);
+}
+
+export function getDefaultForwardingKeywordConfig(): ForwardingKeywordConfig {
+  return cloneForwardingKeywordConfig(DEFAULT_FORWARDING_KEYWORD_CONFIG);
+}
+
+export function rewriteForwardedTextForLane(lane: ForwardingKeywordLane, text: string): string {
+  if (!text) return text;
+
+  let rewrittenText = text;
+  const rules = forwardingKeywordConfig[lane];
+
+  for (const rule of rules.text) {
+    rewrittenText = rewrittenText.replaceAll(rule.match, rule.replace);
+  }
+
+  for (const tagRule of rules.tags) {
+    rewrittenText = rewrittenText
+      .replaceAll(tagRule.open, tagRule.openReplacement)
+      .replaceAll(tagRule.close, tagRule.closeReplacement);
+  }
+
+  return rewrittenText;
+}
+
+export function rewriteForwardedToolNameForLane(
+  lane: ForwardingKeywordLane,
+  toolName: string
+): string {
+  const rules = forwardingKeywordConfig[lane];
+  const matchingRule = rules.toolNames.find((rule) => rule.match === toolName);
+  return matchingRule?.replace ?? toolName;
+}
+
+export function getForwardingKeywordRulesForLane(
+  lane: ForwardingKeywordLane
+): ForwardingKeywordRules {
+  return cloneForwardingKeywordConfig(forwardingKeywordConfig)[lane];
+}
+
+export type {
+  ForwardingKeywordConfig,
+  ForwardingKeywordLane,
+  ForwardingKeywordRule,
+  ForwardingKeywordRules,
+  ForwardingTagRule,
+};

open-sse/config/providerRegistry.ts

@@ -165,6 +165,7 @@ export const REGISTRY: Record<string, RegistryEntry> = {
       tokenUrl: "https://console.anthropic.com/v1/oauth/token",
     },
     models: [
+      { id: "claude-opus-4-7", name: "Claude Opus 4.7" },
       { id: "claude-opus-4-6", name: "Claude Opus 4.6" },
       { id: "claude-sonnet-4-6", name: "Claude 4.6 Sonnet" },
       { id: "claude-opus-4-5-20251101", name: "Claude 4.5 Opus" },

open-sse/handlers/chatCore.ts

@@ -1,6 +1,7 @@
 import { getCorsOrigin } from "../utils/cors.ts";
 import { detectFormatFromEndpoint, getTargetFormat } from "../services/provider.ts";
 import { translateRequest, needsTranslation } from "../translator/index.ts";
+import { applyThinkingBudget } from "../services/thinkingBudget.ts";
 import { FORMATS } from "../translator/formats.ts";
 import {
   createSSETransformStreamWithLogger,
@@ -69,6 +70,7 @@ import {
 import { invalidateCodexQuotaCache } from "../services/codexQuotaFetcher.ts";
 import { translateNonStreamingResponse } from "./responseTranslator.ts";
 import { extractUsageFromResponse } from "./usageExtractor.ts";
+import { applyClaudeOAuthLexicalRewrite } from "../translator/helpers/claudeHelper.ts";
 import {
   parseSSEToClaudeResponse,
   parseSSEToOpenAIResponse,
@@ -1017,8 +1019,17 @@ export async function handleChatCore({
       // as-is without prior normalization. The OpenAI round-trip would strip
       // cache_control markers; even prepareClaudeRequest can alter structure.
       // Claude Code sends well-formed Messages API payloads — trust it.
-      translatedBody = { ...body };
+      // Still apply thinking budget to convert reasoning_effort → Claude thinking
+      // (applyThinkingBudget only touches thinking/reasoning fields, preserves cache_control).
+      translatedBody = applyThinkingBudget({ ...body });
       translatedBody._disableToolPrefix = true;
+      if (provider === "claude") {
+        const lexicalRewrite = applyClaudeOAuthLexicalRewrite(translatedBody);
+        translatedBody = lexicalRewrite.body;
+        if (lexicalRewrite.toolNameMap) {
+          translatedBody._toolNameMap = lexicalRewrite.toolNameMap;
+        }
+      }
 
       log?.debug?.("FORMAT", "claude passthrough with cache_control preservation");
     } else if (isClaudePassthrough) {
@@ -1057,6 +1068,13 @@ export async function handleChatCore({
         reqLogger,
         { normalizeToolCallId, preserveDeveloperRole, preserveCacheControl }
       );
+      if (provider === "claude") {
+        const lexicalRewrite = applyClaudeOAuthLexicalRewrite(translatedBody);
+        translatedBody = lexicalRewrite.body;
+        if (lexicalRewrite.toolNameMap) {
+          translatedBody._toolNameMap = lexicalRewrite.toolNameMap;
+        }
+      }
       log?.debug?.("FORMAT", "claude->openai->claude normalized passthrough");
     } else {
       translatedBody = { ...body };
@@ -1066,7 +1084,7 @@ export async function handleChatCore({
       // conflicts with Claude OAuth tools, but in the passthrough path the tools
       // are already in Claude format. Applying the prefix turns "Bash" into
       // "proxy_Bash", which Claude rejects ("No such tool available: proxy_Bash").
-      if (targetFormat === FORMATS.CLAUDE) {
+      if (sourceFormat === FORMATS.CLAUDE && targetFormat === FORMATS.CLAUDE) {
         translatedBody._disableToolPrefix = true;
       }