@cartanova/qgrid-cli 2.10.10 → 2.11.1

package/bundle/dist/utils/providers/grok/grok-models.js

@@ -0,0 +1,114 @@
+import { GROK_REASONING_EFFORTS, GROK_SEED_MODELS } from "./grok-constants.js";
+import { grokProxyGet } from "./grok-direct-client.js";
+import { buildGrokProxyGetHeaders } from "./grok-headers.js";
+import { GrokModelsResponse } from "./grok-types.js";
+//#region src/utils/providers/grok/grok-models.ts
+function isGrokEffort(value) {
+	return GROK_REASONING_EFFORTS.some((effort) => effort === value);
+}
+/** Strips the qgrid route prefix; an empty id means the default model. */
+function canonicalGrokModelId(modelId) {
+	return ((modelId ?? "").startsWith("grok/") ? (modelId ?? "").slice(5) : modelId ?? "") || "grok-4.7";
+}
+function fromProxyModel(model) {
+	if (model.api_backend !== "responses") return void 0;
+	const listed = (model.reasoning_efforts ?? []).map((entry) => entry.value).filter(isGrokEffort);
+	const efforts = listed.length ? listed : GROK_REASONING_EFFORTS;
+	const defaultEffort = [
+		model.reasoning_efforts?.find((entry) => entry.default)?.value,
+		model.reasoning_effort ?? void 0,
+		"high"
+	].find((value) => value !== void 0 && isGrokEffort(value) && efforts.includes(value)) ?? efforts[0];
+	return {
+		id: model.id,
+		contextWindow: model.context_window,
+		efforts,
+		defaultEffort,
+		known: true
+	};
+}
+/**
+* Model catalog seeded from the U0 capture and merged with live `GET {proxy}/models`. Like the
+* OpenAI runtime, it never rejects an id: an unlisted id is forwarded and the upstream decides.
+*/
+var GrokModelCatalog = class {
+	models = /* @__PURE__ */ new Map();
+	etag;
+	refreshedAt;
+	pendingRefresh;
+	constructor() {
+		for (const seed of GROK_SEED_MODELS) this.models.set(seed.id, {
+			id: seed.id,
+			contextWindow: seed.contextWindow,
+			efforts: seed.reasoningEfforts,
+			defaultEffort: seed.defaultEffort,
+			known: true
+		});
+	}
+	/** True when a response advertised a catalog etag different from the one last merged. */
+	isStale(observedEtag) {
+		return observedEtag !== void 0 && observedEtag !== this.etag;
+	}
+	/** Single-flight refresh. Live entries replace seeds; seeds absent from the live list stay. */
+	async refresh(credentials, options = {}) {
+		this.pendingRefresh ??= this.refreshNow(credentials, options).finally(() => {
+			this.pendingRefresh = void 0;
+		});
+		return this.pendingRefresh;
+	}
+	async refreshNow(credentials, options) {
+		try {
+			const getOptions = { headers: buildGrokProxyGetHeaders({
+				bearer: credentials.accessToken,
+				userId: credentials.userId
+			}) };
+			if (options.fetch) getOptions.fetch = options.fetch;
+			if (options.signal) getOptions.signal = options.signal;
+			if (options.baseUrl) getOptions.baseUrl = options.baseUrl;
+			const { json, headers } = await grokProxyGet("/models", getOptions);
+			const parsed = GrokModelsResponse.safeParse(json);
+			if (!parsed.success) return {
+				kind: "lookup_failed",
+				reason: `unexpected /models shape: ${parsed.error.message}`
+			};
+			const merged = [];
+			for (const entry of parsed.data.data) {
+				const model = fromProxyModel(entry);
+				if (!model) continue;
+				this.models.set(model.id, model);
+				merged.push(model.id);
+			}
+			this.etag = headers.modelsEtag;
+			this.refreshedAt = options.now ?? Date.now();
+			return {
+				kind: "ok",
+				models: merged,
+				etag: this.etag
+			};
+		} catch (error) {
+			return {
+				kind: "lookup_failed",
+				reason: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+	resolve(modelId) {
+		const id = canonicalGrokModelId(modelId);
+		return this.models.get(id) ?? {
+			id,
+			contextWindow: void 0,
+			efforts: GROK_REASONING_EFFORTS,
+			defaultEffort: "high",
+			known: false
+		};
+	}
+	/** The effort if the model accepts it, otherwise undefined. Unlisted ids accept every effort. */
+	validateEffort(modelId, effort) {
+		const model = this.resolve(modelId);
+		return isGrokEffort(effort) && model.efforts.includes(effort) ? effort : void 0;
+	}
+};
+//#endregion
+export { GrokModelCatalog, canonicalGrokModelId };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"grok-models.js","names":[],"sources":["../../../../src/utils/providers/grok/grok-models.ts"],"sourcesContent":["import {\n  GROK_DEFAULT_MODEL,\n  GROK_REASONING_EFFORTS,\n  GROK_SEED_MODELS,\n  type GrokReasoningEffort,\n} from \"./grok-constants\";\nimport { grokProxyGet } from \"./grok-direct-client\";\nimport { buildGrokProxyGetHeaders } from \"./grok-headers\";\nimport { GrokModelsResponse, type GrokCredentials, type GrokProxyModel } from \"./grok-types\";\n\nexport interface GrokResolvedModel {\n  id: string;\n  /** Undefined for an unlisted id; the response `x-grok-context-window` header may fill it. */\n  contextWindow: number | undefined;\n  efforts: readonly GrokReasoningEffort[];\n  defaultEffort: GrokReasoningEffort;\n  /** False when the id is in neither the seed nor the live catalog and is forwarded as-is. */\n  known: boolean;\n}\n\nfunction isGrokEffort(value: string): value is GrokReasoningEffort {\n  return GROK_REASONING_EFFORTS.some((effort) => effort === value);\n}\n\n/** Strips the qgrid route prefix; an empty id means the default model. */\nexport function canonicalGrokModelId(modelId: string | undefined): string {\n  const stripped = (modelId ?? \"\").startsWith(\"grok/\") ? (modelId ?? \"\").slice(5) : (modelId ?? \"\");\n\n  return stripped || GROK_DEFAULT_MODEL;\n}\n\nfunction fromProxyModel(model: GrokProxyModel): GrokResolvedModel | undefined {\n  if (model.api_backend !== \"responses\") return undefined;\n  const listed = (model.reasoning_efforts ?? []).map((entry) => entry.value).filter(isGrokEffort);\n  const efforts: readonly GrokReasoningEffort[] = listed.length ? listed : GROK_REASONING_EFFORTS;\n  const flagged = model.reasoning_efforts?.find((entry) => entry.default)?.value;\n  const candidates = [flagged, model.reasoning_effort ?? undefined, \"high\"];\n\n  const defaultEffort =\n    candidates.find(\n      (value): value is GrokReasoningEffort =>\n        value !== undefined && isGrokEffort(value) && efforts.includes(value),\n    ) ?? efforts[0]!;\n\n  return { id: model.id, contextWindow: model.context_window, efforts, defaultEffort, known: true };\n}\n\nexport type GrokModelRefreshResult =\n  | { kind: \"ok\"; models: string[]; etag: string | undefined }\n  | { kind: \"lookup_failed\"; reason: string };\n\n/**\n * Model catalog seeded from the U0 capture and merged with live `GET {proxy}/models`. Like the\n * OpenAI runtime, it never rejects an id: an unlisted id is forwarded and the upstream decides.\n */\nexport class GrokModelCatalog {\n  readonly models = new Map<string, GrokResolvedModel>();\n  etag: string | undefined;\n  refreshedAt: number | undefined;\n  pendingRefresh: Promise<GrokModelRefreshResult> | undefined;\n\n  constructor() {\n    for (const seed of GROK_SEED_MODELS) {\n      this.models.set(seed.id, {\n        id: seed.id,\n        contextWindow: seed.contextWindow,\n        efforts: seed.reasoningEfforts,\n        defaultEffort: seed.defaultEffort,\n        known: true,\n      });\n    }\n  }\n\n  /** True when a response advertised a catalog etag different from the one last merged. */\n  isStale(observedEtag: string | undefined): boolean {\n    return observedEtag !== undefined && observedEtag !== this.etag;\n  }\n\n  /** Single-flight refresh. Live entries replace seeds; seeds absent from the live list stay. */\n  async refresh(\n    credentials: Pick<GrokCredentials, \"accessToken\" | \"userId\">,\n    options: { fetch?: typeof fetch; signal?: AbortSignal; baseUrl?: string; now?: number } = {},\n  ): Promise<GrokModelRefreshResult> {\n    this.pendingRefresh ??= this.refreshNow(credentials, options).finally(() => {\n      this.pendingRefresh = undefined;\n    });\n\n    return this.pendingRefresh;\n  }\n\n  async refreshNow(\n    credentials: Pick<GrokCredentials, \"accessToken\" | \"userId\">,\n    options: { fetch?: typeof fetch; signal?: AbortSignal; baseUrl?: string; now?: number },\n  ): Promise<GrokModelRefreshResult> {\n    try {\n      const getOptions: Parameters<typeof grokProxyGet>[1] = {\n        headers: buildGrokProxyGetHeaders({\n          bearer: credentials.accessToken,\n          userId: credentials.userId,\n        }),\n      };\n\n      if (options.fetch) getOptions.fetch = options.fetch;\n\n      if (options.signal) getOptions.signal = options.signal;\n\n      if (options.baseUrl) getOptions.baseUrl = options.baseUrl;\n      const { json, headers } = await grokProxyGet(\"/models\", getOptions);\n\n      const parsed = GrokModelsResponse.safeParse(json);\n\n      if (!parsed.success) {\n        return {\n          kind: \"lookup_failed\",\n          reason: `unexpected /models shape: ${parsed.error.message}`,\n        };\n      }\n\n      const merged: string[] = [];\n\n      for (const entry of parsed.data.data) {\n        const model = fromProxyModel(entry);\n\n        if (!model) continue;\n        this.models.set(model.id, model);\n        merged.push(model.id);\n      }\n\n      this.etag = headers.modelsEtag;\n      this.refreshedAt = options.now ?? Date.now();\n\n      return { kind: \"ok\", models: merged, etag: this.etag };\n    } catch (error) {\n      return {\n        kind: \"lookup_failed\",\n        reason: error instanceof Error ? error.message : String(error),\n      };\n    }\n  }\n\n  resolve(modelId: string | undefined): GrokResolvedModel {\n    const id = canonicalGrokModelId(modelId);\n\n    return (\n      this.models.get(id) ?? {\n        id,\n        contextWindow: undefined,\n        efforts: GROK_REASONING_EFFORTS,\n        defaultEffort: \"high\",\n        known: false,\n      }\n    );\n  }\n\n  /** The effort if the model accepts it, otherwise undefined. Unlisted ids accept every effort. */\n  validateEffort(modelId: string | undefined, effort: string): GrokReasoningEffort | undefined {\n    const model = this.resolve(modelId);\n\n    return isGrokEffort(effort) && model.efforts.includes(effort) ? effort : undefined;\n  }\n}\n"],"mappings":"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"}