@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/providers/onboarding-progress.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Onboarding Progress Provider
+ *
+ * Injects onboarding state into LLM context. Shows current step,
+ * what's configured, and what's missing.
+ */
+import type { Provider } from "../types";
+/**
+ * Onboarding Progress Provider
+ *
+ * Provides the current onboarding state to the LLM context.
+ * Only active when onboarding is in progress.
+ */
+export declare const onboardingProgressProvider: Provider;
+/**
+ * Provider that shows what's missing in the onboarding.
+ */
+export declare const onboardingMissingProvider: Provider;
+//# sourceMappingURL=onboarding-progress.d.ts.map

package/packages/typescript/src/providers/onboarding-progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding-progress.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/providers/onboarding-progress.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAGX,QAAQ,EAGR,MAAM,UAAU,CAAC;AA+JlB;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,EAAE,QAmFxC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,yBAAyB,EAAE,QA4EvC,CAAC"}

package/packages/typescript/src/providers/onboarding-progress.js

@@ -0,0 +1,268 @@
+/**
+ * Onboarding Progress Provider
+ *
+ * Injects onboarding state into LLM context. Shows current step,
+ * what's configured, and what's missing.
+ */
+import { logger } from "../logger";
+import { calculateProgress, ONBOARDING_STEP_DESCRIPTIONS, ONBOARDING_STEP_LABELS, OnboardingStep, } from "../types/onboarding";
+import { ChannelType } from "../types/primitives";
+/**
+ * Format a step status for display.
+ */
+function formatStepStatus(status) {
+    switch (status) {
+        case "completed":
+            return "✓";
+        case "current":
+            return "→";
+        case "pending":
+            return "○";
+        case "error":
+            return "✗";
+    }
+}
+/**
+ * Generate onboarding progress text for LLM context.
+ */
+function generateProgressText(context, agentName) {
+    const progress = calculateProgress(context);
+    const currentStep = context.currentStep;
+    const isComplete = currentStep === OnboardingStep.COMPLETE;
+    if (isComplete) {
+        return `## Onboarding Status: Complete
+
+${agentName} has been fully configured and is ready to operate.
+
+Completed setup:
+${context.completedSteps.map((step) => `- ${ONBOARDING_STEP_LABELS[step]}`).join("\n")}`;
+    }
+    let output = `## Onboarding Status: ${progress}% Complete
+
+**Current Step:** ${ONBOARDING_STEP_LABELS[currentStep]}
+**Description:** ${ONBOARDING_STEP_DESCRIPTIONS[currentStep]}
+
+### Progress:
+`;
+    // List all steps with their status
+    for (const step of Object.values(OnboardingStep)) {
+        if (step === OnboardingStep.COMPLETE)
+            continue;
+        let status;
+        if (context.completedSteps.includes(step)) {
+            status = formatStepStatus("completed");
+        }
+        else if (step === currentStep) {
+            status = formatStepStatus("current");
+        }
+        else {
+            status = formatStepStatus("pending");
+        }
+        output += `${status} ${ONBOARDING_STEP_LABELS[step]}\n`;
+    }
+    // Add configured settings summary
+    output += "\n### Configuration Summary:\n";
+    if (context.settings.riskAcknowledged) {
+        output += "- Risk acknowledgement: Accepted\n";
+    }
+    if (context.settings.auth) {
+        const auth = context.settings.auth;
+        output += `- Authentication: ${auth.modelProvider || "Not set"} (${auth.authMethod || "not configured"})\n`;
+    }
+    else {
+        output += "- Authentication: Not configured\n";
+    }
+    if (context.settings.channels) {
+        const channels = context.settings.channels;
+        if (channels.enabledChannels.length > 0) {
+            output += `- Channels: ${channels.enabledChannels.join(", ")}\n`;
+        }
+        else {
+            output += "- Channels: None configured\n";
+        }
+    }
+    else {
+        output += "- Channels: Not configured\n";
+    }
+    if (context.settings.skills) {
+        const skills = context.settings.skills;
+        if (skills.enabledSkills.length > 0) {
+            output += `- Skills: ${skills.enabledSkills.join(", ")}\n`;
+        }
+        else {
+            output += "- Skills: None configured\n";
+        }
+    }
+    else {
+        output += "- Skills: Not configured\n";
+    }
+    // Add errors if any
+    if (context.errors.length > 0) {
+        output += "\n### Errors:\n";
+        for (const error of context.errors) {
+            output += `- [${ONBOARDING_STEP_LABELS[error.step]}] ${error.message}\n`;
+        }
+    }
+    // Add instructions based on current step
+    output += `\n### Instructions for ${agentName}:\n`;
+    switch (currentStep) {
+        case OnboardingStep.WELCOME:
+            output += "- Greet the user and ask if they're ready to begin setup\n";
+            output += "- Explain what the onboarding process will cover\n";
+            break;
+        case OnboardingStep.RISK_ACK:
+            output += "- Present the security and risk information to the user\n";
+            output += "- User MUST explicitly acknowledge to proceed\n";
+            output += "- Do not proceed without explicit acceptance\n";
+            break;
+        case OnboardingStep.AUTH:
+            output +=
+                "- Help the user configure authentication with an AI provider\n";
+            output +=
+                "- Supported providers: Anthropic, OpenAI, Google, Groq, etc.\n";
+            output +=
+                "- Ask for their API key or guide them through OAuth if available\n";
+            output += "- This step can be skipped if using local models\n";
+            break;
+        case OnboardingStep.CHANNELS:
+            output +=
+                "- Help the user configure messaging channels (Discord, Telegram, etc.)\n";
+            output += "- Each channel requires appropriate tokens/credentials\n";
+            output += "- This step can be skipped and configured later\n";
+            break;
+        case OnboardingStep.SKILLS:
+            output += "- Help the user configure agent skills and capabilities\n";
+            output += "- Skills may require dependencies to be installed\n";
+            output += "- This step can be skipped and configured later\n";
+            break;
+    }
+    return output;
+}
+/**
+ * Onboarding Progress Provider
+ *
+ * Provides the current onboarding state to the LLM context.
+ * Only active when onboarding is in progress.
+ */
+export const onboardingProgressProvider = {
+    name: "ONBOARDING_PROGRESS",
+    description: "Current onboarding progress and state for the agent",
+    get: async (runtime, message, _state) => {
+        // Get the room to determine context
+        const room = await runtime.getRoom(message.roomId);
+        if (!room?.worldId) {
+            return {
+                data: { onboarding: null },
+                values: { onboardingProgress: "" },
+                text: "",
+            };
+        }
+        // Only show onboarding progress in DM contexts
+        if (room.type !== ChannelType.DM) {
+            return {
+                data: { onboarding: null },
+                values: { onboardingProgress: "" },
+                text: "",
+            };
+        }
+        // Try to get onboarding state from world metadata
+        const world = await runtime.getWorld(room.worldId);
+        if (!world?.metadata) {
+            return {
+                data: { onboarding: null },
+                values: { onboardingProgress: "" },
+                text: "",
+            };
+        }
+        // Look for serialized state machine state
+        const metadata = world.metadata;
+        if (!metadata.onboardingStateMachine) {
+            return {
+                data: { onboarding: null },
+                values: { onboardingProgress: "" },
+                text: "",
+            };
+        }
+        const context = metadata.onboardingStateMachine.context;
+        const agentName = runtime.character.name ?? "Agent";
+        const progressText = generateProgressText(context, agentName);
+        logger.debug({
+            worldId: room.worldId,
+            currentStep: context.currentStep,
+            progress: calculateProgress(context),
+        }, "[OnboardingProgressProvider] Providing onboarding context");
+        return {
+            data: {
+                onboarding: {
+                    context,
+                    isComplete: context.currentStep === OnboardingStep.COMPLETE,
+                    progress: calculateProgress(context),
+                },
+            },
+            values: {
+                onboardingProgress: progressText,
+                currentOnboardingStep: context.currentStep,
+                onboardingComplete: String(context.currentStep === OnboardingStep.COMPLETE),
+            },
+            text: progressText,
+        };
+    },
+};
+/**
+ * Provider that shows what's missing in the onboarding.
+ */
+export const onboardingMissingProvider = {
+    name: "ONBOARDING_MISSING",
+    description: "Lists what still needs to be configured during onboarding",
+    get: async (runtime, message, _state) => {
+        const room = await runtime.getRoom(message.roomId);
+        if (!room?.worldId) {
+            return {
+                data: { missing: [] },
+                values: { onboardingMissing: "" },
+                text: "",
+            };
+        }
+        const world = await runtime.getWorld(room.worldId);
+        const metadata = world?.metadata;
+        if (!metadata?.onboardingStateMachine) {
+            return {
+                data: { missing: [] },
+                values: { onboardingMissing: "" },
+                text: "",
+            };
+        }
+        const context = metadata.onboardingStateMachine.context;
+        // Determine what's missing
+        const missing = [];
+        if (!context.settings.riskAcknowledged) {
+            missing.push("Risk acknowledgement");
+        }
+        if (!context.settings.auth?.apiKey && !context.settings.auth?.oauthTokens) {
+            missing.push("AI provider authentication");
+        }
+        if (!context.settings.channels ||
+            context.settings.channels.enabledChannels.length === 0) {
+            missing.push("Messaging channels");
+        }
+        if (!context.settings.skills ||
+            context.settings.skills.enabledSkills.length === 0) {
+            missing.push("Agent skills");
+        }
+        if (missing.length === 0) {
+            return {
+                data: { missing: [] },
+                values: {
+                    onboardingMissing: "All onboarding steps have been completed.",
+                },
+                text: "All onboarding steps have been completed.",
+            };
+        }
+        const text = `Still needs configuration:\n${missing.map((m) => `- ${m}`).join("\n")}`;
+        return {
+            data: { missing },
+            values: { onboardingMissing: text },
+            text,
+        };
+    },
+};

