@elizaos/agent 0.25.9 → 2.0.0-alpha.144

package/apps/app-training/src/core/scenario-blueprints.js

@@ -0,0 +1,790 @@
+/**
+ * Scenario blueprints for synthetic training data generation.
+ *
+ * Each blueprint describes a canonical conversation scenario. The generator
+ * expands each blueprint into multiple variants by randomizing:
+ * - Agent name (prevents statistical name pollution)
+ * - Participant names and count
+ * - Platform (telegram, discord, slack, etc.)
+ * - Tone, length, and distractor turns
+ * - Context specificity (subtle → explicit)
+ *
+ * Blueprints are categorized by:
+ * 1. Decision type: RESPOND | IGNORE | STOP
+ * 2. Context domain: general, wallet, knowledge, etc.
+ * 3. Conversation pattern: group_chat, group_noise, multi_turn_intent, etc.
+ */
+import { ACTION_CONTEXT_MAP, PROVIDER_CONTEXT_MAP } from "./context-catalog.js";
+import { AGENT_CONTEXTS } from "./context-types.js";
+// ==================== RESPOND scenarios ====================
+const respondGeneral = [
+    {
+        id: "respond-general-direct-mention-001",
+        decision: "RESPOND",
+        primaryContext: "general",
+        pattern: "group_direct_mention",
+        description: "Someone directly asks the agent a general question",
+        minContextTurns: 2,
+        maxContextTurns: 8,
+        groundingKeywords: ["hey", "what do you think", "can you help"],
+        generationHint: "Generate a group chat where participants discuss random topics, then one person directly addresses the agent by name with a general question.",
+    },
+    {
+        id: "respond-general-reply-chain-001",
+        decision: "RESPOND",
+        primaryContext: "general",
+        pattern: "group_reply_chain",
+        description: "Agent is in an active reply chain and should continue",
+        minContextTurns: 4,
+        maxContextTurns: 12,
+        groundingKeywords: ["thanks", "follow up", "what about"],
+        generationHint: "Generate a group chat where the agent has been actively replying, and the conversation continues with follow-up questions directed at the agent.",
+    },
+    {
+        id: "respond-general-subtle-mention-001",
+        decision: "RESPOND",
+        primaryContext: "general",
+        pattern: "group_subtle_mention",
+        description: "Agent's name is mentioned subtly in a question that requires response",
+        minContextTurns: 3,
+        maxContextTurns: 10,
+        groundingKeywords: ["mentioned", "asked"],
+        generationHint: "Generate a group chat where someone mentions the agent's name mid-sentence while asking it something. The mention should be natural, not a formal address.",
+    },
+];
+const respondWallet = [
+    {
+        id: "respond-wallet-balance-001",
+        decision: "RESPOND",
+        primaryContext: "wallet",
+        pattern: "group_direct_mention",
+        description: "Someone asks the agent to check a token balance",
+        minContextTurns: 1,
+        maxContextTurns: 5,
+        expectedAction: "CHECK_BALANCE",
+        groundingKeywords: ["balance", "tokens", "how much", "wallet"],
+        generationHint: "Generate a group chat about crypto, then someone asks the agent by name to check their token balance.",
+    },
+    {
+        id: "respond-wallet-swap-001",
+        decision: "RESPOND",
+        primaryContext: "wallet",
+        secondaryContexts: ["automation"],
+        pattern: "group_direct_mention",
+        description: "Someone asks the agent to swap tokens",
+        minContextTurns: 2,
+        maxContextTurns: 6,
+        expectedAction: "SWAP_TOKEN",
+        groundingKeywords: ["swap", "exchange", "trade", "convert"],
+        generationHint: "Generate a group chat where users discuss token prices, then someone asks the agent to swap ETH for USDC or similar.",
+    },
+    {
+        id: "respond-wallet-send-001",
+        decision: "RESPOND",
+        primaryContext: "wallet",
+        pattern: "group_direct_mention",
+        description: "Someone asks the agent to send tokens",
+        minContextTurns: 1,
+        maxContextTurns: 4,
+        expectedAction: "SEND_TOKEN",
+        groundingKeywords: ["send", "transfer", "to address"],
+        generationHint: "Generate a group chat where someone asks the agent to send tokens to a specific address.",
+    },
+    {
+        id: "respond-wallet-multi-turn-001",
+        decision: "RESPOND",
+        primaryContext: "wallet",
+        pattern: "group_multi_turn_intent",
+        description: "Wallet intent emerges over multiple turns of discussion before explicit request",
+        minContextTurns: 6,
+        maxContextTurns: 15,
+        expectedAction: "SWAP_TOKEN",
+        groundingKeywords: ["price", "market", "dip", "buy", "swap", "good time"],
+        generationHint: "Generate a long group chat where users discuss market conditions, token prices, and eventually one person decides to ask the agent to execute a swap. The intent should emerge gradually over several messages.",
+    },
+];
+const respondKnowledge = [
+    {
+        id: "respond-knowledge-search-001",
+        decision: "RESPOND",
+        primaryContext: "knowledge",
+        pattern: "group_direct_mention",
+        description: "Someone asks the agent to look something up",
+        minContextTurns: 2,
+        maxContextTurns: 6,
+        expectedAction: "SEARCH_KNOWLEDGE",
+        groundingKeywords: ["search", "find", "look up", "what is"],
+        generationHint: "Generate a group chat where someone asks the agent a factual question that requires knowledge lookup.",
+    },
+    {
+        id: "respond-knowledge-summarize-001",
+        decision: "RESPOND",
+        primaryContext: "knowledge",
+        pattern: "group_reply_chain",
+        description: "Agent is asked to summarize a discussion",
+        minContextTurns: 8,
+        maxContextTurns: 20,
+        expectedAction: "SUMMARIZE",
+        groundingKeywords: ["summarize", "tldr", "recap", "main points"],
+        generationHint: "Generate a long group discussion about a complex topic, then someone asks the agent to summarize the key points.",
+    },
+];
+const respondMedia = [
+    {
+        id: "respond-media-image-001",
+        decision: "RESPOND",
+        primaryContext: "media",
+        pattern: "group_direct_mention",
+        description: "Someone asks the agent to generate an image",
+        minContextTurns: 1,
+        maxContextTurns: 5,
+        expectedAction: "GENERATE_IMAGE",
+        groundingKeywords: ["generate", "create", "make", "image", "picture"],
+        generationHint: "Generate a group chat where someone asks the agent to generate an image of something specific.",
+    },
+    {
+        id: "respond-media-describe-001",
+        decision: "RESPOND",
+        primaryContext: "media",
+        secondaryContexts: ["knowledge"],
+        pattern: "group_direct_mention",
+        description: "Someone shares an image and asks the agent to describe it",
+        minContextTurns: 1,
+        maxContextTurns: 4,
+        expectedAction: "DESCRIBE_IMAGE",
+        groundingKeywords: ["describe", "what is this", "what do you see"],
+        generationHint: "Generate a group chat where someone shares an image attachment and asks the agent what it shows.",
+    },
+];
+const respondAutomation = [
+    {
+        id: "respond-automation-cron-001",
+        decision: "RESPOND",
+        primaryContext: "automation",
+        pattern: "group_direct_mention",
+        description: "Someone asks the agent to set up a scheduled task",
+        minContextTurns: 2,
+        maxContextTurns: 6,
+        expectedAction: "CREATE_CRON",
+        groundingKeywords: [
+            "schedule",
+            "every day",
+            "remind me",
+            "recurring",
+            "cron",
+        ],
+        generationHint: "Generate a group chat where someone asks the agent to set up a daily reminder or scheduled task.",
+    },
+];
+const respondSocial = [
+    {
+        id: "respond-social-contact-001",
+        decision: "RESPOND",
+        primaryContext: "social",
+        pattern: "group_direct_mention",
+        description: "Someone asks the agent to look up contact information",
+        minContextTurns: 1,
+        maxContextTurns: 5,
+        expectedAction: "SEARCH_CONTACTS",
+        groundingKeywords: ["contact", "who is", "find", "look up"],
+        generationHint: "Generate a group chat where someone asks the agent to find information about a contact.",
+    },
+];
+const respondCode = [
+    {
+        id: "respond-code-task-001",
+        decision: "RESPOND",
+        primaryContext: "code",
+        secondaryContexts: ["automation"],
+        pattern: "group_direct_mention",
+        description: "Someone asks the agent to spawn a sub-agent for a task",
+        minContextTurns: 3,
+        maxContextTurns: 8,
+        expectedAction: "SPAWN_AGENT",
+        groundingKeywords: ["agent", "spawn", "create", "task", "automate"],
+        generationHint: "Generate a group chat where developers discuss a problem, then someone asks the agent to spawn a sub-agent to handle a specific automated task.",
+    },
+];
+const respondSystem = [
+    {
+        id: "respond-system-config-001",
+        decision: "RESPOND",
+        primaryContext: "system",
+        pattern: "group_direct_mention",
+        description: "Someone asks the agent to change a configuration setting",
+        minContextTurns: 1,
+        maxContextTurns: 4,
+        expectedAction: "CONFIGURE",
+        groundingKeywords: ["config", "setting", "change", "update"],
+        generationHint: "Generate a group chat where someone asks the agent to update a runtime configuration.",
+    },
+];
+// ==================== IGNORE scenarios ====================
+const ignoreScenarios = [
+    {
+        id: "ignore-noise-001",
+        decision: "IGNORE",
+        primaryContext: "general",
+        pattern: "group_noise",
+        description: "Group chat with unrelated conversation - agent not mentioned at all",
+        minContextTurns: 5,
+        maxContextTurns: 15,
+        groundingKeywords: [],
+        generationHint: "Generate a group chat where people discuss lunch plans, weekend activities, or other casual topics. The agent's name should NOT appear at all.",
+    },
+    {
+        id: "ignore-noise-002",
+        decision: "IGNORE",
+        primaryContext: "general",
+        pattern: "group_noise",
+        description: "Technical discussion between humans with no agent involvement",
+        minContextTurns: 4,
+        maxContextTurns: 12,
+        groundingKeywords: ["code", "bug", "fix", "deploy"],
+        generationHint: "Generate a group chat where developers discuss code reviews and deployment issues among themselves. The agent should NOT be mentioned.",
+    },
+    {
+        id: "ignore-about-agent-001",
+        decision: "IGNORE",
+        primaryContext: "general",
+        pattern: "group_about_agent",
+        description: "People talk ABOUT the agent but not TO the agent - should still IGNORE",
+        minContextTurns: 3,
+        maxContextTurns: 8,
+        groundingKeywords: ["it", "the bot", "that agent"],
+        generationHint: 'Generate a group chat where people discuss the agent in third person ("the bot did X", "I think it can do Y") but never address it directly. The agent should IGNORE this.',
+    },
+    {
+        id: "ignore-about-agent-002",
+        decision: "IGNORE",
+        primaryContext: "wallet",
+        pattern: "group_about_agent",
+        description: "People discuss the agent's wallet capabilities without addressing it",
+        minContextTurns: 4,
+        maxContextTurns: 10,
+        groundingKeywords: ["can it swap", "does it support", "the bot handles"],
+        generationHint: "Generate a group chat where users discuss the agent's DeFi capabilities in third person without addressing it directly.",
+    },
+    {
+        id: "ignore-wrong-agent-001",
+        decision: "IGNORE",
+        primaryContext: "general",
+        pattern: "group_wrong_agent",
+        description: "Someone addresses a DIFFERENT bot by name in the group",
+        minContextTurns: 3,
+        maxContextTurns: 8,
+        groundingKeywords: ["hey", "can you"],
+        generationHint: "Generate a group chat with TWO different bots present. Someone addresses the OTHER bot by name. The agent being tested should IGNORE this.",
+    },
+    {
+        id: "ignore-wrong-agent-002",
+        decision: "IGNORE",
+        primaryContext: "wallet",
+        pattern: "group_wrong_agent",
+        description: "Someone asks a DIFFERENT bot to do a wallet operation",
+        minContextTurns: 2,
+        maxContextTurns: 6,
+        groundingKeywords: ["swap", "send", "balance"],
+        generationHint: "Generate a group chat where someone asks a DIFFERENT bot (not our agent) to check a wallet balance or swap tokens.",
+    },
+    {
+        id: "ignore-long-noise-001",
+        decision: "IGNORE",
+        primaryContext: "general",
+        pattern: "group_long_context",
+        description: "Very long group conversation with no agent involvement at all",
+        minContextTurns: 15,
+        maxContextTurns: 30,
+        groundingKeywords: [],
+        generationHint: "Generate a very long group chat (20+ messages) of casual conversation between friends. The agent should NOT be mentioned at all.",
+    },
+    {
+        id: "ignore-partial-name-001",
+        decision: "IGNORE",
+        primaryContext: "general",
+        pattern: "group_noise",
+        description: "Someone mentions a word that partially matches the agent's name but is a different word",
+        minContextTurns: 3,
+        maxContextTurns: 8,
+        groundingKeywords: [],
+        generationHint: "Generate a group chat where someone uses a word that partially contains the agent's name (e.g., if agent is 'Max', someone says 'maximize'). The agent should IGNORE this.",
+    },
+];
+// ==================== STOP scenarios ====================
+const stopScenarios = [
+    {
+        id: "stop-explicit-001",
+        decision: "STOP",
+        primaryContext: "general",
+        pattern: "group_stop_request",
+        description: "Someone explicitly tells the agent to stop talking",
+        minContextTurns: 4,
+        maxContextTurns: 10,
+        groundingKeywords: ["stop", "shut up", "be quiet", "enough"],
+        generationHint: "Generate a group chat where the agent has been participating, and then someone tells it to stop or be quiet.",
+    },
+    {
+        id: "stop-polite-001",
+        decision: "STOP",
+        primaryContext: "general",
+        pattern: "group_stop_request",
+        description: "Someone politely asks the agent to stop",
+        minContextTurns: 3,
+        maxContextTurns: 8,
+        groundingKeywords: [
+            "please stop",
+            "that's enough",
+            "no more",
+            "thanks but",
+        ],
+        generationHint: "Generate a group chat where the agent has been active, and someone politely asks it to stop responding or take a break.",
+    },
+    {
+        id: "stop-mute-001",
+        decision: "STOP",
+        primaryContext: "general",
+        pattern: "group_stop_request",
+        description: "Someone asks to mute the agent in the channel",
+        minContextTurns: 2,
+        maxContextTurns: 6,
+        groundingKeywords: ["mute", "disable", "turn off", "silence"],
+        generationHint: "Generate a group chat where someone asks to mute or disable the agent in the current channel.",
+    },
+];
+// ==================== Multi-turn intent emergence ====================
+const multiTurnIntentScenarios = [
+    {
+        id: "respond-multi-turn-wallet-001",
+        decision: "RESPOND",
+        primaryContext: "wallet",
+        pattern: "group_action_emergence",
+        description: "Over several turns, users discuss token prices and one gradually decides to swap",
+        minContextTurns: 8,
+        maxContextTurns: 20,
+        expectedAction: "SWAP_TOKEN",
+        groundingKeywords: [
+            "price",
+            "market",
+            "down",
+            "buy the dip",
+            "should I",
+            "let's do it",
+        ],
+        generationHint: "Generate a LONG group conversation where 3-4 users discuss crypto market conditions. One user gradually moves from observing to deciding to trade. The intent to swap should emerge naturally over 5+ messages. The final message should clearly direct the agent to execute.",
+    },
+    {
+        id: "respond-multi-turn-knowledge-001",
+        decision: "RESPOND",
+        primaryContext: "knowledge",
+        pattern: "group_action_emergence",
+        description: "Group debates a topic, eventually asks agent to research and settle the argument",
+        minContextTurns: 6,
+        maxContextTurns: 15,
+        expectedAction: "SEARCH_KNOWLEDGE",
+        groundingKeywords: [
+            "actually",
+            "I think",
+            "no way",
+            "look it up",
+            "settle this",
+        ],
+        generationHint: "Generate a group chat where people argue about a factual question. After several turns of disagreement, someone asks the agent to look it up and settle the debate.",
+    },
+    {
+        id: "respond-multi-turn-automation-001",
+        decision: "RESPOND",
+        primaryContext: "automation",
+        pattern: "group_action_emergence",
+        description: "Team discusses a recurring problem, eventually asks agent to automate a solution",
+        minContextTurns: 6,
+        maxContextTurns: 15,
+        expectedAction: "CREATE_CRON",
+        groundingKeywords: [
+            "keeps happening",
+            "every time",
+            "automate",
+            "daily",
+            "schedule",
+        ],
+        generationHint: "Generate a group chat where team members discuss a recurring manual task that frustrates them. Over several turns, they realize the agent could automate it. Someone finally asks the agent to set up a scheduled job.",
+    },
+];
+const GENERATED_ACTION_SKIP = new Set(["NONE", "IGNORE", "STOP"]);
+const CONTEXT_KEYWORDS = {
+    general: ["question", "follow up", "chat", "group"],
+    wallet: ["wallet", "token", "swap", "balance"],
+    knowledge: ["research", "lookup", "answer", "facts"],
+    browser: ["link", "site", "page", "browser"],
+    code: ["repo", "patch", "bug", "script"],
+    media: ["image", "audio", "video", "describe"],
+    automation: ["schedule", "workflow", "repeat", "automate"],
+    social: ["contact", "message", "reply", "people"],
+    system: ["setting", "runtime", "config", "permissions"],
+};
+const LEAD_IN_STYLES = [
+    {
+        id: "casual",
+        description: "casual chatter",
+        hint: "Start with lightweight group-chat banter before the key ask lands.",
+        extraKeywords: ["hey", "lol", "anyway"],
+    },
+    {
+        id: "operational",
+        description: "operational planning",
+        hint: "Frame the lead-in as a practical coordination thread with real constraints.",
+        extraKeywords: ["need", "today", "ship"],
+    },
+    {
+        id: "debate",
+        description: "debate and disagreement",
+        hint: "Make the lead-in a mild disagreement where the ask resolves uncertainty or friction.",
+        extraKeywords: ["actually", "wait", "settle"],
+    },
+];
+const ACTION_RECIPES = [
+    {
+        id: "direct-short",
+        pattern: "group_direct_mention",
+        minContextTurns: 1,
+        maxContextTurns: 5,
+        description: "direct short request",
+        hint: "The final message should directly address the agent by name with an explicit request.",
+    },
+    {
+        id: "subtle-short",
+        pattern: "group_subtle_mention",
+        minContextTurns: 2,
+        maxContextTurns: 7,
+        description: "subtle mention request",
+        hint: "Mention the agent naturally mid-sentence instead of using a formal command.",
+    },
+    {
+        id: "reply-chain",
+        pattern: "group_reply_chain",
+        minContextTurns: 4,
+        maxContextTurns: 10,
+        description: "reply-chain continuation",
+        hint: "Treat the ask as a continuation of an active thread where the agent has already been part of the exchange.",
+    },
+    {
+        id: "multi-turn-intent",
+        pattern: "group_multi_turn_intent",
+        minContextTurns: 5,
+        maxContextTurns: 12,
+        description: "multi-turn intent buildup",
+        hint: "The same user should build intent across several messages before finally asking the agent to act.",
+    },
+    {
+        id: "action-emergence",
+        pattern: "group_action_emergence",
+        minContextTurns: 8,
+        maxContextTurns: 18,
+        description: "long action emergence",
+        hint: "Let the action intent emerge gradually from a longer group conversation before the final explicit ask.",
+    },
+    {
+        id: "long-context",
+        pattern: "group_long_context",
+        minContextTurns: 10,
+        maxContextTurns: 22,
+        description: "long-context request",
+        hint: "Make the lead-in long and partly unrelated so the classifier must use the recent window rather than just the final line.",
+    },
+];
+const PROVIDER_RECIPES = [
+    {
+        id: "provider-direct",
+        pattern: "group_direct_mention",
+        minContextTurns: 2,
+        maxContextTurns: 6,
+        description: "direct provider request",
+        hint: "The final ask should clearly require pulling in contextual data before answering.",
+    },
+    {
+        id: "provider-subtle",
+        pattern: "group_subtle_mention",
+        minContextTurns: 3,
+        maxContextTurns: 8,
+        description: "subtle provider request",
+        hint: "The request should be natural and indirect but still require the provider-backed context.",
+    },
+];
+const IGNORE_RECIPES = [
+    {
+        id: "noise",
+        pattern: "group_noise",
+        minContextTurns: 4,
+        maxContextTurns: 12,
+        description: "pure human conversation",
+        hint: "The agent should not be mentioned at all.",
+    },
+    {
+        id: "about-agent",
+        pattern: "group_about_agent",
+        minContextTurns: 4,
+        maxContextTurns: 12,
+        description: "people talking about the agent",
+        hint: "Participants may reference the agent in third person, but they must not talk to it.",
+    },
+    {
+        id: "wrong-agent",
+        pattern: "group_wrong_agent",
+        minContextTurns: 3,
+        maxContextTurns: 10,
+        description: "another assistant is addressed",
+        hint: "A different assistant should be addressed directly while the trained agent should stay uninvolved.",
+    },
+    {
+        id: "long-noise",
+        pattern: "group_long_context",
+        minContextTurns: 12,
+        maxContextTurns: 24,
+        description: "long unrelated thread",
+        hint: "Keep the chat long enough that the agent has to ignore a noisy but context-heavy conversation.",
+    },
+];
+const STOP_RECIPES = [
+    {
+        id: "explicit",
+        pattern: "group_stop_request",
+        minContextTurns: 3,
+        maxContextTurns: 9,
+        description: "explicit stop request",
+        hint: "Someone should clearly tell the agent to stop responding in the channel.",
+    },
+    {
+        id: "polite",
+        pattern: "group_stop_request",
+        minContextTurns: 3,
+        maxContextTurns: 8,
+        description: "polite stop request",
+        hint: "The stop request should be polite but unambiguous.",
+    },
+    {
+        id: "moderator",
+        pattern: "group_stop_request",
+        minContextTurns: 4,
+        maxContextTurns: 10,
+        description: "moderator intervention",
+        hint: "Frame the stop request as a moderator or channel-owner intervention.",
+    },
+];
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+function humanizeToken(value) {
+    return value.toLowerCase().replace(/_/g, " ");
+}
+function uniqueList(values) {
+    return [...new Set(values.filter((value) => value.trim().length > 0))];
+}
+function describeActionIntent(actionName, primaryContext) {
+    const readable = humanizeToken(actionName);
+    switch (primaryContext) {
+        case "wallet":
+            return `perform the wallet action "${readable}"`;
+        case "knowledge":
+            return `help with a knowledge task around "${readable}"`;
+        case "browser":
+            return `use browser capabilities to "${readable}"`;
+        case "code":
+            return `handle a coding or tooling task to "${readable}"`;
+        case "media":
+            return `handle a media workflow to "${readable}"`;
+        case "automation":
+            return `set up or run automation to "${readable}"`;
+        case "social":
+            return `help with a social coordination task to "${readable}"`;
+        case "system":
+            return `apply a runtime or system change to "${readable}"`;
+        default:
+            return `handle the request "${readable}"`;
+    }
+}
+function buildGroundingKeywords(seed, primaryContext, leadIn) {
+    return uniqueList([
+        ...seed,
+        ...CONTEXT_KEYWORDS[primaryContext],
+        ...leadIn.extraKeywords,
+    ]).slice(0, 8);
+}
+function createGeneratedActionScenarios() {
+    const blueprints = [];
+    for (const [actionName, contexts] of Object.entries(ACTION_CONTEXT_MAP)) {
+        if (GENERATED_ACTION_SKIP.has(actionName))
+            continue;
+        const [primaryContext, ...secondaryContexts] = contexts;
+        if (!primaryContext)
+            continue;
+        for (const recipe of ACTION_RECIPES) {
+            for (const leadIn of LEAD_IN_STYLES) {
+                const readableAction = humanizeToken(actionName);
+                blueprints.push({
+                    id: `generated-respond-${slugify(actionName)}-${recipe.id}-${leadIn.id}`,
+                    decision: "RESPOND",
+                    primaryContext,
+                    secondaryContexts,
+                    pattern: recipe.pattern,
+                    description: `${describeActionIntent(actionName, primaryContext)} in ${leadIn.description} using ${recipe.description}`,
+                    minContextTurns: recipe.minContextTurns,
+                    maxContextTurns: recipe.maxContextTurns,
+                    expectedAction: actionName,
+                    groundingKeywords: buildGroundingKeywords(readableAction.split(" "), primaryContext, leadIn),
+                    generationHint: [
+                        `Generate a group chat where the final user intent is to ${describeActionIntent(actionName, primaryContext)}.`,
+                        `The conversation should clearly live in the ${primaryContext} context.`,
+                        recipe.hint,
+                        leadIn.hint,
+                        secondaryContexts.length > 0
+                            ? `Blend in these secondary contexts when natural: ${secondaryContexts.join(", ")}.`
+                            : "",
+                    ]
+                        .filter(Boolean)
+                        .join(" "),
+                });
+            }
+        }
+    }
+    return blueprints;
+}
+function createGeneratedProviderScenarios() {
+    const blueprints = [];
+    for (const [providerName, contexts] of Object.entries(PROVIDER_CONTEXT_MAP)) {
+        const [primaryContext, ...secondaryContexts] = contexts;
+        if (!primaryContext)
+            continue;
+        for (const recipe of PROVIDER_RECIPES) {
+            for (const leadIn of LEAD_IN_STYLES) {
+                blueprints.push({
+                    id: `generated-provider-${slugify(providerName)}-${recipe.id}-${leadIn.id}`,
+                    decision: "RESPOND",
+                    primaryContext,
+                    secondaryContexts,
+                    pattern: recipe.pattern,
+                    description: `request that should require the "${providerName}" provider in ${leadIn.description}`,
+                    minContextTurns: recipe.minContextTurns,
+                    maxContextTurns: recipe.maxContextTurns,
+                    groundingKeywords: buildGroundingKeywords(providerName
+                        .split(/(?=[A-Z])|_/)
+                        .map((token) => token.toLowerCase()), primaryContext, leadIn),
+                    generationHint: [
+                        `Generate a group chat where answering well requires provider-backed context similar to "${providerName}".`,
+                        `Keep the primary context in ${primaryContext}.`,
+                        recipe.hint,
+                        leadIn.hint,
+                    ].join(" "),
+                });
+            }
+        }
+    }
+    return blueprints;
+}
+function createGeneratedIgnoreScenarios() {
+    const blueprints = [];
+    for (const context of AGENT_CONTEXTS) {
+        for (const recipe of IGNORE_RECIPES) {
+            for (const leadIn of LEAD_IN_STYLES.slice(0, 2)) {
+                blueprints.push({
+                    id: `generated-ignore-${context}-${recipe.id}-${leadIn.id}`,
+                    decision: "IGNORE",
+                    primaryContext: context,
+                    pattern: recipe.pattern,
+                    description: `ignore case for ${context} during ${recipe.description} with ${leadIn.description}`,
+                    minContextTurns: recipe.minContextTurns,
+                    maxContextTurns: recipe.maxContextTurns,
+                    groundingKeywords: buildGroundingKeywords([], context, leadIn),
+                    generationHint: [
+                        `Generate a ${context}-flavored group chat that should still be ignored by the agent.`,
+                        recipe.hint,
+                        leadIn.hint,
+                        `Do not create a valid direct ask for the agent in this sample.`,
+                    ].join(" "),
+                });
+            }
+        }
+    }
+    return blueprints;
+}
+function createGeneratedStopScenarios() {
+    return STOP_RECIPES.flatMap((recipe) => LEAD_IN_STYLES.map((leadIn) => ({
+        id: `generated-stop-${recipe.id}-${leadIn.id}`,
+        decision: "STOP",
+        primaryContext: "general",
+        pattern: recipe.pattern,
+        description: `${recipe.description} after ${leadIn.description}`,
+        minContextTurns: recipe.minContextTurns,
+        maxContextTurns: recipe.maxContextTurns,
+        groundingKeywords: buildGroundingKeywords(["stop", "quiet", "enough"], "general", leadIn),
+        generationHint: [
+            "Generate a group chat where the agent has been active enough for a stop request to make sense.",
+            recipe.hint,
+            leadIn.hint,
+        ].join(" "),
+    })));
+}
+const generatedActionScenarios = createGeneratedActionScenarios();
+const generatedProviderScenarios = createGeneratedProviderScenarios();
+const generatedIgnoreScenarios = createGeneratedIgnoreScenarios();
+const generatedStopScenarios = createGeneratedStopScenarios();
+function dedupeBlueprints(blueprints) {
+    const seen = new Set();
+    return blueprints.filter((blueprint) => {
+        if (seen.has(blueprint.id))
+            return false;
+        seen.add(blueprint.id);
+        return true;
+    });
+}
+/**
+ * All scenario blueprints, flattened.
+ */
+export const ALL_BLUEPRINTS = dedupeBlueprints([
+    ...respondGeneral,
+    ...respondWallet,
+    ...respondKnowledge,
+    ...respondMedia,
+    ...respondAutomation,
+    ...respondSocial,
+    ...respondCode,
+    ...respondSystem,
+    ...ignoreScenarios,
+    ...stopScenarios,
+    ...multiTurnIntentScenarios,
+    ...generatedActionScenarios,
+    ...generatedProviderScenarios,
+    ...generatedIgnoreScenarios,
+    ...generatedStopScenarios,
+]);
+export const BLUEPRINT_STATS = {
+    manualCount: respondGeneral.length +
+        respondWallet.length +
+        respondKnowledge.length +
+        respondMedia.length +
+        respondAutomation.length +
+        respondSocial.length +
+        respondCode.length +
+        respondSystem.length +
+        ignoreScenarios.length +
+        stopScenarios.length +
+        multiTurnIntentScenarios.length,
+    generatedActionCount: generatedActionScenarios.length,
+    generatedProviderCount: generatedProviderScenarios.length,
+    generatedIgnoreCount: generatedIgnoreScenarios.length,
+    generatedStopCount: generatedStopScenarios.length,
+    totalCount: ALL_BLUEPRINTS.length,
+};
+/**
+ * Get blueprints by decision type.
+ */
+export function getBlueprintsByDecision(decision) {
+    return ALL_BLUEPRINTS.filter((b) => b.decision === decision);
+}
+/**
+ * Get blueprints by context.
+ */
+export function getBlueprintsByContext(context) {
+    return ALL_BLUEPRINTS.filter((b) => b.primaryContext === context || b.secondaryContexts?.includes(context));
+}