pi-provider-litellm 3.1.0 → 3.2.0

package/README.md

@@ -154,6 +154,8 @@ Treat the configured LiteLLM proxy as trusted: Skills can add instructions to th
 /model
 ```
 
+To refresh catalogs on demand, run `/litellm-refresh` for every configured LiteLLM provider, or `/litellm-refresh <provider>` for one alias. It works with `PI_OFFLINE` set, which stops Pi's own `/model` refresh from contacting the network. It contacts only the configured proxies: `LITELLM_OFFLINE=1` and `LITELLM_DISCOVERY_TIMEOUT_MS=0` still disable it, and models.dev enrichment stays off under `PI_OFFLINE`. Each provider reports its model count, the failure, or missing credentials. With LiteLLM MCP enabled, the refresh also re-checks that provider's MCP tools.
+
 Every request routed through a configured LiteLLM provider includes Pi's canonical session ID in the
 `x-litellm-session-id` header. This groups Chat Completions, Responses, and native Messages requests in LiteLLM without
 adding transport-specific fields to request bodies.
@@ -173,13 +175,17 @@ Native Messages authenticates with `x-api-key`; every transport carries the `x-l
 | `LITELLM_GCLOUD_TOKEN_AUTH` | unset | If set to a non-empty value other than `0`, use Google Application Default Credentials as the LiteLLM bearer token source. This takes precedence over `LITELLM_API_KEY_HELPER` and `LITELLM_API_KEY` when no stored `/login litellm` credential exists. |
 | `GOOGLE_APPLICATION_CREDENTIALS` | Google default ADC path | Optional path to an ADC JSON file used by `LITELLM_GCLOUD_TOKEN_AUTH`. If unset, the extension checks the default gcloud ADC locations. |
 | `LITELLM_OFFLINE` | unset | If `1`, disable all model and MCP discovery, including post-login discovery; use cached models only when their stored canonical proxy root exactly matches the active credential root, including any path prefix. URL-standard host casing and default ports are canonicalized, but paths remain case-sensitive. |
+| `PI_OFFLINE` | unset | Pi documents it as disabling automatic network activity, including model catalog refreshes. Through Pi 0.87.1, any set value (including `0` or an empty string) disables startup model discovery and `/model` network refreshes. Run `/litellm-refresh`, or unset it, to discover; cached models can still be used offline. |
 | `LITELLM_DISCOVERY_TIMEOUT_MS` | `5000` | Background and explicit discovery fetch timeout in ms; `0` disables automatic discovery |
 | `LITELLM_CLI_JWT_EXPIRATION_HOURS` | `24` | CLI SSO token lifetime fallback for older proxies whose poll response omits `expires_in`; mirror a non-default proxy setting locally |
-| `LITELLM_VERBOSE_DISCOVERY` | unset | If `1`, enable progress messages during model and MCP discovery (login, refresh, startup), including MCP prepared/registered/dropped counts. Progress messages are off by default; MCP safety diagnostics (see below) are always reported regardless of this setting |
+| `LITELLM_VERBOSE_DISCOVERY` | unset | If `1`, enable progress messages during model and MCP discovery (login, refresh, startup), including startup skip reasons, defaulted `/model/info` context windows, and MCP prepared/registered/dropped counts. Progress messages are off by default; MCP safety diagnostics (see below) are always reported regardless of this setting |
+| `LITELLM_DEFAULT_CONTEXT_WINDOW` | `128000` | Context window assumed when neither LiteLLM's `/model/info` nor the catalog reports `max_input_tokens`. Set a positive integer for proxies whose custom aliases carry no metadata; an unset or unusable value keeps 128K |
 | `LITELLM_MODELS_DEV` | unset | If `1`, enrich discovered metadata (limits, prices, effort lists) from models.dev, cached for 28 days in `litellm-models-dev.json`. Off by default because LiteLLM's `/model/info` is authoritative; use it when LiteLLM's model map lacks a model's metadata |
 
 Only use a trusted `LITELLM_API_KEY_HELPER` or `!command`. Prefer an absolute executable path, keep secrets out of command arguments, and print only the token to stdout without logging it to stderr.
 
+With `LITELLM_VERBOSE_DISCOVERY=1`, `/model/info` discovery reports published routes whose context window uses the fallback assumption (including wildcard expansions) on one line with the selected value, a count, and a sample of escaped route names. Each route is reported once per process. Explicit or authoritative catalog limits do not trigger it, even when numerically equal to the default. Set `model_info.max_input_tokens` on every deployment in the route to provide real limits; this diagnostic does not change discovery limits or routing.
+
 `LITELLM_DISCOVERY_TIMEOUT_MS=0` disables automatic and explicit refresh model discovery. It does not replace the base URL or API key settings required to send requests when you are not using `/login litellm`.
 
 ### Google ADC token auth
@@ -201,11 +207,11 @@ If your LiteLLM proxy exposes MCP REST endpoints, this extension discovers tools
 - `GET /mcp-rest/tools/list`
 - `POST /mcp-rest/tools/call`
 
-An MCP access denial pauses discovery until a successful `/login litellm` (SSO or API key). The pause survives restarts in `~/.pi/agent/litellm-mcp-pauses/`, scoped to the proxy, login, and headers with salted credential fingerprints. A new API key or header configuration has its own scope. Each explicit login creates a fresh opaque `litellmMcpSession` identifier in Pi's stored credential, even when the key is unchanged; automatic OAuth refresh preserves that identifier and its pause. Older Pi processes cannot pause the new login. Pause files contain no credentials or proxy error text. Model discovery and chat continue normally. Grant MCP access on the proxy before signing in again. An explicit `litellm.mcp.enabled: false` setting remains disabled after login.
+An MCP access denial pauses discovery until a successful `/login litellm` (SSO or API key); an alias provider, which has no login, stays paused until its credentials, base URL, or headers change. The pause survives restarts in `~/.pi/agent/litellm-mcp-pauses/`, scoped to the proxy, login, and headers with salted credential fingerprints. A new API key or header configuration has its own scope. Each explicit login creates a fresh opaque `litellmMcpSession` identifier in Pi's stored credential, even when the key is unchanged; automatic OAuth refresh preserves that identifier and its pause. Older Pi processes cannot pause the new login. Pause files contain no credentials or proxy error text. Model discovery and chat continue normally. Grant MCP access on the proxy before signing in again. An explicit `litellm.mcp.enabled: false` setting remains disabled after login.
 
-Each discovered tool is registered as a native Pi tool named `mcp_<server>_<tool>_<hash>`, at most 64 characters, using only `[a-z0-9_]`. The trailing 10-character hash is derived from the tool's identity (`server_id`, `server_name`, `name`) and is always present, so a name depends only on that tool and never on which other tools happen to be in the same catalog — adding or removing a sibling never renames a survivor. When the readable prefix would overflow 64 characters it is truncated from the right, so a long server name can leave little or none of the tool name visible; the hash is what distinguishes such tools. Tools from different servers therefore never overwrite each other, and exact duplicate identities are registered once.
+Each discovered tool is registered as a native Pi tool named `mcp_<server>_<tool>_<hash>`, at most 64 characters, using only `[a-z0-9_]`. The trailing 10-character hash is derived from the tool's identity (`server_id`, `server_name`, `name`) and is always present, so a name depends only on that tool and never on which other tools happen to be in the same catalog — adding or removing a sibling never renames a survivor. When the readable prefix would overflow 64 characters it is truncated from the right, so a long server name can leave little or none of the tool name visible; the hash is what distinguishes such tools. Tools from different servers therefore never overwrite each other, and exact duplicate identities are registered once. Each alias provider discovers its own catalog: its tools are named `mcp_<alias>_<server>_<tool>_<hash>`, with the alias name also folded into the hash, and are called with that alias's credentials, so two providers exposing the same server never replace each other's tools. The default `litellm` provider keeps unprefixed names, and diagnostics for an alias read `LiteLLM MCP ("<alias>"):`.
 
-MCP discovery runs after Pi refreshes LiteLLM models or after `/login litellm`; extension activation never waits for it. Discovery accepts at most a 5 MiB response and registers at most 512 tools. The response must be a JSON array of tools or an object with a `tools` array; an `unexpected_error` or unknown non-null `error` in the object envelope, an object without `tools`, and every other shape are reported as discovery failures rather than as empty catalogs. Failure reports use extension-owned text and never include LiteLLM's proxy-supplied tag or `message`. A `partial_failure` envelope keeps and registers the returned tools while reporting one bounded generated diagnostic. Each tool is isolated during normalization, so one bad tool never hides valid siblings. A tool is accepted only when its schema has a root of exactly `"type": "object"` (a bare `properties` object with no `type`, or a type union such as `["object","null"]`, is refused), plain-object `properties`, at most 16 levels of JSON nesting (about eight nested schema objects when each level uses `properties`), and a serialized size of at most 64 KiB. Descriptions are limited to 4 KiB, and tool labels and result metadata to 256 bytes, each with a truncation marker.
+MCP discovery runs once for every configured provider before the first agent turn (so `-p` and other non-interactive modes get MCP tools), after Pi refreshes LiteLLM models, and after `/login litellm`; extension activation never waits for it. Discovery accepts at most a 5 MiB response and registers at most 512 tools. The response must be a JSON array of tools or an object with a `tools` array; an `unexpected_error` or unknown non-null `error` in the object envelope, an object without `tools`, and every other shape are reported as discovery failures rather than as empty catalogs. Failure reports use extension-owned text and never include LiteLLM's proxy-supplied tag or `message`. A `partial_failure` envelope keeps and registers the returned tools while reporting one bounded generated diagnostic. Each tool is isolated during normalization, so one bad tool never hides valid siblings. A tool is accepted only when its schema has a root of exactly `"type": "object"` (a bare `properties` object with no `type`, or a type union such as `["object","null"]`, is refused), plain-object `properties`, at most 16 levels of JSON nesting (about eight nested schema objects when each level uses `properties`), and a serialized size of at most 64 KiB. Descriptions are limited to 4 KiB, and tool labels and result metadata to 256 bytes, each with a truncation marker.
 
 ### Which schema a tool ends up with
 
