llmshim 0.7.1__tar.gz → 0.7.2__tar.gz

llmshim-0.7.2/.github/scripts/npm-verify-served.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# `npm publish` exiting 0 means the registry *accepted* the tarball, not that it
+# serves it. 0.7.1 was accepted, logged to Sigstore, answered "may take a few
+# minutes to become available" — and half an hour later still served nothing,
+# behind a green job. So a publish is not done until `npm view` returns the
+# version. Run from the package's directory, after its publish step.
+#
+# Bound: 20 polls, 30 s apart — about ten minutes. npm's "few minutes" has been
+# minutes, never seconds, and a version still unserved after ten is stuck in
+# npm's processing, which more waiting here will not fix.
+#
+# Compares `npm view`'s output to the version rather than its exit status: for a
+# package that exists with a version that does not, npm's exit status has
+# differed across releases. `--prefer-online` revalidates on every poll, so the
+# first poll's packument — cached without the new version — cannot answer for
+# the rest of the window.
+set -euo pipefail
+
+ATTEMPTS=20
+INTERVAL=30
+NAME=$(node -p "require('./package.json').name")
+VER=$(node -p "require('./package.json').version")
+
+for attempt in $(seq 1 "$ATTEMPTS"); do
+  served=$(npm view --prefer-online "$NAME@$VER" version 2>/dev/null || true)
+  if [ "$served" = "$VER" ]; then
+    echo "$NAME@$VER is served by the registry."
+    exit 0
+  fi
+  echo "poll $attempt/$ATTEMPTS: $NAME@$VER not served yet"
+  if [ "$attempt" -lt "$ATTEMPTS" ]; then
+    sleep "$INTERVAL"
+  fi
+done
+
+echo "::error::$NAME@$VER was accepted by npm but is still not served after $((ATTEMPTS * INTERVAL / 60)) minutes. The publish step exited 0 and its output carries the Sigstore provenance line, so the tarball is stuck in npm's processing, not missing from this run. Look at https://www.npmjs.com/package/$NAME?activeTab=versions and https://status.npmjs.org; once it appears, re-run this job — the publish step sees it and skips. If it never appears, npm will refuse a second publish of the same version and support has to release it."
+exit 1

{llmshim-0.7.1 → llmshim-0.7.2}/.github/workflows/release.yml

@@ -223,6 +223,9 @@ jobs:
           else
             npm publish --access public --provenance
           fi
+      - name: Verify npm serves llmshim-darwin-arm64
+        working-directory: clients/typescript/packages/llmshim-darwin-arm64
+        run: bash "$GITHUB_WORKSPACE/.github/scripts/npm-verify-served.sh"
       - name: Publish llmshim-darwin-x64
         working-directory: clients/typescript/packages/llmshim-darwin-x64
         run: |
@@ -234,6 +237,9 @@ jobs:
           else
             npm publish --access public --provenance
           fi
+      - name: Verify npm serves llmshim-darwin-x64
+        working-directory: clients/typescript/packages/llmshim-darwin-x64
+        run: bash "$GITHUB_WORKSPACE/.github/scripts/npm-verify-served.sh"
 
   npm-linux-x64-binary:
     needs: test
@@ -274,6 +280,9 @@ jobs:
           else
             npm publish --access public --provenance
           fi
+      - name: Verify npm serves llmshim-linux-x64
+        working-directory: clients/typescript/packages/llmshim-linux-x64
+        run: bash "$GITHUB_WORKSPACE/.github/scripts/npm-verify-served.sh"
 
   # Native arm64 runner (GA, free on public repos) — no cross-compilation needed.
   npm-linux-arm64-binary:
@@ -315,6 +324,9 @@ jobs:
           else
             npm publish --access public --provenance
           fi
+      - name: Verify npm serves llmshim-linux-arm64
+        working-directory: clients/typescript/packages/llmshim-linux-arm64
+        run: bash "$GITHUB_WORKSPACE/.github/scripts/npm-verify-served.sh"
 
   npm-windows-binary:
     needs: test
@@ -358,6 +370,10 @@ jobs:
           else
             npm publish --access public --provenance
           fi
+      - name: Verify npm serves llmshim-win32-x64
+        shell: bash
+        working-directory: clients/typescript/packages/llmshim-win32-x64
+        run: bash "$GITHUB_WORKSPACE/.github/scripts/npm-verify-served.sh"
 
   # --- Publish TypeScript client to npm ---
   # First release must be published manually once (npm's trusted-publisher UI
