@elizaos/ui 2.0.0-alpha.85 → 2.0.0-beta.2

package/onboarding/probe-local-agent.d.ts

@@ -0,0 +1,51 @@
+/**
+ * probe-local-agent.ts
+ *
+ * Liveness probe for an on-device Eliza agent.
+ *
+ * Android reaches the bundled foreground service over loopback. iOS reaches
+ * an in-process route kernel through the ITTP transport, so its local option
+ * is available as soon as the native app is running.
+ *
+ * Result is cached for `PROBE_CACHE_TTL_MS` so repeated renders during the
+ * onboarding flow do not hammer loopback. The cache is keyed by URL.
+ *
+ * `clearLocalAgentProbeCache()` resets the cache between tests.
+ */
+export declare const DEFAULT_LOCAL_AGENT_HEALTH_URL = "http://127.0.0.1:31337/api/health";
+/** Reset the probe cache. Test-only. */
+export declare function clearLocalAgentProbeCache(): void;
+export interface LocalOptionGate {
+    isDesktop: boolean;
+    isDev: boolean;
+    isAndroid: boolean;
+    isIOS: boolean;
+}
+/**
+ * Liveness probe for the on-device local agent, framed as "should the local
+ * option be visible / actionable yet?".
+ *
+ * - Desktop and dev builds: always `true` synchronously — they manage the
+ *   runtime themselves.
+ * - Android: unconditionally the only runtime mode on ElizaOS (the picker is bypassed
+ *   in the APK by `preSeedAndroidLocalRuntimeIfFresh` + the `RuntimeGate`
+ *   Android branch). The probe here is purely a *readiness* signal —
+ *   "is the agent's `/api/health` reachable yet?" — used by the splash to
+ *   know when to call `finishAsLocal()`. It is **not** a gate on whether
+ *   the local mode is offered at all; on Android it always is.
+ * - iOS: `true` in native builds because the local agent uses the in-WebView
+ *   ITTP route kernel instead of a TCP listener.
+ * - Plain web: `false`. It does not host a local agent.
+ */
+export declare function shouldShowLocalOption(gate: LocalOptionGate): Promise<boolean>;
+/**
+ * Probes a local agent's `/api/health` endpoint with a timeout.
+ *
+ * Returns `true` only when the response is HTTP 200 and the JSON body
+ * contains `{ ok: true }`. Any other outcome (timeout, network error,
+ * non-200, non-JSON, missing field) returns `false`.
+ *
+ * Results are memoized per URL for 30 seconds.
+ */
+export declare function probeLocalAgent(timeoutMs?: number, url?: string): Promise<boolean>;
+//# sourceMappingURL=probe-local-agent.d.ts.map

package/onboarding/probe-local-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe-local-agent.d.ts","sourceRoot":"","sources":["../../../../../src/onboarding/probe-local-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,eAAO,MAAM,8BAA8B,sCACN,CAAC;AAqFtC,wCAAwC;AACxC,wBAAgB,yBAAyB,IAAI,IAAI,CAGhD;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,OAAO,CAAC,CAKlB;AAqGD;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,SAAS,SAAO,EAChB,GAAG,GAAE,MAAuC,GAC3C,OAAO,CAAC,OAAO,CAAC,CA0BlB"}

package/onboarding/probe-local-agent.js

