@oh-my-pi/pi-catalog 18.2.8 → 18.2.9

package/src/provider-models/cache-provider-id.ts

@@ -1,5 +1,10 @@
 import { CHARM_HYPER_API_BASE_URL, normalizeCharmHyperBaseUrl } from "../wire/charm-hyper";
 import { PERSONAL_GITHUB_COPILOT_BASE_URL } from "../wire/github-copilot";
+import {
+	SINGULARITYAPI_DEV_API_BASE_URL,
+	SINGULARITYAPI_TECH_API_BASE_URL,
+	normalizeSingularityApiBaseUrl,
+} from "../wire/singularityapi";
 
 export interface ModelCacheProviderIdOptions {
 	apiKey?: string;
@@ -11,6 +16,11 @@ const CREDENTIAL_SCOPED_MODEL_CACHE_PROVIDERS: Readonly<Record<string, true>> =
 	"opencode-zen": true,
 	"github-copilot": true,
 	"muse-code": true,
+	// Both SingularityAPI rosters are issued per key, so the namespace must be
+	// resolved with the credential (`hydrateCredentialScopedModelCaches`) rather
+	// than from the synchronous, credential-less startup read.
+	"singularityapi-dev": true,
+	"singularityapi-tech": true,
 };
 
 /** Whether a provider's model-cache namespace requires its resolved credential. */
@@ -87,6 +97,27 @@ export function resolveModelCacheProviderId(providerId: string, options: ModelCa
 			const scope = `${options.apiKey ?? ""}\u0000${baseUrl}`;
 			return `muse-code:models-v1:${Bun.hash(scope).toString(36)}`;
 		}
