@tangle-network/agent-runtime 0.51.0 → 0.52.0

package/dist/{chunk-HYG4ISNS.js → chunk-4JI4BCBI.js}

@@ -12,7 +12,7 @@ import {
   sleep,
   throwAbort,
   throwIfAborted
-} from "./chunk-FQH33M5N.js";
+} from "./chunk-2OU7ZQPD.js";
 import {
   ValidationError
 } from "./chunk-GSUO5QS6.js";
@@ -620,4 +620,4 @@ export {
   coderTaskFromArgs,
   settleDetachedCoderTurn
 };
-//# sourceMappingURL=chunk-HYG4ISNS.js.map
+//# sourceMappingURL=chunk-4JI4BCBI.js.map

package/dist/{chunk-HAA4KZUD.js → chunk-7SP2OVYZ.js}

@@ -25,11 +25,11 @@ import {
   createDelegationHistoryHandler,
   createDelegationStatusHandler,
   hashIdempotencyInput
-} from "./chunk-47SWANFA.js";
+} from "./chunk-BERLUBAP.js";
 import {
   createFleetWorkspaceExecutor,
   createSiblingSandboxExecutor
-} from "./chunk-HYG4ISNS.js";
+} from "./chunk-4JI4BCBI.js";
 import {
   runLocalHarness
 } from "./chunk-GLR25NG7.js";
@@ -905,4 +905,4 @@ export {
   createPropagatingTraceEmitter,
   traceContextToEnv
 };
-//# sourceMappingURL=chunk-HAA4KZUD.js.map
+//# sourceMappingURL=chunk-7SP2OVYZ.js.map

package/dist/{chunk-47SWANFA.js → chunk-BERLUBAP.js}

@@ -3,7 +3,7 @@ import {
   createDelegationTraceCollector,
   formatDetachedSessionRef,
   generateDelegationSpanId
-} from "./chunk-HYG4ISNS.js";
+} from "./chunk-4JI4BCBI.js";
 import {
   AgentEvalError,
   NotFoundError,
@@ -1353,4 +1353,4 @@ export {
   validateDelegationStatusArgs,
   createDelegationStatusHandler
 };
-//# sourceMappingURL=chunk-47SWANFA.js.map
+//# sourceMappingURL=chunk-BERLUBAP.js.map

package/dist/{chunk-XEI7AIHU.js → chunk-COAVO6QB.js}

@@ -3,14 +3,14 @@ import {
 } from "./chunk-FNMGYYSS.js";
 import {
   createDefaultCoderDelegate
-} from "./chunk-HYG4ISNS.js";
+} from "./chunk-4JI4BCBI.js";
 import {
   runAnalystLoop
 } from "./chunk-HNUXAZIJ.js";
 import {
   createDriver,
   runLoop
-} from "./chunk-FQH33M5N.js";
+} from "./chunk-2OU7ZQPD.js";
 import {
   ConfigError
 } from "./chunk-GSUO5QS6.js";
@@ -200,4 +200,4 @@ export {
   runLoopRunnerCli,
   parseLoopRunnerArgv
 };
-//# sourceMappingURL=chunk-XEI7AIHU.js.map
+//# sourceMappingURL=chunk-COAVO6QB.js.map

package/dist/{chunk-FKHNHUXP.js → chunk-V2K35HF2.js}

