@elizaos/agent 2.0.0-beta.2 → 2.0.11-beta.6

package/packages/agent/src/actions/settings-actions.js

@@ -1,478 +0,0 @@
-/**
- * SETTINGS — single polymorphic owner-only action covering provider, capability,
- * training, owner-name, and worldSettings-registry mutations.
- *
- * Ops:
- *   - update_ai_provider → applyOnboardingConnectionConfig + saveElizaConfig
- *   - toggle_capability  → config.ui.capabilities.{wallet|browser|computerUse}
- *   - toggle_training    → app-training loadTrainingConfig/saveTrainingConfig
- *   - set_owner_name     → config.ui.ownerName via owner-name service
- *   - set                → worldSettings registry write (key/value list)
- *
- * Owner role gate is enforced action-wide. There is no chat-channel constraint
- * — the planner dispatches SETTINGS with explicit structured parameters.
- */
-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 { findWorldsForOwner, getSalt, logger, saltWorldSettings, unsaltWorldSettings, } from "@elizaos/core";
-import { getOnboardingProviderOption, normalizeOnboardingProviderId, } from "@elizaos/shared";
-import { applyOnboardingConnectionConfig, createProviderSwitchConnection, } from "../api/provider-switch-config.js";
-import { loadElizaConfig, saveElizaConfig } from "../config/config.js";
-import { fetchConfiguredOwnerName, OWNER_NAME_MAX_LENGTH, persistConfiguredOwnerName, } from "../services/owner-name.js";
-// ── Op catalog ────────────────────────────────────────────────────────────
-export const SETTINGS_OPS = [
-    "update_ai_provider",
-    "toggle_capability",
-    "toggle_training",
-    "set_owner_name",
-    "set",
-];
-// ── Constants ────────────────────────────────────────────────────────────
-const PROVIDER_API_KEY_MAX_LENGTH = 512;
-const MODEL_SLOT_MAX_LENGTH = 256;
-const CAPABILITY_KEYS = ["wallet", "browser", "computerUse"];
-const MODEL_SLOTS = ["nano", "small", "medium", "large", "mega"];
-const TRAINING_CONFIG_MODULE = "@elizaos/app-training";
-// ── Helpers ──────────────────────────────────────────────────────────────
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isCapabilityKey(value) {
-    return (typeof value === "string" &&
-        CAPABILITY_KEYS.includes(value));
-}
-function trimToString(value, max) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return undefined;
-    return trimmed.slice(0, max);
-}
-function fail(error, text, extra) {
-    return {
-        text,
-        success: false,
-        values: { success: false, error },
-        data: { actionName: "SETTINGS", error, ...(extra ?? {}) },
-    };
-}
-function ok(text, data) {
-    return {
-        text,
-        success: true,
-        values: { success: true },
-        data: { actionName: "SETTINGS", ...data },
-    };
-}
-function readParams(options) {
-    const raw = options?.parameters;
-    return isRecord(raw) ? raw : {};
-}
-// ── op: update_ai_provider ────────────────────────────────────────────────
-async function handleUpdateAiProvider(params) {
-    const rawProvider = params.provider;
-    if (typeof rawProvider !== "string" || !rawProvider.trim()) {
-        return fail("MISSING_PROVIDER", "SETTINGS update_ai_provider requires a `provider` (e.g. anthropic, openai, elizacloud).");
-    }
-    const normalizedProvider = normalizeOnboardingProviderId(rawProvider);
-    if (!normalizedProvider) {
-        return fail("UNKNOWN_PROVIDER", `Unknown AI provider: ${rawProvider}. Use one from the onboarding catalog (anthropic, openai, openrouter, gemini, grok, groq, deepseek, mistral, together, ollama, zai, elizacloud).`, { provider: rawProvider });
-    }
-    const apiKey = trimToString(params.apiKey, PROVIDER_API_KEY_MAX_LENGTH);
-    const modelConfigs = isRecord(params.modelConfigs)
-        ? params.modelConfigs
-        : null;
-    const primaryModel = trimToString(modelConfigs?.primary ?? modelConfigs?.large, MODEL_SLOT_MAX_LENGTH);
-    const config = loadElizaConfig();
-    const connection = normalizedProvider === "elizacloud"
-        ? {
-            kind: "cloud-managed",
-            cloudProvider: "elizacloud",
-            ...(apiKey ? { apiKey } : {}),
-        }
-        : createProviderSwitchConnection({
-            provider: normalizedProvider,
-            ...(apiKey ? { apiKey } : {}),
-            ...(primaryModel ? { primaryModel } : {}),
-        });
-    if (!connection) {
-        return fail("INVALID_PROVIDER", `Failed to build provider switch connection for ${normalizedProvider}.`, { provider: normalizedProvider });
-    }
-    try {
-        await applyOnboardingConnectionConfig(config, connection);
-        if (modelConfigs) {
-            const models = (config.models ?? {});
-            for (const slot of MODEL_SLOTS) {
-                const value = trimToString(modelConfigs[slot], MODEL_SLOT_MAX_LENGTH);
-                if (value)
-                    models[slot] = value;
-            }
-            config.models = models;
-        }
-        saveElizaConfig(config);
-    }
-    catch (err) {
-        logger.error({ error: err instanceof Error ? err.stack : String(err) }, "[SETTINGS] update_ai_provider failed");
-        return fail("SETTINGS_UPDATE_AI_PROVIDER_FAILED", `Failed to apply provider config: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    const providerOption = getOnboardingProviderOption(normalizedProvider);
-    return ok(`Switched AI provider to ${providerOption?.name ?? normalizedProvider}. Restart the agent to load the new provider.`, {
-        op: "update_ai_provider",
-        provider: normalizedProvider,
-        providerName: providerOption?.name ?? normalizedProvider,
-        ...(primaryModel ? { primaryModel } : {}),
-        requiresRestart: true,
-    });
-}
-// ── op: toggle_capability ────────────────────────────────────────────────
-function handleToggleCapability(params) {
-    const capability = params.capability;
-    if (!isCapabilityKey(capability)) {
-        return fail("UNKNOWN_CAPABILITY", `Unknown capability: ${String(capability)}. Must be one of: ${CAPABILITY_KEYS.join(", ")}.`, { allowed: [...CAPABILITY_KEYS] });
-    }
-    if (typeof params.enabled !== "boolean") {
-        return fail("MISSING_ENABLED", "SETTINGS toggle_capability requires `enabled: boolean`.");
-    }
-    const enabled = params.enabled;
-    try {
-        const config = loadElizaConfig();
-        const ui = isRecord(config.ui) ? config.ui : {};
-        const capabilities = isRecord(ui.capabilities) ? ui.capabilities : {};
-        capabilities[capability] = enabled;
-        ui.capabilities = capabilities;
-        config.ui = ui;
-        saveElizaConfig(config);
-    }
-    catch (err) {
-        logger.error({ error: err instanceof Error ? err.stack : String(err) }, "[SETTINGS] toggle_capability failed");
-        return fail("SETTINGS_TOGGLE_CAPABILITY_FAILED", `Failed to persist capability toggle: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    return ok(`Capability ${capability} is now ${enabled ? "enabled" : "disabled"}.`, { op: "toggle_capability", capability, enabled });
-}
-// ── op: toggle_training ──────────────────────────────────────────────────
-async function handleToggleTraining(params) {
-    if (typeof params.enabled !== "boolean") {
-        return fail("MISSING_ENABLED", "SETTINGS toggle_training requires `enabled: boolean`.");
-    }
-    const threshold = params.threshold;
-    if (threshold !== undefined &&
-        (typeof threshold !== "number" ||
-            !Number.isFinite(threshold) ||
-            threshold <= 0)) {
-        return fail("INVALID_THRESHOLD", "`threshold` must be a positive finite number when provided.");
-    }
-    const cooldownHours = params.cooldownHours;
-    if (cooldownHours !== undefined &&
-        (typeof cooldownHours !== "number" ||
-            !Number.isFinite(cooldownHours) ||
-            cooldownHours < 0)) {
-        return fail("INVALID_COOLDOWN", "`cooldownHours` must be a non-negative finite number when provided.");
-    }
-    let next;
-    try {
-        const mod = (await import(__rewriteRelativeImportExtension(TRAINING_CONFIG_MODULE)));
-        const current = mod.loadTrainingConfig();
-        next = {
-            ...current,
-            autoTrain: params.enabled,
-            ...(typeof threshold === "number"
-                ? { triggerThreshold: Math.floor(threshold) }
-                : {}),
-            ...(typeof cooldownHours === "number"
-                ? { triggerCooldownHours: cooldownHours }
-                : {}),
-        };
-        mod.saveTrainingConfig(next);
-    }
-    catch (err) {
-        logger.error({ error: err instanceof Error ? err.stack : String(err) }, "[SETTINGS] toggle_training failed");
-        return fail("SETTINGS_TOGGLE_TRAINING_FAILED", `Failed to update auto-training config: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    return ok(`Auto-training is now ${next.autoTrain ? "enabled" : "disabled"} (threshold ${next.triggerThreshold}, cooldown ${next.triggerCooldownHours}h).`, {
-        op: "toggle_training",
-        autoTrain: next.autoTrain,
-        triggerThreshold: next.triggerThreshold,
-        triggerCooldownHours: next.triggerCooldownHours,
-    });
-}
-// ── op: set_owner_name ───────────────────────────────────────────────────
-async function handleSetOwnerName(params) {
-    const raw = typeof params.name === "string" ? params.name.trim() : "";
-    const name = raw.slice(0, OWNER_NAME_MAX_LENGTH);
-    if (!name) {
-        return fail("INVALID_PARAMETERS", "SETTINGS set_owner_name requires a non-empty `name` parameter.");
-    }
-    const previous = await fetchConfiguredOwnerName();
-    const saved = await persistConfiguredOwnerName(name);
-    if (!saved) {
-        return fail("SETTINGS_SET_OWNER_NAME_FAILED", `Failed to persist owner name "${name}".`, { name });
-    }
-    return ok(previous
-        ? `Owner name updated from "${previous}" to "${name}".`
-        : `Owner name set to "${name}".`, { op: "set_owner_name", name, previous: previous ?? null });
-}
-function normalizeSettingValue(value) {
-    if (typeof value === "string" || typeof value === "boolean")
-        return value;
-    if (typeof value === "number" || typeof value === "bigint")
-        return String(value);
-    return null;
-}
-function readSettingUpdates(params) {
-    const updates = [];
-    const push = (rawKey, rawValue) => {
-        const key = typeof rawKey === "string" ? rawKey.trim() : "";
-        const value = normalizeSettingValue(rawValue);
-        if (key && value !== null)
-            updates.push({ key, value });
-    };
-    if (typeof params.key === "string" && params.value !== undefined) {
-        push(params.key, params.value);
-    }
-    if (Array.isArray(params.updates)) {
-        for (const entry of params.updates) {
-            if (isRecord(entry))
-                push(entry.key, entry.value);
-        }
-    }
-    return updates;
-}
-async function handleSet(runtime, ownerEntityId, params) {
-    const updates = readSettingUpdates(params);
-    if (!updates.length) {
-        return fail("INVALID_PARAMETERS", "SETTINGS set requires `key` + `value`, or an `updates: [{ key, value }]` array.");
-    }
-    if (!ownerEntityId) {
-        return fail("NO_OWNER_ENTITY", "SETTINGS set requires the calling message's entityId to resolve the owner world.");
-    }
-    const worlds = await findWorldsForOwner(runtime, ownerEntityId);
-    const world = worlds?.find((w) => w.metadata?.settings);
-    if (!world) {
-        return fail("NO_OWNER_WORLD", "No world with a settings registry was found for the calling owner.");
-    }
-    const salt = getSalt();
-    const rawSettings = world.metadata?.settings;
-    const worldSettings = rawSettings
-        ? unsaltWorldSettings(rawSettings, salt)
-        : undefined;
-    if (!worldSettings) {
-        return fail("NO_SETTINGS_REGISTRY", "The owner world has no settings registry.");
-    }
-    const registry = worldSettings.settings ?? {};
-    const next = { ...registry };
-    const applied = [];
-    const skipped = [];
-    for (const update of updates) {
-        const setting = next[update.key];
-        if (!setting) {
-            skipped.push({ key: update.key, reason: "UNKNOWN_KEY" });
-            continue;
-        }
-        if (setting.dependsOn?.length) {
-            const depsMet = setting.dependsOn.every((dep) => next[dep] && next[dep].value !== null);
-            if (!depsMet) {
-                skipped.push({ key: update.key, reason: "DEPENDENCY_NOT_MET" });
-                continue;
-            }
-        }
-        next[update.key] = { ...setting, value: update.value };
-        applied.push(update);
-        if (typeof setting.onSetAction === "function") {
-            setting.onSetAction(update.value);
-        }
-    }
-    if (!applied.length) {
-        return fail("NO_VALID_UPDATES", "No valid setting updates were applied.", {
-            skipped,
-        });
-    }
-    const merged = { ...worldSettings, settings: next };
-    if (!world.metadata)
-        world.metadata = {};
-    world.metadata.settings = saltWorldSettings(merged, salt);
-    try {
-        await runtime.updateWorld(world);
-    }
-    catch (err) {
-        logger.error({
-            error: err instanceof Error ? err.stack : String(err),
-            worldId: world.id,
-        }, "[SETTINGS] set failed to persist world settings");
-        return fail("SETTINGS_SET_FAILED", `Failed to persist setting updates: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    return ok(`Updated ${applied.length} setting${applied.length === 1 ? "" : "s"}.`, {
-        op: "set",
-        applied,
-        skipped,
-        worldId: world.id,
-    });
-}
-// ── Action ───────────────────────────────────────────────────────────────
-export const settingsAction = {
-    name: "SETTINGS",
-    contexts: ["settings", "admin", "agent_internal"],
-    roleGate: { minRole: "OWNER" },
-    similes: [
-        // Old leaf action names
-        "UPDATE_AI_PROVIDER",
-        "TOGGLE_CAPABILITY",
-        "TOGGLE_AUTO_TRAINING",
-        "SET_USER_NAME",
-        "SET_OWNER_NAME",
-        "UPDATE_OWNER_NAME",
-        // Common aliases
-        "REMEMBER_NAME",
-        "SAVE_NAME",
-        "SET_NAME",
-    ],
-    description: "Owner-only polymorphic settings mutation. Dispatches on `action` to update " +
-        "AI provider, toggle a capability, toggle/configure auto-training, set " +
-        "the owner display name, or write to the world's settings registry.",
-    descriptionCompressed: "owner-only settings mutation dispatch on action update AI provider, toggle capability, toggle/configure auto-train, set owner display name, write world settings registry",
-    validate: async () => true,
-    parameters: [
-        {
-            name: "action",
-            description: `Operation discriminator. One of: ${SETTINGS_OPS.join(", ")}.`,
-            required: true,
-            schema: { type: "string" },
-        },
-        {
-            name: "provider",
-            description: "[update_ai_provider] AI provider id (anthropic, openai, openrouter, gemini, grok, groq, deepseek, mistral, together, ollama, zai, elizacloud).",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "apiKey",
-            description: "[update_ai_provider] Optional API key for the provider.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "modelConfigs",
-            description: "[update_ai_provider] Optional model slot overrides — `nano|small|medium|large|mega` or `primary`.",
-            required: false,
-            schema: { type: "object" },
-        },
-        {
-            name: "capability",
-            description: `[toggle_capability] Capability key. One of: ${CAPABILITY_KEYS.join(", ")}.`,
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "enabled",
-            description: "[toggle_capability | toggle_training] Boolean enable flag.",
-            required: false,
-            schema: { type: "boolean" },
-        },
-        {
-            name: "threshold",
-            description: "[toggle_training] Optional positive integer — trajectories per task that triggers a run.",
-            required: false,
-            schema: { type: "number" },
-        },
-        {
-            name: "cooldownHours",
-            description: "[toggle_training] Optional non-negative number — minimum hours between runs for the same task.",
-            required: false,
-            schema: { type: "number" },
-        },
-        {
-            name: "name",
-            description: `[set_owner_name] New owner display name (1–${OWNER_NAME_MAX_LENGTH} chars after trim).`,
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "key",
-            description: "[set] Setting registry key.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "value",
-            description: "[set] Setting value (string | boolean | number).",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "updates",
-            description: "[set] Optional array of `{ key, value }` for bulk writes.",
-            required: false,
-            schema: { type: "array" },
-        },
-    ],
-    handler: async (runtime, message, _state, options) => {
-        const params = readParams(options);
-        const op = params.action ?? params.subaction ?? params.op;
-        switch (op) {
-            case "update_ai_provider":
-                return handleUpdateAiProvider(params);
-            case "toggle_capability":
-                return handleToggleCapability(params);
-            case "toggle_training":
-                return handleToggleTraining(params);
-            case "set_owner_name":
-                return handleSetOwnerName(params);
-            case "set":
-                return handleSet(runtime, message?.entityId, params);
-            default:
-                return fail("SETTINGS_INVALID", `SETTINGS requires \`action\`. One of: ${SETTINGS_OPS.join(", ")}.`, { op: typeof op === "string" ? op : null });
-        }
-    },
-    examples: [
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "Switch to Anthropic with my API key sk-ant-xxx." },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Switched AI provider to Anthropic. Restart the agent to load the new provider.",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "Turn off the wallet capability." },
-            },
-            {
-                name: "{{agentName}}",
-                content: { text: "Capability wallet is now disabled." },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "Turn on auto-training." },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Auto-training is now enabled (threshold 100, cooldown 12h).",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "Change my display name to Sam." },
-            },
-            {
-                name: "{{agentName}}",
-                content: { text: 'Owner name set to "Sam".' },
-            },
-        ],
-    ],
-};

