@tangle-network/agent-runtime 0.51.0 → 0.53.0

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

@@ -14,7 +14,7 @@ import {
   DELEGATION_STATUS_DESCRIPTION,
   DELEGATION_STATUS_INPUT_SCHEMA,
   DELEGATION_STATUS_TOOL_NAME
-} from "./chunk-47SWANFA.js";
+} from "./chunk-FO4DCM7R.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-P4QNEXFC.js.map

package/dist/{coder-_YCf3BAK.d.ts → coder-LKm3Mczw.d.ts}

@@ -1,5 +1,5 @@
 import { AgentProfile } from '@tangle-network/sandbox';
-import { O as OutputAdapter, V as Validator, A as AgentRunSpec, D as Driver } from './types-BEQsBhOE.js';
+import { O as OutputAdapter, V as Validator, A as AgentRunSpec, D as Driver } from './types-CklkW4Eh.js';
 
 /**
  * @experimental

package/dist/{delegation-profile-1GbW5yA3.d.ts → delegation-profile-Bvfro2m1.d.ts}

@@ -1,4 +1,4 @@
-import { AgentProfileFileMount, AgentProfileMcpServer, AgentProfile } from '@tangle-network/sandbox';
+import { AgentProfileFileMount, AgentProfile, AgentSubagentProfile, AgentProfileMcpServer } from '@tangle-network/sandbox';
 
 /**
  * Production-profile composition for the agent-runtime delegation MCP.
@@ -17,6 +17,11 @@ import { AgentProfileFileMount, AgentProfileMcpServer, AgentProfile } from '@tan
  * authenticate on startup. No static profile entry, ever.
  */
 