@@ -0,0 +1,235 @@
+/**
+ * probe-local-agent.ts
+ *
+ * Liveness probe for an on-device Eliza agent.
+ *
+ * Android reaches the bundled foreground service over loopback. iOS reaches
+ * an in-process route kernel through the ITTP transport, so its local option
+ * is available as soon as the native app is running.
+ *
+ * Result is cached for `PROBE_CACHE_TTL_MS` so repeated renders during the
+ * onboarding flow do not hammer loopback. The cache is keyed by URL.
+ *
+ * `clearLocalAgentProbeCache()` resets the cache between tests.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { Capacitor } from "@capacitor/core";
+import { isAndroidLocalAgentUrl } from "./local-agent-token.js";
+export const DEFAULT_LOCAL_AGENT_HEALTH_URL = "http://127.0.0.1:31337/api/health";
+// Positive results are cached longer so re-renders during onboarding don't
+// hammer loopback. Negative results are short-lived because the agent may
+// finish booting moments after the first probe — without a short negative
+// TTL the user sees "no local agent" for 30 s after a reboot even though
+// the agent is up. 3 s lets `RuntimeGate`'s render cycle re-poll naturally.
+const PROBE_POSITIVE_CACHE_TTL_MS = 30_000;
+const PROBE_NEGATIVE_CACHE_TTL_MS = 3_000;
+const resultCache = new Map();
+const inflight = new Map();
+const agentPluginId = "@elizaos/capacitor-agent";
+const agentPluginName = "Agent";
+function toNativeAgentProbePlugin(plugin) {
+    if (typeof plugin?.request !== "function")
+        return null;
+    const request = plugin.request.bind(plugin);
+    return {
+        request: (options) => request(options),
+    };
+}
+function isNativeAndroid() {
+    try {
+        return (Capacitor.isNativePlatform() && Capacitor.getPlatform() === "android");
+    }
+    catch {
+        return false;
+    }
+}
+function isNativeIos() {
+    try {
+        return Capacitor.isNativePlatform() && Capacitor.getPlatform() === "ios";
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveNativeAgentPlugin() {
+    try {
+        const capacitorWithPlugins = Capacitor;
+        const registeredAgent = capacitorWithPlugins.Plugins?.[agentPluginName] ??
+            Capacitor.registerPlugin(agentPluginName);
+        const agent = toNativeAgentProbePlugin(registeredAgent);
+        if (agent)
+            return agent;
+    }
+    catch {
+        // Fall through to the package import for browser/package-mode test builds.
+    }
+    try {
+        const mod = (await import(__rewriteRelativeImportExtension(/* @vite-ignore */ agentPluginId)));
+        return toNativeAgentProbePlugin(mod.Agent);
+    }
+    catch {
+        return null;
+    }
+}
+/** Reset the probe cache. Test-only. */
+export function clearLocalAgentProbeCache() {
+    resultCache.clear();
+    inflight.clear();
+}
+/**
+ * Liveness probe for the on-device local agent, framed as "should the local
+ * option be visible / actionable yet?".
+ *
+ * - Desktop and dev builds: always `true` synchronously — they manage the
+ *   runtime themselves.
+ * - Android: unconditionally the only runtime mode on ElizaOS (the picker is bypassed
+ *   in the APK by `preSeedAndroidLocalRuntimeIfFresh` + the `RuntimeGate`
+ *   Android branch). The probe here is purely a *readiness* signal —
+ *   "is the agent's `/api/health` reachable yet?" — used by the splash to
+ *   know when to call `finishAsLocal()`. It is **not** a gate on whether
+ *   the local mode is offered at all; on Android it always is.
+ * - iOS: `true` in native builds because the local agent uses the in-WebView
+ *   ITTP route kernel instead of a TCP listener.
+ * - Plain web: `false`. It does not host a local agent.
+ */
+export async function shouldShowLocalOption(gate) {
+    if (gate.isDesktop || gate.isDev)
+        return true;
+    if (gate.isIOS)
+        return isNativeIos();
+    if (!gate.isAndroid)
+        return false;
+    return probeLocalAgent();
+}
+function isHealthyBody(body) {
+    if (typeof body !== "object" || body === null)
+        return false;
+    const b = body;
+    if (b.ok === true)
+        return true;
+    if (b.ready === true)
+        return true;
+    if (b.agentState === "running")
+        return true;
+    return false;
+}
+async function runNativeAndroidProbe(url, timeoutMs) {
+    if (!isAndroidLocalAgentUrl(url) || !isNativeAndroid())
+        return null;
+    const agent = await resolveNativeAgentPlugin();
+    if (!agent?.request)
+        return null;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    let result;
+    try {
+        result = await agent.request({
+            method: "GET",
+            path: `${parsed.pathname}${parsed.search}`,
+            headers: {
+                Accept: "application/json",
+                "X-ElizaOS-Client-Id": "local-agent-probe",
+            },
+            timeoutMs,
+        });
+    }
+    catch {
+        return false;
+    }
+    if (result.status < 200 || result.status >= 300)
+        return false;
+    let body;
+    try {
+        body = JSON.parse(result.body ?? "");
+    }
+    catch {
+        return false;
+    }
+    return isHealthyBody(body);
+}
+async function runProbe(url, timeoutMs) {
+    const nativeResult = await runNativeAndroidProbe(url, timeoutMs);
+    if (nativeResult !== null)
+        return nativeResult;
+    if (typeof fetch !== "function")
+        return false;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "GET",
+            signal: controller.signal,
+            headers: { Accept: "application/json" },
+        });
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!res.ok)
+        return false;
+    let body;
+    try {
+        body = await res.json();
+    }
+    catch {
+        return false;
+    }
+    // The agent's /api/health responds with one of two shapes depending on
+    // version:
+    //   { ok: true, agent, bun, uptime }                 ← spike stub
+    //   { ready: true, runtime: "ok", database: "ok",
+    //     agentState: "running", uptime, ...}            ← real @elizaos/agent
+    // Treat either as healthy. `ok === true` covers the stub; `ready === true`
+    // and `agentState === "running"` cover the real runtime. Without this, the
+    // RuntimeGate tile stays hidden even when the agent is plainly up.
+    return isHealthyBody(body);
+}
+/**
+ * Probes a local agent's `/api/health` endpoint with a timeout.
+ *
+ * Returns `true` only when the response is HTTP 200 and the JSON body
+ * contains `{ ok: true }`. Any other outcome (timeout, network error,
+ * non-200, non-JSON, missing field) returns `false`.
+ *
+ * Results are memoized per URL for 30 seconds.
+ */
+export async function probeLocalAgent(timeoutMs = 1500, url = DEFAULT_LOCAL_AGENT_HEALTH_URL) {
+    const now = Date.now();
+    const cached = resultCache.get(url);
+    if (cached && cached.expiresAt > now) {
+        return cached.result;
+    }
+    const existing = inflight.get(url);
+    if (existing)
+        return existing;
+    const promise = runProbe(url, timeoutMs)
+        .then((result) => {
+        resultCache.set(url, {
+            result,
+            expiresAt: Date.now() +
+                (result ? PROBE_POSITIVE_CACHE_TTL_MS : PROBE_NEGATIVE_CACHE_TTL_MS),
+        });
+        return result;
+    })
+        .finally(() => {
+        inflight.delete(url);
+    });
+    inflight.set(url, promise);
+    return promise;
+}