@@ -257,6 +263,8 @@ If your LiteLLM proxy exposes `/claude-code/marketplace.json`, enabled skills ar
 - `litellm_skill_create`
 - `litellm_skill_delete`
 
+`litellm_skill_create` needs Skill Hub `sourceJson` metadata and a proxy that exposes `/claude-code/plugins`. It does not create skills from code: LiteLLM's `POST /v1/skills` is Anthropic's multipart Skills API.
+
 ## Mocked LiteLLM smoke workflow
 
 The `LiteLLM Smoke` GitHub Actions workflow starts VidaiMock and a real LiteLLM proxy on the runner. LiteLLM exposes route-distinct Chat, Responses, native Messages, and mixed-deployment models whose upstreams are served by VidaiMock. The smoke runner discovers those models through LiteLLM, asserts each model's expected API, exercises `/v1/chat/completions`, `/v1/responses`, and `/v1/messages`, verifies the expected `x-litellm-response-cost` behavior, and proves endpoint coverage from captured LiteLLM request logs rather than response text.
@@ -296,7 +304,9 @@ Dynamic catalogs are persisted by Pi in `~/.pi/agent/models-store.json`. Credent
 
 LiteLLM's `/model/info` is the metadata authority, so models.dev enrichment is an opt-in escape hatch. With `LITELLM_MODELS_DEV=1`, for every genuine `/model/info` row, including deployment details fetched through `/health`, the extension requests `https://models.dev/api.json` for enrichment and caches the result for 28 days in `~/.pi/agent/litellm-models-dev.json`. Without it, discovery neither requests models.dev nor reads that cache; Pi's own catalog still applies. Health-only entries without deployment details use the bounded Pi catalog lookup without models.dev enrichment. `PI_OFFLINE` suppresses activation-time discovery and the models.dev request. `LITELLM_OFFLINE=1` also disables LiteLLM discovery; direct discovery callers use only an existing models.dev cache and do not refresh it.
 
