openclaw/dist/commands/status.summary.runtime.js

Multi-channel AI gateway with extensible messaging integrations

import { c as normalizeOptionalLowercaseString, l as normalizeOptionalString, o as normalizeLowercaseStringOrEmpty } from "../string-coerce-1VuiLaaR.mjs";
import { t as createLazyImportLoader } from "../lazy-promise-DGqyc4Y4.mjs";
import { C as tryResolveAmbientOwnerAgentId, r as resolveAgentConfig } from "../agent-scope-config-BEk6-ThS.mjs";
import { s as resolveAgentModelPrimaryValue } from "../model-input-CeM8o97s.mjs";
import "../defaults-Jag53zwP.mjs";
import { g as resolveConfiguredPrimaryProviderFallback, i as buildModelAliasIndex } from "../model-selection-shared-CHVNQnp1.mjs";
import { n as findModelInCatalog } from "../model-catalog-lookup-_nlJdlgO.mjs";
import { n as parseModelRef } from "../model-selection-normalize-B-Anaau2.mjs";
import { o as resolveEffectiveAgentRuntime } from "../thinking-runtime-CveqpPq0.mjs";
import { r as resolvePersistedSelectedModelRef } from "../model-selection-Cpoq0B2R.mjs";
import { n as getPreparedModelCatalogSnapshot } from "../prepared-model-catalog-KgiwpXAj.mjs";
import { o as resolveStoredSessionKeyForAgentStore } from "../session-store-key-Dvf3CKvN.mjs";
import { t as classifySessionKind } from "../classify-session-kind-ntGSaMKe.mjs";
import { n as resolveSessionStorePathForAcp } from "../session-meta-store-CUp3yxTU.mjs";
import { n as readAcpSessionMetaForEntry } from "../session-meta-readonly-CDWxL7Mp.mjs";
import "../session-meta-CSN8P5u2.mjs";
import { t as resolveCurrentSessionAgentRuntimeMetadata } from "../agent-runtime-metadata-Ce1GWgqV.mjs";
import { i as resolveContextTokensForModelFromCache, n as resolveAuthoredModelContextTokens } from "../context-resolution-B-tr3K6X.mjs";
import { o as selectModelCatalogRuntimeEntry } from "../model-catalog-view-CRGj0Ybc.mjs";
import { t as resolveModelContextWindowProfile } from "../model-context-window-CoR3Uyg1.mjs";
import { n as resolveAgentRuntimeLabel } from "../agent-runtime-label-A9YUSe9-.mjs";
//#region src/status/summary.runtime.ts
const staticModelCatalogResolverLoader = createLazyImportLoader(async () => {
	const modelCatalog = await import("../model.static-catalog-DCEEkZKX.mjs");
	return {
		resolveManifestModel: modelCatalog.createBundledStaticCatalogModelResolver({ includeRuntimeDiscovery: true }),
		createProviderContextResolver: modelCatalog.createBundledProviderStaticCatalogContextResolver
	};
});
async function createStatusModelContextResolver(cfg) {
	const { resolveManifestModel, createProviderContextResolver } = await staticModelCatalogResolverLoader.load();
	const resolveProviderContext = createProviderContextResolver({ cfg });
	const modelContextCache = /* @__PURE__ */ new Map();
	return async (provider, model, agentId, runtimeId = "openclaw", sessionEntry) => {
		if (!provider || !model) return {};
		const ownerAgentId = agentId ?? tryResolveAmbientOwnerAgentId(cfg);
		const catalog = ownerAgentId ? getPreparedModelCatalogSnapshot({
			config: cfg,
			agentId: ownerAgentId,
			workspaceDir: sessionEntry?.spawnedWorkspaceDir
		}) : void 0;
		if (catalog) {
			const logicalEntry = findModelInCatalog(catalog.entries, provider, model);
			const entry = logicalEntry && selectModelCatalogRuntimeEntry({
				entry: logicalEntry,
				routeVariants: catalog.routeVariants,
				runtimeId,
				allowApiFallback: false
			}).entry;
			return {
				modelContextWindow: resolveModelContextWindowProfile({
					catalogEntry: entry,
					selected: sessionEntry?.contextWindow
				}).contextTokens,
				modelContextTokens: entry?.contextTokens
			};
		}
		if (runtimeId !== "openclaw" && runtimeId !== "auto" && runtimeId !== provider) return {};
		const key = `${provider}\0${model}`;
		const cached = modelContextCache.get(key);
		if (cached) return cached;
		const resolved = (async () => {
			try {
				const entry = resolveManifestModel({
					provider,
					modelId: model
				}) ?? await resolveProviderContext({
					provider,
					modelId: model
				});
				return {
					...entry?.contextWindow ? { modelContextWindow: entry.contextWindow } : {},
					...entry?.contextTokens ? { modelContextTokens: entry.contextTokens } : {}
				};
			} catch {
				return {};
			}
		})();
		modelContextCache.set(key, resolved);
		return resolved;
	};
}
function resolveStatusModelRefFromRaw(params) {
	const trimmed = params.rawModel.trim();
	if (!trimmed) return null;
	if (!trimmed.includes("/")) return buildModelAliasIndex({
		cfg: params.cfg,
		agentId: params.agentId,
		defaultProvider: params.defaultProvider,
		allowManifestNormalization: false,
		allowPluginNormalization: false,
		manifestPlugins: []
	}).byAlias.get(normalizeLowercaseStringOrEmpty(trimmed))?.ref ?? {
		provider: params.defaultProvider,
		model: trimmed
	};
	return parseModelRef(trimmed, params.defaultProvider, {
		allowManifestNormalization: false,
		allowPluginNormalization: false
	});
}
function resolveConfiguredStatusModelRef(params) {
	const agentRawModel = params.agentId ? resolveAgentModelPrimaryValue(resolveAgentConfig(params.cfg, params.agentId)?.model) : void 0;
	for (const rawModel of [agentRawModel, resolveAgentModelPrimaryValue(params.cfg.agents?.defaults?.model)]) if (rawModel) {
		const parsed = resolveStatusModelRefFromRaw({
			cfg: params.cfg,
			rawModel,
			defaultProvider: params.defaultProvider,
			agentId: params.agentId
		});
		if (parsed) return parsed;
	}
	const fallbackProvider = resolveConfiguredPrimaryProviderFallback({
		cfg: params.cfg,
		agentId: params.agentId,
		defaultProvider: params.defaultProvider,
		defaultModel: params.defaultModel,
		allowManifestNormalization: false,
		allowPluginNormalization: false
	});
	if (fallbackProvider) return fallbackProvider;
	return {
		provider: params.defaultProvider,
		model: params.defaultModel
	};
}
function resolveProviderlessPersistedStatusModelRef(params) {
	const provider = normalizeOptionalString(params.provider);
	const model = normalizeOptionalString(params.model);
	if (!model || provider || model.includes("/") || normalizeLowercaseStringOrEmpty(model) === "openrouter:auto") return null;
	return {
		provider: params.defaultProvider,
		model
	};
}
function resolveStatusModelLookupRef(params) {
	const provider = normalizeOptionalString(params.provider);
	const model = normalizeOptionalString(params.model);
	if (!model) return null;
	const defaultProvider = normalizeOptionalString(params.defaultProvider) ?? provider ?? "openai";
	const raw = provider ? `${provider}/${model}` : model;
	return parseModelRef(raw, defaultProvider, {
		allowManifestNormalization: false,
		allowPluginNormalization: false
	}) ?? {
		provider: provider ?? defaultProvider,
		model
	};
}
function resolveStatusModelComparisonLabel(params) {
	const ref = resolveStatusModelLookupRef(params);
	return ref ? `${ref.provider}/${ref.model}` : null;
}
function resolveSessionModelRef(resolved, entry) {
	const defaultProvider = resolved.provider || "openai";
	const providerlessPersisted = resolveProviderlessPersistedStatusModelRef({
		defaultProvider,
		provider: entry?.providerOverride,
		model: entry?.modelOverride
	}) ?? resolveProviderlessPersistedStatusModelRef({
		defaultProvider,
		provider: entry?.modelProvider,
		model: entry?.model
	});
	if (providerlessPersisted) return providerlessPersisted;
	return resolvePersistedSelectedModelRef({
		defaultProvider,
		runtimeProvider: entry?.modelProvider,
		runtimeModel: entry?.model,
		overrideProvider: entry?.providerOverride,
		overrideModel: entry?.modelOverride,
		allowManifestNormalization: false,
		allowPluginNormalization: false
	}) ?? resolved;
}
function resolveSessionRuntime(params) {
	const acpSessionKey = params.agentId ? resolveStoredSessionKeyForAgentStore({
		cfg: params.cfg,
		agentId: params.agentId,
		sessionKey: params.sessionKey
	}) : params.sessionKey;
	const { agentId: acpAgentId } = resolveSessionStorePathForAcp({
		cfg: params.cfg,
		sessionKey: acpSessionKey
	});
	const acpMeta = readAcpSessionMetaForEntry({
		cfg: params.cfg,
		sessionKey: acpSessionKey,
		agentId: acpAgentId,
		entry: params.entry
	});
	const runtime = resolveCurrentSessionAgentRuntimeMetadata({
		cfg: params.cfg,
		agentId: params.agentId ?? acpAgentId,
		provider: params.provider,
		model: params.model,
		sessionKey: acpSessionKey,
		sessionEntry: params.entry,
		acpRuntime: acpMeta != null,
		acpBackend: acpMeta?.backend
	});
	const id = normalizeOptionalLowercaseString(runtime.id === "auto" ? resolveEffectiveAgentRuntime({
		cfg: params.cfg,
		agentId: params.agentId ?? acpAgentId,
		provider: params.provider,
		modelId: params.model,
		sessionKey: acpSessionKey,
		sessionEntry: params.entry
	}) : runtime.id);
	const resolvedHarness = id && id !== "openclaw" && id !== "auto" ? id : void 0;
	return {
		id,
		label: resolveAgentRuntimeLabel({
			config: params.cfg,
			sessionEntry: params.entry,
			resolvedHarness,
			fallbackProvider: params.provider
		})
	};
}
const statusSummaryRuntime = {
	createStatusModelContextResolver,
	resolveAuthoredModelContextTokens,
	resolveContextTokensForModel: resolveContextTokensForModelFromCache,
	classifySessionKey: classifySessionKind,
	resolveSessionModelRef,
	resolveSessionRuntime,
	resolveConfiguredStatusModelRef,
	resolveStatusModelLookupRef,
	resolveStatusModelComparisonLabel
};
//#endregion
export { statusSummaryRuntime };