pi-inferhub 0.2.0 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Damn Mersault
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -7,9 +7,10 @@ InferHub **combos** as selectable chat models.
 InferHub pools AI subscriptions behind one OpenAI-compatible endpoint. Combos
 are its server-side routed bundles — failover, cache-sticky, billed in USDC —
 and they are the primary consumption surface. This extension exposes **combos
-only**: each combo on your account appears as exactly one model named
-`combo/<slug>`. Upstream `prefix/model` entries, bare-name aliases, and
-free-tier models from InferHub's model list are intentionally not exposed.
+only by default**: each combo on your account appears as exactly one model
+named `combo/<slug>`. Upstream `prefix/model` entries, bare-name aliases, and
+free-tier models are not exposed unless you opt in with
+[`publishUpstream`](#full-upstream-catalog-optional).
 
 ## Install
 
@@ -51,9 +52,30 @@ points you to `/login inferhub` if not.
 ## Model selection
 
 Send `/model` and filter by provider name `inferhub` or by `combo/`. Each
-model id is `combo/<slug>` — the routable inference name on
+combo model id is `combo/<slug>` — the routable inference name on
 `https://api.inferhub.dev/v1`.
 
+## Configuration
+
+Optional `~/.pi/agent/pi-inferhub.json` (or `$PI_AGENT_DIR/pi-inferhub.json`).
+A missing file means defaults; a malformed one logs an issue and keeps the
+defaults — it never breaks startup.
+
+```json
+{ "publishUpstream": true }
+```
+
+### Full upstream catalog (optional)
+
+`publishUpstream` (default `false`) additionally publishes every chat model
+from `/v1/models` as a direct-selectable `prefix/model` entry, listed after
+the combos. This bypasses combo routing — you pick one specific serving — and
+is intended for pinning a particular upstream. Alias rows, `free/` tiers, and
+image/video generation models are never published, even with the option on.
+
+The `INFERHUB_PUBLISH_UPSTREAM` environment variable overrides the file in
+both directions (`1/true/yes/on`, `0/false/no/off`).
+
 ## Catalog derivation
 
 On refresh the extension makes two authenticated GETs —
@@ -63,19 +85,34 @@ combo to one model:
 
 - **Context/output limits** — minimum across resolvable members
   (`input_token_limit` / `max_output_tokens`), so a combo is only as large as
-  its smallest member. When no resolvable member supplies limits, conservative
-  fallbacks apply: **128k context / 8k max output**.
+  its smallest member. When no resolvable member supplies limits, fallbacks
+  apply: **256k context / 128k max output**. A limit of `0` is treated as
+  missing data rather than a real ceiling.
+- **Output cap enforcement** — `max_tokens` is sent rather than
+  `max_completion_tokens`, because InferHub ignores the latter (a request
+  capped at 20 tokens still produced 107).
 - **Image input** — offered (`text` + `image`) only when *every* resolvable
   member's modality includes image; otherwise text-only.
-- **Reasoning** — the combo is marked reasoning-capable when any resolvable
-  member advertises `reasoning_levels`; Pi's thinking levels map onto the
-  advertised ladder (levels a combo doesn't advertise are unavailable).
+- **Reasoning** — combos are always marked reasoning-capable: a false
+  negative hides Pi's thinking knob (the worse error), while a false positive
+  only shows an inert one. Where members advertise `reasoning_levels`, Pi's
+  levels map onto that union; when none advertise a ladder the map is omitted
+  so every level stays selectable.
+- **Surface** — each combo rides the API its membership implies:
+  **Anthropic messages** for Claude-only combos, **[OI] responses** for
+  GPT-only combos, and **chat completions** for everything else — including
+  combos that mix both native families. Family is decided from the model name,
+  not the serving prefix.
 - **Cost** — per-direction minimum of resolvable members' *official* rates
-  (see below). `cacheRead`/`cacheWrite` are shown as `0`: the catalog carries
-  no per-combo cache pricing, and none is fabricated.
+  (see below). Cache reads bill at **0.1x the input rate** (owner-confirmed);
+  cache writes are left at `0` because no write rate is published.
 
-Combos whose members are all unresolvable aliases get safe defaults:
-text-only, reasoning-capable, `0` cost, and the fallback limits.
+Member resolution is conservative but forgiving: a member resolves directly
+from `/v1/models` when its prefixed row carries data; otherwise it joins the
+prefixed servings of the same model name (exact suffix first, then a
+normalized last-segment match, which covers multi-segment prefixes such as
+`cp/cline-pass/<model>`). Combos whose members resolve to nothing at all get
+safe defaults: text-only, reasoning-capable, `0` cost, and the fallback limits.
 
 ## Refresh semantics
 
@@ -98,6 +135,27 @@ member's *official* list rates (`official_in` / `official_out`) per direction.
 InferHub's marketplace bills below list, so the real `usage.cost` reported per
 request comes in **at or under** the displayed estimate.
 
+Cached input is priced at **0.1x the input rate**, the rate InferHub charges
+(confirmed by its owner). On the Anthropic surface this is not theoretical:
+sending the same prefix twice cut a request's real cost by roughly 16x in
+testing, because the second call billed its 1218-token prefix as a cache read
+instead of fresh input.
+
+## Surfaces
+
+InferHub exposes three compatible APIs. The extension picks per model:
+
+| membership | API | endpoint |
+|---|---|---|
+| Claude models only | Anthropic messages | `api.inferhub.dev/v1/messages` |
+| GPT models only | [OI] responses | `api.inferhub.dev/v1/responses` |
+| both families, or neither | chat completions | `api.inferhub.dev/v1/chat/completions` |
+
+This buys native behaviour where it is unambiguous: structured thinking
+control, `cache_control` breakpoints, and the responses surface's typed tool
+calls. Mixed combos deliberately fall back to chat completions, which InferHub
+translates for every model.
+
 ## Design rationale
 
 The full design — why combos only, why `/v1/models` supplies member metadata

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-inferhub",
-	"version": "0.2.0",
+	"version": "0.4.0",
 	"description": "Pi extension for the InferHub inference provider",
 	"license": "MIT",
 	"keywords": [
@@ -23,9 +23,15 @@
 		"typebox": "*"
 	},
 	"peerDependenciesMeta": {
-		"@earendil-works/pi-ai": { "optional": false },
-		"@earendil-works/pi-coding-agent": { "optional": false },
-		"typebox": { "optional": false }
+		"@earendil-works/pi-ai": {
+			"optional": false
+		},
+		"@earendil-works/pi-coding-agent": {
+			"optional": false
+		},
+		"typebox": {
+			"optional": false
+		}
 	},
 	"devDependencies": {
 		"@earendil-works/pi-ai": "^1.0.4",
@@ -34,5 +40,17 @@
 		"typebox": "^1.3.36",
 		"typescript": "^6.0.3",
 		"vitest": "^5.0.3"
+	},
+	"files": [
+		"src",
+		"README.md",
+		"LICENSE"
+	],
+	"engines": {
+		"node": ">=22"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/damnmersault/pi-inferhub.git"
 	}
 }

package/src/catalog.ts

@@ -1,14 +1,55 @@
-import type { Model, ThinkingLevel, ThinkingLevelMap } from "@earendil-works/pi-ai";
+import type { Api, Model, ThinkingLevel, ThinkingLevelMap } from "@earendil-works/pi-ai";
 import { Type, type Static } from "typebox";
 import { Compile } from "typebox/compile";
 import { fetchJson, type FetchJsonOptions } from "./http.js";
-import { INFERENCE_BASE_URL, MGMT_BASE_URL, PROVIDER_NAME } from "./inferhub.js";
+import { ANTHROPIC_BASE_URL, INFERENCE_BASE_URL, MGMT_BASE_URL, PROVIDER_NAME } from "./inferhub.js";
 
 /** pi thinking levels, in ladder order; `off` is handled separately. */
 const PI_THINKING_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const satisfies readonly ThinkingLevel[];
 
 const CONTEXT_WINDOW_FALLBACK = 262_144;
 const MAX_TOKENS_FALLBACK = 131_072;
+/**
+ * Owner-confirmed 2026-10-18 (and matching the marketplace cache rule): InferHub
+ * bills cached input at 0.1x the input rate. Cache WRITES have no published
+ * rate, so they stay 0 rather than being guessed.
+ */
+const CACHE_READ_MULTIPLIER = 0.1;
+
+type ChatModel = Model<Api>;
+
+/** Which native surface a model name belongs to. */
+export type NativeFamily = "anthropic" | "openai" | "other";
+
+/**
+ * Family of the model NAME (last path segment), never the serving prefix:
+ * live catalog 2026-10-18 shows `kiro/` serving both claude-* and gpt-* rows.
+ * `gpt-oss` is an open-weight model, not an [OI] native one, so it stays other.
+ */
+export function nativeFamily(id: string): NativeFamily {
+	const name = (id.split("/").pop() ?? id).toLowerCase();
+	if (name.includes("claude")) return "anthropic";
+	if (/^(gpt(?!-oss)|o\d|codex)/.test(name)) return "openai";
+	return "other";
+}
+
+interface Surface {
+	api: Api;
+	baseUrl: string;
+}
+
+/**
+ * One native family present → its own surface. Both native families present
+ * (or none) → chat completions, which InferHub translates for every model.
+ */
+export function selectSurface(names: readonly string[]): Surface {
+	const families = new Set(names.map(nativeFamily));
+	const anthropic = families.has("anthropic");
+	const openai = families.has("openai");
+	if (anthropic && !openai) return { api: "anthropic-messages", baseUrl: ANTHROPIC_BASE_URL };
+	if (openai && !anthropic) return { api: "openai-responses", baseUrl: INFERENCE_BASE_URL };
+	return { api: "openai-completions", baseUrl: INFERENCE_BASE_URL };
+}
 
 export const MemberSchema = Type.Union([
 	Type.Object({ kind: Type.Literal("model"), model: Type.String() }),
@@ -31,6 +72,8 @@ export const CatalogModelSchema = Type.Object({
 	id: Type.String(),
 	owned_by: Type.Optional(Type.String()),
 	modality: Type.Optional(Type.String()),
+	output_modality: Type.Optional(Type.String()),
+	upstream_label: Type.Optional(Type.String()),
 	input_token_limit: Type.Optional(Type.Number()),
 	max_output_tokens: Type.Optional(Type.Number()),
 	reasoning_levels: Type.Optional(Type.Array(Type.String())),
@@ -60,24 +103,32 @@ const ModelsEnvelope = Type.Object({ data: Type.Array(CatalogModelSchema) });
 const CombosValidator = Compile(CombosEnvelope);
 const ModelsValidator = Compile(ModelsEnvelope);
 
+export interface FetchCatalogOptions extends FetchJsonOptions {
+	/** Also publish direct-selectable upstream models from /v1/models. */
+	publishUpstream?: boolean;
+}
+
 /** GET /combos + GET /v1/models (independent), then map combos to pi models. */
 export async function fetchComboCatalog(
 	token: string,
 	signal?: AbortSignal,
-	opts?: FetchJsonOptions,
-): Promise<Model<"openai-completions">[]> {
+	opts?: FetchCatalogOptions,
+): Promise<ChatModel[]> {
 	const [combos, models] = await Promise.all([
 		fetchJson<Combo[]>(`${MGMT_BASE_URL}/combos`, token, CombosValidator, signal, opts),
 		fetchJson<Static<typeof ModelsEnvelope>>(`${INFERENCE_BASE_URL}/models`, token, ModelsValidator, signal, opts),
 	]);
-	return combosToModels(combos, models.data);
+	const comboModels = combosToModels(combos, models.data);
+	// Combos are the product: they stay first. The upstream catalog only widens
+	// the list when the operator opts in.
+	return opts?.publishUpstream ? [...comboModels, ...catalogToModels(models.data)] : comboModels;
 }
 
 /** Pure combo → Model mapping; output order follows `combos` order. */
 export function combosToModels(
 	combos: Combo[],
 	catalogModels: CatalogModel[],
-): Model<"openai-completions">[] {
+): ChatModel[] {
 	const catalogById = new Map(catalogModels.map((model) => [model.id, model]));
 	return combos.map((combo) => comboToModel(combo, catalogById, catalogModels));
 }
@@ -86,10 +137,16 @@ function comboToModel(
 	combo: Combo,
 	catalogById: Map<string, CatalogModel>,
 	catalogModels: CatalogModel[],
-): Model<"openai-completions"> {
+): ChatModel {
 	// Alias rows (`owned_by: "alias"`, no data) and alias-kind members resolve
 	// through prefixed sibling servings of the same model name; min-of over the
 	// siblings bounds the combo exactly like directly-joined members.
+	//
+	// Live shape 2026-10-18: combos reference multi-segment prefixes
+	// (cp/cline-pass/<model>, cp/zai/<model>) that have no exact serving, while
+	// the same model is served under another prefix (zai/<model>,
+	// cmc/moonshotai/<model>). Exact suffix matches win; the normalized
+	// last-segment name is the recovery path, never a wider net.
 	const resolvable: CatalogModel[] = [];
 	for (const member of combo.members) {
 		const name = member.kind === "model" ? member.model : member.alias;
@@ -98,58 +155,144 @@ function comboToModel(
 			resolvable.push(entry);
 			continue;
 		}
-		for (const sibling of catalogModels) {
-			if (sibling.owned_by === "alias") continue;
-			if (sibling.id.endsWith(`/${name}`)) resolvable.push(sibling);
+		const exact = catalogModels.filter(
+			(sibling) => sibling.owned_by !== "alias" && sibling.id.endsWith(`/${name}`),
+		);
+		if (exact.length > 0) {
+			resolvable.push(...exact);
+			continue;
+		}
+		const normalized = normalizeModelName(name);
+		if (normalized.length > 0) {
+			resolvable.push(
+				...catalogModels.filter(
+					(sibling) => sibling.owned_by !== "alias" && normalizeModelName(sibling.id) === normalized,
+				),
+			);
 		}
 	}
 
-	// Alias-only / all-missed-join combos reason optimistically: a false
-	// negative hides thinking levels, a false positive shows an inert knob.
+	// Optimistic by design: a false negative hides thinking levels (the worse
+	// error); a false positive shows an inert knob. Applies to every combo,
+	// including level-less resolved members (live-verified 2026-10-18 on
+	// combo/deepseek-v4-pro: no advertised levels, honors reasoning_effort).
+	const name = combo.name.trim().length > 0 ? combo.name : combo.slug;
+	const surface = selectSurface(combo.members.map((member) => (member.kind === "model" ? member.model : member.alias)));
+	return buildModel(`combo/${combo.slug}`, name, resolvable, surface);
+}
+
+/**
+ * Direct-selectable upstream models from `/v1/models`, in catalog order.
+ * Skipped: alias rows (information-free duplicates of a prefixed serving),
+ * image-output rows (not chat models), and blank ids (live shape `cc/`).
+ */
+export function catalogToModels(catalogModels: CatalogModel[]): ChatModel[] {
+	return catalogModels
+		.filter(
+			(row) =>
+				row.owned_by !== "alias" &&
+				// AGENTS.md product rule: never surface image/video generation or
+				// `free/` tier models, even when the upstream catalog is published.
+				row.output_modality !== "image" &&
+				row.output_modality !== "video" &&
+				!row.id.startsWith("free/") &&
+				// Live shape `cc/`: prefix with an empty model segment — not selectable.
+				(row.id.split("/").pop() ?? "").trim().length > 0,
+		)
+		.map((row) => {
+			const label = row.upstream_label?.trim();
+			return buildModel(row.id, label && label.length > 0 ? label : row.id, [row], selectSurface([row.id]));
+		});
+}
+
+/** Shared pi-model construction for combo and direct-catalog entries. */
+function buildModel(id: string, name: string, sources: CatalogModel[], surface: Surface): ChatModel {
 	const advertised = new Set<string>();
-	for (const model of resolvable) {
+	for (const model of sources) {
 		for (const level of model.reasoning_levels ?? []) advertised.add(level);
 	}
-	const reasoning = resolvable.length === 0 || advertised.size > 0;
 
-	const image = resolvable.length > 0 && resolvable.every((model) => (model.modality ?? "").includes("image"));
+	const image = sources.length > 0 && sources.every((model) => (model.modality ?? "").includes("image"));
 
-	const priced = resolvable.flatMap((model) => (model.pricing ? [model.pricing] : []));
+	const priced = sources.flatMap((model) => (model.pricing ? [model.pricing] : []));
+	const inputRate = minOf(priced.map((pricing) => pricing.official_in)) ?? 0;
 
-	const model: Model<"openai-completions"> = {
-		id: `combo/${combo.slug}`,
-		name: combo.name.trim().length > 0 ? combo.name : combo.slug,
-		api: "openai-completions",
+	const model: ChatModel = {
+		id,
+		name,
+		api: surface.api,
 		provider: PROVIDER_NAME,
-		baseUrl: INFERENCE_BASE_URL,
+		baseUrl: surface.baseUrl,
 		input: image ? ["text", "image"] : ["text"],
 		cost: {
-			input: minOf(priced.map((pricing) => pricing.official_in)) ?? 0,
+			input: inputRate,
 			output: minOf(priced.map((pricing) => pricing.official_out)) ?? 0,
-			cacheRead: 0,
+			cacheRead: roundRate(inputRate * CACHE_READ_MULTIPLIER),
 			cacheWrite: 0,
 		},
-		reasoning,
-		contextWindow: minOf(resolvable.map((m) => m.input_token_limit)) ?? CONTEXT_WINDOW_FALLBACK,
-		maxTokens: minOf(resolvable.map((m) => m.max_output_tokens)) ?? MAX_TOKENS_FALLBACK,
+		reasoning: true,
+		contextWindow: minPositiveOf(sources.map((source) => source.input_token_limit)) ?? CONTEXT_WINDOW_FALLBACK,
+		maxTokens: minPositiveOf(sources.map((source) => source.max_output_tokens)) ?? MAX_TOKENS_FALLBACK,
 	};
-	// thinkingLevelMap: built only from an advertised union; an empty union
-	// (alias-only combos) omits the map so pi defaults keep thinking levels
-	// selectable — marking them all `null` would hide the knob entirely.
-	if (reasoning && advertised.size > 0) model.thinkingLevelMap = buildThinkingLevelMap(advertised);
+
+	if (surface.api === "openai-completions") {
+		// InferHub's [OI]-compatible surface ignores max_completion_tokens (verified
+		// live 2026-10-18: a 20-token cap sent that way produced 107 tokens; the
+		// same cap as max_tokens stopped at 20). pi-ai auto-detects per-provider
+		// and inferhub is not on its list, so pin the field explicitly.
+		model.compat = { maxTokensField: "max_tokens" };
+	}
+
+	// thinkingLevelMap: built only from an advertised union; a level-less union
+	// omits the level keys so pi defaults keep thinking levels selectable —
+	// marking them all `null` would hide the knob entirely.
+	if (surface.api === "anthropic-messages") {
+		// These Claude models reject thinking:{type:"disabled"} (400, live
+		// 2026-10-18) and require adaptive thinking. `off: null` makes pi-ai omit
+		// the field instead; the map is therefore always present, even when no
+		// ladder is advertised.
+		model.compat = { forceAdaptiveThinking: true };
+		// With no advertised ladder only `off` is pinned: the level keys stay
+		// absent so pi keeps every level selectable (optimistic by design).
+		model.thinkingLevelMap = advertised.size > 0 ? buildThinkingLevelMap(advertised, null) : { off: null };
+	} else if (surface.api === "openai-responses") {
+		// [OI] reasoning-off is effort "none"; the value "off" is accepted but
+		// leaves the effort unset (live-verified 2026-10-18).
+		if (advertised.size > 0) model.thinkingLevelMap = buildThinkingLevelMap(advertised, "none");
+		else model.thinkingLevelMap = { off: "none" };
+	} else if (advertised.size > 0) {
+		model.thinkingLevelMap = buildThinkingLevelMap(advertised, "off");
+	}
+
 	return model;
 }
 
+/** Cache rates are derived; trim float noise (3 * 0.1 = 0.30000000000000004). */
+function roundRate(value: number): number {
+	return Math.round(value * 1e6) / 1e6;
+}
+
 /** Each pi level maps to itself when the combo advertises it, else `null`. */
-function buildThinkingLevelMap(advertised: ReadonlySet<string>): ThinkingLevelMap {
-	const map: ThinkingLevelMap = { off: "off" };
+function buildThinkingLevelMap(advertised: ReadonlySet<string>, off: "off" | "none" | null): ThinkingLevelMap {
+	const map: ThinkingLevelMap = { off };
 	for (const level of PI_THINKING_LEVELS) {
 		map[level] = advertised.has(level) ? level : null;
 	}
 	return map;
 }
 
+/** Last path segment, lowercased, alphanumerics only: "cp/cline-pass/Kimi-K3" → "kimik3". */
+function normalizeModelName(id: string): string {
+	return (id.split("/").pop() ?? id).toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
 function minOf(values: Array<number | undefined>): number | undefined {
 	const present = values.filter((value): value is number => value !== undefined);
 	return present.length > 0 ? Math.min(...present) : undefined;
 }
+
+/** Limits: 0 (or non-finite) is missing data, never a real ceiling. Prices keep 0. */
+function minPositiveOf(values: Array<number | undefined>): number | undefined {
+	const present = values.filter((value): value is number => value !== undefined && Number.isFinite(value) && value > 0);
+	return present.length > 0 ? Math.min(...present) : undefined;
+}

package/src/config.ts

@@ -0,0 +1,75 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/** Canonical config file for this package, under pi's agent dir. */
+export const CONFIG_FILE_NAME = "pi-inferhub.json";
+
+/** Env override for `publishUpstream`; wins over the file when set. */
+export const PUBLISH_UPSTREAM_ENV = "INFERHUB_PUBLISH_UPSTREAM";
+
+export interface InferhubConfig {
+	/**
+	 * Also publish every chat model from `/v1/models` as a direct-selectable
+	 * `prefix/model` entry, alongside the `combo/<slug>` models. Combos stay
+	 * first; this only widens the catalog. Default: false.
+	 */
+	publishUpstream: boolean;
+	/** Human-readable problems found while loading; never fatal. */
+	issues: string[];
+}
+
+/** pi's agent dir: `PI_AGENT_DIR` when set, else `~/.pi/agent`. */
+export function defaultAgentDir(): string {
+	return process.env.PI_AGENT_DIR ?? join(homedir(), ".pi", "agent");
+}
+
+function parseEnvBoolean(raw: string): boolean | undefined {
+	const value = raw.trim().toLowerCase();
+	if (["1", "true", "yes", "on"].includes(value)) return true;
+	if (["0", "false", "no", "off"].includes(value)) return false;
+	return undefined;
+}
+
+/**
+ * Load `<agentDir>/pi-inferhub.json`. Missing file = defaults; malformed file =
+ * defaults + issue; unknown keys are ignored, wrong-typed values are reported
+ * and leave the default in place. Never throws for file content problems.
+ */
+export function loadInferhubConfig(agentDir: string = defaultAgentDir()): InferhubConfig {
+	const issues: string[] = [];
+	let raw: unknown;
+	try {
+		raw = JSON.parse(readFileSync(join(agentDir, CONFIG_FILE_NAME), "utf8"));
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException)?.code;
+		if (code === "ENOENT") return { publishUpstream: false, issues };
+		const message = error instanceof Error ? error.message : String(error);
+		issues.push(`${CONFIG_FILE_NAME} is not valid JSON (${message}); using defaults`);
+		return { publishUpstream: false, issues };
+	}
+
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+		issues.push(`${CONFIG_FILE_NAME} must contain a JSON object; using defaults`);
+		return { publishUpstream: false, issues };
+	}
+
+	let publishUpstream = false;
+	for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
+		if (key !== "publishUpstream") continue;
+		if (typeof value === "boolean") publishUpstream = value;
+		else issues.push(`publishUpstream must be a boolean (got ${typeof value}); using false`);
+	}
+
+	const envRaw = process.env[PUBLISH_UPSTREAM_ENV];
+	if (envRaw !== undefined) {
+		const envValue = parseEnvBoolean(envRaw);
+		if (envValue === undefined) {
+			issues.push(`${PUBLISH_UPSTREAM_ENV} must be a boolean-like value; ignoring`);
+		} else {
+			publishUpstream = envValue;
+		}
+	}
+
+	return { publishUpstream, issues };
+}

package/src/index.ts

@@ -1,9 +1,10 @@
-import { createProvider, type Provider } from "@earendil-works/pi-ai";
+import { createProvider, type Api, type Provider } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 // Pi's extension loader doesn't virtualize lazy API implementation subpaths yet
-import { openAICompletionsApi } from "@earendil-works/pi-ai/compat";
+import { anthropicMessagesApi, openAICompletionsApi, openAIResponsesApi } from "@earendil-works/pi-ai/compat";
 import { inferhubApiKeyAuth, loginInferhub } from "./auth.js";
 import { fetchComboCatalog } from "./catalog.js";
+import { type InferhubConfig, loadInferhubConfig } from "./config.js";
 import { INFERENCE_BASE_URL, PROVIDER_DISPLAY_NAME, PROVIDER_NAME } from "./inferhub.js";
 
 /**
@@ -17,8 +18,14 @@ export interface InferhubRegistrationPi {
 	registerCommand(name: string, options: { description?: string; handler: (args: string, ctx: ExtensionCommandContext) => Promise<void> }): void;
 }
 
-function inferhubProvider(): Provider<"openai-completions"> {
-	return createProvider({
+export interface InferhubRegistrationOptions {
+	/** Config loader seam; production reads `<agentDir>/pi-inferhub.json`. */
+	loadConfig?: () => InferhubConfig;
+}
+
+function inferhubProvider(options: InferhubRegistrationOptions = {}): Provider<Api> {
+	const loadConfig = options.loadConfig ?? (() => loadInferhubConfig());
+	return createProvider<Api>({
 		id: PROVIDER_NAME,
 		name: PROVIDER_DISPLAY_NAME,
 		baseUrl: INFERENCE_BASE_URL,
@@ -36,15 +43,23 @@ function inferhubProvider(): Provider<"openai-completions"> {
 			const credential = context.credential;
 			const token = credential?.type === "api_key" ? credential.key : undefined;
 			if (!token) return [];
-			return fetchComboCatalog(token, context.signal);
+			return fetchComboCatalog(token, context.signal, { publishUpstream: loadConfig().publishUpstream });
+		},
+		api: {
+			// Combos carry the surface their membership selects: anthropic-messages
+			// for Claude-only, openai-responses for GPT-only, chat completions for
+			// everything else (including mixed membership). createProvider
+			// dispatches on model.api.
+			"openai-completions": openAICompletionsApi(),
+			"openai-responses": openAIResponsesApi(),
+			"anthropic-messages": anthropicMessagesApi(),
 		},
-		api: openAICompletionsApi(),
 	});
 }
 
 /** Register the InferHub provider and its companion command. */
-export function registerInferhubProvider(pi: InferhubRegistrationPi): void {
-	pi.registerProvider(inferhubProvider());
+export function registerInferhubProvider(pi: InferhubRegistrationPi, options?: InferhubRegistrationOptions): void {
+	pi.registerProvider(inferhubProvider(options));
 
 	// pi's registerCommand takes a single command name; `/login inferhub` is
 	// provided by pi's auth system through the apiKey login wired above. This

package/src/inferhub.ts

@@ -1,4 +1,6 @@
 export const PROVIDER_NAME = "inferhub";
 export const PROVIDER_DISPLAY_NAME = "InferHub";
 export const INFERENCE_BASE_URL = "https://api.inferhub.dev/v1";
+/** Anthropic surface lives on the bare host: pi-ai appends /v1/messages itself. */
+export const ANTHROPIC_BASE_URL = "https://api.inferhub.dev";
 export const MGMT_BASE_URL = "https://inferhub.dev/api";