@@ -14,7 +14,7 @@ import {
   DELEGATION_STATUS_DESCRIPTION,
   DELEGATION_STATUS_INPUT_SCHEMA,
   DELEGATION_STATUS_TOOL_NAME
-} from "./chunk-47SWANFA.js";
+} from "./chunk-BERLUBAP.js";
 
 // src/mcp/openai-tools.ts
 function buildTool(name, description, parameters) {
@@ -61,4 +61,4 @@ export {
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset
 };
-//# sourceMappingURL=chunk-FKHNHUXP.js.map
+//# sourceMappingURL=chunk-V2K35HF2.js.map

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import { AgentEvalError, KnowledgeReadinessReport, RunRecord, ControlEvalResult, KnowledgeRequirement } from '@tangle-network/agent-eval';
+import { AgentProfile, AgentEvalError, KnowledgeReadinessReport, RunRecord, ControlEvalResult, KnowledgeRequirement } from '@tangle-network/agent-eval';
 export { AgentEvalError, AgentEvalErrorCode, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, RunRecord, ValidationError } from '@tangle-network/agent-eval';
 import { h as AgentBackendInput, i as AgentExecutionBackend, c as OpenAIChatTool, j as OpenAIChatToolChoice, k as AgentBackendContext, R as RuntimeStreamEvent, K as KnowledgeReadinessDecision, l as RunAgentTaskOptions, m as AgentTaskRunResult, n as RunAgentTaskStreamOptions, o as AgentRuntimeEvent, p as AgentTaskStatus, q as RuntimeSessionStore, r as RuntimeSession } from './types-BEQsBhOE.js';
 export { s as AgentAdapter, t as AgentKnowledgeProvider, u as AgentRuntimeEventSink, v as AgentTaskContext, w as AgentTaskSpec, B as BackendErrorDetail, x as RuntimeRunHandle, y as RuntimeRunPersistenceAdapter, z as RuntimeRunRow, C as startRuntimeRun } from './types-BEQsBhOE.js';
+import { Scenario, ProfileDispatchFn } from '@tangle-network/agent-eval/campaign';
 export { C as CoderLoopRunnerOptions, D as DELEGATED_LOOP_MODES, a as DelegatedLoopMode, b as DelegatedLoopRegistry, c as DelegatedLoopResult, d as DelegatedLoopRunner, e as DynamicLoopRunnerOptions, L as LoopRunnerCliArgs, f as LoopRunnerCliResult, R as ResearchLoopResult, g as ResearchLoopRunnerOptions, h as RunDelegatedLoopOptions, V as VetoedFact, i as auditLoopRunner, j as coderLoopRunner, k as dynamicLoopRunner, l as isDelegatedLoopMode, p as parseLoopRunnerArgv, r as researchLoopRunner, m as reviewLoopRunner, n as runDelegatedLoop, o as runLoopRunnerCli, s as selfImproveLoopRunner } from './loop-runner-bin-DFUNgpeK.js';
 export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './openai-tools-D4HLDWgw.js';
 export { aD as EvalRunEvent, aE as EvalRunGeneration, aF as EvalRunsExportConfig, aG as EvalRunsExportResult, aH as INTELLIGENCE_WIRE_VERSION, aI as LoopSpanNode, aJ as OtelAttribute, aK as OtelExportConfig, aL as OtelExporter, aM as OtelSpan, aN as buildLoopOtelSpans, aO as buildLoopSpanNodes, aP as createOtelExporter, aQ as exportEvalRuns, aR as loopEventToOtelSpan } from './kb-gate-CHAyt4aI.js';
 import { R as RuntimeHooks } from './runtime-hooks-C7JwKb9E.js';
 export { b as RuntimeDecisionEvidenceRef, c as RuntimeDecisionKind, d as RuntimeDecisionPoint, e as RuntimeHookContext, f as RuntimeHookErrorContext, a as RuntimeHookEvent, g as RuntimeHookPhase, h as RuntimeHookTarget, i as composeRuntimeHooks, j as defineRuntimeHooks, n as notifyRuntimeDecisionPoint, k as notifyRuntimeHookEvent } from './runtime-hooks-C7JwKb9E.js';
 import '@tangle-network/sandbox';
-import '@tangle-network/agent-eval/campaign';
 import '@tangle-network/agent-eval/contract';
 import './types-p8dWBIXL.js';
 import './coder-_YCf3BAK.js';
@@ -801,6 +801,88 @@ 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;
+    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
  *
@@ -1332,9 +1414,37 @@ type ToolCallOutcome = {
     message: string;
     status?: number;
 };
+/** One OpenAI-shaped tool-call entry carried on an assistant message. */
+interface ToolLoopAssistantToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * A message in the running conversation the loop sends to `streamTurn`.
+ *
+ * The base `{ role, content }` covers `system` / `user` / plain `assistant`
+ * turns. Two optional fields carry the OpenAI function-calling contract so a
+ * strict model (Claude, and any OpenAI-compatible provider that validates tool
+ * history) reads its own tool use back instead of re-issuing the same call:
+ *
+ *   - an assistant turn that emitted tool calls carries `tool_calls`, and its
+ *     `content` is `null` when the turn was tool-only;
+ *   - each tool result is its own `{ role: 'tool', tool_call_id, content }`
+ *     message keyed to the call that produced it.
+ *
+ * Widening is additive: a `streamTurn` that reads only `role` + `content` still
+ * works; one that forwards the whole message to an OpenAI-compatible endpoint
+ * now sends correct tool history.
+ */
 type ToolLoopMessage = {
     role: string;
-    content: string;
+    content: string | null;
+    tool_calls?: ToolLoopAssistantToolCall[];
+    tool_call_id?: string;
 };
 type ToolLoopEvent = {
     type: 'text';
@@ -1433,4 +1543,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, 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, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatTool, OpenAIChatToolChoice, PlannerError, type PropagatedHeaders, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunChatTurnInput, type RunConversationOptions, type RunToolLoopOptions, type RuntimeEventCollector, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SqlAdapter, SqlConversationJournal, type StreamToolLoopOptions, type StreamToolLoopYield, type ToolCallOutcome, 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, isDepthExceeded, makePerAttemptSignal, readDepth, readinessServerSentEvent, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runToolLoop, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, sleep, slugifySpeaker, streamToolLoop, turnId, validateChatModelId };
+export { AgentBackendContext, AgentBackendInput, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, type AuthSource, type BackendCallPolicy, BackendTransportError, 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, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatTool, OpenAIChatToolChoice, type PersonaConversationResult, type PersonaDriver, PlannerError, type PropagatedHeaders, 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, isDepthExceeded, makePerAttemptSignal, readDepth, readinessServerSentEvent, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runPersonaConversation, runPersonaDispatch, runToolLoop, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, sleep, slugifySpeaker, streamToolLoop, turnId, validateChatModelId };

package/dist/index.js

@@ -1,8 +1,8 @@
 import {
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset
-} from "./chunk-FKHNHUXP.js";
-import "./chunk-47SWANFA.js";
+} from "./chunk-V2K35HF2.js";
+import "./chunk-BERLUBAP.js";
 import {
   DELEGATED_LOOP_MODES,
   auditLoopRunner,
@@ -15,9 +15,9 @@ import {
   runDelegatedLoop,
   runLoopRunnerCli,
   selfImproveLoopRunner
-} from "./chunk-XEI7AIHU.js";
+} from "./chunk-COAVO6QB.js";
 import "./chunk-FNMGYYSS.js";
