@auroraflow/code 0.0.7 → 0.0.8

package/README.md

@@ -38,6 +38,7 @@ aurora update-clients
 
 ```bash
 npm run check
+scripts/release_npm.sh 0.0.7
 node bin/aurora.js
 node bin/aurora.js init
 node bin/aurora.js claude

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@auroraflow/code",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "type": "module",
   "description": "Aurora launcher and sidecar for official Codex and Claude Code clients.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/auroraflowintl/aurora-code.git"
+  },
   "bin": {
     "aurora": "bin/aurora.js",
     "aurora-claude": "bin/aurora-claude.js",
@@ -11,7 +15,8 @@
   },
   "scripts": {
     "postinstall": "node bin/aurora-postinstall.js",
-    "check": "find bin lib packages -name '*.js' -print0 | xargs -0 -n1 node --check"
+    "check": "find bin lib packages -name '*.js' -print0 | xargs -0 -n1 node --check",
+    "test": "node --test packages/protocol/src/index.test.js"
   },
   "engines": {
     "node": ">=24"

package/packages/clients/src/index.js

@@ -36,6 +36,9 @@ export async function createClientLaunchSpec(client, args = []) {
       CLAUDE_CONFIG_DIR: CLAUDE_HOME,
       ANTHROPIC_BASE_URL: sidecar.baseURL,
       ANTHROPIC_AUTH_TOKEN: sidecar.token,
+      // Claude Code v2.1.36+ sends attribution header by default.
+      // Keep request prefixes stable for DeepSeek prompt-cache reuse.
+      CLAUDE_CODE_ATTRIBUTION_HEADER: process.env.CLAUDE_CODE_ATTRIBUTION_HEADER ?? "0",
       CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
       CLAUDE_CODE_DISABLE_TELEMETRY: "1",
       DISABLE_AUTOUPDATER: "1"
@@ -161,8 +164,11 @@ async function ensureSidecar() {
 
 async function writeCodexRuntimeFiles({ sidecar, model }) {
   await mkdir(CODEX_HOME, { recursive: true });
+  const modelCatalogPath = join(CODEX_HOME, "model_catalog.json");
+  await writeCodexModelCatalog(sidecar, modelCatalogPath);
   const config = `model = ${tomlString(model)}
 model_provider = "aurora"
+model_catalog_json = ${tomlString(modelCatalogPath)}
 suppress_unstable_features_warning = true
 
 [model_providers.aurora]