package/packages/typescript/src/providers/skill-eligibility.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Skill Eligibility Provider
+ *
+ * Provides LLM context about which skills are eligible for use,
+ * which are ineligible, and why. Helps the LLM make informed
+ * decisions about skill usage and suggest fixes for missing deps.
+ *
+ * @module providers/skill-eligibility
+ */
+import type { Provider } from "../types/index.js";
+/**
+ * Skill Eligibility Provider
+ *
+ * Injects information about skill eligibility into the LLM context:
+ * - List of eligible skills that are ready to use
+ * - List of ineligible skills with reasons and suggested fixes
+ * - Summary of what's missing (binaries, env vars, config)
+ */
+export declare const skillEligibilityProvider: Provider;
+/**
+ * Compact Skill Eligibility Provider
+ *
+ * A more compact version that only shows ineligible skills.
+ * Good for systems with many skills.
+ */
+export declare const skillEligibilityCompactProvider: Provider;
+export default skillEligibilityProvider;
+//# sourceMappingURL=skill-eligibility.d.ts.map

package/packages/typescript/src/providers/skill-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-eligibility.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/providers/skill-eligibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAGX,QAAQ,EAGR,MAAM,mBAAmB,CAAC;AAqD3B;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,QAoJtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAwD7C,CAAC;AAEF,eAAe,wBAAwB,CAAC"}

