claude-multiacc 2.0.57 → 2.0.59

package/lib/model_catalog.json

@@ -0,0 +1,404 @@
+{
+ "claude": {
+  "efforts": [
+   "low",
+   "medium",
+   "high",
+   "xhigh",
+   "max"
+  ],
+  "families": {
+   "fable": 5,
+   "haiku": 2,
+   "mythos": 5,
+   "opus": 4,
+   "sonnet": 3
+  },
+  "fetched_at": "2026-10-14T08:49:41Z",
+  "models": {
+   "claude-fable-5": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "fable",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     5
+    ]
+   },
+   "claude-fable-5-1": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "fable",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     1
+    ]
+   },
+   "claude-haiku-4-5-20251001": {
+    "default_effort": null,
+    "efforts": [],
+    "family": "haiku",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     4,
+     5
+    ]
+   },
+   "claude-haiku-5-5": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "haiku",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     5
+    ]
+   },
+   "claude-opus-4-6": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "max"
+    ],
+    "family": "opus",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     4,
+     6
+    ]
+   },
+   "claude-opus-4-7": {
+    "default_effort": "xhigh",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "opus",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     4,
+     7
+    ]
+   },
+   "claude-opus-4-8": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "opus",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     4,
+     8
+    ]
+   },
+   "claude-opus-5": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "opus",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     5
+    ]
+   },
+   "claude-opus-5-5": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "opus",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     5
+    ]
+   },
+   "claude-sonnet-4-6": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "max"
+    ],
+    "family": "sonnet",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     4,
+     6
+    ]
+   },
+   "claude-sonnet-5": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "sonnet",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     5
+    ]
+   },
+   "claude-sonnet-5-5": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "sonnet",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     5
+    ]
+   }
+  },
+  "source": "release"
+ },
+ "codex": {
+  "efforts": [
+   "none",
+   "minimal",
+   "low",
+   "medium",
+   "high",
+   "xhigh",
+   "max",
+   "ultra"
+  ],
+  "families": {
+   "astra": 4,
+   "luna": 1,
+   "sol": 3,
+   "terra": 2
+  },
+  "fetched_at": "2026-10-14T08:54:28Z",
+  "models": {
+   "codex-auto-review": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": null,
+    "listed": false,
+    "upgrade": null,
+    "version": []
+   },
+   "gpt-5.5": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh"
+    ],
+    "family": null,
+    "listed": false,
+    "upgrade": "gpt-6.1-sol",
+    "version": [
+     5,
+     5
+    ]
+   },
+   "gpt-5.6-luna": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "luna",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     6
+    ]
+   },
+   "gpt-5.6-sol": {
+    "default_effort": "low",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max",
+     "ultra"
+    ],
+    "family": "sol",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     6
+    ]
+   },
+   "gpt-5.6-terra": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max",
+     "ultra"
+    ],
+    "family": "terra",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     6
+    ]
+   },
+   "gpt-6-astra": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max",
+     "ultra"
+    ],
+    "family": "astra",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     6
+    ]
+   },
+   "gpt-6-luna": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "luna",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     6
+    ]
+   },
+   "gpt-6-sol": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max",
+     "ultra"
+    ],
+    "family": "sol",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     6
+    ]
+   },
+   "gpt-6.1-sol": {
+    "default_effort": "low",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max",
+     "ultra"
+    ],
+    "family": "sol",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     6,
+     1
+    ]
+   },
+   "gpt-reserve": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": null,
+    "listed": false,
+    "upgrade": null,
+    "version": []
+   }
+  },
+  "source": "release"
+ },
+ "generated_at": "2026-10-14T08:55:08Z",
+ "schema": 1
+}