@@ -184,6 +190,32 @@ stream_idle_timeout_ms = 300000
   await writeFile(join(CODEX_HOME, "auth.json"), `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600 });
 }
 
+async function writeCodexModelCatalog(sidecar, modelCatalogPath) {
+  const clientVersion = "0.137.0";
+  const response = await fetch(
+    `${sidecar.baseURL}/v1/models?client_version=${encodeURIComponent(clientVersion)}`,
+    {
+      headers: { authorization: `Bearer ${sidecar.token}` },
+      signal: AbortSignal.timeout(5000)
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Aurora Codex model catalog request failed with HTTP ${response.status}`);
+  }
+  const payload = await response.json();
+  if (!Array.isArray(payload.models) || payload.models.length === 0) {
+    throw new Error("Aurora Codex model catalog is empty");
+  }
+  const catalog = { models: payload.models };
+  const cache = {
+    fetched_at: new Date().toISOString(),
+    client_version: clientVersion,
+    models: payload.models
+  };
+  await writeFile(modelCatalogPath, `${JSON.stringify(catalog, null, 2)}\n`, { mode: 0o600 });
+  await writeFile(join(CODEX_HOME, "models_cache.json"), `${JSON.stringify(cache, null, 2)}\n`, { mode: 0o600 });
+}
+
 async function waitForSidecar(info) {
   const deadline = Date.now() + 2500;
   while (Date.now() < deadline) {

package/packages/protocol/src/index.js

@@ -10,17 +10,26 @@ export function selectedKeyHeaders(state) {
   return key ? { authorization: `Bearer ${key}`, "x-api-key": key } : {};
 }
 
-export function rewriteRuntimeModel(raw, selectedAlias) {
-  if (!selectedAlias || !raw.trim()) return raw;
+export function rewriteRuntimeModel(raw, selectedAlias, capabilitiesByAlias = {}) {
+  if (!raw.trim()) return raw;
   try {
     const parsed = JSON.parse(raw);
-    parsed.model = selectedAlias;
+    if (selectedAlias) parsed.model = selectedAlias;
+    filterHostedWebSearch(parsed, capabilitiesByAlias);
     return JSON.stringify(parsed);
   } catch {
     return raw;
   }
 }
 
+function filterHostedWebSearch(payload, capabilitiesByAlias) {
+  const model = String(payload.model ?? "");
+  const supportsWebSearch = capabilitiesByAlias[model]?.supports_web_search === true;
+  if (supportsWebSearch || !Array.isArray(payload.tools)) return;
+  payload.tools = payload.tools.filter(tool => tool?.type !== "web_search");
+  if (payload.tools.length === 0) delete payload.tools;
+}
+
 export function toClientModelItem(item) {
   const provider = String(item.provider ?? "aurora").replace(/[^a-zA-Z0-9_-]/g, "-");
   const modelID = encodeURIComponent(String(item.model_id ?? item.alias ?? item.id));
@@ -35,6 +44,124 @@ export function toClientModelItem(item) {
   };
 }
 
+export function toCodexModelInfo(item, priority = 0) {
+  const alias = String(item.alias ?? item.id ?? item.model_id ?? "");
+  const displayName = item.display_name || `${item.provider ?? "aurora"} / ${item.model_id ?? alias}`;
+  const providerName = providerDisplayName(item.provider);
+  const supportsThinking = Boolean(item.supports_thinking);
+  const supportsTools = Boolean(item.supports_tools);
+  const supportsImages = Boolean(item.supports_images);
+  const supportsWebSearch = Boolean(item.supports_web_search);
+  const contextWindow = positiveNumber(item.context_window ?? item.context_window_tokens, 256000);
+  const maxContextWindow = positiveNumber(item.max_context_window, contextWindow);
+  const reasoningLevels = Array.isArray(item.supported_reasoning_levels)
+    ? item.supported_reasoning_levels
+    : defaultReasoningLevels(supportsThinking);
+  const modalities = Array.isArray(item.input_modalities)
+    ? item.input_modalities
+    : Array.isArray(item.modalities)
+      ? item.modalities
+      : supportsImages
+        ? ["text", "image"]
+        : ["text"];
+  const applyPatchToolType = Object.hasOwn(item, "apply_patch_tool_type")
+    ? item.apply_patch_tool_type
+    : supportsTools
+      ? "freeform"
+      : null;
+  return {
+    slug: alias,
+    display_name: displayName,
+    description: item.description || `${providerName} Provider`,
+    default_reasoning_level: item.default_reasoning_level ?? (supportsThinking ? "medium" : null),
+    supported_reasoning_levels: reasoningLevels,
+    shell_type: item.shell_type ?? "shell_command",
+    visibility: item.visibility ?? "list",
+    supported_in_api: item.supported_in_api ?? true,
+    priority: Number(item.priority ?? priority + 1),
+    additional_speed_tiers: Array.isArray(item.additional_speed_tiers) ? item.additional_speed_tiers : [],
+    service_tiers: Array.isArray(item.service_tiers) ? item.service_tiers : [],
+    default_service_tier: item.default_service_tier ?? null,
+    availability_nux: item.availability_nux ?? null,
+    upgrade: item.upgrade ?? null,
+    base_instructions: item.base_instructions || "You are a coding model routed through Aurora sidecar.",
+    model_messages: item.model_messages ?? null,
+    supports_reasoning_summaries: item.supports_reasoning_summaries ?? supportsThinking,
+    default_reasoning_summary: item.default_reasoning_summary ?? "none",
+    support_verbosity: item.support_verbosity ?? false,
+    default_verbosity: Object.hasOwn(item, "default_verbosity") ? item.default_verbosity : null,
+    apply_patch_tool_type: applyPatchToolType,
+    web_search_tool_type: Object.hasOwn(item, "web_search_tool_type") && item.web_search_tool_type
+      ? item.web_search_tool_type
+      : supportsWebSearch
+        ? (supportsImages ? "text_and_image" : "text")
+        : "text",
+    truncation_policy: item.truncation_policy ?? { mode: "tokens", limit: 10000 },
+    supports_parallel_tool_calls: item.supports_parallel_tool_calls ?? supportsTools,
+    supports_image_detail_original: item.supports_image_detail_original ?? supportsImages,
+    context_window: contextWindow,
+    max_context_window: maxContextWindow,
+    auto_compact_token_limit: item.auto_compact_token_limit ?? null,
+    effective_context_window_percent: positiveNumber(item.effective_context_window_percent, 95),
+    experimental_supported_tools: Array.isArray(item.experimental_supported_tools)
+      ? item.experimental_supported_tools
+      : [],
+    input_modalities: modalities,
+    supports_search_tool: item.supports_search_tool ?? supportsWebSearch,
+    auto_review_model_override: item.auto_review_model_override ?? null,
+    tool_mode: item.tool_mode ?? null,
+    multi_agent_version: item.multi_agent_version ?? null
+  };
+}
+
+function positiveNumber(value, defaultValue) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultValue;
+}
+
+function defaultReasoningLevels(supportsThinking) {
+  if (!supportsThinking) return [];
+  return [
+    { effort: "minimal", description: "Fastest response with shallow reasoning" },
+    { effort: "low", description: "Lower latency and lighter reasoning depth" },
+    { effort: "medium", description: "Balanced reasoning quality and speed" },
+    { effort: "high", description: "Deep reasoning for complex coding tasks" },
+    { effort: "xhigh", description: "Maximum reasoning depth for hardest tasks" }
+  ];
+}
+
+function providerDisplayName(provider) {
+  const raw = String(provider ?? "Aurora").trim().toLowerCase();
+  if (!raw) return "Aurora";
+  const known = {
+    antigravity: "Antigravity",
+    anthropic: "Anthropic",
+    claude: "Claude",
+    codex: "Codex",
+    cursor: "Cursor",
+    deepseek: "DeepSeek",
+    gemini: "Gemini",
+    google: "Google",
+    kimi: "Kimi",
+    kiro: "Kiro",
+    minimax: "MiniMax",
+    openai: "OpenAI",
+    openrouter: "OpenRouter",
+    qwen: "Qwen",
+    siliconflow: "SiliconFlow",
+    volcengine_ark: "Volcengine Ark",
+    windsurf: "Windsurf",
+    xai: "xAI",
+    zhipu: "Zhipu"
+  };
+  if (known[raw]) return known[raw];
+  return raw
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(" ");
+}
+
 export function isRuntimePath(pathname) {
   return pathname === "/v1/messages" ||
     pathname === "/v1/responses" ||

package/packages/protocol/src/index.test.js

@@ -0,0 +1,180 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { rewriteRuntimeModel, toCodexModelInfo } from "./index.js";
+
+const CODEX_MODEL_INFO_FIELDS = [
+  "additional_speed_tiers",
+  "apply_patch_tool_type",
+  "auto_compact_token_limit",
+  "auto_review_model_override",
+  "availability_nux",
+  "base_instructions",
+  "context_window",
+  "default_reasoning_level",
+  "default_reasoning_summary",
+  "default_service_tier",
+  "default_verbosity",
+  "description",
+  "display_name",
+  "effective_context_window_percent",
+  "experimental_supported_tools",
+  "input_modalities",
+  "max_context_window",
+  "model_messages",
+  "multi_agent_version",
+  "priority",
+  "service_tiers",
+  "shell_type",
+  "slug",
+  "support_verbosity",
+  "supported_in_api",
+  "supported_reasoning_levels",
+  "supports_image_detail_original",
+  "supports_parallel_tool_calls",
+  "supports_reasoning_summaries",
+  "supports_search_tool",
+  "tool_mode",
+  "truncation_policy",
+  "upgrade",
+  "visibility",
+  "web_search_tool_type"
+].sort();
+
+test("projects published reasoning and tool capabilities into Codex metadata", () => {
+  const model = toCodexModelInfo({
+    alias: "deepseek/deepseek-v4-flash",
+    provider: "deepseek",
+    model_id: "deepseek-v4-flash",
+    context_window_tokens: 1048576,
+    supports_tools: true,
+    supports_images: false,
+    supports_thinking: true,
+    supports_web_search: false,
+    default_reasoning_level: "high",
+    supported_reasoning_levels: [
+      { effort: "minimal", description: "off" },
+      { effort: "high", description: "high" },
+      { effort: "xhigh", description: "max" }
+    ],
+    supports_reasoning_summaries: true,
+    shell_type: "shell_command",
+    truncation_policy: { mode: "tokens", limit: 10000 },
+    supports_parallel_tool_calls: true,
+    tool_mode: null,
+    multi_agent_version: null
+  }, 4);
+
+  assert.equal(model.slug, "deepseek/deepseek-v4-flash");
+  assert.equal(model.priority, 5);
+  assert.equal(model.supports_reasoning_summaries, true);
+  assert.equal(model.default_reasoning_level, "high");
+  assert.deepEqual(model.supported_reasoning_levels.map(level => level.effort), [
+    "minimal",
+    "high",
+    "xhigh"
+  ]);
+  assert.equal(model.shell_type, "shell_command");
+  assert.equal(model.supports_parallel_tool_calls, true);
+  assert.equal(model.apply_patch_tool_type, "freeform");
+  assert.equal(model.supports_search_tool, false);
+  assert.equal(model.web_search_tool_type, "text");
+  assert.deepEqual(model.input_modalities, ["text"]);
+  assert.deepEqual(model.truncation_policy, { mode: "tokens", limit: 10000 });
+  assert.equal(model.auto_compact_token_limit, null);
+  assert.equal(model.tool_mode, null);
+  assert.equal(model.multi_agent_version, null);
+  assert.deepEqual(Object.keys(model).sort(), CODEX_MODEL_INFO_FIELDS);
+});
+
+test("does not advertise unsupported capabilities", () => {
+  const model = toCodexModelInfo({
+    alias: "provider/text-only",
+    provider: "provider",
+    model_id: "text-only",
+    supports_tools: false,
+    supports_images: false,
+    supports_thinking: false,
+    supports_web_search: false
+  });
+
+  assert.equal(model.default_reasoning_level, null);
+  assert.deepEqual(model.supported_reasoning_levels, []);
+  assert.equal(model.supports_reasoning_summaries, false);
+  assert.equal(model.apply_patch_tool_type, null);
+  assert.equal(model.supports_parallel_tool_calls, false);
+  assert.equal(model.supports_image_detail_original, false);
+  assert.equal(model.supports_search_tool, false);
+  assert.equal(model.web_search_tool_type, "text");
+  assert.equal(model.support_verbosity, false);
+  assert.equal(model.default_verbosity, null);
+  assert.deepEqual(model.input_modalities, ["text"]);
+  assert.deepEqual(Object.keys(model).sort(), CODEX_MODEL_INFO_FIELDS);
+});
+
+test("preserves explicit Codex deferred tool search capability", () => {
+  const model = toCodexModelInfo({
+    alias: "cx/gpt-5.5",
+    provider: "codex",
+    model_id: "gpt-5.5",
+    supports_tools: true,
+    supports_images: true,
+    supports_thinking: true,
+    supports_web_search: true,
+    supports_search_tool: true,
+    web_search_tool_type: "text_and_image"
+  });
+
+  assert.equal(model.supports_search_tool, true);
+  assert.equal(model.web_search_tool_type, "text_and_image");
+});
+
+test("preserves explicit disabled deferred tool search despite hosted web search", () => {
+  const model = toCodexModelInfo({
+    alias: "provider/hosted-search-only",
+    provider: "provider",
+    model_id: "hosted-search-only",
+    supports_tools: true,
+    supports_images: false,
+    supports_thinking: false,
+    supports_web_search: true,
+    supports_search_tool: false,
+    web_search_tool_type: "text"
+  });
+
+  assert.equal(model.supports_search_tool, false);
+  assert.equal(model.web_search_tool_type, "text");
+});
+
+test("strips hosted web search from runtime requests for unsupported models", () => {
+  const raw = JSON.stringify({
+    model: "deepseek/deepseek-v4-flash",
+    tools: [
+      { type: "web_search" },
+      { type: "function", name: "shell" }
+    ],
+    input: "hi"
+  });
+
+  const rewritten = JSON.parse(rewriteRuntimeModel(raw, "", {
+    "deepseek/deepseek-v4-flash": { supports_web_search: false }
+  }));
+
+  assert.equal(rewritten.model, "deepseek/deepseek-v4-flash");
+  assert.deepEqual(rewritten.tools, [{ type: "function", name: "shell" }]);
+});
+
+test("keeps hosted web search for supported selected models", () => {
+  const raw = JSON.stringify({
+    model: "gpt-5.5",
+    tools: [{ type: "web_search" }],
+    input: "hi"
+  });
+
+  const rewritten = JSON.parse(rewriteRuntimeModel(raw, "cx/gpt-5.5", {
+    "cx/gpt-5.5": { supports_web_search: true }
+  }));
+
+  assert.equal(rewritten.model, "cx/gpt-5.5");
+  assert.deepEqual(rewritten.tools, [{ type: "web_search" }]);
+});

package/packages/sidecar/src/index.js

@@ -1,6 +1,10 @@
 import { createServer } from "node:http";
-import { AURORA_LOCALHOST, AURORA_SIDECAR_PORT, isRuntimePath, rewriteRuntimeModel, selectedKeyHeaders, toClientModelItem, trimSlash } from "../../protocol/src/index.js";
-import { readState, writeSidecarInfo } from "../../state/src/index.js";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { AURORA_LOCALHOST, AURORA_SIDECAR_PORT, isRuntimePath, rewriteRuntimeModel, selectedKeyHeaders, toClientModelItem, toCodexModelInfo, trimSlash } from "../../protocol/src/index.js";
+import { CODEX_HOME, readState, writeSidecarInfo } from "../../state/src/index.js";
+
+const CODEX_MODEL_CAPABILITIES_PATH = join(CODEX_HOME, "model_capabilities.json");
 
 export async function startSidecar(options = {}) {
   const token = options.token || readArg("--token") || process.env.AURORA_SIDECAR_TOKEN || "aurora-local-dev";
@@ -33,7 +37,7 @@ async function handle(request, response, token) {
     return;
   }
   if (request.method === "GET" && url.pathname === "/v1/models") {
-    await proxyModels(response);
+    await proxyModels(response, url);
     return;
   }
   if (request.method === "POST" && isRuntimePath(url.pathname)) {
@@ -43,37 +47,78 @@ async function handle(request, response, token) {
   writeJSON(response, 404, { error: { type: "not_found", message: "unknown sidecar route" } });
 }
 
-async function proxyModels(response) {
+async function proxyModels(response, incomingURL) {
   const state = await readState();
   const gatewayURL = trimSlash(state.gatewayURL ?? "https://auroramos.com");
-  const upstream = await fetch(`${gatewayURL}/v1/aurora-cli/models`, {
-    headers: selectedKeyHeaders(state)
+  const clientVersion = incomingURL.searchParams.get("client_version");
+  const upstreamURL = clientVersion
+    ? `${gatewayURL}/v1/aurora-cli/models?client_version=${encodeURIComponent(clientVersion)}`
+    : `${gatewayURL}/v1/aurora-cli/models`;
+  const upstream = await fetch(upstreamURL, {
+    headers: {
+      ...selectedKeyHeaders(state),
+      "accept-encoding": "identity"
+    }
   });
   const payload = await upstream.json().catch(() => ({ object: "list", data: [] }));
-  const data = Array.isArray(payload.data) ? payload.data.map(toClientModelItem) : [];
+  const sourceModels = Array.isArray(payload.data) ? payload.data : [];
+  if (clientVersion) {
+    await writeCodexModelCapabilities(sourceModels);
+    const models = sourceModels.map((item, index) => toCodexModelInfo(item, index));
+    writeJSON(response, upstream.ok ? 200 : upstream.status, { models });
+    return;
+  }
+  const data = sourceModels.map(toClientModelItem);
   writeJSON(response, upstream.ok ? 200 : upstream.status, { object: "list", data });
 }
 
 async function proxyRuntime(request, response, path) {
   const state = await readState();
   const body = await readBody(request);
+  const capabilitiesByAlias = await readCodexModelCapabilities();
   const gatewayURL = trimSlash(state.gatewayURL ?? "https://auroramos.com");
   const upstream = await fetch(`${gatewayURL}${path}`, {
     method: request.method,
     headers: {
       ...copyForwardHeaders(request.headers),
       ...selectedKeyHeaders(state),
-      "content-type": request.headers["content-type"] ?? "application/json"
+      "content-type": request.headers["content-type"] ?? "application/json",
+      "accept-encoding": "identity"
     },
-    body: rewriteRuntimeModel(body, state.selectedModel?.alias)
+    body: rewriteRuntimeModel(body, state.selectedModel?.alias, capabilitiesByAlias)
   });
-  response.writeHead(upstream.status, Object.fromEntries(upstream.headers.entries()));
+  response.writeHead(upstream.status, responseHeaders(upstream.headers));
   if (upstream.body) {
     for await (const chunk of upstream.body) response.write(chunk);
   }
   response.end();
 }
 
+async function writeCodexModelCapabilities(sourceModels) {
+  const models = {};
+  for (const item of sourceModels) {
+    const alias = String(item.alias ?? item.id ?? item.model_id ?? "");
+    if (!alias) continue;
+    models[alias] = {
+      supports_web_search: item.supports_web_search === true,
+      web_search_tool_type: item.web_search_tool_type ?? null
+    };
+  }
+  await writeFile(CODEX_MODEL_CAPABILITIES_PATH, `${JSON.stringify({
+    generated_at: new Date().toISOString(),
+    models
+  }, null, 2)}\n`, { mode: 0o600 });
+}
+
+async function readCodexModelCapabilities() {
+  try {
+    const payload = JSON.parse(await readFile(CODEX_MODEL_CAPABILITIES_PATH, "utf8"));
+    return payload && typeof payload.models === "object" && payload.models !== null ? payload.models : {};
+  } catch {
+    return {};
+  }
+}
+
 function isAuthorized(request, token) {
   const auth = String(request.headers.authorization ?? "");
   const xKey = String(request.headers["x-api-key"] ?? "");
@@ -83,12 +128,35 @@ function isAuthorized(request, token) {
 function copyForwardHeaders(headers) {
   const out = {};
   for (const [key, value] of Object.entries(headers)) {
-    if (["host", "authorization", "x-api-key", "content-length"].includes(key.toLowerCase())) continue;
+    if (["host", "authorization", "x-api-key", "content-length", "accept-encoding"].includes(key.toLowerCase())) continue;
     if (value !== undefined) out[key] = Array.isArray(value) ? value.join(", ") : value;
   }
   return out;
 }
 
+function responseHeaders(headers) {
+  const out = {};
+  for (const [key, value] of headers.entries()) {
+    const normalized = key.toLowerCase();
+    if ([
+      "connection",
+      "content-encoding",
+      "content-length",
+      "keep-alive",
+      "proxy-authenticate",
+      "proxy-authorization",
+      "te",
+      "trailer",
+      "transfer-encoding",
+      "upgrade"
+    ].includes(normalized)) {
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
 function readBody(request) {
   return new Promise((resolve, reject) => {
     const chunks = [];