diff --git a/src/config/aiConfig.ts b/src/config/aiConfig.ts index 4f8fefbbcd..7140e175e0 100644 --- a/src/config/aiConfig.ts +++ b/src/config/aiConfig.ts @@ -1,16 +1,16 @@ import type { + AiModelApi, AiModelCapabilities, + AiModelOption, AiReasoningEffort, } from "@/types/aiProvider"; -import { isRecord } from "@/utils/typeGuards"; - -export interface AiModelOption extends AiModelCapabilities { - label?: string; - description?: string; -} +import { isRecord, isStringRecord } from "@/utils/typeGuards"; interface AiModelOptionsConfig { models?: AiModelOption[]; + catalogUrl?: string; + defaultModel?: string; + replacements?: Record; } export const AI_CONFIG = { @@ -98,6 +98,26 @@ export function isAiReasoningEffort( return AI_CONFIG.reasoningLevels.some((level) => level.value === value); } +const AI_MODEL_APIS: readonly AiModelApi[] = [ + "openai-responses", + "anthropic-messages", +]; + +export function isAiModelApi(value: unknown): value is AiModelApi { + return AI_MODEL_APIS.some((api) => api === value); +} + +export function isThinkingLevelMap( + value: unknown, +): value is Record { + return ( + isRecord(value) && + Object.values(value).every( + (effort) => effort === null || isAiReasoningEffort(effort), + ) + ); +} + declare global { interface Window { __TANGLE_AI_MODELS__?: AiModelOptionsConfig; @@ -112,6 +132,13 @@ function readModelOption(value: unknown): AiModelOption | null { return { id, + ...(typeof value.tangentModelId === "string" + ? { tangentModelId: value.tangentModelId } + : {}), + ...(isAiModelApi(value.api) ? { api: value.api } : {}), + ...(isThinkingLevelMap(value.thinkingLevelMap) + ? { thinkingLevelMap: value.thinkingLevelMap } + : {}), ...(typeof value.label === "string" && value.label.trim() ? { label: value.label.trim() } : {}), @@ -130,6 +157,12 @@ function readInjectedModelOptions(): AiModelOptionsConfig | null { if (!isRecord(config)) return null; return { + ...(typeof config.defaultModel === "string" + ? { defaultModel: config.defaultModel } + : {}), + ...(isStringRecord(config.replacements) + ? { replacements: config.replacements } + : {}), ...(Array.isArray(config.models) ? { models: config.models.map(readModelOption).filter((v) => v !== null) } : {}), @@ -143,8 +176,14 @@ export function getAiModelOptions(): AiModelOption[] { : AI_CONFIG.models; } +export function getAiModelReplacement(modelId: string): string | undefined { + return readInjectedModelOptions()?.replacements?.[modelId]; +} + export function getDefaultAiModelId(): string { - return getAiModelOptions()[0].id; + const options = getAiModelOptions(); + const preferred = readInjectedModelOptions()?.defaultModel; + return options.find((m) => m.id === preferred)?.id ?? options[0].id; } export function supportsAiEmbeddings(apiBase: string): boolean { @@ -156,7 +195,12 @@ export function supportsAiEmbeddings(apiBase: string): boolean { } export function getAiProviderConfig(modelId: string) { - return AI_CONFIG.providers.anthropic.modelPattern.test(modelId) + const protocol = getAiModelOptions().find((m) => m.id === modelId)?.api; + return ( + protocol + ? protocol === "anthropic-messages" + : AI_CONFIG.providers.anthropic.modelPattern.test(modelId) + ) ? AI_CONFIG.providers.anthropic : AI_CONFIG.providers.openai; } diff --git a/src/config/modelCatalog.test.ts b/src/config/modelCatalog.test.ts new file mode 100644 index 0000000000..a43b6e4bae --- /dev/null +++ b/src/config/modelCatalog.test.ts @@ -0,0 +1,169 @@ +import { afterEach, describe, expect, it, vi } from "vitest"; + +import { + AI_CONFIG, + getAiModelOptions, + getAiProviderConfig, + getDefaultAiModelId, +} from "@/config/aiConfig"; +import { + getStartingSessionModel, + getStartingSessionThinkingDepth, +} from "@/services/projects/startingSession"; + +import { ensureModelCatalog, getModelCatalogStatus } from "./modelCatalog"; + +const model = { + id: "example-model", + label: "Example", + api: "anthropic-messages", + tangentModelId: "example/example-model", + reasoningEfforts: ["low", "high", "max"], + thinkingLevelMap: { + off: null, + minimal: null, + low: "low", + medium: null, + high: "high", + xhigh: "max", + max: "max", + }, +}; +const fixture = { + schemaVersion: 1, + defaults: { browser: model.id }, + replacements: { "old-example": model.id }, + models: [model], +}; +describe("deployment model catalog", () => { + afterEach(() => { + delete window.__TANGLE_AI_MODELS__; + vi.unstubAllGlobals(); + }); + it("does not fetch a catalog for standalone installations", async () => { + const fetch = vi.fn(); + vi.stubGlobal("fetch", fetch); + expect(await ensureModelCatalog()).toBeNull(); + expect(fetch).not.toHaveBeenCalled(); + }); + it("loads authenticated choices and explicit model/thinking handoff", async () => { + window.__TANGLE_AI_MODELS__ = { catalogUrl: "/api/example-models/handoff" }; + const fetch = vi + .fn() + .mockResolvedValue(new Response(JSON.stringify(fixture))); + vi.stubGlobal("fetch", fetch); + await ensureModelCatalog(); + expect(fetch).toHaveBeenCalledWith( + "/api/example-models/handoff", + expect.objectContaining({ credentials: "include" }), + ); + expect(getDefaultAiModelId()).toBe(model.id); + expect(getAiModelOptions()).toHaveLength(1); + expect(getAiProviderConfig(model.id)).toBe(AI_CONFIG.providers.anthropic); + expect(getStartingSessionModel({ model: model.id })).toBe( + model.tangentModelId, + ); + expect( + getStartingSessionThinkingDepth({ + model: model.id, + reasoningEffortPreference: "max", + }), + ).toBe("xhigh"); + }); + it("shares one request between every consumer on the page", async () => { + window.__TANGLE_AI_MODELS__ = { catalogUrl: "/api/example-models/shared" }; + const fetch = vi + .fn() + .mockResolvedValue(new Response(JSON.stringify(fixture))); + vi.stubGlobal("fetch", fetch); + expect(getModelCatalogStatus()).toBe("loading"); + await Promise.all([ensureModelCatalog(), ensureModelCatalog()]); + await ensureModelCatalog(); + expect(fetch).toHaveBeenCalledTimes(1); + expect(getModelCatalogStatus()).toBe("ready"); + }); + + it("does not offer agent-only Chat Completions models for browser execution", async () => { + window.__TANGLE_AI_MODELS__ = { + catalogUrl: "/api/example-models/agent-only", + }; + const agentOnly = { + ...model, + id: "agent-only", + api: "openai-completions", + browserAvailable: false, + }; + vi.stubGlobal( + "fetch", + vi + .fn() + .mockResolvedValue( + new Response( + JSON.stringify({ ...fixture, models: [model, agentOnly] }), + ), + ), + ); + await ensureModelCatalog(); + expect(getAiModelOptions().map((m) => m.id)).toEqual([model.id]); + }); + + it("hands off the nearest mapped level when the preferred effort has no Pi level", async () => { + window.__TANGLE_AI_MODELS__ = { catalogUrl: "/api/example-models/gappy" }; + const gappy = { + ...model, + reasoningEfforts: ["low", "medium", "high"], + thinkingLevelMap: { ...model.thinkingLevelMap, xhigh: null, max: null }, + }; + vi.stubGlobal( + "fetch", + vi.fn().mockResolvedValue( + new Response( + JSON.stringify({ + ...fixture, + defaults: { browser: gappy.id }, + models: [gappy], + }), + ), + ), + ); + await ensureModelCatalog(); + expect( + getStartingSessionThinkingDepth({ + model: gappy.id, + reasoningEffortPreference: "medium", + }), + ).toBe("low"); + }); + + it("rejects failed and invalid catalogs without installing a partial list", async () => { + window.__TANGLE_AI_MODELS__ = { catalogUrl: "/api/example-models/invalid" }; + vi.stubGlobal( + "fetch", + vi.fn().mockResolvedValue(new Response("{}", { status: 401 })), + ); + await expect(ensureModelCatalog()).rejects.toThrow(); + expect(window.__TANGLE_AI_MODELS__.models).toBeUndefined(); + vi.stubGlobal( + "fetch", + vi + .fn() + .mockResolvedValue( + new Response(JSON.stringify({ ...fixture, schemaVersion: 2 })), + ), + ); + await expect(ensureModelCatalog()).rejects.toThrow(); + expect(window.__TANGLE_AI_MODELS__.models).toBeUndefined(); + vi.stubGlobal( + "fetch", + vi + .fn() + .mockResolvedValue( + new Response( + JSON.stringify({ ...fixture, replacements: { old: 42 } }), + ), + ), + ); + await expect(ensureModelCatalog()).rejects.toThrow(); + expect(window.__TANGLE_AI_MODELS__.models).toBeUndefined(); + }); +}); diff --git a/src/config/modelCatalog.ts b/src/config/modelCatalog.ts new file mode 100644 index 0000000000..2e84449b0a --- /dev/null +++ b/src/config/modelCatalog.ts @@ -0,0 +1,116 @@ +import { + getAiModelOptions, + isAiModelApi, + isAiReasoningEffort, + isThinkingLevelMap, +} from "@/config/aiConfig"; +import type { AiModelOption } from "@/types/aiProvider"; +import { isRecord, isStringRecord } from "@/utils/typeGuards"; + +export const MODEL_CATALOG_EVENT = "tangle:model-catalog"; + +export type ModelCatalogStatus = "loading" | "ready" | "failed"; + +type CatalogModel = AiModelOption & + Required>; + +/** Optional, deployment-selected endpoint. Standalone installs do not call it. */ +export function getModelCatalogUrl(): string | undefined { + return typeof window !== "undefined" + ? window.__TANGLE_AI_MODELS__?.catalogUrl + : undefined; +} + +function isAgentOnly(model: unknown): boolean { + return isRecord(model) && model.browserAvailable === false; +} + +function isCatalogModel(value: unknown): value is CatalogModel { + return ( + isRecord(value) && + typeof value.id === "string" && + value.id.trim() !== "" && + typeof value.label === "string" && + typeof value.tangentModelId === "string" && + isAiModelApi(value.api) && + Array.isArray(value.reasoningEfforts) && + value.reasoningEfforts.every(isAiReasoningEffort) && + isThinkingLevelMap(value.thinkingLevelMap) + ); +} + +async function loadModelCatalog() { + const url = getModelCatalogUrl(); + if (!url) return null; + const response = await fetch(url, { credentials: "include" }); + if (!response.ok) throw new Error("Unable to load deployment model catalog"); + const value: unknown = await response.json(); + if ( + !isRecord(value) || + value.schemaVersion !== 1 || + !Array.isArray(value.models) || + !value.models.length || + !isRecord(value.defaults) || + typeof value.defaults.browser !== "string" + ) + throw new Error("Invalid model catalog"); + const models = value.models.filter((model) => !isAgentOnly(model)); + if (!models.every(isCatalogModel)) throw new Error("Invalid catalog model"); + const defaultModel = value.defaults.browser; + if ( + !models.some((m) => m.id === defaultModel) || + new Set(models.map((m) => m.id)).size !== models.length + ) + throw new Error("Invalid catalog default"); + if (value.replacements !== undefined && !isStringRecord(value.replacements)) + throw new Error("Invalid catalog replacements"); + window.__TANGLE_AI_MODELS__ = { + catalogUrl: url, + models, + defaultModel, + replacements: value.replacements ?? {}, + }; + return getAiModelOptions(); +} + +interface CatalogLoad { + url: string; + status: ModelCatalogStatus; + pending: Promise; +} + +let load: CatalogLoad | undefined; + +function announce(url: string, status: ModelCatalogStatus) { + if (load?.url === url) load.status = status; + window.dispatchEvent(new Event(MODEL_CATALOG_EVENT)); +} + +export function getModelCatalogStatus(): ModelCatalogStatus { + const url = getModelCatalogUrl(); + if (!url) return "ready"; + return load?.url === url ? load.status : "loading"; +} + +/** + * Every AI consumer shares one catalog request per page, so a dozen mounting + * hooks cannot fan out into a dozen fetches or re-announce the same catalog. + */ +export function ensureModelCatalog(): Promise { + const url = getModelCatalogUrl(); + if (!url) return Promise.resolve(null); + if (load?.url !== url || load.status === "failed") { + const pending = loadModelCatalog().then( + (models) => { + announce(url, "ready"); + return models; + }, + (error: unknown) => { + announce(url, "failed"); + throw error; + }, + ); + load = { url, status: "loading", pending }; + } + return load.pending; +} diff --git a/src/hooks/useAiProviderSettings.ts b/src/hooks/useAiProviderSettings.ts index 9a7e388cfa..490a883220 100644 --- a/src/hooks/useAiProviderSettings.ts +++ b/src/hooks/useAiProviderSettings.ts @@ -1,12 +1,19 @@ -import { useSyncExternalStore } from "react"; +import { useEffect, useSyncExternalStore } from "react"; import { AI_CONFIG, getAiModelOptions, + getAiModelReplacement, getDefaultAiModelId, getEffectiveReasoningEffort, isAiReasoningEffort, } from "@/config/aiConfig"; +import { + ensureModelCatalog, + getModelCatalogStatus, + getModelCatalogUrl, + MODEL_CATALOG_EVENT, +} from "@/config/modelCatalog"; import { useBackend } from "@/providers/BackendProvider"; import type { AiProviderConfig } from "@/types/aiProvider"; import { getStorage } from "@/utils/typedStorage"; @@ -76,7 +83,7 @@ const REPLACED_MODEL_IDS = new Map([["gpt-6-sol", "gpt-6.1-sol"]]); function readModelId(record: Record, key: string): string { const model = readTrimmedString(record, key); - return REPLACED_MODEL_IDS.get(model) ?? model; + return getAiModelReplacement(model) ?? REPLACED_MODEL_IDS.get(model) ?? model; } function readReasoningPreference(record: Record) { @@ -155,7 +162,11 @@ function subscribe(callback: () => void): () => void { } }; window.addEventListener("storage", handler); - return () => window.removeEventListener("storage", handler); + window.addEventListener(MODEL_CATALOG_EVENT, callback); + return () => { + window.removeEventListener("storage", handler); + window.removeEventListener(MODEL_CATALOG_EVENT, callback); + }; } let cachedJSON = ""; @@ -165,7 +176,7 @@ function getSnapshot(): AiProviderSettings { customConfig: readStoredConfig(), proxyConfig: readProxySettings(), }; - const json = JSON.stringify(fresh); + const json = JSON.stringify({ fresh, models: getAiModelOptions() }); if (json !== cachedJSON) { cachedJSON = json; cachedConfig = fresh; @@ -179,6 +190,15 @@ function getServerSnapshot(): AiProviderSettings { export function useAiProviderSettings() { const { backendUrl } = useBackend(); + const catalogUrl = getModelCatalogUrl(); + const catalogStatus = useSyncExternalStore( + subscribe, + getModelCatalogStatus, + () => "ready", + ); + useEffect(() => { + if (catalogUrl) ensureModelCatalog().catch(() => undefined); + }, [catalogUrl]); const backendBase = backendUrl.trim().replace(/\/+$/, ""); const { customConfig, proxyConfig } = useSyncExternalStore( subscribe, @@ -204,7 +224,7 @@ export function useAiProviderSettings() { const config: AiProviderConfig = { apiBase: isOwnKeyEnabled ? customConfig.apiBase - : backendBase + : backendBase && catalogStatus === "ready" ? `${backendBase}/api/experimental/ai/v1` : "", apiKey: isOwnKeyEnabled ? customConfig.apiKey : "", diff --git a/src/services/projects/startingSession.ts b/src/services/projects/startingSession.ts index 7b9b76dbb8..184c8395ef 100644 --- a/src/services/projects/startingSession.ts +++ b/src/services/projects/startingSession.ts @@ -8,7 +8,7 @@ import { getEffectiveReasoningEffort, isAiReasoningEffort, } from "@/config/aiConfig"; -import type { AiProviderConfig } from "@/types/aiProvider"; +import type { AiModelOption, AiProviderConfig } from "@/types/aiProvider"; import { HOURS } from "@/utils/constants"; const PROMPT = "startingPrompt"; @@ -54,12 +54,33 @@ const asText = (value: unknown) => const asThinkingLevel = (value: unknown) => THINKING_LEVELS.find((level) => level === value); +function selectedCatalogModel( + config: Pick, +): AiModelOption | undefined { + return (config.modelCapabilities ?? getAiModelOptions()).find( + (option) => option.id === config.model, + ); +} + export function getStartingSessionThinkingDepth( config: Pick< AiProviderConfig, "model" | "reasoningEffortPreference" | "modelCapabilities" >, ): ThinkingLevel | undefined { + const thinkingLevelMap = selectedCatalogModel(config)?.thinkingLevelMap; + if (thinkingLevelMap) { + const reachableEfforts = THINKING_LEVELS.map( + (level) => thinkingLevelMap[level], + ).filter(isAiReasoningEffort); + const effort = getEffectiveReasoningEffort( + config.model, + config.reasoningEffortPreference, + config.modelCapabilities, + reachableEfforts, + ); + return THINKING_LEVELS.find((level) => thinkingLevelMap[level] === effort); + } const effort = getEffectiveReasoningEffort( config.model, config.reasoningEffortPreference, @@ -74,10 +95,9 @@ export function getStartingSessionThinkingDepth( export function getStartingSessionModel( config: Pick, ): string | undefined { - const isCatalogModel = (config.modelCapabilities ?? getAiModelOptions()).some( - (option) => option.id === config.model, - ); - if (!isCatalogModel) return undefined; + const selected = selectedCatalogModel(config); + if (!selected) return undefined; + if (selected.tangentModelId) return selected.tangentModelId; const provider = getAiProviderConfig(config.model) === AI_CONFIG.providers.anthropic ? "anthropic" diff --git a/src/types/aiProvider.ts b/src/types/aiProvider.ts index 377a0c310d..2e12e3ea18 100644 --- a/src/types/aiProvider.ts +++ b/src/types/aiProvider.ts @@ -6,12 +6,22 @@ export interface AiModelCapabilities { reasoningEfforts?: AiReasoningEffort[]; } +export type AiModelApi = "openai-responses" | "anthropic-messages"; + +export interface AiModelOption extends AiModelCapabilities { + label?: string; + description?: string; + tangentModelId?: string; + api?: AiModelApi; + thinkingLevelMap?: Record; +} + export interface AiProviderConfig { apiBase: string; apiKey: string; model: string; reasoningEffort?: AiReasoningEffort; reasoningEffortPreference?: AiReasoningEffort; - modelCapabilities?: AiModelCapabilities[]; + modelCapabilities?: AiModelOption[]; credentials?: RequestCredentials; } diff --git a/src/utils/typeGuards.ts b/src/utils/typeGuards.ts index 35f1d60d9a..d64091a921 100644 --- a/src/utils/typeGuards.ts +++ b/src/utils/typeGuards.ts @@ -1,3 +1,12 @@ export function isRecord(value: unknown): value is Record { return typeof value === "object" && value !== null && !Array.isArray(value); } + +export function isStringRecord( + value: unknown, +): value is Record { + return ( + isRecord(value) && + Object.values(value).every((entry) => typeof entry === "string") + ); +}