package/packages/agent/src/actions/skill-command.d.ts

@@ -1,20 +0,0 @@
-/**
- * Skill slash-command dispatch action.
- *
- * When the user types `/<skill-slug> <args>`, this action bypasses normal LLM
- * routing and immediately loads the skill's full instructions, then responds
- * with the skill context + user args so the agent can act on them directly.
- *
- * Works with @elizaos/plugin-commands — skills are registered as commands
- * in the registry during eliza-plugin init(), and this action handles the
- * dispatch when a skill command is detected.
- */
-import type { Action } from "@elizaos/core";
-/**
- * Called from eliza-plugin init() after skills are loaded.
- * Populates the set so validate() can match quickly.
- */
-export declare function addRegisteredSkillSlug(slug: string): void;
-export declare function clearRegisteredSkillSlugs(): void;
-export declare const skillCommandAction: Action;
-//# sourceMappingURL=skill-command.d.ts.map

package/packages/agent/src/actions/skill-command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-command.d.ts","sourceRoot":"","sources":["../../../../../src/actions/skill-command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,MAAM,EAQP,MAAM,eAAe,CAAC;AAOvB;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEzD;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD;AAoCD,eAAO,MAAM,kBAAkB,EAAE,MA0JhC,CAAC"}

package/packages/agent/src/actions/skill-command.js

