eggpool 0.2.0__tar.gz → 0.2.2__tar.gz

{eggpool-0.2.0 → eggpool-0.2.2}/CHANGELOG.md

@@ -7,6 +7,48 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.2] - 2026-06-25
+
+### Fixed
+
+- Catalog no longer accumulates orphans when an upstream provider
+  withdraws a model. `ModelCatalogCache.update_from_account` now
+  records the per-account `(model_id, provider_id)` keys it
+  advertises and clears stale per-provider rows on the next
+  refresh; `prune_unused()` drops entries from `_models` and
+  `_account_support` that have no remaining reference, and
+  `CatalogService.refresh()` calls it after every per-account
+  gather. The "Skipping unresolved model during catalog
+  persistence" warning now fires once per model id per process
+  and is demoted to DEBUG on subsequent cycles, so a persistent
+  unresolved upstream name no longer spams the log.
+- A new reconciliation pass runs at the end of
+  `_persist_catalog` to align the durable catalog with the live
+  cache. Models that are no longer advertised by any account are
+  deleted; rows with historical request or reservation history
+  are relinked to a shared `__deprecated__` placeholder while
+  the original id is preserved in the new
+  `requests.original_model_id` and `reservations.original_model_id`
+  columns. Orphan `provider_model_metadata` rows and disabled
+  `account_models` rows with no request history are also
+  removed. Migration `0023_deprecated_model_placeholder.sql`
+  inserts the placeholder and adds the two new columns.
+  Stats queries use `COALESCE(original_model_id, model_id)` so
+  dashboard widgets continue to attribute historical usage to
+  the real model name.
+
+## [0.2.1] - 2026-06-24
+
+### Fixed
+
+- `eggpool serve` returning 500 with `TypeError: 'NoneType' object is not
+  callable` on Python 3.14 / spawn-based multiprocessing start methods.
+  Granian workers re-import `eggpool.cli` in a fresh interpreter, so the
+  module-level `_app` set by the parent process was `None` in the worker
+  and the `target_loader` returned `None` as the ASGI callback. `_app_loader`
+  now rebuilds the `FastAPI` app from the config path inside each worker.
+  Follow-up to the [0.1.4] module-level loader fix.
+
 ## [0.2.0] - 2026-06-24
 
 ### Added

