@auroraflow/code 0.0.6 → 0.0.8

package/packages/clients/src/index.js

@@ -0,0 +1,299 @@
+import { spawn, spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AURORA_SIDECAR_PORT } from "../../protocol/src/index.js";
+import { CLAUDE_HOME, CODEX_HOME, readSidecarInfo, readState, writeSidecarInfo } from "../../state/src/index.js";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, "..", "..", "..");
+const rootSidecarBin = join(packageRoot, "bin", "aurora-sidecar.js");
+
+const OFFICIAL_CLIENTS = {
+  claude: {
+    name: "Claude Code",
+    packageName: "@anthropic-ai/claude-code",
+    binName: "claude"
+  },
+  codex: {
+    name: "Codex",
+    packageName: "@openai/codex",
+    binName: "codex"
+  }
+};
+
+export async function createClientLaunchSpec(client, args = []) {
+  const sidecar = await ensureSidecar();
+  const state = await readState();
+  const model = selectedModelAlias(state);
+  const key = selectedKey(state);
+  if (client === "claude") {
+    const env = {
+      ...process.env,
+      AURORA_HOME: process.env.AURORA_HOME ?? "",
+      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"
+    };
+    env.ANTHROPIC_MODEL = model;
+    return { command: officialClientBin("claude"), args, env };
+  }
+  await writeCodexRuntimeFiles({ sidecar, model, key });
+  const env = {
+    ...process.env,
+    AURORA_HOME: process.env.AURORA_HOME ?? "",
+    CODEX_HOME,
+    OPENAI_API_KEY: sidecar.token,
+    OPENAI_BASE_URL: `${sidecar.baseURL}/v1`
+  };
+  env.OPENAI_MODEL = model;
+  return { command: officialClientBin("codex"), args, env };
+}
+
+export async function runClient(client, args = []) {
+  const spec = await createClientLaunchSpec(client, args);
+  await spawnAndExit(spec.command, spec.args, spec.env);
+}
+
+export function officialClientStatuses() {
+  return Object.entries(OFFICIAL_CLIENTS).map(([id, client]) => {
+    const bin = resolveOfficialClientBin(client.binName);
+    const packagePath = officialClientPackageJSONPath(client.packageName);
+    const version = readOfficialClientVersion(bin) ?? (packagePath ? JSON.parse(readFileSync(packagePath, "utf8")).version : null);
+    return {
+      id,
+      name: client.name,
+      packageName: client.packageName,
+      bin,
+      installed: Boolean(bin),
+      version
+    };
+  });
+}
+
+export async function updateOfficialClients() {
+  await installOfficialClients();
+}
+
+export async function installOfficialClients() {
+  const npm = process.env.npm_execpath || "npm";
+  const args = ["install", "-g", "@anthropic-ai/claude-code@latest", "@openai/codex@latest"];
+  await spawnAndWait(npm, args, { ...process.env });
+}
+
+export function isGlobalNpmLifecycle() {
+  return process.env.npm_config_global === "true" || process.env.npm_config_location === "global";
+}
+
+function officialClientBin(client) {
+  const spec = OFFICIAL_CLIENTS[client];
+  if (!spec) throw new Error(`unknown official client: ${client}`);
+  const bin = resolveOfficialClientBin(spec.binName);
+  if (!bin) {
+    throw new Error(`${spec.name} is not installed. Run: aurora install-clients`);
+  }
+  return bin;
+}
+
+function resolveOfficialClientBin(binName) {
+  return findPathCommand(binName) ?? localClientBinPath(binName);
+}
+
+function localClientBinPath(binName) {
+  const suffix = process.platform === "win32" ? ".cmd" : "";
+  const bin = join(packageRoot, "node_modules", ".bin", `${binName}${suffix}`);
+  return existsSync(bin) ? bin : null;
+}
+
+function findPathCommand(binName) {
+  const suffixes = process.platform === "win32" ? [".cmd", ".exe", ""] : [""];
+  for (const dir of String(process.env.PATH ?? "").split(delimiter)) {
+    if (!dir) continue;
+    for (const suffix of suffixes) {
+      const candidate = join(dir, `${binName}${suffix}`);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+function officialClientPackageJSONPath(packageName) {
+  const parts = packageName.startsWith("@") ? packageName.split("/") : [packageName];
+  const packagePath = join(packageRoot, "node_modules", ...parts, "package.json");
+  return existsSync(packagePath) ? packagePath : null;
+}
+
+function readOfficialClientVersion(bin) {
+  if (!bin) return null;
+  try {
+    const result = spawnSyncCompat(bin, ["--version"]);
+    if (result.status !== 0) return null;
+    return String(result.stdout || result.stderr || "").trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+async function ensureSidecar() {
+  try {
+    const info = await readSidecarInfo();
+    if (info?.port && info?.token && await pingSidecar(info)) return normalizedSidecarInfo(info);
+  } catch {
+    // Start below.
+  }
+  const token = `aurora-local-${randomBytes(24).toString("hex")}`;
+  const child = spawn(process.execPath, [process.env.AURORA_SIDECAR_BIN || rootSidecarBin, "--token", token], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  child.unref();
+  const info = { port: AURORA_SIDECAR_PORT, token, baseURL: `http://127.0.0.1:${AURORA_SIDECAR_PORT}` };
+  await waitForSidecar(info);
+  await writeSidecarInfo(info);
+  return info;
+}
+
+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]
+name = "Aurora"
+base_url = ${tomlString(`${sidecar.baseURL}/v1`)}
+env_key = "OPENAI_API_KEY"
+wire_api = "responses"
+requires_openai_auth = false
+request_max_retries = 0
+stream_max_retries = 0
+stream_idle_timeout_ms = 300000
+`;
+  const auth = {
+    OPENAI_API_KEY: sidecar.token,
+    tokens: null,
+    last_refresh: null
+  };
+  await writeFile(join(CODEX_HOME, "config.toml"), config, { mode: 0o600 });
+  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) {
+    if (await pingSidecar(info)) return;
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error("Aurora sidecar did not become ready on 127.0.0.1:17878");
+}
+
+async function pingSidecar(info) {
+  try {
+    const normalized = normalizedSidecarInfo(info);
+    const response = await fetch(`${normalized.baseURL}/aurora/status`, {
+      headers: { authorization: `Bearer ${normalized.token}` },
+      signal: AbortSignal.timeout(500)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+function normalizedSidecarInfo(info) {
+  return {
+    port: Number(info.port),
+    token: String(info.token),
+    baseURL: info.baseURL || `http://127.0.0.1:${Number(info.port)}`
+  };
+}
+
+function selectedModelAlias(state) {
+  const model = state.selectedModel?.alias;
+  if (!model) throw new Error("Aurora runtime model is not selected. Select a model in Aurora Desktop > 本机调用.");
+  return model;
+}
+
+function selectedKey(state) {
+  const key = state.selectedKey?.presentedKey;
+  if (!key) throw new Error("Aurora runtime key is not selected. Select a key in Aurora Desktop > 本机调用.");
+  return key;
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value));
+}
+
+async function spawnAndExit(command, args, env) {
+  const child = spawn(command, args, {
+    stdio: "inherit",
+    env,
+    shell: process.platform === "win32" && command.endsWith(".cmd")
+  });
+  child.on("error", error => {
+    console.error(`Failed to start ${command}: ${error.message}`);
+    process.exit(1);
+  });
+  child.on("exit", code => process.exit(code ?? 1));
+}
+
+function spawnAndWait(command, args, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: packageRoot,
+      stdio: "inherit",
+      env,
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("exit", code => {
+      if (code === 0) resolve();
+      else reject(new Error(`${command} exited with code ${code ?? 1}`));
+    });
+  });
+}
+
+function spawnSyncCompat(command, args) {
+  return spawnSync(command, args, {
+    encoding: "utf8",
+    shell: process.platform === "win32" && command.endsWith(".cmd")
+  });
+}