+		case "singularityapi-dev":
+		case "singularityapi-tech": {
+			// Both products issue their roster per key, and a configured proxy
+			// publishes its own. Discovery is authoritative, so a shared namespace
+			// would serve the previous key's roster for the full 24h TTL — including
+			// ids the current key cannot call. Hashing the pair means switching
+			// either re-runs discovery instead, and the provider-id prefix keeps the
+			// two products from ever reading each other's rows behind one proxy.
+			//
+			// Both call paths must land on one namespace: `ModelRegistry` resolves
+			// this provider through the credential-scoped hydration pass (it is in
+			// CREDENTIAL_SCOPED_MODEL_CACHE_PROVIDERS), while discovery hashes the
+			// `/v1`-suffixed endpoint the matching `singularityApi*ModelManagerOptions`
+			// passes — which is why both normalize through
+			// `normalizeSingularityApiBaseUrl` against their own canonical host.
+			const canonical =
+				providerId === "singularityapi-tech" ? SINGULARITYAPI_TECH_API_BASE_URL : SINGULARITYAPI_DEV_API_BASE_URL;
+			const baseUrl = normalizeSingularityApiBaseUrl(options.baseUrl, canonical);
+			const scope = `${options.apiKey ?? ""}\u0000${baseUrl}`;
+			return `${providerId}:models-v1:${Bun.hash(scope).toString(36)}`;
+		}
 		case "litellm": {
 			const baseUrl = options.baseUrl ?? getDefaultModelDiscoveryBaseUrl(providerId)!;
 			// rich-v11 invalidates rows that inherited ClinePass gateway metadata

package/src/provider-models/descriptors.ts

@@ -59,6 +59,8 @@ import {
 	sakanaModelManagerOptions,
 	siliconflowCnModelManagerOptions,
 	siliconflowModelManagerOptions,
+	singularityApiDevModelManagerOptions,
+	singularityApiTechModelManagerOptions,
 	syntheticModelManagerOptions,
 	togetherModelManagerOptions,
 	umansModelManagerOptions,
@@ -137,6 +139,8 @@ const MODEL_MANAGER_FACTORIES: Readonly<Partial<Record<KnownProvider, ModelManag
 	sakana: config => sakanaModelManagerOptions(config),
 	siliconflow: config => siliconflowModelManagerOptions(config),
 	"siliconflow-cn": config => siliconflowCnModelManagerOptions(config),
+	"singularityapi-dev": config => singularityApiDevModelManagerOptions(config),
+	"singularityapi-tech": config => singularityApiTechModelManagerOptions(config),
 	synthetic: config => syntheticModelManagerOptions(config),
 	together: config => togetherModelManagerOptions(config),
 	typesafe: config => typesafeModelManagerOptions(config),

package/src/provider-models/openai-compat.ts

@@ -55,6 +55,11 @@ import {
 	mergeCopilotApiHeaders,
 	parseGitHubCopilotApiKey,
 } from "../wire/github-copilot";
+import {
+	SINGULARITYAPI_DEV_API_BASE_URL,
+	SINGULARITYAPI_TECH_API_BASE_URL,
+	normalizeSingularityApiBaseUrl,
+} from "../wire/singularityapi";
 import { createBundledReferenceMap, createReferenceResolver, toModelSpec } from "./bundled-references";
 import { getDefaultModelDiscoveryBaseUrl, resolveModelCacheProviderId } from "./cache-provider-id";
 import { getClinePassModelMetadata } from "./cline-pass";
@@ -5048,6 +5053,9 @@ export function xiaomiModelManagerOptions(
 	// would incorrectly pin to the standard endpoint (api.xiaomimimo.com).
 	const baseUrl = isTokenPlanKey ? tokenPlanBaseUrls[0] : (config?.baseUrl ?? XIAOMI_STANDARD_BASE_URL);
 	const references = createBundledReferenceMap<"openai-completions">("xiaomi");
+	for (const seed of seedModels<"openai-completions">(providerId)) {
+		references.set(seed.id, seed);
+	}
 	const fetchModels = (url: string) =>
 		fetchOpenAICompatibleModels({
 			api: "openai-completions",
@@ -7400,3 +7408,154 @@ export function charmHyperModelManagerOptions(
 			}),
 	};
 }
+
+// ---------------------------------------------------------------------------
+// SingularityAPI
+// ---------------------------------------------------------------------------
+
+export interface SingularityApiModelManagerConfig {
+	apiKey?: string;
+	baseUrl?: string;
+	fetch?: FetchImpl;
+}
+
+interface SingularityApiCapability extends Record<string, unknown> {
+	endpoint?: unknown;
+	context_window_tokens?: unknown;
+	maximum_output_tokens?: unknown;
+	default_output_tokens?: unknown;
+	pricing?: unknown;
+}
+
+/** Endpoints that decide which transport serves a `/v1/models` row. */
+const SINGULARITYAPI_CHAT_ENDPOINT = "/v1/chat/completions";
+const SINGULARITYAPI_IMAGE_ENDPOINT = "/v1/images/generations";
+
+function singularityApiCapabilities(entry: OpenAICompatibleModelRecord): readonly SingularityApiCapability[] {
+	const capabilities = entry.capabilities;
+	if (!Array.isArray(capabilities)) return [];
+	return capabilities.filter((capability): capability is SingularityApiCapability => isRecord(capability));
+}
+
+function toSingularityApiRate(value: unknown): number {
+	const parsed = toNumber(value);
+	return parsed !== undefined && parsed >= 0 ? parsed : 0;
+}
+
+function resolveSingularityApiCost(capability: SingularityApiCapability | undefined): ModelSpec<Api>["cost"] {
+	const pricing = capability !== undefined && isRecord(capability.pricing) ? capability.pricing : undefined;
+	if (!pricing) return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+	return {
+		input: toSingularityApiRate(pricing.input_per_million_usd),
+		output: toSingularityApiRate(pricing.output_per_million_usd),
+		cacheRead: 0,
+		cacheWrite: 0,
+	};
+}
+
+/**
+ * Map one `/v1/models` row onto its serving transport.
+ *
+ * The wire's own `capabilities` list decides the transport: a row that serves
+ * chat completions is a chat model, and a row whose only surface is
+ * `/v1/images/generations` is routed to `openai-images` so
+ * `generateImage`-style dispatch can reach it. Without that assignment the row
+ * kept the discovery default (`openai-completions`) while still being marked
+ * as an image model, so it was offered as an image target and then rejected by
+ * every image client. The gateway bills image requests per request, never by
+ * tokens, so those rows carry no token tariff.
+ */
+function mapSingularityApiModel(entry: OpenAICompatibleModelRecord, defaults: ModelSpec<Api>): ModelSpec<Api> {
+	const capabilities = singularityApiCapabilities(entry);
+	const capability = capabilities.find(candidate => candidate.endpoint === SINGULARITYAPI_CHAT_ENDPOINT);
+	if (
+		capability === undefined &&
+		capabilities.some(candidate => candidate.endpoint === SINGULARITYAPI_IMAGE_ENDPOINT)
+	) {
+		return {
+			...defaults,
+			api: "openai-images",
+			name: toModelName(entry.name, defaults.name),
+			kind: "image",
+			reasoning: false,
+			input: ["text", "image"],
+			supportsTools: false,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow: null,
+			maxTokens: null,
+		};
+	}
+	return {
+		...defaults,
+		name: toModelName(entry.name, defaults.name),
+		contextWindow: toPositiveNumber(capability?.context_window_tokens, defaults.contextWindow),
+		maxTokens: toPositiveNumber(capability?.maximum_output_tokens, defaults.maxTokens),
+		cost: resolveSingularityApiCost(capability),
+	};
+}
+/**
+ * Core options shared by both SingularityAPI products. `mapModel` is supplied
+ * only by the universal gateway, whose rows publish capability metadata; the
+ * lane roster answers with bare ids and keeps the discovery defaults.
+ */
+function singularityApiModelManagerOptions(
+	providerId: "singularityapi-dev" | "singularityapi-tech",
+	canonical: string,
+	config: SingularityApiModelManagerConfig | undefined,
+	mapModel?: (entry: OpenAICompatibleModelRecord, defaults: ModelSpec<Api>) => ModelSpec<Api>,
+): ModelManagerOptions<Api> {
+	const apiKey = config?.apiKey;
+	const baseUrl = normalizeSingularityApiBaseUrl(config?.baseUrl, canonical);
+	return {
+		providerId,
+		cacheProviderId: resolveModelCacheProviderId(providerId, { apiKey, baseUrl }),
+		dynamicModelsAuthoritative: true,
+		...(apiKey && {
+			fetchDynamicModels: () =>
+				fetchOpenAICompatibleModels<Api>({
+					api: "openai-completions",
+					provider: providerId,
+					baseUrl,
+					apiKey,
+					...(mapModel && { mapModel }),
+					fetch: config?.fetch,
+				}),
+		}),
+	};
+}
+
+/**
+ * `singularityapi-dev` — SingularityAPI's pay-as-you-go universal gateway
+ * (`api.singularityapi.dev`): chat completions over a 300+ model catalog,
+ * plus image generation for the rows that advertise it.
+ * `GET /v1/models` publishes each row's per-endpoint capabilities — context
+ * window, max output tokens, and per-million pricing as 12-decimal strings —
+ * with `cache-control: no-store`, so discovery reads limits and tariffs
+ * straight off the wire and the endpoint list picks each row's transport.
+ * Rows without a reasoning vocabulary stay non-reasoning; reviewed KDL rules
+ * own the ladders the gateway leaves implicit (DeepSeek Flash/Pro, GPT-5.6
+ * flagships), because a model discovered as non-reasoning never sends a
+ * `reasoning_effort` and the gateway requires one alongside tools.
+ */
+export function singularityApiDevModelManagerOptions(
+	config?: SingularityApiModelManagerConfig,
+): ModelManagerOptions<Api> {
+	return singularityApiModelManagerOptions(
+		"singularityapi-dev",
+		SINGULARITYAPI_DEV_API_BASE_URL,
+		config,
+		mapSingularityApiModel,
+	);
+}
+
+/**
+ * `singularityapi-tech` — SingularityAPI's slot-reserved DeepSeek lanes
+ * (`api.singularityapi.tech`). `/v1/models` answers with bare `{id}` rows and
+ * no capability metadata, so rows keep the discovery defaults and the
+ * reviewed KDL rules own the wire shape, limits patch, and effort ladder.
+ */
+export function singularityApiTechModelManagerOptions(
+	config?: SingularityApiModelManagerConfig,
+): ModelManagerOptions<Api> {
+	return singularityApiModelManagerOptions("singularityapi-tech", SINGULARITYAPI_TECH_API_BASE_URL, config);
+}

package/src/wire/singularityapi.ts

@@ -0,0 +1,34 @@
+/**
+ * SingularityAPI gateways, shared so a host migration — or a self-hosted
+ * proxy override — touches a single module.
+ *
+ * SingularityAPI ships two unrelated products behind one brand: the
+ * pay-as-you-go universal gateway (`singularityapi-dev`) and the
+ * slot-reserved DeepSeek lanes (`singularityapi-tech`). They accept disjoint
+ * keys, so each provider resolves its own canonical endpoint from here.
+ */
+export const SINGULARITYAPI_DEV_API_BASE_URL = "https://api.singularityapi.dev/v1";
+export const SINGULARITYAPI_TECH_API_BASE_URL = "https://api.singularityapi.tech/v1";
+
+/**
+ * Resolve a configured SingularityAPI base URL onto its gateway's `/v1`
+ * surface.
+ *
+ * Every consumer must agree on this, because they key different things off the
+ * result: discovery and inference target it, and the model-cache namespace is
+ * hashed from it. `ModelRegistry` hashes the raw configured value while the
+ * model-manager options hash a `/v1`-suffixed one, so a disagreement would
+ * split the namespace discovery writes from the one the registry reads and the
+ * authoritative roster would never come back.
+ *
+ * `canonical` names the product the caller belongs to: a blank or
+ * whitespace-only value means "not configured" and resolves to that canonical
+ * host, while anything else keeps its host and gains the `/v1` segment if it
+ * omits one. Passing the wrong product's canonical URL would silently point a
+ * provider at the other gateway, so there is no default.
+ */
+export function normalizeSingularityApiBaseUrl(baseUrl: string | undefined, canonical: string): string {
+	const trimmed = baseUrl?.trim().replace(/\/+$/, "");
+	if (!trimmed) return canonical;
+	return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+}