@rowan-agent/agent 0.15.0 → 0.15.3

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);
@@ -3280,8 +3305,15 @@ 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 output = await executePhase(runtime);
+  let output = await executePhase(runtime);
   if (phaseMsgId) removePhaseMessage(messages, phaseMsgId);
+  if (config.afterPhase) {
+    const extAfter = await config.afterPhase(phase.name, output);
+    if (extAfter?.output) output = extAfter.output;
+  }
+  if (output.status) {
+    await execution.reportStatus(output.status);
+  }
   const decision = output.toolCalls ? extractRouteCall(output.toolCalls) : void 0;
   const resultPayload = decision?.decision[0]?.payload !== void 0 ? normalizePayload(decision.decision[0].payload) : output.payload;
   return { instanceId, phaseId: phase.name, payload: resultPayload, content: output.message ?? `${phase.name} completed.` };
@@ -6532,7 +6564,30 @@ var AgentRuntime = class _AgentRuntime {
         interactionAnswers: claim.run.interactionAnswers,
         signal: controller.signal,
         beforePhase: assembly.beforePhase,
-        afterPhase: assembly.afterPhase,
+        afterPhase: async (phaseId, output) => {
+          const extAfter = assembly.afterPhase ? await assembly.afterPhase(phaseId, output) : {};
+          const effectiveOutput = extAfter.output ?? output;
+          if (!extAfter.abort && (phaseId === COMPACT_PHASE_ID || isCompactionOutcome(effectiveOutput.payload))) {
+            const active = this.executions.get(run.id);
+            if (active?.executionId === claim.execution.executionId && !this.cancellationRequested.has(run.id) && !controller.signal.aborted) {
+              const summary = compactSummary(effectiveOutput.payload);
+              const instructions = compactInstructions2(run) ?? compactOutputInstructions(effectiveOutput.payload);
+              if (summary) {
+                const covered = claim.history.at(-1);
+                const record = {
+                  id: createId("compact"),
+                  agentId: run.agentId,
+                  summary,
+                  ...covered ? { coveredThrough: { messageId: covered.id, sequence: covered.sequenceWithinRun } } : {},
+                  ...instructions ? { instructions } : {},
+                  createdAt: (/* @__PURE__ */ new Date()).toISOString()
+                };
+                await this.owned.commitContextCompaction(record);
+              }
+            }
+          }
+          return extAfter;
+        },
         beforePrompt: assembly.beforePrompt,
         onPhaseEntered: async (phaseId) => {
           const active = this.executions.get(run.id);
@@ -6639,14 +6694,6 @@ var AgentRuntime = class _AgentRuntime {
         const compactResult = await executeModel(compactContext);
         const summary = compactResult.type === "completed" ? compactSummary(compactResult.outcome.payload) : void 0;
         if (summary) {
-          const covered = claim.history.at(-1);
-          await this.owned.commitContextCompaction({
-            id: createId("compact"),
-            agentId: run.agentId,
-            summary,
-            ...covered ? { coveredThrough: { messageId: covered.id, sequence: covered.sequenceWithinRun } } : {},
-            createdAt: (/* @__PURE__ */ new Date()).toISOString()
-          });
           modelMessages = await this.owned.contextMessages(run.agentId);
           executionContext = buildExecutionContext(modelMessages);
           result = await executeModel(executionContext);
@@ -6695,22 +6742,6 @@ var AgentRuntime = class _AgentRuntime {
       }
       if (result.type === "completed") {
         const output = latestAssistant(run, result.messages, modelMessages.length);
-        if (controlKind === "compact" || isCompactionOutcome(result.outcome.payload)) {
-          const summary = compactSummary(result.outcome.payload);
-          const instructions = compactInstructions2(run) ?? compactOutputInstructions(result.outcome.payload);
-          if (summary) {
-            const covered = claim.history.at(-1);
-            const record = {
-              id: createId("compact"),
-              agentId: run.agentId,
-              summary,
-              ...covered ? { coveredThrough: { messageId: covered.id, sequence: covered.sequenceWithinRun } } : {},
-              ...instructions ? { instructions } : {},
-              createdAt: (/* @__PURE__ */ new Date()).toISOString()
-            };
-            await this.owned.commitContextCompaction(record);
-          }
-        }
         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;

package/package.json

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