+/** One hook command entry. The SDK declares `AgentProfile.hooks` as
+ *  `Record<string, AgentProfileHookCommand[]>` but does not re-export the element
+ *  type from the package entry, so derive it from `AgentProfile` by indexed
+ *  access — the single source of truth, no drift from the SDK shape. */
+type AgentProfileHookCommand = NonNullable<AgentProfile['hooks']>[string][number];
 /** MCP server key under which the agent-runtime delegation tools mount. */
 declare const DELEGATION_MCP_SERVER_KEY = "agent-runtime-delegation";
 interface BuildDelegationMcpServerOptions {
@@ -53,6 +58,22 @@ interface ComposeProductionAgentProfileOptions {
     name?: string;
     /** Environment source for key + OTEL resolution. Defaults to `process.env`. */
     env?: Record<string, string | undefined>;
+    /** Box built-in tool ON/OFF flags merged over the base profile's `tools`
+     *  (overlay wins per key). The sandbox-seam mapping of a certified surface's
+     *  tool grants — `AgentProfile.tools` is `Record<string, boolean>` box flags,
+     *  so it carries grants, not arbitrary tool defs. */
+    tools?: Record<string, boolean>;
+    /** Per-event hook commands merged over the base profile's `hooks`. An event
+     *  present in both has the extra commands appended after the base ones. */
+    hooks?: Record<string, AgentProfileHookCommand[]>;
+    /** Subagent definitions merged over the base profile's `subagents` (overlay
+     *  wins per key). */
+    subagents?: Record<string, AgentSubagentProfile>;
+    /** Resolved certified MCP connections injected into `AgentProfile.mcp` — the
+     *  sandbox-seam delivery of a `ResolvedSurface.mcpConnections`. Merged after
+     *  the base map and before the delegation entry, so a base/delegation key is
+     *  never silently shadowed by an injected one. */
+    mcpConnections?: Record<string, AgentProfileMcpServer>;
 }
 /**
  * Compose the production `AgentProfile`: the canonical base profile with the
@@ -61,9 +82,14 @@ interface ComposeProductionAgentProfileOptions {
  * the scorecard profile hash reflects the actual production profile.
  *
  * Merge rules:
- *   - `mcp`: base map preserved; the delegation entry is appended under
+ *   - `mcp`: base map preserved; `options.mcpConnections` (resolved certified
+ *     servers) merged over it; the delegation entry is appended last under
  *     {@link DELEGATION_MCP_SERVER_KEY}, and omitted entirely when no sandbox
  *     API key resolves.
+ *   - `tools`: base box-flags map preserved; `options.tools` overlaid per key.
+ *   - `hooks`: per event, base commands preserved; `options.hooks[event]`
+ *     appended after the base ones.
+ *   - `subagents`: base map preserved; `options.subagents` overlaid per key.
  *   - `prompt.systemPrompt`: replaced when `options.systemPrompt` is set.
  *   - `resources.files`: `options.extraFiles` concatenated after base files.
  *   - `name`: replaced when `options.name` is set.

package/dist/{driver-DLI1io57.d.ts → driver-B2RKkVJW.d.ts}

@@ -1,5 +1,5 @@
 import { AnalystFinding } from '@tangle-network/agent-eval';
-import { I as Iteration, D as Driver } from './types-BEQsBhOE.js';
+import { I as Iteration, D as Driver } from './types-CklkW4Eh.js';
 
 /**
  * @experimental

package/dist/index.d.ts

@@ -1,18 +1,18 @@
-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';
-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 { 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-CklkW4Eh.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-CklkW4Eh.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-D4Ir7b00.js';
+export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './openai-tools-CKfR3EMh.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-CKfykcYQ.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';
-import './driver-DLI1io57.js';
+import './coder-LKm3Mczw.js';
+import './driver-B2RKkVJW.js';
 import './substrate-CUgk7F7s.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-P4QNEXFC.js";
+import "./chunk-FO4DCM7R.js";
 import {
   DELEGATED_LOOP_MODES,
   auditLoopRunner,
@@ -15,9 +15,9 @@ import {
   runDelegatedLoop,
   runLoopRunnerCli,
   selfImproveLoopRunner
-} from "./chunk-XEI7AIHU.js";
+} from "./chunk-K5M3SHEU.js";
 import "./chunk-FNMGYYSS.js";
-import "./chunk-HYG4ISNS.js";
+import "./chunk-AYRQZRDV.js";
 import "./chunk-KADIJAD4.js";
 import "./chunk-HNUXAZIJ.js";
 import {
@@ -33,7 +33,7 @@ import {
   defineRuntimeHooks,
   notifyRuntimeDecisionPoint,
   notifyRuntimeHookEvent
-} from "./chunk-FQH33M5N.js";
+} from "./chunk-K6WP7PYW.js";
 import {
   AgentEvalError,
   BackendTransportError,
@@ -351,6 +351,7 @@ function mapCommonBackendEvent(event, context) {
       proposalId,
       title: stringValue(data.title) ?? stringValue(record.title) ?? proposalId,
       status: status === "pending" || status === "approved" || status === "rejected" ? status : void 0,
+      content: stringValue(data.content) ?? stringValue(data.body) ?? stringValue(record.content),
       timestamp: nowIso()
     };
   }
@@ -1664,6 +1665,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) {
@@ -2494,6 +2605,7 @@ function sanitizeRuntimeStreamEvent(event, options = {}) {
       timestamp: event.timestamp,
       proposalId: event.proposalId,
       title: options.includeControlPayloads ? event.title : void 0,
+      content: options.includeControlPayloads ? event.content : void 0,
       status: event.status
     };
   }
@@ -2740,6 +2852,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 +2923,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 +2957,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 +2970,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 +2989,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 +3037,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 +3078,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 +3098,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 +3117,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 +3294,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 +3394,8 @@ export {
   runConversationStream,
   runDelegatedLoop,
   runLoopRunnerCli,
+  runPersonaConversation,
+  runPersonaDispatch,
   runToolLoop,
   runtimeStreamServerSentEvent,
   sanitizeAgentRuntimeEvent,