@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/api/provider-switch-config.js

@@ -1,44 +1,128 @@
-import { applySubscriptionCredentials, deleteCredentials, } from "@elizaos/agent/auth";
-import { SUBSCRIPTION_PROVIDER_MAP } from "../auth/types";
-import { getOnboardingProviderOption, isCloudManagedConnection, isLocalProviderConnection, isRemoteProviderConnection, normalizeOnboardingProviderId, } from "../contracts/onboarding";
-const REDACTED_SECRET = "[REDACTED]";
-function asRecord(value) {
-    return value && typeof value === "object"
-        ? value
-        : null;
-}
-function trimToUndefined(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-function normalizeSecret(value, existing) {
-    const trimmed = trimToUndefined(value);
-    if (!trimmed || trimmed.toUpperCase() === REDACTED_SECRET) {
-        return existing;
-    }
-    return trimmed;
-}
+import { asNonEmptyString, asRecord, buildDefaultElizaCloudServiceRouting, buildElizaCloudServiceRoute, deriveOnboardingCredentialPersistencePlan, getOnboardingProviderOption, getOnboardingProviderSignalEnvKeys, getStoredOnboardingProviderId, getStoredSubscriptionProvider, migrateLegacyRuntimeConfig, normalizeDeploymentTargetConfig, normalizeOnboardingCredentialInputs, normalizeOnboardingProviderId, normalizeServiceRoutingConfig, normalizeSubscriptionProviderSelectionId, requiresAdditionalRuntimeProvider, } from "@elizaos/shared";
+import { applySubscriptionCredentials, deleteProviderCredentials, } from "../auth/credentials.js";
+import { SUBSCRIPTION_PROVIDER_IDS, SUBSCRIPTION_PROVIDER_MAP, } from "../auth/types.js";
+const trimToUndefined = asNonEmptyString;
 function ensureEnv(config) {
     config.env ??= {};
     return config.env;
 }
+function ensureEnvVars(config) {
+    const env = ensureEnv(config);
+    const existing = asRecord(env.vars);
+    if (existing) {
+        return existing;
+    }
+    const next = {};
+    env.vars = next;
+    return next;
+}
 function ensureDefaults(config) {
     config.agents ??= {};
     config.agents.defaults ??= {};
     return config.agents.defaults;
 }
+function ensureCloud(config) {
+    config.cloud ??= {};
+    return config.cloud;
+}
+function ensureModels(config) {
+    config.models ??= {};
+    return config.models;
+}
+function ensureLinkedAccounts(config) {
+    config.linkedAccounts ??= {};
+    return config.linkedAccounts;
+}
+function ensureServiceRouting(config) {
+    config.serviceRouting ??= {};
+    return config.serviceRouting;
+}
+function persistDeploymentTarget(config, deploymentTarget) {
+    if (!deploymentTarget) {
+        delete config.deploymentTarget;
+        return;
+    }
+    config.deploymentTarget = { ...deploymentTarget };
+}
+function persistLinkedAccounts(config, linkedAccounts) {
+    if (!linkedAccounts) {
+        return;
+    }
+    const existing = ensureLinkedAccounts(config);
+    for (const [accountId, account] of Object.entries(linkedAccounts)) {
+        if (!account || Object.keys(account).length === 0) {
+            delete existing[accountId];
+            continue;
+        }
+        const nextAccount = account;
+        existing[accountId] = {
+            ...existing[accountId],
+            ...nextAccount,
+        };
+    }
+    if (Object.keys(existing).length === 0) {
+        delete config.linkedAccounts;
+    }
+}
+function persistServiceRouting(config, serviceRouting, clearRoutes = []) {
+    const existing = ensureServiceRouting(config);
+    for (const capability of clearRoutes) {
+        delete existing[capability];
+    }
+    if (serviceRouting) {
+        for (const [capability, route] of Object.entries(serviceRouting)) {
+            const serviceKey = capability;
+            if (!route || Object.keys(route).length === 0) {
+                delete existing[serviceKey];
+                continue;
+            }
+            const nextRoute = route;
+            existing[serviceKey] = { ...nextRoute };
+        }
+    }
+    if (Object.keys(existing).length === 0) {
+        delete config.serviceRouting;
+    }
+}
+export function applyCanonicalOnboardingConfig(config, args) {
+    if (args.deploymentTarget !== undefined) {
+        persistDeploymentTarget(config, args.deploymentTarget);
+    }
+    if (args.linkedAccounts !== undefined) {
+        persistLinkedAccounts(config, args.linkedAccounts);
+    }
+    if (args.serviceRouting !== undefined || args.clearRoutes?.length) {
+        persistServiceRouting(config, args.serviceRouting, args.clearRoutes);
+    }
+}
+function pruneEnv(config) {
+    const env = asRecord(config.env);
+    if (!env) {
+        return;
+    }
+    const vars = asRecord(env.vars);
+    if (vars && Object.keys(vars).length === 0) {
+        delete env.vars;
+    }
+    const envKeys = Object.keys(env).filter((key) => key !== "shellEnv");
+    const hasShellEnv = Boolean(env.shellEnv);
+    if (envKeys.length === 0 && !hasShellEnv) {
+        delete config.env;
+    }
+}
 function setEnvValue(config, key, value) {
     const env = ensureEnv(config);
+    const vars = ensureEnvVars(config);
     if (value) {
         env[key] = value;
+        vars[key] = value;
         process.env[key] = value;
         return;
     }
     delete env[key];
+    delete vars[key];
     delete process.env[key];
+    pruneEnv(config);
 }
 function setPrimaryModel(config, primaryModel) {
     const defaults = ensureDefaults(config);
@@ -50,58 +134,267 @@ function setPrimaryModel(config, primaryModel) {
     }
     defaults.model = { ...defaults.model, primary: primaryModel };
 }
-function clearPiAiFlag(config) {
-    const env = ensureEnv(config);
-    delete env.ELIZA_USE_PI_AI;
-    delete process.env.ELIZA_USE_PI_AI;
+function clearPersistedEnvValue(config, key) {
+    const env = asRecord(config.env);
+    const vars = asRecord(env?.vars);
+    if (vars) {
+        delete vars[key];
+        if (Object.keys(vars).length === 0 && env) {
+            delete env.vars;
+        }
+    }
+    if (env) {
+        delete env[key];
+        if (Object.keys(env).length === 0) {
+            delete config.env;
+        }
+    }
 }
-function readString(source, key) {
-    const value = source?.[key];
-    return trimToUndefined(typeof value === "string" ? value : undefined);
+function clearCloudModelSelections(config) {
+    const models = asRecord(config.models);
+    if (!models) {
+        return;
+    }
+    delete models.nano;
+    delete models.small;
+    delete models.medium;
+    delete models.large;
+    delete models.mega;
+    if (Object.keys(models).length === 0) {
+        delete config.models;
+    }
 }
-function readEnvString(config, key) {
-    const env = asRecord(config?.env);
-    const vars = asRecord(env?.vars);
-    return readString(vars, key) ?? readString(env, key);
+function clearRemoteProviderConfig(config) {
+    const cloud = asRecord(config.cloud);
+    if (!cloud) {
+        return;
+    }
+    delete cloud.remoteApiBase;
+    delete cloud.remoteAccessToken;
+    if (cloud.provider === "remote") {
+        delete cloud.provider;
+    }
 }
-function resolveConfiguredLocalProvider(config) {
-    const agents = asRecord(config?.agents);
-    const defaults = asRecord(agents?.defaults);
-    const storedSubscriptionProvider = normalizeOnboardingProviderId(readString(defaults, "subscriptionProvider"));
-    if (storedSubscriptionProvider &&
-        storedSubscriptionProvider !== "elizacloud") {
-        return storedSubscriptionProvider;
-    }
-    const piAiEnabled = readEnvString(config, "ELIZA_USE_PI_AI");
-    if (piAiEnabled && piAiEnabled !== "0" && piAiEnabled !== "false") {
-        return "pi-ai";
-    }
-    const localProvider = [
-        "anthropic",
-        "deepseek",
-        "gemini",
-        "grok",
-        "groq",
-        "mistral",
-        "ollama",
-        "openai",
-        "openrouter",
-        "pi-ai",
-        "together",
-        "zai",
-    ].find((providerId) => {
-        const providerOption = getOnboardingProviderOption(providerId);
-        return providerOption?.envKey
-            ? Boolean(readEnvString(config, providerOption.envKey))
-            : false;
+// Remove ElizaCloud CLI proxy endpoints from process.env and the API keys that server.ts
+// pairs with them (same cloud key for both SDKs). Only clears a key when its matching
+// base URL pointed at ElizaCloud—so local-provider switches that never set those URLs
+// keep multi-key preservation (provider-switch.e2e).
+function clearElizaCloudCliProxyEnv() {
+    const pairs = [
+        ["OPENAI_BASE_URL", "OPENAI_API_KEY"],
+        ["ANTHROPIC_BASE_URL", "ANTHROPIC_API_KEY"],
+    ];
+    for (const [baseKey, apiKey] of pairs) {
+        const v = process.env[baseKey];
+        if (v && /elizacloud/i.test(v)) {
+            delete process.env[baseKey];
+            delete process.env[apiKey];
+        }
+    }
+}
+function persistLinkedCloudApiKey(config, apiKey) {
+    const normalizedApiKey = trimToUndefined(apiKey);
+    if (!normalizedApiKey) {
+        return;
+    }
+    const cloud = ensureCloud(config);
+    cloud.apiKey = normalizedApiKey;
+    process.env.ELIZAOS_CLOUD_API_KEY = normalizedApiKey;
+    applyCanonicalOnboardingConfig(config, {
+        linkedAccounts: {
+            elizacloud: {
+                status: "linked",
+                source: "api-key",
+            },
+        },
     });
-    return localProvider ?? null;
+}
+function applyLocalProviderCapabilities(config, selection) {
+    const normalizedProvider = normalizeOnboardingProviderId(selection.backend);
+    if (!normalizedProvider || normalizedProvider === "elizacloud") {
+        return Promise.resolve();
+    }
+    clearElizaCloudCliProxyEnv();
+    clearRemoteProviderConfig(config);
+    clearCloudModelSelections(config);
+    clearSubscriptionProviderConfig(config);
+    const storedProviderId = getStoredOnboardingProviderId(normalizedProvider);
+    if (storedProviderId &&
+        normalizeSubscriptionProviderSelectionId(storedProviderId)) {
+        applySubscriptionProviderConfig(config, storedProviderId);
+        // Subscription coding plans must remain on their first-party coding
+        // surfaces. Do not inject their credentials into direct API env vars.
+        if (storedProviderId === "anthropic-subscription") {
+            // Store the setup token in config for task-agent discovery but do
+            // NOT set it in process.env.
+            const setupToken = trimToUndefined(selection.apiKey);
+            if (setupToken?.startsWith("sk-ant-")) {
+                const env = ensureEnv(config);
+                // Persist only for config-level discovery, not runtime env.
+                env.__anthropicSubscriptionToken =
+                    setupToken;
+            }
+            return Promise.resolve();
+        }
+        return applySubscriptionCredentials(config);
+    }
+    const providerOption = getOnboardingProviderOption(normalizedProvider);
+    if (providerOption?.envKey) {
+        const apiKey = trimToUndefined(selection.apiKey);
+        if (apiKey) {
+            setEnvValue(config, providerOption.envKey, apiKey);
+        }
+    }
+    else {
+        for (const envKey of getOnboardingProviderSignalEnvKeys(normalizedProvider)) {
+            const value = trimToUndefined(selection.apiKey);
+            if (value) {
+                setEnvValue(config, envKey, value);
+            }
+        }
+    }
+    // Set the primary model plugin so the runtime boosts its priority.
+    // If the user didn't pick a specific model, resolve from the provider's
+    // plugin name so the correct provider wins the TEXT_SMALL/TEXT_LARGE
+    // handler registration.
+    const explicitPrimary = trimToUndefined(selection.primaryModel);
+    const resolvedPrimary = explicitPrimary ?? providerOption?.pluginName ?? undefined;
+    setPrimaryModel(config, resolvedPrimary);
+    // Set provider-specific default model names so TEXT_SMALL and TEXT_LARGE
+    // resolve to sensible models even when the user didn't override them.
+    applyDefaultModelNames(config, normalizedProvider);
+    return Promise.resolve();
+}
+/** Default small/large model names by provider family. */
+const PROVIDER_DEFAULT_MODELS = {
+    anthropic: {
+        smallKey: "ANTHROPIC_SMALL_MODEL",
+        smallVal: "claude-haiku-4-5-20251001",
+        largeKey: "ANTHROPIC_LARGE_MODEL",
+        largeVal: "claude-opus-4-7",
+    },
+    openai: {
+        smallKey: "OPENAI_SMALL_MODEL",
+        smallVal: "gpt-5-mini",
+        largeKey: "OPENAI_LARGE_MODEL",
+        largeVal: "gpt-5.5",
+    },
+    google: {
+        smallKey: "GOOGLE_SMALL_MODEL",
+        smallVal: "gemini-2.0-flash-001",
+        largeKey: "GOOGLE_LARGE_MODEL",
+        largeVal: "gemini-2.5-pro-preview-03-25",
+    },
+    groq: {
+        smallKey: "GROQ_SMALL_MODEL",
+        smallVal: "openai/gpt-oss-120b",
+        largeKey: "GROQ_LARGE_MODEL",
+        largeVal: "openai/gpt-oss-120b",
+    },
+};
+function applyDefaultModelNames(config, provider) {
+    const defaults = PROVIDER_DEFAULT_MODELS[provider];
+    if (!defaults)
+        return;
+    // Only set if not already configured — don't clobber user overrides
+    if (!process.env[defaults.smallKey]) {
+        setEnvValue(config, defaults.smallKey, defaults.smallVal);
+    }
+    if (!process.env[defaults.largeKey]) {
+        setEnvValue(config, defaults.largeKey, defaults.largeVal);
+    }
+}
+function toOnboardingConnectionFromSelection(selection) {
+    if (selection.transport === "cloud-proxy") {
+        return {
+            kind: "cloud-managed",
+            cloudProvider: "elizacloud",
+            ...(trimToUndefined(selection.apiKey)
+                ? { apiKey: trimToUndefined(selection.apiKey) }
+                : {}),
+            ...(trimToUndefined(selection.nanoModel)
+                ? { nanoModel: trimToUndefined(selection.nanoModel) }
+                : {}),
+            ...(trimToUndefined(selection.smallModel)
+                ? { smallModel: trimToUndefined(selection.smallModel) }
+                : {}),
+            ...(trimToUndefined(selection.mediumModel)
+                ? { mediumModel: trimToUndefined(selection.mediumModel) }
+                : {}),
+            ...(trimToUndefined(selection.largeModel)
+                ? { largeModel: trimToUndefined(selection.largeModel) }
+                : {}),
+            ...(trimToUndefined(selection.megaModel)
+                ? { megaModel: trimToUndefined(selection.megaModel) }
+                : {}),
+            ...(trimToUndefined(selection.responseHandlerModel)
+                ? {
+                    responseHandlerModel: trimToUndefined(selection.responseHandlerModel),
+                }
+                : {}),
+            ...(trimToUndefined(selection.shouldRespondModel)
+                ? { shouldRespondModel: trimToUndefined(selection.shouldRespondModel) }
+                : {}),
+            ...(trimToUndefined(selection.actionPlannerModel)
+                ? { actionPlannerModel: trimToUndefined(selection.actionPlannerModel) }
+                : {}),
+            ...(trimToUndefined(selection.plannerModel)
+                ? { plannerModel: trimToUndefined(selection.plannerModel) }
+                : {}),
+            ...(trimToUndefined(selection.responseModel)
+                ? { responseModel: trimToUndefined(selection.responseModel) }
+                : {}),
+            ...(trimToUndefined(selection.mediaDescriptionModel)
+                ? {
+                    mediaDescriptionModel: trimToUndefined(selection.mediaDescriptionModel),
+                }
+                : {}),
+        };
+    }
+    const normalizedProvider = normalizeOnboardingProviderId(selection.backend);
+    if (!normalizedProvider || normalizedProvider === "elizacloud") {
+        return null;
+    }
+    if (selection.transport === "remote") {
+        const remoteApiBase = trimToUndefined(selection.remoteApiBase);
+        if (!remoteApiBase) {
+            return null;
+        }
+        return {
+            kind: "remote-provider",
+            remoteApiBase,
+            provider: normalizedProvider,
+            ...(trimToUndefined(selection.remoteAccessToken)
+                ? { remoteAccessToken: trimToUndefined(selection.remoteAccessToken) }
+                : {}),
+            ...(trimToUndefined(selection.apiKey)
+                ? { apiKey: trimToUndefined(selection.apiKey) }
+                : {}),
+            ...(trimToUndefined(selection.primaryModel)
+                ? { primaryModel: trimToUndefined(selection.primaryModel) }
+                : {}),
+        };
+    }
+    return {
+        kind: "local-provider",
+        provider: normalizedProvider,
+        ...(trimToUndefined(selection.apiKey)
+            ? { apiKey: trimToUndefined(selection.apiKey) }
+            : {}),
+        ...(trimToUndefined(selection.primaryModel)
+            ? { primaryModel: trimToUndefined(selection.primaryModel) }
+            : {}),
+    };
 }
 /**
  * Apply subscription provider configuration to the config object.
  *
- * Sets `agents.defaults.subscriptionProvider` and `agents.defaults.model.primary`
- * so the runtime auto-detects the correct provider on restart.
+ * Sets `agents.defaults.subscriptionProvider` so the task-agent orchestrator
+ * knows which subscription is active.
+ *
+ * For providers with a runtime model-provider plugin, also sets
+ * `agents.defaults.model.primary`. Anthropic subscriptions are restricted to
+ * Claude Code CLI (TOS), so `model.primary` is NOT set for that provider.
  *
  * Mutates `config` in place.
  */
@@ -109,11 +402,20 @@ export function applySubscriptionProviderConfig(config, provider) {
     config.agents ??= {};
     config.agents.defaults ??= {};
     const defaults = config.agents.defaults;
-    const subscriptionKey = provider === "openai-subscription" ? "openai-codex" : provider;
+    const selectionId = normalizeSubscriptionProviderSelectionId(provider);
+    const subscriptionKey = selectionId
+        ? getStoredSubscriptionProvider(selectionId)
+        : provider;
     const modelProvider = SUBSCRIPTION_PROVIDER_MAP[subscriptionKey];
     if (modelProvider) {
         defaults.subscriptionProvider = subscriptionKey;
-        defaults.model = { ...defaults.model, primary: modelProvider };
+        // Only set model.primary for providers with a runtime model-provider
+        // plugin. Anthropic subscription tokens are restricted to Claude Code
+        // CLI (TOS), so the runtime cannot use them for LLM inference.
+        const runtimeApplicable = subscriptionKey === "openai-codex";
+        if (runtimeApplicable) {
+            defaults.model = { ...defaults.model, primary: modelProvider };
+        }
     }
 }
 /**
@@ -129,189 +431,289 @@ export function clearSubscriptionProviderConfig(config) {
     config.agents.defaults ??= {};
     delete config.agents.defaults.subscriptionProvider;
 }
+/**
+ * Clear persisted onboarding state that should force the UI back through the
+ * onboarding flow on the next load/reset.
+ */
+export function clearPersistedOnboardingConfig(config) {
+    if (config.meta && typeof config.meta === "object") {
+        delete config.meta.onboardingComplete;
+    }
+    config.agents = { list: [] };
+    if (config.cloud && typeof config.cloud === "object") {
+        config.cloud = {};
+    }
+    const models = asRecord(config.models);
+    if (models) {
+        delete models.nano;
+        delete models.small;
+        delete models.medium;
+        delete models.large;
+        delete models.mega;
+        if (Object.keys(models).length === 0) {
+            delete config.models;
+        }
+    }
+    // Clear voice settings so presets apply their correct voice on re-onboarding.
+    const messages = asRecord(config.messages);
+    if (messages) {
+        delete messages.tts;
+        if (Object.keys(messages).length === 0) {
+            delete config.messages;
+        }
+    }
+    // Clear UI state (avatar, preset selection) so the full character resets.
+    // Without this, the avatar survives a reset but the voice doesn't,
+    // causing mismatched character state (e.g. male preset with female voice).
+    delete config.ui;
+    delete config.connection;
+    delete config.deploymentTarget;
+    delete config.linkedAccounts;
+    delete config.serviceRouting;
+    const signalProviders = [
+        "anthropic",
+        "anthropic-subscription",
+        "deepseek",
+        "gemini",
+        "grok",
+        "groq",
+        "mistral",
+        "moonshot",
+        "ollama",
+        "openai",
+        "openai-subscription",
+        "openrouter",
+        "together",
+        "zai",
+    ];
+    for (const providerId of signalProviders) {
+        for (const envKey of getOnboardingProviderSignalEnvKeys(providerId)) {
+            clearPersistedEnvValue(config, envKey);
+            delete process.env[envKey];
+        }
+    }
+    delete process.env.ELIZAOS_CLOUD_API_KEY;
+    delete process.env.ELIZAOS_CLOUD_ENABLED;
+    delete process.env.ELIZAOS_CLOUD_NANO_MODEL;
+    delete process.env.ELIZAOS_CLOUD_MEDIUM_MODEL;
+    delete process.env.ELIZAOS_CLOUD_SMALL_MODEL;
+    delete process.env.ELIZAOS_CLOUD_LARGE_MODEL;
+    delete process.env.ELIZAOS_CLOUD_MEGA_MODEL;
+    delete process.env.ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL;
+    delete process.env.ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL;
+    delete process.env.ELIZAOS_CLOUD_ACTION_PLANNER_MODEL;
+    delete process.env.ELIZAOS_CLOUD_PLANNER_MODEL;
+    for (const provider of SUBSCRIPTION_PROVIDER_IDS) {
+        deleteProviderCredentials(provider);
+    }
+}
 export function createProviderSwitchConnection(args) {
     const provider = normalizeOnboardingProviderId(args.provider);
-    if (!provider || provider === "elizacloud") {
+    if (!provider) {
         return null;
     }
-    return {
-        kind: "local-provider",
-        provider,
-        apiKey: trimToUndefined(args.apiKey),
-        primaryModel: trimToUndefined(args.primaryModel),
-    };
-}
-export function resolveExistingOnboardingConnection(config) {
-    const cloud = asRecord(config?.cloud);
-    const models = asRecord(config?.models);
-    const agentDefaults = asRecord(asRecord(config?.agents)?.defaults);
-    const agentModel = asRecord(agentDefaults?.model);
-    const remoteApiBase = readString(cloud, "remoteApiBase");
-    const remoteAccessToken = normalizeSecret(readString(cloud, "remoteAccessToken"));
-    const localProvider = resolveConfiguredLocalProvider(config);
-    const primaryModel = readString(agentModel, "primary");
-    const localProviderOption = getOnboardingProviderOption(localProvider);
-    const localApiKey = localProviderOption?.envKey != null
-        ? normalizeSecret(readEnvString(config, localProviderOption.envKey))
-        : undefined;
-    if (remoteApiBase || remoteAccessToken) {
-        return {
-            kind: "remote-provider",
-            remoteApiBase: remoteApiBase ?? "",
-            remoteAccessToken,
-            provider: localProvider ?? undefined,
-            apiKey: localApiKey,
-            primaryModel,
-        };
-    }
-    const cloudProvider = normalizeOnboardingProviderId(readString(cloud, "provider"));
-    const cloudApiKey = normalizeSecret(readString(cloud, "apiKey"));
-    const smallModel = readString(models, "small");
-    const largeModel = readString(models, "large");
-    if (cloud?.enabled === true ||
-        cloudProvider === "elizacloud" ||
-        readString(cloud, "inferenceMode") === "cloud" ||
-        cloudApiKey ||
-        smallModel ||
-        largeModel) {
+    if (provider === "elizacloud") {
         return {
             kind: "cloud-managed",
             cloudProvider: "elizacloud",
-            apiKey: cloudApiKey,
-            smallModel,
-            largeModel,
         };
     }
-    if (!localProvider) {
-        return null;
-    }
     return {
         kind: "local-provider",
-        provider: localProvider,
-        apiKey: localApiKey,
-        primaryModel,
-    };
-}
-export function mergeOnboardingConnectionWithExisting(nextConnection, existingConnection) {
-    if (!existingConnection || existingConnection.kind !== nextConnection.kind) {
-        return nextConnection;
-    }
-    if (nextConnection.kind === "cloud-managed") {
-        if (!isCloudManagedConnection(existingConnection) ||
-            existingConnection.cloudProvider !== nextConnection.cloudProvider) {
-            return nextConnection;
-        }
-        return {
-            ...existingConnection,
-            ...nextConnection,
-            apiKey: normalizeSecret(nextConnection.apiKey, existingConnection.apiKey),
-            smallModel: nextConnection.smallModel ?? existingConnection.smallModel,
-            largeModel: nextConnection.largeModel ?? existingConnection.largeModel,
-        };
-    }
-    if (nextConnection.kind === "local-provider") {
-        if (!isLocalProviderConnection(existingConnection) ||
-            existingConnection.provider !== nextConnection.provider) {
-            return nextConnection;
-        }
-        return {
-            ...existingConnection,
-            ...nextConnection,
-            apiKey: normalizeSecret(nextConnection.apiKey, existingConnection.apiKey),
-            primaryModel: nextConnection.primaryModel ?? existingConnection.primaryModel,
-        };
-    }
-    if (!isRemoteProviderConnection(existingConnection)) {
-        return nextConnection;
-    }
-    return {
-        ...existingConnection,
-        ...nextConnection,
-        apiKey: normalizeSecret(nextConnection.apiKey, existingConnection.apiKey),
-        remoteAccessToken: normalizeSecret(nextConnection.remoteAccessToken, existingConnection.remoteAccessToken),
-        primaryModel: nextConnection.primaryModel ?? existingConnection.primaryModel,
+        provider,
+        apiKey: trimToUndefined(args.apiKey),
+        primaryModel: trimToUndefined(args.primaryModel),
     };
 }
-export async function applyOnboardingConnectionConfig(config, connection) {
-    if (connection.kind === "cloud-managed") {
-        config.cloud ??= {};
-        config.models ??= {};
-        config.cloud.enabled = true;
-        config.cloud.provider = "elizacloud";
-        config.cloud.inferenceMode = "cloud";
-        config.cloud.runtime = "cloud";
-        const apiKey = trimToUndefined(connection.apiKey);
+export async function applyOnboardingConnectionConfig(config, connection, options = {}) {
+    const normalizedConnection = connection;
+    const excludeServices = options.useLocalEmbeddings
+        ? ["embeddings"]
+        : undefined;
+    delete config.connection;
+    const existingDeploymentTarget = normalizeDeploymentTargetConfig(config.deploymentTarget);
+    if (normalizedConnection.kind === "cloud-managed") {
+        clearRemoteProviderConfig(config);
+        clearCloudModelSelections(config);
+        setPrimaryModel(config, undefined);
+        const cloud = ensureCloud(config);
+        const models = ensureModels(config);
+        const apiKey = trimToUndefined(normalizedConnection.apiKey);
         if (apiKey) {
-            config.cloud.apiKey = apiKey;
+            cloud.apiKey = apiKey;
             process.env.ELIZAOS_CLOUD_API_KEY = apiKey;
         }
-        if (connection.smallModel) {
-            config.models.small = connection.smallModel;
+        if (normalizedConnection.nanoModel) {
+            models.nano = normalizedConnection.nanoModel;
+        }
+        if (normalizedConnection.smallModel) {
+            models.small = normalizedConnection.smallModel;
         }
-        if (connection.largeModel) {
-            config.models.large = connection.largeModel;
+        if (normalizedConnection.mediumModel) {
+            models.medium = normalizedConnection.mediumModel;
         }
+        if (normalizedConnection.largeModel) {
+            models.large = normalizedConnection.largeModel;
+        }
+        if (normalizedConnection.megaModel) {
+            models.mega = normalizedConnection.megaModel;
+        }
+        const serviceRouting = buildDefaultElizaCloudServiceRouting({
+            base: {
+                ...config.serviceRouting,
+                llmText: buildElizaCloudServiceRoute({
+                    nanoModel: normalizedConnection.nanoModel,
+                    smallModel: normalizedConnection.smallModel,
+                    mediumModel: normalizedConnection.mediumModel,
+                    largeModel: normalizedConnection.largeModel,
+                    megaModel: normalizedConnection.megaModel,
+                    responseHandlerModel: normalizedConnection.responseHandlerModel,
+                    shouldRespondModel: normalizedConnection.shouldRespondModel,
+                    actionPlannerModel: normalizedConnection.actionPlannerModel,
+                    plannerModel: normalizedConnection.plannerModel,
+                    responseModel: normalizedConnection.responseModel,
+                    mediaDescriptionModel: normalizedConnection.mediaDescriptionModel,
+                }),
+            },
+            ...(excludeServices ? { excludeServices } : {}),
+        });
+        applyCanonicalOnboardingConfig(config, {
+            deploymentTarget: existingDeploymentTarget,
+            linkedAccounts: apiKey
+                ? {
+                    elizacloud: {
+                        status: "linked",
+                        source: "api-key",
+                    },
+                }
+                : undefined,
+            serviceRouting,
+        });
+        process.env.ELIZAOS_CLOUD_ENABLED = "true";
         clearSubscriptionProviderConfig(config);
-        clearPiAiFlag(config);
+        migrateLegacyRuntimeConfig(config);
         return;
     }
-    if (connection.kind === "remote-provider") {
-        config.cloud ??= {};
-        config.cloud.enabled = true;
-        config.cloud.provider = "remote";
-        config.cloud.runtime = "cloud";
-        config.cloud.remoteApiBase =
-            connection.remoteApiBase;
-        if (connection.remoteAccessToken) {
-            config.cloud.remoteAccessToken =
-                connection.remoteAccessToken;
-        }
-        if (connection.provider) {
-            const localConnection = createProviderSwitchConnection({
-                provider: connection.provider,
-                apiKey: connection.apiKey,
-                primaryModel: connection.primaryModel,
-            });
-            if (localConnection) {
-                await applyOnboardingConnectionConfig(config, localConnection);
-            }
-        }
+    delete process.env.ELIZAOS_CLOUD_ENABLED;
+    delete process.env.ELIZAOS_CLOUD_API_KEY;
+    delete process.env.ELIZAOS_CLOUD_BASE_URL;
+    delete process.env.ELIZAOS_CLOUD_NANO_MODEL;
+    delete process.env.ELIZAOS_CLOUD_MEDIUM_MODEL;
+    delete process.env.ELIZAOS_CLOUD_SMALL_MODEL;
+    delete process.env.ELIZAOS_CLOUD_LARGE_MODEL;
+    delete process.env.ELIZAOS_CLOUD_MEGA_MODEL;
+    delete process.env.ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL;
+    delete process.env.ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL;
+    delete process.env.ELIZAOS_CLOUD_ACTION_PLANNER_MODEL;
+    delete process.env.ELIZAOS_CLOUD_PLANNER_MODEL;
+    if (normalizedConnection.kind === "remote-provider") {
+        clearSubscriptionProviderConfig(config);
+        clearCloudModelSelections(config);
+        clearRemoteProviderConfig(config);
+        setPrimaryModel(config, undefined);
+        applyCanonicalOnboardingConfig(config, {
+            deploymentTarget: {
+                runtime: "remote",
+                provider: "remote",
+                remoteApiBase: normalizedConnection.remoteApiBase,
+                ...(normalizedConnection.remoteAccessToken
+                    ? { remoteAccessToken: normalizedConnection.remoteAccessToken }
+                    : {}),
+            },
+            serviceRouting: normalizedConnection.provider
+                ? {
+                    llmText: {
+                        backend: normalizedConnection.provider,
+                        transport: "remote",
+                        remoteApiBase: normalizedConnection.remoteApiBase,
+                        ...(normalizedConnection.primaryModel
+                            ? { primaryModel: normalizedConnection.primaryModel }
+                            : {}),
+                    },
+                }
+                : undefined,
+            clearRoutes: normalizedConnection.provider ? [] : ["llmText"],
+        });
+        migrateLegacyRuntimeConfig(config);
         return;
     }
-    config.cloud ??= {};
-    config.cloud.enabled = false;
-    config.cloud.runtime = "local";
-    const normalizedProvider = connection.provider === "openai-subscription"
-        ? "openai-codex"
-        : connection.provider;
-    if (normalizedProvider === "anthropic-subscription" ||
-        normalizedProvider === "openai-codex") {
-        applySubscriptionProviderConfig(config, normalizedProvider);
-        const setupToken = normalizedProvider === "anthropic-subscription"
-            ? trimToUndefined(connection.apiKey)
-            : undefined;
-        if (setupToken?.startsWith("sk-ant-")) {
-            setEnvValue(config, "ANTHROPIC_API_KEY", setupToken);
-            deleteCredentials("anthropic-subscription");
-            deleteCredentials("openai-codex");
-            return;
+    await applyLocalProviderCapabilities(config, {
+        backend: normalizedConnection.provider,
+        ...(normalizedConnection.apiKey
+            ? { apiKey: normalizedConnection.apiKey }
+            : {}),
+        ...(normalizedConnection.primaryModel
+            ? { primaryModel: normalizedConnection.primaryModel }
+            : {}),
+    });
+    const linkedAccounts = normalizedConnection.provider === "anthropic-subscription" ||
+        normalizedConnection.provider === "openai-subscription"
+        ? {
+            [normalizedConnection.provider]: {
+                status: "linked",
+                source: "subscription",
+            },
         }
-        await applySubscriptionCredentials(config);
-        deleteCredentials((normalizedProvider === "anthropic-subscription"
-            ? "openai-codex"
-            : "anthropic-subscription"));
+        : undefined;
+    const shouldDefaultCloudServices = existingDeploymentTarget?.runtime === "cloud" &&
+        existingDeploymentTarget.provider === "elizacloud";
+    const directLlmRoute = {
+        backend: normalizedConnection.provider,
+        transport: "direct",
+        ...(normalizedConnection.primaryModel
+            ? { primaryModel: normalizedConnection.primaryModel }
+            : {}),
+    };
+    const serviceRouting = shouldDefaultCloudServices
+        ? buildDefaultElizaCloudServiceRouting({
+            base: {
+                ...config.serviceRouting,
+                llmText: directLlmRoute,
+            },
+            ...(excludeServices ? { excludeServices } : {}),
+        })
+        : {
+            llmText: directLlmRoute,
+        };
+    if (requiresAdditionalRuntimeProvider(normalizedConnection.provider)) {
+        const currentBackend = normalizeOnboardingProviderId(normalizeServiceRoutingConfig(config.serviceRouting)?.llmText?.backend);
+        applyCanonicalOnboardingConfig(config, {
+            deploymentTarget: existingDeploymentTarget,
+            linkedAccounts,
+            clearRoutes: currentBackend === normalizedConnection.provider ? ["llmText"] : [],
+        });
+        migrateLegacyRuntimeConfig(config);
         return;
     }
-    clearSubscriptionProviderConfig(config);
-    if (normalizedProvider === "pi-ai") {
-        setEnvValue(config, "ELIZA_USE_PI_AI", "1");
+    applyCanonicalOnboardingConfig(config, {
+        deploymentTarget: existingDeploymentTarget,
+        linkedAccounts,
+        serviceRouting,
+    });
+    migrateLegacyRuntimeConfig(config);
+}
+export async function applyOnboardingCredentialPersistence(config, args) {
+    const plan = deriveOnboardingCredentialPersistencePlan({
+        credentialInputs: normalizeOnboardingCredentialInputs(args.credentialInputs),
+        deploymentTarget: args.deploymentTarget,
+        serviceRouting: args.serviceRouting,
+    });
+    if (plan.llmSelection) {
+        const llmConnection = toOnboardingConnectionFromSelection(plan.llmSelection);
+        if (llmConnection) {
+            await applyOnboardingConnectionConfig(config, llmConnection);
+        }
     }
-    else {
-        clearPiAiFlag(config);
+    if (plan.cloudApiKey) {
+        persistLinkedCloudApiKey(config, plan.cloudApiKey);
     }
-    const providerOption = getOnboardingProviderOption(normalizedProvider);
-    if (providerOption?.envKey) {
-        setEnvValue(config, providerOption.envKey, trimToUndefined(connection.apiKey));
+    migrateLegacyRuntimeConfig(config);
+    if (plan.llmSelection?.transport !== "direct") {
+        return null;
+    }
+    const provider = normalizeOnboardingProviderId(plan.llmSelection.backend);
+    if (!provider || provider === "elizacloud") {
+        return null;
     }
-    setPrimaryModel(config, trimToUndefined(connection.primaryModel));
+    return getOnboardingProviderOption(provider)?.envKey ?? null;
 }