package/packages/protocol/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@aurora/protocol",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  }
+}

package/packages/protocol/src/index.js

@@ -0,0 +1,170 @@
+export const AURORA_SIDECAR_PORT = 17878;
+export const AURORA_LOCALHOST = "127.0.0.1";
+
+export function trimSlash(value) {
+  return String(value).replace(/\/+$/, "");
+}
+
+export function selectedKeyHeaders(state) {
+  const key = state.selectedKey?.presentedKey;
+  return key ? { authorization: `Bearer ${key}`, "x-api-key": key } : {};
+}
+
+export function rewriteRuntimeModel(raw, selectedAlias, capabilitiesByAlias = {}) {
+  if (!raw.trim()) return raw;
+  try {
+    const parsed = JSON.parse(raw);
+    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));
+  return {
+    id: `claude-${provider}/${modelID}`,
+    object: "model",
+    owned_by: provider,
+    display_name: item.display_name || `${provider} / ${item.model_id ?? item.alias ?? item.id}`,
+    aurora_alias: item.alias ?? item.id,
+    aurora_provider: item.provider,
+    aurora_model_id: item.model_id
+  };
+}
+
+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" ||
+    pathname === "/v1/chat/completions" ||
+    pathname === "/v1/messages/count_tokens";
+}

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/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@aurora/sidecar",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  }
+}