{eggpool-0.2.0 → eggpool-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eggpool
-Version: 0.2.0
+Version: 0.2.2
 Summary: A lightweight proxy that aggregates multiple LLM provider accounts behind one OpenAI-compatible endpoint
 Project-URL: Homepage, https://github.com/eggstack/eggpool
 Project-URL: Repository, https://github.com/eggstack/eggpool

{eggpool-0.2.0 → eggpool-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "eggpool"
-version = "0.2.0"
+version = "0.2.2"
 description = "A lightweight proxy that aggregates multiple LLM provider accounts behind one OpenAI-compatible endpoint"
 readme = "README.md"
 requires-python = ">=3.11"

{eggpool-0.2.0 → eggpool-0.2.2}/scripts/check_database.py

@@ -61,7 +61,7 @@ class InvariantQueryError(CheckerError):
 #: Highest migration number this checker knows how to inspect.
 #: If the database is older or newer than this, the checker
 #: returns exit code 2 with a clear message.
-EXPECTED_SCHEMA_VERSION = 22
+EXPECTED_SCHEMA_VERSION = 23
 
 #: Required tables for the production EggPool schema.
 REQUIRED_TABLES: frozenset[str] = frozenset(
@@ -107,10 +107,11 @@ REQUIRED_COLUMNS: dict[str, frozenset[str]] = {
             "cache_write_tokens",
             "reasoning_tokens",
             "provider_id",
+            "original_model_id",
         }
     ),
     "request_attempts": frozenset({"id", "request_id", "completed_at"}),
-    "reservations": frozenset({"id", "request_id", "status"}),
+    "reservations": frozenset({"id", "request_id", "status", "original_model_id"}),
     "models": frozenset({"model_id", "protocol", "resolution_status", "provider_id"}),
     "model_price_snapshots": frozenset({"source"}),
     "provider_pings": frozenset(

{eggpool-0.2.0 → eggpool-0.2.2}/scripts/install.sh

@@ -89,6 +89,10 @@ echo "Checking for pipx..."
 if "$PYTHON" -m pipx --version >/dev/null 2>&1; then
     echo "Installing eggpool via pipx (Python $PYTHON_VERSION)..."
     "$PYTHON" -m pipx install eggpool
+    # Ensure ~/.local/bin is on PATH so subsequent shell invocations
+    # (and any helpers invoked below) can find the freshly-installed
+    # `eggpool` binary.
+    export PATH="$HOME/.local/bin:$PATH"
     echo "Installation complete. Run 'eggpool onboard' to start."
 else
     # Check for uv

{eggpool-0.2.0 → eggpool-0.2.2}/scripts/verify_upstream_auth.py

@@ -149,7 +149,6 @@ def _run_single_check(
     )
 
 
-_STREAM_TIMEOUT = 15.0
 _DEFAULT_SENSITIVE_HEADERS = frozenset({"authorization", "x-api-key", "x-goog-api-key"})
 
 
@@ -809,24 +808,15 @@ def main() -> int:
         failed = [r for r in all_results if not r.ok]
         if not args.verbose:
             for r in all_results:
-                if r.failure_class == "usage_missing":
-                    marker = "\u26a0\ufe0f"
-                elif r.ok:
-                    marker = "OK"
-                else:
-                    marker = "FAIL"
+                marker = "OK" if r.ok else "FAIL"
                 sys.stdout.write(
                     f"  [{marker}] {r.provider_id}/{r.account_name} "
                     f"{r.family}: {r.detail}\n"
                 )
 
         if failed:
-            non_usage = [r for r in failed if r.failure_class != "usage_missing"]
-            if non_usage:
-                sys.stdout.write(
-                    f"\n{len(non_usage)}/{len(all_results)} checks failed\n"
-                )
-                return 1
+            sys.stdout.write(f"\n{len(failed)}/{len(all_results)} checks failed\n")
+            return 1
         sys.stdout.write(f"\nAll {len(all_results)} checks passed\n")
         return 0
 

{eggpool-0.2.0 → eggpool-0.2.2}/src/eggpool/catalog/cache.py

@@ -7,6 +7,7 @@ import time
 from typing import Any, cast
 
 from eggpool.catalog.limits import EffectiveModelLimits, conservative_limits
+from eggpool.constants import DEPRECATED_MODEL_ID
 from eggpool.routing.provider import parse_model_provider
 
 logger = logging.getLogger(__name__)
@@ -39,6 +40,12 @@ class ModelCatalogCache:
         self._last_refresh: float = 0.0
         # Per-account last successful refresh timestamp
         self._account_last_refresh: dict[str, float] = {}
+        # Per-account set of (model_id, provider_id) keys the account
+        # currently advertises.  Used by ``update_from_account`` to
+        # drop stale ``_provider_models`` rows when an upstream removes
+        # a model from a single account, so the in-memory cache can
+        # converge with the live catalog.
+        self._account_provider_keys: dict[str, set[tuple[str, str]]] = {}
 
     def update_from_account(
         self,
@@ -54,6 +61,27 @@ class ModelCatalogCache:
         # exposed or routed for this account while other accounts'
         # support remains intact.
         self.mark_account_models_unavailable(account_name)
+
+        # Drop any per-provider rows this account used to advertise
+        # but the new response no longer includes.  A row survives when
+        # at least one other account on the same provider still
+        # publishes it; otherwise it is removed so the in-memory cache
+        # converges with the live catalog.
+        new_keys: set[tuple[str, str]] = set()
+        for model in models:
+            new_keys.add((model["model_id"], provider_id))
+        prior_keys = self._account_provider_keys.get(account_name, set())
+        if prior_keys - new_keys:
+            surviving: set[tuple[str, str]] = set()
+            for other_acct, other_keys in self._account_provider_keys.items():
+                if other_acct == account_name:
+                    continue
+                surviving |= other_keys
+            for stale_key in prior_keys - new_keys:
+                if stale_key not in surviving:
+                    self._provider_models.pop(stale_key, None)
+        self._account_provider_keys[account_name] = new_keys
+
         for model in models:
             model_id = model["model_id"]
             provider_key = (model_id, provider_id)
@@ -239,11 +267,15 @@ class ModelCatalogCache:
 
         Excludes models with unresolved protocol (None) since they
         cannot be routed to any endpoint.  When multiple providers
-        advertise the same model, uses per-provider metadata.
+        advertise the same model, uses per-provider metadata.  The
+        ``__deprecated__`` placeholder is also excluded; it only
+        exists in the durable layer for relinking historical usage.
         """
         result: list[dict[str, Any]] = []
 
         for model_id, _model_info in self._models.items():
+            if model_id == DEPRECATED_MODEL_ID:
+                continue
             accounts_supporting = self._account_support.get(model_id, set())
             visible_accounts = accounts_supporting & eligible_account_names
 
@@ -298,6 +330,8 @@ class ModelCatalogCache:
 
         result: list[dict[str, Any]] = []
         for model_id in self._models:
+            if model_id == DEPRECATED_MODEL_ID:
+                continue
             accounts_supporting = self._account_support.get(model_id, set())
 
             # Group supporting accounts by provider
@@ -634,3 +668,29 @@ class ModelCatalogCache:
     ) -> None:
         """Set a per-provider model entry."""
         self._provider_models[(model_id, provider_id)] = model_info
+
+    def prune_unused(self) -> int:
+        """Drop cache entries no longer referenced by any account or provider.
+
+        A model is removed from ``_models`` only when both:
+
+        * its ``_account_support`` set is empty (no live account can route
+          the model), and
+        * no ``_provider_models`` row exists for any provider.
+
+        Returns the number of models removed. The returned count is
+        intended for log diagnostics; tests assert on it to prove that
+        withdraw-from-every-account actually clears the in-memory state.
+        """
+        referenced: set[str] = set()
+        for model_id in self._account_support:
+            if self._account_support[model_id]:
+                referenced.add(model_id)
+        for model_id, _provider_id in self._provider_models:
+            referenced.add(model_id)
+
+        stale = [model_id for model_id in self._models if model_id not in referenced]
+        for model_id in stale:
+            del self._models[model_id]
+            self._account_support.pop(model_id, None)
+        return len(stale)

{eggpool-0.2.0 → eggpool-0.2.2}/src/eggpool/catalog/service.py

@@ -17,8 +17,12 @@ from eggpool.catalog.pricing import (
     parse_price_per_1k,
 )
 from eggpool.catalog.protocols import SUPPORTED_PROTOCOLS, ModelProtocolResolver
-from eggpool.constants import DEFAULT_PROVIDER_ID
-from eggpool.db.repositories import PingRepository, PriceSnapshotRepository
+from eggpool.constants import DEFAULT_PROVIDER_ID, DEPRECATED_MODEL_ID
+from eggpool.db.repositories import (
+    CatalogReconciliationRepository,
+    PingRepository,
+    PriceSnapshotRepository,
+)
 from eggpool.providers.client_pool import ProviderClientPool
 
 if TYPE_CHECKING:
@@ -148,6 +152,12 @@ class CatalogService:
         self._protocol_resolver = ModelProtocolResolver(config)
         self._limit_resolver = ModelLimitResolver(config)
         self._price_change_callback: Callable[[str, str | None], None] | None = None
+        # Track model_ids that have already produced an unresolved-protocol
+        # warning during persistence. A persistent unresolved model would
+        # otherwise spam the log every refresh cycle; the warning is the
+        # signal that an upstream name needs a TOML override or family
+        # mapping, not a per-cycle event.
+        self._warned_unresolved_models: set[str] = set()
 
     def set_price_change_callback(
         self, callback: Callable[[str, str | None], None]
@@ -230,6 +240,13 @@ class CatalogService:
             if tasks:
                 await asyncio.gather(*tasks, return_exceptions=True)
 
+            # Drop models no longer referenced by any account or provider
+            # so the in-memory cache converges with the live catalog and
+            # downstream persistence no longer needs to skip them.
+            pruned = self._cache.prune_unused()
+            if pruned:
+                logger.info("Pruned %d stale model(s) from catalog cache", pruned)
+
             # Persist the updated catalog
             await self._persist_catalog()
 
@@ -386,7 +403,9 @@ class CatalogService:
             rows = await self._db.fetch_all(
                 "SELECT model_id, display_name, protocol, "
                 "capabilities, source_metadata, "
-                "first_seen_at, last_seen_at, protocol_source FROM models"
+                "first_seen_at, last_seen_at, protocol_source FROM models "
+                "WHERE model_id <> ?",
+                (DEPRECATED_MODEL_ID,),
             )
             for row in rows:
                 model_id = str(row["model_id"])
@@ -415,7 +434,9 @@ class CatalogService:
                 "SELECT model_id, provider_id, display_name, protocol, "
                 "capabilities, source_metadata, protocol_source, "
                 "first_seen_at, last_seen_at "
-                "FROM provider_model_metadata"
+                "FROM provider_model_metadata "
+                "WHERE model_id <> ?",
+                (DEPRECATED_MODEL_ID,),
             )
             for row in provider_rows:
                 provider_id = str(row["provider_id"])
@@ -542,12 +563,25 @@ class CatalogService:
         desired_support: set[tuple[int, str]] = set()
 
         for model_id, model_info in self._cache.get_all_models().items():
+            if model_id == DEPRECATED_MODEL_ID:
+                # The placeholder only exists in the durable layer so
+                # historical request rows can keep their FK after the
+                # upstream model is deleted. Never treat it as a live
+                # catalog entry.
+                continue
             protocol = model_info.get("protocol")
             if protocol not in SUPPORTED_PROTOCOLS:
-                logger.warning(
-                    "Skipping unresolved model during catalog persistence: %s",
-                    model_id,
-                )
+                if model_id in self._warned_unresolved_models:
+                    logger.debug(
+                        "Skipping unresolved model during catalog persistence: %s",
+                        model_id,
+                    )
+                else:
+                    logger.warning(
+                        "Skipping unresolved model during catalog persistence: %s",
+                        model_id,
+                    )
+                    self._warned_unresolved_models.add(model_id)
                 continue
 
             protocol_source = model_info.get("protocol_source")
@@ -676,6 +710,157 @@ class CatalogService:
                         latest=latest_prices.get((pid_model_id, pid)),
                     )
 
+            # Reconcile the durable catalog with the live cache.
+            # Models and provider rows that are no longer advertised
+            # by any account are deleted; rows with historical
+            # request/reservation references are relinked to the
+            # placeholder so usage data is preserved.
+            await self._reconcile_catalog(persisted_model_ids)
+
+    async def _reconcile_catalog(self, live_model_ids: set[str]) -> None:
+        """Align the durable catalog tables with the live in-memory cache.
+
+        The caller's transaction is already open. Steps:
+
+        1. Ensure the placeholder ``models`` row exists.
+        2. Relink any durable model row that is not in the live
+           cache and that has historical ``requests`` or
+           ``reservations`` references. The original id is preserved
+           in ``original_model_id``; the FK pointer moves to
+           ``__deprecated__``.
+        3. Delete the (now-referenced-free) original ``models`` rows
+           and any ``provider_model_metadata`` rows that the live
+           cache no longer carries.
+        4. Delete ``account_models`` rows that are currently
+           disabled and have no recent ``requests`` activity so old
+           withdraw-enable toggles do not accumulate.
+
+        Errors during relink leave the durable state unchanged:
+        SQLite is the only place these rows are mutated, so the
+        catch-and-log branch is informational only.
+        """
+        reconciliation = CatalogReconciliationRepository(self._db)
+        await reconciliation.ensure_placeholder()
+
+        # Step 1: collect durable model ids that the live cache no
+        # longer carries. The placeholder must be excluded so it is
+        # never a candidate for relink or deletion.
+        durable_rows = await self._db.fetch_all(
+            "SELECT model_id FROM models WHERE model_id <> ?",
+            (DEPRECATED_MODEL_ID,),
+        )
+        durable_model_ids = {str(row["model_id"]) for row in durable_rows}
+        withdrawn_ids = durable_model_ids - live_model_ids
+
+        if not withdrawn_ids and not await self._has_orphan_provider_rows(
+            live_model_ids
+        ):
+            return
+
+        relinked_total = 0
+        deleted_models = 0
+        for withdrawn_id in sorted(withdrawn_ids):
+            try:
+                counts = await reconciliation.relink_model(withdrawn_id)
+            except Exception:
+                logger.exception(
+                    "Failed to relink withdrawn model %r; leaving row in place",
+                    withdrawn_id,
+                )
+                continue
+            if counts["requests"] or counts["reservations"]:
+                relinked_total += counts["requests"] + counts["reservations"]
+                logger.info(
+                    "Relinked withdrawn model %r: %d request(s), "
+                    "%d reservation(s) moved to %r",
+                    withdrawn_id,
+                    counts["requests"],
+                    counts["reservations"],
+                    DEPRECATED_MODEL_ID,
+                )
+            await self._db.execute_write(
+                "DELETE FROM account_models WHERE model_id = ?",
+                (withdrawn_id,),
+            )
+            await self._db.execute_write(
+                "DELETE FROM provider_model_metadata WHERE model_id = ?",
+                (withdrawn_id,),
+            )
+            await self._db.execute_write(
+                "DELETE FROM models WHERE model_id = ?",
+                (withdrawn_id,),
+            )
+            deleted_models += 1
+
+        deleted_provider_rows = await self._delete_orphan_provider_rows(live_model_ids)
+        deleted_account_links = await self._delete_stale_account_links()
+
+        if deleted_models or deleted_provider_rows or deleted_account_links:
+            logger.info(
+                "Catalog reconciliation: relinked=%d rows, "
+                "deleted_models=%d, deleted_provider_rows=%d, "
+                "deleted_account_links=%d",
+                relinked_total,
+                deleted_models,
+                deleted_provider_rows,
+                deleted_account_links,
+            )
+
+    async def _has_orphan_provider_rows(self, live_model_ids: set[str]) -> bool:
+        """Return whether durable provider rows reference a withdrawn model."""
+        rows = await self._db.fetch_all(
+            "SELECT model_id FROM provider_model_metadata WHERE model_id <> ?",
+            (DEPRECATED_MODEL_ID,),
+        )
+        durable = {str(r["model_id"]) for r in rows}
+        return bool(durable - live_model_ids)
+
+    async def _delete_orphan_provider_rows(self, live_model_ids: set[str]) -> int:
+        """Delete ``provider_model_metadata`` rows the live cache no longer carries."""
+        rows = await self._db.fetch_all(
+            "SELECT model_id, provider_id FROM provider_model_metadata "
+            "WHERE model_id <> ?",
+            (DEPRECATED_MODEL_ID,),
+        )
+        stale: list[tuple[Any, ...]] = []
+        for row in rows:
+            model_id = str(row["model_id"])
+            provider_id = str(row["provider_id"])
+            if model_id not in live_model_ids:
+                stale.append((model_id, provider_id))
+        if not stale:
+            return 0
+        await self._db.execute_many(
+            "DELETE FROM provider_model_metadata "
+            "WHERE model_id = ? AND provider_id = ?",
+            stale,
+        )
+        return len(stale)
+
+    async def _delete_stale_account_links(self) -> int:
+        """Delete ``account_models`` rows that are disabled and unused.
+
+        A row counts as unused when there are no ``requests`` rows
+        referencing the (account_id, model_id) pair within the
+        retention window.  Historical request activity still wins
+        because the durable ``requests`` table is the source of
+        truth for the dashboard.
+        """
+        rows = await self._db.fetch_all(
+            "SELECT am.account_id, am.model_id FROM account_models am "
+            "LEFT JOIN requests r ON r.account_id = am.account_id "
+            "  AND r.model_id = am.model_id "
+            "WHERE am.enabled = 0 AND r.id IS NULL"
+        )
+        if not rows:
+            return 0
+        targets = [(int(r["account_id"]), str(r["model_id"])) for r in rows]
+        await self._db.execute_many(
+            "DELETE FROM account_models WHERE account_id = ? AND model_id = ?",
+            targets,
+        )
+        return len(targets)
+
     async def _maybe_insert_price_snapshot(
         self,
         model_id: str,