package/packages/typescript/src/providers/skill-eligibility.js

@@ -0,0 +1,179 @@
+/**
+ * Skill Eligibility Provider
+ *
+ * Provides LLM context about which skills are eligible for use,
+ * which are ineligible, and why. Helps the LLM make informed
+ * decisions about skill usage and suggest fixes for missing deps.
+ *
+ * @module providers/skill-eligibility
+ */
+// ============================================================
+// PROVIDER
+// ============================================================
+/**
+ * Skill Eligibility Provider
+ *
+ * Injects information about skill eligibility into the LLM context:
+ * - List of eligible skills that are ready to use
+ * - List of ineligible skills with reasons and suggested fixes
+ * - Summary of what's missing (binaries, env vars, config)
+ */
+export const skillEligibilityProvider = {
+    name: "skill_eligibility",
+    description: "Shows which skills are eligible and which have missing dependencies",
+    position: -5, // After skill metadata, before instructions
+    dynamic: true,
+    get: async (runtime, _message, _state) => {
+        // Try to get the agent skills service
+        const service = runtime.getService("AGENT_SKILLS_SERVICE");
+        if (!service) {
+            return { text: "" };
+        }
+        try {
+            const [eligible, ineligible] = await Promise.all([
+                service.getEligibleSkills(),
+                service.getIneligibleSkills(),
+            ]);
+            // If all skills are eligible, return simple message
+            if (ineligible.length === 0) {
+                return {
+                    text: `**Skill Status:** All ${eligible.length} installed skills are ready to use.`,
+                    values: {
+                        eligibleCount: eligible.length,
+                        ineligibleCount: 0,
+                    },
+                    data: {
+                        eligible: eligible.map((s) => s.slug),
+                        ineligible: [],
+                    },
+                };
+            }
+            // Build detailed output
+            const lines = [];
+            lines.push(`## Skill Eligibility`);
+            lines.push("");
+            // Eligible skills
+            if (eligible.length > 0) {
+                lines.push(`### Ready to Use (${eligible.length})`);
+                for (const skill of eligible.slice(0, 10)) {
+                    lines.push(`- **${skill.name}** (${skill.slug})`);
+                }
+                if (eligible.length > 10) {
+                    lines.push(`- ...and ${eligible.length - 10} more`);
+                }
+                lines.push("");
+            }
+            // Ineligible skills with reasons
+            lines.push(`### Missing Dependencies (${ineligible.length})`);
+            lines.push("");
+            for (const { skill, eligibility } of ineligible) {
+                lines.push(`#### ${skill.name} (${skill.slug})`);
+                // Group reasons by type
+                const binReasons = eligibility.reasons.filter((r) => r.type === "bin");
+                const envReasons = eligibility.reasons.filter((r) => r.type === "env");
+                const configReasons = eligibility.reasons.filter((r) => r.type === "config");
+                if (binReasons.length > 0) {
+                    lines.push(`- Missing binaries: ${binReasons.map((r) => r.missing).join(", ")}`);
+                    // Show installation suggestions
+                    for (const reason of binReasons) {
+                        if (reason.suggestion) {
+                            lines.push(`  - ${reason.suggestion}`);
+                        }
+                    }
+                }
+                if (envReasons.length > 0) {
+                    lines.push(`- Missing env vars: ${envReasons.map((r) => r.missing).join(", ")}`);
+                }
+                if (configReasons.length > 0) {
+                    lines.push(`- Missing config: ${configReasons.map((r) => r.missing).join(", ")}`);
+                }
+                lines.push("");
+            }
+            // Add summary of fixes
+            const allReasons = ineligible.flatMap((i) => i.eligibility.reasons);
+            const missingBins = [
+                ...new Set(allReasons.filter((r) => r.type === "bin").map((r) => r.missing)),
+            ];
+            const missingEnv = [
+                ...new Set(allReasons.filter((r) => r.type === "env").map((r) => r.missing)),
+            ];
+            if (missingBins.length > 0 || missingEnv.length > 0) {
+                lines.push("### To enable more skills:");
+                if (missingBins.length > 0) {
+                    lines.push(`- Install: ${missingBins.slice(0, 5).join(", ")}${missingBins.length > 5 ? ` (+${missingBins.length - 5} more)` : ""}`);
+                }
+                if (missingEnv.length > 0) {
+                    lines.push(`- Set env: ${missingEnv.slice(0, 5).join(", ")}${missingEnv.length > 5 ? ` (+${missingEnv.length - 5} more)` : ""}`);
+                }
+            }
+            return {
+                text: lines.join("\n"),
+                values: {
+                    eligibleCount: eligible.length,
+                    ineligibleCount: ineligible.length,
+                    missingBinaries: missingBins,
+                    missingEnvVars: missingEnv,
+                },
+                data: {
+                    eligible: eligible.map((s) => s.slug),
+                    ineligible: ineligible.map((i) => ({
+                        slug: i.skill.slug,
+                        reasons: i.eligibility.reasons,
+                    })),
+                },
+            };
+        }
+        catch (_error) {
+            // Service might not support eligibility checking
+            return { text: "" };
+        }
+    },
+};
+/**
+ * Compact Skill Eligibility Provider
+ *
+ * A more compact version that only shows ineligible skills.
+ * Good for systems with many skills.
+ */
+export const skillEligibilityCompactProvider = {
+    name: "skill_eligibility_compact",
+    description: "Compact view of ineligible skills only",
+    position: -5,
+    dynamic: true,
+    get: async (runtime, _message, _state) => {
+        const service = runtime.getService("AGENT_SKILLS_SERVICE");
+        if (!service) {
+            return { text: "" };
+        }
+        try {
+            const ineligible = await service.getIneligibleSkills();
+            if (ineligible.length === 0) {
+                return { text: "" }; // All skills ready, no need to mention
+            }
+            const skillNames = ineligible.map((i) => i.skill.slug).join(", ");
+            const missingBins = [
+                ...new Set(ineligible.flatMap((i) => i.eligibility.reasons
+                    .filter((r) => r.type === "bin")
+                    .map((r) => r.missing))),
+            ];
+            let text = `⚠️ Skills unavailable: ${skillNames}`;
+            if (missingBins.length > 0) {
+                text += ` (missing: ${missingBins.join(", ")})`;
+            }
+            return {
+                text,
+                values: {
+                    ineligibleCount: ineligible.length,
+                },
+                data: {
+                    ineligible: ineligible.map((i) => i.skill.slug),
+                    missingBins,
+                },
+            };
+        }
+        catch {
+            return { text: "" };
+        }
+    },
+};
+export default skillEligibilityProvider;

