@inkeep/agents-cli 0.39.5 → 0.41.0

package/dist/instrumentation.js

@@ -0,0 +1,47 @@
+import { registerOTel } from "@vercel/otel";
+import { LangfuseExporter } from "langfuse-vercel";
+
+//#region src/instrumentation.ts
+/**
+* OpenTelemetry instrumentation setup for Langfuse
+* This file sets up LLM observability for the CLI using Langfuse
+*
+* Initialization happens automatically when this file is imported
+* in the entry point (index.ts), before any AI SDK calls are made.
+*/
+const langfuseEnabled = process.env.LANGFUSE_ENABLED === "true";
+const langfuseSecretKey = process.env.LANGFUSE_SECRET_KEY;
+const langfusePublicKey = process.env.LANGFUSE_PUBLIC_KEY;
+/**
+* Check if Langfuse is properly configured
+*/
+function isLangfuseConfigured() {
+	return !!(langfuseEnabled && langfuseSecretKey && langfusePublicKey);
+}
+/**
+* Initialize OpenTelemetry with Langfuse exporter
+* This will be called automatically when the module is imported
+*/
+function initializeInstrumentation() {
+	if (!isLangfuseConfigured()) {
+		if (process.env.DEBUG) console.log("[Langfuse] Tracing disabled - missing configuration");
+		return;
+	}
+	try {
+		registerOTel({
+			serviceName: "inkeep-agents-cli",
+			traceExporter: new LangfuseExporter({
+				secretKey: langfuseSecretKey,
+				publicKey: langfusePublicKey,
+				baseUrl: process.env.LANGFUSE_BASEURL || "https://cloud.langfuse.com"
+			})
+		});
+		if (process.env.DEBUG) console.log("[Langfuse] Tracing initialized successfully");
+	} catch (error) {
+		console.warn("[Langfuse] Failed to initialize tracing:", error);
+	}
+}
+initializeInstrumentation();
+
+//#endregion
+export { initializeInstrumentation, isLangfuseConfigured };

package/dist/types/agent.js

@@ -0,0 +1 @@
+export {  };

package/dist/types/tsx.d.d.ts

@@ -0,0 +1 @@
+export {  };

package/dist/utils/background-version-check.js

@@ -0,0 +1,19 @@
+import { checkForUpdate } from "./version-check.js";
+import chalk from "chalk";
+
+//#region src/utils/background-version-check.ts
+/**
+* Perform a non-blocking version check and display a warning if an update is available
+* This function runs in the background and will not block command execution
+*/
+function performBackgroundVersionCheck() {
+	checkForUpdate().then((versionInfo) => {
+		if (versionInfo.needsUpdate) {
+			console.log(chalk.yellow(`\n⚠️  A new version of @inkeep/agents-cli is available: ${versionInfo.latest} (current: ${versionInfo.current})`));
+			console.log(chalk.gray("   Run `inkeep update` to upgrade to the latest version\n"));
+		}
+	}).catch(() => {});
+}
+
+//#endregion
+export { performBackgroundVersionCheck };

package/dist/utils/ci-environment.js