-Opening `/model` refreshes configured provider catalogs in the background using Pi's native model lifecycle.
+Opening `/model` refreshes configured provider catalogs in the background using Pi's native model lifecycle when network discovery is enabled.
+
+Pi documents `PI_OFFLINE` and `--offline` as disabling automatic network activity, including model catalog refreshes. Pi 0.87.1 adopted that wording to resolve [earendil-works/pi#8684](https://github.com/earendil-works/pi/issues/8684), without changing the behavior. Pi still checks only whether the variable is set, so `PI_OFFLINE=0` and an empty value also disable model refreshes. With `LITELLM_VERBOSE_DISCOVERY=1`, disabled startup discovery reports its reason, for example `startup discovery skipped (PI_OFFLINE)`. To discover models while keeping `PI_OFFLINE`, run `/litellm-refresh`. To allow all discovery for one invocation, use `env -u PI_OFFLINE pi` and do not pass `--offline`. If you only want to disable Pi's version check, use `PI_SKIP_VERSION_CHECK=1` instead; it does not apply offline mode's other network restrictions. See [#155](https://github.com/balcsida/pi-provider-litellm/issues/155).
 
 ### Model host enforcement
 
@@ -319,7 +329,7 @@ Each distinct availability diagnostic is written once per session on stderr. `LI
 
 ### Protocols and prompt caching
 
-Discovery selects native Messages for proven Claude groups under the [Model transport](#model-transport) rules, Responses for OpenAI-family backends, and Chat Completions for other OpenAI-compatible backends. An Azure deployment with an explicit `api_version` older than `2025-03-01-preview` stays on Chat Completions; an unset or newer version uses Responses. Azure is detected from the adapter field, an `azure/` or `azure_ai/` model prefix, or the reported provider; other adapters follow the backend family because LiteLLM bridges `/v1/responses` to Chat Completions when the provider has no native Responses config (`litellm/responses/main.py`, `_bridges_to_chat_completions`). A route whose model prefix and `custom_llm_provider` name different providers is treated as unidentified and stays on Chat Completions, so it also does not get the local 128-tool preflight. When `/model/info` supplies `supported_endpoints`, that list takes precedence, and `mode: "responses"` remains an explicit Responses signal. An evidence-free fallback entry—a bare `/v1/models` id or a `/health` entry with no detail row—takes its protocol from the Pi catalog entry for its id; both evidence-free fallback paths also inherit presentation metadata from the bounded catalog lookup. An unknown id stays on Chat Completions. The route name alone authorizes nothing. A concrete id expanded from wildcard `/model/info` routes inherits the deployment evidence of the wildcard route LiteLLM would select for it, with the requested id substituted into the row's `model` the way LiteLLM serves it; the id is omitted when that selected route is not a published chat-style route. Chat Completions and Responses use `<root>/v1`; native Messages uses the proxy root directly. All three protocols pass through the provider's host guard. When an evidence-free cached `(no metadata)` entry can be enriched from the Pi catalog, it is restored on Responses only for a catalog Responses model and otherwise on Chat Completions, never Anthropic Messages. A model supplied only through `models.json` whose `api` this provider does not implement takes Pi's global API fallback rather than this provider's host guard; the credential-root pin (see [Model host enforcement](#model-host-enforcement)) still keeps the credential on the active proxy.
+Discovery selects native Messages for proven Claude groups under the [Model transport](#model-transport) rules, Responses for OpenAI-family backends, and Chat Completions for other OpenAI-compatible backends. Azure and Azure AI deployments stay on Chat Completions unless an explicit Responses mode or a `supported_endpoints` list containing `/v1/responses` authorizes Responses; `api_version` alone does not prove support. Azure is detected from the adapter field, an `azure/` or `azure_ai/` model prefix, or the reported provider; other adapters follow the backend family because LiteLLM bridges `/v1/responses` to Chat Completions when the provider has no native Responses config (`litellm/responses/main.py`, `_bridges_to_chat_completions`). A route whose model prefix and `custom_llm_provider` name different providers is treated as unidentified and stays on Chat Completions, so it also does not get the local 128-tool preflight. When `/model/info` supplies `supported_endpoints`, that list takes precedence, and `mode: "responses"` remains an explicit Responses signal. An evidence-free fallback entry—a bare `/v1/models` id or a `/health` entry with no detail row—takes its protocol from the Pi catalog entry for its id; both evidence-free fallback paths also inherit presentation metadata from the bounded catalog lookup. An unknown id stays on Chat Completions. The route name alone authorizes nothing. A concrete id expanded from wildcard `/model/info` routes inherits the deployment evidence of the wildcard route LiteLLM would select for it, with the requested id substituted into the row's `model` the way LiteLLM serves it; the id is omitted when that selected route is not a published chat-style route. Chat Completions and Responses use `<root>/v1`; native Messages uses the proxy root directly. All three protocols pass through the provider's host guard. When an evidence-free cached `(no metadata)` entry can be enriched from the Pi catalog, it is restored on Responses only for a catalog Responses model and otherwise on Chat Completions, never Anthropic Messages. A model supplied only through `models.json` whose `api` this provider does not implement takes Pi's global API fallback rather than this provider's host guard; the credential-root pin (see [Model host enforcement](#model-host-enforcement)) still keeps the credential on the active proxy.
 
 `cacheControlFormat: "anthropic"` applies only to Chat Completions, where Pi adds Anthropic `cache_control` markers. The Responses transport has a different compatibility type and uses native `prompt_cache_key` (plus supported retention fields), so Responses models must not receive `cacheControlFormat`. Freshly discovered OpenAI-family models forced onto Chat Completions are rejected locally when a request contains more than 128 tools; route them through Responses or reduce enabled extensions. Moonshot request-side reasoning suppression follows LiteLLM's routing provider, not `model_info.base_model`; response-side `<think>` normalization follows discovered Kimi-family evidence. Opaque aliases retain display normalization without sending Moonshot-only parameters to Azure- or Bedrock-hosted Kimi models. Strict tool-message repair requires every deployment to identify Kimi; Gemini effort normalization likewise requires consistent backend-family evidence.
 
@@ -331,7 +341,7 @@ LiteLLM may load-balance one public `model_name` across deployments with differe
 
 - Responses is selected only when every deployment supports it under the protocol rules above; a deployment that requires Chat keeps the group on Chat.
 - Vision and reasoning are advertised only when every routable deployment resolves them as supported. An explicit `supports_reasoning: false` suppresses all thinking controls, even when catalog or router effort metadata exists. Catalog thinking controls are intersected per level: a level is exposed only when every deployment maps it to the same value, while disagreement or absence becomes an explicit denial. Catalog maps are not complete effort lists, so absence has one exception: an omitted `minimal`, `low`, `medium` or `high` counts as Pi's default spelling of that level. An omitted `off`, `xhigh` or `max` still differs from an explicit mapping. Reasoning selectors additionally require an accepted wire carrier on every deployment. Public effort lists are intersected, explicit LiteLLM denials win, and `xhigh`/`max` need unanimous explicit support. Null or absent standard-effort flags have no opinion. A deployment that declares `model_info.reasoning_effort_levels` answers every level from that list, ahead of its per-level flags, as LiteLLM itself reads it.
-- Context and output limits use the minimum resolved value across deployments.
+- Context and output limits use the minimum resolved value across deployments. Pi catalogue lookup prefers the deployment's provider-specific entry before falling back to the generic vendor entry; Azure and Azure AI therefore retain Azure-specific limits rather than being capped by a different OpenAI catalogue entry. When models.dev supplies a sparse vendor record, missing fields still use the provider-specific Pi catalogue.
 - Each displayed base-price field uses the maximum only when every deployment resolves that field; unresolved fields remain zero and the model name is suffixed with ` (incomplete metadata)`.
 - When complete base pricing comes from the catalog under unanimous catalog authority, tiered pricing is the conservative worst-case envelope. Its usable finite non-negative thresholds are the sorted union of every deployment's thresholds, and each price field at each interval is the maximum applicable rate across all deployments, floored by each deployment's base rate. Differing tier breakpoints are therefore preserved rather than treated as incompatible. An explicit `/model/info` base-price field replaces catalog pricing for that field at every threshold; catalog tiers remain for unaffected fields and are omitted only when every base-price field is explicit.
 - Reduced route groups omit tier ladders when complete base-pricing or catalog authority is unavailable. Wildcard expansion retains every known tier from matching groups even when another match has incomplete metadata: suppressing a complete sibling's higher tier could understate the known worst-case rate. The ` (incomplete metadata)` marker remains because the resulting envelope is only as complete as the available ladders.
@@ -359,6 +369,7 @@ The development probe runs against minimized snapshots with `npm run probe:proxy
 | Symptom | Likely cause |
 |---|---|
 | "no credentials" warning at startup | Env vars not set and no OAuth credential — run `/login litellm` |
+| No models, or no new routes, while `PI_OFFLINE` is set | Pi skips every model network refresh, including the one `/model` starts. Run `/litellm-refresh`, or unset `PI_OFFLINE` (`PI_OFFLINE=0` is not enough) |
 | `No models available` at startup, gone after a restart | A Pi startup race, not discovery — see [`No models available` at startup](#no-models-available-at-startup) |
 | "discovered no models" | Proxy returned an empty list — check pi's startup log and verify `/model/info`, `/v1/models`, or `/health` responds |
 | `/model/info` returning 401/403/404 | Expected behavior with virtual keys — extension falls back to `/v1/models` |
@@ -367,6 +378,7 @@ The development probe runs against minimized snapshots with `npm run probe:proxy
 | A configured or restored model fails to complete but never leaks the credential | Its `api` is absent from the current provider catalog, so Pi used global API fallback with the credential root pinned. Open `/model` against the active proxy to repopulate the protocol — see [Model host enforcement](#model-host-enforcement) |
 | `LiteLLM discovery: ... route group(s) have missing or conflicting deployment provider evidence` | One or more deployments lack resolvable backend authority or resolve to different providers or concrete catalog models. Add consistent `litellm_params.model`, `model_info.base_model`, or adapter metadata; catalog-derived limits, pricing, and reasoning metadata are withheld meanwhile. This may be intentional for cross-host routes such as Vertex/Bedrock Claude. |
 | `LiteLLM discovery: ... route group(s) mix chat-style and explicitly incompatible deployment modes` | A public route can select both a chat-style deployment and an incompatible deployment such as an embedding model. Give the embedding deployment its own `model_name`. |
+| `LiteLLM (...): a fallback served "<route>"` | A successful HTTP response reports a LiteLLM router fallback (`x-litellm-attempted-fallbacks`). `/model/info` does not expose fallbacks, so protocol and model handling follow the requested route's own deployments. If the primary and fallback groups support Chat Completions, set `model_info.supported_endpoints: ["/v1/chat/completions"]` on the primary to avoid Responses-to-Chat bridging. This warning does not change routing or fix upstream bridging defects. Warned once per provider and route until the extension reloads; shown in the UI, or stderr without a UI. |
 | A model is marked ` (incomplete metadata)` | `/model/info` or `/health` did not provide enough authoritative metadata. Explicit fields remain usable, but unknown cost fields are shown as zero and route-name cache enrichment stays disabled. |
 | `401 Token expired` | Set `LITELLM_API_KEY_HELPER`. |
 | No models with gcloud auth | Verify `gcloud auth application-default login` has been run or set `GOOGLE_APPLICATION_CREDENTIALS` to an `authorized_user` ADC file |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-litellm",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "LiteLLM proxy provider extension for Pi",
   "type": "module",
   "license": "MIT",

package/src/backend-identity.ts

@@ -29,6 +29,10 @@ const PROVIDER_FAMILIES: Readonly<Record<string, BackendFamily>> = {
 // Prefixes whose keyword match is trustworthy across the whole "prefix/modelId" string because
 // the prefix itself names a vendor, not just some unrelated string that happens to contain one.
 const KNOWN_VENDOR_PREFIXES = new Set([...Object.keys(PROVIDER_FAMILIES), "openai"]);
+// First segments that are known to be model path, never a provider: Fireworks' account-scoped
+// ids ("accounts/fireworks/models/x"). An allowlist fails closed: any other differing prefix,
+// recognized provider or not, stays a conflict.
+const MODEL_PATH_SEGMENTS = new Set(["accounts"]);
 // `o\d` (OpenAI's o1/o3/o4-mini reasoning models) is only trustworthy at the start of the id or
 // right after a provider path segment — an interior "-o1-" is as likely to be an unrelated
 // product's own version marker (e.g. "custom-o1-clone").
@@ -62,14 +66,20 @@ export function resolveBackendIdentity(row: BackendIdentityRow): BackendIdentity
     wireString(row.model_info?.base_model) ?? wireString(row.litellm_params?.model) ?? wireString(row.model_name);
   if (!raw) return undefined;
 
-  const slash = raw.indexOf("/");
+  let slash = raw.indexOf("/");
   const prefix = slash > 0 ? raw.slice(0, slash).trim().toLowerCase() : undefined;
-  const prefixProvider = prefix && !GENERIC_ADAPTERS.has(prefix) ? prefix : undefined;
+  let prefixProvider = prefix && !GENERIC_ADAPTERS.has(prefix) ? prefix : undefined;
   // `custom_llm_provider` is how LiteLLM routes an unprefixed model. It is provider evidence
-  // in its own right, so a prefix that names a different provider is a conflict, not a tiebreak.
+  // in its own right, so a differing prefix is a conflict, not a tiebreak. The exception is a
+  // known model-path segment: LiteLLM routes by custom_llm_provider, so Fireworks'
+  // "accounts/fireworks/models/x" is not a provider named "accounts".
   const custom = wireString(row.litellm_params?.custom_llm_provider)?.toLowerCase();
   const customProvider = custom && !GENERIC_ADAPTERS.has(custom) ? custom : undefined;
-  if (prefixProvider && customProvider && prefixProvider !== customProvider) return undefined;
+  if (prefixProvider && customProvider && prefixProvider !== customProvider) {
+    if (!MODEL_PATH_SEGMENTS.has(prefixProvider)) return undefined;
+    prefixProvider = undefined;
+    slash = -1;
+  }
   const provider = prefixProvider ?? customProvider;
   const modelId = slash > 0 ? raw.slice(slash + 1) : raw;
   // Scan the full "prefix/modelId" string only when the prefix is itself a whole known vendor

package/src/discover.ts

@@ -8,9 +8,10 @@ import {
   catalogResolution,
   closeSerializerPolicy,
   conservativeCostTiers,
-  DEFAULT_CONTEXT_WINDOW,
   DEFAULT_MAX_TOKENS,
+  defaultContextWindow,
   hasMixedIncompatibleDeploymentModes,
+  isFallbackContextWindow,
   type MessagesBackendCompat,
   meetVendorCompat,
   normalizedMode,
@@ -39,6 +40,7 @@ const DEFAULT_TIMEOUT_MS = 5000;
 const HEALTH_DETAIL_CONCURRENCY = 8;
 const reportedConflictingFamilyRoutes = new Set<string>();
 const reportedWithheldRepairRoutes = new Set<string>();
+const reportedDefaultedContextRoutes = new Set<string>();
 interface HealthDeployment {
   entry: ModelInfoEntry;
   denyLevels: boolean;
@@ -148,16 +150,11 @@ function supportsResponses(entry: ModelInfoEntry): boolean {
     /^azure(?:_ai)?\//.test(configuredModel ?? "") ||
     reportedProvider === "azure" ||
     reportedProvider === "azure_ai";
-  // LiteLLM bridges /v1/responses to chat completions when the provider has no native Responses config
-  // (litellm/responses/main.py, _bridges_to_chat_completions), so generic adapters remain eligible for Responses.
-  if (!azureAdapter) return true;
-
-  const apiVersion = entry.litellm_params?.api_version;
-  if (apiVersion != null && typeof apiVersion !== "string") return false;
-  const version = apiVersion?.trim();
-  if (!version) return true;
-  const date = version.match(/^(\d{4}-\d{2}-\d{2})(?:-preview)?$/)?.[1];
-  return date !== undefined && date >= "2025-03-01";
+  // An Azure API version describes the API surface, not whether this deployment
+  // serves Responses. Require the explicit mode/endpoint evidence above instead
+  // of promoting a working Chat route to an unavailable endpoint.
+  // Generic adapters remain eligible for LiteLLM's Responses-to-Chat bridge.
+  return !azureAdapter;
 }
 
 export function modelProtocol(modelId: string, modeOrEntry?: string | null | ModelInfoEntry): ModelProtocol {
@@ -231,7 +228,9 @@ export function enrichCachedModel(input: Model<Api>): Model<Api> {
     }),
   } as Model<Api>;
   // Reduced deployment groups use a distinct marker; this sentinel remains
-  // exclusive to evidence-free fallback models that may be enriched safely.
+  // exclusive to evidence-free fallback models that may be enriched safely. A window is
+  // fallback evidence when it matches either default, so a cached entry still qualifies
+  // after an operator configures LITELLM_DEFAULT_CONTEXT_WINDOW.
   if (
     !model.name.endsWith(" (no metadata)") ||
     model.reasoning ||
@@ -243,13 +242,15 @@ export function enrichCachedModel(input: Model<Api>): Model<Api> {
     model.cost.cacheRead !== 0 ||
     model.cost.cacheWrite !== 0 ||
     model.cost.tiers !== undefined ||
-    model.contextWindow !== DEFAULT_CONTEXT_WINDOW ||
+    !isFallbackContextWindow(model.contextWindow) ||
     model.maxTokens !== DEFAULT_MAX_TOKENS
   ) {
     return model;
   }
   const catalogModel = findCatalogModel(model.id);
-  if (!catalogModel) return model;
+  // The gate above proved this window is an assumption, so it is re-derived rather than
+  // restored: the cache is seeded offline, where discovery never re-reads the setting.
+  if (!catalogModel) return { ...model, contextWindow: defaultContextWindow() };
   // Match evidence-free discovery: only an explicit Responses catalog transport
   // changes the protocol; all other catalog APIs continue through Chat.
   const api = catalogModel.api === "openai-responses" ? "openai-responses" : "openai-completions";
@@ -597,6 +598,7 @@ function mapFromModelInfoGroup(
     ambiguousRoutes?: string[];
     conflictingFamilyRoutes?: string[];
     withheldRepairRoutes?: string[];
+    defaultedContextRoutes?: Set<string>;
     denyLevels?: boolean;
     allowMessages?: boolean;
   } = {},
@@ -618,6 +620,7 @@ function mapFromModelInfoGroup(
     };
   });
   if (!reduced) return undefined;
+  if (reduced.contextWindowDefaulted) options.defaultedContextRoutes?.add(reduced.id);
   if (reduced.catalogAuthorityAmbiguous) options.ambiguousRoutes?.push(reduced.id);
   if (reduced.deploymentFamilies.includes("conflicting")) options.conflictingFamilyRoutes?.push(reduced.id);
   const protocols = entries.map((entry) => modelProtocol(reduced.id, entry));
@@ -720,7 +723,7 @@ function mapFromModelsList(entry: ModelsListEntry): DiscoveredModel | undefined
     }),
     input: catalogModel?.input ?? ["text"],
     cost: catalogModel?.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: catalogModel?.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
+    contextWindow: catalogModel?.contextWindow ?? defaultContextWindow(),
     maxTokens: catalogModel?.maxTokens ?? DEFAULT_MAX_TOKENS,
     api,
     litellmDiscoveryVersion: LITELLM_DISCOVERY_VERSION,
@@ -1034,6 +1037,7 @@ export async function discoverModels(
     const incompatibleModeRoutes: string[] = [];
     const conflictingFamilyRoutes: string[] = [];
     const withheldRepairRoutes: string[] = [];
+    const defaultedContextRoutes = new Set<string>();
     const reducedGroups = [...groups.entries()].map(([route, group]) => {
       if (hasMixedIncompatibleDeploymentModes(group)) incompatibleModeRoutes.push(route);
       return {
@@ -1042,6 +1046,7 @@ export async function discoverModels(
           ambiguousRoutes,
           conflictingFamilyRoutes,
           withheldRepairRoutes,
+          defaultedContextRoutes,
         }),
         deploymentFamilies: group.map(deploymentFamily),
       };
@@ -1097,7 +1102,27 @@ export async function discoverModels(
       }
     }
     reportWithheldToolRepair(withheldRepairRoutes);
-    return { source: "model_info", models: deduplicateModels(models) };
+    models = deduplicateModels(models);
+    if (process.env.LITELLM_VERBOSE_DISCOVERY === "1") {
+      const defaultedWildcards = wildcardRoutes.filter(({ route }) => defaultedContextRoutes.has(route));
+      // Exact routes override wildcard templates; a tighter measured parent can also win.
+      const defaulted = models.filter((model) =>
+        groups.has(model.id)
+          ? defaultedContextRoutes.has(model.id)
+          : defaultedWildcards.some(
+              ({ route, model: parent }) =>
+                parent?.contextWindow === model.contextWindow && wildcardMatches(route, model.id),
+            ),
+      );
+      reportBoundedRoutes(
+        reportedDefaultedContextRoutes,
+        defaulted.map((model) => JSON.stringify(model.id)),
+        (count) =>
+          `LiteLLM discovery: ${count} route(s) default contextWindow to ${defaultContextWindow()}; ` +
+          "set model_info.max_input_tokens on every deployment in each route",
+      );
+    }
+    return { source: "model_info", models };
   }
   if (![401, 403, 404].includes(infoResult.status)) {
     throw new Error(`/model/info returned ${infoResult.status}`);

package/src/index.ts

@@ -1643,8 +1643,10 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     };
   }
 
-  let registeredMcpIdentity: string | undefined;
-  let mcpRegistration: Promise<void> | undefined;
+  // Each provider owns its own MCP catalog, keyed by provider name.
+  const registeredMcpIdentities = new Map<string, string>();
+  let mcpSeeded = false;
+  const mcpRegistrations = new Map<string, Promise<void>>();
   // Pi's registerTool throws only from assertActive(), whose staleness flag is set with `??=` and
   // never cleared, so a refusal is fatal for this extension instance rather than a per-tool or
   // retryable condition. Once seen, stop attempting registration here; a reload creates a fresh
@@ -1655,7 +1657,10 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   const mcpPauseInMemory = new Set<string>();
   let mcpPauseSalt: Buffer | undefined;
   let mcpPausePersistent = true;
-  let mcpLoginGeneration = 0;
+  // Keyed by provider: only the default provider has /login, and its login must not cancel an
+  // alias's in-flight registration, which login does not retry.
+  const mcpLoginGenerations = new Map<string, number>();
+  const mcpLoginGeneration = (name: string) => mcpLoginGenerations.get(name) ?? 0;
 
   function getMcpPauseSalt(): Buffer {
     if (!mcpPauseSalt) {
@@ -1724,8 +1729,8 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   }
 
   function resumeMcpDiscovery(): void {
-    mcpLoginGeneration += 1;
-    registeredMcpIdentity = undefined;
+    mcpLoginGenerations.set(PROVIDER_NAME, mcpLoginGeneration(PROVIDER_NAME) + 1);
+    registeredMcpIdentities.delete(PROVIDER_NAME);
     // The new login ID selects a fresh scope; other processes may still use the old scopes.
   }
 
@@ -1746,17 +1751,17 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     });
   }
 
-  async function getRuntimeAuth(ctx: ExtensionContext): Promise<LiteLLMRuntimeAuth | undefined> {
-    const auth = await ctx.modelRegistry.getProviderAuth(PROVIDER_NAME);
+  async function getRuntimeAuth(
+    ctx: ExtensionContext,
+    definition = definitions[0]!,
+  ): Promise<LiteLLMRuntimeAuth | undefined> {
+    const auth = await ctx.modelRegistry.getProviderAuth(definition.name);
     if (!auth) return undefined;
-    const provider = ctx.modelRegistry.getProvider(PROVIDER_NAME);
+    const provider = ctx.modelRegistry.getProvider(definition.name);
     const apiKey = auth.auth.apiKey;
     const baseUrl = cleanConfig(auth.auth.baseUrl) ?? cleanConfig(auth.env?.[ENV_BASE_URL]) ?? provider?.baseUrl;
     if (!baseUrl || !apiKey) return undefined;
-    const runtimeRoot = requireCredentialRoot(
-      normalizeBaseUrl(baseUrl, definitions[0]?.allowInsecureHttp),
-      PROVIDER_NAME,
-    );
+    const runtimeRoot = requireCredentialRoot(normalizeBaseUrl(baseUrl, definition.allowInsecureHttp), definition.name);
     const headers = Object.fromEntries(
       Object.entries(auth.auth.headers ?? provider?.headers ?? {}).filter(
         (entry): entry is [string, string] => typeof entry[1] === "string",
@@ -1766,16 +1771,23 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       baseUrl: runtimeRoot,
       apiKey,
       headers: Object.keys(headers).length > 0 ? headers : undefined,
-      allowInsecureHttp: definitions[0]?.allowInsecureHttp,
+      allowInsecureHttp: definition.allowInsecureHttp,
     };
   }
 
+  function missingCredentials(definition: ProviderDefinition): string {
+    const fix = definition.name === PROVIDER_NAME ? "Run /login litellm or set env vars" : "Set its baseUrl and apiKey";
+    return `no credentials for ${definition.name}. ${fix}.`;
+  }
+
+  async function requireRuntimeAuth(ctx: ExtensionContext, definition = definitions[0]!): Promise<LiteLLMRuntimeAuth> {
+    const auth = await getRuntimeAuth(ctx, definition);
+    if (auth) return auth;
+    throw new Error(missingCredentials(definition));
+  }
+
   async function resolveDefaultRuntimeAuth(ctx?: ExtensionContext): Promise<LiteLLMRuntimeAuth> {
-    if (ctx?.modelRegistry) {
-      const auth = await getRuntimeAuth(ctx);
-      if (auth) return auth;
-      throw new Error("no credentials for litellm. Run /login litellm or set env vars.");
-    }
+    if (ctx?.modelRegistry) return requireRuntimeAuth(ctx);
     if (!defaultRuntimeAuth) throw new Error("no credentials for litellm. Run /login litellm or set env vars.");
     return defaultRuntimeAuth;
   }
@@ -1798,34 +1810,49 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     });
   }
 
-  async function registerMcpTools(auth: McpRuntimeAuth, credential: Credential, signal?: AbortSignal): Promise<void> {
+  async function registerMcpTools(
+    definition: ProviderDefinition,
+    auth: McpRuntimeAuth,
+    credential: Credential,
+    signal?: AbortSignal,
+  ): Promise<void> {
     if (!mcpEnabled || discoveryDisabledReason() || mcpRegistrationFatal || isMcpPaused(auth, credential)) return;
-    const loginGeneration = mcpLoginGeneration;
+    const loginGeneration = mcpLoginGeneration(definition.name);
     const identity = mcpCatalogIdentity(auth, credential);
-    while (mcpRegistration) {
-      await waitForMcpRegistration(mcpRegistration, signal);
+    const isDefault = definition.name === PROVIDER_NAME;
+    // The default provider keeps its unprefixed tool names and diagnostics; an alias is scoped by name.
+    const namespace = isDefault ? undefined : definition.name;
+    const notify = isDefault
+      ? notifyMcp
+      : Object.assign((message: string) => notifyMcp(message), { incidentScope: definition.name });
+    const label = isDefault ? "LiteLLM MCP" : `LiteLLM MCP (${JSON.stringify(definition.name)})`;
+    let pending = mcpRegistrations.get(definition.name);
+    while (pending) {
+      await waitForMcpRegistration(pending, signal);
       signal?.throwIfAborted();
       if (
         mcpRegistrationFatal ||
         isMcpPaused(auth, credential) ||
-        loginGeneration !== mcpLoginGeneration ||
-        registeredMcpIdentity === identity
+        loginGeneration !== mcpLoginGeneration(definition.name) ||
+        registeredMcpIdentities.get(definition.name) === identity
       )
         return;
+      pending = mcpRegistrations.get(definition.name);
     }
-    if (registeredMcpIdentity === identity) return;
+    if (registeredMcpIdentities.get(definition.name) === identity) return;
 
     const registration = (async () => {
       try {
         signal?.throwIfAborted();
         const { definitions, report } = await createMcpToolDefinitions(
-          (ctx) => (ctx?.modelRegistry ? resolveDefaultRuntimeAuth(ctx) : Promise.resolve(auth)),
-          isVerboseDiscovery() ? (message) => notifyMcp(`LiteLLM MCP: ${message}`, "info") : undefined,
+          (ctx) => (ctx?.modelRegistry ? requireRuntimeAuth(ctx, definition) : Promise.resolve(auth)),
+          isVerboseDiscovery() ? (message) => notifyMcp(`${label}: ${message}`, "info") : undefined,
           signal,
-          notifyMcp,
+          notify,
+          namespace,
         );
         signal?.throwIfAborted();
-        if (loginGeneration !== mcpLoginGeneration) return;
+        if (loginGeneration !== mcpLoginGeneration(definition.name)) return;
         const registeredNames: string[] = [];
         try {
           for (const definition of definitions) {
@@ -1840,14 +1867,14 @@ export default async function (pi: ExtensionAPI): Promise<void> {
           // Fatal for this instance: report once, with a bounded Pi-authored cause and no proxy text,
           // then stop retrying so a stale instance cannot churn discovery on every later refresh.
           mcpRegistrationFatal = true;
-          reportMcpRegistrationFatal(registeredNames.length, definitions.length, error, notifyMcp);
+          reportMcpRegistrationFatal(registeredNames.length, definitions.length, error, notify);
           return;
         }
-        reportMcpRegistrationSuccess();
-        reportMcpPartialDiscovery(report.partialFailure, registeredNames, notifyMcp);
+        reportMcpRegistrationSuccess(notify);
+        reportMcpPartialDiscovery(report.partialFailure, registeredNames, notify);
         if (isVerboseDiscovery()) {
           notifyMcp(
-            `LiteLLM MCP: registered ${registeredNames.length} of ${definitions.length} prepared MCP tools ` +
+            `${label}: registered ${registeredNames.length} of ${definitions.length} prepared MCP tools ` +
               `(${report.discovered} raw, ${report.enveloped} enveloped).`,
             "info",
           );
@@ -1855,26 +1882,29 @@ export default async function (pi: ExtensionAPI): Promise<void> {
         // A catalog that produced nothing or came from a partial-failure response is not settled:
         // leaving the identity unset lets a later refresh retry discovery, which is network-only and
         // non-blocking. Re-registering surviving tools is safe because Pi replaces tools by name.
-        reportMcpCatalogOutcome(report.discovered, definitions.length, notifyMcp);
-        if (definitions.length > 0 && !report.partialFailure) registeredMcpIdentity = identity;
+        reportMcpCatalogOutcome(report.discovered, definitions.length, notify);
+        if (definitions.length > 0 && !report.partialFailure) registeredMcpIdentities.set(definition.name, identity);
       } catch (error) {
         if (signal?.aborted) throw signal.reason;
-        if (loginGeneration !== mcpLoginGeneration) return;
+        if (loginGeneration !== mcpLoginGeneration(definition.name)) return;
         if (error instanceof McpAccessDeniedError) {
           pauseMcpDiscovery(auth, credential);
-          notifyMcp("LiteLLM MCP: access denied; discovery paused until /login litellm succeeds.");
+          // Aliases have no /login; their pause scope is their URL, key, and headers, so a change lifts it.
+          notifyMcp(
+            `${label}: access denied; discovery paused until ${isDefault ? "/login litellm succeeds" : "its credentials change"}.`,
+          );
           return;
         }
         notifyMcp(
-          `LiteLLM (${PROVIDER_NAME}): MCP tool discovery failed (${error instanceof Error ? error.message : String(error)}).`,
+          `LiteLLM (${definition.name}): MCP tool discovery failed (${error instanceof Error ? error.message : String(error)}).`,
         );
       }
     })();
-    mcpRegistration = registration;
+    mcpRegistrations.set(definition.name, registration);
     try {
       await registration;
     } finally {
-      if (mcpRegistration === registration) mcpRegistration = undefined;
+      if (mcpRegistrations.get(definition.name) === registration) mcpRegistrations.delete(definition.name);
     }
   }
 
@@ -1896,7 +1926,13 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   // network phase, so the provider would stay empty until the user opens /model. Discover here
   // instead, the way 1.x did, and hand the catalog over as the provider's baseline models.
   async function seedModels(definition: ProviderDefinition): Promise<Model<LiteLLMApi>[]> {
-    if (discoveryDisabledReason() || isHostOffline()) return [];
+    const disabledReason = discoveryDisabledReason() ?? (isHostOffline() ? "PI_OFFLINE" : null);
+    if (disabledReason) {
+      if (isVerboseDiscovery()) {
+        process.stderr.write(`LiteLLM (${definition.name}): startup discovery skipped (${disabledReason}).\n`);
+      }
+      return [];
+    }
     try {
       const stored = readStoredCredential(definition.name, join(getAgentDir(), "auth.json"));
       // executeHelpers:false — activation must never run the user's key helper as a side effect,
@@ -1916,6 +1952,9 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   }
 
   const seeded = await Promise.all(definitions.map(seedModels));
+  // Pi runs a provider's network phase only once a credential resolves, so /litellm-refresh reads an
+  // unchanged count as "no credentials" rather than as a successful refresh.
+  const networkRefreshAttempts = new Map<string, number>();
 
   for (const [index, definition] of definitions.entries()) {
     const auth = createProviderAuth(
@@ -1975,24 +2014,26 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     Object.assign(provider, { headers: resolveHeaders(definition) });
     const refreshModels = provider.refreshModels!;
     provider.refreshModels = async (context) => {
-      const loginGeneration = mcpLoginGeneration;
+      const loginGeneration = mcpLoginGeneration(definition.name);
+      if (context.allowNetwork) {
+        networkRefreshAttempts.set(definition.name, (networkRefreshAttempts.get(definition.name) ?? 0) + 1);
+      }
       try {
         await refreshModels(context);
       } finally {
         if (
-          definition.name === PROVIDER_NAME &&
           context.allowNetwork &&
           !discoveryDisabledReason() &&
-          loginGeneration === mcpLoginGeneration &&
+          loginGeneration === mcpLoginGeneration(definition.name) &&
           context.credential
         ) {
           // Best-effort: refreshing the cached default auth / MCP catalog must not let a bad or
           // placeholder credential override refreshModels' own try/throw outcome via `finally`.
           try {
             const auth = await authForCredential(definition, context.credential);
-            if (loginGeneration === mcpLoginGeneration) {
-              defaultRuntimeAuth = auth;
-              void registerMcpTools(auth, context.credential, context.signal).catch(() => undefined);
+            if (loginGeneration === mcpLoginGeneration(definition.name)) {
+              if (definition.name === PROVIDER_NAME) defaultRuntimeAuth = auth;
+              void registerMcpTools(definition, auth, context.credential, context.signal).catch(() => undefined);
             }
           } catch {
             // ignored — authForCredential already reported/will report this via the paths that use it directly.
@@ -2003,6 +2044,54 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     pi.registerProvider(provider);
   }
 
+  // Pi documents PI_OFFLINE as disabling model catalog refreshes, including the one /model starts, and a
+  // provider cannot tell that refresh from an automatic one. This is the explicit refresh: it reaches only
+  // the configured proxies, so LITELLM_OFFLINE=1 and a zero timeout still disable it and models.dev stays off.
+  pi.registerCommand("litellm-refresh", {
+    description: "Refresh LiteLLM model catalogs from the proxy, even with PI_OFFLINE set",
+    getArgumentCompletions: (prefix) => {
+      const matches = [...providerNames].filter((name) => name.startsWith(prefix));
+      return matches.length > 0 ? matches.map((name) => ({ value: name, label: name })) : null;
+    },
+    handler: async (args, ctx) => {
+      const notify = (message: string, level: "info" | "warning"): void => {
+        if (ctx.hasUI) ctx.ui.notify(message, level);
+        else process.stderr.write(`${message}\n`);
+      };
+      const disabledReason = discoveryDisabledReason();
+      if (disabledReason) {
+        notify(`LiteLLM: model refresh skipped (${disabledReason}).`, "warning");
+        return;
+      }
+      const requested = args.trim();
+      const selected = requested ? definitions.filter(({ name }) => name === requested) : definitions;
+      if (selected.length === 0) {
+        const configured = [...providerNames].map((name) => JSON.stringify(name)).join(", ");
+        notify(`LiteLLM: unknown provider ${JSON.stringify(requested)}; configured: ${configured}.`, "warning");
+        return;
+      }
+      const attempts = new Map(selected.map(({ name }) => [name, networkRefreshAttempts.get(name) ?? 0]));
+      const result = await ctx.modelRegistry.refresh({
+        providers: selected.map(({ name }) => name),
+        allowNetwork: true,
+        force: true,
+      });
+      const models = ctx.modelRegistry.getAll();
+      for (const definition of selected) {
+        const label = `LiteLLM (${JSON.stringify(definition.name)})`;
+        const error = result.errors.get(definition.name);
+        if (error) {
+          notify(`${label}: model refresh failed (${error.message}).`, "warning");
+        } else if ((networkRefreshAttempts.get(definition.name) ?? 0) === attempts.get(definition.name)) {
+          notify(`${label}: model refresh skipped; ${missingCredentials(definition)}`, "warning");
+        } else {
+          const count = models.filter((model) => model.provider === definition.name).length;
+          notify(`${label}: refreshed ${count} model${count === 1 ? "" : "s"}.`, "info");
+        }
+      }
+    },
+  });
+
   setupLiteLLMCostTracking(pi, [...providerNames]);
 
   if (skillsEnabled) {
@@ -2026,6 +2115,27 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     );
   });
 
+  // Router fallbacks are invisible to discovery, so protocol and model policy were chosen for the
+  // requested route even when another group answered. Name the route only; header text is proxy-supplied.
+  const warnedFallbackRoutes = new Set<string>();
+  pi.on("after_provider_response", (event, ctx) => {
+    const model = ctx.model;
+    if (!model?.provider || !providerNames.has(model.provider)) return;
+    if (event.status < 200 || event.status >= 300) return;
+    const attemptedFallbacks = Number(event.headers["x-litellm-attempted-fallbacks"]);
+    if (!Number.isSafeInteger(attemptedFallbacks) || attemptedFallbacks <= 0) return;
+    const key = `${model.provider}\0${model.id}`;
+    if (warnedFallbackRoutes.has(key)) return;
+    warnedFallbackRoutes.add(key);
+    const route = JSON.stringify(model.id);
+    const message =
+      `LiteLLM (${JSON.stringify(model.provider)}): a fallback served ${route}, but protocol and model handling were chosen ` +
+      `for ${route}'s own deployments. If its fallbacks cross model families, pin the protocol with ` +
+      "`model_info.supported_endpoints`.";
+    if (ctx.hasUI) ctx.ui.notify(message, "warning");
+    else process.stderr.write(`${message}\n`);
+  });
+
   // Skills enrichment is best-effort: an expired credential or an unreachable proxy must not
   // report an extension error on every turn. The failing model request states the real problem.
   pi.on("before_agent_start", async (event, ctx) => {
@@ -2048,6 +2158,40 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     return { systemPrompt: `${event.systemPrompt}\n\n${section}` };
   });
 
