706 lines
22 KiB
TypeScript
706 lines
22 KiB
TypeScript
import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
|
|
import { homedir } from "node:os";
|
|
import { dirname, join } from "node:path";
|
|
import type { ThinkingLevel, ThinkingLevelMap } from "@earendil-works/pi-ai";
|
|
import { buildAuthHeaders } from "./cosy.js";
|
|
import { getQoderBaseUrl, getQoderModelListURL, getQoderRegionConfig, type QoderMode } from "./region.js";
|
|
|
|
export const ZERO_COST = Object.freeze({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
|
|
|
|
/**
|
|
* Maximum output tokens sent per request. Aliyun Model Studio (the upstream
|
|
* behind Qoder's CN catalog) documents Max Output Length = 131072 for every
|
|
* model we expose (qwen3.8-max/flash, qwen3.7-max/plus/flash), in both normal
|
|
* and thinking modes (thinking chain alone goes up to 262144). The Qoder
|
|
* /model/list catalog does not return a per-model output cap, so this single
|
|
* constant is the source of truth for both static models and request sending.
|
|
* qodercli ships a conservative 32e3 default and caps its UI at 65536; we use
|
|
* the documented upstream ceiling so reasoning chains and long generations
|
|
* are not truncated.
|
|
*/
|
|
export const MAX_OUTPUT_TOKENS = 131072;
|
|
|
|
/**
|
|
* Fallback context window when the catalog omits `context_config`.
|
|
*
|
|
* Qoder's `/model/list` often ships `max_input_tokens` as a stale 180K floor
|
|
* even for models that accept 1M-token prompts (verified against global `lite`
|
|
* through 1,000K tokens). When `context_config` is present we use its largest
|
|
* `token_count` instead, so models that truly advertise 200K/256K stay there.
|
|
*/
|
|
export const DEFAULT_CONTEXT_WINDOW = 1000000;
|
|
|
|
/** Shape of a single entry returned by the Qoder /model/list endpoint. */
|
|
export interface QoderModelEntry {
|
|
key?: string;
|
|
enable?: boolean;
|
|
display_name?: string;
|
|
max_input_tokens?: number;
|
|
context_config?: Record<string, { token_count?: number; is_default?: boolean }>;
|
|
is_vl?: boolean;
|
|
is_reasoning?: boolean;
|
|
thinking_config?: {
|
|
disabled?: unknown;
|
|
enabled?: { efforts?: Record<string, { is_default?: boolean }>; is_default?: boolean };
|
|
};
|
|
source?: string;
|
|
[key: string]: unknown;
|
|
}
|
|
|
|
export interface QoderModelDef {
|
|
id: string;
|
|
upstreamKey?: string;
|
|
name: string;
|
|
api: "qoder-api";
|
|
provider: "qoder" | "qoder-cn";
|
|
baseUrl: string;
|
|
reasoning: boolean;
|
|
supportsEffort: boolean;
|
|
thinkingLevelMap?: ThinkingLevelMap;
|
|
input: ("text" | "image")[];
|
|
cost: typeof ZERO_COST;
|
|
contextWindow: number;
|
|
maxTokens: number;
|
|
description?: string;
|
|
}
|
|
|
|
function getHomeDir(): string {
|
|
// Prefer process.env.HOME so vitest setup can isolate caches. Node 26+ caches
|
|
// os.homedir() from process start, ignoring later HOME changes.
|
|
return process.env.HOME || process.env.USERPROFILE || homedir();
|
|
}
|
|
|
|
function getQoderCachePath(mode: QoderMode): string {
|
|
return join(getHomeDir(), ".pi", "agent", getQoderRegionConfig(mode).modelCacheFile);
|
|
}
|
|
|
|
interface ParsedModelCache {
|
|
updatedAt?: number;
|
|
models?: QoderModelDef[];
|
|
configs?: Record<string, QoderModelEntry>;
|
|
}
|
|
|
|
/** In-memory cache keyed by absolute cache path (HOME-safe across tests). */
|
|
const modelCacheMem = new Map<string, ParsedModelCache | null>();
|
|
|
|
/** Clear process-memory model caches (also used by tests that mutate cache files). */
|
|
export function clearQoderModelsMemCache(): void {
|
|
modelCacheMem.clear();
|
|
}
|
|
|
|
function readParsedModelCache(mode: QoderMode): ParsedModelCache | null {
|
|
const cachePath = getQoderCachePath(mode);
|
|
if (modelCacheMem.has(cachePath)) {
|
|
return modelCacheMem.get(cachePath) ?? null;
|
|
}
|
|
if (!existsSync(cachePath)) {
|
|
modelCacheMem.set(cachePath, null);
|
|
return null;
|
|
}
|
|
try {
|
|
const data = JSON.parse(readFileSync(cachePath, "utf8")) as ParsedModelCache;
|
|
modelCacheMem.set(cachePath, data);
|
|
return data;
|
|
} catch {
|
|
modelCacheMem.set(cachePath, null);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function writeParsedModelCache(mode: QoderMode, data: ParsedModelCache): void {
|
|
const cachePath = getQoderCachePath(mode);
|
|
mkdirSync(dirname(cachePath), { recursive: true });
|
|
writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
|
|
modelCacheMem.set(cachePath, data);
|
|
}
|
|
|
|
/**
|
|
* Derive the only public model id from Qoder's display name.
|
|
* The upstream key remains available solely inside the matching config entry.
|
|
*/
|
|
export function toQoderModelId(displayName?: string): string {
|
|
return (displayName || "QoderModel").replace(/\s+/g, "");
|
|
}
|
|
|
|
export const staticModels: QoderModelDef[] = [
|
|
{
|
|
id: "Auto",
|
|
upstreamKey: "auto",
|
|
name: "Auto",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: true,
|
|
supportsEffort: false,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "Ultimate",
|
|
upstreamKey: "ultimate",
|
|
name: "Ultimate",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: true,
|
|
supportsEffort: true,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "Performance",
|
|
upstreamKey: "performance",
|
|
name: "Performance",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: true,
|
|
supportsEffort: true,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "Efficient",
|
|
upstreamKey: "efficient",
|
|
name: "Efficient",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: false,
|
|
supportsEffort: false,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "Lite",
|
|
upstreamKey: "lite",
|
|
name: "Lite",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: false,
|
|
supportsEffort: false,
|
|
input: ["text"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "Qwen3.7Plus",
|
|
upstreamKey: "qmodel",
|
|
name: "Qwen3.7 Plus",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: false,
|
|
supportsEffort: false,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "Cantus",
|
|
upstreamKey: "cmodel",
|
|
name: "Cantus",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: true,
|
|
supportsEffort: true,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "Qwen3.8-Max",
|
|
upstreamKey: "qmodel_preview",
|
|
name: "Qwen3.8-Max",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: true,
|
|
supportsEffort: true,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "Qwen3.7-Max",
|
|
upstreamKey: "qmodel_latest",
|
|
name: "Qwen3.7-Max",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: false,
|
|
supportsEffort: false,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "DeepSeek-V4-Pro",
|
|
upstreamKey: "dmodel",
|
|
name: "DeepSeek-V4-Pro",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: true,
|
|
supportsEffort: true,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "DeepSeek-V4-Flash",
|
|
upstreamKey: "dfmodel",
|
|
name: "DeepSeek-V4-Flash",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: true,
|
|
supportsEffort: true,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "GLM-5.2",
|
|
upstreamKey: "gm51model",
|
|
name: "GLM-5.2",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: true,
|
|
supportsEffort: true,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "Kimi-K2.7-Code",
|
|
upstreamKey: "kmodel",
|
|
name: "Kimi-K2.7-Code",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: false,
|
|
supportsEffort: false,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
// Catalog advertises 256K; not included in the 1M live test in issue #13.
|
|
contextWindow: 256000,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "Kimi-K3",
|
|
upstreamKey: "kmodel_latest",
|
|
name: "Kimi-K3",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: false,
|
|
supportsEffort: false,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
{
|
|
id: "MiniMax-M3",
|
|
upstreamKey: "mmodel",
|
|
name: "MiniMax-M3",
|
|
api: "qoder-api",
|
|
provider: "qoder",
|
|
baseUrl: getQoderBaseUrl("global"),
|
|
reasoning: false,
|
|
supportsEffort: false,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
},
|
|
];
|
|
|
|
export const staticCnModels: QoderModelDef[] = [
|
|
{
|
|
id: "Auto",
|
|
upstreamKey: "auto",
|
|
name: "Auto",
|
|
api: "qoder-api",
|
|
provider: "qoder-cn",
|
|
baseUrl: getQoderBaseUrl("cn"),
|
|
reasoning: true,
|
|
supportsEffort: false,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
// CN Auto has not been live-tested at 1M; keep the conservative 200K
|
|
// fallback until the CN catalog advertises a larger option.
|
|
contextWindow: 200000,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
description: "Qoder CN smart routing; fallback context window of 200K.",
|
|
},
|
|
{
|
|
id: "Qwen3.7-Max",
|
|
upstreamKey: "qmodel_latest",
|
|
name: "Qwen3.7-Max",
|
|
api: "qoder-api",
|
|
provider: "qoder-cn",
|
|
baseUrl: getQoderBaseUrl("cn"),
|
|
reasoning: true,
|
|
supportsEffort: false,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
description: "Qoder CN qmodel_latest; context options 200K/400K/1M.",
|
|
},
|
|
{
|
|
id: "Qwen3.7-Plus",
|
|
upstreamKey: "qmodel",
|
|
name: "Qwen3.7-Plus",
|
|
api: "qoder-api",
|
|
provider: "qoder-cn",
|
|
baseUrl: getQoderBaseUrl("cn"),
|
|
reasoning: true,
|
|
supportsEffort: false,
|
|
input: ["text"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
description: "Qoder CN qmodel; context options 200K/400K/1M.",
|
|
},
|
|
{
|
|
id: "Qwen3.6-Flash",
|
|
upstreamKey: "q36fmodel",
|
|
name: "Qwen3.6-Flash",
|
|
api: "qoder-api",
|
|
provider: "qoder-cn",
|
|
baseUrl: getQoderBaseUrl("cn"),
|
|
reasoning: true,
|
|
supportsEffort: false,
|
|
input: ["text"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
description: "Qoder CN q36fmodel; context options 200K/400K/1M.",
|
|
},
|
|
{
|
|
id: "DeepSeek-V4-Pro",
|
|
upstreamKey: "dmodel",
|
|
name: "DeepSeek-V4-Pro",
|
|
api: "qoder-api",
|
|
provider: "qoder-cn",
|
|
baseUrl: getQoderBaseUrl("cn"),
|
|
reasoning: true,
|
|
supportsEffort: false,
|
|
input: ["text"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
description: "Qoder CN dmodel; context options 200K/400K/1M.",
|
|
},
|
|
{
|
|
id: "DeepSeek-V4-Flash",
|
|
upstreamKey: "dfmodel",
|
|
name: "DeepSeek-V4-Flash",
|
|
api: "qoder-api",
|
|
provider: "qoder-cn",
|
|
baseUrl: getQoderBaseUrl("cn"),
|
|
reasoning: false,
|
|
supportsEffort: false,
|
|
input: ["text"],
|
|
cost: ZERO_COST,
|
|
contextWindow: DEFAULT_CONTEXT_WINDOW,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
description: "Qoder CN dfmodel; context options 200K/400K/1M.",
|
|
},
|
|
{
|
|
id: "GLM-5.2",
|
|
upstreamKey: "gm51model",
|
|
name: "GLM-5.2",
|
|
api: "qoder-api",
|
|
provider: "qoder-cn",
|
|
baseUrl: getQoderBaseUrl("cn"),
|
|
reasoning: true,
|
|
supportsEffort: false,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
// Live CN catalog currently displays 200K; do not copy global gm51model's 1M.
|
|
contextWindow: 200000,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
description: "Qoder CN gm51model; live catalog currently displays GLM-5.2 with 200K context.",
|
|
},
|
|
{
|
|
id: "Kimi-K2.7-Code",
|
|
upstreamKey: "kmodel",
|
|
name: "Kimi-K2.7-Code",
|
|
api: "qoder-api",
|
|
provider: "qoder-cn",
|
|
baseUrl: getQoderBaseUrl("cn"),
|
|
reasoning: true,
|
|
supportsEffort: false,
|
|
input: ["text", "image"],
|
|
cost: ZERO_COST,
|
|
// Catalog advertises 256K; same as global kmodel.
|
|
contextWindow: 256000,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
description: "Qoder CN kmodel; context option 256K.",
|
|
},
|
|
{
|
|
id: "MiniMax-M2.7",
|
|
upstreamKey: "mmodel",
|
|
name: "MiniMax-M2.7",
|
|
api: "qoder-api",
|
|
provider: "qoder-cn",
|
|
baseUrl: getQoderBaseUrl("cn"),
|
|
reasoning: false,
|
|
supportsEffort: false,
|
|
input: ["text"],
|
|
cost: ZERO_COST,
|
|
// Live CN catalog reports 200K; not confirmed at 1M.
|
|
contextWindow: 200000,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
description: "Qoder CN mmodel; live catalog reports 200K context.",
|
|
},
|
|
];
|
|
|
|
/** pi thinking levels in display order (matches the pi-ai SDK this build targets). */
|
|
const PI_THINKING_LEVELS: readonly ThinkingLevel[] = ["minimal", "low", "medium", "high", "xhigh"];
|
|
|
|
/**
|
|
* Map Qoder's `thinking_config` to pi's `thinkingLevelMap` so the TUI exposes
|
|
* the levels the upstream model actually supports.
|
|
*
|
|
* Qoder has two shapes:
|
|
* - effort-based: `thinking_config.enabled.efforts = { low, medium, xhigh, ... }`
|
|
* Each effort key is already a pi level name, so supported levels map to
|
|
* themselves and the rest are pinned to null (hidden in the picker).
|
|
* `xhigh`/`max` are only shown when the map carries them, otherwise the
|
|
* picker tops out at `high`.
|
|
* - toggle-based: `thinking_config.enabled` without `efforts` (only on/off).
|
|
* Every pi level is exposed and maps to "enabled" so a user picking any
|
|
* level turns thinking on; the exact effort sent upstream is decided at
|
|
* request time.
|
|
* Returns undefined for models that do not support thinking, so pi falls back
|
|
* to `reasoning: false`-style behavior (only `off`).
|
|
*/
|
|
function buildThinkingLevelMap(entry: QoderModelEntry): ThinkingLevelMap | undefined {
|
|
const tc = entry.thinking_config;
|
|
if (!tc) return undefined;
|
|
const efforts = tc.enabled?.efforts;
|
|
if (efforts && typeof efforts === "object") {
|
|
const supported = new Set(Object.keys(efforts));
|
|
// `off` (disable thinking) is selectable when the catalog advertises a
|
|
// `disabled` option; otherwise pin it to null to hide it.
|
|
const map: ThinkingLevelMap = { off: tc.disabled ? "disabled" : null };
|
|
for (const level of PI_THINKING_LEVELS) {
|
|
map[level] = supported.has(level) ? level : null;
|
|
}
|
|
return map;
|
|
}
|
|
// toggle-only (enabled/disabled, no efforts) — expose every level as "on".
|
|
// `off` is selectable when the catalog advertises `disabled`.
|
|
if (tc.enabled) {
|
|
const map: ThinkingLevelMap = { off: tc.disabled ? "disabled" : null };
|
|
for (const level of PI_THINKING_LEVELS) {
|
|
map[level] = "enabled";
|
|
}
|
|
return map;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
export function getCachedModels(mode: QoderMode): QoderModelDef[] {
|
|
const data = readParsedModelCache(mode);
|
|
if (data && Array.isArray(data.models)) {
|
|
const models = data.models.map((model: QoderModelDef) => {
|
|
const config = data.configs?.[model.id] as QoderModelEntry | undefined;
|
|
const display = config?.display_name;
|
|
const staticModel = (mode === "cn" ? staticCnModels : staticModels).find((seed) => seed.upstreamKey === model.id);
|
|
if (display) return { ...model, id: toQoderModelId(display), name: display };
|
|
if (staticModel) return { ...model, id: staticModel.id, name: staticModel.name };
|
|
return model.name ? { ...model, id: toQoderModelId(model.name) } : model;
|
|
});
|
|
// Older releases injected `auto` without a corresponding service config.
|
|
// Keep an explicitly enabled service model, but drop the legacy fallback.
|
|
if (data.configs && typeof data.configs === "object" && !data.configs.auto) {
|
|
return models.filter((model: QoderModelDef) => model.id.toLowerCase() !== "auto");
|
|
}
|
|
return models;
|
|
}
|
|
return mode === "cn" ? staticCnModels : staticModels;
|
|
}
|
|
|
|
export function getCachedModelConfig(modelId: string, mode: QoderMode): QoderModelEntry | null {
|
|
const data = readParsedModelCache(mode);
|
|
if (data) {
|
|
const direct = data.configs?.[modelId] as QoderModelEntry | undefined;
|
|
if (direct && toQoderModelId(direct.display_name) === modelId) {
|
|
return withMaxContextAsDefault(direct);
|
|
}
|
|
|
|
// Read old cache shapes without preserving their raw-key aliases.
|
|
const legacyEntry = Object.values(data.configs || {}).find(
|
|
(entry) =>
|
|
entry && typeof entry === "object" && toQoderModelId((entry as QoderModelEntry).display_name) === modelId,
|
|
) as QoderModelEntry | undefined;
|
|
if (legacyEntry) {
|
|
return withMaxContextAsDefault(legacyEntry);
|
|
}
|
|
}
|
|
|
|
const staticModel = (mode === "cn" ? staticCnModels : staticModels).find((model) => model.id === modelId);
|
|
if (staticModel) {
|
|
return {
|
|
key: staticModel.upstreamKey || modelId,
|
|
is_reasoning: staticModel.reasoning,
|
|
source: "system",
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/** Resolve contextWindow from a catalog entry. Exported for tests. */
|
|
export function contextWindowFromCatalog(entry: QoderModelEntry): number {
|
|
const contextConfig = entry.context_config;
|
|
if (contextConfig && typeof contextConfig === "object") {
|
|
let advertised = 0;
|
|
for (const configVal of Object.values(contextConfig)) {
|
|
if (configVal && typeof configVal === "object" && typeof configVal.token_count === "number") {
|
|
if (configVal.token_count > advertised) advertised = configVal.token_count;
|
|
}
|
|
}
|
|
if (advertised > 0) return advertised;
|
|
}
|
|
return DEFAULT_CONTEXT_WINDOW;
|
|
}
|
|
|
|
/** Prefer the largest context option when Qoder exposes selectable contexts. */
|
|
function withMaxContextAsDefault(entry: QoderModelEntry): QoderModelEntry {
|
|
const contextConfig = entry.context_config;
|
|
if (!contextConfig || typeof contextConfig !== "object") return entry;
|
|
|
|
const maxTokenCount = Math.max(
|
|
...Object.values(contextConfig).map((config) => (typeof config?.token_count === "number" ? config.token_count : 0)),
|
|
);
|
|
if (maxTokenCount <= 0) return entry;
|
|
|
|
return {
|
|
...entry,
|
|
context_config: Object.fromEntries(
|
|
Object.entries(contextConfig).map(([name, config]) => [
|
|
name,
|
|
{ ...config, is_default: config.token_count === maxTokenCount },
|
|
]),
|
|
),
|
|
};
|
|
}
|
|
|
|
export function isCacheStale(mode: QoderMode): boolean {
|
|
const data = readParsedModelCache(mode);
|
|
if (!data || typeof data.updatedAt !== "number") return true;
|
|
// Stale if older than 1 hour
|
|
return Date.now() - data.updatedAt > 3600_000;
|
|
}
|
|
|
|
export async function updateQoderModelsCache(
|
|
authToken: string,
|
|
userID: string,
|
|
name: string,
|
|
email: string,
|
|
mode: QoderMode,
|
|
): Promise<void> {
|
|
const modelListURL = getQoderModelListURL(mode);
|
|
try {
|
|
const headers = buildAuthHeaders(null, modelListURL, {
|
|
userID,
|
|
authToken,
|
|
name,
|
|
email,
|
|
});
|
|
|
|
const response = await fetch(modelListURL, {
|
|
method: "GET",
|
|
headers: {
|
|
Accept: "application/json",
|
|
...headers,
|
|
},
|
|
});
|
|
|
|
if (!response.ok) {
|
|
return;
|
|
}
|
|
|
|
const resData = (await response.json()) as { chat?: QoderModelEntry[] };
|
|
const chatModels = resData.chat || [];
|
|
if (chatModels.length === 0) return;
|
|
|
|
const newModels: QoderModelDef[] = [];
|
|
const configs: Record<string, QoderModelEntry> = {};
|
|
|
|
for (const entry of chatModels) {
|
|
const key = entry.key;
|
|
if (!key || !entry.enable || !entry.display_name) continue;
|
|
|
|
const display = entry.display_name;
|
|
// Prefer the largest selectable context option the catalog advertises
|
|
// (e.g. 1M when 200K/400K/1M are offered). If none is advertised, use
|
|
// DEFAULT_CONTEXT_WINDOW rather than the stale 180K `max_input_tokens`
|
|
// floor. Do not seed from DEFAULT_CONTEXT_WINDOW before scanning
|
|
// context_config: that would inflate models that only advertise 200K.
|
|
const ctxLen = contextWindowFromCatalog(entry);
|
|
const isVL = !!entry.is_vl;
|
|
const isReasoning = !!entry.is_reasoning || !!entry.thinking_config;
|
|
const supportsEffort = !!entry.thinking_config?.enabled?.efforts;
|
|
const thinkingLevelMap = buildThinkingLevelMap(entry);
|
|
// Both regions expose display_name (whitespace-stripped) as the sole
|
|
// pi-visible id. The config stores the upstream key under that id for
|
|
// request-time use.
|
|
const modelInfo = { id: toQoderModelId(display), name: display };
|
|
|
|
configs[modelInfo.id] = entry;
|
|
|
|
newModels.push({
|
|
id: modelInfo.id,
|
|
name: modelInfo.name,
|
|
api: "qoder-api",
|
|
provider: getQoderRegionConfig(mode).providerID,
|
|
baseUrl: getQoderBaseUrl(mode),
|
|
reasoning: isReasoning,
|
|
supportsEffort,
|
|
thinkingLevelMap,
|
|
input: isVL ? ["text", "image"] : ["text"],
|
|
cost: ZERO_COST,
|
|
contextWindow: ctxLen,
|
|
maxTokens: MAX_OUTPUT_TOKENS,
|
|
});
|
|
}
|
|
|
|
if (newModels.length === 0) return;
|
|
|
|
const cacheData = {
|
|
updatedAt: Date.now(),
|
|
models: newModels,
|
|
configs,
|
|
};
|
|
|
|
writeParsedModelCache(mode, cacheData);
|
|
} catch {}
|
|
}
|