-import "./chunk-HYG4ISNS.js";
+import "./chunk-4JI4BCBI.js";
 import "./chunk-KADIJAD4.js";
 import "./chunk-HNUXAZIJ.js";
 import {
@@ -33,7 +33,7 @@ import {
   defineRuntimeHooks,
   notifyRuntimeDecisionPoint,
   notifyRuntimeHookEvent
-} from "./chunk-FQH33M5N.js";
+} from "./chunk-2OU7ZQPD.js";
 import {
   AgentEvalError,
   BackendTransportError,
@@ -1664,6 +1664,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" }
+  });
+  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) {
@@ -2740,6 +2850,23 @@ var RUNAWAY_BACKSTOP_TURNS = 200;
 var DEFAULT_DECISION_CONTEXT_CHARS = 12e3;
 var FAILURE_RECOVERY_ACTIONS = ["retry", "verify", "continue", "stop"];
 var STUCK_LOOP_THRESHOLD = 3;
+function toolCallId(call) {
+  return call.toolCallId ?? `call_${call.toolName}`;
+}
+function assistantToolCallMessage(turnText, pending) {
+  return {
+    role: "assistant",
+    content: turnText.trim() || null,
+    tool_calls: pending.map((call) => ({
+      id: toolCallId(call),
+      type: "function",
+      function: { name: call.toolName, arguments: JSON.stringify(call.args) }
+    }))
+  };
+}
+function toolResultMessage(call, content) {
+  return { role: "tool", tool_call_id: toolCallId(call), content };
+}
 function defaultRender(label, outcome) {
   if (outcome.ok) return `- ${label} \u2192 ok: ${JSON.stringify(outcome.result)}`;
   return `- ${label} \u2192 failed (${outcome.code}): ${outcome.message}`;
@@ -2794,8 +2921,7 @@ async function runToolLoop(opts) {
       observer.loopAfter({ turns, toolResults: toolResults.length, stopReason: "backstop" });
       return { finalText, toolResults, turns, stopReason: "backstop", cappedOut: true };
     }
-    if (turnText.trim()) messages.push({ role: "assistant", content: turnText });
-    const lines = [];
+    messages.push(assistantToolCallMessage(turnText, pending));
     const outcomes = [];
     for (const [callIndex, call] of pending.entries()) {
       const callHash = canonicalCallHash(call);
@@ -2829,6 +2955,7 @@ async function runToolLoop(opts) {
         if (accumulatedCostUsd >= opts.maxCostUsd) {
           const label2 = labelFor(call);
           toolResults.push({ call, label: label2, outcome });
+          messages.push(toolResultMessage(call, render(label2, outcome)));
           observer.toolCallAfter(toolTurn, callEventId, call, outcome);
           observer.turnAfter(toolTurn, turnEventId, {
             pendingToolCalls: pending.length,
@@ -2841,8 +2968,8 @@ async function runToolLoop(opts) {
       const label = labelFor(call);
       const rendered = render(label, outcome);
       toolResults.push({ call, label, outcome });
-      lines.push(rendered);
       outcomes.push({ call, label, outcome, rendered });
+      messages.push(toolResultMessage(call, rendered));
       observer.toolCallAfter(toolTurn, callEventId, call, outcome);
     }
     observer.failureRecovery({
@@ -2860,8 +2987,6 @@ async function runToolLoop(opts) {
       })),
       failedToolCalls: outcomes.filter((item) => !item.outcome.ok).length
     });
-    messages.push({ role: "user", content: `Tool results:
-${lines.join("\n")}` });
   }
   observer.loopAfter({ turns, toolResults: toolResults.length, stopReason: "completed" });
   return { finalText, toolResults, turns, stopReason: "completed", cappedOut: false };
@@ -2910,8 +3035,7 @@ async function* streamToolLoop(opts) {
       yield { kind: "capped", pending: pending.length, stopReason: "backstop" };
       return;
     }
-    if (turnText.trim()) messages.push({ role: "assistant", content: turnText });
-    const lines = [];
+    messages.push(assistantToolCallMessage(turnText, pending));
     const outcomes = [];
     for (const [callIndex, call] of pending.entries()) {
       const callHash = canonicalCallHash(call);
@@ -2952,6 +3076,7 @@ async function* streamToolLoop(opts) {
             label: label2,
             outcome
           };
+          messages.push(toolResultMessage(call, render(label2, outcome)));
           observer.toolCallAfter(toolTurn, callEventId, call, outcome);
           observer.turnAfter(toolTurn, turnEventId, {
             pendingToolCalls: pending.length,
@@ -2971,8 +3096,8 @@ async function* streamToolLoop(opts) {
         outcome
       };
       const rendered = render(label, outcome);
-      lines.push(rendered);
       outcomes.push({ call, label, outcome, rendered });
+      messages.push(toolResultMessage(call, rendered));
       observer.toolCallAfter(toolTurn, callEventId, call, outcome);
     }
     observer.failureRecovery({
@@ -2990,8 +3115,6 @@ async function* streamToolLoop(opts) {
       })),
       failedToolCalls: outcomes.filter((item) => !item.outcome.ok).length
     });
-    messages.push({ role: "user", content: `Tool results:
-${lines.join("\n")}` });
   }
 }
 function createToolLoopObserver(hooks, runId, scenarioId) {
@@ -3169,7 +3292,7 @@ function failureMetadata(outcome) {
 }
 function renderDecisionContext(messages, turnText, outcomes) {
   const recent = messages.slice(-6).map((message) => `[${message.role}]
-${message.content}`);
+${message.content ?? ""}`);
   const assistant = turnText.trim() ? [`[assistant]
 ${turnText}`] : [];
   const toolResults = [`[tool results]
@@ -3269,6 +3392,8 @@ export {
   runConversationStream,
   runDelegatedLoop,
   runLoopRunnerCli,
+  runPersonaConversation,
+  runPersonaDispatch,
   runToolLoop,
   runtimeStreamServerSentEvent,
   sanitizeAgentRuntimeEvent,