@@ -410,6 +426,8 @@ jobs:
           else
             npm publish --access public --provenance
           fi
+      - name: Verify npm serves the TypeScript client
+        run: bash "$GITHUB_WORKSPACE/.github/scripts/npm-verify-served.sh"
 
   # --- Publish Ruby client to RubyGems ---
   # Uses a "pending trusted publisher" — configurable on rubygems.org before

{llmshim-0.7.1 → llmshim-0.7.2}/Cargo.lock

@@ -1180,7 +1180,7 @@ checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
 name = "llmshim"
-version = "0.7.1"
+version = "0.7.2"
 dependencies = [
  "async-stream",
  "async-trait",

{llmshim-0.7.1 → llmshim-0.7.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "llmshim"
-version = "0.7.1"
+version = "0.7.2"
 edition = "2021"
 description = "Blazing fast LLM API translation layer in pure Rust"
 license = "MIT OR Apache-2.0"

{llmshim-0.7.1 → llmshim-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llmshim
-Version: 0.7.1
+Version: 0.7.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{llmshim-0.7.1 → llmshim-0.7.2}/docs/src/concepts/routing.md

@@ -136,3 +136,25 @@ let router = llmshim::router::Router::from_env();
 
 Applications that manage secrets themselves can call `Router::from_env()`
 directly or construct a Router by registering provider implementations.
+
+## Catalog refresh is the daemon's default, not the embedder's
+
+`Router::from_env()` also schedules one background fetch of the model catalog
+(prices, context windows, capabilities). That is right for the proxy, which
+starts once and runs for days. A program that starts many times a day, or runs
+air-gapped, should build its router with
+`Router::from_env_without_catalog_refresh()` — identical, except that
+constructing it makes no network call — and refresh only when it decides to:
+
+```rust
+let router = llmshim::router::Router::from_env_without_catalog_refresh();
+if user_asked_for_it {
+    // Rides the caller's Tokio runtime; `None` when there is none, when
+    // LLMSHIM_CATALOG_OFFLINE=1 is set, or when the local catalog is invalid.
+    router.refresh_catalog_in_background();
+}
+```
+
+The offline router still resolves and prices every model in the vendored
+snapshot, any earlier cached download, and the local override files; its data
+is simply never newer than the disk.

{llmshim-0.7.1 → llmshim-0.7.2}/docs/src/reference/models.md

@@ -28,7 +28,10 @@ compile-time API for curated and historical facts.
 
 Startup reads the vendored floor, cached data, and local overrides without
 waiting for network. Refresh uses ETags and a 24-hour TTL; errors keep the old
-snapshot available. Offline mode uses only vendored and local layers. User
+snapshot available. `Router::from_env()` schedules one such refresh;
+`Router::from_env_without_catalog_refresh()` schedules none and leaves it to
+`Router::refresh_catalog_in_background()`. Offline mode uses only vendored and
+local layers. User
 overrides live in `~/.config/llmshim/models.toml`, project overrides in
 `.llmshim/models.toml`, and cached data in `~/.cache/llmshim/models.dev.json`.
 Local overrides win; verified builtin assertions win over models.dev data.

{llmshim-0.7.1 → llmshim-0.7.2}/src/router.rs

@@ -176,15 +176,35 @@ impl Router {
             .ok_or_else(|| ShimError::UnknownProvider(key.to_string()))
     }
 
-    /// Build a router from provider env vars and a saved ChatGPT login.
+    /// Build a router from provider env vars and a saved ChatGPT login, and
+    /// schedule one background refresh of the model catalog.
+    ///
+    /// This is the daemon's constructor. The proxy starts once and serves for
+    /// days, so a single fetch at startup is what keeps its prices and
+    /// capabilities current for the rest of its life. A process that starts
+    /// many times a day, or must run air-gapped, wants
+    /// [`Router::from_env_without_catalog_refresh`] instead and decides for
+    /// itself when — or whether — to call
+    /// [`Router::refresh_catalog_in_background`].
     pub fn from_env() -> Self {
-        let mut router = Router::new();
+        let router = Self::from_env_without_catalog_refresh();
+        router.refresh_catalog_in_background();
+        router
+    }
 
-        // Only startup's local snapshot is synchronous. No catalog HTTP fetch
-        // is ever awaited by a model request.
-        if let Ok(catalog) = crate::catalog::global() {
-            catalog.refresh_in_background();
-        }
+    /// [`Router::from_env`] minus the catalog refresh: building a router makes
+    /// no network call.
+    ///
+    /// The catalog is still there — the vendored snapshot, whatever an earlier
+    /// refresh cached on disk, and the local override files — so `resolve` and
+    /// pricing work exactly as they do after `from_env`; the data is simply
+    /// never newer than the disk. For a short-lived embedder that is the right
+    /// default: a CLI that phones home for a price list before the user has
+    /// typed anything is doing something nobody asked for, and a machine with
+    /// no route out should not have to discover `LLMSHIM_CATALOG_OFFLINE` to
+    /// stop it. The fetch becomes something the caller asks for.
+    pub fn from_env_without_catalog_refresh() -> Self {
+        let mut router = Router::new();
 
         // Named routes are configuration, not discovery: they come from
         // ~/.llmshim/config.toml and nothing synthesizes a default set.
@@ -230,6 +250,22 @@ impl Router {
         router
     }
 
+    /// Refresh the shared model catalog from the network, detached from every
+    /// request: only startup's local snapshot is synchronous, and no catalog
+    /// HTTP fetch is ever awaited by a model request.
+    ///
+    /// The refresh rides the caller's Tokio runtime and never creates one, so
+    /// `None` means nothing was scheduled: there is no runtime on this thread,
+    /// `LLMSHIM_CATALOG_OFFLINE=1` is set, or the local catalog configuration
+    /// is invalid. The catalog is process-wide — it is what every router in
+    /// the process resolves against — so refreshing through one router
+    /// refreshes it for all of them.
+    pub fn refresh_catalog_in_background(
+        &self,
+    ) -> Option<tokio::task::JoinHandle<crate::catalog::RefreshOutcome>> {
+        crate::catalog::global().ok()?.refresh_in_background()
+    }
+
     /// Resolve model string to (provider, model_name).
     pub fn resolve(&self, model: &str) -> Result<(&dyn Provider, String)> {
         let (key, model) = self.resolve_key(model)?;

{llmshim-0.7.1 → llmshim-0.7.2}/tests/unit_router.rs

@@ -432,3 +432,63 @@ fn routes_are_configuration_and_parse_from_the_config_file() {
         "the target is not a setting"
     );
 }
+
+// ============================================================
+// from_env / from_env_without_catalog_refresh
+// ============================================================
+
+fn alive_tasks() -> usize {
+    tokio::runtime::Handle::current()
+        .metrics()
+        .num_alive_tasks()
+}
+
+fn catalog_offline() -> bool {
+    std::env::var("LLMSHIM_CATALOG_OFFLINE").is_ok_and(|v| v == "1")
+}
+
+/// The refresh's one observable is the task it spawns. On a current-thread
+/// runtime that task cannot run until this test yields, and the test never
+/// does, so the fetch never starts even without `LLMSHIM_CATALOG_OFFLINE`.
+///
+/// Under CI's `LLMSHIM_CATALOG_OFFLINE=1` neither constructor may spawn, so
+/// only the first assertion discriminates there; the `from_env` half is live
+/// when a developer runs the tests without the variable.
+#[tokio::test(flavor = "current_thread")]
+async fn offline_constructor_spawns_no_refresh_and_from_env_still_does() {
+    let before = alive_tasks();
+    let router = Router::from_env_without_catalog_refresh();
+    assert_eq!(
+        alive_tasks(),
+        before,
+        "constructing the router spawned a task"
+    );
+
+    let expected = usize::from(!catalog_offline());
+    let scheduled = router.refresh_catalog_in_background();
+    assert_eq!(scheduled.is_some(), !catalog_offline());
+    assert_eq!(alive_tasks(), before + expected);
+    if let Some(task) = scheduled {
+        task.abort();
+    }
+
+    let before = alive_tasks();
+    let _ = Router::from_env();
+    assert_eq!(
+        alive_tasks(),
+        before + expected,
+        "from_env no longer refreshes"
+    );
+}
+
+/// No refresh still means a catalog: the vendored snapshot resolves without
+/// any network having happened.
+#[test]
+fn offline_constructor_resolves_a_bundled_model() {
+    let router = Router::from_env_without_catalog_refresh()
+        .register("anthropic", Box::new(Anthropic::new("test".into())));
+    let (provider, model) = router.resolve("anthropic/claude-sonnet-5").unwrap();
+    assert_eq!(provider.name(), "anthropic");
+    assert_eq!(model, "claude-sonnet-5");
+    assert!(llmshim::catalog::resolve("anthropic/claude-sonnet-5").is_some());
+}