+  // MCP tools otherwise register only from refreshModels' `finally`, which needs
+  // context.allowNetwork. Pi core sets that solely for the interactive TUI and the RPC
+  // background refresh, so `-p` and `--list-models` register no MCP tool at all, even when
+  // credentials resolve and the proxy is reachable — the defect #136 fixed for models.
+  //
+  // Seeding here rather than at activation is deliberate: registerMcpTools serialises callers
+  // per provider, so an activation-time call would become an in-flight registration
+  // that Pi's own refresh then waits on. Running once before the first turn keeps that ordering
+  // intact, still precedes any tool use, and leaves startup latency untouched.
+  async function seedMcpTools(definition: ProviderDefinition): Promise<void> {
+    try {
+      const stored = readStoredCredential(definition.name, join(getAgentDir(), "auth.json"));
+      // executeHelpers:false — seeding must never run the user's key helper as a side effect.
+      const auth = await authForCredential(definition, stored, false);
+      // An env-configured provider has no stored credential and must still seed. The credential
+      // only derives the pause identity, so the resolved key reproduces the stored api_key scope.
+      const credential: Credential = stored ?? { type: "api_key", key: auth.apiKey };
+      await registerMcpTools(definition, auth, credential, AbortSignal.timeout(getSeedTimeoutMs()));
+    } catch (error) {
+      if (isVerboseDiscovery()) {
+        process.stderr.write(
+          `LiteLLM (${definition.name}): MCP seeding skipped (${error instanceof Error ? error.message : String(error)}).\n`,
+        );
+      }
+    }
+  }
+
+  pi.on("before_agent_start", async () => {
+    if (!mcpEnabled || mcpSeeded || discoveryDisabledReason() || isHostOffline()) return;
+    mcpSeeded = true;
+    // Catalogs are independent per provider, so every configured provider seeds in parallel.
+    await Promise.all(definitions.map(seedMcpTools));
+  });
+
   pi.on("message_end", (event, ctx) => {
     if (event.message.role !== "assistant") return;
     // Resolve the discovered model that produced this message so the display

package/src/mcp-tools.ts

@@ -27,7 +27,9 @@ const TRUNCATION_MARKER = "\n[truncated by pi-provider-litellm]";
 const DESCRIPTION_TRUNCATION_MARKER = "… [truncated]";
 const SHORT_TRUNCATION_MARKER = "…";
 
-type DiagnosticSink = (message: string) => void;
+// `incidentScope` separates the suppression state of catalogs from different providers, so one
+// provider's clean pass cannot clear, and its differing report cannot re-trigger, another's incident.
+type DiagnosticSink = ((message: string) => void) & { readonly incidentScope?: string };
 
 interface RawLiteLLMMcpTool {
   name?: unknown;
@@ -130,13 +132,16 @@ function emitSafetyDiagnostic(
     process.stderr.write(line);
   },
 ): void {
-  if (lastEmittedIncident.get(incident) === identity) return;
-  lastEmittedIncident.set(incident, identity);
-  onDiagnostic(`LiteLLM MCP: ${message}\n`);
+  const scope = onDiagnostic.incidentScope;
+  const key = scope === undefined ? incident : `${scope}\0${incident}`;
+  if (lastEmittedIncident.get(key) === identity) return;
+  lastEmittedIncident.set(key, identity);
+  onDiagnostic(`LiteLLM MCP${scope === undefined ? "" : ` (${JSON.stringify(scope)})`}: ${message}\n`);
 }
 
-function clearIncident(incident: string): void {
-  lastEmittedIncident.delete(incident);
+function clearIncident(incident: string, onDiagnostic?: DiagnosticSink): void {
+  const scope = onDiagnostic?.incidentScope;
+  lastEmittedIncident.delete(scope === undefined ? incident : `${scope}\0${incident}`);
 }
 
 function membershipIdentity(tools: readonly string[]): string {
@@ -184,8 +189,8 @@ export function reportMcpRegistrationFatal(
 
 // A successful pass clears any fatal incident left by an earlier extension instance, so the same
 // failure is reported if it later recurs.
-export function reportMcpRegistrationSuccess(): void {
-  clearIncident("registration-fatal");
+export function reportMcpRegistrationSuccess(onDiagnostic?: DiagnosticSink): void {
+  clearIncident("registration-fatal", onDiagnostic);
 }
 
 // `registered` is the generated names of the tools that survived, so a failure that changes
@@ -196,7 +201,7 @@ export function reportMcpPartialDiscovery(
   onDiagnostic?: DiagnosticSink,
 ): void {
   if (!partialFailure) {
-    clearIncident("discovery-partial-failure");
+    clearIncident("discovery-partial-failure", onDiagnostic);
     return;
   }
   emitSafetyDiagnostic(
@@ -212,7 +217,7 @@ export function reportMcpPartialDiscovery(
 // an unchanged message.
 export function reportMcpCatalogOutcome(raw: number, registered: number, onDiagnostic?: DiagnosticSink): void {
   if (registered > 0) {
-    clearIncident("empty-catalog");
+    clearIncident("empty-catalog", onDiagnostic);
     return;
   }
   emitSafetyDiagnostic(
@@ -281,7 +286,7 @@ async function readBoundedText(
   onDiagnostic?: DiagnosticSink,
 ): Promise<string> {
   if (!response.body) {
-    clearIncident(`${surface}-body-cap`);
+    clearIncident(`${surface}-body-cap`, onDiagnostic);
     return "";
   }
   const reader = response.body.getReader();
@@ -312,7 +317,7 @@ async function readBoundedText(
   }
   // A response that stayed within the cap clears the incident, so a later breach on this surface
   // is reported again instead of being suppressed as an unchanged message.
-  clearIncident(`${surface}-body-cap`);
+  clearIncident(`${surface}-body-cap`, onDiagnostic);
   return Buffer.concat(
     chunks.map((chunk) => Buffer.from(chunk)),
     size,
@@ -743,9 +748,13 @@ function toolIdentity(tool: LiteLLMMcpTool): string {
 // A conditional hash would make a survivor's name depend on which *other* tools happened to be in
 // the same catalog, so adding or removing a sibling would rename it — and because Pi cannot
 // unregister, the old name would linger and the model would see one tool twice.
-function buildPiToolName(tool: LiteLLMMcpTool): string {
-  const hash = createHash("sha256").update(toolIdentity(tool)).digest("hex").slice(0, TOOL_NAME_HASH_LENGTH);
-  const base = `mcp_${sanitizeName(tool.server_name)}_${sanitizeName(tool.name)}`;
+// An alias provider's catalog is namespaced by the provider name, in both the prefix and the hash,
+// so two providers exposing the same server never replace each other's tools.
+function buildPiToolName(tool: LiteLLMMcpTool, namespace?: string): string {
+  const identity = namespace === undefined ? toolIdentity(tool) : JSON.stringify([namespace, toolIdentity(tool)]);
+  const hash = createHash("sha256").update(identity).digest("hex").slice(0, TOOL_NAME_HASH_LENGTH);
+  const prefix = namespace === undefined ? "mcp" : `mcp_${sanitizeName(namespace)}`;
+  const base = `${prefix}_${sanitizeName(tool.server_name)}_${sanitizeName(tool.name)}`;
   return `${base.slice(0, MAX_TOOL_NAME_LENGTH - hash.length - 1)}_${hash}`;
 }
 
@@ -1135,7 +1144,10 @@ function buildParameters(tool: LiteLLMMcpTool): BuiltParameters | McpDropReason
   return { parameters: Type.Unsafe(inputSchema), syntheticArgsEnvelope: false };
 }
 
-export function prepareTools(discovery: McpDiscovery): {
+export function prepareTools(
+  discovery: McpDiscovery,
+  namespace?: string,
+): {
   prepared: PreparedTool[];
   report: McpPreparationReport;
 } {
@@ -1160,12 +1172,12 @@ export function prepareTools(discovery: McpDiscovery): {
   for (const tool of discovery.tools) {
     const built = buildParameters(tool);
     if (typeof built === "string") {
-      recordDrop(built, buildPiToolName(tool));
+      recordDrop(built, buildPiToolName(tool, namespace));
       continue;
     }
     const identity = toolIdentity(tool);
     if (acceptedIdentities.has(identity)) {
-      recordDrop("duplicate-identity", buildPiToolName(tool));
+      recordDrop("duplicate-identity", buildPiToolName(tool, namespace));
       continue;
     }
     acceptedIdentities.add(identity);
@@ -1178,12 +1190,12 @@ export function prepareTools(discovery: McpDiscovery): {
   }
 
   const candidates = accepted.slice(0, MAX_REGISTERED_TOOLS);
-  const overflowTools = accepted.slice(MAX_REGISTERED_TOOLS).map(({ tool }) => buildPiToolName(tool));
+  const overflowTools = accepted.slice(MAX_REGISTERED_TOOLS).map(({ tool }) => buildPiToolName(tool, namespace));
   const finalNames = new Set<string>();
   const prepared: PreparedTool[] = [];
   for (const candidate of candidates) {
     // Membership-independent: the name depends only on this tool's identity.
-    const name = buildPiToolName(candidate.tool);
+    const name = buildPiToolName(candidate.tool, namespace);
     if (finalNames.has(name)) {
       recordDrop("name-collision", name);
       continue;
@@ -1251,7 +1263,7 @@ function emitPreparationDiagnostics(report: McpPreparationReport, onDiagnostic?:
   // Clear classes that did not recur, so the same incident is reported again if it comes back
   // after a clean refresh instead of being suppressed as an unchanged identity.
   for (const reason of [...Object.keys(INCIDENT_REASON_TEXT), "tool-cap"]) {
-    if (!seen.has(reason)) clearIncident(reason);
+    if (!seen.has(reason)) clearIncident(reason, onDiagnostic);
   }
 }
 
@@ -1260,6 +1272,7 @@ export async function createMcpToolDefinitions(
   onProgress?: (message: string) => void,
   signal?: AbortSignal,
   onDiagnostic?: DiagnosticSink,
+  namespace?: string,
 ): Promise<{ definitions: ToolDefinition[]; report: McpPreparationReport }> {
   const discoveryAuth = await getAuth();
   const discovery = await discoverMcpTools(
@@ -1271,7 +1284,7 @@ export async function createMcpToolDefinitions(
     discoveryAuth.allowInsecureHttp,
     onDiagnostic,
   );
-  const { prepared, report } = prepareTools(discovery);
+  const { prepared, report } = prepareTools(discovery, namespace);
   emitPreparationDiagnostics(report, onDiagnostic);
   const lostTotal = report.dropped.reduce((total, entry) => total + entry.tools.length, 0) + report.overflow;
   const lostDetail = [

package/src/model-groups.ts

@@ -2,7 +2,32 @@ import type { Api, Model } from "@earendil-works/pi-ai";
 import { intersectThinkingLevelMaps, THINKING_LEVEL_DEFINITIONS } from "./thinking-levels.js";
 import type { DiscoveredModel, ModelInfoEntry } from "./types.js";
 
-export const DEFAULT_CONTEXT_WINDOW = 128_000;
+const BUILTIN_CONTEXT_WINDOW = 128_000;
+
+/**
+ * Context window used when neither /model/info nor the catalog reports one.
+ * LITELLM_DEFAULT_CONTEXT_WINDOW raises it for proxies whose model map cannot
+ * populate `max_input_tokens`; an unset or unusable value keeps the 128K default.
+ */
+export function defaultContextWindow(): number {
+  // Number, not parseInt: parseInt takes a numeric prefix, so `1.5` would become a
+  // 1-token window and `922000junk` would pass as a limit instead of being rejected.
+  const parsed = Number(process.env.LITELLM_DEFAULT_CONTEXT_WINDOW ?? "");
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : BUILTIN_CONTEXT_WINDOW;
+}
+
+/**
+ * Whether a stored window is one this extension assumed rather than read. A model cached
+ * under the built-in default must still read as evidence-free once an operator configures
+ * LITELLM_DEFAULT_CONTEXT_WINDOW, or the setting would never reach cached entries.
+ * ponytail: a window stored under a setting that was later lowered is indistinguishable
+ * from measured evidence and stays until the next online discovery; persist a fallback
+ * marker on the model if that ever matters.
+ */
+export function isFallbackContextWindow(contextWindow: number): boolean {
+  return contextWindow === BUILTIN_CONTEXT_WINDOW || contextWindow === defaultContextWindow();
+}
+
 export const DEFAULT_MAX_TOKENS = 16_384;
 
 export type SemanticFamily = "claude" | "deepseek" | "gemini" | "kimi" | "openai";
@@ -52,6 +77,7 @@ export interface ReducedModelGroup {
   thinkingLevelMap?: DiscoveredModel["thinkingLevelMap"];
   vision: boolean;
   contextWindow: number;
+  contextWindowDefaulted?: boolean;
   maxTokens: number;
   cost: DiscoveredModel["cost"];
   hasCompleteCost: boolean;
@@ -801,7 +827,8 @@ export function reduceModelGroup(
     (entry) => wireBoolean(entry.model_info?.supports_reasoning) === false,
   );
   const vision = visionEvidence.every((value) => value ?? false);
-  const contextWindow = min(contextWindowEvidence.map((value) => value ?? DEFAULT_CONTEXT_WINDOW));
+  const fallbackContextWindow = defaultContextWindow();
+  const contextWindow = min(contextWindowEvidence.map((value) => value ?? fallbackContextWindow));
   const maxTokens = min(maxTokensEvidence.map((value) => value ?? DEFAULT_MAX_TOKENS));
 
   const costValues = COST_FIELDS.map((field) =>
@@ -930,6 +957,9 @@ export function reduceModelGroup(
     ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
     vision,
     contextWindow,
+    ...(contextWindowEvidence.includes(undefined) && contextWindow === fallbackContextWindow
+      ? { contextWindowDefaulted: true }
+      : {}),
     maxTokens,
     cost,
     hasCompleteCost,

package/src/public-catalog.ts

@@ -73,6 +73,7 @@ const PROVIDER_ALIASES: Readonly<Record<string, readonly string[]>> = {
 const PI_PROVIDER_ALIASES: Readonly<Record<string, readonly string[]>> = {
   "amazon-bedrock": ["amazon-bedrock"],
   azure: ["azure-openai-responses"],
+  azure_ai: ["azure-openai-responses"],
   chatgpt: ["openai-codex"],
   "fireworks-ai": ["fireworks"],
   openai: ["openai"],
@@ -245,6 +246,7 @@ export async function loadPublicCatalog(options: LoadPublicCatalogOptions = {}):
       const providers = providerCandidates(provider);
       const ids = lookupIds(id);
       const vendor = providers.find((candidate) => candidate !== "azure") ?? providers[0];
+      const adapter = provider?.trim().toLowerCase();
       for (const candidate of providers) {
         const models = catalog?.[candidate]?.models;
         for (const modelId of ids) {
@@ -252,20 +254,25 @@ export async function loadPublicCatalog(options: LoadPublicCatalogOptions = {}):
           if (!model) continue;
           const record = mapModelsDev(candidate, modelId, model);
           if (candidate === providers[0] || !vendor) return record;
-          return { ...record, piProvider: (PI_PROVIDER_ALIASES[vendor] ?? [vendor])[0] };
+          const fallback =
+            adapter && (PI_PROVIDER_ALIASES[adapter] ?? [adapter]).some((piProvider) => findPiModel(piProvider, ids))
+              ? adapter
+              : vendor;
+          return { ...record, piProvider: (PI_PROVIDER_ALIASES[fallback] ?? [fallback])[0] };
         }
       }
-      if (vendor) {
-        for (const piProvider of PI_PROVIDER_ALIASES[vendor] ?? [vendor]) {
+      // Provider-specific limits and pricing must not be replaced by the generic
+      // vendor's entry just because both catalogs recognize the model id.
+      if (adapter && adapter !== vendor) {
+        for (const piProvider of PI_PROVIDER_ALIASES[adapter] ?? [adapter]) {
           const model = findPiModel(piProvider, ids);
-          if (model) return toPiRecord("pi-vendor", piProvider, model);
+          if (model) return toPiRecord("pi-adapter", piProvider, model);
         }
       }
-      const adapter = provider?.trim().toLowerCase();
-      if (adapter) {
-        for (const piProvider of PI_PROVIDER_ALIASES[adapter] ?? [adapter]) {
+      if (vendor) {
+        for (const piProvider of PI_PROVIDER_ALIASES[vendor] ?? [vendor]) {
           const model = findPiModel(piProvider, ids);
-          if (model) return toPiRecord("pi-adapter", piProvider, model);
+          if (model) return toPiRecord("pi-vendor", piProvider, model);
         }
       }
       return undefined;

package/src/skills.ts

@@ -42,97 +42,55 @@ export async function listSkills(
     return skillsCache.skills;
   }
 
-  const fetchSkills = async (path: string): Promise<LiteLLMSkill[]> => {
+  const fetchSkills = async (path: string): Promise<LiteLLMSkill[] | undefined> => {
     try {
       const response = await fetch(`${normalizedBaseUrl}${path}`, {
         headers: { ...headers, Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
         signal: AbortSignal.timeout(10_000),
       });
-      return response.ok ? getSkillsFromBody(await response.json()) : [];
+      return response.ok ? getSkillsFromBody(await response.json()) : undefined;
     } catch {
-      return [];
+      return undefined;
     }
   };
 
-  const [skillHub, legacy] = await Promise.all([
-    fetchSkills("/claude-code/marketplace.json"),
-    fetchSkills("/v1/skills"),
-  ]);
-  const skillHubNames = new Set(skillHub.map((skill) => skill.name));
-  const skills = [...skillHub, ...legacy.filter((skill) => !skillHubNames.has(skill.name))];
+  const skills = (await fetchSkills("/claude-code/marketplace.json")) ?? (await fetchSkills("/v1/skills")) ?? [];
   skillsCache = { baseUrl: normalizedBaseUrl, apiKey, fetchedAt: Date.now(), skills };
   return skills;
 }
 
+// Only the Skill Hub creates skills from JSON. LiteLLM's POST /v1/skills is Anthropic's multipart
+// Skills API, so a JSON code skill sent there never becomes a listable skill.
 export async function createSkill(
   baseUrl: string,
   apiKey: string,
-  input: {
-    name: string;
-    description?: string;
-    source?: Record<string, unknown>;
-    code?: string;
-    inputSchema?: Record<string, unknown>;
-  },
+  input: { name: string; description?: string; source: Record<string, unknown> },
   headers?: Record<string, string>,
   allowInsecureHttp = false,
 ): Promise<unknown> {
-  if (!input.source && !input.code) throw new Error("code is required when source is omitted");
+  if (!input.source) throw new Error("source is required: skills are created through the LiteLLM Skill Hub");
   const normalizedBaseUrl = normalizeBaseUrl(baseUrl, allowInsecureHttp);
-  let usedSkillHub = input.source !== undefined;
-  const skillHubPayload = input.source
-    ? {
-        name: input.name,
-        description: input.description,
-        source: input.source,
-      }
-    : {
-        name: input.name,
-        description: input.description,
-        code: input.code,
-        input_schema: input.inputSchema ?? { type: "object", properties: {} },
-      };
-  let response = await fetch(`${normalizedBaseUrl}${input.source ? "/claude-code/plugins" : "/v1/skills"}`, {
+  const response = await fetch(`${normalizedBaseUrl}/claude-code/plugins`, {
     method: "POST",
     headers: {
       ...headers,
       Authorization: `Bearer ${apiKey}`,
       "Content-Type": "application/json",
     },
-    body: JSON.stringify(skillHubPayload),
+    body: JSON.stringify({ name: input.name, description: input.description, source: input.source }),
     signal: AbortSignal.timeout(10_000),
   });
-  if (input.source && response.status === 404) {
-    usedSkillHub = false;
-    response = await fetch(`${normalizedBaseUrl}/v1/skills`, {
-      method: "POST",
-      headers: {
-        ...headers,
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        name: input.name,
-        description: input.description,
-        code: input.code,
-        input_schema: input.inputSchema ?? { type: "object", properties: {} },
-      }),
-      signal: AbortSignal.timeout(10_000),
-    });
-  }
   if (!response.ok) throw new Error(`LiteLLM skill create failed: HTTP ${response.status}`);
   skillsCache = undefined;
-  if (usedSkillHub) {
-    const enableResponse = await fetch(
-      `${normalizedBaseUrl}/claude-code/plugins/${encodeURIComponent(input.name)}/enable`,
-      {
-        method: "POST",
-        headers: { ...headers, Authorization: `Bearer ${apiKey}` },
-        signal: AbortSignal.timeout(10_000),
-      },
-    );
-    if (!enableResponse.ok) throw new Error(`LiteLLM skill enable failed: HTTP ${enableResponse.status}`);
-  }
+  const enableResponse = await fetch(
+    `${normalizedBaseUrl}/claude-code/plugins/${encodeURIComponent(input.name)}/enable`,
+    {
+      method: "POST",
+      headers: { ...headers, Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(10_000),
+    },
+  );
+  if (!enableResponse.ok) throw new Error(`LiteLLM skill enable failed: HTTP ${enableResponse.status}`);
   return response.json().catch(() => ({}));
 }
 
@@ -196,9 +154,7 @@ function formatSkills(skills: LiteLLMSkill[]): string {
 const CreateSkillParams = Type.Object({
   name: Type.String({ description: "Skill name" }),
   description: Type.Optional(Type.String({ description: "Skill description" })),
-  sourceJson: Type.Optional(Type.String({ description: "Optional Skill Hub source metadata JSON object" })),
-  code: Type.Optional(Type.String({ description: "Legacy Skills Gateway implementation or prompt code" })),
-  inputSchemaJson: Type.Optional(Type.String({ description: "Optional JSON Schema string for skill inputs" })),
+  sourceJson: Type.String({ description: "Skill Hub source metadata JSON object" }),
 });
 
 const DeleteSkillParams = Type.Object({
@@ -232,24 +188,15 @@ export function createSkillToolDefinitions(
     defineTool({
       name: "litellm_skill_create",
       label: "Create LiteLLM Skill",
-      description: "Create a skill on the LiteLLM proxy Skills Gateway.",
+      description: "Create and enable a skill on the LiteLLM proxy Skill Hub from source metadata.",
       parameters: CreateSkillParams,
       async execute(_toolCallId, params: Static<typeof CreateSkillParams>, _signal, _onUpdate, ctx) {
         const auth = await getAuth(ctx);
-        const source = params.sourceJson ? parseJsonObject(params.sourceJson, "sourceJson") : undefined;
-        const inputSchema = params.inputSchemaJson
-          ? parseJsonObject(params.inputSchemaJson, "inputSchemaJson")
-          : undefined;
+        const source = parseJsonObject(params.sourceJson, "sourceJson");
         const result = await createSkill(
           auth.baseUrl,
           auth.apiKey,
-          {
-            name: params.name,
-            description: params.description,
-            source,
-            code: params.code,
-            inputSchema,
-          },
+          { name: params.name, description: params.description, source },
           auth.headers,
           auth.allowInsecureHttp,
         );