@rowan-agent/agent 0.15.1 → 0.15.4

package/dist/index.d.ts

@@ -1137,6 +1137,12 @@ interface OwnedStore {
         phaseId: string;
         visit: number;
     }): Promise<RunRecord>;
+    commitPhaseOutput(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        message: AssistantMessage;
+    }): Promise<RunRecord>;
     commitInputRequired(input: {
         runId: RunId;
         execution: ExecutionToken;
@@ -2368,6 +2374,13 @@ declare class InMemoryStore implements DurableStore {
         phaseId: string;
         visit: number;
     }): RunRecord;
+    /** Commit a parallel Phase's reply while its Run is still running. */
+    commitPhaseOutput(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        message: AssistantMessage;
+    }): RunRecord;
     commitInputRequired(lease: OwnerLease, input: {
         runId: RunId;
         execution: ExecutionToken;
@@ -2571,6 +2584,12 @@ declare class SqliteStore implements DurableStore {
         phaseId: string;
         visit: number;
     }): Promise<RunRecord>;
+    commitPhaseOutput(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        message: AssistantMessage;
+    }): Promise<RunRecord>;
     commitInputRequired(lease: OwnerLease, input: {
         runId: RunId;
         execution: ExecutionToken;

package/dist/index.js

@@ -2512,12 +2512,22 @@ function createToolResultContent(result) {
     }
   ];
 }