package/onboarding/reload-into-runtime-picker.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Helper for the Settings ▸ Runtime panel "Switch runtime" action.
+ *
+ * Clears the persisted runtime selection (mobile-runtime-mode + active-server
+ * in localStorage / native Preferences), then navigates to the current URL with
+ * `?runtime=picker` appended. The query flag is consumed by
+ * `RuntimeGate.hasPickerOverride()` so the ElizaOS auto-local branch is
+ * bypassed and the chooser tiles render — the user can then pick Cloud /
+ * Remote / Local without the picker auto-completing back to local.
+ *
+ * This file is deliberately a leaf module with zero React
+ * dependencies so its contract can be tested without booting the
+ * SettingsView dependency graph (which transitively imports the API
+ * client and reads localStorage at module init).
+ */
+export declare const RUNTIME_PICKER_QUERY_NAME = "runtime";
+export declare const RUNTIME_PICKER_QUERY_VALUE = "picker";
+export declare const RUNTIME_PICKER_TARGET_QUERY_NAME = "runtimeTarget";
+export type RuntimePickerTarget = "cloud" | "local" | "remote";
+export declare function reloadIntoRuntimePicker(target?: RuntimePickerTarget): void;
+export declare const __TEST_ONLY__: {
+    ACTIVE_SERVER_STORAGE_KEY: string;
+    MOBILE_RUNTIME_MODE_STORAGE_KEY: string;
+};
+//# sourceMappingURL=reload-into-runtime-picker.d.ts.map

