@tangle-network/agent-runtime 0.50.0 → 0.52.0

package/dist/index.js

@@ -1,8 +1,8 @@
 import {
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset
-} from "./chunk-ML4IXGTV.js";
-import "./chunk-RHW75JW5.js";
+} from "./chunk-V2K35HF2.js";
+import "./chunk-BERLUBAP.js";
 import {
   DELEGATED_LOOP_MODES,
   auditLoopRunner,
@@ -15,8 +15,11 @@ import {
   runDelegatedLoop,
   runLoopRunnerCli,
   selfImproveLoopRunner
-} from "./chunk-BKAIVNFA.js";
+} from "./chunk-COAVO6QB.js";
 import "./chunk-FNMGYYSS.js";
+import "./chunk-4JI4BCBI.js";
+import "./chunk-KADIJAD4.js";
+import "./chunk-HNUXAZIJ.js";
 import {
   INTELLIGENCE_WIRE_VERSION,
   buildLoopOtelSpans,
@@ -24,15 +27,13 @@ import {
   createOtelExporter,
   exportEvalRuns,
   loopEventToOtelSpan
-} from "./chunk-OM3YNZIW.js";
-import "./chunk-KADIJAD4.js";
-import "./chunk-HNUXAZIJ.js";
+} from "./chunk-G3RGMA7C.js";
 import {
   composeRuntimeHooks,
   defineRuntimeHooks,
   notifyRuntimeDecisionPoint,
   notifyRuntimeHookEvent
-} from "./chunk-CM2IK7VS.js";
+} from "./chunk-2OU7ZQPD.js";
 import {
   AgentEvalError,
   BackendTransportError,
@@ -1663,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) {
@@ -2739,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}`;
@@ -2793,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);
@@ -2828,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,
@@ -2840,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({
@@ -2859,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 };
@@ -2909,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);
@@ -2951,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,
@@ -2970,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({
@@ -2989,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) {
@@ -3168,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]
@@ -3268,6 +3392,8 @@ export {
   runConversationStream,
   runDelegatedLoop,
   runLoopRunnerCli,
+  runPersonaConversation,
+  runPersonaDispatch,
   runToolLoop,
   runtimeStreamServerSentEvent,
   sanitizeAgentRuntimeEvent,