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

package/dist/core/roleplay-executor.js

@@ -0,0 +1,675 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import {
+  exportTrajectoryTaskDatasets
+} from "./trajectory-task-datasets.js";
+const GROUP_CHANNEL = "GROUP";
+function deterministicUuid(seed) {
+  const hex = createHash("sha1").update(seed).digest("hex").slice(0, 32);
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32)
+  ].join("-");
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function parseDelimitedList(value) {
+  return value.split(",").map((entry) => entry.trim()).filter(
+    (entry, index, entries) => entry.length > 0 && entries.indexOf(entry) === index
+  );
+}
+function stripOutputFences(response) {
+  return response.trim().replace(/^```[a-z0-9_-]*\s*/i, "").replace(/\s*```$/i, "").trim();
+}
+function parseJsonObject(response) {
+  const trimmed = stripOutputFences(response);
+  if (!trimmed.startsWith("{")) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function getMessageHandlerCandidate(parsed) {
+  const nested = parsed.messageHandler;
+  if (isRecord(nested)) {
+    return nested;
+  }
+  if (typeof parsed.action === "string") {
+    return parsed;
+  }
+  return null;
+}
+function readLegacyField(response, fieldName) {
+  const lineMatch = new RegExp(`(^|\\n)${fieldName}:\\s*([^\\n]+)`, "i").exec(
+    response
+  );
+  if (lineMatch?.[2]) {
+    const value = lineMatch[2].trim();
+    return value.length > 0 ? value : void 0;
+  }
+  return void 0;
+}
+function parseRoutingDecision(response) {
+  const parsed = parseJsonObject(response);
+  const candidate = parsed ? getMessageHandlerCandidate(parsed) : null;
+  const rawAction = typeof candidate?.action === "string" ? candidate.action : readLegacyField(response, "action");
+  const decision = rawAction?.toUpperCase();
+  const contexts = Array.isArray(candidate?.contexts) ? candidate.contexts.filter(
+    (context) => typeof context === "string" && context.trim().length > 0
+  ) : [];
+  const primaryContext = contexts[0] ?? readLegacyField(response, "primaryContext");
+  const secondaryContexts = contexts.length > 1 ? contexts.slice(1) : parseDelimitedList(
+    readLegacyField(response, "secondaryContexts") ?? ""
+  );
+  return {
+    decision: decision === "RESPOND" || decision === "IGNORE" || decision === "STOP" ? decision : void 0,
+    primaryContext,
+    secondaryContexts
+  };
+}
+function collectRuntimeCandidates(runtime) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (candidate) => {
+    if (!candidate || seen.has(candidate)) {
+      return;
+    }
+    seen.add(candidate);
+    candidates.push(candidate);
+  };
+  if (typeof runtime.getServicesByType === "function") {
+    const value = runtime.getServicesByType("trajectories");
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        push(entry);
+      }
+    } else {
+      push(value);
+    }
+  }
+  if (typeof runtime.getService === "function") {
+    push(runtime.getService("trajectories"));
+  }
+  return candidates;
+}
+function getTrajectoryLogger(runtime) {
+  for (const candidate of collectRuntimeCandidates(runtime)) {
+    if (candidate && typeof candidate === "object" && typeof candidate.getTrajectoryDetail === "function") {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function waitForTrajectoryDetail(logger, trajectoryId) {
+  if (!logger?.getTrajectoryDetail) {
+    return null;
+  }
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const detail = await logger.getTrajectoryDetail(trajectoryId);
+    if (detail) {
+      return detail;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  return null;
+}
+function normalizeActionName(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim().toUpperCase();
+}
+function collectActionNamesFromContent(content) {
+  if (!content?.actions) {
+    return [];
+  }
+  return content.actions.map((action) => normalizeActionName(action)).filter(
+    (action, index, actions) => action.length > 0 && actions.indexOf(action) === index
+  );
+}
+function collectExecutedActionNames(runtime, messageId) {
+  return runtime.getActionResults(messageId).map((result) => {
+    if (typeof result === "string") {
+      return result;
+    }
+    const record = isRecord(result) ? result : null;
+    if (!record) {
+      return "";
+    }
+    if (typeof record.actionName === "string") {
+      return record.actionName;
+    }
+    const data = isRecord(record.data) ? record.data : null;
+    return typeof data?.actionName === "string" ? data.actionName : "";
+  }).map((action) => normalizeActionName(action)).filter(
+    (action, index, actions) => action.length > 0 && actions.indexOf(action) === index
+  );
+}
+function resolveActualDecision(args) {
+  const callbackActions = args.callbackContents.flatMap(
+    (content) => collectActionNamesFromContent(content)
+  );
+  if (callbackActions.includes("STOP")) {
+    return "STOP";
+  }
+  if (callbackActions.includes("IGNORE")) {
+    return "IGNORE";
+  }
+  const responseActions = collectActionNamesFromContent(args.responseContent);
+  if (responseActions.includes("STOP")) {
+    return "STOP";
+  }
+  if (responseActions.includes("IGNORE") && !args.didRespond) {
+    return "IGNORE";
+  }
+  if (args.shouldRespondDecision) {
+    return args.shouldRespondDecision;
+  }
+  return args.didRespond ? "RESPOND" : "IGNORE";
+}
+function secondaryContextsEqual(expected, actual) {
+  const normalizedExpected = [
+    ...new Set(expected.map((value) => value.trim().toLowerCase()))
+  ].filter(Boolean).sort();
+  const normalizedActual = [
+    ...new Set(actual.map((value) => value.trim().toLowerCase()))
+  ].filter(Boolean).sort();
+  return JSON.stringify(normalizedExpected) === JSON.stringify(normalizedActual);
+}
+function buildEmptyBucketReport() {
+  return {
+    totalEpisodes: 0,
+    decisionMatches: 0,
+    routingMatches: 0,
+    primaryContextMatches: 0,
+    secondaryContextExactMatches: 0,
+    actionRelevantEpisodes: 0,
+    actionMatches: 0,
+    selectedActionMatches: 0,
+    executedActionMatches: 0,
+    decisionAccuracy: 0,
+    routingAccuracy: 0,
+    primaryContextAccuracy: 0,
+    secondaryContextExactAccuracy: 0,
+    actionAccuracy: 0,
+    selectedActionAccuracy: 0,
+    executedActionAccuracy: 0
+  };
+}
+function finalizeBucketReport(bucket) {
+  return {
+    ...bucket,
+    decisionAccuracy: bucket.decisionMatches / (bucket.totalEpisodes || 1),
+    routingAccuracy: bucket.routingMatches / (bucket.totalEpisodes || 1),
+    primaryContextAccuracy: bucket.primaryContextMatches / (bucket.totalEpisodes || 1),
+    secondaryContextExactAccuracy: bucket.secondaryContextExactMatches / (bucket.totalEpisodes || 1),
+    actionAccuracy: bucket.actionMatches / (bucket.actionRelevantEpisodes || 1),
+    selectedActionAccuracy: bucket.selectedActionMatches / (bucket.actionRelevantEpisodes || 1),
+    executedActionAccuracy: bucket.executedActionMatches / (bucket.actionRelevantEpisodes || 1)
+  };
+}
+function updateBucketReport(bucket, execution) {
+  bucket.totalEpisodes += 1;
+  if (execution.decisionMatch) {
+    bucket.decisionMatches += 1;
+  }
+  if (execution.routingMatch) {
+    bucket.routingMatches += 1;
+  }
+  if (execution.primaryContextMatch) {
+    bucket.primaryContextMatches += 1;
+  }
+  if (execution.secondaryContextExactMatch) {
+    bucket.secondaryContextExactMatches += 1;
+  }
+  if (execution.expectedAction) {
+    bucket.actionRelevantEpisodes += 1;
+    if (execution.actionMatch) {
+      bucket.actionMatches += 1;
+    }
+    if (execution.selectedActionMatch) {
+      bucket.selectedActionMatches += 1;
+    }
+    if (execution.executedActionMatch) {
+      bucket.executedActionMatches += 1;
+    }
+  }
+}
+function createDecisionConfusionMatrix() {
+  return {
+    RESPOND: { RESPOND: 0, IGNORE: 0, STOP: 0 },
+    IGNORE: { RESPOND: 0, IGNORE: 0, STOP: 0 },
+    STOP: { RESPOND: 0, IGNORE: 0, STOP: 0 }
+  };
+}
+function resolveMessageRoutingFallback(message) {
+  const metadata = message.content.metadata && typeof message.content.metadata === "object" ? message.content.metadata : {};
+  const responseContext = metadata.__responseContext && typeof metadata.__responseContext === "object" ? metadata.__responseContext : {};
+  const secondaryContexts = Array.isArray(responseContext.secondaryContexts) ? responseContext.secondaryContexts.filter(
+    (value) => typeof value === "string" && value.trim().length > 0
+  ) : parseDelimitedList(String(responseContext.secondaryContexts ?? ""));
+  return {
+    primaryContext: typeof responseContext.primaryContext === "string" ? responseContext.primaryContext : void 0,
+    secondaryContexts
+  };
+}
+function buildParticipantId(episodeId, speaker) {
+  return deterministicUuid(`roleplay-${episodeId}-${speaker.toLowerCase()}`);
+}
+function buildRoomIds(episodeId) {
+  return {
+    roomId: deterministicUuid(`roleplay-room-${episodeId}`),
+    worldId: deterministicUuid(`roleplay-world-${episodeId}`),
+    messageServerId: deterministicUuid(`roleplay-server-${episodeId}`)
+  };
+}
+async function seedTurnMemory(runtime, episode, turn, roomIds) {
+  const entityId = turn.role === "assistant" ? runtime.agentId : buildParticipantId(episode.id, turn.speaker);
+  await runtime.createMemory(
+    {
+      id: deterministicUuid(`roleplay-seed-${episode.id}-${turn.id}`),
+      entityId,
+      agentId: runtime.agentId,
+      roomId: roomIds.roomId,
+      createdAt: Date.now(),
+      content: {
+        text: turn.content,
+        source: episode.platform,
+        channelType: GROUP_CHANNEL,
+        metadata: {
+          entityName: turn.speaker
+        }
+      }
+    },
+    "messages"
+  );
+}
+async function ensureRoleplayConnections(runtime, episode, roomIds) {
+  if (typeof runtime.ensureConnection !== "function") {
+    return;
+  }
+  const participants = [
+    ...new Set(
+      episode.turns.filter((turn) => turn.role === "participant").map((turn) => turn.speaker)
+    )
+  ];
+  for (const speaker of participants) {
+    const entityId = buildParticipantId(episode.id, speaker);
+    await runtime.ensureConnection({
+      entityId,
+      roomId: roomIds.roomId,
+      worldId: roomIds.worldId,
+      userName: speaker,
+      source: episode.platform,
+      channelId: `roleplay-${episode.id}`,
+      type: GROUP_CHANNEL,
+      messageServerId: roomIds.messageServerId,
+      metadata: {
+        ownership: {
+          ownerId: entityId
+        }
+      }
+    });
+  }
+}
+async function resolveRuntime(runtime) {
+  if (runtime) {
+    return runtime;
+  }
+  const { bootElizaRuntime } = await import("@elizaos/agent");
+  return await bootElizaRuntime();
+}
+async function executeRoleplayEpisode(episode, options = {}) {
+  const runtime = await resolveRuntime(options.runtime);
+  const roomIds = buildRoomIds(episode.id);
+  const logger = getTrajectoryLogger(runtime);
+  const turnExecutions = [];
+  await ensureRoleplayConnections(runtime, episode, roomIds);
+  for (const turn of episode.turns) {
+    if (turn.role === "assistant") {
+      await seedTurnMemory(runtime, episode, turn, roomIds);
+      turnExecutions.push({
+        turnId: turn.id,
+        speaker: turn.speaker,
+        role: turn.role,
+        isEvaluationTarget: turn.isEvaluationTarget,
+        actualSecondaryContexts: [],
+        selectedActions: [],
+        executedActions: [],
+        responseText: turn.content,
+        callbackTexts: [],
+        warnings: []
+      });
+      continue;
+    }
+    if (!turn.isEvaluationTarget && !options.executeAllParticipantTurns) {
+      await seedTurnMemory(runtime, episode, turn, roomIds);
+      turnExecutions.push({
+        turnId: turn.id,
+        speaker: turn.speaker,
+        role: turn.role,
+        isEvaluationTarget: false,
+        actualSecondaryContexts: [],
+        selectedActions: [],
+        executedActions: [],
+        responseText: "",
+        callbackTexts: [],
+        warnings: []
+      });
+      continue;
+    }
+    const trajectoryId = deterministicUuid(
+      `roleplay-trajectory-${episode.id}-${turn.id}`
+    );
+    const message = {
+      id: deterministicUuid(`roleplay-message-${episode.id}-${turn.id}`),
+      entityId: buildParticipantId(episode.id, turn.speaker),
+      roomId: roomIds.roomId,
+      agentId: runtime.agentId,
+      createdAt: Date.now(),
+      content: {
+        text: turn.content,
+        source: episode.platform,
+        channelType: GROUP_CHANNEL,
+        metadata: {
+          entityName: turn.speaker,
+          type: "message",
+          trajectoryStepId: trajectoryId
+        }
+      }
+    };
+    const callbackContents = [];
+    const result = await runtime.messageService.handleMessage(
+      runtime,
+      message,
+      async (content) => {
+        callbackContents.push(content);
+        return [];
+      },
+      options.timeoutMs ? { timeoutDuration: options.timeoutMs } : void 0
+    );
+    const trajectory2 = await waitForTrajectoryDetail(logger, trajectoryId);
+    const shouldRespondCall = trajectory2?.steps?.flatMap((step) => step.llmCalls ?? []).find((call) => normalizeActionName(call.purpose) === "SHOULD_RESPOND");
+    const routingFromModel = shouldRespondCall?.response ? parseRoutingDecision(shouldRespondCall.response) : { secondaryContexts: [] };
+    const routingFallback = resolveMessageRoutingFallback(message);
+    const actualDecision = resolveActualDecision({
+      didRespond: result.didRespond,
+      callbackContents,
+      responseContent: result.responseContent ?? null,
+      shouldRespondDecision: routingFromModel.decision
+    });
+    const actualPrimaryContext = routingFromModel.primaryContext ?? routingFallback.primaryContext;
+    const actualSecondaryContexts = routingFromModel.secondaryContexts.length > 0 ? routingFromModel.secondaryContexts : routingFallback.secondaryContexts;
+    const selectedActions = [
+      .../* @__PURE__ */ new Set([
+        ...collectActionNamesFromContent(result.responseContent ?? null),
+        ...callbackContents.flatMap(
+          (content) => collectActionNamesFromContent(content)
+        )
+      ])
+    ];
+    if (!message.id) {
+      throw new Error(`Roleplay message ${turn.id} is missing an ID`);
+    }
+    const executedActions = collectExecutedActionNames(runtime, message.id);
+    const callbackTexts = callbackContents.map((content) => content.text?.trim() ?? "").filter((text) => text.length > 0);
+    const responseText = result.responseContent?.text?.trim() ?? callbackTexts[callbackTexts.length - 1] ?? "";
+    const warnings = [];
+    if (!trajectory2) {
+      warnings.push("trajectory_capture_missing");
+    }
+    if (turn.isEvaluationTarget && !routingFromModel.primaryContext && !routingFallback.primaryContext) {
+      warnings.push("context_routing_missing");
+    }
+    turnExecutions.push({
+      turnId: turn.id,
+      speaker: turn.speaker,
+      role: turn.role,
+      isEvaluationTarget: turn.isEvaluationTarget,
+      actualDecision,
+      actualPrimaryContext,
+      actualSecondaryContexts,
+      selectedActions,
+      executedActions,
+      responseText,
+      callbackTexts,
+      trajectoryId,
+      warnings
+    });
+  }
+  const evaluationTurn = turnExecutions.find((turn) => turn.isEvaluationTarget);
+  if (!evaluationTurn) {
+    throw new Error(
+      `Roleplay episode ${episode.id} has no evaluation target turn`
+    );
+  }
+  const actualActions = [
+    .../* @__PURE__ */ new Set([
+      ...evaluationTurn.selectedActions,
+      ...evaluationTurn.executedActions
+    ])
+  ];
+  const decisionMatch = evaluationTurn.actualDecision === episode.expectedDecision;
+  const primaryContextMatch = (evaluationTurn.actualPrimaryContext ?? "").toLowerCase() === episode.primaryContext.toLowerCase();
+  const secondaryContextExactMatch = secondaryContextsEqual(
+    episode.secondaryContexts,
+    evaluationTurn.actualSecondaryContexts
+  );
+  const routingMatch = primaryContextMatch && secondaryContextExactMatch;
+  const normalizedExpectedAction = episode.expectedAction ? normalizeActionName(episode.expectedAction) : "";
+  const selectedActionMatch = episode.expectedAction ? evaluationTurn.selectedActions.includes(normalizedExpectedAction) : true;
+  const executedActionMatch = episode.expectedAction ? evaluationTurn.executedActions.includes(normalizedExpectedAction) : true;
+  const actionMatch = episode.expectedAction ? actualActions.includes(normalizedExpectedAction) : true;
+  const trajectory = evaluationTurn.trajectoryId && logger ? await waitForTrajectoryDetail(logger, evaluationTurn.trajectoryId) : null;
+  return {
+    episodeId: episode.id,
+    blueprintId: episode.blueprintId,
+    agentName: episode.agentName,
+    pattern: typeof episode.metadata.pattern === "string" ? episode.metadata.pattern : void 0,
+    evaluationTurnId: episode.evaluationTurnId,
+    expectedDecision: episode.expectedDecision,
+    actualDecision: evaluationTurn.actualDecision ?? "IGNORE",
+    expectedPrimaryContext: episode.primaryContext,
+    actualPrimaryContext: evaluationTurn.actualPrimaryContext,
+    expectedSecondaryContexts: episode.secondaryContexts,
+    actualSecondaryContexts: evaluationTurn.actualSecondaryContexts,
+    expectedAction: episode.expectedAction,
+    actualActions,
+    selectedActions: evaluationTurn.selectedActions,
+    executedActions: evaluationTurn.executedActions,
+    decisionMatch,
+    primaryContextMatch,
+    secondaryContextExactMatch,
+    routingMatch,
+    actionMatch,
+    selectedActionMatch,
+    executedActionMatch,
+    trajectoryCaptured: Boolean(trajectory),
+    responseText: evaluationTurn.responseText,
+    callbackTexts: evaluationTurn.callbackTexts,
+    warnings: evaluationTurn.warnings,
+    turnExecutions,
+    trajectory
+  };
+}
+async function executeRoleplayEpisodes(episodes, options = {}) {
+  const runtime = await resolveRuntime(options.runtime);
+  const executions = [];
+  for (const episode of episodes) {
+    executions.push(
+      await executeRoleplayEpisode(episode, {
+        ...options,
+        runtime
+      })
+    );
+  }
+  return executions;
+}
+function buildRoleplayExecutionReport(executions, trajectoryDatasetSummary) {
+  const totalEpisodes = executions.length;
+  const decisionMatches = executions.filter(
+    (execution) => execution.decisionMatch
+  ).length;
+  const routingMatches = executions.filter(
+    (execution) => execution.routingMatch
+  ).length;
+  const primaryContextMatches = executions.filter(
+    (execution) => execution.primaryContextMatch
+  ).length;
+  const secondaryContextExactMatches = executions.filter(
+    (execution) => execution.secondaryContextExactMatch
+  ).length;
+  const actionRelevantExecutions = executions.filter(
+    (execution) => execution.expectedAction
+  );
+  const actionMatches = actionRelevantExecutions.filter(
+    (execution) => execution.actionMatch
+  ).length;
+  const selectedActionMatches = actionRelevantExecutions.filter(
+    (execution) => execution.selectedActionMatch
+  ).length;
+  const executedActionMatches = actionRelevantExecutions.filter(
+    (execution) => execution.executedActionMatch
+  ).length;
+  const trajectoryCaptured = executions.filter(
+    (execution) => execution.trajectoryCaptured
+  ).length;
+  const decisionConfusionMatrix = createDecisionConfusionMatrix();
+  const warningCounts = {};
+  const byPrimaryContext = {};
+  const byPattern = {};
+  for (const execution of executions) {
+    decisionConfusionMatrix[execution.expectedDecision][execution.actualDecision] += 1;
+    for (const warning of execution.warnings) {
+      warningCounts[warning] = (warningCounts[warning] ?? 0) + 1;
+    }
+    const contextKey = execution.expectedPrimaryContext.toLowerCase();
+    byPrimaryContext[contextKey] ??= buildEmptyBucketReport();
+    updateBucketReport(byPrimaryContext[contextKey], execution);
+    const patternKey = execution.pattern ?? "unknown";
+    byPattern[patternKey] ??= buildEmptyBucketReport();
+    updateBucketReport(byPattern[patternKey], execution);
+  }
+  return {
+    totalEpisodes,
+    decisionMatches,
+    routingMatches,
+    primaryContextMatches,
+    secondaryContextExactMatches,
+    actionMatches,
+    selectedActionMatches,
+    executedActionMatches,
+    trajectoryCaptured,
+    decisionAccuracy: decisionMatches / (totalEpisodes || 1),
+    routingAccuracy: routingMatches / (totalEpisodes || 1),
+    primaryContextAccuracy: primaryContextMatches / (totalEpisodes || 1),
+    secondaryContextExactAccuracy: secondaryContextExactMatches / (totalEpisodes || 1),
+    actionAccuracy: actionMatches / (actionRelevantExecutions.length || 1),
+    selectedActionAccuracy: selectedActionMatches / (actionRelevantExecutions.length || 1),
+    executedActionAccuracy: executedActionMatches / (actionRelevantExecutions.length || 1),
+    trajectoryCaptureRate: trajectoryCaptured / (totalEpisodes || 1),
+    decisionConfusionMatrix,
+    warningCounts,
+    byPrimaryContext: Object.fromEntries(
+      Object.entries(byPrimaryContext).map(([context, bucket]) => [
+        context,
+        finalizeBucketReport(bucket)
+      ])
+    ),
+    byPattern: Object.fromEntries(
+      Object.entries(byPattern).map(([pattern, bucket]) => [
+        pattern,
+        finalizeBucketReport(bucket)
+      ])
+    ),
+    trajectoryDatasetSummary,
+    mismatches: executions.filter(
+      (execution) => !execution.decisionMatch || !execution.routingMatch || !execution.actionMatch || !execution.selectedActionMatch || !execution.executedActionMatch
+    ).map((execution) => ({
+      episodeId: execution.episodeId,
+      pattern: execution.pattern,
+      expectedDecision: execution.expectedDecision,
+      actualDecision: execution.actualDecision,
+      expectedPrimaryContext: execution.expectedPrimaryContext,
+      actualPrimaryContext: execution.actualPrimaryContext,
+      expectedAction: execution.expectedAction,
+      actualActions: execution.actualActions,
+      selectedActions: execution.selectedActions,
+      executedActions: execution.executedActions,
+      warnings: execution.warnings
+    }))
+  };
+}
+async function exportRoleplayExecutionResults(executions, outputDir) {
+  await mkdir(outputDir, { recursive: true });
+  const executionsPath = join(outputDir, "roleplay_execution_results.json");
+  const reportPath = join(outputDir, "roleplay_execution_report.json");
+  const trajectories = executions.map((execution) => execution.trajectory).filter((trajectory) => Boolean(trajectory));
+  const trajectoryDataset = trajectories.length > 0 ? await exportTrajectoryTaskDatasets(
+    trajectories,
+    join(outputDir, "trajectory-datasets")
+  ) : void 0;
+  const report = buildRoleplayExecutionReport(
+    executions,
+    trajectoryDataset?.summary ?? null
+  );
+  await writeFile(executionsPath, JSON.stringify(executions, null, 2));
+  await writeFile(reportPath, JSON.stringify(report, null, 2));
+  return {
+    executionsPath,
+    reportPath,
+    trajectoryDataset
+  };
+}
+async function loadRoleplayEpisodesFromPath(inputPath) {
+  const raw = await readFile(inputPath, "utf-8");
+  if (inputPath.endsWith(".jsonl")) {
+    return raw.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line)).map((line) => ({
+      id: line.episodeId,
+      blueprintId: line.blueprintId,
+      agentName: line.agentName,
+      platform: "group-chat",
+      roomType: "group",
+      primaryContext: line.primaryContext,
+      secondaryContexts: line.secondaryContexts,
+      expectedDecision: line.expectedDecision,
+      expectedAction: line.expectedAction,
+      evaluationTurnId: line.evaluationTurnId,
+      turns: line.conversation.map((turn) => ({
+        id: turn.id,
+        role: turn.role,
+        speaker: turn.speaker,
+        content: turn.content,
+        isEvaluationTarget: turn.id === line.evaluationTurnId
+      })),
+      metadata: {
+        pattern: "manifest-import",
+        generatedBy: "manifest",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceSampleId: line.episodeId
+      }
+    }));
+  }
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error(`Expected an array of roleplay episodes in ${inputPath}`);
+  }
+  return parsed;
+}
+export {
+  buildRoleplayExecutionReport,
+  executeRoleplayEpisode,
+  executeRoleplayEpisodes,
+  exportRoleplayExecutionResults,
+  loadRoleplayEpisodesFromPath
+};
+//# sourceMappingURL=roleplay-executor.js.map