@linxiraos/pi-catalog 1.1.7 → 1.1.9

package/CHANGELOG.md

@@ -2,9 +2,9 @@
 
 ## [Unreleased]
 
-## [1.1.7] - 2026-09-01
+## [1.1.9] - 2026-09-05
 
-- 同步上游 OMP v18.0.11（`b8ce33a58911c26bed1d84f0db9a5e2e727c49a2`）。
+- v18.1.10 sync baseline; retired pi-hashline catalog entry removed from the version-line catalogs.
 
 ## [1.1.6] - 2026-08-30
 
@@ -14,12 +14,6 @@
 
 - 同步上游 OMP v18.0.5 / v18.0.6：新增 DeepInfra / Yolo-Auto 提供商标识。
 
-## [1.1.3] - 2026-08-25
-
-### Fixed
-
-- Republished as 1.1.3 to reset the latest tag after the broken 1.1.2 (no functional change over 1.1.1).
-
 ## [1.1.2] - 2026-08-25
 
 ### Fixed
@@ -47,3 +41,8 @@
 ### Changed
 
 - Reset the version to 1.0.0 and republished under the `@linxiraos/*` scope, breaking from the `@linxiraos` version lineage.
+- Bundled model metadata is prebuilt during generation, reducing catalog startup work.
+
+### Fixed
+
+- Fixed tool-call turn failures for `opencode-go/muse-spark-1.2` and related variants by ensuring API transport pins apply to live discovery and automatically inferring response routes for gateway-first OpenCode models ([#8957](https://github.com/can1357/oh-my-pi/issues/8957)).

package/README.md

@@ -9,25 +9,26 @@ Model catalog for [Zeta](https://github.com/Linxira-OS/linxira-zeta): bundled mo
 | `models.json` + `models`        | Bundled model database (pricing, context windows, modalities, thinking support)                             |
 | `provider-models`               | Provider catalog descriptors (`CATALOG_PROVIDERS`), per-provider model resolution rules                     |
 | `discovery`                     | Runtime model discovery for OpenAI-compatible endpoints, Gemini, Codex, Cursor, Antigravity, Ollama         |
-| `identity`                      | Model id parsing and classification (family/version), reference resolution, equivalence, selection priority |
-| `model-thinking`                | Thinking/reasoning metadata and generated per-model policies                                                |
+| `compat/rules`                  | Checked-in KDL policy tree: taxonomy (classes/families/revisions), class/provider cascade rules, runtime behavior vocabulary; compiled by `bun run gen:compat` into the committed `rules.json` |
+| `compat`                        | The rule engine: `classifyModel` (taxonomy), `resolveModelPolicy` (cascade), behavior accessors (`api-routes`, `model-limits`, `exclude-models`, `pricing-peer`), collapse, and OpenAI/Anthropic wire builders that consume resolved records |
+| `identity`                      | Mechanical id utilities: reference resolution against the bundled index, dialects, selection priority, tokenizer families                                |
+| `model-thinking`                | Runtime thinking helpers (`getSupportedEfforts`, effort clamping/mapping, wire-id routing) over resolved model records                                   |
 | `model-manager` / `model-cache` | Runtime model registry with discovery refresh and on-disk caching                                           |
-| `variant-collapse`              | Collapsing provider-specific variants of the same underlying model                                          |
-| `compat`                        | Request/response compatibility fixups for OpenAI- and Anthropic-shaped APIs                                 |
 | `wire`                          | Wire-level helpers: Codex, Gemini headers, GitHub Copilot                                                   |
 | `effort`                        | Reasoning-effort level definitions                                                                          |
 
 Import from subpaths (`@linxiraos/pi-catalog/<module>`) or the root barrel.
 
-## models.json is generated
+## models.json and rules.json are generated
 
-Never edit `src/models.json` by hand — it is produced from upstream sources (stencil.so, provider catalog discovery, OpenCode docs) by `scripts/generate-models.ts` and the resolvers in `src/provider-models/`. Regenerate with:
+Never edit `src/models.json` or `src/compat/rules.json` by hand. `models.json` is produced from upstream sources (stencil.so, provider catalog discovery, OpenCode docs) by `scripts/generate-models.ts`; `rules.json` is compiled from the KDL tree in `src/compat/rules/`. Regenerate with:
 
 ```sh
-bun run gen:models
+bun run gen:compat   # src/compat/rules/**/*.kdl -> src/compat/rules.json
+bun run gen:models   # upstream sources + rules -> src/models.json
 ```
 
-To change an entry, fix the source: resolver overrides in `provider-models/openai-compat.ts`, provider entries in `provider-models/descriptors.ts`, generator fixups in `scripts/generate-models.ts`, or thinking policies in `model-thinking.ts`.
+Model- or provider-conditional policy (identity, effort ladders, wire quirks, modality/limit/pricing corrections, API routing, roster exclusions) lives in the KDL tree — see `src/compat/rules/README.md` for the grammar and axis vocabulary. TypeScript changes are only for transport mechanics: provider entries in `provider-models/descriptors.ts`, discovery/request plumbing in `provider-models/openai-compat.ts`, and generator wiring in `scripts/generate-models.ts`. Commit `rules.json` (and a rebaked `models.json` when values change) alongside the `.kdl` edit.
 
 ## Install
 

package/package.json

@@ -1,102 +1,98 @@
 {
-	"type": "module",
-	"name": "@linxiraos/pi-catalog",
-	"version": "1.1.7",
-	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
-	"homepage": "https://linxira-os.github.io/zeta/",
-	"author": "Can Boluk",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/Linxira-OS/linxira-zeta.git",
-		"directory": "packages/catalog"
-	},
-	"bugs": {
-		"url": "https://github.com/Linxira-OS/linxira-zeta/issues"
-	},
-	"keywords": [
-		"ai",
-		"llm",
-		"models",
-		"catalog",
-		"discovery"
-	],
-	"main": "./src/index.ts",
-	"types": "./dist/types/index.d.ts",
-	"scripts": {
-		"check": "biome check . && bun run check:types",
-		"check:types": "tsgo -p tsconfig.json --noEmit",
-		"lint": "biome lint .",
-		"test": "bun test --parallel",
-		"fix": "biome check --write --unsafe .",
-		"fmt": "biome format --write .",
-		"gen:models": "bun scripts/generate-models.ts",
-		"gen:proto": "bun scripts/generate-protocols.ts"
-	},
-	"dependencies": {
-		"@linxiraos/pi-omptype": "1.1.7",
-		"@linxiraos/pi-utils": "1.1.7"
-	},
-	"devDependencies": {
-		"@linxiraos/pi-ai": "1.1.7",
-		"@types/bun": "^1.3.14"
-	},
-	"engines": {
-		"bun": ">=1.3.14"
-	},
-	"files": [
-		"src",
-		"README.md",
-		"CHANGELOG.md",
-		"LICENSE",
-		"THIRD-PARTY-NOTICES.txt",
-		"dist/types"
-	],
-	"exports": {
-		".": {
-			"types": "./dist/types/index.d.ts",
-			"import": "./src/index.ts"
-		},
-		"./models.json": {
-			"types": "./dist/types/models.json.d.d.ts",
-			"import": "./src/models.json"
-		},
-		"./provider-models": {
-			"types": "./dist/types/provider-models/index.d.ts",
-			"import": "./src/provider-models/index.ts"
-		},
-		"./provider-models/*": {
-			"types": "./dist/types/provider-models/*.d.ts",
-			"import": "./src/provider-models/*.ts"
-		},
-		"./discovery": {
-			"types": "./dist/types/discovery/index.d.ts",
-			"import": "./src/discovery/index.ts"
-		},
-		"./discovery/*": {
-			"types": "./dist/types/discovery/*.d.ts",
-			"import": "./src/discovery/*.ts"
-		},
-		"./identity": {
-			"types": "./dist/types/identity/index.d.ts",
-			"import": "./src/identity/index.ts"
-		},
-		"./identity/*": {
-			"types": "./dist/types/identity/*.d.ts",
-			"import": "./src/identity/*.ts"
-		},
-		"./wire/*": {
-			"types": "./dist/types/wire/*.d.ts",
-			"import": "./src/wire/*.ts"
-		},
-		"./compat/*": {
-			"types": "./dist/types/compat/*.d.ts",
-			"import": "./src/compat/*.ts"
-		},
-		"./*": {
-			"types": "./dist/types/*.d.ts",
-			"import": "./src/*.ts"
-		},
-		"./*.js": "./src/*.ts"
-	}
+  "exports": {
+    "./*.js": "./src/*.ts",
+    "./*": {
+      "import": "./src/*.ts",
+      "types": "./src/*.ts"
+    },
+    "./compat/*": {
+      "import": "./src/compat/*.ts",
+      "types": "./src/compat/*.ts"
+    },
+    "./wire/*": {
+      "import": "./src/wire/*.ts",
+      "types": "./src/wire/*.ts"
+    },
+    "./identity/*": {
+      "import": "./src/identity/*.ts",
+      "types": "./src/identity/*.ts"
+    },
+    "./identity": {
+      "import": "./src/identity/index.ts",
+      "types": "./src/identity/index.ts"
+    },
+    "./discovery/*": {
+      "import": "./src/discovery/*.ts",
+      "types": "./src/discovery/*.ts"
+    },
+    "./discovery": {
+      "import": "./src/discovery/index.ts",
+      "types": "./src/discovery/index.ts"
+    },
+    "./provider-models/*": {
+      "import": "./src/provider-models/*.ts",
+      "types": "./src/provider-models/*.ts"
+    },
+    "./provider-models": {
+      "import": "./src/provider-models/index.ts",
+      "types": "./src/provider-models/index.ts"
+    },
+    "./models.json": {
+      "import": "./src/models.json",
+      "types": "./src/models.json.d.ts"
+    },
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "bun": ">=1.3.14"
+  },
+  "devDependencies": {
+    "@linxiraos/pi-ai": "1.1.9",
+    "@types/bun": "^1.3.14",
+    "@bgotink/kdl": "0.4.0"
+  },
+  "dependencies": {
+    "@linxiraos/pi-utils": "1.1.9",
+    "@linxiraos/pi-omptype": "1.1.9"
+  },
+  "scripts": {
+    "gen:proto": "bun scripts/generate-protocols.ts",
+    "gen:compat": "bun scripts/compile-compat.ts",
+    "gen:models": "bun scripts/generate-models.ts",
+    "test": "bun test --parallel",
+    "check:types": "tsgo -p tsconfig.json --noEmit",
+    "check": "tsgo -p tsconfig.json --noEmit"
+  },
+  "types": "./src/index.ts",
+  "main": "./src/index.ts",
+  "keywords": [
+    "ai",
+    "llm",
+    "models",
+    "catalog",
+    "discovery"
+  ],
+  "bugs": {
+    "url": "https://github.com/Linxira-OS/linxira-zeta/issues"
+  },
+  "repository": {
+    "directory": "packages/catalog",
+    "url": "git+https://github.com/Linxira-OS/linxira-zeta.git",
+    "type": "git"
+  },
+  "license": "MIT",
+  "author": "Can Boluk",
+  "homepage": "https://linxira-os.github.io/zeta/",
+  "description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
+  "version": "1.1.9",
+  "name": "@linxiraos/pi-catalog",
+  "type": "module"
 }

package/src/build.ts

@@ -1,26 +1,149 @@
 /**
- * The single Model constructor. Resolution order is a dependency chain, each
- * step materialized exactly once per spec:
- *
- *   1. compat   — URL/provider/id detection resolved into a complete record;
- *   2. thinking — derived from identity + resolved compat (or trusted verbatim
- *                 when the spec carries explicit metadata);
+ * The single Model constructor. Resolution runs through the compat engine
+ * (`compat/resolve`): identity classification, cascade-rule axes, host
+ * detection, and spec overrides materialize exactly once per spec.
  *
  * Request handlers read fields — they never detect, parse ids, or allocate
  * compat per request.
  */
 
-import { buildAnthropicCompat } from "./compat/anthropic";
-import { buildBedrockCompat } from "./compat/bedrock";
-import { buildDevinCompat } from "./compat/devin";
-import { buildOpenAICompat, buildOpenAIResponsesCompat, buildOpenRouterCompat } from "./compat/openai";
-import { bareModelId, parseOpenAIModel, semverGte } from "./identity/classify";
-import { isClaudeModelId } from "./identity/family";
-import { resolveModelThinking } from "./model-thinking";
+import { resolveModelPolicy } from "./compat/resolve";
+import type { ModelIdentity } from "./compat/types";
 import { resolveModelTokenizer } from "./model-tokenizer";
-import type { Api, CompatOf, Model, ModelSpec } from "./types";
+import type { Api, Model, ModelSpec } from "./types";
 import { cleanModelName } from "./utils";
 
+function numberField(source: object, key: string): number | undefined {
+	const value: unknown = Reflect.get(source, key);
+	return typeof value === "number" ? value : undefined;
+}
+
+/** Narrow an unknown compiled-axis payload to an object payload. */
+function objectPayload(value: unknown): object | undefined {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+
+/** Narrow a compiled `input-modalities` axis value to the model input union. */
+function isInputModalities(value: unknown): value is ("text" | "image")[] {
+	return Array.isArray(value) && value.every(entry => entry === "text" || entry === "image");
+}
+
+/**
+ * Applies resolved catalog-data axes onto the model: reviewed metadata
+ * corrections (`cost-patch`, `limits-patch`, `long-context-cost`,
+ * `context-window-floor`) overwrite upstream values; selection metadata
+ * (`priority`, `apply-patch-tool-type`, `service-tier-cost`,
+ * `requires-cursor-tool-schema-projection`) is rule-owned;
+ * `context-promotion-target` fills only when the spec left it unset.
+ */
+function applyCatalogAssignments<TApi extends Api>(model: Model<TApi>, catalog: Record<string, unknown>): void {
+	const serviceTierCost = objectPayload(catalog.serviceTierCost);
+	if (serviceTierCost !== undefined) {
+		const flex = numberField(serviceTierCost, "flex");
+		const priorityTier = numberField(serviceTierCost, "priority");
+		model.serviceTierCost = {
+			...(flex !== undefined && { flex }),
+			...(priorityTier !== undefined && { priority: priorityTier }),
+		};
+	}
+	const priority = catalog.priority;
+	if (typeof priority === "number") model.priority = priority;
+	const applyPatchToolType = catalog.applyPatchToolType;
+	if (applyPatchToolType === "freeform" || applyPatchToolType === "function") {
+		model.applyPatchToolType = applyPatchToolType;
+	}
+	const requiresCursorToolSchemaProjection = catalog.requiresCursorToolSchemaProjection;
+	if (requiresCursorToolSchemaProjection === true) {
+		model.requiresCursorToolSchemaProjection = true;
+	} else {
+		delete model.requiresCursorToolSchemaProjection;
+	}
+	const contextPromotionTarget = catalog.contextPromotionTarget;
+	if (typeof contextPromotionTarget === "string" && model.contextPromotionTarget === undefined) {
+		model.contextPromotionTarget = contextPromotionTarget;
+	}
+}
+
+/**
+ * Applies reviewed catalog-data value corrections (`cost-patch`,
+ * `limits-patch`, `long-context-cost`, `context-window-floor`,
+ * `input-modalities`) onto an upstream-sourced spec. Applied by
+ * `buildModel` to every upstream-sourced spec; user-authored overrides are
+ * recomposed after building by the override applicators, so explicit user
+ * limits and pricing still win.
+ */
+export function applyCatalogCorrections(
+	model: Pick<ModelSpec<Api>, "cost" | "contextWindow" | "maxTokens" | "input">,
+	catalog: Record<string, unknown>,
+): void {
+	const longContext = objectPayload(catalog.longContext);
+	if (longContext !== undefined) {
+		const inputThreshold = numberField(longContext, "inputThreshold");
+		const inclusive = Reflect.get(longContext, "inputThresholdInclusive") === true;
+		const multiplier = numberField(longContext, "multiplier");
+		const input = numberField(longContext, "input");
+		const output = numberField(longContext, "output");
+		const cacheRead = numberField(longContext, "cacheRead");
+		const cacheWrite = numberField(longContext, "cacheWrite");
+		const base = model.cost;
+		const hasTokenPrice = base.input !== 0 || base.output !== 0 || base.cacheRead !== 0 || base.cacheWrite !== 0;
+		if (inputThreshold !== undefined && multiplier !== undefined && hasTokenPrice) {
+			// Multiplier form: tier rates derive from the row's live list price.
+			model.cost = {
+				...base,
+				longContext: {
+					inputThreshold,
+					...(inclusive && { inputThresholdInclusive: true }),
+					input: base.input * multiplier,
+					output: base.output * multiplier,
+					cacheRead: base.cacheRead * multiplier,
+					cacheWrite: base.cacheWrite * multiplier,
+				},
+			};
+		} else if (
+			inputThreshold !== undefined &&
+			input !== undefined &&
+			output !== undefined &&
+			cacheRead !== undefined &&
+			cacheWrite !== undefined
+		) {
+			model.cost = { ...model.cost, longContext: { inputThreshold, input, output, cacheRead, cacheWrite } };
+		}
+	}
+	const patch = objectPayload(catalog.costPatch);
+	if (patch !== undefined) {
+		model.cost = { ...model.cost };
+		const input = numberField(patch, "input");
+		if (input !== undefined) model.cost.input = input;
+		const output = numberField(patch, "output");
+		if (output !== undefined) model.cost.output = output;
+		const cacheRead = numberField(patch, "cacheRead");
+		if (cacheRead !== undefined) model.cost.cacheRead = cacheRead;
+		const cacheWrite = numberField(patch, "cacheWrite");
+		if (cacheWrite !== undefined) model.cost.cacheWrite = cacheWrite;
+	}
+	const limitsPatch = objectPayload(catalog.limitsPatch);
+	if (limitsPatch !== undefined) {
+		const contextWindow = numberField(limitsPatch, "contextWindow");
+		if (contextWindow !== undefined) model.contextWindow = contextWindow;
+		const maxTokens = numberField(limitsPatch, "maxTokens");
+		if (maxTokens !== undefined) model.maxTokens = maxTokens;
+	}
+	const contextWindowFloor = catalog.contextWindowFloor;
+	if (typeof contextWindowFloor === "number") {
+		model.contextWindow = Math.max(model.contextWindow ?? 0, contextWindowFloor);
+	}
+	const inputModalities = catalog.inputModalities;
+	if (isInputModalities(inputModalities)) {
+		model.input = inputModalities;
+	}
+}
+
+/**
+ * Direct first-party OpenAI Responses endpoints (api.openai.com, Azure OpenAI
+ * deployments). Gates GA computer-use detection; identity supplies the model
+ * generation.
+ */
 function isDirectOpenAIResponsesEndpoint(spec: ModelSpec<Api>): boolean {
 	if (spec.api === "openai-responses") {
 		if (spec.provider !== "openai") return false;
@@ -48,16 +171,27 @@ function isDirectOpenAIResponsesEndpoint(spec: ModelSpec<Api>): boolean {
 }
 
 function explicitComputerUseConfig(spec: ModelSpec<Api>): boolean | undefined {
-	return "supportsComputerUseConfig" in spec
-		? (spec as Model<Api>).supportsComputerUseConfig
-		: spec.supportsComputerUse;
+	if (!("supportsComputerUseConfig" in spec)) return spec.supportsComputerUse;
+	const value: unknown = Reflect.get(spec, "supportsComputerUseConfig");
+	return typeof value === "boolean" ? value : undefined;
+}
+
+function revisionAtLeast(identity: ModelIdentity, major: number, minor: number): boolean {
+	if (identity.revision === undefined) return false;
+	const [revMajor = 0, revMinor = 0] = identity.revision.split(".").map(Number);
+	return revMajor > major || (revMajor === major && revMinor >= minor);
 }
 
-function supportsOpenAIGAComputerUse(spec: ModelSpec<Api>, explicitSupport: boolean | undefined): boolean {
+function supportsOpenAIGAComputerUse(
+	spec: ModelSpec<Api>,
+	identity: ModelIdentity,
+	explicitSupport: boolean | undefined,
+): boolean {
 	if (explicitSupport !== undefined) return explicitSupport;
 	if (!isDirectOpenAIResponsesEndpoint(spec)) return false;
-	const parsed = parseOpenAIModel(bareModelId(spec.requestModelId ?? spec.id));
-	return parsed !== null && semverGte(parsed.version, "5.4");
+	const wireIdentity =
+		spec.requestModelId === undefined ? identity : resolveModelPolicy({ ...spec, id: spec.requestModelId }).identity;
+	return wireIdentity.class === "openai" && revisionAtLeast(wireIdentity, 5, 4);
 }
 
 /**
@@ -66,38 +200,21 @@ function supportsOpenAIGAComputerUse(spec: ModelSpec<Api>, explicitSupport: bool
  * 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 policy = resolveModelPolicy(spec);
 	const supportsComputerUseConfig = explicitComputerUseConfig(spec);
-	return {
+	const model: Model<TApi> = {
 		...spec,
 		name: cleanModelName(spec.name),
-		requiresGlyphTokenization: isClaudeModelId(spec.id),
+		identity: policy.identity,
+		requiresGlyphTokenization: policy.identity.class === "anthropic",
 		tokenizer: spec.tokenizer ?? resolveModelTokenizer(spec.requestModelId ?? spec.id),
-		thinking: resolveModelThinking(spec, compat),
-		supportsComputerUse: supportsOpenAIGAComputerUse(spec, supportsComputerUseConfig),
+		thinking: policy.thinking,
+		supportsComputerUse: supportsOpenAIGAComputerUse(spec, policy.identity, supportsComputerUseConfig),
 		supportsComputerUseConfig,
-		compat,
+		compat: policy.compat,
 		compatConfig: spec.compat,
-	} as Model<TApi>;
-}
-
-export function buildCompat(spec: ModelSpec<Api>): CompatOf<Api> {
-	switch (spec.api) {
-		case "openrouter":
-			return buildOpenRouterCompat(spec as ModelSpec<"openrouter">);
-		case "openai-completions":
-			return buildOpenAICompat(spec as ModelSpec<"openai-completions">);
-		case "openai-responses":
-		case "azure-openai-responses":
-		case "openai-codex-responses":
-			return buildOpenAIResponsesCompat(spec as ModelSpec<"openai-responses">);
-		case "anthropic-messages":
-			return buildAnthropicCompat(spec as ModelSpec<"anthropic-messages">);
-		case "bedrock-converse-stream":
-			return buildBedrockCompat(spec as ModelSpec<"bedrock-converse-stream">);
-		case "devin-agent":
-			return buildDevinCompat(spec as ModelSpec<"devin-agent">);
-		default:
-			return undefined;
-	}
+	};
+	applyCatalogAssignments(model, policy.catalog);
+	applyCatalogCorrections(model, policy.catalog);
+	return model;
 }

package/src/cline-pass-model-id.ts

@@ -0,0 +1,11 @@
+const CLINEPASS_WIRE_PREFIX = "cline-pass/";
+
+/** Convert a public ClinePass catalog id to the gateway's wire id. */
+export function toClinePassWireModelId(modelId: string): string {
+	return modelId.startsWith(CLINEPASS_WIRE_PREFIX) ? modelId : `${CLINEPASS_WIRE_PREFIX}${modelId}`;
+}
+
+/** Convert a gateway ClinePass wire id to the public catalog id. */
+export function toClinePassPublicModelId(modelId: string): string {
+	return modelId.startsWith(CLINEPASS_WIRE_PREFIX) ? modelId.slice(CLINEPASS_WIRE_PREFIX.length) : modelId;
+}