package/onboarding/reload-into-runtime-picker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reload-into-runtime-picker.d.ts","sourceRoot":"","sources":["../../../../../src/onboarding/reload-into-runtime-picker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH,eAAO,MAAM,yBAAyB,YAAY,CAAC;AACnD,eAAO,MAAM,0BAA0B,WAAW,CAAC;AACnD,eAAO,MAAM,gCAAgC,kBAAkB,CAAC;AAEhE,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE/D,wBAAgB,uBAAuB,CAAC,MAAM,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAiB1E;AAED,eAAO,MAAM,aAAa;;;CAGzB,CAAC"}

package/onboarding/reload-into-runtime-picker.js

@@ -0,0 +1,45 @@
+/**
+ * Helper for the Settings ▸ Runtime panel "Switch runtime" action.
+ *
+ * Clears the persisted runtime selection (mobile-runtime-mode + active-server
+ * in localStorage / native Preferences), then navigates to the current URL with
+ * `?runtime=picker` appended. The query flag is consumed by
+ * `RuntimeGate.hasPickerOverride()` so the ElizaOS auto-local branch is
+ * bypassed and the chooser tiles render — the user can then pick Cloud /
+ * Remote / Local without the picker auto-completing back to local.
+ *
+ * This file is deliberately a leaf module with zero React
+ * dependencies so its contract can be tested without booting the
+ * SettingsView dependency graph (which transitively imports the API
+ * client and reads localStorage at module init).
+ */
+import { MOBILE_RUNTIME_MODE_STORAGE_KEY, persistMobileRuntimeModeForServerTarget, } from "./mobile-runtime-mode.js";
+const ACTIVE_SERVER_STORAGE_KEY = "elizaos:active-server";
+export const RUNTIME_PICKER_QUERY_NAME = "runtime";
+export const RUNTIME_PICKER_QUERY_VALUE = "picker";
+export const RUNTIME_PICKER_TARGET_QUERY_NAME = "runtimeTarget";
+export function reloadIntoRuntimePicker(target) {
+    if (typeof window === "undefined")
+        return;
+    persistMobileRuntimeModeForServerTarget("");
+    try {
+        window.localStorage.removeItem(ACTIVE_SERVER_STORAGE_KEY);
+    }
+    catch {
+        // localStorage unreachable in some embedded shells; the picker query
+        // alone is still enough to surface the chooser on the next render.
+    }
+    const url = new URL(window.location.href);
+    url.searchParams.set(RUNTIME_PICKER_QUERY_NAME, RUNTIME_PICKER_QUERY_VALUE);
+    if (target) {
+        url.searchParams.set(RUNTIME_PICKER_TARGET_QUERY_NAME, target);
+    }
+    else {
+        url.searchParams.delete(RUNTIME_PICKER_TARGET_QUERY_NAME);
+    }
+    window.location.href = url.toString();
+}
+export const __TEST_ONLY__ = {
+    ACTIVE_SERVER_STORAGE_KEY,
+    MOBILE_RUNTIME_MODE_STORAGE_KEY,
+};

package/onboarding/server-target.d.ts

@@ -0,0 +1,4 @@
+export type OnboardingServerTarget = "" | "local" | "remote" | "elizacloud" | "elizacloud-hybrid";
+export declare function isElizaCloudOnboardingTarget(target: OnboardingServerTarget): boolean;
+export declare function activeServerKindToOnboardingServerTarget(kind: "local" | "cloud" | "remote"): Exclude<OnboardingServerTarget, "">;
+//# sourceMappingURL=server-target.d.ts.map

package/onboarding/server-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-target.d.ts","sourceRoot":"","sources":["../../../../../src/onboarding/server-target.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,sBAAsB,GAC9B,EAAE,GACF,OAAO,GACP,QAAQ,GACR,YAAY,GACZ,mBAAmB,CAAC;AAExB,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAET;AAED,wBAAgB,wCAAwC,CACtD,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,GACjC,OAAO,CAAC,sBAAsB,EAAE,EAAE,CAAC,CASrC"}

package/onboarding/server-target.js