package/lib/model_catalog.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""The model/effort catalog of both providers, from the freshest credential-free source (3.8+).
+
+Sources, freshest wins per provider: the catalog shipped beside this file (``model_catalog.json``,
+a snapshot of the lineup, the fallback), a pool's refreshed copy (``<root>/model-catalog.json``, written by
+``refresh`` on every install and self-update and kept current by the limits passes), and the
+caches the CLIs themselves maintain while they run -- Codex's ``<acct>/models_cache.json``
+(rewritten every few minutes by any app-server) and Claude Code's served catalog
+``<acct>/cache/model-catalog/*-cc.json`` (hourly). No request is ever sent: the CLIs already
+fetch these with their own credentials and budgets.
+
+Shape: ``{"schema": 1, "<provider>": {"fetched_at": iso, "source": str, "efforts": [ascending],
+"families": {family: tier}, "models": {id: {"family", "version", "efforts", "default_effort",
+"listed", "upgrade"}}}}``. ``efforts``/``families`` are structure and come from the shipped file;
+``models`` from the freshest source. ``lib/model_match.py`` does the matching.
+"""
+
+import glob
+import json
+import os
+import re
+import sys
+import tempfile
+import time
+
+SHIPPED = os.path.join(os.path.dirname(os.path.abspath(__file__)), "model_catalog.json")
+OVERLAY = "model-catalog.json"
+PROVIDERS = ("claude", "codex")
+CLAUDE_ID = re.compile(r"^claude-(?P<family>[a-z]+)(?:-(?P<version>\d+(?:-\d+)*?))?(?:-\d{8})?$")
+CODEX_ID = re.compile(r"^gpt-(?P<version>\d+(?:\.\d+)*)(?:-(?P<family>[a-z]+))?$")
+
+
+def parse_id(provider, model):
+    """(family, version tuple) of a model id; family None when the id is not understood."""
+    model = re.sub(r"\[\d+[km]\]$", "", model or "", flags=re.I).strip()
+    match = (CLAUDE_ID if provider == "claude" else CODEX_ID).match(model)
+    if not match:
+        return None, ()
+    version = match.group("version") or ""
+    return match.group("family"), tuple(int(part) for part in re.split(r"[.-]", version) if part)
+
+
+def _read_json(path):
+    try:
+        with open(path, "rb") as fh:
+            return json.loads(fh.read().decode("utf-8"))
+    except (OSError, ValueError):
+        return None
+
+
+def _iso(epoch):
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(epoch))
+
+
+def _entry(provider, model, efforts, default, listed, upgrade=None):
+    family, version = parse_id(provider, model)
+    return {"family": family, "version": list(version), "efforts": [e for e in efforts if isinstance(e, str)],
+            "default_effort": default if isinstance(default, str) else None, "listed": bool(listed),
+            "upgrade": upgrade if isinstance(upgrade, str) else None}
+
+
+def codex_cache(path):
+    """A ``models_cache.json`` as a provider section, or None (also for a half-written file)."""
+    doc = _read_json(path)
+    models = doc.get("models") if isinstance(doc, dict) else None
+    if not isinstance(models, list) or not isinstance(doc.get("fetched_at"), str):
+        return None
+    table = {}
+    for item in models:
+        if not isinstance(item, dict) or not isinstance(item.get("slug"), str):
+            continue
+        levels = item.get("supported_reasoning_levels") or []
+        efforts = [lvl.get("effort") for lvl in levels if isinstance(lvl, dict)]
+        upgrade = item.get("upgrade") if isinstance(item.get("upgrade"), dict) else {}
+        table[item["slug"]] = _entry("codex", item["slug"], efforts, item.get("default_reasoning_level"),
+                                     item.get("visibility") == "list", upgrade.get("model"))
+    return {"fetched_at": doc["fetched_at"][:19] + "Z", "source": path, "models": table} if table else None
+
+
+def claude_cache(path):
+    """A served-catalog cache (``*-cc.json``) as a provider section, or None."""
+    doc = _read_json(path)
+    catalog = doc.get("catalog") if isinstance(doc, dict) else None
+    config = catalog.get("config") if isinstance(catalog, dict) else None
+    rows = config.get("models") if isinstance(config, dict) else None
+    if not isinstance(rows, list) or not isinstance(doc.get("fetchedAt"), (int, float)):
+        return None
+    state = catalog.get("state") if isinstance(catalog.get("state"), dict) else {}
+    defaults = {}
+    for item in state.get("thinking_by_model") or []:
+        thinking = item.get("thinking") if isinstance(item, dict) else None
+        if isinstance(thinking, dict) and isinstance(item.get("id"), str):
+            defaults[item["id"]] = thinking.get("effort")
+    table = {}
+    for row in rows:
+        if not isinstance(row, dict) or not isinstance(row.get("id"), str):
+            continue
+        thinking = row.get("thinking") if isinstance(row.get("thinking"), dict) else {}
+        options = [opt.get("id") for opt in thinking.get("effort_options") or [] if isinstance(opt, dict)]
+        table[row["id"]] = _entry("claude", row["id"], options, defaults.get(row["id"]),
+                                  row.get("section") == "main")
+    return {"fetched_at": _iso(doc["fetchedAt"] / 1000.0), "source": path, "models": table} if table else None
+
+
+def sources(roots):
+    """Every candidate section per provider: shipped, overlays, then the CLIs' own caches."""
+    found = {provider: [] for provider in PROVIDERS}
+    shipped = _read_json(SHIPPED) or {}
+    for provider in PROVIDERS:
+        if isinstance(shipped.get(provider), dict) and isinstance(shipped[provider].get("models"), dict):
+            found[provider].append(dict(shipped[provider], source=SHIPPED))
+    for root in [r for r in (roots or {}).values() if r]:
+        overlay = _read_json(os.path.join(root, OVERLAY)) or {}
+        for provider in PROVIDERS:
+            if isinstance(overlay.get(provider), dict) and isinstance(overlay[provider].get("models"), dict):
+                found[provider].append(dict(overlay[provider], source=os.path.join(root, OVERLAY)))
+    codex_root, claude_root = (roots or {}).get("codex"), (roots or {}).get("claude")
+    for path in glob.glob(os.path.join(codex_root, "acct-*", "models_cache.json")) if codex_root else []:
+        section = codex_cache(path)
+        if section:
+            found["codex"].append(section)
+    for path in glob.glob(os.path.join(claude_root, "acct-*", "cache", "model-catalog", "*-cc.json")) \
+            if claude_root else []:
+        section = claude_cache(path)
+        if section:
+            found["claude"].append(section)
+    return found
+
+
+def load(roots=None):
+    """The merged catalog: structure from the shipped file, models from the freshest source."""
+    shipped = _read_json(SHIPPED) or {}
+    found = sources(roots)
+    catalog = {"schema": 1}
+    for provider in PROVIDERS:
+        base = shipped.get(provider) if isinstance(shipped.get(provider), dict) else {}
+        best = max(found[provider], key=lambda s: str(s.get("fetched_at") or ""), default=None)
+        catalog[provider] = {"efforts": list(base.get("efforts") or []), "families": dict(base.get("families") or {}),
+                             "fetched_at": best.get("fetched_at") if best else None,
+                             "source": best.get("source") if best else None,
+                             "models": dict(best.get("models") or {}) if best else {}}
+    return catalog
+
+
+def refresh(roots, if_stale=False, max_age=3600):
+    """Write the merged catalog to every pool root given; ``if_stale`` skips roots whose copy
+    is younger than ``max_age`` seconds. Returns the paths written."""
+    written = []
+    for root in sorted(set(r for r in roots.values() if r)):
+        path = os.path.join(root, OVERLAY)
+        try:
+            if if_stale and time.time() - os.stat(path).st_mtime < max_age:
+                continue
+        except OSError:
+            pass
+        catalog = load(roots)
+        catalog["generated_at"] = _iso(time.time())
+        scratch = None
+        try:
+            handle, scratch = tempfile.mkstemp(prefix=".model-catalog.", dir=root)
+            with os.fdopen(handle, "w", encoding="utf-8") as fh:
+                os.fchmod(fh.fileno(), 0o644)
+                fh.write(json.dumps(catalog, indent=1, sort_keys=True) + "\n")
+            os.replace(scratch, path)
+            written.append(path)
+        except OSError:
+            if scratch:
+                try:
+                    os.unlink(scratch)
+                except OSError:
+                    pass
+    return written
+
+
+def main(argv):
+    roots, verb, if_stale, i = {}, None, False, 0
+    while i < len(argv):
+        if argv[i] in ("--claude-root", "--codex-root") and i + 1 < len(argv):
+            roots[argv[i][2:-5]] = argv[i + 1]
+            i += 2
+        elif argv[i] == "--if-stale":
+            if_stale, i = True, i + 1
+        elif argv[i] in ("refresh", "show") and verb is None:
+            verb, i = argv[i], i + 1
+        else:
+            verb = None
+            break
+    if verb is None:
+        sys.stderr.write("usage: model_catalog.py <refresh|show> [--claude-root R] [--codex-root R] [--if-stale]\n")
+        return 2
+    if verb == "show":
+        print(json.dumps(load(roots), indent=1, sort_keys=True))
+        return 0
+    written = refresh(roots, if_stale)
+    for path in written:
+        print(path)
+    return 0 if written or if_stale or not roots else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/lib/model_match.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Which model and effort a resumed session should run with (Python 3.8+).
+
+Same provider: the session's own model and effort, as its history recorded them. Another
+provider: the model of the same LEVEL -- every family has a level in the catalog (Claude: haiku 2,
+sonnet 3, opus 4, fable 5; Codex: luna 1, terra 2, sol 3, astra 4, so astra <-> opus, sol <->
+sonnet, terra -> haiku <- luna, haiku -> terra, fable -> astra), the source model's level picks
+the destination family, and the newest listed model of that family is the match -- and the
+effort of the same level by name (low, medium, high, xhigh, max), with Codex's ``ultra`` landing
+on ``max`` and its ``minimal``/``none`` on ``low``, clamped to what the destination model
+supports (the nearest level below, else the lowest). An unknown model or effort is simply
+omitted, and the destination CLI applies its own default.
+
+``settings_flags`` renders the result as argv: Claude ``--model M --effort E``; Codex ``-m M -c
+model_reasoning_effort=E`` -- always both, because any single model flag makes Codex drop the
+thread's other saved value (the effort falls back to the model's catalog default).
+"""
+
+import sys
+
+sys.path.insert(0, __import__("os").path.dirname(__import__("os").path.abspath(__file__)))
+from model_catalog import load, parse_id  # noqa: E402
+
+RENAME = {"codex": {"claude": {"ultra": "max", "minimal": "low", "none": "low"}},
+          "claude": {"codex": {}}}
+
+
+def tier(catalog, provider, model, hops=4):
+    """The model's family tier; a retiring model counts as the one the catalog upgrades it to."""
+    section = catalog.get(provider) or {}
+    entry = (section.get("models") or {}).get(model) or {}
+    family = entry.get("family") or parse_id(provider, model)[0]
+    level = (section.get("families") or {}).get(family)
+    if level is None and entry.get("upgrade") and hops:
+        return tier(catalog, provider, entry["upgrade"], hops - 1)
+    return level
+
+
+def current_models(catalog, provider):
+    """family -> the newest listed model of that family. Every listed family is a level of its
+    own, whatever its version: launches are staggered, and a tier must never borrow another
+    family's model while a listed one of its own exists."""
+    best = {}
+    for model, entry in ((catalog.get(provider) or {}).get("models") or {}).items():
+        family = entry.get("family") or parse_id(provider, model)[0]
+        if not family or not entry.get("listed"):
+            continue
+        version = tuple(entry.get("version") or parse_id(provider, model)[1])
+        if family not in best or version > best[family][0]:
+            best[family] = (version, model)
+    return {family: model for family, (_, model) in best.items()}
+
+
+def match_model(catalog, source, model, target):
+    """The target provider's current model at the source model's tier (nearest above, then
+    below, when that exact tier has no current model); None when the source is unknown."""
+    if not model:
+        return None
+    if source == target:
+        return model
+    wanted = tier(catalog, source, model)
+    if wanted is None:
+        return None
+    current = current_models(catalog, target)
+    families = (catalog.get(target) or {}).get("families") or {}
+    ranked = sorted(((level, family) for family, level in families.items() if family in current),
+                    key=lambda item: (abs(item[0] - wanted), -item[0]))
+    return current[ranked[0][1]] if ranked else None
+
+
+def match_effort(catalog, source, effort, target, model):
+    """The same effort by name, renamed between vocabularies, clamped to the target model."""
+    if not effort:
+        return None
+    name = RENAME.get(source, {}).get(target, {}).get(effort, effort) if source != target else effort
+    section = catalog.get(target) or {}
+    scale = list(section.get("efforts") or [])
+    supported = ((section.get("models") or {}).get(model) or {}).get("efforts") or []
+    if name not in scale:
+        return name if not supported or name in supported else None
+    if not supported or name in supported:
+        return name
+    below = [level for level in supported if level in scale and scale.index(level) <= scale.index(name)]
+    return max(below, key=scale.index) if below else min(supported, key=lambda level: scale.index(level)
+                                                           if level in scale else len(scale))
+
+
+def resume_settings(source, settings, target, catalog=None):
+    """{"model", "effort"} for the target provider from a source session's settings."""
+    catalog = catalog or load()
+    model = match_model(catalog, source, (settings or {}).get("model"), target)
+    effort = match_effort(catalog, source, (settings or {}).get("effort"), target, model)
+    if model and not effort and target == "codex":
+        effort = (((catalog.get("codex") or {}).get("models") or {}).get(model) or {}).get("default_effort")
+    return {"model": model, "effort": effort}
+
+
+def settings_flags(provider, model, effort):
+    """argv fragment that pins ``model``/``effort`` for ``provider``; empty when nothing is known."""
+    if provider == "claude":
+        return (["--model", model] if model else []) + (["--effort", effort] if effort else [])
+    if provider == "codex" and model and effort:
+        return ["-m", model, "-c", "model_reasoning_effort=" + effort]
+    return []