@tangle-network/agent-runtime 0.75.1 → 0.76.0

package/dist/index.d.ts

@@ -2,11 +2,11 @@ import { AgentProfile, AgentEvalError, AnalystFinding, KnowledgeReadinessReport,
 export { AgentEvalError, AgentEvalErrorCode, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, RunRecord, ValidationError } from '@tangle-network/agent-eval';
 import { f as AgentBackendInput, g as AgentExecutionBackend, O as OpenAIChatTool, h as OpenAIChatToolChoice, i as OpenAIChatResponseFormat, j as AgentBackendContext, a as RuntimeStreamEvent, K as KnowledgeReadinessDecision, k as RunAgentTaskOptions, l as AgentTaskRunResult, m as RunAgentTaskStreamOptions, n as AgentRuntimeEvent, o as AgentTaskStatus, p as RuntimeSessionStore, q as RuntimeSession, R as RuntimeHooks } from './types-B-jWSfcu.js';
 export { r as AgentAdapter, s as AgentKnowledgeProvider, t as AgentRuntimeEventSink, u as AgentTaskContext, v as AgentTaskSpec, B as BackendErrorDetail, w as RuntimeDecisionEvidenceRef, x as RuntimeDecisionKind, y as RuntimeDecisionPoint, z as RuntimeHookContext, C as RuntimeHookErrorContext, D as RuntimeHookEvent, F as RuntimeHookPhase, G as RuntimeHookTarget, H as RuntimeRunHandle, J as RuntimeRunPersistenceAdapter, M as RuntimeRunRow, N as composeRuntimeHooks, P as defineRuntimeHooks, Q as notifyRuntimeDecisionPoint, T as notifyRuntimeHookEvent, U as startRuntimeRun } from './types-B-jWSfcu.js';
-import { AgentProfile as AgentProfile$1 } from '@tangle-network/agent-interface';
 import { Scenario, ProfileDispatchFn } from '@tangle-network/agent-eval/campaign';
 import { C as CandidateGenerator } from './mcp-serve-verifier-CT1KLTG_.js';
 export { A as AgenticGeneratorOptions, I as ImprovementDriverOptions, M as McpServeSpec, V as Verifier, a as VerifyResult, b as agenticGenerator, c as commandVerifier, i as improvementDriver, m as mcpServeVerifier } from './mcp-serve-verifier-CT1KLTG_.js';
 import { Scenario as Scenario$1, SurfaceProposer, JudgeConfig, MutableSurface, DispatchContext, SelfImproveBudget, SelfImproveLlm, SelfImproveResult } from '@tangle-network/agent-eval/contract';
+import { AgentProfile as AgentProfile$1 } from '@tangle-network/agent-interface';
 import { S as SurfaceImprovementEdit } from './improvement-adapter-CioiEE2z.js';
 import { I as ImprovementAdapter } from './types-BC3bZpH0.js';
 export { D as DELEGATED_LOOP_MODES, a as DelegatedLoopMode, b as DelegatedLoopRegistry, c as DelegatedLoopResult, d as DelegatedLoopRunner, L as LoopRunnerCliArgs, e as LoopRunnerCliResult, R as ResearchLoopResult, f as ResearchLoopRunnerOptions, g as RunDelegatedLoopOptions, V as VetoedFact, W as WorktreeLoopRunnerOptions, h as auditLoopRunner, i as isDelegatedLoopMode, p as parseLoopRunnerArgv, r as researchLoopRunner, j as runDelegatedLoop, k as runLoopRunnerCli, s as selfImproveLoopRunner, w as worktreeLoopRunner } from './loop-runner-bin-Dbtg787n.js';
@@ -675,144 +675,6 @@ declare function defineConversation(input: {
     policy: ConversationPolicy;
 }): Conversation;
 
-/**
- * `runPersonaConversation` — the persona loop runner: run a WORKER `AgentProfile`
- * (the agent under test) as a multi-round conversation driven by a PERSONA (the
- * simulated user), over the persistent conversation transcript.
- *
- * It is profiles-vs-profiles: the persona is itself a driver `AgentProfile` (an
- * LLM role-playing the user from its facts) — `runConversation` runs the two
- * against each other. Scripted persona turns are kept as a deterministic
- * fast-path. Only the WORKER is metered (it is the side under test); the
- * persona-driver is the test harness, not billed against the agent.
- *
- * `runPersonaDispatch` wraps the runner as a `ProfileDispatchFn` so it drops
- * straight into `runProfileMatrix({ dispatch })` — the same loop serves a single
- * cell and the whole matrix, replacing the per-agent hand-rolled
- * `dispatchWithSurface` bridges.
- */
-
-/** A persona that drives the conversation: either a full driver `AgentProfile`
- *  (an LLM user-sim) or a deterministic script of user turns (the fast-path). */
-type PersonaDriver = {
-    kind: 'profile';
-    profile: AgentProfile;
-} | {
-    kind: 'scripted';
-    turns: string[];
-};
-interface RunPersonaConversationOptions {
-    /** The agent under test. Metered; its rendered prompt leads its turns. */
-    worker: AgentProfile;
-    /** The simulated user driving the dialogue. */
-    persona: PersonaDriver;
-    /** Turn an `AgentProfile` into a runnable backend (router / sandbox / fake).
-     *  Applied to the worker and to a `profile`-kind persona. */
-    backendFor: (profile: AgentProfile, role: 'worker' | 'persona') => AgentExecutionBackend;
-    /** Render a profile's system prompt — prepended to that profile's messages. */
-    systemPromptOf: (profile: AgentProfile) => string;
-    /** Speaker-turn cap. Default for a scripted persona = `2 * turns.length`
-     *  (worker answers each user turn). REQUIRED for a `profile` persona. */
-    maxTurns?: number;
-    /** Kickoff message routed to the first speaker (the persona). Default 'Begin.' */
-    seed?: string;
-    /** Content-based "until satisfied" halt, called after every turn. `maxTurns` is the
-     *  hard ceiling; this is the early stop (the persona declares the goal met / unreachable). */
-    haltOn?: HaltPredicate;
-    signal?: AbortSignal;
-    /** Worker participant / transcript speaker label. Default 'agent'. */
-    workerName?: string;
-}
-interface PersonaConversationResult {
-    transcript: ConversationTurn[];
-    turns: number;
-    halted: HaltReason;
-    /** Worker-only spend (the side under test). */
-    costUsd: number;
-    tokensIn: number;
-    tokensOut: number;
-}
-/**
- * Run one worker profile against one persona as a multi-round conversation.
- * The persona leads (participant 0): it speaks, the worker answers, repeat,
- * until `maxTurns`. Returns the persistent transcript + worker-only usage.
- */
-declare function runPersonaConversation(opts: RunPersonaConversationOptions): Promise<PersonaConversationResult>;
-interface RunPersonaConfig<TScenario extends Scenario, TArtifact> {
-    /** Turn an `AgentProfile` into a runnable backend (router / sandbox / fake). */
-    backendFor: (profile: AgentProfile, role: 'worker' | 'persona') => AgentExecutionBackend;
-    /** Render a profile's system prompt. */
-    systemPromptOf: (profile: AgentProfile) => string;
-    /** The persona driving each scenario — a driver profile or scripted turns. */
-    personaOf: (scenario: TScenario) => PersonaDriver;
-    /** Build the scored artifact from the finished transcript. */
-    artifactOf: (transcript: ConversationTurn[], scenario: TScenario) => TArtifact;
-    /** Speaker-turn cap (required when a persona is profile-driven). */
-    maxTurns?: (scenario: TScenario) => number;
-    seed?: (scenario: TScenario) => string;
-    workerName?: string;
-}
-/**
- * Wrap {@link runPersonaConversation} as a `ProfileDispatchFn` for
- * `runProfileMatrix`: the profile axis is the worker-under-test, the scenario
- * axis is the persona, and the runner is the cell. Meters the worker through
- * `ctx.cost` so the matrix's backend-integrity guard sees real usage.
- */
-declare function runPersonaDispatch<TScenario extends Scenario, TArtifact>(config: RunPersonaConfig<TScenario, TArtifact>): ProfileDispatchFn<TScenario, TArtifact>;
-
-/**
- * `evalPersona` — the one-call user-sim product eval. Run a worker `AgentProfile` (the agent under
- * test) against a PERSONA (a simulated user — a scripted script or an LLM driver profile) as a
- * multi-round conversation, with the two seams `runPersonaConversation` otherwise makes you hand-wire
- * defaulted:
- *
- *  - `backendFor` defaults to `createOpenAICompatibleBackend({ apiKey, baseUrl, model })` (the
- *    OpenAI-compatible router endpoint) for both the worker and a profile-driven persona;
- *  - `systemPromptOf` defaults to `p.prompt?.systemPrompt ?? ''`.
- *
- * Either is overridable (tests pass a fake `backendFor` to run offline). `maxTurns` (the hard
- * ceiling) and `haltOn` (the "until satisfied" early stop) pass straight through. Mirrors
- * `supervise()`'s defaulting style: the common case is one call; the raw `runPersonaConversation`
- * seam stays available for full control.
- *
- * The profile here is the authored `AgentProfile` (with `prompt.systemPrompt`), which is why the
- * default `systemPromptOf` can read it. `runPersonaConversation` treats the profile opaquely — only
- * the two callbacks inspect it — so the worker/persona profiles flow straight through.
- */
-
-interface EvalPersonaOptions {
-    /** Router (or OpenAI-compatible) endpoint for the DEFAULT backend. Required unless `backendFor`
-     *  is supplied (tests/advanced override the backend entirely and may omit these). */
-    apiKey?: string;
-    baseUrl?: string;
-    model?: string;
-    /** Override the backend seam directly instead of deriving it from `apiKey`/`baseUrl`/`model`
-     *  (the offline-test path: pass a fake here and the credentials are not needed). */
-    backendFor?: (profile: AgentProfile$1, role: 'worker' | 'persona') => AgentExecutionBackend;
-    /** Override system-prompt rendering. Default: `p.prompt?.systemPrompt ?? ''`. */
-    systemPromptOf?: (profile: AgentProfile$1) => string;
-    /** Hard speaker-turn ceiling. REQUIRED for a profile-driven persona; for a scripted persona it
-     *  defaults to `2 * turns.length`. `maxTurns` is a CEILING, NOT a target — `maxTurns: 0` is zero
-     *  turns, not run-until-done; `haltOn` is the "until satisfied" knob. */
-    maxTurns?: number;
-    /** Content-based early stop (the persona declares the goal met / unreachable). */
-    haltOn?: HaltPredicate;
-    /** Kickoff message to the persona. Default 'Begin.' */
-    seed?: string;
-    signal?: AbortSignal;
-    /** Worker transcript speaker label. Default 'agent'. */
-    workerName?: string;
-}
-/** The persona side, authored against the same `AgentProfile` shape as the worker. */
-type EvalPersona = {
-    kind: 'scripted';
-    turns: string[];
-} | {
-    kind: 'profile';
-    profile: AgentProfile$1;
-};
-declare function evalPersona(worker: AgentProfile$1, persona: EvalPersona, opts?: EvalPersonaOptions): Promise<PersonaConversationResult>;
-
 /**
  * @stable
  *
@@ -947,6 +809,91 @@ declare class SqlConversationJournal implements ConversationJournal {
 declare function runConversation(conversation: Conversation, options: RunConversationOptions): Promise<ConversationResult>;
 declare function runConversationStream(conversation: Conversation, options: RunConversationOptions): AsyncIterable<ConversationStreamEvent>;
 
+/**
+ * `runPersonaConversation` — the persona loop runner: run a WORKER `AgentProfile`
+ * (the agent under test) as a multi-round conversation driven by a PERSONA (the
+ * simulated user), over the persistent conversation transcript.
+ *
+ * It is profiles-vs-profiles: the persona is itself a driver `AgentProfile` (an
+ * LLM role-playing the user from its facts) — `runConversation` runs the two
+ * against each other. Scripted persona turns are kept as a deterministic
+ * fast-path. Only the WORKER is metered (it is the side under test); the
+ * persona-driver is the test harness, not billed against the agent.
+ *
+ * `runPersonaDispatch` wraps the runner as a `ProfileDispatchFn` so it drops
+ * straight into `runProfileMatrix({ dispatch })` — the same loop serves a single
+ * cell and the whole matrix, replacing the per-agent hand-rolled
+ * `dispatchWithSurface` bridges.
+ */
+
+/** A persona that drives the conversation: either a full driver `AgentProfile`
+ *  (an LLM user-sim) or a deterministic script of user turns (the fast-path). */
+type PersonaDriver = {
+    kind: 'profile';
+    profile: AgentProfile;
+} | {
+    kind: 'scripted';
+    turns: string[];
+};
+interface RunPersonaConversationOptions {
+    /** The agent under test. Metered; its rendered prompt leads its turns. */
+    worker: AgentProfile;
+    /** The simulated user driving the dialogue. */
+    persona: PersonaDriver;
+    /** Turn an `AgentProfile` into a runnable backend (router / sandbox / fake).
+     *  Applied to the worker and to a `profile`-kind persona. */
+    backendFor: (profile: AgentProfile, role: 'worker' | 'persona') => AgentExecutionBackend;
+    /** Render a profile's system prompt — prepended to that profile's messages. */
+    systemPromptOf: (profile: AgentProfile) => string;
+    /** Speaker-turn cap. Default for a scripted persona = `2 * turns.length`
+     *  (worker answers each user turn). REQUIRED for a `profile` persona. */
+    maxTurns?: number;
+    /** Kickoff message routed to the first speaker (the persona). Default 'Begin.' */
+    seed?: string;
+    /** Content-based "until satisfied" halt, called after every turn. `maxTurns` is the
+     *  hard ceiling; this is the early stop (the persona declares the goal met / unreachable). */
+    haltOn?: HaltPredicate;
+    signal?: AbortSignal;
+    /** Worker participant / transcript speaker label. Default 'agent'. */
+    workerName?: string;
+}
+interface PersonaConversationResult {
+    transcript: ConversationTurn[];
+    turns: number;
+    halted: HaltReason;
+    /** Worker-only spend (the side under test). */
+    costUsd: number;
+    tokensIn: number;
+    tokensOut: number;
+}
+/**
+ * Run one worker profile against one persona as a multi-round conversation.
+ * The persona leads (participant 0): it speaks, the worker answers, repeat,
+ * until `maxTurns`. Returns the persistent transcript + worker-only usage.
+ */
+declare function runPersonaConversation(opts: RunPersonaConversationOptions): Promise<PersonaConversationResult>;
+interface RunPersonaConfig<TScenario extends Scenario, TArtifact> {
+    /** Turn an `AgentProfile` into a runnable backend (router / sandbox / fake). */
+    backendFor: (profile: AgentProfile, role: 'worker' | 'persona') => AgentExecutionBackend;
+    /** Render a profile's system prompt. */
+    systemPromptOf: (profile: AgentProfile) => string;
+    /** The persona driving each scenario — a driver profile or scripted turns. */
+    personaOf: (scenario: TScenario) => PersonaDriver;
+    /** Build the scored artifact from the finished transcript. */
+    artifactOf: (transcript: ConversationTurn[], scenario: TScenario) => TArtifact;
+    /** Speaker-turn cap (required when a persona is profile-driven). */
+    maxTurns?: (scenario: TScenario) => number;
+    seed?: (scenario: TScenario) => string;
+    workerName?: string;
+}
+/**
+ * Wrap {@link runPersonaConversation} as a `ProfileDispatchFn` for
+ * `runProfileMatrix`: the profile axis is the worker-under-test, the scenario
+ * axis is the persona, and the runner is the cell. Meters the worker through
+ * `ctx.cost` so the matrix's backend-integrity guard sees real usage.
+ */
+declare function runPersonaDispatch<TScenario extends Scenario, TArtifact>(config: RunPersonaConfig<TScenario, TArtifact>): ProfileDispatchFn<TScenario, TArtifact>;
+
 /**
  * @stable
  *
@@ -1735,4 +1682,4 @@ interface StreamToolLoopOptions<Raw> {
  *  `capped` if it stops for any non-completed reason with calls still pending. */
 declare function streamToolLoop<Raw>(opts: StreamToolLoopOptions<Raw>): AsyncGenerator<StreamToolLoopYield<Raw>, void, unknown>;
 
-export { AgentBackendContext, AgentBackendInput, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, type AuthSource, type BackendCallPolicy, BackendTransportError, CandidateGenerator, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type CircuitBreakerConfig, CircuitBreakerState, CircuitOpenError, type Conversation, type ConversationDriveState, type ConversationJournal, type ConversationJournalEntry, type ConversationParticipant, type ConversationPolicy, type ConversationResult, type ConversationStreamEvent, type ConversationTurn, type D1DatabaseLike, type D1StmtLike, DEFAULT_MAX_DEPTH, DEFAULT_ROUTER_BASE_URL, DeadlineExceededError, type EvalPersonaOptions, FORWARD_HEADERS, FileConversationJournal, type ForwardHeaderName, type HaltContext, type HaltPredicate, type HaltReason, type HaltSignal, type ImproveOptions, type ImproveResult, type ImproveSurface, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatResponseFormat, OpenAIChatTool, OpenAIChatToolChoice, type PersonaConversationResult, type PersonaDriver, PlannerError, type PropagatedHeaders, type ReflectiveGeneratorOptions, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunChatTurnInput, type RunConversationOptions, type RunPersonaConfig, type RunPersonaConversationOptions, type RunToolLoopOptions, type RuntimeEventCollector, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SqlAdapter, SqlConversationJournal, type StreamToolLoopOptions, type StreamToolLoopYield, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, type TurnOrder, applyRunRecordDefaults, buildForwardHeaders, cleanModelId, computeBackoff, createConversationBackend, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, d1ToSqlAdapter, decideKnowledgeReadiness, defaultIsRetryable, defineConversation, deriveExecutionId, evalPersona, getModels, handleChatTurn, improve, isDepthExceeded, makePerAttemptSignal, mcpBuildPrompt, readDepth, readinessServerSentEvent, reflectiveGenerator, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runPersonaConversation, runPersonaDispatch, runToolLoop, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, sleep, slugifySpeaker, streamToolLoop, toolBuildPrompt, turnId, validateChatModelId };
+export { AgentBackendContext, AgentBackendInput, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, type AuthSource, type BackendCallPolicy, BackendTransportError, CandidateGenerator, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type CircuitBreakerConfig, CircuitBreakerState, CircuitOpenError, type Conversation, type ConversationDriveState, type ConversationJournal, type ConversationJournalEntry, type ConversationParticipant, type ConversationPolicy, type ConversationResult, type ConversationStreamEvent, type ConversationTurn, type D1DatabaseLike, type D1StmtLike, DEFAULT_MAX_DEPTH, DEFAULT_ROUTER_BASE_URL, DeadlineExceededError, FORWARD_HEADERS, FileConversationJournal, type ForwardHeaderName, type HaltContext, type HaltPredicate, type HaltReason, type HaltSignal, type ImproveOptions, type ImproveResult, type ImproveSurface, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatResponseFormat, OpenAIChatTool, OpenAIChatToolChoice, type PersonaConversationResult, type PersonaDriver, PlannerError, type PropagatedHeaders, type ReflectiveGeneratorOptions, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunChatTurnInput, type RunConversationOptions, type RunPersonaConfig, type RunPersonaConversationOptions, type RunToolLoopOptions, type RuntimeEventCollector, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SqlAdapter, SqlConversationJournal, type StreamToolLoopOptions, type StreamToolLoopYield, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, type TurnOrder, applyRunRecordDefaults, buildForwardHeaders, cleanModelId, computeBackoff, createConversationBackend, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, d1ToSqlAdapter, decideKnowledgeReadiness, defaultIsRetryable, defineConversation, deriveExecutionId, getModels, handleChatTurn, improve, isDepthExceeded, makePerAttemptSignal, mcpBuildPrompt, readDepth, readinessServerSentEvent, reflectiveGenerator, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runPersonaConversation, runPersonaDispatch, runToolLoop, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, sleep, slugifySpeaker, streamToolLoop, toolBuildPrompt, turnId, validateChatModelId };

package/dist/index.js

@@ -1430,146 +1430,6 @@ function normalizePolicy(policy, participantCount) {
   return { ...policy, turnOrder };
 }
 
-// src/conversation/run-persona.ts
-function withProfilePrompt(inner, systemPrompt, counter) {
-  return {
-    kind: inner.kind,
-    start: inner.start ? (input, ctx) => inner.start(input, ctx) : void 0,
-    resume: inner.resume ? (session, input, ctx) => inner.resume(session, input, ctx) : void 0,
-    stop: inner.stop ? (session, reason) => inner.stop(session, reason) : void 0,
-    async *stream(input, context) {
-      const base = input.messages ?? (input.message ? [{ role: "user", content: input.message }] : []);
-      const messages = base[0]?.role === "system" ? base : [{ role: "system", content: systemPrompt }, ...base];
-      for await (const event of inner.stream({ ...input, messages }, context)) {
-        if (counter && event.type === "llm_call") {
-          counter.tokensIn += event.tokensIn ?? 0;
-          counter.tokensOut += event.tokensOut ?? 0;
-          counter.costUsd += event.costUsd ?? 0;
-        }
-        yield event;
-      }
-    }
-  };
-}
-function scriptedPersonaBackend(turns) {
-  let idx = 0;
-  return createIterableBackend({
-    kind: "persona-user",
-    async *stream(_input, context) {
-      const text = turns[idx];
-      if (text === void 0) {
-        throw new Error(
-          `persona-user: ran out of scripted turns at index ${idx} (had ${turns.length})`
-        );
-      }
-      idx += 1;
-      yield {
-        type: "text_delta",
-        task: context.task,
-        session: context.session,
-        text,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    }
-  });
-}
-async function runPersonaConversation(opts) {
-  const counter = { tokensIn: 0, tokensOut: 0, costUsd: 0 };
-  const workerName = opts.workerName ?? "agent";
-  const worker = withProfilePrompt(
-    opts.backendFor(opts.worker, "worker"),
-    opts.systemPromptOf(opts.worker),
-    counter
-  );
-  let persona;
-  let maxTurns;
-  if (opts.persona.kind === "scripted") {
-    if (opts.persona.turns.length === 0) {
-      throw new Error("runPersonaConversation: scripted persona has no turns");
-    }
-    persona = scriptedPersonaBackend(opts.persona.turns);
-    maxTurns = opts.maxTurns ?? 2 * opts.persona.turns.length;
-  } else {
-    persona = withProfilePrompt(
-      opts.backendFor(opts.persona.profile, "persona"),
-      opts.systemPromptOf(opts.persona.profile)
-    );
-    if (opts.maxTurns === void 0) {
-      throw new Error("runPersonaConversation: maxTurns is required for a profile-driven persona");
-    }
-    maxTurns = opts.maxTurns;
-  }
-  const conversation = defineConversation({
-    // Persona leads (participant 0): the seed routes to it, it produces the
-    // user turn, the worker answers, alternate.
-    participants: [
-      { name: "user", backend: persona },
-      { name: workerName, backend: worker }
-    ],
-    policy: { maxTurns, turnOrder: "alternate", ...opts.haltOn ? { haltOn: opts.haltOn } : {} }
-  });
-  const result = await runConversation(conversation, {
-    seed: opts.seed ?? "Begin.",
-    signal: opts.signal
-  });
-  const costUsd = counter.costUsd > 0 ? counter.costUsd : opts.persona.kind === "scripted" ? result.spentCreditsCents / 100 : 0;
-  return {
-    transcript: result.transcript,
-    turns: result.turns,
-    halted: result.halted,
-    costUsd,
-    tokensIn: counter.tokensIn,
-    tokensOut: counter.tokensOut
-  };
-}
-function runPersonaDispatch(config) {
-  return async (worker, scenario, ctx) => {
-    const result = await runPersonaConversation({
-      worker,
-      persona: config.personaOf(scenario),
-      backendFor: config.backendFor,
-      systemPromptOf: config.systemPromptOf,
-      maxTurns: config.maxTurns?.(scenario),
-      seed: config.seed?.(scenario),
-      signal: ctx.signal,
-      workerName: config.workerName
-    });
-    ctx.cost.observe(result.costUsd, "persona-conversation");
-    ctx.cost.observeTokens({ input: result.tokensIn, output: result.tokensOut });
-    return config.artifactOf(result.transcript, scenario);
-  };
-}
-
-// src/conversation/eval-persona.ts
-function evalPersona(worker, persona, opts = {}) {
-  const defaultBackendFor = () => {
-    if (!opts.apiKey || !opts.baseUrl || !opts.model) {
-      throw new Error(
-        "evalPersona: provide opts.{apiKey,baseUrl,model} for the default backend, or opts.backendFor"
-      );
-    }
-    const { apiKey, baseUrl, model } = opts;
-    return () => createOpenAICompatibleBackend({ apiKey, baseUrl, model });
-  };
-  const backendFor = opts.backendFor ?? defaultBackendFor();
-  const systemPromptOf = opts.systemPromptOf ?? ((p) => p.prompt?.systemPrompt ?? "");
-  return runPersonaConversation({
-    // runPersonaConversation types its profile as the benchmark-cell AgentProfile; here it is the
-    // authored AgentProfile (the carrier of prompt.systemPrompt). The runner never inspects the
-    // profile itself — only backendFor/systemPromptOf do, and both are typed for THIS profile — so
-    // the cast at this single boundary is sound.
-    worker,
-    persona,
-    backendFor,
-    systemPromptOf,
-    ...opts.maxTurns !== void 0 ? { maxTurns: opts.maxTurns } : {},
-    ...opts.haltOn ? { haltOn: opts.haltOn } : {},
-    ...opts.seed !== void 0 ? { seed: opts.seed } : {},
-    ...opts.signal ? { signal: opts.signal } : {},
-    ...opts.workerName !== void 0 ? { workerName: opts.workerName } : {}
-  });
-}
-
 // src/conversation/journal.ts
 var InMemoryConversationJournal = class {
   entries = /* @__PURE__ */ new Map();
@@ -1823,6 +1683,116 @@ var SqlConversationJournal = class {
   }
 };
 
+// src/conversation/run-persona.ts
+function withProfilePrompt(inner, systemPrompt, counter) {
+  return {
+    kind: inner.kind,
+    start: inner.start ? (input, ctx) => inner.start(input, ctx) : void 0,
+    resume: inner.resume ? (session, input, ctx) => inner.resume(session, input, ctx) : void 0,
+    stop: inner.stop ? (session, reason) => inner.stop(session, reason) : void 0,
+    async *stream(input, context) {
+      const base = input.messages ?? (input.message ? [{ role: "user", content: input.message }] : []);
+      const messages = base[0]?.role === "system" ? base : [{ role: "system", content: systemPrompt }, ...base];
+      for await (const event of inner.stream({ ...input, messages }, context)) {
+        if (counter && event.type === "llm_call") {
+          counter.tokensIn += event.tokensIn ?? 0;
+          counter.tokensOut += event.tokensOut ?? 0;
+          counter.costUsd += event.costUsd ?? 0;
+        }
+        yield event;
+      }
+    }
+  };
+}
+function scriptedPersonaBackend(turns) {
+  let idx = 0;
+  return createIterableBackend({
+    kind: "persona-user",
+    async *stream(_input, context) {
+      const text = turns[idx];
+      if (text === void 0) {
+        throw new Error(
+          `persona-user: ran out of scripted turns at index ${idx} (had ${turns.length})`
+        );
+      }
+      idx += 1;
+      yield {
+        type: "text_delta",
+        task: context.task,
+        session: context.session,
+        text,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  });
+}
+async function runPersonaConversation(opts) {
+  const counter = { tokensIn: 0, tokensOut: 0, costUsd: 0 };
+  const workerName = opts.workerName ?? "agent";
+  const worker = withProfilePrompt(
+    opts.backendFor(opts.worker, "worker"),
+    opts.systemPromptOf(opts.worker),
+    counter
+  );
+  let persona;
+  let maxTurns;
+  if (opts.persona.kind === "scripted") {
+    if (opts.persona.turns.length === 0) {
+      throw new Error("runPersonaConversation: scripted persona has no turns");
+    }
+    persona = scriptedPersonaBackend(opts.persona.turns);
+    maxTurns = opts.maxTurns ?? 2 * opts.persona.turns.length;
+  } else {
+    persona = withProfilePrompt(
+      opts.backendFor(opts.persona.profile, "persona"),
+      opts.systemPromptOf(opts.persona.profile)
+    );
+    if (opts.maxTurns === void 0) {
+      throw new Error("runPersonaConversation: maxTurns is required for a profile-driven persona");
+    }
+    maxTurns = opts.maxTurns;
+  }
+  const conversation = defineConversation({
+    // Persona leads (participant 0): the seed routes to it, it produces the
+    // user turn, the worker answers, alternate.
+    participants: [
+      { name: "user", backend: persona },
+      { name: workerName, backend: worker }
+    ],
+    policy: { maxTurns, turnOrder: "alternate", ...opts.haltOn ? { haltOn: opts.haltOn } : {} }
+  });
+  const result = await runConversation(conversation, {
+    seed: opts.seed ?? "Begin.",
+    signal: opts.signal
+  });
+  const costUsd = counter.costUsd > 0 ? counter.costUsd : opts.persona.kind === "scripted" ? result.spentCreditsCents / 100 : 0;
+  return {
+    transcript: result.transcript,
+    turns: result.turns,
+    halted: result.halted,
+    costUsd,
+    tokensIn: counter.tokensIn,
+    tokensOut: counter.tokensOut
+  };
+}
+function runPersonaDispatch(config) {
+  return async (worker, scenario, ctx) => {
+    const result = await runPersonaConversation({
+      worker,
+      persona: config.personaOf(scenario),
+      backendFor: config.backendFor,
+      systemPromptOf: config.systemPromptOf,
+      maxTurns: config.maxTurns?.(scenario),
+      seed: config.seed?.(scenario),
+      signal: ctx.signal,
+      workerName: config.workerName
+    });
+    ctx.cost.observe(result.costUsd, "persona-conversation");
+    ctx.cost.observeTokens({ input: result.tokensIn, output: result.tokensOut });
+    return config.artifactOf(result.transcript, scenario);
+  };
+}
+
 // src/durable/chat-engine.ts
 var encoder = new TextEncoder();
 function encodeLine(event) {
@@ -3521,7 +3491,6 @@ export {
   defineConversation,
   defineRuntimeHooks,
   deriveExecutionId,
-  evalPersona,
   exportEvalRuns,
   getModels,
   handleChatTurn,