@elizaos/app-core 2.0.0-alpha.74 → 2.0.0-alpha.76

package/src/state/index.ts

@@ -1,6 +0,0 @@
-export * from "./AppContext";
-export * from "./parsers";
-export * from "./persistence";
-export * from "./types";
-export * from "./useApp";
-export * from "./vrm";

package/src/state/internal.ts

@@ -1,91 +0,0 @@
-export {
-  deriveOnboardingResumeConnection,
-  deriveOnboardingResumeFields,
-  hasPartialOnboardingConnectionConfig,
-  inferOnboardingResumeStep,
-} from "./onboarding-resume";
-export {
-  asApiLikeError,
-  computeStreamingDelta,
-  formatSearchBullet,
-  formatStartupErrorDetail,
-  mergeStreamingText,
-  normalizeCustomActionName,
-  normalizeStreamComparisonText,
-  parseAgentStartupDiagnostics,
-  parseAgentStatusEvent,
-  parseConversationMessageEvent,
-  parseCustomActionParams,
-  parseProactiveMessageEvent,
-  parseSlashCommandInput,
-  parseStreamEventEnvelopeEvent,
-  shouldApplyFinalStreamText,
-} from "./parsers";
-export {
-  applyUiTheme,
-  clearPersistedConnectionMode,
-  clearPersistedOnboardingStep,
-  loadActiveConversationId,
-  loadAvatarIndex,
-  loadChatAvatarVisible,
-  loadChatMode,
-  loadChatVoiceMuted,
-  loadCompanionMessageCutoffTs,
-  loadLastNativeTab,
-  loadPersistedConnectionMode,
-  loadPersistedOnboardingStep,
-  type PersistedConnectionMode,
-  loadUiLanguage,
-  loadUiShellMode,
-  loadUiTheme,
-  normalizeUiShellMode,
-  normalizeUiTheme,
-  saveActiveConversationId,
-  saveAvatarIndex,
-  saveChatAvatarVisible,
-  saveChatMode,
-  saveChatVoiceMuted,
-  saveCompanionMessageCutoffTs,
-  saveLastNativeTab,
-  saveOnboardingStep,
-  savePersistedConnectionMode,
-  saveUiLanguage,
-  saveUiShellMode,
-  saveUiTheme,
-  type UiTheme,
-} from "./persistence";
-export {
-  type ActionNotice,
-  AGENT_READY_TIMEOUT_MS,
-  AGENT_STATES,
-  AGENT_TRANSFER_MIN_PASSWORD_LENGTH,
-  type AppActions,
-  type AppContextValue,
-  type AppState,
-  type ChatTurnUsage,
-  type GamePostMessageAuthPayload,
-  LIFECYCLE_MESSAGES,
-  type LifecycleAction,
-  type LoadConversationMessagesResult,
-  ONBOARDING_PERMISSION_LABELS,
-  type OnboardingMode,
-  type OnboardingNextOptions,
-  type OnboardingStep,
-  type ShellView,
-  type SlashCommandInput,
-  type StartupErrorReason,
-  type StartupErrorState,
-  type StartupPhase,
-  type UiShellMode,
-} from "./types";
-export { AppContext, useApp } from "./useApp";
-export {
-  getCompanionBackgroundUrl,
-  getVrmBackgroundUrl,
-  getVrmPreviewUrl,
-  getVrmTitle,
-  getVrmUrl,
-  isOfficialVrmIndex,
-  normalizeAvatarIndex,
-  VRM_COUNT,
-} from "./vrm";

package/src/state/onboarding-resume.test.ts

