chainlesschain 0.166.46 → 0.166.47

package/src/lib/model-capabilities.js

@@ -0,0 +1,271 @@
+import { canonicalDigest } from "@chainlesschain/context-memory-kernel";
+import {
+  CONTEXT_WINDOWS,
+  DOCUMENTED_OPENAI_MODELS,
+  LEGACY_MODEL_PROVIDERS,
+  MODEL_CAPABILITY_CATALOG_VERSION,
+} from "./model-context-catalog.js";
+import { mergeProviderOptions } from "./provider-options.js";
+
+const PROFILE_SCHEMA = "chainlesschain.model-capability-profile/v1";
+const MAX_CONTEXT_WINDOW_TOKENS = 16_777_216;
+const CHAT_COMPLETIONS_PROVIDERS = new Set([
+  "openai",
+  "deepseek",
+  "dashscope",
+  "mistral",
+  "gemini",
+  "volcengine",
+]);
+
+function optionalIdentity(value, field) {
+  if (value == null || value === "") return null;
+  if (typeof value !== "string" || value.length > 256) {
+    throw new TypeError(`${field} must be a string of at most 256 characters`);
+  }
+  if (/\p{Cc}/u.test(value)) {
+    throw new TypeError(`${field} must not contain control characters`);
+  }
+  // Provider/model identity is exact, just like the request transport. Do not
+  // certify an alias by trimming or changing the case of an actual request id.
+  return value;
+}
+
+function optionalPositiveInteger(
+  value,
+  field,
+  { min = 1, max = Number.MAX_SAFE_INTEGER } = {},
+) {
+  if (value == null) return null;
+  const normalized =
+    typeof value === "string" && /^\d+$/u.test(value.trim())
+      ? Number(value.trim())
+      : value;
+  if (
+    typeof normalized !== "number" ||
+    !Number.isSafeInteger(normalized) ||
+    normalized < min ||
+    normalized > max
+  ) {
+    throw new RangeError(
+      `${field} must be an integer between ${min} and ${max}`,
+    );
+  }
+  return normalized;
+}
+
+function deepFreeze(value) {
+  for (const child of Object.values(value)) {
+    if (child && typeof child === "object") deepFreeze(child);
+  }
+  return Object.freeze(value);
+}
+
+function isOfficialOpenAIBaseUrl(baseUrl) {
+  if (baseUrl == null || baseUrl === "") return true;
+  if (typeof baseUrl !== "string") {
+    throw new TypeError("baseUrl must be a string when provided");
+  }
+  try {
+    // Deliberately excludes credentials, paths other than /v1, query/hash
+    // decorations and non-default ports. Never return or hash the input URL.
+    return (
+      baseUrl === baseUrl.trim() &&
+      new URL(baseUrl).href === "https://api.openai.com/v1"
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Describe the output cap the existing agent transport actually sends.
+ * This does not add a cap to Chat Completions/Ollama or select a new model.
+ * The planner may apply its own minimum reserve and reject an impossible
+ * input/output allocation; no context-window clipping happens here.
+ */
+export function resolveAgentOutputBudget({
+  provider,
+  model,
+  maxOutputTokens,
+} = {}) {
+  const requested = optionalPositiveInteger(maxOutputTokens, "maxOutputTokens");
+  if (provider === "anthropic") {
+    const effectiveModel = model || "claude-sonnet-4-6";
+    const { maxTokens } = mergeProviderOptions("anthropic", effectiveModel);
+    const defaultCap = maxTokens || 8192;
+    const requestMaxOutputTokens =
+      requested === null ? defaultCap : Math.min(defaultCap, requested);
+    return Object.freeze({
+      requestMaxOutputTokens,
+      plannedOutputReserveTokens: requestMaxOutputTokens,
+      outputReserveSource:
+        requested === null
+          ? "anthropic-request-default"
+          : requested > defaultCap
+            ? "anthropic-request-clamp"
+            : "explicit-request-cap",
+    });
+  }
+  return Object.freeze({
+    requestMaxOutputTokens: requested,
+    plannedOutputReserveTokens: requested ?? 4096,
+    outputReserveSource:
+      requested === null ? "planning-fallback" : "explicit-request-cap",
+  });
+}
+
+/**
+ * Pure, versioned diagnostics/planning projection. No provider discovery,
+ * credential loading, model calls or protocol negotiation is performed.
+ * `runtimeVerified:false` applies even to documented model specifications.
+ */
+export function resolveModelCapabilityProfile({
+  provider,
+  model,
+  baseUrl,
+  contextMemoryModelWindowTokens,
+  maxOutputTokens,
+} = {}) {
+  const selectedProvider = optionalIdentity(provider, "provider");
+  const selectedModel = optionalIdentity(model, "model");
+  if (baseUrl != null && typeof baseUrl !== "string") {
+    throw new TypeError("baseUrl must be a string when provided");
+  }
+  const override = optionalPositiveInteger(
+    contextMemoryModelWindowTokens,
+    "contextMemoryModelWindowTokens",
+    { min: 1024, max: MAX_CONTEXT_WINDOW_TOKENS },
+  );
+  const officialEndpoint =
+    selectedProvider === "openai" && isOfficialOpenAIBaseUrl(baseUrl);
+  const documented =
+    officialEndpoint &&
+    selectedModel &&
+    Object.hasOwn(DOCUMENTED_OPENAI_MODELS, selectedModel)
+      ? DOCUMENTED_OPENAI_MODELS[selectedModel]
+      : null;
+  const legacyOwner =
+    selectedModel && Object.hasOwn(LEGACY_MODEL_PROVIDERS, selectedModel)
+      ? LEGACY_MODEL_PROVIDERS[selectedModel]
+      : null;
+  let contextWindowTokens;
+  let windowSource;
+  let windowAssumed = true;
+  if (override !== null) {
+    contextWindowTokens = override;
+    windowSource = "explicit-override";
+  } else if (documented) {
+    contextWindowTokens = documented.contextWindowTokens;
+    windowSource = "official-model-docs";
+    windowAssumed = false;
+  } else if (
+    legacyOwner &&
+    (!selectedProvider || legacyOwner === selectedProvider)
+  ) {
+    contextWindowTokens = CONTEXT_WINDOWS[selectedModel];
+    windowSource = selectedProvider
+      ? "legacy-catalog"
+      : "legacy-catalog-unscoped";
+  } else if (
+    selectedProvider &&
+    Object.hasOwn(CONTEXT_WINDOWS._provider_defaults, selectedProvider)
+  ) {
+    contextWindowTokens = CONTEXT_WINDOWS._provider_defaults[selectedProvider];
+    windowSource = "provider-default";
+  } else {
+    contextWindowTokens = 32768;
+    windowSource = "generic-default";
+  }
+
+  const output = resolveAgentOutputBudget({
+    provider: selectedProvider,
+    model: selectedModel,
+    maxOutputTokens,
+  });
+  const runtimeProtocol =
+    selectedProvider === "ollama"
+      ? "ollama-chat"
+      : selectedProvider === "anthropic"
+        ? "anthropic-messages"
+        : selectedProvider === "openai" && documented?.requiresResponsesForTools
+          ? "openai-responses"
+          : CHAT_COMPLETIONS_PROVIDERS.has(selectedProvider) || Boolean(baseUrl)
+            ? "chat-completions"
+            : "unsupported";
+  const limitations = [
+    "Runtime execution, endpoint access and account entitlement have not been verified.",
+  ];
+  if (windowSource === "explicit-override") {
+    limitations.push("The context window is operator-declared and unverified.");
+  } else if (windowAssumed) {
+    limitations.push(
+      "The context window is a legacy or fallback planning estimate, not a verified model limit.",
+    );
+  }
+  if (!selectedProvider) {
+    limitations.push(
+      "No provider was specified; an unscoped legacy model lookup does not establish provider capabilities.",
+    );
+  }
+  if (legacyOwner && selectedProvider && legacyOwner !== selectedProvider) {
+    limitations.push(
+      "The model's legacy catalog entry belongs to another provider and was not applied.",
+    );
+  }
+  if (selectedProvider === "openai" && !officialEndpoint) {
+    limitations.push(
+      "Official OpenAI model specifications are not applied to a custom endpoint.",
+    );
+  }
+  if (output.requestMaxOutputTokens === null) {
+    limitations.push(
+      "The output reserve is a planning fallback, not an output cap sent to the provider.",
+    );
+  }
+  if (documented?.requiresResponsesForTools) {
+    limitations.push(
+      "Responses selection is based on the versioned catalog and has not been verified against this account at runtime.",
+    );
+  }
+  if (runtimeProtocol === "unsupported") {
+    limitations.push(
+      "No supported agent transport was resolved for this provider and endpoint configuration.",
+    );
+  }
+  if (
+    documented &&
+    output.requestMaxOutputTokens > documented.advertisedMaxOutputTokens
+  ) {
+    limitations.push(
+      "The requested output cap exceeds the documented model maximum; the profile does not rewrite the request.",
+    );
+  }
+
+  const identityDigest = canonicalDigest(
+    {
+      schema: PROFILE_SCHEMA,
+      provider: selectedProvider || "unknown",
+      model: selectedModel,
+    },
+    "chainlesschain.model-capability-identity/v1",
+  );
+  const profile = {
+    schema: PROFILE_SCHEMA,
+    catalogVersion: MODEL_CAPABILITY_CATALOG_VERSION,
+    profileId: `model-capability-v1:${identityDigest.slice(7, 39)}`,
+    provider: selectedProvider || "unknown",
+    model: selectedModel,
+    contextWindowTokens,
+    windowSource,
+    windowAssumed,
+    runtimeProtocol,
+    runtimeVerified: false,
+    ...output,
+    advertisedMaxOutputTokens: documented?.advertisedMaxOutputTokens ?? null,
+    sources: documented ? [...documented.sources] : [],
+    limitations,
+  };
+  profile.digest = canonicalDigest(profile, PROFILE_SCHEMA);
+  return deepFreeze(profile);
+}

package/src/lib/model-context-catalog.js

@@ -0,0 +1,105 @@
+// Compatibility catalog: these legacy values are retained verbatim. They are
+// planning assumptions, not recently verified provider capability guarantees.
+export const CONTEXT_WINDOWS = Object.freeze({
+  "qwen2.5:7b": 32768,
+  "qwen2.5:14b": 32768,
+  "qwen2.5-coder:14b": 32768,
+  "qwen2:7b": 32768,
+  "llama3:8b": 8192,
+  "mistral:7b": 32768,
+  "codellama:7b": 16384,
+  "gpt-4o": 128000,
+  "gpt-4o-mini": 128000,
+  "gpt-4-turbo": 128000,
+  "gpt-3.5-turbo": 16385,
+  o1: 200000,
+  "claude-opus-4-6": 200000,
+  "claude-sonnet-4-6": 200000,
+  "claude-haiku-4-5-20251001": 200000,
+  "deepseek-chat": 64000,
+  "deepseek-coder": 64000,
+  "deepseek-reasoner": 64000,
+  "qwen-turbo": 131072,
+  "qwen-plus": 131072,
+  "qwen-max": 32768,
+  "gemini-2.0-flash": 1048576,
+  "gemini-2.0-pro": 1048576,
+  "gemini-1.5-flash": 1048576,
+  "moonshot-v1-auto": 131072,
+  "moonshot-v1-8k": 8192,
+  "moonshot-v1-32k": 32768,
+  "moonshot-v1-128k": 131072,
+  "doubao-seed-1-6-251015": 32768,
+  "doubao-seed-2-1-pro-260628": 32768,
+  _provider_defaults: Object.freeze({
+    ollama: 32768,
+    openai: 128000,
+    anthropic: 200000,
+    deepseek: 64000,
+    dashscope: 131072,
+    gemini: 1048576,
+    kimi: 131072,
+    volcengine: 32768,
+    minimax: 32768,
+    mistral: 32768,
+  }),
+});
+
+export const MODEL_CAPABILITY_CATALOG_VERSION = "2026-09-13";
+
+// Explicit ownership prevents a model name served by an unrelated provider
+// from silently inheriting another provider's catalog window.
+export const LEGACY_MODEL_PROVIDERS = Object.freeze({
+  "qwen2.5:7b": "ollama",
+  "qwen2.5:14b": "ollama",
+  "qwen2.5-coder:14b": "ollama",
+  "qwen2:7b": "ollama",
+  "llama3:8b": "ollama",
+  "mistral:7b": "ollama",
+  "codellama:7b": "ollama",
+  "gpt-4o": "openai",
+  "gpt-4o-mini": "openai",
+  "gpt-4-turbo": "openai",
+  "gpt-3.5-turbo": "openai",
+  o1: "openai",
+  "claude-opus-4-6": "anthropic",
+  "claude-sonnet-4-6": "anthropic",
+  "claude-haiku-4-5-20251001": "anthropic",
+  "deepseek-chat": "deepseek",
+  "deepseek-coder": "deepseek",
+  "deepseek-reasoner": "deepseek",
+  "qwen-turbo": "dashscope",
+  "qwen-plus": "dashscope",
+  "qwen-max": "dashscope",
+  "gemini-2.0-flash": "gemini",
+  "gemini-2.0-pro": "gemini",
+  "gemini-1.5-flash": "gemini",
+  "moonshot-v1-auto": "kimi",
+  "moonshot-v1-8k": "kimi",
+  "moonshot-v1-32k": "kimi",
+  "moonshot-v1-128k": "kimi",
+  "doubao-seed-1-6-251015": "volcengine",
+  "doubao-seed-2-1-pro-260628": "volcengine",
+});
+
+// Official pages reviewed on the catalog version date. These describe the
+// named models, not endpoint access, account entitlement, or a live CLI run.
+export const DOCUMENTED_OPENAI_MODELS = Object.freeze({
+  "gpt-4o": Object.freeze({
+    contextWindowTokens: 128000,
+    advertisedMaxOutputTokens: 16384,
+    requiresResponsesForTools: false,
+    sources: Object.freeze([
+      "https://developers.openai.com/api/docs/models/gpt-4o",
+    ]),
+  }),
+  "gpt-6-astra": Object.freeze({
+    contextWindowTokens: 1050000,
+    advertisedMaxOutputTokens: 128000,
+    requiresResponsesForTools: true,
+    sources: Object.freeze([
+      "https://developers.openai.com/api/docs/models/gpt-6-astra",
+      "https://developers.openai.com/api/docs/guides/migrate-to-responses",
+    ]),
+  }),
+});

package/src/lib/model-context-window.js

@@ -1,52 +1,7 @@
-export const CONTEXT_WINDOWS = Object.freeze({
-  "qwen2.5:7b": 32768,
-  "qwen2.5:14b": 32768,
-  "qwen2.5-coder:14b": 32768,
-  "qwen2:7b": 32768,
-  "llama3:8b": 8192,
-  "mistral:7b": 32768,
-  "codellama:7b": 16384,
-  "gpt-4o": 128000,
-  "gpt-4o-mini": 128000,
-  "gpt-4-turbo": 128000,
-  "gpt-3.5-turbo": 16385,
-  o1: 200000,
-  "claude-opus-4-6": 200000,
-  "claude-sonnet-4-6": 200000,
-  "claude-haiku-4-5-20251001": 200000,
-  "deepseek-chat": 64000,
-  "deepseek-coder": 64000,
-  "deepseek-reasoner": 64000,
-  "qwen-turbo": 131072,
-  "qwen-plus": 131072,
-  "qwen-max": 32768,
-  "gemini-2.0-flash": 1048576,
-  "gemini-2.0-pro": 1048576,
-  "gemini-1.5-flash": 1048576,
-  "moonshot-v1-auto": 131072,
-  "moonshot-v1-8k": 8192,
-  "moonshot-v1-32k": 32768,
-  "moonshot-v1-128k": 131072,
-  "doubao-seed-1-6-251015": 32768,
-  "doubao-seed-2-1-pro-260628": 32768,
-  _provider_defaults: Object.freeze({
-    ollama: 32768,
-    openai: 128000,
-    anthropic: 200000,
-    deepseek: 64000,
-    dashscope: 131072,
-    gemini: 1048576,
-    kimi: 131072,
-    volcengine: 32768,
-    minimax: 32768,
-    mistral: 32768,
-  }),
-});
+import { resolveModelCapabilityProfile } from "./model-capabilities.js";
+
+export { CONTEXT_WINDOWS } from "./model-context-catalog.js";
 
 export function getContextWindow(model, provider) {
-  if (model && CONTEXT_WINDOWS[model]) return CONTEXT_WINDOWS[model];
-  if (provider && CONTEXT_WINDOWS._provider_defaults[provider]) {
-    return CONTEXT_WINDOWS._provider_defaults[provider];
-  }
-  return 32768;
+  return resolveModelCapabilityProfile({ model, provider }).contextWindowTokens;
 }