openclaw/dist/provider-discovery.runtime-BjGmF_Ad.js

Multi-channel AI gateway with extensible messaging integrations

import { v as sortUniqueStrings } from "./string-normalization-DsCfAx8q.js";
import { r as normalizeProviderId } from "./provider-id-DMd-TDFp.js";
import { a as preparePluginModule, t as getCachedPluginModuleLoader } from "./plugin-module-loader-cache-lf3kAaBw.js";
import { t as shouldRejectHardlinkedPluginFiles } from "./hardlink-policy-CslDqyMD.js";
import { c as loadManifestMetadataSnapshot } from "./manifest-contract-eligibility-BbV7X6pV.js";
import { t as planEffectiveModelCatalogRows } from "./model-catalog-BiOJ2EJd.js";
import { n as resolvePluginRuntimeArtifactPreference, t as prefersBuiltPluginArtifacts } from "./plugin-runtime-artifact-selection-OSt151GX.js";
import { o as resolveDiscoveredProviderPluginIds } from "./providers-DCe4UB6a.js";
import { r as resolvePluginRuntimeArtifact } from "./plugin-runtime-artifact-resolution-B06Nm0lT.js";
import { t as getPluginRuntimeGenerationRegistry } from "./generation-scope-Cf83d_iq.js";
import { i as withProfile } from "./plugin-load-profile-CjbuhLIb.js";
import { i as getPluginRuntimeLoadContext } from "./load-context-BdeWeJHL.js";
import { n as resolvePluginProvidersCore } from "./providers.runtime-DCovueHC.js";
import { t as buildEffectiveManifestProviderConfig } from "./provider-catalog-8ARoyQkL.js";
//#region src/plugins/provider-discovery.runtime.ts
function normalizeDiscoveryModule(value) {
	const resolved = value && typeof value === "object" && "default" in value && value.default !== void 0 ? value.default : value;
	if (Array.isArray(resolved)) return resolved;
	if (resolved && typeof resolved === "object" && "id" in resolved) return [resolved];
	if (value && typeof value === "object" && !Array.isArray(value)) {
		const record = value;
		if (Array.isArray(record.providers)) return record.providers;
		if (record.provider) return [record.provider];
	}
	return [];
}
function loadProviderDiscoveryProviders(manifest) {
	const registry = getPluginRuntimeGenerationRegistry();
	const loadContext = getPluginRuntimeLoadContext(registry);
	const { source, rootDir } = registry ? resolvePluginRuntimeArtifact({
		pluginId: manifest.id,
		entryKind: "provider-discovery",
		source: manifest.providerDiscoverySource,
		rootDir: manifest.rootDir,
		origin: manifest.origin,
		packageManifest: manifest.packageManifest,
		preferBuiltPluginArtifacts: prefersBuiltPluginArtifacts(resolvePluginRuntimeArtifactPreference(loadContext?.preferBuiltPluginArtifacts), manifest.origin),
		sourcePreferred: manifest.sourcePreferred,
		registry
	}) : {
		source: manifest.providerDiscoverySource,
		rootDir: manifest.rootDir
	};
	const modulePath = registry ? preparePluginModule({
		modulePath: source,
		boundaryRoot: rootDir,
		boundaryLabel: "plugin root",
		surfaceLabel: `plugin provider discovery ${manifest.id}`,
		rejectHardlinks: shouldRejectHardlinkedPluginFiles({
			origin: manifest.origin,
			rootDir: manifest.rootDir,
			env: loadContext?.env
		})
	}).modulePath : source;
	const moduleLoader = getCachedPluginModuleLoader({
		modulePath,
		rootDir,
		importerUrl: import.meta.url,
		loaderFilename: import.meta.url,
		preferBuiltDist: true
	});
	return normalizeDiscoveryModule(withProfile({
		pluginId: manifest.id,
		source: modulePath
	}, "provider-discovery-entry", () => moduleLoader(modulePath))).map((provider) => Object.assign({}, provider, { pluginId: manifest.id }));
}
function hasLiveProviderDiscoveryHook(provider) {
	return typeof provider.catalog?.run === "function";
}
function hasProviderCatalogHook(provider) {
	return hasLiveProviderDiscoveryHook(provider) || typeof provider.staticCatalog?.run === "function";
}
function hasProviderAuthEnvCredential(plugin, env) {
	return (plugin.setup?.providers ?? []).flatMap((provider) => provider.envVars ?? []).some((name) => {
		const value = env[name]?.trim();
		return value !== void 0 && value !== "";
	});
}
function prepareManifestCatalogDiscovery(pluginRecords, config, includeProviders) {
	const providers = [];
	const runtimeManifestCatalogPluginIds = /* @__PURE__ */ new Set();
	for (const plugin of pluginRecords) {
		if (!plugin.modelCatalog) continue;
		const ownedProviders = new Set(plugin.providers.map((provider) => normalizeProviderId(provider)));
		if (Object.entries(plugin.modelCatalog.discovery ?? {}).some(([provider, discovery]) => (discovery === "runtime" || discovery === "refreshable") && ownedProviders.has(normalizeProviderId(provider)))) runtimeManifestCatalogPluginIds.add(plugin.id);
		if (!plugin.modelCatalog.providers) continue;
		const plan = planEffectiveModelCatalogRows({
			registry: { plugins: [plugin] },
			config
		});
		for (const entry of plan.entries) {
			if (entry.discovery === "runtime" || entry.discovery === "refreshable") {
				runtimeManifestCatalogPluginIds.add(plugin.id);
				continue;
			}
			if (!includeProviders || entry.rows.length === 0) continue;
			const providerConfig = buildEffectiveManifestProviderConfig(entry.rows);
			if (!providerConfig) continue;
			providers.push({
				id: entry.provider,
				pluginId: plugin.id,
				label: entry.provider,
				auth: [],
				staticCatalog: {
					order: "simple",
					run: async () => ({ providers: { [entry.provider]: providerConfig } })
				}
			});
		}
	}
	return {
		providers,
		runtimeManifestCatalogPluginIds
	};
}
function resolveProviderDiscoveryEntryPlugins(params) {
	const metadataSnapshot = params.pluginMetadataSnapshot ?? loadManifestMetadataSnapshot({
		config: params.config ?? {},
		env: params.env ?? process.env,
		...params.workspaceDir ? { workspaceDir: params.workspaceDir } : {}
	});
	const registry = metadataSnapshot.index;
	const manifestRegistry = metadataSnapshot.manifestRegistry;
	const pluginIds = resolveDiscoveredProviderPluginIds({
		...params,
		registry,
		manifestRegistry
	});
	const pluginIdSet = new Set(pluginIds);
	const pluginRecords = manifestRegistry.plugins.filter((plugin) => pluginIdSet.has(plugin.id));
	const { providers: manifestProviders, runtimeManifestCatalogPluginIds } = prepareManifestCatalogDiscovery(pluginRecords, params.config ?? {}, params.includeManifestModelCatalogProviders !== false);
	const entryRecords = pluginRecords.filter((plugin) => plugin.providerDiscoverySource);
	const entryPluginIds = new Set(entryRecords.map((plugin) => plugin.id));
	const manifestEntryPluginIds = /* @__PURE__ */ new Set();
	for (const pluginId of manifestProviders.map((provider) => provider.pluginId)) if (pluginId) {
		manifestEntryPluginIds.add(pluginId);
		if (!runtimeManifestCatalogPluginIds.has(pluginId)) entryPluginIds.add(pluginId);
	}
	const complete = entryPluginIds.size === pluginIdSet.size;
	const result = {
		providers: manifestProviders,
		complete,
		pluginRecords,
		entryPluginIds,
		runtimeManifestCatalogPluginIds
	};
	const entriesOnlyComplete = (/* @__PURE__ */ new Set([...entryPluginIds, ...manifestEntryPluginIds])).size === pluginIdSet.size;
	if (entryRecords.length === 0) return result;
	if (params.requireCompleteDiscoveryEntryCoverage && !(params.discoveryEntriesOnly === true ? entriesOnlyComplete : complete)) return {
		...result,
		providers: [],
		complete: false
	};
	const providers = [];
	for (const manifest of entryRecords) try {
		providers.push(...loadProviderDiscoveryProviders(manifest));
	} catch {
		return {
			...result,
			complete: false,
			entryPluginIds: manifestEntryPluginIds
		};
	}
	return {
		...result,
		providers: [...manifestProviders, ...providers]
	};
}
function resolveRuntimeEntryProviders(entryResult) {
	return entryResult.providers.filter((provider) => {
		if (hasLiveProviderDiscoveryHook(provider)) return true;
		return Boolean(provider.pluginId && entryResult.entryPluginIds.has(provider.pluginId) && typeof provider.staticCatalog?.run === "function");
	});
}
function planPluginDiscoveryRuntime(params) {
	const env = params.env ?? process.env;
	const entryResult = resolveProviderDiscoveryEntryPlugins({
		...params,
		env
	});
	const entryProviders = entryResult.providers.filter((provider) => hasProviderCatalogHook(provider) || params.includeSyntheticAuthProviders === true && (typeof provider.resolveSyntheticAuth === "function" || typeof provider.prepareSyntheticAuth === "function"));
	const runtimeEntryProviders = resolveRuntimeEntryProviders(entryResult);
	if (params.discoveryEntriesOnly === true) return {
		kind: "entries",
		providers: entryProviders
	};
	if (entryResult.providers.length > 0 && entryResult.complete && runtimeEntryProviders.length === entryResult.providers.length && entryResult.runtimeManifestCatalogPluginIds.size === 0) return {
		kind: "entries",
		providers: runtimeEntryProviders
	};
	let fullPluginIds = params.onlyPluginIds;
	let retainedProviders;
	if (runtimeEntryProviders.length > 0 || entryResult.runtimeManifestCatalogPluginIds.size > 0) {
		fullPluginIds = sortUniqueStrings([...entryResult.pluginRecords.filter((plugin) => !entryResult.entryPluginIds.has(plugin.id) && (params.onlyPluginIds !== void 0 || hasProviderAuthEnvCredential(plugin, env))).map((plugin) => plugin.id), ...entryResult.runtimeManifestCatalogPluginIds]);
		if (fullPluginIds.length === 0) return {
			kind: "entries",
			providers: runtimeEntryProviders
		};
		const fullPluginIdSet = new Set(fullPluginIds);
		retainedProviders = runtimeEntryProviders.filter((provider) => !provider.pluginId || !fullPluginIdSet.has(provider.pluginId));
	} else if (entryProviders.length > 0) {
		const entryPluginIds = sortUniqueStrings(entryProviders.map((provider) => provider.pluginId).filter((pluginId) => typeof pluginId === "string" && pluginId !== ""));
		if (entryPluginIds.length > 0) fullPluginIds = entryPluginIds;
	}
	return {
		kind: "runtime",
		providers: retainedProviders ?? [],
		pluginIds: fullPluginIds
	};
}
function resolvePluginDiscoveryProvidersRuntime(params) {
	const plan = planPluginDiscoveryRuntime(params);
	if (plan.kind === "entries") return plan.providers;
	const fullProviders = resolvePluginProvidersCore({
		...params,
		env: params.env ?? process.env,
		...plan.pluginIds ? { onlyPluginIds: plan.pluginIds } : {}
	});
	return [...plan.providers, ...fullProviders];
}
//#endregion
export { resolvePluginDiscoveryProvidersRuntime as n, planPluginDiscoveryRuntime as t };