@@ -1,170 +0,0 @@
-/**
- * Skill slash-command dispatch action.
- *
- * When the user types `/<skill-slug> <args>`, this action bypasses normal LLM
- * routing and immediately loads the skill's full instructions, then responds
- * with the skill context + user args so the agent can act on them directly.
- *
- * Works with @elizaos/plugin-commands — skills are registered as commands
- * in the registry during eliza-plugin init(), and this action handles the
- * dispatch when a skill command is detected.
- */
-import { logger } from "@elizaos/core";
-/** Set of registered skill slugs — populated by registerSkillCommands(). */
-const registeredSkillSlugs = new Set();
-/**
- * Called from eliza-plugin init() after skills are loaded.
- * Populates the set so validate() can match quickly.
- */
-export function addRegisteredSkillSlug(slug) {
-    registeredSkillSlugs.add(slug.toLowerCase());
-}
-export function clearRegisteredSkillSlugs() {
-    registeredSkillSlugs.clear();
-}
-/**
- * Extract skill slug from a slash-command message.
- * Returns null if the message doesn't match a registered skill.
- */
-function extractSkillSlug(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith("/"))
-        return null;
-    // Extract the command part (everything up to first space)
-    const spaceIdx = trimmed.indexOf(" ");
-    const commandPart = spaceIdx === -1 ? trimmed.substring(1) : trimmed.substring(1, spaceIdx);
-    const args = spaceIdx === -1 ? "" : trimmed.substring(spaceIdx + 1).trim();
-    const slug = commandPart.toLowerCase();
-    if (registeredSkillSlugs.has(slug)) {
-        return { slug, args };
-    }
-    return null;
-}
-function skillCommandResult(success, text, data) {
-    return {
-        success,
-        text,
-        values: { success, actionName: "SKILL_COMMAND" },
-        data: { actionName: "SKILL_COMMAND", ...data },
-    };
-}
-export const skillCommandAction = {
-    name: "SKILL_COMMAND",
-    contexts: ["admin", "agent_internal", "automation"],
-    roleGate: { minRole: "ADMIN" },
-    similes: ["/skill"],
-    description: "Dispatch a slash command to an installed skill. Loads the skill's instructions and responds with contextual guidance.",
-    descriptionCompressed: "dispatch slash command install skill load skill instruction respond w/ contextual guidance",
-    validate: async (_runtime, _message) => {
-        return registeredSkillSlugs.size > 0;
-    },
-    handler: async (runtime, message, _state, _options, callback) => {
-        const params = _options?.parameters;
-        const nativeSlug = typeof params?.slug === "string" ? params.slug.trim().toLowerCase() : "";
-        const nativeArgs = typeof params?.args === "string" ? params.args.trim() : "";
-        const text = message.content?.text ?? "";
-        const match = nativeSlug && registeredSkillSlugs.has(nativeSlug)
-            ? { slug: nativeSlug, args: nativeArgs }
-            : extractSkillSlug(text);
-        if (!match) {
-            const text = "Could not identify a skill command. Use /help to see available commands.";
-            await callback?.({ text });
-            return skillCommandResult(false, text, {
-                reason: "unknown_skill_command",
-            });
-        }
-        const service = runtime.getService("AGENT_SKILLS_SERVICE");
-        if (!service) {
-            const text = "Skills service is not available. The agent is still starting up.";
-            await callback?.({ text });
-            return skillCommandResult(false, text, {
-                slug: match.slug,
-                reason: "skills_service_unavailable",
-            });
-        }
-        const instructions = service.getSkillInstructions(match.slug);
-        if (!instructions?.body) {
-            const text = `Skill "${match.slug}" is registered but has no instructions available.`;
-            await callback?.({ text });
-            return skillCommandResult(false, text, {
-                slug: match.slug,
-                reason: "skill_instructions_unavailable",
-            });
-        }
-        // Cap instructions to keep context reasonable
-        const maxChars = 3000;
-        const body = instructions.body.length > maxChars
-            ? `${instructions.body.substring(0, maxChars)}\n\n...[truncated — full instructions available via USE_SKILL]`
-            : instructions.body;
-        // Find the skill name for display
-        const skills = service.getLoadedSkills();
-        const skill = skills.find((s) => s.slug.toLowerCase() === match.slug);
-        const skillName = skill?.name ?? match.slug;
-        logger.info(`[skill-command] Dispatching /${match.slug}${match.args ? ` ${match.args}` : ""}`);
-        // Inject the skill instructions + user's request as a structured prompt
-        const userRequest = match.args || "General help with this skill";
-        const response = [
-            `## Skill: ${skillName}`,
-            "",
-            body,
-            "",
-            `---`,
-            "",
-            `**User request:** ${userRequest}`,
-            "",
-            `Follow the skill instructions above to help with this request. If the skill requires specific tools or CLI commands, explain what needs to happen.`,
-        ].join("\n");
-        await callback?.({
-            text: response,
-            actions: ["SKILL_COMMAND"],
-        });
-        return skillCommandResult(true, response, {
-            slug: match.slug,
-            args: match.args,
-            skillName,
-            bodyTruncated: instructions.body.length > maxChars,
-        });
-    },
-    parameters: [
-        {
-            name: "slug",
-            description: "Registered skill slug to dispatch.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "args",
-            description: "Optional arguments or request text for the skill.",
-            required: false,
-            schema: { type: "string" },
-        },
-    ],
-    examples: [
-        [
-            {
-                name: "{{user1}}",
-                content: { text: "/github create an issue about the login bug" },
-            },
-            {
-                name: "{{agent}}",
-                content: {
-                    text: "## Skill: GitHub\n\nRelevant GitHub skill instructions.\n\n---\n\n**User request:** create an issue about the login bug",
-                    actions: ["SKILL_COMMAND"],
-                },
-            },
-        ],
-        [
-            {
-                name: "{{user1}}",
-                content: { text: "/weather tokyo" },
-            },
-            {
-                name: "{{agent}}",
-                content: {
-                    text: "## Skill: Weather\n\nRelevant weather skill instructions.\n\n---\n\n**User request:** tokyo",
-                    actions: ["SKILL_COMMAND"],
-                },
-            },
-        ],
-    ],
-};