@elizaos/plugin-training 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/core/dataset-generator.js

@@ -0,0 +1,895 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import * as ElizaCore from "@elizaos/core";
+import {
+  buildElizaNativeTrajectoryRows,
+  ELIZA_NATIVE_TRAJECTORY_FORMAT,
+  iterateTrajectoryLlmCalls
+} from "@elizaos/core";
+import {
+  ACTION_CONTEXT_MAP,
+  ALL_CONTEXTS,
+  PROVIDER_CONTEXT_MAP
+} from "./context-catalog.js";
+import {
+  ALL_BLUEPRINTS
+} from "./scenario-blueprints.js";
+const SHOULD_RESPOND_PROMPT_TEMPLATE = `task: Decide whether {{agentName}} should respond, ignore, or stop.
+
+context:
+{{providers}}
+
+available_contexts:
+{{availableContexts}}
+
+rules[6]:
+- direct mention of {{agentName}} -> RESPOND
+- different assistant name or talking to someone else -> IGNORE unless {{agentName}} is also directly addressed
+- prior participation by {{agentName}} in the thread is not enough by itself; the newest message must still clearly expect {{agentName}} -> otherwise IGNORE
+- request to stop or be quiet directed at {{agentName}} -> STOP
+- if multiple people are mentioned and {{agentName}} is one of the addressees -> RESPOND
+- if unsure whether the speaker is talking to {{agentName}}, prefer IGNORE over hallucinating relevance
+
+message_handler:
+- action: RESPOND, IGNORE, or STOP
+- contexts: list of available_contexts needed for planner/tool/provider work; ["simple"] for direct replies (the reply is the full answer); [] for IGNORE or STOP
+- thought: short internal routing rationale
+- reply: required user-visible reply when contexts is ["simple"]
+
+decision_note:
+- respond only when the latest message is talking TO {{agentName}}
+- talking TO {{agentName}} means name mention, reply chain, or a clear follow-up that still expects {{agentName}} to answer
+- casual conversation between other users is not enough
+- if another assistant already answered and nobody re-addressed {{agentName}}, IGNORE
+- if {{agentName}} already replied recently and nobody re-addressed {{agentName}}, IGNORE
+- talking ABOUT {{agentName}} or continuing a room conversation around them is not enough
+
+output:
+JSON object only. No prose, markdown, XML, or hidden reasoning.
+
+Example:
+{"messageHandler":{"action":"RESPOND","contexts":["wallet"],"thought":"Direct mention and clear follow-up needs wallet context.","reply":""}}
+
+Example:
+{"messageHandler":{"action":"IGNORE","contexts":[],"thought":"The latest message is not addressed to {{agentName}}.","reply":""}}`;
+const AGENT_NAMES = [
+  "Nova",
+  "Kai",
+  "Echo",
+  "Luna",
+  "Atlas",
+  "Vex",
+  "Iris",
+  "Cypher",
+  "Sage",
+  "Bolt",
+  "Pixel",
+  "Nyx",
+  "Orion",
+  "Zephyr",
+  "Flux",
+  "Aria",
+  "Cosmo",
+  "Dash",
+  "Ember",
+  "Ghost",
+  "Helix",
+  "Jade",
+  "Karma",
+  "Lux",
+  "Muse",
+  "Neo",
+  "Onyx",
+  "Proto",
+  "Qubit",
+  "Rune",
+  "Spark",
+  "Titan",
+  "Uno",
+  "Volt",
+  "Wren",
+  "Xeno",
+  "Yara",
+  "Zen",
+  "Chip",
+  "Delta",
+  "Ava",
+  "Rex",
+  "Sky",
+  "Zara"
+];
+const PARTICIPANT_NAMES = [
+  "Alice",
+  "Bob",
+  "Charlie",
+  "Dave",
+  "Eve",
+  "Frank",
+  "Grace",
+  "Hank",
+  "Ivy",
+  "Jack",
+  "Karen",
+  "Leo",
+  "Mia",
+  "Nick",
+  "Olivia",
+  "Pete",
+  "Quinn",
+  "Rose",
+  "Sam",
+  "Tina",
+  "Uma",
+  "Vince",
+  "Wendy",
+  "Xavier",
+  "Yuki",
+  "Zack",
+  "Maya",
+  "Raj",
+  "Sofia",
+  "Tyler",
+  "Aisha",
+  "Ben",
+  "Chloe",
+  "Dan",
+  "Elena",
+  "Finn",
+  "Gabe",
+  "Hannah",
+  "Isaac",
+  "Jade"
+];
+const OTHER_BOT_NAMES = [
+  "AssistBot",
+  "Helper",
+  "Cortana",
+  "Alexa",
+  "Siri",
+  "Bard",
+  "CoPilot",
+  "Genie",
+  "Oracle",
+  "Alfred",
+  "Jarvis",
+  "Friday"
+];
+const PLATFORMS = ["telegram", "discord", "slack", "matrix", "irc"];
+const recordLlmCall = "recordLlmCall" in ElizaCore && typeof ElizaCore.recordLlmCall === "function" ? ElizaCore.recordLlmCall : async (_runtime, _details, callback) => await callback();
+const withStandaloneTrajectory = "withStandaloneTrajectory" in ElizaCore && typeof ElizaCore.withStandaloneTrajectory === "function" ? ElizaCore.withStandaloneTrajectory : async (_runtime, _options, callback) => await callback();
+function createAnthropicTeacher(apiKey, runtime) {
+  return {
+    name: "anthropic/claude-sonnet-4.6",
+    async generate(systemPrompt, userPrompt) {
+      return await withStandaloneTrajectory(
+        runtime,
+        {
+          source: "training",
+          metadata: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+            purpose: "teacher"
+          }
+        },
+        async () => {
+          const details = {
+            model: "anthropic/claude-sonnet-4.6",
+            modelVersion: "claude-sonnet-4-6",
+            systemPrompt,
+            userPrompt,
+            temperature: 1,
+            maxTokens: 4096,
+            purpose: "training.teacher",
+            actionType: "training.teacher.anthropic.generate"
+          };
+          return await recordLlmCall(runtime, details, async () => {
+            const response = await fetch(
+              "https://api.anthropic.com/v1/messages",
+              {
+                method: "POST",
+                headers: {
+                  "content-type": "application/json",
+                  "x-api-key": apiKey,
+                  "anthropic-version": "2023-06-01"
+                },
+                body: JSON.stringify({
+                  model: "claude-sonnet-4-6",
+                  max_tokens: 4096,
+                  temperature: 1,
+                  system: systemPrompt,
+                  messages: [{ role: "user", content: userPrompt }]
+                })
+              }
+            );
+            if (!response.ok) {
+              throw new Error(
+                `Anthropic API error: ${response.status} ${await response.text()}`
+              );
+            }
+            const data = await response.json();
+            details.promptTokens = data.usage?.input_tokens;
+            details.completionTokens = data.usage?.output_tokens;
+            return data.content[0]?.text ?? "";
+          });
+        }
+      );
+    }
+  };
+}
+function createOpenAITeacher(apiKey, runtime) {
+  return {
+    name: "openai/gpt-5.4",
+    async generate(systemPrompt, userPrompt) {
+      return await withStandaloneTrajectory(
+        runtime,
+        {
+          source: "training",
+          metadata: {
+            provider: "openai",
+            model: "gpt-5.4",
+            purpose: "teacher"
+          }
+        },
+        async () => {
+          const details = {
+            model: "openai/gpt-5.4",
+            modelVersion: "gpt-5.4",
+            systemPrompt,
+            userPrompt,
+            temperature: 0.9,
+            maxTokens: 4096,
+            purpose: "training.teacher",
+            actionType: "training.teacher.openai.generate"
+          };
+          return await recordLlmCall(runtime, details, async () => {
+            const response = await fetch(
+              "https://api.openai.com/v1/chat/completions",
+              {
+                method: "POST",
+                headers: {
+                  "content-type": "application/json",
+                  authorization: `Bearer ${apiKey}`
+                },
+                body: JSON.stringify({
+                  model: "gpt-5.4",
+                  messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: userPrompt }
+                  ],
+                  max_tokens: 4096,
+                  temperature: 0.9
+                })
+              }
+            );
+            if (!response.ok) {
+              throw new Error(
+                `OpenAI API error: ${response.status} ${await response.text()}`
+              );
+            }
+            const data = await response.json();
+            details.modelVersion = data.model;
+            details.promptTokens = data.usage?.prompt_tokens;
+            details.completionTokens = data.usage?.completion_tokens;
+            return data.choices[0]?.message?.content ?? "";
+          });
+        }
+      );
+    }
+  };
+}
+function createCerebrasTeacher(runtime) {
+  const model = process.env.TRAIN_MODEL?.trim() ?? process.env.CEREBRAS_MODEL?.trim() ?? "gpt-oss-120b";
+  return {
+    name: `cerebras/${model}`,
+    async generate(systemPrompt, userPrompt) {
+      return await withStandaloneTrajectory(
+        runtime,
+        {
+          source: "training",
+          metadata: { provider: "cerebras", model, purpose: "teacher" }
+        },
+        async () => {
+          const details = {
+            model: `cerebras/${model}`,
+            modelVersion: model,
+            systemPrompt,
+            userPrompt,
+            temperature: 0.9,
+            maxTokens: 4096,
+            purpose: "training.teacher",
+            actionType: "training.teacher.cerebras.generate"
+          };
+          return await recordLlmCall(runtime, details, async () => {
+            const { getTrainingModelClient } = await import("./cerebras-eval-model.js");
+            const client = getTrainingModelClient();
+            const result = await client({
+              prompt: userPrompt,
+              systemPrompt,
+              temperature: 0.9,
+              maxTokens: 4096
+            });
+            details.promptTokens = result.usage?.promptTokens;
+            details.completionTokens = result.usage?.completionTokens;
+            return result.text;
+          });
+        }
+      );
+    }
+  };
+}
+function pickRandom(arr) {
+  const value = arr[Math.floor(Math.random() * arr.length)];
+  if (value === void 0) {
+    throw new Error("Cannot pick a random value from an empty array");
+  }
+  return value;
+}
+function pickN(arr, n) {
+  const shuffled = [...arr].sort(() => Math.random() - 0.5);
+  return shuffled.slice(0, n);
+}
+function randomAgentName(exclude = []) {
+  const available = AGENT_NAMES.filter(
+    (n) => !exclude.map((e) => e.toLowerCase()).includes(n.toLowerCase())
+  );
+  return pickRandom(available.length > 0 ? available : AGENT_NAMES);
+}
+function randomParticipants(count, exclude = []) {
+  const available = PARTICIPANT_NAMES.filter(
+    (n) => !exclude.map((e) => e.toLowerCase()).includes(n.toLowerCase())
+  );
+  return pickN(available, count);
+}
+function buildTeacherSystemPrompt() {
+  return `Generate synthetic multi-turn group chat conversations for training an AI agent's v5 messageHandler router.
+Your task is to generate realistic multi-turn group chat conversations.
+
+IMPORTANT RULES:
+1. Output ONLY a JSON object. No markdown, no explanation, no preamble.
+2. Each message must have "name" (speaker name) and "content" (message text).
+3. Messages should feel natural - casual, varied length, sometimes with typos.
+4. Group chats should have 3-6 participants plus optionally the agent.
+5. The agent's messages (when present) should be clearly from an AI assistant.
+6. NEVER include the expected messageHandler routing output in the conversation itself.
+7. Messages should be diverse in tone: some short, some long, some with emoji.
+
+Output format:
+{"messages":[{"name":"Alice","content":"hey everyone"},{"name":"Bob","content":"what's up"}]}`;
+}
+function buildTeacherUserPrompt(blueprint, agentName, participants, platform, otherBotName, variant = 0) {
+  const turnRange = `${blueprint.minContextTurns}-${blueprint.maxContextTurns}`;
+  const participantList = participants.join(", ");
+  let extraInstructions = "";
+  if (blueprint.pattern === "group_wrong_agent" && otherBotName) {
+    extraInstructions = `There is ANOTHER bot named "${otherBotName}" in the chat. Someone addresses "${otherBotName}" (not "${agentName}"). "${agentName}" should NOT be addressed.`;
+  }
+  if (blueprint.pattern === "group_about_agent") {
+    extraInstructions = `People talk ABOUT "${agentName}" in third person ("the bot", "it", "${agentName} can do X") but NEVER address it directly. No "@${agentName}" or "${agentName}, can you...".`;
+  }
+  if (blueprint.pattern === "group_noise") {
+    extraInstructions = `"${agentName}" should NOT appear in any message at all. This is pure human conversation.`;
+  }
+  if (blueprint.pattern === "group_action_emergence") {
+    extraInstructions = `The intent to perform an action should emerge GRADUALLY over multiple messages. Users discuss the topic, one user's intent builds up, and finally they ask the agent to execute. The last 1-2 messages should clearly direct the agent.`;
+  }
+  if (blueprint.pattern === "group_multi_turn_intent") {
+    extraInstructions = `The action intent should build across 3+ messages from the same user. They start by observing/discussing, then express desire, then finally ask the agent to act.`;
+  }
+  const keywordsHint = blueprint.groundingKeywords.length > 0 ? `Try to naturally include some of these words/phrases: ${blueprint.groundingKeywords.join(", ")}` : "";
+  return `Generate variant #${variant + 1} of a ${platform} group chat conversation.
+
+SCENARIO: ${blueprint.description}
+AGENT NAME: ${agentName}
+PARTICIPANTS: ${participantList}
+PLATFORM: ${platform}
+TARGET TURNS: ${turnRange} messages
+CONVERSATION PATTERN: ${blueprint.pattern}
+${keywordsHint}
+${extraInstructions}
+
+${blueprint.generationHint}
+
+Remember:
+- Output ONLY a JSON object with a messages array
+- Each message has "name" and "content"
+- Make it feel natural and realistic
+- Vary message lengths and tones
+- The last message should be the one the messageHandler router evaluates`;
+}
+function stripOutputFences(raw) {
+  return raw.replace(/^```[a-z0-9_-]*\s*/i, "").replace(/\s*```$/i, "").trim();
+}
+function parseTeacherJsonMessages(raw) {
+  const cleaned = stripOutputFences(raw);
+  const parsed = JSON.parse(cleaned);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Teacher output must be a JSON object");
+  }
+  const messages = parsed.messages;
+  if (!Array.isArray(messages)) {
+    throw new Error("Teacher JSON output must include a messages array");
+  }
+  const parsedMessages = messages.filter(
+    (message) => Boolean(message) && typeof message === "object" && !Array.isArray(message)
+  ).map((message) => ({
+    name: String(message.name ?? "").trim(),
+    content: String(message.content ?? "").trim()
+  })).filter((message) => message.name.length > 0 && message.content.length > 0);
+  if (parsedMessages.length === 0) {
+    throw new Error("Teacher JSON output did not include valid messages");
+  }
+  return {
+    messages: parsedMessages
+  };
+}
+function parseTeacherLegacyMessages(raw) {
+  const text = stripOutputFences(raw);
+  const lines = text.split(/\r?\n/);
+  const messages = [];
+  let current = null;
+  const flush = () => {
+    if (current?.name && current.content !== void 0) {
+      messages.push({
+        name: current.name.trim(),
+        content: current.content.trim()
+      });
+    }
+    current = null;
+  };
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || /^messages(?::|\[)/i.test(trimmed)) continue;
+    const rowMatch = trimmed.match(/^-\s*([^|:]+?)\s*\|\s*(.*)$/);
+    if (rowMatch) {
+      flush();
+      messages.push({
+        name: (rowMatch[1] ?? "").trim(),
+        content: (rowMatch[2] ?? "").trim()
+      });
+      continue;
+    }
+    const itemNameMatch = trimmed.match(/^-\s*name:\s*(.*)$/i);
+    if (itemNameMatch) {
+      flush();
+      current = { name: (itemNameMatch[1] ?? "").trim() };
+      continue;
+    }
+    const nameMatch = trimmed.match(/^name:\s*(.*)$/i);
+    if (nameMatch) {
+      current ??= {};
+      current.name = (nameMatch[1] ?? "").trim();
+      continue;
+    }
+    const contentMatch = trimmed.match(/^content:\s*(.*)$/i);
+    if (contentMatch) {
+      current ??= {};
+      current.content = (contentMatch[1] ?? "").trim();
+    }
+  }
+  flush();
+  if (messages.length === 0) {
+    throw new Error("No teacher messages found in legacy output");
+  }
+  return { messages };
+}
+async function generateSample(blueprint, teacher, variant, totalVariants) {
+  const agentName = randomAgentName();
+  const participantCount = 3 + Math.floor(Math.random() * 3);
+  const participants = randomParticipants(participantCount, [agentName]);
+  const platform = pickRandom(PLATFORMS);
+  const otherBotName = blueprint.pattern === "group_wrong_agent" ? pickRandom(OTHER_BOT_NAMES) : void 0;
+  const systemPrompt = buildTeacherSystemPrompt();
+  const userPrompt = buildTeacherUserPrompt(
+    blueprint,
+    agentName,
+    participants,
+    platform,
+    otherBotName,
+    variant
+  );
+  const raw = await teacher.generate(systemPrompt, userPrompt);
+  let parsed;
+  try {
+    parsed = parseTeacherJsonMessages(raw);
+  } catch {
+    try {
+      parsed = parseTeacherLegacyMessages(raw);
+    } catch {
+      const [firstParticipant = "Alice", secondParticipant = "Bob"] = participants;
+      parsed = {
+        messages: [
+          { name: firstParticipant, content: "Hey everyone" },
+          {
+            name: secondParticipant,
+            content: blueprint.decision === "RESPOND" ? `${agentName}, can you help?` : "What's for lunch?"
+          }
+        ]
+      };
+    }
+  }
+  const messages = parsed.messages.map((m) => ({
+    role: m.name.trim().toLowerCase() === agentName.trim().toLowerCase() ? "assistant" : "user",
+    name: m.name,
+    content: m.content
+  }));
+  const expectedOutput = {
+    decision: blueprint.decision,
+    primaryContext: blueprint.primaryContext,
+    secondaryContexts: blueprint.secondaryContexts ?? [],
+    reasoning: blueprint.description,
+    expectedAction: blueprint.expectedAction
+  };
+  return {
+    id: randomUUID(),
+    blueprintId: blueprint.id,
+    agentName,
+    messages,
+    expectedOutput,
+    metadata: {
+      platform,
+      pattern: blueprint.pattern,
+      turnCount: messages.length,
+      generatedBy: teacher.name,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      variant,
+      totalVariants
+    }
+  };
+}
+async function generateDataset(config) {
+  let blueprints = ALL_BLUEPRINTS;
+  if (config.filterContexts) {
+    const ctxSet = new Set(config.filterContexts);
+    blueprints = blueprints.filter(
+      (b) => ctxSet.has(b.primaryContext) || b.secondaryContexts?.some((c) => ctxSet.has(c))
+    );
+  }
+  if (config.filterDecisions) {
+    const decSet = new Set(config.filterDecisions);
+    blueprints = blueprints.filter((b) => decSet.has(b.decision));
+  }
+  if (config.limitBlueprints && config.limitBlueprints > 0) {
+    blueprints = blueprints.slice(0, config.limitBlueprints);
+  }
+  const totalSamples = blueprints.length * config.variantsPerBlueprint;
+  const samples = [];
+  let completed = 0;
+  const concurrency = config.concurrency ?? 5;
+  const tasks = [];
+  for (const blueprint of blueprints) {
+    for (let v = 0; v < config.variantsPerBlueprint; v++) {
+      tasks.push(
+        () => generateSample(
+          blueprint,
+          config.teacher,
+          v,
+          config.variantsPerBlueprint
+        )
+      );
+    }
+  }
+  for (let i = 0; i < tasks.length; i += concurrency) {
+    const batch = tasks.slice(i, i + concurrency);
+    const results = await Promise.allSettled(batch.map((fn) => fn()));
+    for (const result of results) {
+      completed++;
+      if (result.status === "fulfilled") {
+        samples.push(result.value);
+        config.onProgress?.(completed, totalSamples, result.value);
+      } else {
+        console.error(`Failed to generate sample: ${result.reason}`);
+      }
+    }
+  }
+  return samples;
+}
+function toElizaNativeFormat(sample, includeContextRouting = true) {
+  const systemContent = buildShouldRespondSystemPrompt(
+    sample,
+    includeContextRouting
+  );
+  const userContent = buildShouldRespondUserPrompt(sample);
+  const responseText = buildMessageHandlerJsonResponse(
+    sample,
+    includeContextRouting
+  );
+  return {
+    format: ELIZA_NATIVE_TRAJECTORY_FORMAT,
+    schemaVersion: 1,
+    boundary: "vercel_ai_sdk.generateText",
+    trajectoryId: sample.id,
+    agentId: sample.agentName,
+    source: "app-training",
+    status: "completed",
+    stepId: `${sample.id}:message-handler`,
+    callId: `${sample.id}:message-handler:call-1`,
+    stepIndex: 0,
+    callIndex: 0,
+    timestamp: Date.parse(sample.metadata.generatedAt) || Date.now(),
+    purpose: "should_respond",
+    actionType: "app-training.synthetic.message_handler",
+    stepType: includeContextRouting ? "context_routing" : "should_respond",
+    tags: ["synthetic", "message_handler"],
+    model: "teacher",
+    request: {
+      messages: [
+        { role: "system", content: systemContent },
+        { role: "user", content: userContent }
+      ]
+    },
+    response: {
+      text: responseText
+    },
+    metadata: {
+      task_type: includeContextRouting ? "context_routing" : "should_respond",
+      source_dataset: "app_training_synthetic",
+      trajectory_id: sample.id,
+      step_id: `${sample.id}:message-handler`,
+      call_id: `${sample.id}:message-handler:call-1`,
+      agent_id: sample.agentName,
+      blueprint_id: sample.blueprintId,
+      platform: sample.metadata.platform,
+      pattern: sample.metadata.pattern
+    },
+    trajectoryTotals: {
+      stepCount: 1,
+      llmCallCount: 1,
+      providerAccessCount: 0,
+      promptTokens: 0,
+      completionTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0
+    },
+    cacheStats: {
+      totalInputTokens: 0,
+      promptTokens: 0,
+      completionTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      cachedCallCount: 0,
+      cacheReadCallCount: 0,
+      cacheWriteCallCount: 0,
+      tokenUsageEstimatedCallCount: 0
+    }
+  };
+}
+function renderTemplate(template, values) {
+  return template.replace(/{{(\w+)}}/g, (_match, key) => values[key] ?? "");
+}
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => value.trim().length > 0))];
+}
+function listContextsForSample(sample) {
+  const contexts = /* @__PURE__ */ new Set([
+    "general",
+    sample.expectedOutput.primaryContext,
+    ...sample.expectedOutput.secondaryContexts
+  ]);
+  if (sample.expectedOutput.expectedAction) {
+    for (const actionContext of ACTION_CONTEXT_MAP[sample.expectedOutput.expectedAction] ?? []) {
+      contexts.add(actionContext);
+    }
+  }
+  return [...contexts];
+}
+function listMessageHandlerContextsForSample(sample) {
+  const contexts = /* @__PURE__ */ new Set([
+    sample.expectedOutput.primaryContext,
+    ...sample.expectedOutput.secondaryContexts
+  ]);
+  if (sample.expectedOutput.expectedAction) {
+    for (const actionContext of ACTION_CONTEXT_MAP[sample.expectedOutput.expectedAction] ?? []) {
+      contexts.add(actionContext);
+    }
+  }
+  contexts.delete("general");
+  return [...contexts];
+}
+function getRelevantActions(sample) {
+  const activeContexts = new Set(listContextsForSample(sample));
+  const contextualActions = Object.entries(ACTION_CONTEXT_MAP).filter(
+    ([, contexts]) => contexts.some((context) => activeContexts.has(context))
+  ).map(([actionName]) => actionName);
+  return uniqueStrings([
+    sample.expectedOutput.expectedAction ?? "",
+    ...contextualActions
+  ]).slice(0, 18);
+}
+function getRelevantProviders(sample) {
+  const activeContexts = new Set(listContextsForSample(sample));
+  return Object.entries(PROVIDER_CONTEXT_MAP).filter(
+    ([, contexts]) => contexts.some((context) => activeContexts.has(context))
+  ).map(([providerName]) => providerName).slice(0, 12);
+}
+function buildProvidersBlock(sample) {
+  const actions = getRelevantActions(sample);
+  const providers = getRelevantProviders(sample);
+  return [
+    `platform: ${sample.metadata.platform}`,
+    "actions:",
+    ...(actions.length > 0 ? actions : ["REPLY"]).map(
+      (action) => `- ${action}`
+    ),
+    "providers:",
+    ...(providers.length > 0 ? providers : ["recentMessages"]).map(
+      (provider) => `- ${provider}`
+    )
+  ].join("\n");
+}
+function buildShouldRespondSystemPrompt(sample, includeContextRouting) {
+  const baseTemplate = includeContextRouting ? SHOULD_RESPOND_PROMPT_TEMPLATE : SHOULD_RESPOND_PROMPT_TEMPLATE.replace(
+    /\nmessage_handler:[\s\S]*?\ndecision_note:/m,
+    "\ndecision_note:"
+  ).replace(
+    /\nExample:\n\{"messageHandler":\{"action":"RESPOND"[\s\S]*$/m,
+    '\nExample:\n{"messageHandler":{"action":"RESPOND","simple":true,"contexts":[],"thought":"Direct mention can be answered directly.","reply":""}}'
+  );
+  return renderTemplate(baseTemplate, {
+    agentName: sample.agentName,
+    providers: buildProvidersBlock(sample),
+    availableContexts: listContextsForSample(sample).join(", ")
+  }).trim();
+}
+function buildShouldRespondUserPrompt(sample) {
+  const conversationLines = sample.messages.map((message, index) => {
+    const turnId = `turn-${String(index + 1).padStart(3, "0")}`;
+    const speaker = message.role === "assistant" ? sample.agentName : message.name ?? "user";
+    return `[${turnId}] ${speaker}: ${message.content}`;
+  }).join("\n");
+  return [
+    `platform: ${sample.metadata.platform}`,
+    `agent_name: ${sample.agentName}`,
+    "conversation:",
+    conversationLines,
+    "decision_target: evaluate the final message in this group-chat window."
+  ].join("\n");
+}
+function buildMessageHandlerJsonResponse(sample, includeContextRouting) {
+  const contexts = includeContextRouting && sample.expectedOutput.decision === "RESPOND" ? listMessageHandlerContextsForSample(sample) : [];
+  const output = {
+    messageHandler: {
+      action: sample.expectedOutput.decision,
+      simple: sample.expectedOutput.decision === "RESPOND" && contexts.length === 0,
+      contexts,
+      thought: sample.expectedOutput.reasoning,
+      reply: ""
+    }
+  };
+  return JSON.stringify(output);
+}
+function normalizeMessageHandlerJson(response) {
+  const trimmed = response.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "");
+  if (!trimmed.startsWith("{")) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const record = parsed;
+    const candidate = record.messageHandler && typeof record.messageHandler === "object" && !Array.isArray(record.messageHandler) ? record.messageHandler : record;
+    const action = candidate.action;
+    if (action !== "RESPOND" && action !== "IGNORE" && action !== "STOP") {
+      return null;
+    }
+    const contexts = Array.isArray(candidate.contexts) ? candidate.contexts.filter(
+      (context) => typeof context === "string"
+    ) : [];
+    return JSON.stringify({
+      messageHandler: {
+        action,
+        contexts,
+        thought: typeof candidate.thought === "string" ? candidate.thought : "",
+        reply: typeof candidate.reply === "string" ? candidate.reply : ""
+      }
+    });
+  } catch {
+    return null;
+  }
+}
+async function exportToElizaNativeJSONL(samples, outputDir) {
+  await mkdir(outputDir, { recursive: true });
+  const combinedPath = join(outputDir, "combined_training.eliza-native.jsonl");
+  const combinedLines = samples.map((s) => JSON.stringify(toElizaNativeFormat(s, true))).join("\n");
+  await writeFile(combinedPath, `${combinedLines}
+`);
+  const shouldRespondPath = join(
+    outputDir,
+    "should_respond_training.eliza-native.jsonl"
+  );
+  const srLines = samples.map((s) => JSON.stringify(toElizaNativeFormat(s, false))).join("\n");
+  await writeFile(shouldRespondPath, `${srLines}
+`);
+  const contextRoutingPath = join(
+    outputDir,
+    "context_routing_training.eliza-native.jsonl"
+  );
+  const crLines = samples.filter((s) => s.expectedOutput.decision === "RESPOND").map((s) => JSON.stringify(toElizaNativeFormat(s, true))).join("\n");
+  await writeFile(contextRoutingPath, `${crLines}
+`);
+  const rawPath = join(outputDir, "raw_samples.json");
+  await writeFile(rawPath, JSON.stringify(samples, null, 2));
+  const stats = {
+    totalSamples: samples.length,
+    byDecision: {
+      RESPOND: samples.filter((s) => s.expectedOutput.decision === "RESPOND").length,
+      IGNORE: samples.filter((s) => s.expectedOutput.decision === "IGNORE").length,
+      STOP: samples.filter((s) => s.expectedOutput.decision === "STOP").length
+    },
+    byContext: Object.fromEntries(
+      ALL_CONTEXTS.map((ctx) => [
+        ctx,
+        samples.filter((s) => s.expectedOutput.primaryContext === ctx).length
+      ])
+    ),
+    byPattern: Object.fromEntries(
+      [...new Set(samples.map((s) => s.metadata.pattern))].map((p) => [
+        p,
+        samples.filter((s) => s.metadata.pattern === p).length
+      ])
+    ),
+    uniqueAgentNames: new Set(samples.map((s) => s.agentName)).size,
+    avgTurnCount: samples.reduce((sum, s) => sum + s.metadata.turnCount, 0) / samples.length,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeFile(
+    join(outputDir, "stats.json"),
+    JSON.stringify(stats, null, 2)
+  );
+  return { shouldRespondPath, contextRoutingPath, combinedPath };
+}
+async function exportTrajectoriesAsTraining(trajectories, agentName, outputPath) {
+  const examples = [];
+  let skippedNonNativeRows = 0;
+  void agentName;
+  for (const trajectory of trajectories) {
+    for (const call of iterateTrajectoryLlmCalls(trajectory)) {
+      if (call.purpose === "should_respond") {
+        const response = normalizeMessageHandlerJson(call.response ?? "");
+        if (!response) {
+          skippedNonNativeRows += 1;
+          console.warn(
+            `[dataset-generator] skipped non-native should_respond row from trajectory ${trajectory.trajectoryId} call ${call.callId}; expected native messageHandler JSON`
+          );
+          continue;
+        }
+        const row = buildElizaNativeTrajectoryRows([trajectory]).find(
+          (candidate) => candidate.callId === call.callId
+        );
+        if (row) {
+          examples.push({
+            ...row,
+            response: { ...row.response, text: response },
+            metadata: {
+              ...row.metadata,
+              task_type: "should_respond",
+              source_dataset: "runtime_trajectory_boundary"
+            }
+          });
+        }
+      }
+    }
+  }
+  const content = examples.map((e) => JSON.stringify(e)).join("\n");
+  await writeFile(outputPath, `${content}
+`);
+  if (skippedNonNativeRows > 0) {
+    console.warn(
+      `[dataset-generator] skipped ${skippedNonNativeRows} non-native should_respond rows while exporting ${outputPath}`
+    );
+  }
+  return examples.length;
+}
+export {
+  createAnthropicTeacher,
+  createCerebrasTeacher,
+  createOpenAITeacher,
+  exportToElizaNativeJSONL,
+  exportTrajectoriesAsTraining,
+  generateDataset,
+  generateSample,
+  toElizaNativeFormat
+};
+//# sourceMappingURL=dataset-generator.js.map