xsync-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{xsync_cli-0.1.2 → xsync_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: xsync-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: Sync the model list of an OpenAI-compatible endpoint into the Codex model catalog.
 License-Expression: MIT
 License-File: LICENSE
@@ -79,10 +79,52 @@ Run this command again when the endpoint changes.
 | `xsync codex --reset` | Remove everything that xSync wrote. |
 | `xsync codex --reset --force` | Reset when no state file exists. It asks first. |
 | `xsync codex --reset --force --yes` | Reset with no question. Use this in a script. |
+| `xsync claude` | Sync the active profile into the Claude Code model picker. |
+| `xsync claude --init` | Point Claude Code at the endpoint of the profile. |
+| `xsync claude --dry-run` | Show the difference. Write nothing. |
+| `xsync claude --reset` | Remove everything that xSync wrote. |
+| `xsync help` | Show the help. `xsync help codex` explains one command. |
 
 Exit codes: `0` for success, `1` for an error, `2` when the endpoint does not
 answer.
 
+## Claude Code
+
+    xsync claude --init
+    xsync claude
+
+Claude Code holds no catalog file. It reads the rows of the `/model`
+picker from `modelPicker.options` in `~/.claude/settings.json`, and it reads
+the endpoint from the `env` block of the same file. `xsync claude` writes
+those two keys and nothing else.
+
+The endpoint must answer the Anthropic API at `POST /v1/messages`. An
+endpoint that answers only the OpenAI API works with Codex, not with Claude
+Code.
+
+### The map to a known model
+
+Claude Code refuses a model that it does not know:
+
+    "cmc/deepseek/deepseek-v4-pro" isn't described by this version's model
+    catalog; update Claude Code, or map it with behavesAs on a modelPicker row
+
+Therefore each row carries `behavesAs`: the id of a model that Claude Code
+knows. The prompt profile, the capability defaults, and the effort defaults
+of that model then apply. The model id that Claude Code sends does not
+change.
+
+A model name that already holds a known model id, such as
+`ed3n/claude-sonnet-5`, gets no `behavesAs`. It keeps its native handling.
+
+Edit `adapters/rules/claude.toml` to change a map.
+
+### The built-in models stay
+
+xSync sets `replaceBuiltInOptions` to `false`. The built-in models stay at
+the top of the picker, and the router models come after them. A router that
+stops therefore leaves a working picker.
+
 ## Switch between endpoints
 
 Codex holds one model provider. Therefore one profile is active at a time.
@@ -128,7 +170,7 @@ A glob pattern selects a model by name. The sign `*` means any characters.
 | Rule | Effect |
 |---|---|
 | `include = []` | Keep every model. This is the default. |
-| `include = ["cx/*", "ed3n/*"]` | Keep only the models of those two providers. |
+| `include = ["openai/*", "anthropic/*"]` | Keep only the models of those two providers. |
 | `exclude = ["*embedding*"]` | Drop every model with `embedding` in the name. |
 | `exclude = ["*-image-*", "*-tts-*"]` | Drop the image models and the speech models. |
 

{xsync_cli-0.1.2 → xsync_cli-0.1.4}/README.md

@@ -67,10 +67,52 @@ Run this command again when the endpoint changes.
 | `xsync codex --reset` | Remove everything that xSync wrote. |
 | `xsync codex --reset --force` | Reset when no state file exists. It asks first. |
 | `xsync codex --reset --force --yes` | Reset with no question. Use this in a script. |
+| `xsync claude` | Sync the active profile into the Claude Code model picker. |
+| `xsync claude --init` | Point Claude Code at the endpoint of the profile. |
+| `xsync claude --dry-run` | Show the difference. Write nothing. |
+| `xsync claude --reset` | Remove everything that xSync wrote. |
+| `xsync help` | Show the help. `xsync help codex` explains one command. |
 
 Exit codes: `0` for success, `1` for an error, `2` when the endpoint does not
 answer.
 
+## Claude Code
+
+    xsync claude --init
+    xsync claude
+
+Claude Code holds no catalog file. It reads the rows of the `/model`
+picker from `modelPicker.options` in `~/.claude/settings.json`, and it reads
+the endpoint from the `env` block of the same file. `xsync claude` writes
+those two keys and nothing else.
+
+The endpoint must answer the Anthropic API at `POST /v1/messages`. An
+endpoint that answers only the OpenAI API works with Codex, not with Claude
+Code.
+
+### The map to a known model
+
+Claude Code refuses a model that it does not know:
+
+    "cmc/deepseek/deepseek-v4-pro" isn't described by this version's model
+    catalog; update Claude Code, or map it with behavesAs on a modelPicker row
+
+Therefore each row carries `behavesAs`: the id of a model that Claude Code
+knows. The prompt profile, the capability defaults, and the effort defaults
+of that model then apply. The model id that Claude Code sends does not
+change.
+
+A model name that already holds a known model id, such as
+`ed3n/claude-sonnet-5`, gets no `behavesAs`. It keeps its native handling.
+
+Edit `adapters/rules/claude.toml` to change a map.
+
+### The built-in models stay
+
+xSync sets `replaceBuiltInOptions` to `false`. The built-in models stay at
+the top of the picker, and the router models come after them. A router that
+stops therefore leaves a working picker.
+
 ## Switch between endpoints
 
 Codex holds one model provider. Therefore one profile is active at a time.
@@ -116,7 +158,7 @@ A glob pattern selects a model by name. The sign `*` means any characters.
 | Rule | Effect |
 |---|---|
 | `include = []` | Keep every model. This is the default. |
-| `include = ["cx/*", "ed3n/*"]` | Keep only the models of those two providers. |
+| `include = ["openai/*", "anthropic/*"]` | Keep only the models of those two providers. |
 | `exclude = ["*embedding*"]` | Drop every model with `embedding` in the name. |
 | `exclude = ["*-image-*", "*-tts-*"]` | Drop the image models and the speech models. |
 

{xsync_cli-0.1.2 → xsync_cli-0.1.4}/docs/superpowers/specs/2026-09-13-xsync-design.md

@@ -425,3 +425,75 @@ works against a second endpoint.
 The upload needs a PyPI API token. The token belongs to the user. The token
 never enters the repository. The user supplies it through the environment
 variable `UV_PUBLISH_TOKEN` or through `~/.pypirc`.
+
+## 18. The Claude Code adapter
+
+Date added: 2026-09-13
+
+### 18.1 What Claude Code offers
+
+Claude Code holds no catalog file like Codex. It reads two things from
+`~/.claude/settings.json`:
+
+| Key | Purpose |
+|---|---|
+| `modelPicker.options` | The rows of the `/model` picker, in order. |
+| `modelPicker.replaceBuiltInOptions` | True hides the built-in models. |
+| `env` | The variables that point Claude Code at an endpoint. |
+
+One picker row holds these fields:
+
+| Field | Meaning |
+|---|---|
+| `model` | The model id, taken word for word. |
+| `label` | The row title. |
+| `description` | The row subtitle. |
+| `behavesAs` | The id of a model that this version knows. Its prompt profile, its capability defaults, and its effort defaults then apply. |
+
+Claude Code refuses a model that it does not know:
+
+```
+"cmc/deepseek/deepseek-v4-pro" isn't described by this version's model
+catalog; update Claude Code, or map it with behavesAs on a modelPicker row
+```
+
+A model name that holds a known model id, such as
+`ed3n/claude-sonnet-5`, needs no `behavesAs`.
+
+### 18.2 The proof
+
+Each fact below comes from a test on this machine, not from a document.
+
+1. 9router answers the Anthropic API at `POST /v1/messages`.
+2. `claude -p "say ok" --model ed3n/claude-sonnet-5` answered `ok`.
+3. The same command with `cmc/deepseek/deepseek-v4-pro` failed, until a
+   picker row gave it `behavesAs = "claude-opus-4-8"`. It then answered
+   `ok`.
+4. The variables in the `env` block of `settings.json` are enough. The
+   shell needs no variable.
+
+### 18.3 The design
+
+- `xsync claude` writes `modelPicker.options` into `settings.json`.
+- `replaceBuiltInOptions` stays `false`. The built-in models stay in the
+  picker. The router models come after them. A router that stops
+  therefore leaves a working picker.
+- A rules file `adapters/rules/claude.toml` gives `behavesAs`. It uses
+  the same layers as the Codex rules: defaults, prefix, name, slug.
+- A model whose name holds a known Claude model id gets no `behavesAs`.
+  It keeps its native handling.
+- `xsync claude --init` writes the `env` block with
+  `ANTHROPIC_BASE_URL` and `ANTHROPIC_AUTH_TOKEN`.
+- `xsync claude --reset` removes only what the state file records.
+
+### 18.4 Safety
+
+The file `settings.json` holds the hooks and the settings of the user. It
+is large. Therefore:
+
+- xSync changes the key `modelPicker` only, and the key `env` only with
+  `--init`.
+- The write is atomic. xSync keeps one backup.
+- xSync hashes the file before the edit and again before the replace. On
+  a difference it stops.
+- The state file `~/.claude/.xsync-state.json` records every change.

{xsync_cli-0.1.2 → xsync_cli-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "xsync-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "Sync the model list of an OpenAI-compatible endpoint into the Codex model catalog."
 readme = "README.md"
 requires-python = ">=3.11"

xsync_cli-0.1.4/src/xsync_cli/adapters/claude.py

@@ -0,0 +1,92 @@
+"""The Claude Code adapter.
+
+Claude Code holds no catalog file. It reads the rows of the `/model`
+picker from `modelPicker.options` in `settings.json`. This module makes
+those rows. It knows nothing about HTTP.
+"""
+
+from __future__ import annotations
+
+import tomllib
+from collections.abc import Sequence
+from dataclasses import dataclass
+from importlib.resources import files
+from pathlib import Path
+from typing import Any
+
+from xsync_cli.core.model import Model
+
+
+@dataclass(frozen=True, slots=True)
+class Rules:
+    """The four rule layers, and the list of native model ids."""
+
+    defaults: dict[str, Any]
+    prefixes: dict[str, dict[str, Any]]
+    names: dict[str, dict[str, Any]]
+    slugs: dict[str, dict[str, Any]]
+
+    def for_model(self, model: Model) -> dict[str, Any]:
+        """The merged rule values for one model."""
+        merged: dict[str, Any] = dict(self.defaults)
+        merged.update(self.prefixes.get(model.prefix.lower(), {}))
+        merged.update(self.names.get(model.leaf_name.lower(), {}))
+        merged.update(self.slugs.get(model.slug, {}))
+        return merged
+
+    @property
+    def native_ids(self) -> list[str]:
+        """The model ids that Claude Code knows."""
+        return [str(item).lower() for item in self.defaults.get("native_ids", [])]
+
+
+def load_rules(path: Path | None = None) -> Rules:
+    """Read the rules file. The default file is package data."""
+    if path is None:
+        text = files("xsync_cli.adapters.rules").joinpath("claude.toml").read_text(
+            encoding="utf-8"
+        )
+    else:
+        text = path.read_text(encoding="utf-8")
+    data = tomllib.loads(text)
+    return Rules(
+        defaults=dict(data.get("defaults", {})),
+        prefixes={k.lower(): dict(v) for k, v in (data.get("prefix") or {}).items()},
+        names={k.lower(): dict(v) for k, v in (data.get("name") or {}).items()},
+        slugs={k: dict(v) for k, v in (data.get("slug") or {}).items()},
+    )
+
+
+def is_native(slug: str, rules: Rules) -> bool:
+    """True when Claude Code already knows how to drive this model.
+
+    Claude Code matches a known model id inside the name of the model.
+    Therefore `ed3n/claude-sonnet-5` needs no map.
+    """
+    lowered = slug.lower()
+    return any(known in lowered for known in rules.native_ids)
+
+
+def _label(model: Model) -> str:
+    words = model.leaf_name.replace("_", "-").split("-")
+    return " ".join(word[:1].upper() + word[1:] for word in words if word)
+
+
+def render_rows(models: Sequence[Model], rules: Rules) -> list[dict[str, Any]]:
+    """One picker row for each model.
+
+    A row holds `behavesAs` only when Claude Code does not know the
+    model. Claude Code refuses such a model without that field.
+    """
+    rows: list[dict[str, Any]] = []
+    for model in models:
+        values = rules.for_model(model)
+        row: dict[str, Any] = {
+            "model": model.slug,
+            "label": values.get("label") or _label(model),
+            "description": str(values["description_template"]).format(slug=model.slug),
+        }
+        if not is_native(model.slug, rules):
+            row["behavesAs"] = values["behaves_as"]
+        rows.append(row)
+    return rows

xsync_cli-0.1.4/src/xsync_cli/adapters/claude_config.py

@@ -0,0 +1,206 @@
+"""The reader and the writer of the Claude Code settings.
+
+Claude Code keeps the rows of the `/model` picker in
+`modelPicker.options`. It keeps the endpoint in the `env` block. This
+module changes those two keys and nothing else.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import hashlib
+import json
+import os
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+from xsync_cli.core.profiles import Profile
+
+STATE_FILENAME = ".xsync-state.json"
+STATE_VERSION = 1
+BASE_URL_KEY = "ANTHROPIC_BASE_URL"
+TOKEN_KEY = "ANTHROPIC_AUTH_TOKEN"
+PICKER_KEY = "modelPicker"
+
+
+class ClaudeConfigError(Exception):
+    """The settings file cannot be read or written."""
+
+
+def default_claude_home() -> Path:
+    """The Claude Code home directory."""
+    return Path(os.environ.get("CLAUDE_CONFIG_DIR") or Path.home() / ".claude")
+
+
+def settings_path_for(claude_home: Path) -> Path:
+    """The settings file of that home."""
+    return claude_home / "settings.json"
+
+
+def file_sha256(path: Path) -> str:
+    """The hash of a file. An absent file gives an empty string."""
+    if not path.exists():
+        return ""
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def read_settings(path: Path) -> dict[str, Any]:
+    """Read the settings. An absent file gives an empty mapping."""
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as error:
+        raise ClaudeConfigError(f"{path} is not valid JSON: {error}") from None
+    if not isinstance(data, dict):
+        raise ClaudeConfigError(f"{path} does not hold a JSON object.")
+    return data
+
+
+def base_url_of(settings: dict[str, Any]) -> str | None:
+    """The endpoint that Claude Code uses."""
+    value = (settings.get("env") or {}).get(BASE_URL_KEY)
+    return str(value).rstrip("/") if value else None
+
+
+def check_endpoint_match(settings: dict[str, Any], profile: Profile) -> str | None:
+    """Confirm that Claude Code talks to the endpoint of the profile."""
+    current = base_url_of(settings)
+    if current is None:
+        return (
+            "Claude Code has no endpoint.\n"
+            f"run: xsync claude --profile {profile.name} --init"
+        )
+    if current != profile.base_url:
+        return (
+            f'the rows would come from "{profile.name}" ({profile.base_url})\n'
+            f"but Claude Code talks to {current}\n"
+            f"run: xsync claude --profile {profile.name} --init"
+        )
+    return None
+
+
+@dataclass(frozen=True, slots=True)
+class State:
+    """The record of what xSync wrote into the settings."""
+
+    profile: str
+    keys_written: list[str] = field(default_factory=list)
+    settings_sha256: str = ""
+    written_at: str = ""
+
+
+def _now() -> str:
+    return dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _write_atomic(path: Path, data: dict[str, Any], before: str) -> None:
+    """Write the settings only when the file did not change."""
+    if file_sha256(path) != before:
+        raise ClaudeConfigError(
+            f"{path} changed during the edit. Close Claude Code and try again."
+        )
+    text = json.dumps(data, indent=2, ensure_ascii=False) + "\n"
+    json.loads(text)
+    temporary = path.with_name(path.name + ".tmp")
+    temporary.write_text(text, encoding="utf-8")
+    if path.exists():
+        path.with_name(path.name + ".bak").write_bytes(path.read_bytes())
+    os.replace(temporary, path)
+
+
+def init_settings(path: Path, profile: Profile, api_key: str | None) -> State:
+    """Point Claude Code at the endpoint of the profile."""
+    before = file_sha256(path)
+    settings = read_settings(path)
+
+    environment = dict(settings.get("env") or {})
+    environment[BASE_URL_KEY] = profile.base_url
+    keys = [f"env.{BASE_URL_KEY}"]
+    if api_key:
+        environment[TOKEN_KEY] = api_key
+        keys.append(f"env.{TOKEN_KEY}")
+    settings["env"] = environment
+
+    _write_atomic(path, settings, before)
+    return State(
+        profile=profile.name,
+        keys_written=keys,
+        settings_sha256=file_sha256(path),
+        written_at=_now(),
+    )
+
+
+def write_picker(path: Path, rows: list[dict[str, Any]]) -> None:
+    """Write the rows of the `/model` picker.
+
+    The value `replaceBuiltInOptions` stays false. The built-in models
+    stay in the picker, and the rows come after them. A router that
+    stops therefore leaves a working picker.
+    """
+    before = file_sha256(path)
+    settings = read_settings(path)
+    settings[PICKER_KEY] = {"options": rows, "replaceBuiltInOptions": False}
+    _write_atomic(path, settings, before)
+
+
+def current_rows(settings: dict[str, Any]) -> list[dict[str, Any]]:
+    """The rows that the settings hold now."""
+    picker = settings.get(PICKER_KEY) or {}
+    rows = picker.get("options")
+    return list(rows) if isinstance(rows, list) else []
+
+
+def reset_settings(path: Path, state: State) -> list[str]:
+    """Remove every key that the state records."""
+    before = file_sha256(path)
+    settings = read_settings(path)
+    removed: list[str] = []
+
+    for key in state.keys_written:
+        parent, _, child = key.partition(".")
+        if child:
+            table = settings.get(parent)
+            if isinstance(table, dict) and child in table:
+                del table[child]
+                removed.append(key)
+                if not table:
+                    del settings[parent]
+        elif parent in settings:
+            del settings[parent]
+            removed.append(parent)
+
+    _write_atomic(path, settings, before)
+    return removed
+
+
+def read_state(path: Path) -> State | None:
+    """Read the state file. An absent file gives None."""
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as error:
+        raise ClaudeConfigError(f"{path} is not valid JSON: {error}") from None
+    entry = data.get("claude") or {}
+    return State(
+        profile=entry.get("profile", ""),
+        keys_written=list(entry.get("keys_written", [])),
+        settings_sha256=entry.get("settings_sha256", ""),
+        written_at=entry.get("written_at", ""),
+    )
+
+
+def write_state(path: Path, state: State) -> None:
+    """Write the state file."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps({"version": STATE_VERSION, "claude": asdict(state)}, indent=2),
+        encoding="utf-8",
+    )
+
+
+def clear_state(path: Path) -> None:
+    """Delete the state file."""
+    path.unlink(missing_ok=True)

{xsync_cli-0.1.2 → xsync_cli-0.1.4}/src/xsync_cli/adapters/codex.py

@@ -58,16 +58,24 @@ def _read_prompt(name: str) -> str:
 
 @dataclass(frozen=True, slots=True)
 class Rules:
-    """The three rule layers."""
+    """The four rule layers.
+
+    A router gives the same model a different slug. The model gpt-5.5
+    is `cx/gpt-5.5` on one router and `openai/gpt-5.5` on another one.
+    Therefore a name rule matches the last slug segment, and it works
+    on every router. A slug rule still wins over a name rule.
+    """
 
     defaults: dict[str, Any]
     prefixes: dict[str, dict[str, Any]]
+    names: dict[str, dict[str, Any]]
     slugs: dict[str, dict[str, Any]]
 
     def for_model(self, model: Model) -> dict[str, Any]:
         """The merged rule values for one model."""
         merged: dict[str, Any] = dict(self.defaults)
-        merged.update(self.prefixes.get(model.prefix, {}))
+        merged.update(self.prefixes.get(model.prefix.lower(), {}))
+        merged.update(self.names.get(model.leaf_name.lower(), {}))
         merged.update(self.slugs.get(model.slug, {}))
         return merged
 
@@ -83,7 +91,8 @@ def load_rules(path: Path | None = None) -> Rules:
     data = tomllib.loads(text)
     return Rules(
         defaults=dict(data.get("defaults", {})),
-        prefixes={k: dict(v) for k, v in (data.get("prefix") or {}).items()},
+        prefixes={k.lower(): dict(v) for k, v in (data.get("prefix") or {}).items()},
+        names={k.lower(): dict(v) for k, v in (data.get("name") or {}).items()},
         slugs={k: dict(v) for k, v in (data.get("slug") or {}).items()},
     )
 
@@ -103,7 +112,8 @@ def render_entry(model: Model, rules: Rules) -> dict[str, Any]:
         "slug": model.slug,
         "display_name": values.get("display_name") or _display_name(model),
         "description": str(values["description_template"]).format(slug=model.slug),
-        "default_reasoning_level": "medium" if model.reasoning else None,
+        # Codex accepts a string here. A null stops Codex at startup.
+        "default_reasoning_level": values["default_reasoning_level"],
         "supported_reasoning_levels": (
             [dict(level) for level in REASONING_LEVELS] if model.reasoning else []
         ),
@@ -127,9 +137,10 @@ def render_entry(model: Model, rules: Rules) -> dict[str, Any]:
         "support_verbosity": values["support_verbosity"],
         "default_verbosity": values["default_verbosity"],
         "apply_patch_tool_type": values["apply_patch_tool_type"],
-        "web_search_tool_type": (
-            values["web_search_tool_type"] if model.search else None
-        ),
+        # Codex accepts a string or a map here. A null stops Codex at
+        # startup. The flag supports_search_tool carries the fact from
+        # the endpoint.
+        "web_search_tool_type": values["web_search_tool_type"],
         "truncation_policy": values["truncation_policy"],
         "supports_parallel_tool_calls": model.tools,
         "supports_image_detail_original": values["supports_image_detail_original"],

xsync_cli-0.1.4/src/xsync_cli/adapters/rules/claude.toml

@@ -0,0 +1,51 @@
+# Claude Code refuses a model that it does not know. A picker row gives
+# it `behavesAs`: the id of a model that Claude Code knows. The prompt
+# profile, the capability defaults, and the effort defaults of that
+# model then apply.
+#
+# A model name that already holds a known model id needs no behavesAs.
+# The list `native_ids` holds those known ids.
+#
+# The layers apply in this order. A later layer wins:
+#   1. defaults
+#   2. prefix.<first slug segment>
+#   3. name.<last slug segment>      matches on every router
+#   4. slug."<exact slug>"           matches one router only
+
+[defaults]
+behaves_as = "claude-opus-4-8"
+description_template = "{slug}"
+
+# A model name that holds one of these ids keeps its native handling.
+native_ids = [
+  "claude-opus-5",
+  "claude-opus-4-8",
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  "claude-opus-4-5",
+  "claude-opus-4-1",
+  "claude-opus-4",
+  "claude-sonnet-5",
+  "claude-sonnet-4-6",
+  "claude-sonnet-4-5",
+  "claude-sonnet-4",
+  "claude-sonnet-3-7",
+  "claude-haiku-4-5",
+  "claude-haiku-4",
+  "claude-haiku-3-5",
+  "claude-fable-5-1",
+  "claude-fable-5",
+]
+
+# A small or fast model works better with the handling of a small model.
+[name."deepseek-v4.1-flash"]
+behaves_as = "claude-haiku-4-5"
+
+[name."deepseek-v4-flash"]
+behaves_as = "claude-haiku-4-5"
+
+[name."step-3.5-flash"]
+behaves_as = "claude-haiku-4-5"
+
+[name."gpt-5.4-mini"]
+behaves_as = "claude-sonnet-4-6"

{xsync_cli-0.1.2 → xsync_cli-0.1.4}/src/xsync_cli/adapters/rules/codex.toml

@@ -8,7 +8,12 @@
 # The layers apply in this order. A later layer wins:
 #   1. defaults
 #   2. prefix.<first slug segment>
-#   3. slug."<exact slug>"
+#   3. name.<last slug segment>      matches on every router
+#   4. slug."<exact slug>"           matches one router only
+#
+# Prefer a name rule. A router gives the same model a different slug.
+# The model gpt-5.5 is "cx/gpt-5.5" on one router and "openai/gpt-5.5"
+# on another one. A name rule matches both.
 
 [defaults]
 base_instructions_file = "generic-codex.md"
@@ -20,6 +25,7 @@ shell_type = "shell_command"
 supported_in_api = true
 apply_patch_tool_type = "freeform"
 web_search_tool_type = "text_and_image"
+default_reasoning_level = "medium"
 supports_reasoning_summaries = true
 default_reasoning_summary = "none"
 support_verbosity = true
@@ -40,9 +46,10 @@ limit = 10000
 priority = 10
 
 # The two OpenAI models carry their own prompts and their own speed
-# tiers. The values come from the working catalog.
+# tiers. The values come from the working catalog. A name rule matches
+# the model on every router.
 
-[slug."cx/gpt-5.5"]
+[name."gpt-5.5"]
 base_instructions_file = "gpt-5.5.md"
 model_messages_file = "gpt-5.5.messages.json"
 priority = 18
@@ -53,7 +60,7 @@ service_tiers = [
   { id = "priority", name = "Fast", description = "1.5x speed, increased usage" },
 ]
 
-[slug."cx/gpt-5.4"]
+[name."gpt-5.4"]
 base_instructions_file = "gpt-5.4.md"
 model_messages_file = "gpt-5.4.messages.json"
 priority = 14