@golba98/codexa 1.0.1

package/src/core/providerRuntime/capabilityProfile.test.ts

@@ -0,0 +1,311 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  clearModelCapabilityProfileCache,
+  resolveModelCapabilityProfileCached,
+} from "./capabilityProfile.js";
+
+test("raw API supports_system_prompt: false sets supportsSystemPrompt false with api/verified", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "test-model",
+    rawMetadata: {
+      id: "test-model",
+      supports_system_prompt: false,
+    },
+  });
+
+  assert.equal(profile.supportsSystemPrompt, false);
+  assert.equal(profile.source, "api");
+  assert.equal(profile.confidence, "verified");
+});
+
+test("raw API supportsStreaming: true (camelCase) is detected", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "test-model",
+    rawMetadata: {
+      id: "test-model",
+      supportsStreaming: true,
+    },
+  });
+
+  assert.equal(profile.supportsStreaming, true);
+  assert.equal(profile.source, "api");
+});
+
+test("nested model_info.supports_tool_calls is detected", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "test-model",
+    rawMetadata: {
+      id: "test-model",
+      model_info: {
+        supports_tool_calls: true,
+        max_output_tokens: 2048,
+      },
+    },
+  });
+
+  assert.equal(profile.supportsToolCalls, true);
+  assert.equal(profile.maxOutputTokens, 2048);
+  assert.equal(profile.source, "api");
+});
+
+test("raw API with no capability fields returns all-null profile with unknown source", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "no-caps-model",
+    rawMetadata: {
+      id: "no-caps-model",
+      object: "model",
+    },
+  });
+
+  assert.equal(profile.supportsSystemPrompt, null);
+  assert.equal(profile.supportsStreaming, null);
+  assert.equal(profile.supportsToolCalls, null);
+  assert.equal(profile.maxOutputTokens, null);
+  assert.equal(profile.source, "unknown");
+  assert.equal(profile.confidence, "unknown");
+});
+
+test("config override supportsSystemPrompt: false applies when no raw metadata", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "config-model",
+    providerConfig: {
+      models: {
+        "config-model": {
+          supportsSystemPrompt: false,
+          supportsStreaming: true,
+        },
+      },
+    },
+  });
+
+  assert.equal(profile.supportsSystemPrompt, false);
+  assert.equal(profile.supportsStreaming, true);
+  assert.equal(profile.source, "config");
+  assert.equal(profile.confidence, "configured");
+});
+
+test("config override rejects non-boolean string values", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "bad-model",
+    providerConfig: {
+      models: {
+        "bad-model": {
+          // TypeScript would reject these, but test that runtime parsing rejects them too
+          supportsStreaming: "true" as unknown as boolean,
+        },
+      },
+    },
+  });
+
+  // A string "true" is not a boolean — should fall through to unknown
+  assert.equal(profile.supportsStreaming, null);
+  assert.equal(profile.source, "unknown");
+});
+
+test("config override maxOutputTokens: 4096 applies; negative is rejected", () => {
+  clearModelCapabilityProfileCache();
+  const validProfile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "model-a",
+    providerConfig: {
+      models: {
+        "model-a": { maxOutputTokens: 4096 },
+      },
+    },
+  });
+
+  assert.equal(validProfile.maxOutputTokens, 4096);
+  assert.equal(validProfile.source, "config");
+
+  clearModelCapabilityProfileCache();
+  const invalidProfile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "model-b",
+    providerConfig: {
+      models: {
+        "model-b": { maxOutputTokens: -1 },
+      },
+    },
+  });
+
+  assert.equal(invalidProfile.maxOutputTokens, null);
+  assert.equal(invalidProfile.source, "unknown");
+});
+
+test("known registry is initially empty — all models return unknown without raw/config", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "google",
+    modelId: "gemini-2.5-pro",
+  });
+
+  assert.equal(profile.source, "unknown");
+  assert.equal(profile.supportsStreaming, null);
+  assert.equal(profile.supportsToolCalls, null);
+});
+
+test("raw API for non-local providers returns unknown (only local queries /v1/models)", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-6",
+    rawMetadata: {
+      id: "claude-sonnet-4-6",
+      supports_streaming: true,
+    },
+  });
+
+  // Non-local providers don't scan raw metadata
+  assert.equal(profile.source, "unknown");
+  assert.equal(profile.supportsStreaming, null);
+});
+
+test("capability cache is upgraded from unknown when raw API metadata arrives", () => {
+  clearModelCapabilityProfileCache();
+
+  const first = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "upgrade-model",
+  });
+
+  const second = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "upgrade-model",
+    rawMetadata: {
+      id: "upgrade-model",
+      supports_tool_calls: false,
+    },
+  });
+
+  const third = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "upgrade-model",
+  });
+
+  assert.equal(first.source, "unknown");
+  assert.equal(first.supportsToolCalls, null);
+  assert.equal(second.source, "api");
+  assert.equal(second.supportsToolCalls, false);
+  // Third call hits the upgraded cache
+  assert.equal(third.source, "api");
+  assert.equal(third.supportsToolCalls, false);
+});
+
+test("clearModelCapabilityProfileCache resets all cached profiles", () => {
+  const profile1 = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "clear-test-model",
+    rawMetadata: { id: "clear-test-model", supports_streaming: true },
+  });
+  assert.equal(profile1.supportsStreaming, true);
+
+  clearModelCapabilityProfileCache();
+
+  const profile2 = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "clear-test-model",
+  });
+  assert.equal(profile2.supportsStreaming, null);
+  assert.equal(profile2.source, "unknown");
+});
+
+test("capabilities: ['tool_use'] sets supportsToolCalls true with api source", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "gemma-tools",
+    rawMetadata: {
+      id: "gemma-tools",
+      capabilities: ["tool_use"],
+    },
+  });
+
+  assert.equal(profile.supportsToolCalls, true);
+  assert.equal(profile.source, "api");
+  assert.equal(profile.confidence, "verified");
+});
+
+test("capabilities: ['vision'] without tool_use leaves supportsToolCalls null (absence != false)", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "vision-only",
+    rawMetadata: {
+      id: "vision-only",
+      capabilities: ["vision"],
+    },
+  });
+
+  assert.equal(profile.supportsToolCalls, null);
+  assert.equal(profile.source, "unknown");
+});
+
+test("capabilities: [] (empty array) leaves all capabilities null", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "no-caps",
+    rawMetadata: {
+      id: "no-caps",
+      capabilities: [],
+    },
+  });
+
+  assert.equal(profile.supportsToolCalls, null);
+  assert.equal(profile.source, "unknown");
+});
+
+test("type: 'vlm' alone does not set supportsVision (no automatic mapping)", () => {
+  clearModelCapabilityProfileCache();
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "vlm-model",
+    rawMetadata: {
+      id: "vlm-model",
+      type: "vlm",
+      capabilities: ["tool_use"],
+    },
+  });
+
+  assert.equal(profile.supportsVision, null);
+  assert.equal(profile.supportsToolCalls, true);
+});
+
+test("full LM Studio fixture: supportsToolCalls true, supportsVision null", () => {
+  clearModelCapabilityProfileCache();
+  const fixture = {
+    id: "google/gemma-4-26b-a4b",
+    object: "model",
+    type: "vlm",
+    publisher: "google",
+    arch: "gemma4",
+    compatibility_type: "gguf",
+    quantization: "Q4_K_M",
+    state: "loaded",
+    max_context_length: 262144,
+    loaded_context_length: 64000,
+    capabilities: ["tool_use"],
+  };
+  const profile = resolveModelCapabilityProfileCached({
+    providerId: "local",
+    modelId: "google/gemma-4-26b-a4b",
+    rawMetadata: fixture,
+  });
+
+  assert.equal(profile.supportsToolCalls, true);
+  assert.equal(profile.supportsVision, null);
+  assert.equal(profile.source, "api");
+});