@@ -0,0 +1,13 @@
+export function isElizaCloudOnboardingTarget(target) {
+    return target === "elizacloud" || target === "elizacloud-hybrid";
+}
+export function activeServerKindToOnboardingServerTarget(kind) {
+    switch (kind) {
+        case "local":
+            return "local";
+        case "cloud":
+            return "elizacloud";
+        case "remote":
+            return "remote";
+    }
+}

package/onboarding-config.d.ts

@@ -0,0 +1,61 @@
+import { type DeploymentTargetConfig, type LinkedAccountFlagsConfig, type OnboardingCredentialInputs, type ServiceRoutingConfig } from "@elizaos/shared";
+import { type OnboardingServerTarget } from "./onboarding/server-target";
+export interface BuildOnboardingConnectionArgs {
+    onboardingServerTarget?: OnboardingServerTarget;
+    onboardingCloudApiKey: string;
+    onboardingProvider: string;
+    onboardingApiKey: string;
+    omitRuntimeProvider?: boolean;
+    onboardingVoiceProvider: string;
+    onboardingVoiceApiKey: string;
+    onboardingPrimaryModel: string;
+    onboardingOpenRouterModel: string;
+    onboardingRemoteConnected: boolean;
+    onboardingRemoteApiBase: string;
+    onboardingRemoteToken: string;
+    onboardingNanoModel?: string;
+    onboardingSmallModel?: string;
+    onboardingMediumModel?: string;
+    onboardingLargeModel?: string;
+    onboardingMegaModel?: string;
+    onboardingResponseHandlerModel?: string;
+    onboardingActionPlannerModel?: string;
+    onboardingFeatureTelegram?: boolean;
+    onboardingFeatureDiscord?: boolean;
+    onboardingFeaturePhone?: boolean;
+    onboardingFeatureCrypto?: boolean;
+    onboardingFeatureBrowser?: boolean;
+    onboardingFeatureComputerUse?: boolean;
+    onboardingUseLocalEmbeddings?: boolean;
+}
+/** Feature selections from the onboarding features step. */
+export interface OnboardingFeatureSetup {
+    connectors: {
+        telegram?: {
+            managed: boolean;
+        };
+        discord?: {
+            managed: boolean;
+        };
+    };
+    capabilities: {
+        crypto?: boolean;
+        browser?: boolean;
+        computeruse?: boolean;
+    };
+}
+export interface BuildOnboardingRuntimeConfigResult {
+    deploymentTarget: DeploymentTargetConfig;
+    linkedAccounts: LinkedAccountFlagsConfig | undefined;
+    serviceRouting: ServiceRoutingConfig | undefined;
+    credentialInputs: OnboardingCredentialInputs | undefined;
+    needsProviderSetup: boolean;
+    featureSetup: OnboardingFeatureSetup | undefined;
+}
+export declare function resolveOnboardingPrimaryModel(args: {
+    providerId: string;
+    onboardingPrimaryModel: string;
+    onboardingOpenRouterModel: string;
+}): string | undefined;
+export declare function buildOnboardingRuntimeConfig(args: BuildOnboardingConnectionArgs): BuildOnboardingRuntimeConfigResult;
+//# sourceMappingURL=onboarding-config.d.ts.map

package/onboarding-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding-config.d.ts","sourceRoot":"","sources":["../../../../src/onboarding-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAE7B,KAAK,0BAA0B,EAI/B,KAAK,oBAAoB,EAC1B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,6BAA6B;IAC5C,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD,qBAAqB,EAAE,MAAM,CAAC;IAC9B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,uBAAuB,EAAE,MAAM,CAAC;IAChC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,yBAAyB,EAAE,MAAM,CAAC;IAClC,yBAAyB,EAAE,OAAO,CAAC;IACnC,uBAAuB,EAAE,MAAM,CAAC;IAChC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,8BAA8B,CAAC,EAAE,MAAM,CAAC;IACxC,4BAA4B,CAAC,EAAE,MAAM,CAAC;IAEtC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACxC;AAED,4DAA4D;AAC5D,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE;QACV,QAAQ,CAAC,EAAE;YAAE,OAAO,EAAE,OAAO,CAAA;SAAE,CAAC;QAChC,OAAO,CAAC,EAAE;YAAE,OAAO,EAAE,OAAO,CAAA;SAAE,CAAC;KAChC,CAAC;IACF,YAAY,EAAE;QACZ,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,kCAAkC;IACjD,gBAAgB,EAAE,sBAAsB,CAAC;IACzC,cAAc,EAAE,wBAAwB,GAAG,SAAS,CAAC;IACrD,cAAc,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACjD,gBAAgB,EAAE,0BAA0B,GAAG,SAAS,CAAC;IACzD,kBAAkB,EAAE,OAAO,CAAC;IAC5B,YAAY,EAAE,sBAAsB,GAAG,SAAS,CAAC;CAClD;AAuBD,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,yBAAyB,EAAE,MAAM,CAAC;CACnC,GAAG,MAAM,GAAG,SAAS,CAKrB;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,6BAA6B,GAClC,kCAAkC,CAsLpC"}