@@ -1,135 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  deriveOnboardingResumeConnection,
-  deriveOnboardingResumeFields,
-  hasPartialOnboardingConnectionConfig,
-  inferOnboardingResumeStep,
-} from "./onboarding-resume";
-
-describe("hasPartialOnboardingConnectionConfig", () => {
-  it.each([
-    {
-      config: null,
-      expected: false,
-      name: "returns false when config is missing",
-    },
-    {
-      config: {},
-      expected: false,
-      name: "returns false when cloud config is missing",
-    },
-    {
-      config: { cloud: { enabled: true } },
-      expected: true,
-      name: "returns true when cloud is enabled",
-    },
-    {
-      config: { cloud: { apiKey: "sk-test" } },
-      expected: true,
-      name: "returns true when api key is present",
-    },
-    {
-      config: { cloud: { apiKey: "   " } },
-      expected: false,
-      name: "ignores blank strings",
-    },
-  ])("$name", ({ config, expected }) => {
-    expect(
-      hasPartialOnboardingConnectionConfig(
-        config as Record<string, unknown> | null,
-      ),
-    ).toBe(expected);
-  });
-});
-
-describe("inferOnboardingResumeStep", () => {
-  it("prefers the persisted step over inferred config", () => {
-    expect(
-      inferOnboardingResumeStep({
-        persistedStep: "rpc",
-        config: { cloud: { enabled: true } },
-      }),
-    ).toBe("rpc");
-  });
-
-  it("resumes at senses when partial onboarding connection config exists", () => {
-    expect(
-      inferOnboardingResumeStep({
-        config: { cloud: { remoteApiBase: "https://example.com" } },
-      }),
-    ).toBe("senses");
-  });
-
-  it("falls back to identity when nothing is persisted yet", () => {
-    expect(
-      inferOnboardingResumeStep({
-        config: {},
-      }),
-    ).toBe("identity");
-  });
-});
-
-describe("deriveOnboardingResumeConnection", () => {
-  it("reconstructs an eliza cloud connection from partial saved config", () => {
-    expect(
-      deriveOnboardingResumeConnection({
-        cloud: { enabled: true, apiKey: "[REDACTED]" },
-        models: {
-          small: "openai/gpt-5-mini",
-          large: "anthropic/claude-sonnet-4.5",
-        },
-      }),
-    ).toEqual({
-      kind: "cloud-managed",
-      cloudProvider: "elizacloud",
-      apiKey: undefined,
-      smallModel: "openai/gpt-5-mini",
-      largeModel: "anthropic/claude-sonnet-4.5",
-    });
-  });
-
-  it("reconstructs a local provider connection from saved env config", () => {
-    expect(
-      deriveOnboardingResumeConnection({
-        env: {
-          vars: {
-            OPENROUTER_API_KEY: "sk-or-test",
-          },
-        },
-        agents: {
-          defaults: {
-            model: { primary: "openai/gpt-5-mini" },
-          },
-        },
-      }),
-    ).toEqual({
-      kind: "local-provider",
-      provider: "openrouter",
-      apiKey: "sk-or-test",
-      primaryModel: "openai/gpt-5-mini",
-    });
-  });
-});
-
-describe("deriveOnboardingResumeFields", () => {
-  it("maps an openrouter connection back into onboarding state", () => {
-    expect(
-      deriveOnboardingResumeFields({
-        kind: "local-provider",
-        provider: "openrouter",
-        apiKey: "sk-or-test",
-        primaryModel: "openai/gpt-5-mini",
-      }),
-    ).toEqual({
-      onboardingRunMode: "local",
-      onboardingCloudProvider: "",
-      onboardingProvider: "openrouter",
-      onboardingApiKey: "sk-or-test",
-      onboardingPrimaryModel: "",
-      onboardingOpenRouterModel: "openai/gpt-5-mini",
-      onboardingRemoteConnected: false,
-      onboardingRemoteApiBase: "",
-      onboardingRemoteToken: "",
-    });
-  });
-});

package/src/state/onboarding-resume.ts

