comisai 1.0.28 → 1.0.30

package/node_modules/@comis/agent/dist/executor/pi-executor.js

@@ -775,6 +775,12 @@ export function createPiExecutor(config, deps) {
                         session.abortCompaction();
                         suppressError(session.abort(), "session abort on compaction cancel");
                     },
+                    // 260501-dkl: cancel the SDK's internal auto-retry loop when the
+                    // bridge classifies the auto_retry_start error as `rate_limited`.
+                    // Rate-limit windows (per-minute) outlast the SDK's retry budget
+                    // (~30s), so retrying within the window cannot succeed.
+                    // `abortRetry()` is sync void -- no error suppression needed.
+                    onAbortRetry: () => session.abortRetry(),
                     getContextUsage: () => {
                         // Defensive try-catch: upstream estimateTokens() in pi-coding-agent
                         // crashes with "message.content is not iterable" when an assistant

package/node_modules/@comis/agent/dist/executor/stream-wrappers/config-resolver.js

@@ -7,11 +7,10 @@
  *
  * @module
  */
+import { isAnthropicFamily } from "../../provider/capabilities.js";
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
-/** Anthropic-family providers that support cache_control breakpoints. */
-const ANTHROPIC_FAMILY = new Set(["anthropic", "anthropic-vertex", "amazon-bedrock"]);
 /** SYS-BOUNDARY: Deterministic marker between static and dynamic system prompt blocks.
  *  Enables cache break diagnostics to identify whether changes are in the
  *  stable or dynamic portion. Appended to staticPrefix block. */
@@ -64,7 +63,7 @@ export function createConfigResolver(config, logger) {
             }
             // Inject cacheRetention for Anthropic-family providers when truthy
             // Resolve dynamic getter for per-execution cache retention override
-            if (ANTHROPIC_FAMILY.has(model.provider)) {
+            if (isAnthropicFamily(model.provider)) {
                 const retention = typeof config.cacheRetention === "function"
                     ? config.cacheRetention()
                     : config.cacheRetention;

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body-injector.js

@@ -15,6 +15,7 @@
 import { SYSTEM_PROMPT_DYNAMIC_BOUNDARY, resolveBreakpointStrategy } from "./config-resolver.js";
 import { createAccumulativeLatch } from "../session-latch.js";
 import { MIN_CACHEABLE_TOKENS, DEFAULT_MIN_CACHEABLE_TOKENS, CHARS_PER_TOKEN_RATIO, CHARS_PER_TOKEN_RATIO_STRUCTURED, CACHE_LOOKBACK_WINDOW } from "../../context-engine/index.js";
+import { isAnthropicFamily } from "../../provider/capabilities.js";
 import { estimateContextChars } from "../../safety/token-estimator.js";
 import { computeHash, djb2 } from "../cache-break-detection.js";
 import { supportsToolSearch } from "../tool-deferral.js";
@@ -83,8 +84,6 @@ export function resolveCacheRetention(modelId, agentRetention, overrides) {
 // ---------------------------------------------------------------------------
 /** Anthropic beta header for 1M context window. */
 const CONTEXT_1M_BETA = "context-1m-2025-08-07";
-/** Anthropic-family providers that support cache_control breakpoints. */
-const ANTHROPIC_FAMILY = new Set(["anthropic", "anthropic-vertex", "amazon-bedrock"]);
 /** Check if a model uses the OpenAI Responses API. */
 function isResponsesApiProvider(model) {
     return model.api === "openai-responses" || model.api === "azure-openai-responses";
@@ -861,7 +860,7 @@ export function estimateBlockTokens(block) {
 export function createRequestBodyInjector(config, logger) {
     return function requestBodyInjector(next) {
         return (model, context, options) => {
-            const needsCacheBreakpoints = ANTHROPIC_FAMILY.has(model.provider);
+            const needsCacheBreakpoints = isAnthropicFamily(model.provider);
             const needsResponsesApiInjection = isResponsesApiProvider(model);
             if (!needsCacheBreakpoints && !needsResponsesApiInjection) {
                 return next(model, context, options);

package/node_modules/@comis/agent/dist/executor/ttl-guard.js

@@ -11,11 +11,10 @@
  *
  * @module
  */
+import { isAnthropicFamily } from "../provider/capabilities.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-/** Anthropic-family providers that support cache_control breakpoints. */
-const ANTHROPIC_FAMILY = new Set(["anthropic", "anthropic-vertex", "amazon-bedrock"]);
 /** TTL boundaries in milliseconds, keyed by CacheRetention value.
  *  "short" = 5 minutes, "long" = 60 minutes. */
 const TTL_BOUNDARIES = {
@@ -42,7 +41,7 @@ export function createTtlGuard(config) {
     return function ttlGuard(next) {
         return (model, context, options) => {
             // Non-Anthropic providers skip TTL check entirely
-            if (!ANTHROPIC_FAMILY.has(model.provider)) {
+            if (!isAnthropicFamily(model.provider)) {
                 return next(model, context, options);
             }
             // Cold-start: no prior timestamp for this session

package/node_modules/@comis/agent/dist/index.d.ts

@@ -172,7 +172,8 @@ export { computeTokenBudget } from "./context-engine/index.js";
 export type { ContextEngine, ContextEngineDeps, ContextLayer, TokenBudget, ContextEngineMetrics, AssembledContext, LayerCircuitBreaker, } from "./context-engine/index.js";
 export { reconcileJsonlToDag, installDagIngestionHook, createDagContextEngine, runLeafPass, runCondensedPass, resolveFreshTailBoundary, shouldCompact, markAncestorsDirty, recomputeDescendantCounts, runDagCompaction, checkIntegrity, CHARS_PER_TOKEN_RATIO, } from "./context-engine/index.js";
 export type { ReconciliationResult, DagContextEngineDeps, CompactionDeps, DagCompactionConfig, DagCompactionDeps, IntegrityCheckDeps, IntegrityReport, IntegrityIssue, } from "./context-engine/index.js";
-export { DEFAULTS as PROVIDER_CAPABILITY_DEFAULTS, resolveProviderCapabilities, normalizeProviderId, isAnthropicFamily, isOpenAiFamily, shouldDropThinkingBlocks, resolveToolCallIdMode, } from "./provider/capabilities.js";
+export { DEFAULTS as PROVIDER_CAPABILITY_DEFAULTS, resolveProviderCapabilities, normalizeProviderId, isAnthropicFamily, isOpenAiFamily, shouldDropThinkingBlocks, resolveToolCallIdMode, validateProviderOverrides, } from "./provider/capabilities.js";
+export type { ProviderOverridesValidatorLogger } from "./provider/capabilities.js";
 export { normalizeModelCompat } from "./provider/model-compat.js";
 export { normalizeModelId } from "./provider/model-id-normalize.js";
 export type { ModelIdNormalizationResult } from "./provider/model-id-normalize.js";
@@ -185,7 +186,8 @@ export { createThinkingTagFilter } from "./response-filter/thinking-tag-filter.j
 export type { ThinkingTagFilter, ThinkingTagFilterOptions } from "./response-filter/thinking-tag-filter.js";
 export { resolveOperationModel, resolveProviderFamily } from "./model/operation-model-resolver.js";
 export type { OperationModelResolution } from "./model/operation-model-resolver.js";
-export { OPERATION_MODEL_DEFAULTS, OPERATION_TIER_MAP, OPERATION_TIMEOUT_DEFAULTS, OPERATION_CACHE_DEFAULTS } from "./model/operation-model-defaults.js";
+export { resolveOperationDefaults, OPERATION_TIER_MAP, OPERATION_TIMEOUT_DEFAULTS, OPERATION_CACHE_DEFAULTS } from "./model/operation-model-defaults.js";
+export { resolveCompactionModel } from "./model/compaction-model-resolver.js";
 export { createSessionLatch } from "./executor/session-latch.js";
 export type { SessionLatch } from "./executor/session-latch.js";
 export * from "./background/index.js";

package/node_modules/@comis/agent/dist/index.js

@@ -173,7 +173,7 @@ export { computeTokenBudget } from "./context-engine/index.js";
 // DAG reconciliation, compaction, integrity, and assembler (Phases 411-414)
 export { reconcileJsonlToDag, installDagIngestionHook, createDagContextEngine, runLeafPass, runCondensedPass, resolveFreshTailBoundary, shouldCompact, markAncestorsDirty, recomputeDescendantCounts, runDagCompaction, checkIntegrity, CHARS_PER_TOKEN_RATIO, } from "./context-engine/index.js";
 // Provider capabilities
-export { DEFAULTS as PROVIDER_CAPABILITY_DEFAULTS, resolveProviderCapabilities, normalizeProviderId, isAnthropicFamily, isOpenAiFamily, shouldDropThinkingBlocks, resolveToolCallIdMode, } from "./provider/capabilities.js";
+export { DEFAULTS as PROVIDER_CAPABILITY_DEFAULTS, resolveProviderCapabilities, normalizeProviderId, isAnthropicFamily, isOpenAiFamily, shouldDropThinkingBlocks, resolveToolCallIdMode, validateProviderOverrides, } from "./provider/capabilities.js";
 // Model compatibility auto-detection (xAI compat flags)
 export { normalizeModelCompat } from "./provider/model-compat.js";
 // Model ID normalization ()
@@ -187,7 +187,8 @@ export { findCodeRegions, isInsideCode } from "./response-filter/code-regions.js
 export { createThinkingTagFilter } from "./response-filter/thinking-tag-filter.js";
 // Operation model resolver
 export { resolveOperationModel, resolveProviderFamily } from "./model/operation-model-resolver.js";
-export { OPERATION_MODEL_DEFAULTS, OPERATION_TIER_MAP, OPERATION_TIMEOUT_DEFAULTS, OPERATION_CACHE_DEFAULTS } from "./model/operation-model-defaults.js";
+export { resolveOperationDefaults, OPERATION_TIER_MAP, OPERATION_TIMEOUT_DEFAULTS, OPERATION_CACHE_DEFAULTS } from "./model/operation-model-defaults.js";
+export { resolveCompactionModel } from "./model/compaction-model-resolver.js";
 // SessionLatch utility
 export { createSessionLatch } from "./executor/session-latch.js";
 // Background task infrastructure

package/node_modules/@comis/agent/dist/model/compaction-model-resolver.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Compaction-model resolver: runtime-resolves the `compactionModel`
+ * configuration field from the pi-ai catalog when the schema default
+ * is the empty string.
+ *
+ * Why this exists:
+ *   The `compactionModel` field used to default to a hardcoded Anthropic
+ *   literal ("anthropic:claude-haiku-4-5-20250929"). When operators
+ *   switched their primary provider to OpenRouter, Google, etc., compaction
+ *   still routed to Claude Haiku, defeating the cost-tiering intent and
+ *   causing cross-provider auth confusion (no Anthropic API key configured).
+ *
+ *   Phase 2C-2 changes the schema default to "" and resolves at runtime:
+ *   pick the fast-tier model from `resolveOperationDefaults(primaryProvider)`,
+ *   with `getModels(primaryProvider)[0]` as the catalog-fallback.
+ *
+ *   Note: explicit `compactionModel` values from existing YAML configs win
+ *   unchanged (length > 0 short-circuits the resolver). No backward-compat
+ *   shim per `feedback_no_backward_compat.md`.
+ *
+ * @module
+ */
+/**
+ * Resolve the effective compaction model id, in "provider:modelId" format.
+ *
+ * Resolution rules:
+ *   1. If `configValue` is non-empty, return it unchanged (operator explicit).
+ *   2. Otherwise, derive the fast-tier model from `resolveOperationDefaults`
+ *      for the agent's primary provider; fall back to first catalog model
+ *      id if cost-tiering returned nothing (custom YAML provider).
+ *   3. If neither tiering nor catalog produces a candidate (unknown provider
+ *      with empty catalog), return "" so the consumer can fall through to
+ *      session model — graceful degradation.
+ *
+ * Pure function — no side effects, no async. Safe to call per-execute.
+ *
+ * @param configValue - Raw `contextEngine.compactionModel` from agent config
+ * @param primaryProvider - Agent's primary provider (e.g. "anthropic", "openrouter")
+ * @returns Resolved model in "provider:modelId" format, or "" for graceful fallback
+ */
+export declare function resolveCompactionModel(configValue: string, primaryProvider: string): string;

package/node_modules/@comis/agent/dist/model/compaction-model-resolver.js

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Compaction-model resolver: runtime-resolves the `compactionModel`
+ * configuration field from the pi-ai catalog when the schema default
+ * is the empty string.
+ *
+ * Why this exists:
+ *   The `compactionModel` field used to default to a hardcoded Anthropic
+ *   literal ("anthropic:claude-haiku-4-5-20250929"). When operators
+ *   switched their primary provider to OpenRouter, Google, etc., compaction
+ *   still routed to Claude Haiku, defeating the cost-tiering intent and
+ *   causing cross-provider auth confusion (no Anthropic API key configured).
+ *
+ *   Phase 2C-2 changes the schema default to "" and resolves at runtime:
+ *   pick the fast-tier model from `resolveOperationDefaults(primaryProvider)`,
+ *   with `getModels(primaryProvider)[0]` as the catalog-fallback.
+ *
+ *   Note: explicit `compactionModel` values from existing YAML configs win
+ *   unchanged (length > 0 short-circuits the resolver). No backward-compat
+ *   shim per `feedback_no_backward_compat.md`.
+ *
+ * @module
+ */
+import { getModels } from "@mariozechner/pi-ai";
+import { resolveOperationDefaults } from "./operation-model-defaults.js";
+/**
+ * Resolve the effective compaction model id, in "provider:modelId" format.
+ *
+ * Resolution rules:
+ *   1. If `configValue` is non-empty, return it unchanged (operator explicit).
+ *   2. Otherwise, derive the fast-tier model from `resolveOperationDefaults`
+ *      for the agent's primary provider; fall back to first catalog model
+ *      id if cost-tiering returned nothing (custom YAML provider).
+ *   3. If neither tiering nor catalog produces a candidate (unknown provider
+ *      with empty catalog), return "" so the consumer can fall through to
+ *      session model — graceful degradation.
+ *
+ * Pure function — no side effects, no async. Safe to call per-execute.
+ *
+ * @param configValue - Raw `contextEngine.compactionModel` from agent config
+ * @param primaryProvider - Agent's primary provider (e.g. "anthropic", "openrouter")
+ * @returns Resolved model in "provider:modelId" format, or "" for graceful fallback
+ */
+export function resolveCompactionModel(configValue, primaryProvider) {
+    if (configValue.length > 0)
+        return configValue;
+    const tier = resolveOperationDefaults(primaryProvider);
+    const firstId = getModels(primaryProvider)[0]?.id;
+    const modelId = tier.fast ?? firstId;
+    return modelId ? `${primaryProvider}:${modelId}` : "";
+}

package/node_modules/@comis/agent/dist/model/model-registry-adapter.js

@@ -21,13 +21,6 @@ import { getModels, getProviders } from "@mariozechner/pi-ai";
 export function createModelRegistryAdapter(authStorage) {
     return ModelRegistry.inMemory(authStorage);
 }
-/**
- * YAML provider type → pi-ai API identifier. Mirrors the
- * `OPENAI_COMPATIBLE_TYPES` set in `model-scanner.ts`. Unknown types
- * default to `openai-completions` so arbitrary OpenAI-compatible
- * proxies (NVIDIA NIM, Together, ollama, lm-studio, etc.) work without
- * code changes.
- */
 /**
  * Provider types that can register without an API key.
  *
@@ -40,19 +33,45 @@ export function createModelRegistryAdapter(authStorage) {
  * Ollama ignores Authorization unless `OLLAMA_API_KEY` is set server-side.
  */
 const KEYLESS_PROVIDER_TYPES = new Set(["ollama"]);
-const PROVIDER_TYPE_TO_API = {
-    openai: "openai-completions",
-    groq: "openai-completions",
-    mistral: "openai-completions",
+const _builtInProviders = new Set(getProviders());
+/**
+ * Infer pi-ai wire API from the live catalog.
+ *
+ * For any provider name that pi-ai exposes via `getProviders()`, read the
+ * `api` field from the first registered model. This is the single source of
+ * truth: when pi-ai adds a provider with a new wire format (e.g. a future
+ * `xyz-streaming` API), this helper picks it up automatically without any
+ * comis code change.
+ *
+ * Returns `undefined` when the type is not in the native catalog -- callers
+ * should chain to `FALLBACK_API_FOR_CUSTOM_TYPES` and finally to the
+ * `openai-completions` default for arbitrary OpenAI-compatible proxies.
+ */
+function inferApiFromCatalog(type) {
+    if (!_builtInProviders.has(type))
+        return undefined;
+    const models = getModels(type);
+    return models[0]?.api;
+}
+/**
+ * Tiny fallback table for custom provider types pi-ai does NOT ship in its
+ * native catalog. These are local inference servers and legacy aliases that
+ * speak OpenAI-compatible wire format but have no provider entry in
+ * `models.generated.ts`. Everything else falls through to
+ * `"openai-completions"` -- the safe default for arbitrary OpenAI-compatible
+ * proxies (NVIDIA NIM, Fireworks, Perplexity, vLLM, llama.cpp, etc.).
+ */
+const FALLBACK_API_FOR_CUSTOM_TYPES = {
+    ollama: "openai-completions",
+    "lm-studio": "openai-completions",
     together: "openai-completions",
-    deepseek: "openai-completions",
-    cerebras: "openai-completions",
-    xai: "openai-completions",
-    openrouter: "openai-completions",
-    anthropic: "anthropic-messages",
-    google: "google-generative-ai",
 };
-const _builtInProviders = new Set(getProviders());
+/**
+ * API resolution model for `entry.type`:
+ *   1. catalog-first   -- `inferApiFromCatalog(type)` reads the live pi-ai catalog
+ *   2. fallback-second -- `FALLBACK_API_FOR_CUSTOM_TYPES[type]` for legacy custom types
+ *   3. default-final   -- `"openai-completions"` for arbitrary OpenAI-compatible proxies
+ */
 function getBuiltInBaseUrl(type) {
     if (!_builtInProviders.has(type))
         return undefined;
@@ -94,15 +113,81 @@ export function registerCustomProviders(registry, entries, secretManager, logger
         if (isBuiltInType && providerName !== entry.type) {
             providerAliases.set(providerName, entry.type);
         }
-        const customModels = isBuiltInType
-            ? entry.models.filter((m) => !builtInIds.has(m.id))
-            : [...entry.models];
-        if (isBuiltInType && customModels.length < entry.models.length) {
-            const skipped = entry.models.length - customModels.length;
-            logger.debug({ providerName, type: entry.type, skipped, remaining: customModels.length }, "Skipped built-in models already in pi SDK catalog");
+        // Layer 1B (260430-vwt): catalog-aware model enrichment.
+        //
+        // Before computing customModels, decide whether to inherit the full
+        // pi-ai catalog or to enrich the user's sparse list with catalog
+        // metadata.
+        //
+        // Inherit branch (empty list + built-in type + no baseUrl override):
+        //   user wants the full native catalog under this provider name --
+        //   bypass the dedup filter below; the inherited list is intentional.
+        // Enrich branch (sparse list + built-in type):
+        //   for each user model, fill missing fields from the catalog when an
+        //   ID match is found. The dedup filter still applies after enrichment
+        //   so that user-supplied IDs already in pi-ai's built-in catalog are
+        //   served via the built-in path (not redundantly registered).
+        const hasBaseUrlOverride = !!entry.baseUrl;
+        const shouldInheritCatalog = entry.models.length === 0 && isBuiltInType && !hasBaseUrlOverride;
+        let workingModels;
+        if (shouldInheritCatalog) {
+            // Inherit the full native catalog -- no dedup, no fallback values.
+            const catalogModels = getModels(entry.type);
+            workingModels = catalogModels.map((m) => ({
+                id: m.id,
+                name: m.name,
+                contextWindow: m.contextWindow,
+                maxTokens: m.maxTokens,
+                reasoning: m.reasoning,
+                input: m.input,
+                cost: m.cost,
+            }));
+            logger.debug({ providerName, type: entry.type, inherited: workingModels.length }, "Inherited full pi-ai native catalog (empty user list)");
         }
+        else if (isBuiltInType) {
+            // Sparse list: enrich each user model with catalog data, then dedup.
+            const catalog = getModels(entry.type);
+            const enriched = entry.models.map((m) => {
+                const cat = catalog.find((c) => c.id === m.id);
+                if (!cat) {
+                    return {
+                        id: m.id,
+                        name: m.name,
+                        contextWindow: m.contextWindow,
+                        maxTokens: m.maxTokens,
+                        reasoning: m.reasoning,
+                        input: m.input,
+                        cost: m.cost,
+                    };
+                }
+                return {
+                    id: m.id,
+                    name: m.name ?? cat.name,
+                    contextWindow: m.contextWindow ?? cat.contextWindow,
+                    maxTokens: m.maxTokens ?? cat.maxTokens,
+                    reasoning: m.reasoning ?? cat.reasoning,
+                    input: m.input ?? cat.input,
+                    cost: {
+                        input: m.cost?.input ?? cat.cost?.input,
+                        output: m.cost?.output ?? cat.cost?.output,
+                        cacheRead: m.cost?.cacheRead ?? cat.cost?.cacheRead,
+                        cacheWrite: m.cost?.cacheWrite ?? cat.cost?.cacheWrite,
+                    },
+                };
+            });
+            // Dedup: filter out built-in IDs (already served via pi-ai's built-in path).
+            workingModels = enriched.filter((m) => !builtInIds.has(m.id));
+            if (workingModels.length < entry.models.length) {
+                const skipped = entry.models.length - workingModels.length;
+                logger.debug({ providerName, type: entry.type, skipped, remaining: workingModels.length }, "Skipped built-in models already in pi SDK catalog");
+            }
+        }
+        else {
+            // Custom (non-catalog) type: user-supplied list as-is.
+            workingModels = [...entry.models];
+        }
+        const customModels = workingModels;
         const hasModels = customModels.length > 0;
-        const hasBaseUrlOverride = !!entry.baseUrl;
         if (!hasModels && !hasBaseUrlOverride) {
             logger.debug({ providerName }, "Custom provider skipped (no custom models and no baseUrl override)");
             continue;
@@ -118,7 +203,9 @@ export function registerCustomProviders(registry, entries, secretManager, logger
             }, "Custom provider has models but no API key -- skipping registration");
             continue;
         }
-        const api = PROVIDER_TYPE_TO_API[entry.type] ?? "openai-completions";
+        const api = inferApiFromCatalog(entry.type)
+            ?? FALLBACK_API_FOR_CUSTOM_TYPES[entry.type]
+            ?? "openai-completions";
         const headersResolved = Object.keys(entry.headers).length > 0 ? entry.headers : undefined;
         const resolvedApiKey = apiKey ?? (isKeylessType ? "ollama-no-auth" : undefined);
         if (resolvedApiKey === "ollama-no-auth") {

package/node_modules/@comis/agent/dist/model/model-scanner.d.ts

@@ -50,6 +50,33 @@ export interface ModelScanner {
     /** Scan all configured providers in parallel. */
     scanAll(providers: Record<string, ProviderScanAllEntry>, resolveKey: (keyName: string) => string | undefined): Promise<ScanResult[]>;
 }
+/**
+ * Read the baseUrl for a provider type from the live pi-ai catalog.
+ * Returns undefined when the type is not in the native catalog.
+ *
+ * Exported for testing -- in production, callers should use `buildEndpoint`
+ * which chains catalog-first → user-supplied baseUrl → hardcoded fallback.
+ */
+export declare function getCatalogBaseUrl(type: string): string | undefined;
+/**
+ * Whether a provider type should be scanned with the OpenAI-compatible
+ * /v1/models endpoint shape.
+ *
+ * Anthropic and Google have their own dedicated scan paths. Every other
+ * type -- whether it's a native pi-ai provider with an `openai-completions`
+ * primary api (groq, openrouter, cerebras, xai, ...), a native provider
+ * whose primary api is something like `openai-responses` or
+ * `mistral-conversations` (these still typically expose /v1/models for
+ * compat), or a custom non-catalog type (NVIDIA NIM, Together, Fireworks,
+ * Ollama, vLLM, ...) -- is scanned via the OpenAI-compatible shape.
+ *
+ * This is intentionally permissive: the scanner's job is API-key
+ * validation, and most providers expose /v1/models regardless of their
+ * primary wire format.
+ *
+ * Exported for testing.
+ */
+export declare function isOpenAICompatibleType(type: string): boolean;
 /**
  * Create a model scanner with injectable fetch and timeout.
  *

package/node_modules/@comis/agent/dist/model/model-scanner.js

@@ -12,36 +12,75 @@
  *
  * @module
  */
+import { getModels, getProviders } from "@mariozechner/pi-ai";
 // ---------------------------------------------------------------------------
-// Provider-specific endpoint builders
+// Catalog-driven endpoint resolution (Layer 1E -- 260430-vwt)
 // ---------------------------------------------------------------------------
-/** Default base URLs per provider type. */
-const DEFAULT_BASE_URLS = {
-    openai: "https://api.openai.com",
-    anthropic: "https://api.anthropic.com",
-    google: "https://generativelanguage.googleapis.com",
-};
-/** OpenAI-compatible provider types. */
-const OPENAI_COMPATIBLE_TYPES = new Set([
-    "openai",
-    "groq",
-    "mistral",
-    "together",
-    "deepseek",
-    "cerebras",
-    "xai",
-    "openrouter",
-]);
+/**
+ * Native pi-ai providers from the live catalog. Used to source baseUrls
+ * for scanner endpoints when the user has not supplied an explicit
+ * baseUrl override.
+ */
+const _nativeProviders = new Set(getProviders());
+/**
+ * Hardcoded fallback base URLs for the three "first-party" provider
+ * families. These remain only as last-resort defaults when pi-ai's catalog
+ * returns nothing for a given type (e.g., a custom proxy named "openai"
+ * with type:"openai" but no baseUrl). The catalog is the source of truth;
+ * these constants are explicit, discoverable backstops.
+ */
+const OPENAI_FALLBACK_BASE_URL = "https://api.openai.com";
+const ANTHROPIC_FALLBACK_BASE_URL = "https://api.anthropic.com";
+const GOOGLE_FALLBACK_BASE_URL = "https://generativelanguage.googleapis.com";
+/**
+ * Read the baseUrl for a provider type from the live pi-ai catalog.
+ * Returns undefined when the type is not in the native catalog.
+ *
+ * Exported for testing -- in production, callers should use `buildEndpoint`
+ * which chains catalog-first → user-supplied baseUrl → hardcoded fallback.
+ */
+export function getCatalogBaseUrl(type) {
+    if (!_nativeProviders.has(type))
+        return undefined;
+    return getModels(type)[0]?.baseUrl;
+}
+/**
+ * Whether a provider type should be scanned with the OpenAI-compatible
+ * /v1/models endpoint shape.
+ *
+ * Anthropic and Google have their own dedicated scan paths. Every other
+ * type -- whether it's a native pi-ai provider with an `openai-completions`
+ * primary api (groq, openrouter, cerebras, xai, ...), a native provider
+ * whose primary api is something like `openai-responses` or
+ * `mistral-conversations` (these still typically expose /v1/models for
+ * compat), or a custom non-catalog type (NVIDIA NIM, Together, Fireworks,
+ * Ollama, vLLM, ...) -- is scanned via the OpenAI-compatible shape.
+ *
+ * This is intentionally permissive: the scanner's job is API-key
+ * validation, and most providers expose /v1/models regardless of their
+ * primary wire format.
+ *
+ * Exported for testing.
+ */
+export function isOpenAICompatibleType(type) {
+    if (type === "anthropic" || type === "google")
+        return false;
+    return true;
+}
 function buildEndpoint(providerType, baseUrl, apiKey) {
-    if (OPENAI_COMPATIBLE_TYPES.has(providerType)) {
-        const base = baseUrl || DEFAULT_BASE_URLS["openai"];
+    if (isOpenAICompatibleType(providerType)) {
+        const base = baseUrl
+            || getCatalogBaseUrl(providerType)
+            || OPENAI_FALLBACK_BASE_URL;
         return {
             url: `${base}/v1/models`,
             headers: { Authorization: `Bearer ${apiKey}` },
         };
     }
     if (providerType === "anthropic") {
-        const base = baseUrl || DEFAULT_BASE_URLS["anthropic"];
+        const base = baseUrl
+            || getCatalogBaseUrl(providerType)
+            || ANTHROPIC_FALLBACK_BASE_URL;
         return {
             url: `${base}/v1/models`,
             headers: {
@@ -51,7 +90,9 @@ function buildEndpoint(providerType, baseUrl, apiKey) {
         };
     }
     if (providerType === "google") {
-        const base = baseUrl || DEFAULT_BASE_URLS["google"];
+        const base = baseUrl
+            || getCatalogBaseUrl(providerType)
+            || GOOGLE_FALLBACK_BASE_URL;
         return {
             url: `${base}/v1beta/models?key=${apiKey}`,
             headers: {},
@@ -63,7 +104,7 @@ function buildEndpoint(providerType, baseUrl, apiKey) {
 // Response parsers
 // ---------------------------------------------------------------------------
 function parseModelIds(providerType, body) {
-    if (OPENAI_COMPATIBLE_TYPES.has(providerType) || providerType === "anthropic") {
+    if (isOpenAICompatibleType(providerType) || providerType === "anthropic") {
         const data = body?.data;
         if (!Array.isArray(data))
             return [];

package/node_modules/@comis/agent/dist/model/operation-model-defaults.d.ts

@@ -1,28 +1,50 @@
 /**
- * Operation model defaults: static maps for provider-family model tiering.
+ * Operation model defaults: catalog-derived per-provider model tiering.
  *
- * These maps define the zero-config smart defaults for non-interactive
- * operations. When no explicit operationModels config is set, the resolver
- * uses these to select cost-appropriate models per provider family.
+ * Replaces the previous hardcoded `OPERATION_MODEL_DEFAULTS` table (which
+ * pinned `mid`/`fast` model IDs per provider family) with a pure function
+ * that reads the live pi-ai catalog at call time. Two design properties:
  *
- * Default model IDs are verified against pi-ai SDK registry v0.65.0.
- * Do NOT call normalizeModelId() on these -- they are already valid
- * registry IDs that bypass normalization.
+ * 1. Pi-ai SDK upgrades automatically light up new providers/models — no
+ *    per-release source edits to bump `OPERATION_MODEL_DEFAULTS` literals.
+ * 2. Closes the latent bug where switching primary to a non-Anthropic
+ *    provider left cron/heartbeat/compaction routed to Claude Sonnet
+ *    (because the old map was Anthropic/OpenAI/Google only).
+ *
+ * Tier picking: filter to text-capable models with non-zero cost, sort
+ * ascending by total cost (input + output), pick 10th-percentile = `fast`,
+ * 50th-percentile = `mid`. All-free-models providers (e.g. local Ollama,
+ * Z.AI most models) fall back to "first text-capable id" for both slots.
  *
  * @module
  */
 import type { ModelOperationType } from "@comis/core";
 /**
- * Per-provider-family default models for mid-tier and fast-tier operations.
+ * Resolve cost-tier model defaults for a given native pi-ai provider.
+ *
+ * Returns `{ fast, mid }` model IDs (without provider prefix) selected from
+ * the catalog by ascending total cost. Both undefined fields when the
+ * provider is unknown to pi-ai (e.g. custom YAML providers like Ollama).
+ *
+ * Algorithm:
+ *   1. Fetch `getModels(provider)` -> all models for that provider.
+ *   2. Filter to models supporting text input (`m.input.includes("text")`).
+ *   3. Filter to non-zero cost (eliminates free/local-only models from
+ *      ranking — they won't be reachable in production).
+ *   4. Sort ascending by total cost.
+ *   5. `fast` = 10th percentile, `mid` = 50th percentile.
+ *   6. If post-filter set is empty (all-free provider), use the first
+ *      text-capable model id for both slots.
+ *
+ * Pure function — no async, no side effects. Re-callable per request.
  *
- * - anthropic: Sonnet 4.6 (mid) for tool-using ops, Haiku 4.5 (fast) for classification
- * - google: Gemini 3 Flash (mid) for tool-using ops, Gemini 2.5 Flash Lite (fast) for classification
- * - openai: GPT-5.4-mini (mid) for tool-using ops, GPT-5.4-nano (fast) for classification
+ * @param provider - Provider name to resolve (e.g. "anthropic", "openrouter")
+ * @returns `{ fast?: string, mid?: string }` — empty object for unknown providers
  */
-export declare const OPERATION_MODEL_DEFAULTS: Record<string, {
-    mid: string;
-    fast: string;
-}>;
+export declare function resolveOperationDefaults(provider: string): {
+    fast?: string;
+    mid?: string;
+};
 /**
  * Maps each operation type to its cost tier.
  *