package/onboarding-config.js

@@ -0,0 +1,172 @@
+import { buildDefaultElizaCloudServiceRouting, buildElizaCloudServiceRoute, normalizeOnboardingProviderId, requiresAdditionalRuntimeProvider, } from "@elizaos/shared";
+import { isElizaCloudOnboardingTarget, } from "./onboarding/server-target.js";
+function trimToUndefined(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function resolveLocalProviderId(provider) {
+    const normalized = normalizeOnboardingProviderId(provider);
+    return normalized && normalized !== "elizacloud" ? normalized : null;
+}
+function resolveArgsServerTarget(args) {
+    return args.onboardingServerTarget ?? "";
+}
+export function resolveOnboardingPrimaryModel(args) {
+    if (args.providerId === "openrouter") {
+        return trimToUndefined(args.onboardingOpenRouterModel);
+    }
+    return trimToUndefined(args.onboardingPrimaryModel);
+}
+export function buildOnboardingRuntimeConfig(args) {
+    const serverTarget = resolveArgsServerTarget(args);
+    const persistRuntimeOnConnectedRemote = serverTarget === "remote" && args.onboardingRemoteConnected;
+    const useElizaCloudRuntime = isElizaCloudOnboardingTarget(serverTarget);
+    const nanoModel = trimToUndefined(args.onboardingNanoModel);
+    const smallModel = trimToUndefined(args.onboardingSmallModel);
+    const mediumModel = trimToUndefined(args.onboardingMediumModel);
+    const largeModel = trimToUndefined(args.onboardingLargeModel);
+    const megaModel = trimToUndefined(args.onboardingMegaModel);
+    const responseHandlerModel = trimToUndefined(args.onboardingResponseHandlerModel ?? "");
+    const actionPlannerModel = trimToUndefined(args.onboardingActionPlannerModel ?? "");
+    const linkedAccounts = {};
+    const cloudApiKey = trimToUndefined(args.onboardingCloudApiKey);
+    if (cloudApiKey) {
+        linkedAccounts.elizacloud = {
+            status: "linked",
+            source: "api-key",
+        };
+    }
+    const localProviderId = resolveLocalProviderId(args.onboardingProvider);
+    if (localProviderId === "anthropic-subscription" ||
+        localProviderId === "openai-subscription") {
+        linkedAccounts[localProviderId] = {
+            status: "linked",
+            source: "subscription",
+        };
+    }
+    const deploymentTarget = persistRuntimeOnConnectedRemote
+        ? { runtime: "local" }
+        : serverTarget === "remote"
+            ? {
+                runtime: "remote",
+                provider: "remote",
+                remoteApiBase: trimToUndefined(args.onboardingRemoteApiBase) ?? "",
+                ...(trimToUndefined(args.onboardingRemoteToken)
+                    ? {
+                        remoteAccessToken: trimToUndefined(args.onboardingRemoteToken),
+                    }
+                    : {}),
+            }
+            : useElizaCloudRuntime && !args.onboardingRemoteConnected
+                ? {
+                    runtime: "cloud",
+                    provider: "elizacloud",
+                }
+                : { runtime: "local" };
+    const serviceRouting = {};
+    let llmTextRoute;
+    const shouldConfigureRuntimeProvider = !args.omitRuntimeProvider &&
+        !requiresAdditionalRuntimeProvider(args.onboardingProvider);
+    if (args.onboardingProvider === "elizacloud" &&
+        shouldConfigureRuntimeProvider) {
+        llmTextRoute = buildElizaCloudServiceRoute({
+            nanoModel,
+            smallModel,
+            mediumModel,
+            largeModel,
+            megaModel,
+            responseHandlerModel,
+            actionPlannerModel,
+        });
+    }
+    else if (shouldConfigureRuntimeProvider && localProviderId) {
+        const primaryModel = resolveOnboardingPrimaryModel({
+            providerId: localProviderId,
+            onboardingPrimaryModel: args.onboardingPrimaryModel,
+            onboardingOpenRouterModel: args.onboardingOpenRouterModel,
+        });
+        llmTextRoute =
+            serverTarget === "remote" && !persistRuntimeOnConnectedRemote
+                ? {
+                    backend: localProviderId,
+                    transport: "remote",
+                    remoteApiBase: trimToUndefined(args.onboardingRemoteApiBase) ?? "",
+                    ...(primaryModel ? { primaryModel } : {}),
+                }
+                : {
+                    backend: localProviderId,
+                    transport: "direct",
+                    ...(primaryModel ? { primaryModel } : {}),
+                };
+    }
+    if (llmTextRoute) {
+        serviceRouting.llmText = llmTextRoute;
+    }
+    const cloudDefaultsSelected = args.onboardingProvider === "elizacloud" ||
+        (deploymentTarget.runtime === "cloud" &&
+            deploymentTarget.provider === "elizacloud");
+    if (cloudDefaultsSelected) {
+        Object.assign(serviceRouting, buildDefaultElizaCloudServiceRouting({
+            base: serviceRouting,
+            includeInference: shouldConfigureRuntimeProvider &&
+                args.onboardingProvider === "elizacloud",
+            excludeServices: args.onboardingUseLocalEmbeddings
+                ? ["embeddings"]
+                : undefined,
+            nanoModel,
+            smallModel,
+            mediumModel,
+            largeModel,
+            megaModel,
+            responseHandlerModel,
+            actionPlannerModel,
+        }));
+    }
+    const hasLinkedAccounts = Object.keys(linkedAccounts).length > 0;
+    const hasServiceRouting = Object.keys(serviceRouting).length > 0;
+    const credentialInputs = {};
+    if (cloudApiKey) {
+        credentialInputs.cloudApiKey = cloudApiKey;
+    }
+    const llmApiKey = trimToUndefined(args.onboardingApiKey);
+    if (llmApiKey &&
+        llmTextRoute?.backend &&
+        llmTextRoute.backend !== "elizacloud") {
+        credentialInputs.llmApiKey = llmApiKey;
+    }
+    const hasCredentialInputs = Object.keys(credentialInputs).length > 0;
+    // Build feature setup from onboarding feature toggles
+    const hasFeatures = args.onboardingFeatureTelegram ||
+        args.onboardingFeatureDiscord ||
+        args.onboardingFeatureCrypto ||
+        args.onboardingFeatureBrowser ||
+        args.onboardingFeatureComputerUse;
+    const featureSetup = hasFeatures
+        ? {
+            connectors: {
+                ...(args.onboardingFeatureTelegram
+                    ? { telegram: { managed: true } }
+                    : {}),
+                ...(args.onboardingFeatureDiscord
+                    ? { discord: { managed: true } }
+                    : {}),
+            },
+            capabilities: {
+                ...(args.onboardingFeatureCrypto ? { crypto: true } : {}),
+                ...(args.onboardingFeatureBrowser ? { browser: true } : {}),
+                ...(args.onboardingFeatureComputerUse ? { computeruse: true } : {}),
+            },
+        }
+        : undefined;
+    return {
+        deploymentTarget,
+        linkedAccounts: hasLinkedAccounts ? linkedAccounts : undefined,
+        serviceRouting: hasServiceRouting ? serviceRouting : undefined,
+        credentialInputs: hasCredentialInputs ? credentialInputs : undefined,
+        needsProviderSetup: !serviceRouting.llmText,
+        featureSetup,
+    };
+}