package/packages/typescript/src/provisioning.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Agent provisioning: migrations, agent/entity/room setup, embedding dimension.
+ * Runs once at deploy/daemon boot; not part of runtime.initialize().
+ * Export from node entry point only (not browser/edge).
+ *
+ * WHY this module exists:
+ * - Keeps the runtime a lean request handler; heavy one-time setup lives here.
+ * - Edge and ephemeral runtimes can skip provisioning entirely (they don't import this).
+ * - Daemon entry points call provisionAgent() once after initialize().
+ */
+import type { Character, UUID } from "./types";
+import type { IDatabaseAdapter } from "./types/database";
+import type { IAgentRuntime } from "./types/runtime";
+export interface ProvisionAgentOptions {
+    /** Run plugin schema migrations (DDL). Default true for daemon. */
+    runMigrations?: boolean;
+}
+/**
+ * Run plugin migrations (DDL) using the runtime's adapter and registered plugins.
+ * WHY standalone: Migrations are a one-time basic-capabilities step; not part of initialize()
+ * so ephemeral/edge runtimes never run them. process.env guards allow safe use in Node only.
+ */
+export declare function runPluginMigrations(runtime: IAgentRuntime): Promise<void>;
+/**
+ * Ensure agent row exists, then entity, self-room, and self-participant.
+ * Uses batch adapter APIs (getAgentsByIds, createEntities, getRoomsByIds, etc.).
+ * WHY: Agent must exist before the runtime can store memories/tasks; self-room and
+ * participant are required for core conversation flow.
+ */
+export declare function ensureAgentInfrastructure(runtime: IAgentRuntime): Promise<void>;
+/**
+ * Set embedding dimension on the adapter from config (no LLM call).
+ * Uses EMBEDDING_DIMENSION setting if set; otherwise skips.
+ * WHY no LLM: Avoids a model call at boot; set EMBEDDING_DIMENSION in character
+ * settings when using this path. If unset, embedding search may fail until dimension is set.
+ */
+export declare function ensureEmbeddingDimension(runtime: IAgentRuntime): Promise<void>;
+/**
+ * Orchestrator: run migrations (optional), ensure agent/entity/room/participant, set embedding dimension.
+ * Call after runtime.initialize() in daemon mode.
+ * WHY separate from initialize(): Ephemeral and edge runtimes do not call this;
+ * only long-lived daemons run it once at boot.
+ */
+export declare function provisionAgent(runtime: IAgentRuntime, options?: ProvisionAgentOptions): Promise<void>;
+/**
+ * Read agent from DB and merge settings/secrets into the given character.
+ * Returns a new Character; does not mutate the input.
+ * If no agent exists in DB, returns the character unchanged.
+ * Call before constructing the runtime so the runtime gets merged settings.
+ * WHY before runtime: The runtime constructor does not touch the DB; the host
+ * loads DB-backed config once and passes the merged character in.
+ */
+export declare function mergeDbSettings(character: Character, adapter: IDatabaseAdapter, agentId: UUID): Promise<Character>;
+//# sourceMappingURL=provisioning.d.ts.map

package/packages/typescript/src/provisioning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provisioning.d.ts","sourceRoot":"","sources":["../../../../../typescript/src/provisioning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAS,SAAS,EAAa,IAAI,EAAE,MAAM,SAAS,CAAC;AAEjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrD,MAAM,WAAW,qBAAqB;IACrC,mEAAmE;IACnE,aAAa,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,IAAI,CAAC,CA2Df;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC9C,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,IAAI,CAAC,CAyDf;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC7C,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,IAAI,CAAC,CAiCf;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CACnC,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE,qBAA0B,GACjC,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACpC,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,IAAI,GACX,OAAO,CAAC,SAAS,CAAC,CAyDpB"}