-function createRouteToolResultContent(toolCall, error) {
+function createRouteToolResultContent(toolCall, error, executionContext) {
+  const result = error ? { ok: false, error } : { ok: true };
+  if (!error && executionContext) {
+    const { completedPhases, phaseTransitions } = executionContext;
+    if (completedPhases && completedPhases.length > 0) {
+      result.completed_phases = completedPhases;
+    }
+    if (phaseTransitions && phaseTransitions.length > 0) {
+      result.route_history = phaseTransitions.map(({ from, to }) => `${from} \u2192 ${to}`);
+    }
+  }
   return [
     {
       type: "tool_result",
       toolUseId: toolCall.id,
-      content: error ? JSON.stringify({ ok: false, error }) : '{"ok": true}',
+      content: JSON.stringify(result),
       ...error ? { isError: true } : {}
     }
   ];
@@ -2561,11 +2571,13 @@ async function executePhaseWithModel(ctx) {
       };
       for (const toolCall of collected.toolCalls) {
         if (toolCall.name !== PhaseRouteTool) continue;
+        const hasOrdinaryTools = collected.toolCalls.some((candidate) => candidate.name !== PhaseRouteTool);
         const messageId = ctx.messageManager.start(
           "tool",
           createRouteToolResultContent(
             toolCall,
-            collected.toolCalls.some((candidate) => candidate.name !== PhaseRouteTool) ? "Route must be called separately after ordinary tools finish; this route decision was ignored." : void 0
+            hasOrdinaryTools ? "Route must be called separately after ordinary tools finish; this route decision was ignored." : void 0,
+            !hasOrdinaryTools ? { completedPhases: ctx.completedPhases, phaseTransitions: ctx.state.metrics.phaseTransitions } : void 0
           ),
           {
             phase: ctx.phase.name
@@ -2617,6 +2629,7 @@ async function runPhaseLoop(config, state, registry) {
   let previousPhaseInputMsgId;
   let previousResults = resumingSuspendedRun ? state.continuation?.previousResults?.map((result) => ({ ...result })) ?? [] : [];
   let pendingInstruction = resumingSuspendedRun ? state.continuation?.pendingInstruction : void 0;
+  const completedPhases = [];
   const availablePhases = [];
   for (const [, phase] of registry.phases) {
     availablePhases.push({
@@ -2657,7 +2670,16 @@ async function runPhaseLoop(config, state, registry) {
       parallelTasks.set(instanceId, { promise, phaseId: target.phase });
     }
     const successfulResults = await waitForBackgroundTasks(parallelTasks);
-    previousResults = successfulResults.map((r) => ({ name: r.instanceId, output: r.payload }));
+    previousResults = successfulResults.map((r) => ({
+      name: r.instanceId,
+      output: {
+        message: r.content,
+        ...r.payload !== void 0 ? { payload: r.payload } : {}
+      }
+    }));
+    for (const r of successfulResults) {
+      completedPhases.push(r.phaseId);
+    }
     pendingInstruction = void 0;
   };
   if (!resumingSuspendedRun && state.entryPhases && state.entryPhases.length > 0) {
@@ -2842,7 +2864,7 @@ async function runPhaseLoop(config, state, registry) {
       previousResults = [];
       pendingInstruction = void 0;
     }
-    const runtime = { phase, config, state, execution, messageManager, registry, context: phaseContext };
+    const runtime = { phase, config, state, execution, messageManager, registry, context: phaseContext, completedPhases };
     let output = await executePhase(runtime);
     delete state.initialPhasePayload;
     delete state.entryPhases;
@@ -2882,6 +2904,9 @@ async function runPhaseLoop(config, state, registry) {
     if (output.status) {
       await execution.reportStatus(output.status);
     }
+    if (output.route !== "continue") {
+      completedPhases.push(currentPhaseId);
+    }
     if (phase.name === STOP_PHASE_ID) {
       removePhaseMessage(config.context.messages, previousPhaseMsgId);
       removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
@@ -3239,6 +3264,13 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
     }
   };
 }
+function parallelPhaseReply(produced) {
+  const last = [...produced].reverse().find((message) => message.role === "assistant");
+  if (!last) return void 0;
+  if (typeof last.content === "string") return last.content.trim() ? last : void 0;
+  if (last.content.some((part) => part.type === "tool_use")) return void 0;
+  return last.content.some((part) => part.type === "text" && part.text.trim()) ? last : void 0;
+}
 async function executeParallelPhase(config, state, registry, phase, payload, instruction, context, availablePhases, instanceId, groupId, index, count, sourcePhaseId) {
   const messages = [...context];
   const effectivePayload = preparePhasePayload(phase.input, payload);
@@ -3280,7 +3312,12 @@ async function executeParallelPhase(config, state, registry, phase, payload, ins
   const toolExecutionManager = createToolExecutionManager();
   const execution = createPhaseExecution(config, state, phase, messageManager, toolExecutionManager, registry);
   const runtime = { phase, config, state, execution, messageManager, registry, context: phaseContext };
+  const phaseStart = messages.length;
   let output = await executePhase(runtime);
+  const reply = parallelPhaseReply(messages.slice(phaseStart));
+  if (reply && config.onParallelPhaseOutput) {
+    await config.onParallelPhaseOutput(reply, { mode: "parallel", instanceId, groupId, index, count, sourcePhaseId });
+  }
   if (phaseMsgId) removePhaseMessage(messages, phaseMsgId);
   if (config.afterPhase) {
     const extAfter = await config.afterPhase(phase.name, output);
@@ -3458,6 +3495,7 @@ async function executeOnce(input) {
     afterPhase: input.afterPhase,
     beforePrompt: input.beforePrompt,
     onMessage: input.onMessage,
+    onParallelPhaseOutput: input.onParallelPhaseOutput,
     onMessageDelta: input.onMessageDelta,
     onThinkingDelta: input.onThinkingDelta,
     onOutcome: input.onOutcome,
@@ -4282,6 +4320,10 @@ function renderInteractionText(record) {
   const replyStr = record.reply ?? "";
   return template.replaceAll("{{prompt}}", record.prompt).replaceAll("{{answer}}", answerStr).replaceAll("{{reply}}", replyStr);
 }
+var PARALLEL_PHASE_METADATA_KEY = "parallelPhase";
+function isParallelPhaseOutput(message) {
+  return message.role === "assistant" && message.metadata?.[PARALLEL_PHASE_METADATA_KEY] !== void 0;
+}
 function projectModelContext(input) {
   const toolInteractionTexts = /* @__PURE__ */ new Map();
   for (const message of input.messages) {
@@ -4297,6 +4339,7 @@ function projectModelContext(input) {
   }
   const projectedMessages = [];
   for (const message of input.messages) {
+    if (isParallelPhaseOutput(message)) continue;
     if (message.role === "interaction") {
       if (message.toolCallId !== void 0) {
         continue;
@@ -6588,6 +6631,33 @@ var AgentRuntime = class _AgentRuntime {
             status
           });
         },
+        onParallelPhaseOutput: (message, invocation) => {
+          const task = toolQueue.then(async () => {
+            const active = this.executions.get(run.id);
+            if (this.closed || controller.signal.aborted || active?.executionId !== claim.execution.executionId) return;
+            const projected = projectAssistantMessage(message, run.agentId, run.id, 0);
+            const committed = await this.owned.commitPhaseOutput({
+              runId: run.id,
+              execution: claim.execution,
+              expectedRevision: executionRevision,
+              message: {
+                ...projected,
+                metadata: {
+                  ...projected.metadata,
+                  [PARALLEL_PHASE_METADATA_KEY]: {
+                    groupId: invocation.groupId,
+                    instanceId: invocation.instanceId,
+                    index: invocation.index,
+                    count: invocation.count
+                  }
+                }
+              }
+            });
+            executionRevision = committed.revision;
+          });
+          toolQueue = task.then(() => void 0, () => void 0);
+          return task;
+        },
         onMessageDelta: (event) => {
           const active = this.executions.get(run.id);
           if (this.closed || controller.signal.aborted || active?.executionId !== claim.execution.executionId) return;
@@ -6675,7 +6745,7 @@ var AgentRuntime = class _AgentRuntime {
         }
       }
       if (this.cancellationRequested.has(run.id) || controller.signal.aborted) {
-        const output = latestAssistant(run, result.messages, modelMessages.length, true);
+        const output = latestAssistant(run, result.messages, executionContext.messages.length, true);
         const reason = this.cancellationReasons.get(run.id) ?? "Agent run stopped.";
         await this.owned.cancelRun({
           runId: run.id,
@@ -6698,7 +6768,7 @@ var AgentRuntime = class _AgentRuntime {
         const output = isToolCallInteraction ? void 0 : latestAssistant(
           run,
           result.messages,
-          modelMessages.length
+          executionContext.messages.length
         );
         const prompt = isToolCallInteraction ? void 0 : output ?? (result.interactions[0]?.prompt ? promptMessage(run, result.interactions[0].prompt, result.messages.length) : void 0);
         await this.owned.commitInputRequired({
@@ -6716,7 +6786,7 @@ var AgentRuntime = class _AgentRuntime {
         return;
       }
       if (result.type === "completed") {
-        const output = latestAssistant(run, result.messages, modelMessages.length);
+        const output = latestAssistant(run, result.messages, executionContext.messages.length);
         await this.owned.commitOutcome({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, outcome: durableOutcome(result.outcome), ...output ? { output } : {} });
         this.transientEvents.clear(run.id, claim.execution.executionId, true);
         return;
@@ -8100,6 +8170,32 @@ var InMemoryStore = class _InMemoryStore {
     this.writeOperationReceipt(operationKey, operationPayload, result);
     return result;
   }
+  /** Commit a parallel Phase's reply while its Run is still running. */
+  commitPhaseOutput(lease, input) {
+    this.assertOwner(lease);
+    const operationKey = `phase_output:${input.message.id}`;
+    const operationPayload = canonicalJson([input.runId, input.execution.executionId, input.expectedRevision, input.message]);
+    const replay = this.replayOperation(operationKey, operationPayload);
+    if (replay) return clone(replay);
+    const run = this.requireRun(input.runId);
+    this.assertExecution(run, input.execution, input.expectedRevision);
+    this.assertState(run, ["running"]);
+    if (this.messages.has(input.message.id)) throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
+    const message = {
+      ...clone(input.message),
+      agentId: run.agentId,
+      runId: run.id,
+      role: "assistant",
+      sequenceWithinRun: this.nextMessageSequence(run.id)
+    };
+    this.messages.set(message.id, message);
+    run.revision += 1;
+    run.updatedAt = createTimestamp();
+    this.appendMessage(run, message);
+    const result = clone(run);
+    this.writeOperationReceipt(operationKey, operationPayload, result);
+    return result;
+  }
   commitInputRequired(lease, input) {
     this.assertOwner(lease);
     if (typeof input.phase !== "string" || input.phase.length === 0) throw new TypeError("phase must be non-empty");
@@ -8919,6 +9015,9 @@ var MemoryOwnedStore = class {
   async commitPhaseEntered(input) {
     return this.store.commitPhaseEntered(this.lease, input);
   }
+  async commitPhaseOutput(input) {
+    return this.store.commitPhaseOutput(this.lease, input);
+  }
   async commitInputRequired(input) {
     return this.store.commitInputRequired(this.lease, input);
   }
@@ -9322,6 +9421,9 @@ var SqliteStore = class {
   async commitPhaseEntered(lease, input) {
     return this.invoke(lease, (store, current) => store.commitPhaseEntered(current, input));
   }
+  async commitPhaseOutput(lease, input) {
+    return this.invoke(lease, (store, current) => store.commitPhaseOutput(current, input));
+  }
   async commitInputRequired(lease, input) {
     return this.invoke(lease, (store, current) => store.commitInputRequired(current, input));
   }
@@ -9715,6 +9817,9 @@ var SqliteOwnedStore = class {
   commitPhaseEntered(input) {
     return this.store.commitPhaseEntered(this.lease, input);
   }
+  commitPhaseOutput(input) {
+    return this.store.commitPhaseOutput(this.lease, input);
+  }
   commitInputRequired(input) {
     return this.store.commitInputRequired(this.lease, input);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rowan-agent/agent",
-  "version": "0.15.1",
+  "version": "0.15.4",
   "license": "MIT",
   "repository": {
     "type": "git",