@@ -0,0 +1,87 @@
+import { checkKeychainAvailability } from "./credentials.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { homedir } from "node:os";
+
+//#region src/utils/ci-environment.ts
+async function detectCIEnvironment() {
+	if (process.env.INKEEP_CI === "true") return {
+		isCI: true,
+		reason: "INKEEP_CI=true"
+	};
+	if (process.env.CI === "true" || process.env.CI === "1") return {
+		isCI: true,
+		reason: "CI environment detected"
+	};
+	if (process.env.GITHUB_ACTIONS === "true") return {
+		isCI: true,
+		reason: "GitHub Actions detected"
+	};
+	if (process.env.GITLAB_CI === "true") return {
+		isCI: true,
+		reason: "GitLab CI detected"
+	};
+	if (process.env.JENKINS_URL) return {
+		isCI: true,
+		reason: "Jenkins detected"
+	};
+	if (process.env.CIRCLECI === "true") return {
+		isCI: true,
+		reason: "CircleCI detected"
+	};
+	const profilesExist = existsSync(join(homedir(), ".inkeep", "profiles.yaml"));
+	const { available: keychainAvailable } = await checkKeychainAvailability();
+	if (!profilesExist && !keychainAvailable) return {
+		isCI: true,
+		reason: "no keychain available"
+	};
+	if (!keychainAvailable && process.env.INKEEP_API_KEY) return {
+		isCI: true,
+		reason: "no keychain available, using API key"
+	};
+	return {
+		isCI: false,
+		reason: ""
+	};
+}
+function loadCIEnvironmentConfig() {
+	const apiKey = process.env.INKEEP_API_KEY;
+	const manageApiUrl = process.env.INKEEP_MANAGE_API_URL;
+	const runApiUrl = process.env.INKEEP_RUN_API_URL;
+	const environment = process.env.INKEEP_ENVIRONMENT || "production";
+	const tenantId = process.env.INKEEP_TENANT_ID;
+	if (!apiKey) return null;
+	return {
+		isCI: true,
+		apiKey,
+		manageApiUrl: manageApiUrl || "https://manage-api.inkeep.com",
+		runApiUrl: runApiUrl || "https://run-api.inkeep.com",
+		environment,
+		tenantId
+	};
+}
+function logCIConfig(config, reason) {
+	console.log(chalk.yellow(`CI mode detected (${reason})`));
+	console.log(chalk.gray(`  Remote: ${config.manageApiUrl}`));
+	console.log(chalk.gray(`  Environment: ${config.environment}`));
+	console.log(chalk.gray(`  Auth: API key (INKEEP_API_KEY)`));
+	if (config.tenantId) console.log(chalk.gray(`  Tenant: ${config.tenantId}`));
+}
+function getAuthHeaders(config, isCI = false) {
+	const headers = {};
+	if (isCI && config.apiKey) headers["X-API-Key"] = config.apiKey;
+	else if (config.accessToken) headers["Authorization"] = `Bearer ${config.accessToken}`;
+	return headers;
+}
+function validateCIConfig(config) {
+	const errors = [];
+	if (!config.apiKey) errors.push("INKEEP_API_KEY environment variable is required in CI mode");
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+
+//#endregion
+export { detectCIEnvironment, getAuthHeaders, loadCIEnvironmentConfig, logCIConfig, validateCIConfig };

package/dist/utils/cli-pipeline.js

@@ -0,0 +1,158 @@
+import { getCredentialExpiryInfo, loadCredentials } from "./credentials.js";
+import { ProfileManager } from "./profiles/profile-manager.js";
+import "./profiles/index.js";
+import { detectCIEnvironment, loadCIEnvironmentConfig, logCIConfig } from "./ci-environment.js";
+import { validateConfiguration } from "./config.js";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+
+//#region src/utils/cli-pipeline.ts
+/**
+* Standard pipeline for initializing CLI commands
+*
+* This function provides a consistent way to:
+* 1. Load profile configuration (if available)
+* 2. Load and validate configuration from inkeep.config.ts
+* 3. Merge profile config with file config (profile takes precedence)
+* 4. Handle errors with user-friendly messages
+* 5. Optionally display progress with spinners
+* 6. Log configuration sources for debugging
+*
+* Configuration precedence: CLI flag > profile > config.ts defaults
+*
+* @example
+* ```ts
+* export async function myCommand(options: MyOptions) {
+*   const { config, profile, isAuthenticated } = await initializeCommand({
+*     configPath: options.config,
+*     profileName: options.profile,
+*     showSpinner: true,
+*     spinnerText: 'Loading configuration...',
+*     logConfig: true
+*   });
+*
+*   // Your command logic here...
+* }
+* ```
+*/
+async function initializeCommand(options = {}) {
+	const { configPath, tag, profileName, showSpinner = false, spinnerText = "Loading configuration...", logConfig = true, quiet = false } = options;
+	const s = showSpinner ? p.spinner() : void 0;
+	if (s) s.start(spinnerText);
+	try {
+		const ciDetection = await detectCIEnvironment();
+		const ciConfig = ciDetection.isCI ? loadCIEnvironmentConfig() : null;
+		if (ciDetection.isCI) {
+			const config$1 = await validateConfiguration(configPath, tag);
+			if (ciConfig) {
+				if (ciConfig.manageApiUrl) config$1.agentsManageApiUrl = ciConfig.manageApiUrl;
+				if (ciConfig.runApiUrl) config$1.agentsRunApiUrl = ciConfig.runApiUrl;
+				if (ciConfig.apiKey) config$1.agentsManageApiKey = ciConfig.apiKey;
+				if (ciConfig.tenantId) config$1.tenantId = ciConfig.tenantId;
+			}
+			if (s) s.stop("Configuration loaded");
+			if (logConfig && !quiet) if (ciConfig) logCIConfig(ciConfig, ciDetection.reason);
+			else {
+				console.log(chalk.yellow(`CI mode detected (${ciDetection.reason})`));
+				console.log(chalk.gray(`  Using config file settings (no INKEEP_API_KEY set)`));
+				console.log(chalk.gray(`  Remote: ${config$1.agentsManageApiUrl}`));
+			}
+			return {
+				config: config$1,
+				isAuthenticated: !!ciConfig?.apiKey,
+				isCI: true,
+				ciConfig: ciConfig ?? void 0
+			};
+		}
+		let profile;
+		let isAuthenticated = false;
+		let authExpiry;
+		let profileAccessToken;
+		let profileOrganizationId;
+		try {
+			const profileManager = new ProfileManager();
+			if (profileName) {
+				const foundProfile = profileManager.getProfile(profileName);
+				if (!foundProfile) throw new Error(`Profile '${profileName}' not found.`);
+				profile = foundProfile;
+			} else profile = profileManager.getActiveProfile();
+			if (profile) {
+				const credentials = await loadCredentials(profile.credential);
+				if (credentials) {
+					const expiryInfo = getCredentialExpiryInfo(credentials);
+					if (!expiryInfo.isExpired) {
+						profileAccessToken = credentials.accessToken;
+						profileOrganizationId = credentials.organizationId;
+						isAuthenticated = true;
+						authExpiry = expiryInfo.expiresIn;
+					}
+				}
+			}
+		} catch {}
+		const config = await validateConfiguration(configPath, tag);
+		if (profile) {
+			config.agentsManageApiUrl = profile.remote.manageApi;
+			config.agentsRunApiUrl = profile.remote.runApi;
+			config.manageUiUrl = profile.remote.manageUi;
+			if (profileAccessToken) config.agentsManageApiKey = profileAccessToken;
+			if (profileOrganizationId) config.tenantId = profileOrganizationId;
+		}
+		if (s) s.stop("Configuration loaded");
+		if (logConfig && !quiet) if (profile) {
+			const expiryText = authExpiry ? ` (expires in ${authExpiry})` : "";
+			const authStatus = isAuthenticated ? chalk.green("authenticated") + expiryText : chalk.yellow("not authenticated");
+			console.log(chalk.gray(`Using profile: ${chalk.cyan(profile.name)}`));
+			console.log(chalk.gray(`  Remote: ${config.agentsManageApiUrl}`));
+			console.log(chalk.gray(`  Environment: ${profile.environment}`));
+			console.log(chalk.gray(`  Auth: ${authStatus}`));
+		} else {
+			console.log(chalk.gray("Configuration:"));
+			console.log(chalk.gray(`  • Tenant ID: ${config.tenantId}`));
+			console.log(chalk.gray(`  • Manage API URL: ${config.agentsManageApiUrl}`));
+			console.log(chalk.gray(`  • Run API URL: ${config.agentsRunApiUrl}`));
+			if (config.sources.configFile) console.log(chalk.gray(`  • Config file: ${config.sources.configFile}`));
+		}
+		return {
+			config,
+			profile,
+			isAuthenticated,
+			authExpiry,
+			isCI: false
+		};
+	} catch (error) {
+		if (s) s.stop("Configuration failed");
+		console.error(chalk.red("Error:"), error.message);
+		if (error.message.includes("Profile") && error.message.includes("not found")) console.log(chalk.yellow("\nHint: Run \"inkeep profile list\" to see available profiles."));
+		else if (error.message.includes("No configuration found")) {
+			console.log(chalk.yellow("\nHint: Create a configuration file by running:"));
+			console.log(chalk.gray("  inkeep init"));
+		} else if (error.message.includes("Config file not found")) console.log(chalk.yellow("\nHint: Check that your config file path is correct"));
+		else if (error.message.includes("tenantId") || error.message.includes("API URL")) {
+			console.log(chalk.yellow("\nHint: Ensure your inkeep.config.ts has all required fields:"));
+			console.log(chalk.gray("  - tenantId"));
+			console.log(chalk.gray("  - agentsManageApiUrl (or agentsManageApi.url)"));
+			console.log(chalk.gray("  - agentsRunApiUrl (or agentsRunApi.url)"));
+		}
+		process.exit(1);
+	}
+}
+/**
+* Lightweight config loader without spinners or logging
+* Useful for commands that need config but handle their own UI
+*/
+async function loadCommandConfig(configPath, profileName) {
+	try {
+		return await initializeCommand({
+			configPath,
+			profileName,
+			showSpinner: false,
+			logConfig: false
+		});
+	} catch (error) {
+		console.error(chalk.red("Configuration error:"), error.message);
+		process.exit(1);
+	}
+}
+
+//#endregion
+export { initializeCommand, loadCommandConfig };

package/dist/utils/config.js

@@ -0,0 +1,290 @@
+import { loadCredentials } from "./credentials.js";
+import { importWithTypeScriptSupport } from "./tsx-loader.js";
+import { getLogger } from "@inkeep/agents-core";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+
+//#region src/utils/config.ts
+const logger = getLogger("config");
+/**
+* Masks sensitive values in config for safe logging
+* @internal Exported for testing purposes
+*/
+function maskSensitiveConfig(config) {
+	if (!config) return config;
+	const masked = { ...config };
+	if (masked.agentsManageApiKey) masked.agentsManageApiKey = `***${masked.agentsManageApiKey.slice(-4)}`;
+	if (masked.agentsRunApiKey) masked.agentsRunApiKey = `***${masked.agentsRunApiKey.slice(-4)}`;
+	return masked;
+}
+/**
+* Type guard to check if config uses nested format
+*/
+function isNestedConfig(config) {
+	return config && (config.agentsManageApi !== void 0 || config.agentsRunApi !== void 0);
+}
+/**
+* Normalize config from either flat or nested format to internal format
+*/
+function normalizeConfig(config) {
+	if (isNestedConfig(config)) return {
+		tenantId: config.tenantId,
+		agentsManageApiUrl: config.agentsManageApi?.url,
+		agentsRunApiUrl: config.agentsRunApi?.url,
+		agentsManageApiKey: config.agentsManageApi?.apiKey,
+		agentsRunApiKey: config.agentsRunApi?.apiKey,
+		manageUiUrl: config.manageUiUrl,
+		outputDirectory: config.outputDirectory
+	};
+	return {
+		tenantId: config.tenantId,
+		agentsManageApiUrl: config.agentsManageApiUrl,
+		agentsRunApiUrl: config.agentsRunApiUrl,
+		manageUiUrl: config.manageUiUrl,
+		outputDirectory: config.outputDirectory
+	};
+}
+/**
+* Get config file names for a given tag
+* @param tag - Optional tag for environment-specific config (e.g., 'prod', 'staging')
+* @returns Array of config file names to search for
+*/
+function getConfigFileNames(tag) {
+	if (tag) return [`${tag}.__inkeep.config.ts__`, `${tag}.__inkeep.config.js__`];
+	return [
+		"inkeep.config.ts",
+		"inkeep.config.js",
+		".inkeeprc.ts",
+		".inkeeprc.js"
+	];
+}
+/**
+* Search for config file in current directory and parent directories
+* @param startPath - Directory to start searching from (defaults to current working directory)
+* @param tag - Optional tag for environment-specific config (e.g., 'prod', 'staging')
+* @returns Path to config file or null if not found
+*/
+function findConfigFile(startPath = process.cwd(), tag) {
+	let currentPath = resolve(startPath);
+	const root = "/";
+	const configNames = getConfigFileNames(tag);
+	while (currentPath !== root) {
+		for (const configName of configNames) {
+			const configPath = join(currentPath, configName);
+			if (existsSync(configPath)) return configPath;
+		}
+		const parentPath = dirname(currentPath);
+		if (parentPath === currentPath) break;
+		currentPath = parentPath;
+	}
+	return null;
+}
+/**
+* Find all project config files recursively in a directory
+* @param rootDir - Root directory to search
+* @param tag - Optional tag for environment-specific config
+* @param excludeDirs - Directories to exclude from search
+* @returns Array of found config file paths
+*/
+function findAllConfigFiles(rootDir, tag, excludeDirs = [
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	".temp-validation"
+]) {
+	const configFiles = [];
+	const configNames = getConfigFileNames(tag);
+	function scanDirectory(dir) {
+		if (!existsSync(dir)) return;
+		let items;
+		try {
+			items = readdirSync(dir);
+		} catch {
+			return;
+		}
+		for (const item of items) {
+			const fullPath = join(dir, item);
+			const relativePath = relative(rootDir, fullPath);
+			if (excludeDirs.some((excl) => item === excl || relativePath.startsWith(`${excl}/`))) continue;
+			try {
+				const stat = statSync(fullPath);
+				if (stat.isDirectory()) scanDirectory(fullPath);
+				else if (stat.isFile() && configNames.includes(item)) configFiles.push(fullPath);
+			} catch {}
+		}
+	}
+	scanDirectory(rootDir);
+	return configFiles.sort();
+}
+/**
+* Extract project ID from a loaded config
+* The project ID can be specified directly or needs to be loaded from the project
+* @param configPath - Path to the config file
+* @returns Project ID or null if not found
+*/
+async function extractProjectIdFromConfig(configPath) {
+	try {
+		const module = await importWithTypeScriptSupport(configPath);
+		const rawConfig = module.default || module.config;
+		if (!rawConfig) return null;
+		if (rawConfig.projectId) return rawConfig.projectId;
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Find project config and extract project information
+* This walks up directories to find the nearest config file
+* @param startPath - Directory to start searching from
+* @param tag - Optional tag for environment-specific config
+* @returns Project config result or null if not found
+*/
+async function findProjectConfig(startPath = process.cwd(), tag) {
+	const configPath = findConfigFile(startPath, tag);
+	if (!configPath) return null;
+	return {
+		configPath,
+		projectDir: dirname(configPath),
+		projectId: await extractProjectIdFromConfig(configPath)
+	};
+}
+/**
+* Load config file from disk and normalize it
+* This is the core config loading logic used by all CLI commands
+*
+* @param configPath - Optional explicit path to config file
+* @param tag - Optional tag for environment-specific config (e.g., 'prod', 'staging')
+* @returns Normalized config or null if not found
+*/
+async function loadConfigFromFile(configPath, tag) {
+	logger.info({
+		fromPath: configPath,
+		tag
+	}, `Loading config file`);
+	let resolvedPath;
+	if (configPath) {
+		resolvedPath = resolve(process.cwd(), configPath);
+		if (!existsSync(resolvedPath)) throw new Error(`Config file not found: ${resolvedPath}`);
+	} else {
+		resolvedPath = findConfigFile(process.cwd(), tag);
+		if (!resolvedPath) {
+			if (tag) {
+				const taggedFileName = getConfigFileNames(tag)[0];
+				throw new Error(`Tagged config file not found: ${taggedFileName}\nCreate this file or use a different --tag value.`);
+			}
+			return null;
+		}
+	}
+	try {
+		const module = await importWithTypeScriptSupport(resolvedPath);
+		const rawConfig = module.default || module.config;
+		if (!rawConfig) throw new Error(`No config exported from ${resolvedPath}`);
+		const config = normalizeConfig(rawConfig);
+		logger.info({ config: maskSensitiveConfig(config) }, `Loaded config values`);
+		return config;
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("Tagged config file not found")) throw error;
+		console.warn(`Warning: Failed to load config file ${resolvedPath}:`, error);
+		return null;
+	}
+}
+/**
+* Main config loader - single source of truth for loading inkeep.config.ts
+* This is the ONLY function that should be used to load configuration across all CLI commands.
+*
+* Configuration priority (highest to lowest):
+* 1. CLI flags (handled by caller)
+* 2. Config file (inkeep.config.ts)
+* 3. Default values
+*
+* @param configPath - Optional explicit path to config file
+* @param tag - Optional tag for environment-specific config (e.g., 'prod', 'staging')
+* @returns Normalized configuration with defaults applied
+*/
+async function loadConfig(configPath, tag) {
+	const config = {
+		agentsManageApiUrl: "http://localhost:3002",
+		agentsRunApiUrl: "http://localhost:3003",
+		manageUiUrl: "http://localhost:3000"
+	};
+	const fileConfig = await loadConfigFromFile(configPath, tag);
+	if (fileConfig) {
+		Object.keys(fileConfig).forEach((key) => {
+			const value = fileConfig[key];
+			if (value !== void 0) config[key] = value;
+		});
+		logger.info({ mergedConfig: maskSensitiveConfig(config) }, `Config loaded from file`);
+	} else logger.info({ config: maskSensitiveConfig(config) }, `Using default config (no config file found)`);
+	return config;
+}
+/**
+* Validates configuration loaded from inkeep.config.ts file
+* This is the ONLY way to configure the CLI - no CLI flags for URLs/keys
+*
+* Configuration priority:
+* 1. Config file (inkeep.config.ts or --config path/to/config.ts)
+* 2. CLI credentials (from `inkeep login`) - for API key and tenant ID fallback
+* 3. Default values (http://localhost:3002, http://localhost:3003)
+*
+* Note: API URLs and keys are loaded ONLY from the config file, NOT from environment
+* variables or CLI flags. This ensures explicit control over where the CLI connects.
+*
+* Secrets (API keys, bypass tokens) CAN be loaded from .env files in the working directory
+* and parent directories via the config file's environment variable references.
+*
+* @param configPath - explicit path to config file (from --config parameter)
+* @param tag - optional tag for environment-specific config (e.g., 'prod', 'staging')
+* @returns configuration with tenantId, agentsManageApiUrl, agentsRunApiUrl, and source info
+*/
+async function validateConfiguration(configPath, tag) {
+	const config = await loadConfig(configPath, tag);
+	const actualConfigFile = configPath || findConfigFile(process.cwd(), tag);
+	let cliCredentials = null;
+	try {
+		const credentials = await loadCredentials();
+		if (credentials && credentials.accessToken && credentials.organizationId) {
+			cliCredentials = {
+				accessToken: credentials.accessToken,
+				organizationId: credentials.organizationId
+			};
+			logger.info({}, "CLI credentials available for fallback");
+		}
+	} catch {
+		logger.debug({}, "Could not load CLI credentials");
+	}
+	if (!config.agentsManageApiKey && cliCredentials) {
+		config.agentsManageApiKey = cliCredentials.accessToken;
+		logger.info({}, "Using CLI session token as API key");
+	}
+	if (!config.tenantId && cliCredentials) {
+		config.tenantId = cliCredentials.organizationId;
+		logger.info({}, "Using CLI organization ID as tenant ID");
+	}
+	if (!config.tenantId) {
+		if (actualConfigFile) throw new Error(`Tenant ID is missing from configuration file: ${actualConfigFile}\nPlease ensure your config file exports a valid configuration with tenantId,
+or run "inkeep login" to authenticate with Inkeep Cloud.`);
+		throw new Error("No configuration found. Please:\n  1. Run \"inkeep login\" to authenticate with Inkeep Cloud\n  2. Or create \"inkeep.config.ts\" by running \"inkeep init\"\n  3. Or provide --config to specify a config file path");
+	}
+	if (!config.agentsManageApiUrl) throw new Error(`Agents Management API URL is missing from config file${actualConfigFile ? `: ${actualConfigFile}` : ""}\nPlease add agentsManageApiUrl to your configuration file`);
+	if (!config.agentsRunApiUrl) throw new Error(`Agents Run API URL is missing from config file${actualConfigFile ? `: ${actualConfigFile}` : ""}\nPlease add agentsRunApiUrl to your configuration file`);
+	const sources = {
+		tenantId: cliCredentials && !actualConfigFile ? "CLI login (organization ID)" : actualConfigFile ? `config file (${actualConfigFile})` : "default",
+		agentsManageApiUrl: actualConfigFile ? `config file (${actualConfigFile})` : "default value",
+		agentsRunApiUrl: actualConfigFile ? `config file (${actualConfigFile})` : "default value"
+	};
+	if (actualConfigFile) sources.configFile = actualConfigFile;
+	return {
+		tenantId: config.tenantId,
+		agentsManageApiUrl: config.agentsManageApiUrl,
+		agentsRunApiUrl: config.agentsRunApiUrl,
+		agentsManageApiKey: config.agentsManageApiKey,
+		agentsRunApiKey: config.agentsRunApiKey,
+		manageUiUrl: config.manageUiUrl,
+		sources
+	};
+}
+
+//#endregion
+export { extractProjectIdFromConfig, findAllConfigFiles, findConfigFile, findProjectConfig, getConfigFileNames, loadConfig, loadConfigFromFile, maskSensitiveConfig, validateConfiguration };