@oh-my-pi/pi-catalog 17.3.8 → 17.4.1

package/dist/types/discovery/index.d.ts

@@ -3,3 +3,4 @@ export * from "./codex.js";
 export * from "./gemini.js";
 export * from "./gitlab-duo-workflow.js";
 export * from "./openai-compatible.js";
+export * from "./protobuf.js";

package/dist/types/discovery/protobuf.d.ts

@@ -0,0 +1,102 @@
+/**
+ * High-performance, zero-builder protobuf wire codecs for @oh-my-pi/pi-catalog.
+ *
+ * Schemas are declared as static IR descriptors with near-zero module load overhead
+ * and lazy compilation on first encode/decode/create invocation.
+ */
+/** JSON values carried by `google.protobuf.Value` fields. */
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** An unrecognised wire field retained for forward-compatible round-trips. */
+export interface ProtoUnknownField {
+    no: number;
+    wireType: number;
+    data: Uint8Array;
+}
+/** Shared internal metadata present on every decoded protocol message. */
+export interface ProtoMessage {
+    $typeName?: string;
+    $unknown?: ProtoUnknownField[];
+}
+/** A bidirectional codec for one protobuf message type. */
+export interface MessageCodec<T extends ProtoMessage = ProtoMessage> {
+    (value: T): Uint8Array;
+    (value: Uint8Array): T;
+    /** Creates a message with protobuf defaults for omitted fields. */
+    create(value?: Partial<T>): T;
+    /** Encodes one message into protobuf wire bytes. */
+    encode(value: T): Uint8Array;
+    /** Decodes one protobuf message from wire bytes. */
+    decode(value: Uint8Array): T;
+    /** Converts a message to its protobuf JSON representation. */
+    toJson(value: T): JsonValue;
+}
+/** Infers a message shape from a codec result. */
+export type InferMessage<TCodec> = TCodec extends MessageCodec<infer TMessage> ? TMessage : never;
+/** Erases a referenced message's concrete shape for static field descriptors. */
+export interface MessageReference {
+    encode(value: unknown): Uint8Array;
+    decode(value: Uint8Array): ProtoMessage;
+    toJson(value: unknown): JsonValue;
+}
+export type ScalarKind = "bool" | "bytes" | "double" | "enum" | "float" | "int32" | "int64" | "string" | "uint32" | "uint64";
+export type WireType = 0 | 1 | 2 | 5;
+export interface ScalarFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: ScalarKind;
+    readonly optional?: boolean;
+    readonly repeat?: boolean;
+}
+export interface MessageFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "message";
+    readonly T: () => MessageReference;
+    readonly repeat?: boolean;
+}
+export interface EnumFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "enum";
+    readonly optional?: boolean;
+    readonly repeat?: boolean;
+}
+export interface MapFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "map";
+    readonly K: "string";
+    readonly V: ScalarKind | (() => MessageReference);
+}
+export type VariantDesc = {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: ScalarKind;
+} | {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "message";
+    readonly T: () => MessageReference;
+};
+export interface OneofFieldDesc {
+    readonly kind: "oneof";
+    readonly name: string;
+    readonly variants: readonly VariantDesc[];
+}
+export type FieldDesc = ScalarFieldDesc | MessageFieldDesc | EnumFieldDesc | MapFieldDesc | OneofFieldDesc;
+/** Creates a high-performance, lazy protobuf message codec from an IR field descriptor list. */
+export declare function pb<T extends ProtoMessage = ProtoMessage>(typeName: string, fields?: readonly FieldDesc[]): MessageCodec<T>;
+/** Creates a message using its codec's protobuf defaults. */
+export declare function create<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value?: Partial<TMessage>): TMessage;
+/** Encodes a message using its codec. */
+export declare function toBinary<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value: TMessage): Uint8Array;
+/** Decodes wire bytes using a message codec. */
+export declare function fromBinary<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value: Uint8Array): TMessage;
+/** Converts a message to protobuf JSON using its codec. */
+export declare function toJson<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value: TMessage): JsonValue;
+/** Encodes a JSON value as `google.protobuf.Value`. */
+export declare function encodeJsonValue(value: JsonValue): Uint8Array;
+/** Decodes `google.protobuf.Value` wire bytes into a JSON value. */
+export declare function decodeJsonValue(value: Uint8Array): JsonValue;

package/dist/types/identity/family.d.ts

