openclaw/dist/chat-metadata-session-projection-CeMkdpON.mjs

Multi-channel AI gateway with extensible messaging integrations

import { r as truncateUtf16Safe } from "./utf16-slice-D_ngcYKd.mjs";
import { r as assertExistingDatabaseIdentity } from "./sqlite-worker-identity-BRNRpRyc.mjs";
import { n as normalizeAgentId } from "./agent-id-D1-Q6vR4.mjs";
import "./session-key-DY3MOX4N.mjs";
import { t as captureOpenClawStateReadContext } from "./openclaw-state-worker-context-BvvgY6-t.mjs";
import { i as resolveSessionAuthProfileOverrideSource, r as resolveCollapsedSessionAuthPinSource } from "./auth-profile-override-provenance-Jztnei-C.mjs";
import { v as isUserModelAuthProfileId, y as parseUserModelAuthProfileId } from "./profile-usage-stats-DpmWbjlU.mjs";
import { N as captureUserProfileAuthorityRead, P as captureUserProfileModelAccountLinksAuthority, q as readUserProfileVersion } from "./user-profiles-internal-B_G1rF82.mjs";
import { o as getPreparedModelRuntimeAuthMaterializations } from "./prepared-model-runtime-auth-DKS2l7Wv.mjs";
import { n as PreparedModelRuntimePublicationSupersededError } from "./prepared-model-runtime.errors-UvN8VA9R.mjs";
import { n as withCurrentReadAuthority, t as settleCurrentReadPreparations } from "./current-read-authority-CySCga_Z.mjs";
import { t as readAcpSessionMetaForEntries } from "./session-meta-readonly-CDWxL7Mp.mjs";
import { r as resolveSessionModelRef } from "./session-model-ref-CS-wdkCn.mjs";
import { n as readSessionRuntimeOwnership } from "./session-utils-model-selection-CfgNTTco.mjs";
import { i as resolveGatewaySessionRuntimeSelectionLocked } from "./session-utils-projection-FyMCsaP_.mjs";
import { o as readUserModelAccountSelectionAsync } from "./user-model-account-operations-D1BrNlr_.mjs";
import { toUSVString } from "node:util";
//#region src/gateway/server-methods/chat-account-selection.ts
async function prepareChatAccountSelection(params) {
	const requesterProfileId = params.readRequesterProfileId ? params.readRequesterProfileId() : params.requesterProfileId;
	const authProfileId = params.sessionEntry?.authProfileOverride?.trim();
	let personal;
	let ownerDisplayName;
	let isCurrent;
	if (authProfileId && isUserModelAuthProfileId(authProfileId)) {
		const { admission } = captureOpenClawStateReadContext();
		const linksCurrent = requesterProfileId ? captureUserProfileModelAccountLinksAuthority(admission, requesterProfileId) : void 0;
		const authority = await captureUserProfileAuthorityRead(admission);
		const displayVersion = readUserProfileVersion();
		const selection = await readUserModelAccountSelectionAsync({
			profileId: requesterProfileId,
			authProfileId
		}, { path: admission.databasePath });
		personal = selection?.personal;
		ownerDisplayName = selection?.owner?.displayName;
		const locator = parseUserModelAuthProfileId(authProfileId);
		const identityCurrent = authority.bind([
			requesterProfileId,
			locator?.ownerProfileId,
			selection?.owner?.profileId
		].filter((id) => id !== void 0));
		isCurrent = () => {
			if (admission.identity.key.startsWith("file:")) assertExistingDatabaseIdentity(admission.databasePath, admission.identity.key, admission.identity.birthtime);
			return Boolean(identityCurrent?.()) && linksCurrent?.() !== false && readUserProfileVersion() === displayVersion;
		};
	}
	return () => {
		if (isCurrent?.() === false || params.sessionEntry?.authProfileOverride?.trim() !== authProfileId || params.readRequesterProfileId && params.readRequesterProfileId() !== requesterProfileId) throw new PreparedModelRuntimePublicationSupersededError("Personal account changed while preparing its metadata. Retry the request.");
		return resolveChatAccountSelection({
			...params,
			personal,
			ownerDisplayName
		});
	};
}
/** The session owns this preference; it is not a receipt for the account that served a turn. */
function resolveChatAccountSelection(params) {
	const authProfileId = params.sessionEntry?.authProfileOverride?.trim();
	if (!authProfileId) return {
		kind: "automatic",
		label: "Automatic account selection"
	};
	const source = resolveSessionAuthProfileOverrideSource(params.sessionEntry);
	if (!isUserModelAuthProfileId(authProfileId)) {
		const credential = params.authStore.profiles[authProfileId];
		return {
			kind: "shared",
			authProfileId,
			label: truncateUtf16Safe(toUSVString(credential?.displayName?.trim() || authProfileId), 256),
			source
		};
	}
	const personal = params.personal;
	if (personal) return {
		kind: "personal",
		authProfileId,
		label: personal.label,
		source
	};
	const rawDisplayName = params.ownerDisplayName?.trim();
	const displayName = rawDisplayName ? toUSVString(rawDisplayName) : void 0;
	return {
		kind: "personal",
		label: displayName ? truncateUtf16Safe(`${displayName}'s account`, 256) : "Personal account",
		source
	};
}
//#endregion
//#region src/gateway/server-methods/chat-metadata-session-projection.ts
function readPreparedChatMetadata(projection, readParams, config, acpMeta, readAccountSelection) {
	readParams.draftAccountSelection?.assertCurrent();
	const { agent } = projection;
	const metadata = {
		...projection.read(),
		...agent.commands !== void 0 ? { commands: agent.commands } : {},
		swarmEnabled: agent.swarmEnabled,
		accountSelection: readAccountSelection?.() ?? resolveChatAccountSelection({
			authStore: agent.authStore,
			sessionEntry: readParams.sessionEntry
		})
	};
	const projected = metadata.models ? {
		...metadata,
		models: projectSessionModelCatalog(readParams, metadata.models, config)
	} : metadata;
	if (!readParams.sessionKey) return projected;
	return {
		...projected,
		runtimeSelectionLocked: resolveGatewaySessionRuntimeSelectionLocked(readParams.sessionEntry, acpMeta ?? void 0)
	};
}
async function prepareSessionAcpMeta(params, cfg) {
	if (!params.sessionKey) return null;
	const [meta] = await readAcpSessionMetaForEntries({
		cfg,
		entries: [{
			agentId: params.agentId,
			sessionKey: params.sessionKey,
			entry: params.sessionEntry
		}]
	});
	return meta ?? null;
}
async function prepareChatMetadataModelProjection(params) {
	const [{ prepareModelsListResult }, { prepareModelCatalogDecisions }] = await Promise.all([import("./models-list-result-DNp2O-xL.mjs"), import("./model-catalog-decisions-CG8Ke_Vj.mjs")]);
	await withCurrentReadAuthority(params, () => {});
	const snapshot = params.facts.modelCatalog;
	const projector = await prepareModelCatalogDecisions({
		cfg: params.facts.owner.config,
		agentId: params.facts.agentId,
		snapshot,
		metadataSnapshot: params.facts.owner.metadataSnapshot,
		preparedAuthStore: params.facts.authStore,
		accountCatalog: params.facts.owner.accountCatalog,
		requesterProfileId: params.requesterProfileId,
		preparedRuntimeAuthModes: params.facts.authModes,
		preparedRuntimeAuthMaterializations: getPreparedModelRuntimeAuthMaterializations(params.facts.owner),
		pluginRegistry: params.facts.owner.pluginRegistry,
		isCurrent: params.facts.owner.isCurrent,
		observationConfig: params.facts.owner.observationConfig,
		...params.preferredProfileId ? { preferredProfileId: params.preferredProfileId } : {},
		...params.pinnedProfileId ? { pinnedProfileId: params.pinnedProfileId } : {},
		...params.profileProvider ? { profileProvider: params.profileProvider } : {},
		...params.runtimeOverride ? { runtimeOverride: params.runtimeOverride } : {}
	}, params);
	const work = [projector.projectCatalog(params), prepareModelsListResult({
		source: {
			kind: "gateway",
			context: params.context
		},
		agentId: params.facts.agentId,
		params: {
			view: "configured",
			includeDefaultModels: false
		},
		preloadedCatalog: {
			agentId: params.facts.agentId,
			config: params.facts.owner.config,
			snapshot
		},
		preloadedOnly: true,
		preparationAuthority: params,
		catalogProjector: projector
	})];
	const [modelCatalog, readModels] = await settleCurrentReadPreparations(work);
	await withCurrentReadAuthority(params, () => {});
	return {
		modelCatalog,
		read: () => ({ models: readModels.read().models }),
		isCurrent: readModels.isCurrent
	};
}
function resolveSessionCatalogProfiles(sessionEntry, config, agentId) {
	const profileId = sessionEntry?.authProfileOverride?.trim();
	const runtime = sessionEntry?.agentRuntimeOverride?.trim();
	const provider = sessionEntry?.providerOverride ?? (runtime ? resolveSessionModelRef(config, sessionEntry, agentId, { allowPluginNormalization: false }).provider : void 0);
	const context = {
		...provider ? { profileProvider: provider } : {},
		...runtime ? { runtimeOverride: runtime } : {}
	};
	if (!profileId) return context;
	const profileSource = resolveCollapsedSessionAuthPinSource(sessionEntry);
	return {
		preferredProfileId: profileId,
		...context,
		...profileSource === "user" ? { pinnedProfileId: profileId } : {}
	};
}
function sessionProjectionKey(agentId, profiles) {
	return [
		normalizeAgentId(agentId),
		profiles.preferredProfileId ?? "",
		profiles.pinnedProfileId ?? "",
		profiles.profileProvider ?? "",
		profiles.runtimeOverride ?? ""
	].join("\0");
}
function hasSessionCatalogContext(profiles) {
	return profiles.preferredProfileId !== void 0 || profiles.pinnedProfileId !== void 0 || profiles.profileProvider !== void 0 || profiles.runtimeOverride !== void 0;
}
function projectSessionModelCatalog(readParams, models, config) {
	const ownership = readSessionRuntimeOwnership({
		...readParams,
		config
	});
	const nativeAuth = ownership?.auth === "native";
	const entry = readParams.sessionEntry;
	const authProfileSource = resolveCollapsedSessionAuthPinSource(entry);
	const workerAuth = readParams.workerInference === "worker" && !entry?.modelOverride?.trim() && !entry?.agentRuntimeOverride?.trim() && !(entry?.authProfileOverride?.trim() && authProfileSource === "user");
	if (!nativeAuth && !workerAuth) return models;
	const renderedModel = ownership?.modelRef ?? resolveSessionModelRef(config, readParams.sessionEntry, readParams.agentId, { allowPluginNormalization: false });
	return models.map((model) => {
		if (model.provider !== renderedModel.provider || model.id !== renderedModel.model) return model;
		if (workerAuth && model.unavailableReason !== "missing-auth" && model.unavailableReason !== "auth-failed") return model;
		const { available: _available, unavailableReason: _reason, unavailableUntil: _until, ...available } = model;
		return available;
	});
}
//#endregion
export { readPreparedChatMetadata as a, prepareChatAccountSelection as c, projectSessionModelCatalog as i, prepareChatMetadataModelProjection as n, resolveSessionCatalogProfiles as o, prepareSessionAcpMeta as r, sessionProjectionKey as s, hasSessionCatalogContext as t };