package/src/core/providerRuntime/capabilityProfile.ts

@@ -0,0 +1,288 @@
+import type { ProviderId, ProviderWorkspaceOverride } from "../providerLauncher/types.js";
+
+export type CapabilitySource = "api" | "cli" | "config" | "known-registry" | "unknown";
+export type CapabilityConfidence = "verified" | "configured" | "known" | "unknown";
+
+export interface ModelCapabilityProfile {
+  providerId: ProviderId;
+  modelId: string;
+  maxOutputTokens: number | null;
+  supportsStreaming: boolean | null;
+  supportsToolCalls: boolean | null;
+  supportsSystemPrompt: boolean | null;
+  supportsVision: boolean | null;
+  source: CapabilitySource;
+  confidence: CapabilityConfidence;
+  raw?: unknown;
+  error?: string;
+}
+
+export interface ResolveModelCapabilityProfileOptions {
+  providerId: ProviderId;
+  modelId: string;
+  providerConfig?: ProviderWorkspaceOverride | null;
+  rawMetadata?: unknown;
+}
+
+interface KnownCapabilityRegistryEntry {
+  maxOutputTokens?: number;
+  supportsStreaming?: boolean;
+  supportsToolCalls?: boolean;
+  supportsSystemPrompt?: boolean;
+  supportsVision?: boolean;
+}
+
+// Empty by default — only exact "providerId:modelId" matches are allowed.
+// Do NOT add wildcard or family-based entries.
+const KNOWN_CAPABILITY_REGISTRY: Record<string, KnownCapabilityRegistryEntry> = {};
+
+const SYSTEM_PROMPT_CANDIDATES = [
+  "supports_system_prompt",
+  "supportsSystemPrompt",
+  "system_prompt",
+  "has_system_prompt",
+] as const;
+
+const STREAMING_CANDIDATES = [
+  "supports_streaming",
+  "supportsStreaming",
+  "streaming",
+  "stream_supported",
+] as const;
+
+const TOOL_CALLS_CANDIDATES = [
+  "supports_tool_calls",
+  "supportsToolCalls",
+  "tool_calls",
+  "supports_tools",
+  "function_calling",
+  "has_tools",
+] as const;
+
+const MAX_OUTPUT_TOKENS_CANDIDATES = [
+  "max_output_tokens",
+  "maxOutputTokens",
+  "max_new_tokens",
+  "max_tokens_output",
+] as const;
+
+const NESTED_METADATA_KEYS = [
+  "model_info",
+  "modelInfo",
+  "metadata",
+  "details",
+  "config",
+] as const;
+
+const capabilityCache = new Map<string, ModelCapabilityProfile>();
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function validBoolean(value: unknown): boolean | null {
+  if (value === true || value === false) return value;
+  return null;
+}
+
+function validPositiveInteger(value: unknown): number | null {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) return null;
+  return value;
+}
+
+function cacheKey(options: ResolveModelCapabilityProfileOptions): string {
+  return JSON.stringify({
+    providerId: options.providerId,
+    modelId: options.modelId,
+    models: options.providerConfig?.models ?? null,
+  });
+}
+
+export function clearModelCapabilityProfileCache(): void {
+  capabilityCache.clear();
+}
+
+function unknownProfile(
+  providerId: ProviderId,
+  modelId: string,
+  error?: string,
+): ModelCapabilityProfile {
+  return {
+    providerId,
+    modelId,
+    maxOutputTokens: null,
+    supportsStreaming: null,
+    supportsToolCalls: null,
+    supportsSystemPrompt: null,
+    supportsVision: null,
+    source: "unknown",
+    confidence: "unknown",
+    ...(error ? { error } : {}),
+  };
+}
+
+function findBooleanField(
+  raw: Record<string, unknown>,
+  candidates: readonly string[],
+): boolean | null {
+  for (const field of candidates) {
+    const value = validBoolean(raw[field]);
+    if (value !== null) return value;
+  }
+  for (const nestedKey of NESTED_METADATA_KEYS) {
+    const nested = raw[nestedKey];
+    if (!isRecord(nested)) continue;
+    for (const field of candidates) {
+      const value = validBoolean(nested[field]);
+      if (value !== null) return value;
+    }
+  }
+  return null;
+}
+
+function findIntegerField(
+  raw: Record<string, unknown>,
+  candidates: readonly string[],
+): number | null {
+  for (const field of candidates) {
+    const value = validPositiveInteger(raw[field]);
+    if (value !== null) return value;
+  }
+  for (const nestedKey of NESTED_METADATA_KEYS) {
+    const nested = raw[nestedKey];
+    if (!isRecord(nested)) continue;
+    for (const field of candidates) {
+      const value = validPositiveInteger(nested[field]);
+      if (value !== null) return value;
+    }
+  }
+  return null;
+}
+
+function resolveFromRawMetadata(
+  providerId: ProviderId,
+  modelId: string,
+  raw: unknown,
+): ModelCapabilityProfile | null {
+  if (providerId !== "local") return null;
+  if (!isRecord(raw)) return null;
+
+  const supportsSystemPrompt = findBooleanField(raw, SYSTEM_PROMPT_CANDIDATES);
+  const supportsStreaming = findBooleanField(raw, STREAMING_CANDIDATES);
+  let supportsToolCalls = findBooleanField(raw, TOOL_CALLS_CANDIDATES);
+  const maxOutputTokens = findIntegerField(raw, MAX_OUTPUT_TOKENS_CANDIDATES);
+
+  if (supportsToolCalls === null && Array.isArray(raw.capabilities)) {
+    if ((raw.capabilities as unknown[]).includes("tool_use")) {
+      supportsToolCalls = true;
+    }
+    // absence of "tool_use" in capabilities ≠ not supported — leave null
+  }
+
+  if (
+    supportsSystemPrompt === null
+    && supportsStreaming === null
+    && supportsToolCalls === null
+    && maxOutputTokens === null
+  ) {
+    return null;
+  }
+
+  return {
+    providerId,
+    modelId,
+    maxOutputTokens,
+    supportsStreaming,
+    supportsToolCalls,
+    supportsSystemPrompt,
+    supportsVision: null,
+    source: "api",
+    confidence: "verified",
+    raw,
+  };
+}
+
+function resolveFromConfig(
+  providerId: ProviderId,
+  modelId: string,
+  providerConfig?: ProviderWorkspaceOverride | null,
+): ModelCapabilityProfile | null {
+  const modelOverride = providerConfig?.models?.[modelId];
+  if (!modelOverride) return null;
+
+  const supportsStreaming = validBoolean(modelOverride.supportsStreaming);
+  const supportsToolCalls = validBoolean(modelOverride.supportsToolCalls);
+  const supportsSystemPrompt = validBoolean(modelOverride.supportsSystemPrompt);
+  const maxOutputTokens = validPositiveInteger(modelOverride.maxOutputTokens);
+
+  const hasAny =
+    supportsSystemPrompt !== null
+    || supportsStreaming !== null
+    || supportsToolCalls !== null
+    || maxOutputTokens !== null;
+
+  if (!hasAny) return null;
+
+  return {
+    providerId,
+    modelId,
+    maxOutputTokens,
+    supportsStreaming,
+    supportsToolCalls,
+    supportsSystemPrompt,
+    supportsVision: validBoolean(modelOverride.supportsVision),
+    source: "config",
+    confidence: "configured",
+  };
+}
+
+function resolveFromKnownRegistry(
+  providerId: ProviderId,
+  modelId: string,
+): ModelCapabilityProfile | null {
+  const entry = KNOWN_CAPABILITY_REGISTRY[`${providerId}:${modelId}`];
+  if (!entry) return null;
+  return {
+    providerId,
+    modelId,
+    maxOutputTokens: entry.maxOutputTokens ?? null,
+    supportsStreaming: entry.supportsStreaming ?? null,
+    supportsToolCalls: entry.supportsToolCalls ?? null,
+    supportsSystemPrompt: entry.supportsSystemPrompt ?? null,
+    supportsVision: entry.supportsVision ?? null,
+    source: "known-registry",
+    confidence: "known",
+  };
+}
+
+export function resolveModelCapabilityProfileCached(
+  options: ResolveModelCapabilityProfileOptions,
+): ModelCapabilityProfile {
+  const key = cacheKey(options);
+  const cached = capabilityCache.get(key);
+  if (cached && !(options.rawMetadata !== undefined && cached.source === "unknown")) {
+    return cached;
+  }
+
+  const raw = resolveFromRawMetadata(options.providerId, options.modelId, options.rawMetadata);
+  if (raw) {
+    capabilityCache.set(key, raw);
+    return raw;
+  }
+
+  const config = resolveFromConfig(options.providerId, options.modelId, options.providerConfig);
+  if (config) {
+    capabilityCache.set(key, config);
+    return config;
+  }
+
+  const registry = resolveFromKnownRegistry(options.providerId, options.modelId);
+  if (registry) {
+    capabilityCache.set(key, registry);
+    return registry;
+  }
+
+  const result = unknownProfile(options.providerId, options.modelId);
+  capabilityCache.set(key, result);
+  return result;
+}