openclaw/dist/embedding-CcGydyW6.js

Multi-channel AI gateway with extensible messaging integrations

import { l as normalizeOptionalString } from "./string-coerce-CIXf7egm.js";
import { r as defaultRuntime } from "./runtime-CF2WjnNZ.js";
import { n as getRuntimeConfig } from "./io.runtime-B9iJRs3w.js";
import { u as resolveAgentDir } from "./agent-scope-config-DcbEhP0R.js";
import "./agent-scope-DbtJyKUL.js";
import "./config-Cs0XXL3x.js";
import { t as resolveMemorySearchConfig } from "./memory-search-DTACVvxE.js";
import { n as listEmbeddingProviders } from "./embedding-provider-runtime-DbfWoZHh.js";
import { r as listRegisteredMemoryEmbeddingProviderAdapters } from "./memory-embedding-provider-runtime-6fQgM2Qk.js";
import { l as getMemoryEmbeddingCommandSecretTargetIds } from "./command-secret-targets-D0VrT_k_.js";
import { n as runCommandWithRuntime } from "./cli-utils-D1DAWB8d.js";
import { c as providerSummaryText, d as resolveCapabilityProviderAgentId, f as resolveLocalCapabilityRuntimeConfig, l as requireProviderModelOverride, n as formatEnvelopeForText, s as providerHasGenericConfig, t as emitJsonOrText, u as resolveCapabilityAgentOption } from "./shared-LJFJI8g1.js";
import { r as createEmbeddingProvider } from "./memory-core-bundled-runtime-CacBOGXk.js";
import { t as collectOption } from "./helpers-B-LqXQ3Z.js";
//#region src/cli/capability-cli/embedding.ts
async function closeEmbeddingProviderWithRetry(provider) {
	let lastError;
	for (let attempt = 0; attempt < 2; attempt += 1) try {
		await provider.close?.();
		return;
	} catch (err) {
		lastError = err;
	}
	throw lastError;
}
async function runMemoryEmbeddingCreate(params) {
	const modelRef = requireProviderModelOverride(params.model);
	const cfg = await resolveLocalCapabilityRuntimeConfig({
		commandName: "infer embedding create",
		targetIds: getMemoryEmbeddingCommandSecretTargetIds()
	});
	const requestedProvider = normalizeOptionalString(params.provider) || modelRef?.provider || "auto";
	const agentId = resolveCapabilityProviderAgentId(cfg, params.agent, "infer embedding create");
	const result = await createEmbeddingProvider({
		config: cfg,
		agentDir: resolveAgentDir(cfg, agentId),
		provider: requestedProvider,
		fallback: "none",
		model: modelRef?.model ?? ""
	});
	if (!result.provider) throw new Error(result.providerUnavailableReason ?? "No embedding provider available.");
	const provider = result.provider;
	let embeddings = [];
	let operationError;
	let operationFailed = false;
	try {
		embeddings = await provider.embedBatch(params.texts, { inputType: "document" });
	} catch (err) {
		operationError = err;
		operationFailed = true;
	}
	let closeError;
	let closeFailed = false;
	try {
		await closeEmbeddingProviderWithRetry(provider);
	} catch (err) {
		closeError = err;
		closeFailed = true;
	}
	if (operationFailed) throw operationError;
	if (closeFailed) throw closeError;
	return {
		ok: true,
		capability: "embedding.create",
		transport: "local",
		provider: provider.id,
		model: provider.model,
		attempts: result.fallbackFrom ? [{
			provider: result.fallbackFrom,
			outcome: "failed",
			error: result.fallbackReason
		}] : [],
		outputs: embeddings.map((embedding, index) => ({
			text: params.texts[index],
			embedding,
			dimensions: embedding.length
		}))
	};
}
function registerEmbeddingCapabilityCommands(capability) {
	const embedding = capability.command("embedding").description("Embedding providers").option("--agent <id>", "Agent whose model and auth state should be used");
	embedding.command("create").description("Create embeddings").requiredOption("--text <text>", "Input text", collectOption).option("--provider <id>", "Provider id").option("--model <provider/model>", "Model override").option("--agent <id>", "Agent whose saved provider auth is used (default: agents.defaults.systemAgent.agentId, then the sole agent)").option("--json", "Output JSON", false).action(async (opts, command) => {
		await runCommandWithRuntime(defaultRuntime, async () => {
			const result = await runMemoryEmbeddingCreate({
				texts: opts.text,
				agent: resolveCapabilityAgentOption(command, opts.agent),
				provider: opts.provider,
				model: opts.model
			});
			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
		});
	});
	embedding.command("providers").description("List embedding providers").option("--agent <id>", "Agent whose provider state should be inspected").option("--json", "Output JSON", false).action(async (opts, command) => {
		await runCommandWithRuntime(defaultRuntime, async () => {
			const cfg = getRuntimeConfig();
			const agentId = resolveCapabilityProviderAgentId(cfg, resolveCapabilityAgentOption(command, opts.agent));
			const resolvedMemory = resolveMemorySearchConfig(cfg, agentId);
			const selectedProvider = resolvedMemory?.provider;
			const providers = new Map(listRegisteredMemoryEmbeddingProviderAdapters().map((provider) => [provider.id, {
				id: provider.id,
				defaultModel: provider.defaultModel,
				transport: provider.transport,
				autoSelectPriority: provider.autoSelectPriority
			}]));
			for (const provider of listEmbeddingProviders(cfg)) {
				if (providers.has(provider.id)) continue;
				providers.set(provider.id, {
					id: provider.id,
					defaultModel: provider.defaultModel,
					transport: provider.transport,
					autoSelectPriority: void 0
				});
			}
			if (selectedProvider && !providers.has(selectedProvider)) providers.set(selectedProvider, {
				id: selectedProvider,
				defaultModel: resolvedMemory?.model || void 0,
				transport: providerHasGenericConfig({
					cfg,
					providerId: selectedProvider,
					agentId
				}) ? "remote" : void 0,
				autoSelectPriority: void 0
			});
			const result = Array.from(providers.values()).map((provider) => ({
				available: true,
				configured: provider.id === selectedProvider || providerHasGenericConfig({
					cfg,
					providerId: provider.id,
					agentId
				}),
				selected: provider.id === selectedProvider,
				id: provider.id,
				defaultModel: provider.defaultModel,
				transport: provider.transport,
				autoSelectPriority: provider.autoSelectPriority
			}));
			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, providerSummaryText);
		});
	});
}
//#endregion
export { registerEmbeddingCapabilityCommands };