@@ -56,6 +56,8 @@ export declare const isDeepseekModelIdOrName: (modelId: string) => boolean;
 export declare const isDeepseekV4FlashModelId: (modelId: string) => boolean;
 /** Xiaomi MiMo family by id or display name. */
 export declare const isMimoModelIdOrName: (modelId: string) => boolean;
+/** StepFun Step 3.7 Flash SKU in any namespace form (`kilo/stepfun/step-3.7-flash:free`). */
+export declare const isStep37FlashModelId: (modelId: string) => boolean;
 /** Gemini family ids in any namespace form (`gemini-*`, `google/gemini-*`, `openrouter/google/gemini-…`). */
 export declare const isGeminiModelId: (modelId: string) => boolean;
 /** Grok family ids across namespace and delimiter forms (`grok-*`, `cursor-grok-*`, `xai/grok-*`). */
@@ -100,6 +102,13 @@ export declare const isMinimaxM3FamilyModelId: (modelId: string) => boolean;
  * and `none`.
  */
 export declare const isOpenAIGptOssModelId: (modelId: string) => boolean;
+/**
+ * Meta Muse Spark ids (`muse-spark-1.1`, `muse-spark-1.2`,
+ * `muse-spark-1.2-contributor`, `meta/muse-spark-1.2`). The Responses
+ * `reasoning.effort` wire accepts `none` (thinking-off) plus
+ * `minimal`/`low`/`medium`/`high`/`xhigh`.
+ */
+export declare const isMuseSparkModelId: (modelId: string) => boolean;
 /** OpenAI model ids (gpt-*, chatgpt-*, o1/o3/o4 SKUs, codex-*, or openai/*). */
 export declare const isOpenAIModelId: (modelId: string) => boolean;
 /**
@@ -199,6 +208,14 @@ export declare const hasOpus47ApiRestrictions: (modelId: string) => boolean;
  * @see https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages
  */
 export declare const supportsMidConversationSystemMessages: (modelId: string) => boolean;