@@ -1,263 +0,0 @@
-import {
-  normalizeOnboardingProviderId,
-  ONBOARDING_PROVIDER_CATALOG,
-  type OnboardingConnection,
-  type OnboardingLocalProviderId,
-} from "@elizaos/autonomous/contracts/onboarding";
-import type { BuildOnboardingConnectionArgs } from "../onboarding-config";
-import type { OnboardingStep } from "./types";
-
-const REDACTED_SECRET = "[REDACTED]";
-
-function asRecord(value: unknown): Record<string, unknown> | null {
-  return value && typeof value === "object"
-    ? (value as Record<string, unknown>)
-    : null;
-}
-
-function hasConfigValue(value: unknown): boolean {
-  return typeof value === "string" ? value.trim().length > 0 : value === true;
-}
-
-function readString(
-  source: Record<string, unknown> | null | undefined,
-  key: string,
-): string | null {
-  const value = source?.[key];
-  if (typeof value !== "string") {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-
-function readNonRedactedString(
-  source: Record<string, unknown> | null | undefined,
-  key: string,
-): string | null {
-  const value = readString(source, key);
-  return value === REDACTED_SECRET ? null : value;
-}
-
-function readEnvString(
-  config: Record<string, unknown> | null | undefined,
-  key: string,
-): string | null {
-  const env = asRecord(config?.env);
-  const vars = asRecord(env?.vars);
-  return readString(vars, key) ?? readString(env, key);
-}
-
-function readEnvSecret(
-  config: Record<string, unknown> | null | undefined,
-  key: string,
-): string | null {
-  const value = readEnvString(config, key);
-  return value === REDACTED_SECRET ? null : value;
-}
-
-function readPrimaryModel(
-  config: Record<string, unknown> | null | undefined,
-): string | null {
-  const agents = asRecord(config?.agents);
-  const defaults = asRecord(agents?.defaults);
-  const model = asRecord(defaults?.model);
-  return readString(model, "primary");
-}
-
-function isPiAiEnabled(
-  config: Record<string, unknown> | null | undefined,
-): boolean {
-  const value = readEnvString(config, "ELIZA_USE_PI_AI");
-  if (!value) {
-    return false;
-  }
-  return value !== "0" && value.toLowerCase() !== "false";
-}
-
-function resolveConfiguredLocalProvider(
-  config: Record<string, unknown> | null | undefined,
-): OnboardingLocalProviderId | null {
-  const agents = asRecord(config?.agents);
-  const defaults = asRecord(agents?.defaults);
-  const storedSubscriptionProvider = normalizeOnboardingProviderId(
-    readString(defaults, "subscriptionProvider"),
-  );
-  if (
-    storedSubscriptionProvider &&
-    storedSubscriptionProvider !== "elizacloud"
-  ) {
-    return storedSubscriptionProvider;
-  }
-
-  if (isPiAiEnabled(config)) {
-    return "pi-ai";
-  }
-
-  for (const provider of ONBOARDING_PROVIDER_CATALOG) {
-    if (provider.id === "elizacloud" || !provider.envKey) {
-      continue;
-    }
-    if (readEnvString(config, provider.envKey)) {
-      return provider.id;
-    }
-  }
-
-  return null;
-}
-
-export function hasPartialOnboardingConnectionConfig(
-  config: Record<string, unknown> | null | undefined,
-): boolean {
-  const cloud = asRecord(config?.cloud);
-  if (!cloud) {
-    return false;
-  }
-
-  return [
-    cloud.enabled,
-    cloud.apiKey,
-    cloud.provider,
-    cloud.inferenceMode,
-    cloud.remoteApiBase,
-    cloud.remoteAccessToken,
-  ].some(hasConfigValue);
-}
-
-export function inferOnboardingResumeStep(args: {
-  config?: Record<string, unknown> | null;
-  persistedStep?: OnboardingStep | null;
-}): OnboardingStep {
-  if (args.persistedStep) {
-    return args.persistedStep;
-  }
-
-  return hasPartialOnboardingConnectionConfig(args.config)
-    ? "senses"
-    : "identity";
-}
-
-export function deriveOnboardingResumeConnection(
-  config: Record<string, unknown> | null | undefined,
-): OnboardingConnection | null {
-  const cloud = asRecord(config?.cloud);
-  const models = asRecord(config?.models);
-  const remoteApiBase = readString(cloud, "remoteApiBase");
-  const remoteAccessToken = readNonRedactedString(cloud, "remoteAccessToken");
-  const localProvider = resolveConfiguredLocalProvider(config);
-  const primaryModel = readPrimaryModel(config) ?? undefined;
-  const localProviderOption = ONBOARDING_PROVIDER_CATALOG.find(
-    (provider) => provider.id === localProvider,
-  );
-  const localApiKey =
-    localProviderOption?.envKey != null
-      ? (readEnvSecret(config, localProviderOption.envKey) ?? undefined)
-      : undefined;
-
-  if (remoteApiBase || remoteAccessToken) {
-    return {
-      kind: "remote-provider",
-      remoteApiBase: remoteApiBase ?? "",
-      remoteAccessToken: remoteAccessToken ?? undefined,
-      provider: localProvider ?? undefined,
-      apiKey: localApiKey,
-      primaryModel,
-    };
-  }
-
-  const cloudProvider = normalizeOnboardingProviderId(
-    readString(cloud, "provider"),
-  );
-  const cloudApiKey = readNonRedactedString(cloud, "apiKey") ?? undefined;
-  const smallModel = readString(models, "small") ?? undefined;
-  const largeModel = readString(models, "large") ?? undefined;
-
-  if (
-    cloud?.enabled === true ||
-    cloudProvider === "elizacloud" ||
-    readString(cloud, "inferenceMode") === "cloud" ||
-    cloudApiKey ||
-    smallModel ||
-    largeModel
-  ) {
-    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 deriveOnboardingResumeFields(
-  connection: OnboardingConnection | null | undefined,
-): Partial<BuildOnboardingConnectionArgs> {
-  if (!connection) {
-    return {};
-  }
-
-  switch (connection.kind) {
-    case "cloud-managed":
-      return {
-        onboardingRunMode: "cloud",
-        onboardingCloudProvider: "elizacloud",
-        onboardingApiKey: connection.apiKey ?? "",
-        onboardingSmallModel: connection.smallModel ?? "",
-        onboardingLargeModel: connection.largeModel ?? "",
-        onboardingRemoteConnected: false,
-        onboardingRemoteApiBase: "",
-        onboardingRemoteToken: "",
-        onboardingProvider: "",
-        onboardingPrimaryModel: "",
-        onboardingOpenRouterModel: "",
-      };
-    case "local-provider":
-      return {
-        onboardingRunMode: "local",
-        onboardingCloudProvider: "",
-        onboardingProvider: connection.provider,
-        onboardingApiKey: connection.apiKey ?? "",
-        onboardingPrimaryModel:
-          connection.provider === "openrouter"
-            ? ""
-            : (connection.primaryModel ?? ""),
-        onboardingOpenRouterModel:
-          connection.provider === "openrouter"
-            ? (connection.primaryModel ?? "")
-            : "",
-        onboardingRemoteConnected: false,
-        onboardingRemoteApiBase: "",
-        onboardingRemoteToken: "",
-      };
-    case "remote-provider":
-      return {
-        onboardingRunMode: "cloud",
-        onboardingCloudProvider: "remote",
-        onboardingProvider: connection.provider ?? "",
-        onboardingApiKey: connection.apiKey ?? "",
-        onboardingPrimaryModel:
-          connection.provider === "openrouter"
-            ? ""
-            : (connection.primaryModel ?? ""),
-        onboardingOpenRouterModel:
-          connection.provider === "openrouter"
-            ? (connection.primaryModel ?? "")
-            : "",
-        onboardingRemoteConnected: true,
-        onboardingRemoteApiBase: connection.remoteApiBase,
-        onboardingRemoteToken: connection.remoteAccessToken ?? "",
-      };
-  }
-}

package/src/state/parsers.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { computeStreamingDelta, mergeStreamingText } from "./parsers";
-
-describe("computeStreamingDelta", () => {
-  it.each([
-    {
-      name: "returns empty for empty incoming text",
-      existing: "hello",
-      incoming: "",
-      expected: "",
-    },
-    {
-      name: "returns the full incoming text when nothing is accumulated yet",
-      existing: "",
-      incoming: "hello",
-      expected: "hello",
-    },
-    {
-      name: "returns empty when incoming matches the accumulated text",
-      existing: "hello",
-      incoming: "hello",
-      expected: "",
-    },
-    {
-      name: "returns only the new suffix when incoming extends existing",
-      existing: "hello",
-      incoming: "hello world",
-      expected: " world",
-    },
-    {
-      name: "returns empty when incoming is already a large suffix of existing",
-      existing: "streaming",
-      incoming: "aming",
-      expected: "",
-    },
-    {
-      name: "returns the incoming text when there is no overlap",
-      existing: "hello",
-      incoming: "world",
-      expected: "world",
-    },
-    {
-      name: "returns only the non-overlapping tail for partial suffix-prefix overlap",
-      existing: "hello world",
-      incoming: "world!",
-      expected: "!",
-    },
-    {
-      name: "preserves repeated single-character deltas",
-      existing: "Hel",
-      incoming: "l",
-      expected: "l",
-    },
-    {
-      name: "surfaces full snapshot replacements for in-place consumers",
-      existing: "world",
-      incoming: "Hello world",
-      expected: "Hello world",
-    },
-    {
-      name: "surfaces corrected full snapshots that revise earlier words",
-      existing: "Hello wrld",
-      incoming: "Hello world",
-      expected: "Hello world",
-    },
-  ])("$name", ({ existing, incoming, expected }) => {
-    expect(computeStreamingDelta(existing, incoming)).toBe(expected);
-  });
-});
-
-describe("mergeStreamingText", () => {
-  it.each([
-    {
-      name: "appends plain deltas",
-      existing: "Hello",
-      incoming: " world",
-      expected: "Hello world",
-    },
-    {
-      name: "accepts cumulative snapshots",
-      existing: "Hello",
-      incoming: "Hello world",
-      expected: "Hello world",
-    },
-    {
-      name: "replaces with a revised full snapshot",
-      existing: "world",
-      incoming: "Hello world",
-      expected: "Hello world",
-    },
-    {
-      name: "drops large suffix fragments already present",
-      existing: "Hello world",
-      incoming: "world",
-      expected: "Hello world",
-    },
-    {
-      name: "replaces corrected snapshots that share a long prefix",
-      existing: "Hello wrld",
-      incoming: "Hello world",
-      expected: "Hello world",
-    },
-    {
-      name: "preserves repeated single-character chunks",
-      existing: "Hel",
-      incoming: "l",
-      expected: "Hell",
-    },
-    {
-      name: "keeps short multi-character deltas without overlap",
-      existing: "He",
-      incoming: "llo",
-      expected: "Hello",
-    },
-    {
-      name: "drops repeated short suffix fragments already present",
-      existing: "abc",
-      incoming: "bc",
-      expected: "abc",
-    },
-  ])("$name", ({ existing, incoming, expected }) => {
-    expect(mergeStreamingText(existing, incoming)).toBe(expected);
-  });
-});