+/**
+ * Models that reliably follow the hashline line-anchored edit dialect
+ * (`[path#TAG]` headers plus 1-indexed anchors). Kimi, MiMo, DeepSeek V4
+ * Flash, and Step 3.7 Flash miscount anchors or drop the tag header often
+ * enough that hosts fall back to a literal search-replace edit format for
+ * them.
+ */
+export declare const supportsHashlineEdits: (modelId: string) => boolean;
 export declare const isAnthropicFableOrMythosModel: (modelId: string) => boolean;
 /** Thinking-variant token location inside a model id. */
 export interface ThinkingVariantToken {

package/dist/types/index.d.ts

@@ -6,6 +6,7 @@ export * from "./identity/index.js";
 export * from "./model-cache.js";
 export * from "./model-manager.js";
 export * from "./model-thinking.js";
+export * from "./model-tokenizer.js";
 export * from "./models.js";
 export * from "./provider-models/index.js";
 export * from "./types.js";

package/dist/types/model-manager.d.ts

@@ -31,11 +31,11 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
     /** Cached model ids whose presence forces refresh when the static or migration-policy fingerprint changes. */
     dropCachedModelIdsOnStaticMismatch?: readonly string[];
     /**
-     * Trusted, provider-wide request headers (compile-time constants, never
-     * credentials) that the cache may restore by value for any model whose live
-     * headers matched them at write time. Lets header-bearing dynamic models
-     * without a bundled static entry survive offline reads instead of being
-     * dropped as unrestorable (e.g. GitHub Copilot's User-Agent + API version).
+     * Trusted, provider-wide request headers that can be safely re-derived at
+     * cache-read time. The cache never persists their values. Models whose live
+     * headers matched this record at write time can survive offline reads without
+     * a bundled static source, including configured discovery providers whose
+     * bearer header comes from the current local config.
      */
     restorableHeaderFallback?: Record<string, string>;
     /** Optional dynamic endpoint fetcher. */

package/dist/types/model-tokenizer.d.ts

@@ -0,0 +1,8 @@
+import type { ModelTokenizer } from "./types.js";
+/**
+ * Resolve the exact locally embedded tokenizer for a canonical model id.
+ *
+ * This is catalog policy, not a runtime caller heuristic: [`buildModel`](./build.ts)
+ * materializes the result as `Model.tokenizer`; consumers read that property.
+ */
+export declare function resolveModelTokenizer(modelId: string): ModelTokenizer | undefined;

package/dist/types/provider-models/descriptors.d.ts

@@ -205,7 +205,7 @@ export declare const CATALOG_PROVIDERS: readonly [{
     readonly id: "litellm";
     readonly defaultModel: "claude-opus-4-8";
     readonly envVars: readonly ["LITELLM_API_KEY"];
-    readonly createModelManagerOptions: (config: ModelManagerConfig) => import("../index.js").ModelManagerOptions<"openai-completions", unknown>;
+    readonly createModelManagerOptions: (config: ModelManagerConfig) => import("../index.js").ModelManagerOptions<import("../index.js").Api, unknown>;
     readonly catalogDiscovery: {
         readonly label: "LiteLLM";
         readonly allowUnauthenticated: true;

package/dist/types/provider-models/openai-compat.d.ts

@@ -568,12 +568,14 @@ export interface FetchLiteLLMRichModelsOptions<TApi extends Api> {
     signal?: AbortSignal;
     timeoutMs?: number;
     referenceResolver?: (modelId: string) => ModelSpec<TApi> | undefined;
+    resolveApi?: (entry: Record<string, unknown>, modelId: string) => TApi;
 }
 export declare const OPENAI_COMPAT_DISCOVERY_DEFAULT_CONTEXT_WINDOW = 128000;
 export declare const OPENAI_COMPAT_DISCOVERY_DEFAULT_MAX_TOKENS = 32768;
 export declare function normalizeLiteLLMManagementBaseUrl(baseUrl: string): string;
+export declare function resolveLiteLLMApi(entry: Record<string, unknown> | undefined, id: string, fallbackApi?: Api): Api;
 export declare function fetchLiteLLMRichModels<TApi extends Api>(options: FetchLiteLLMRichModelsOptions<TApi>): Promise<ModelSpec<TApi>[] | null>;
-export declare function litellmModelManagerOptions(config?: LiteLLMModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export declare function litellmModelManagerOptions(config?: LiteLLMModelManagerConfig): ModelManagerOptions<Api>;
 export interface VllmModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;

package/dist/types/types.d.ts

@@ -123,7 +123,7 @@ export interface Usage {
 }
 export type OpenAIReasoningFormat = "openai" | "openrouter" | "zai" | "kimi" | "qwen" | "qwen-chat-template";
 export type OpenAIReasoningDisableMode = "omit" | "lowest-effort" | "none-effort" | "openrouter-enabled-false" | "zai-thinking-disabled" | "qwen-enable-thinking-false" | "qwen-template-false";
-export type OpenAIStreamMarkupHealingPattern = "kimi" | "dsml" | "thinking";
+export type OpenAIStreamMarkupHealingPattern = "kimi" | "dsml" | "qwen" | "thinking";
 /**
  * Compatibility settings for openai-completions API.
  * Use this to override URL-based auto-detection for custom providers.
@@ -716,6 +716,15 @@ export interface LongContextTokenCost extends TokenCost {
 export interface ModelCost extends TokenCost {
     longContext?: LongContextTokenCost;
 }
+/**
+ * Exact local content tokenizer family for a model.
+ *
+ * Absent means no first-party local tokenizer is known and consumers retain
+ * their estimate/default-tokenizer policy. The values name tokenizer
+ * generations rather than providers: DeepSeek V3 through V4 share
+ * `"deepseek-v3"`; Kimi K2 through K3 share `"kimi-k2"`.
+ */
+export type ModelTokenizer = "claude-v3" | "claude-v47" | "claude-v5" | "claude-v5-sonnet" | "qwen3" | "deepseek-v3" | "kimi-k2" | "glm5";
 export interface Model<TApi extends Api = Api> {
     id: string;
     /**
@@ -739,6 +748,12 @@ export interface Model<TApi extends Api = Api> {
     provider: Provider;
     baseUrl: string;
     reasoning: boolean;
+    /**
+     * Exact local tokenizer family resolved from the model identity or supplied
+     * explicitly by a catalog/discovery source. Absent leaves local counting to
+     * the consumer's fallback policy.
+     */
+    tokenizer?: ModelTokenizer;
     input: ("text" | "image")[];
     /**
      * Decoder family used for image inputs when it has narrower format support
@@ -797,6 +812,8 @@ export interface Model<TApi extends Api = Api> {
     preferWebsockets?: boolean;
     /** Codex Responses Lite transport: send the lite marker and carry instructions/tools as input items (mirrors codex-rs `use_responses_lite`). */
     useResponsesLite?: boolean;
+    /** Codex Code Mode restriction: model expects tools routed through a programmatic exec surface (mirrors codex-rs `tool_mode`). */
+    toolMode?: "code_mode_only";
     /** Preferred model to switch to when context promotion is triggered (model id or provider/id). */
     contextPromotionTarget?: string;
     /** Preferred model to use only for compaction (model id or provider/id); the active session model is unchanged. */

package/dist/types/variant-collapse.d.ts

@@ -58,7 +58,7 @@ export declare const ANTIGRAVITY_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
 /** `google-gemini-cli` Gemini families on the official CLI's level transport. */
 export declare const GEMINI_CLI_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
 export declare const DEVIN_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
-/** `cursor` Grok families: per-effort siblings collapsed per service-tier lane. */
+/** `cursor` per-effort sibling families collapsed per service-tier lane: Grok 4.5/4.6 plus GPT-5.6 Luna/Sol/Terra. */
 export declare const CURSOR_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
 /** Provider id → hand collapse table. The CCA providers diverge on thinking transport. */
 export declare const VARIANT_COLLAPSE_TABLES: Readonly<Record<string, VariantCollapseTable>>;

package/dist/types/wire/codex.d.ts

@@ -26,6 +26,8 @@ export declare const OPENAI_HEADERS: {
     readonly RESPONSES_LITE: "x-openai-internal-codex-responses-lite";
     /** DeviceCheck attestation envelope (codex-rs `X_OAI_ATTESTATION_HEADER`); sent on ChatGPT-OAuth requests. */
     readonly ATTESTATION: "x-oai-attestation";
+    /** Client-declared data residency for region-pinned enterprise workspaces. */
+    readonly RESIDENCY: "x-openai-internal-codex-residency";
 };
 export declare const OPENAI_HEADER_VALUES: {
     readonly BETA_RESPONSES: "responses=experimental";
@@ -43,3 +45,22 @@ export declare const JWT_CLAIM_PATH: "https://api.openai.com/auth";
  * Returns undefined if the token is not a valid Codex JWT.
  */
 export declare function getCodexAccountId(accessToken: string): string | undefined;
+/**
+ * Extract the account's data residency from a Codex JWT access token.
+ *
+ * Enterprise ChatGPT workspaces can be pinned to a region. Such a workspace
+ * rejects a Codex request whose egress does not match it — HTTP 401
+ * `Workspace is not authorized in this region.` — unless the client declares
+ * the residency itself. The token already carries it, so no configuration is
+ * needed: `chatgpt_data_residency` is the authoritative claim, with
+ * `chatgpt_compute_residency` as the fallback for tokens that only carry that.
+ *
+ * Returns undefined for a non-JWT token, or for the (common) accounts whose
+ * claims omit residency entirely — those workspaces are not region-pinned.
+ */
+export declare function getCodexResidency(accessToken: string): string | undefined;
+/**
+ * Adds the token's workspace residency to Codex request headers without
+ * replacing a caller-supplied value.
+ */
+export declare function applyCodexResidencyHeader(headers: Headers | Record<string, string>, accessToken: string): void;

package/package.json

@@ -1,10 +1,10 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "17.3.8",
+	"version": "17.4.1",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://omp.sh",
-	"author": "Can Boluk",
+	"author": "Stencil Labs, Inc.",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -31,15 +31,14 @@
 		"fix": "biome check --write --unsafe .",
 		"fmt": "biome format --write .",
 		"gen:models": "bun scripts/generate-models.ts",
-		"gen:cursor-proto": "protoc --plugin=protoc-gen-es=../../node_modules/.bin/protoc-gen-es --es_out=src/discovery/cursor-gen --es_opt=target=ts -I ../ai/src/providers/cursor/proto ../ai/src/providers/cursor/proto/agent.proto"
+		"gen:proto": "bun scripts/generate-protocols.ts"
 	},
 	"dependencies": {
-		"@bufbuild/protobuf": "^2.12.1",
-		"@oh-my-pi/omptype": "17.3.8",
-		"@oh-my-pi/pi-utils": "17.3.8"
+		"@oh-my-pi/omptype": "17.4.1",
+		"@oh-my-pi/pi-utils": "17.4.1"
 	},
 	"devDependencies": {
-		"@oh-my-pi/pi-ai": "17.3.8",
+		"@oh-my-pi/pi-ai": "17.4.1",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {
@@ -49,6 +48,8 @@
 		"src",
 		"README.md",
 		"CHANGELOG.md",
+		"LICENSE",
+		"THIRD-PARTY-NOTICES.txt",
 		"dist/types"
 	],
 	"exports": {

package/src/build.ts

@@ -16,6 +16,7 @@ import { buildDevinCompat } from "./compat/devin";
 import { buildOpenAICompat, buildOpenAIResponsesCompat, buildOpenRouterCompat } from "./compat/openai";
 import { bareModelId, parseOpenAIModel, semverGte } from "./identity/classify";
 import { resolveModelThinking } from "./model-thinking";
+import { resolveModelTokenizer } from "./model-tokenizer";
 import type { Api, CompatOf, Model, ModelSpec } from "./types";
 import { cleanModelName } from "./utils";
 
@@ -58,12 +59,18 @@ function supportsOpenAIGAComputerUse(spec: ModelSpec<Api>, explicitSupport: bool
 	return parsed !== null && semverGte(parsed.version, "5.4");
 }
 
+/**
+ * Build one model from an authored spec. Bundled models.json rows are fully
+ * materialized by the generator and consumed directly (see `models.ts`), so
+ * this only runs for discovered/custom/override specs.
+ */
 export function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi> {
 	const compat = buildCompat(spec) as CompatOf<TApi>;
 	const supportsComputerUseConfig = explicitComputerUseConfig(spec);
 	return {
 		...spec,
 		name: cleanModelName(spec.name),
+		tokenizer: spec.tokenizer ?? resolveModelTokenizer(spec.requestModelId ?? spec.id),
 		thinking: resolveModelThinking(spec, compat),
 		supportsComputerUse: supportsOpenAIGAComputerUse(spec, supportsComputerUseConfig),
 		supportsComputerUseConfig,

package/src/compat/openai.ts

@@ -759,7 +759,7 @@ export function buildOpenAIResponsesCompat(spec: OpenAIResponsesSpecLike): Resol
 		disableReasoningOnForcedToolChoice: isKimiModel,
 		disableReasoningOnToolChoice: isDeepseekFamily && reasoningCapable && !isOpenRouter,
 		supportsToolChoice: true,
-		supportsForcedToolChoice: true,
+		supportsForcedToolChoice: spec.provider !== "opencode-go" && spec.provider !== "opencode-zen",
 		supportsNamedToolChoice: STRING_ONLY_NAMED_TOOL_CHOICE_PROVIDERS[spec.provider] !== true,
 		reasoningContentField: "reasoning_content",
 		requiresReasoningContentForToolCalls:

package/src/discovery/codex.ts

@@ -68,6 +68,7 @@ const codexModelEntrySchema = type({
 	"priority?": "unknown",
 	"prefer_websockets?": "unknown",
 	"use_responses_lite?": "unknown",
+	"tool_mode?": "unknown",
 });
 
 const codexModelsResponseSchema = type({
@@ -282,6 +283,7 @@ interface ParsedCodexModelEntry {
 	input: ("text" | "image")[];
 	preferWebsockets: boolean;
 	useResponsesLite: boolean;
+	toolMode: boolean;
 	priority: number;
 }
 
@@ -310,6 +312,7 @@ function parseCodexModelEntry(entry: unknown): ParsedCodexModelEntry | null {
 		input: normalizeInputModalities(payload.input_modalities),
 		preferWebsockets: toBoolean(payload.prefer_websockets) === true,
 		useResponsesLite: toBoolean(payload.use_responses_lite) === true,
+		toolMode: payload.tool_mode === "code_mode_only",
 		priority: toFiniteNumber(payload.priority) ?? Number.MAX_SAFE_INTEGER,
 	};
 }
@@ -360,6 +363,7 @@ function buildNormalizedCodexModel(
 			maxTokens,
 			...(parsed.preferWebsockets ? { preferWebsockets: true } : {}),
 			...(parsed.useResponsesLite ? { useResponsesLite: true } : {}),
+			...(parsed.toolMode ? { toolMode: "code_mode_only" as const } : {}),
 			...(parsed.priority !== Number.MAX_SAFE_INTEGER ? { priority: parsed.priority } : {}),
 		},
 	};