@rowan-agent/agent 0.14.3 → 0.15.1

package/dist/index.js

@@ -2610,12 +2610,74 @@ async function runPhaseLoop(config, state, registry) {
   let isContinuing = resumingSuspendedRun ? state.continuation?.isContinuing ?? true : false;
   if (resumingSuspendedRun) {
     state.status = "running";
+    delete state.entryPhases;
   }
   let previousPayload = resumingSuspendedRun ? state.continuation && Object.hasOwn(state.continuation, "previousPayload") ? state.continuation.previousPayload : state.initialPhasePayload : state.initialPhasePayload;
   let previousPhaseMsgId = resumingSuspendedRun ? state.continuation?.previousPhaseMessageId : void 0;
   let previousPhaseInputMsgId;
   let previousResults = resumingSuspendedRun ? state.continuation?.previousResults?.map((result) => ({ ...result })) ?? [] : [];
   let pendingInstruction = resumingSuspendedRun ? state.continuation?.pendingInstruction : void 0;
+  const availablePhases = [];
+  for (const [, phase] of registry.phases) {
+    availablePhases.push({
+      name: phase.name,
+      description: phase.description,
+      tools: phase.tools,
+      skills: phase.skills,
+      input: phase.input,
+      isolated: phase.isolated,
+      disableAutoInvocation: phase.disableAutoInvocation
+    });
+  }
+  const dispatchParallel = async (targets, instruction, fromPhaseId) => {
+    const contextSnapshot = snapshotMessages(config.context.messages);
+    const parallelTasks = /* @__PURE__ */ new Map();
+    const instanceIds = buildInstanceIds(targets.map((t) => t.phase));
+    const groupId = createId("phase-group");
+    for (let i = 0; i < targets.length; i++) {
+      const target = targets[i];
+      const pt = registry.phases.get(target.phase);
+      if (!pt) continue;
+      const instanceId = instanceIds[i];
+      const promise = executeParallelPhase(
+        config,
+        state,
+        registry,
+        pt,
+        target.payload !== void 0 ? normalizePayload(target.payload) : void 0,
+        instruction,
+        pt.isolated ? [] : contextSnapshot,
+        availablePhases,
+        instanceId,
+        groupId,
+        i,
+        targets.length,
+        fromPhaseId
+      );
+      parallelTasks.set(instanceId, { promise, phaseId: target.phase });
+    }
+    const successfulResults = await waitForBackgroundTasks(parallelTasks);
+    previousResults = successfulResults.map((r) => ({ name: r.instanceId, output: r.payload }));
+    pendingInstruction = void 0;
+  };
+  if (!resumingSuspendedRun && state.entryPhases && state.entryPhases.length > 0) {
+    const entryPhases = state.entryPhases;
+    delete state.entryPhases;
+    for (const entry of entryPhases) {
+      if (!registry.phases.has(entry.phase)) throw new Error(`Phase "${entry.phase}" not found`);
+    }
+    if (entryPhases.length === 1) {
+      currentPhaseId = entryPhases[0].phase;
+      previousPayload = entryPhases[0].payload;
+    } else {
+      if (LoopGuard.checkAbort(config.signal).stopReason !== "none") {
+        return completeRun(config, state, createOutcome.aborted());
+      }
+      await dispatchParallel(entryPhases, void 0, registry.entryPhaseId);
+      currentPhaseId = registry.entryPhaseId;
+      previousPayload = void 0;
+    }
+  }
   const awaitInput = async (prompt, resumeAsContinuing) => {
     if (!config.waitForInput) return void 0;
     const preAbort = LoopGuard.checkAbort(config.signal);
@@ -2664,18 +2726,6 @@ async function runPhaseLoop(config, state, registry) {
     return { type: "continued" };
   };
   while (currentPhaseId) {
-    const availablePhases = [];
-    for (const [, phase2] of registry.phases) {
-      availablePhases.push({
-        name: phase2.name,
-        description: phase2.description,
-        tools: phase2.tools,
-        skills: phase2.skills,
-        input: phase2.input,
-        isolated: phase2.isolated,
-        disableAutoInvocation: phase2.disableAutoInvocation
-      });
-    }
     const abortResult = LoopGuard.checkAbort(config.signal);
     if (abortResult.stopReason !== "none") {
       removePhaseMessage(config.context.messages, previousPhaseMsgId);
@@ -2795,6 +2845,7 @@ async function runPhaseLoop(config, state, registry) {
     const runtime = { phase, config, state, execution, messageManager, registry, context: phaseContext };
     let output = await executePhase(runtime);
     delete state.initialPhasePayload;
+    delete state.entryPhases;
     let modelRouteDecision = resolveModelRouteDecision(output.toolCalls, registry);
     let routeDecision = modelRouteDecision;
     if (routeDecision) applyFirstDecision(routeDecision, output);
@@ -2858,38 +2909,7 @@ async function runPhaseLoop(config, state, registry) {
       continue;
     }
     if (routeDecision && routeDecision.requestedCount > 1) {
-      const contextSnapshot = snapshotMessages(config.context.messages);
-      const parallelTasks = /* @__PURE__ */ new Map();
-      const instanceIds = buildInstanceIds(routeDecision.decision.map((t) => t.phase));
-      const groupId = createId("phase-group");
-      const count = routeDecision.decision.length;
-      for (let i = 0; i < routeDecision.decision.length; i++) {
-        const target = routeDecision.decision[i];
-        const pt = registry.phases.get(target.phase);
-        if (!pt) continue;
-        const instanceId = instanceIds[i];
-        const context = pt.isolated ? [] : contextSnapshot;
-        const payload = target.payload !== void 0 ? normalizePayload(target.payload) : void 0;
-        const promise = executeParallelPhase(
-          config,
-          state,
-          registry,
-          pt,
-          payload,
-          routeDecision.instruction,
-          context,
-          availablePhases,
-          instanceId,
-          groupId,
-          i,
-          count,
-          currentPhaseId
-        );
-        parallelTasks.set(instanceId, { promise, phaseId: target.phase });
-      }
-      const successfulResults = await waitForBackgroundTasks(parallelTasks);
-      previousResults = successfulResults.map((r) => ({ name: r.instanceId, output: r.payload }));
-      pendingInstruction = void 0;
+      await dispatchParallel(routeDecision.decision, routeDecision.instruction, currentPhaseId);
       const entryPhaseId = phase.target ?? registry.entryPhaseId;
       if (entryPhaseId === "stop") {
         if (!shouldRunStopPhase(phase, output)) {
@@ -3260,8 +3280,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.` };
@@ -3337,7 +3364,8 @@ function encodeExecutionCheckpoint(state) {
     metrics,
     ...continuation ? { continuation } : {},
     ...runInteractions === void 0 ? {} : { runInteractions },
-    ...state.initialPhasePayload === void 0 ? {} : { initialPhasePayload: state.initialPhasePayload }
+    ...state.initialPhasePayload === void 0 ? {} : { initialPhasePayload: state.initialPhasePayload },
+    ...state.entryPhases === void 0 ? {} : { entryPhases: state.entryPhases }
   };
   assertJsonValue(data, "execution checkpoint");
   return {
@@ -3365,6 +3393,7 @@ function decodeExecutionCheckpoint(checkpoint) {
     },
     status: "suspended",
     ...checkpoint.data.initialPhasePayload === void 0 ? {} : { initialPhasePayload: checkpoint.data.initialPhasePayload },
+    ...checkpoint.data.entryPhases === void 0 ? {} : { entryPhases: checkpoint.data.entryPhases },
     ...checkpoint.data.continuation ? {
       continuation: {
         ...checkpoint.data.continuation,
@@ -3401,7 +3430,8 @@ async function executeOnce(input) {
     attempt: 0,
     status: "running",
     metrics: createMetrics(),
-    ...input.initialPhasePayload === void 0 ? {} : { initialPhasePayload: input.initialPhasePayload }
+    ...input.initialPhasePayload === void 0 ? {} : { initialPhasePayload: input.initialPhasePayload },
+    ...input.entryPhases === void 0 ? {} : { entryPhases: input.entryPhases }
   };
   if (input.interactionAnswers) {
     const existing = state.runInteractions ?? state.phaseInteractions;
@@ -3498,11 +3528,16 @@ function isCheckpointData(value) {
   if (!isRecord2(value) || typeof value.currentPhase !== "string" || !Number.isInteger(value.attempt)) return false;
   if (!isMetrics(value.metrics)) return false;
   if (value.initialPhasePayload !== void 0 && !isJsonValue(value.initialPhasePayload)) return false;
+  if (value.entryPhases !== void 0 && !isEntryPhases(value.entryPhases)) return false;
   if (value.continuation !== void 0 && !isContinuation(value.continuation)) return false;
   if (value.runInteractions !== void 0 && !isRunInteractionState(value.runInteractions)) return false;
   if (value.phaseInteractions !== void 0 && !isRunInteractionState(value.phaseInteractions)) return false;
   return true;
 }
+function isEntryPhases(value) {
+  if (!Array.isArray(value) || value.length === 0) return false;
+  return value.every((item) => isRecord2(item) && typeof item.phase === "string" && item.phase.trim().length > 0 && (item.payload === void 0 || isJsonValue(item.payload)));
+}
 function isRunInteractionState(value) {
   if (!isRecord2(value) || !Array.isArray(value.requests) || !isRecord2(value.answers)) return false;
   if (!Object.values(value.answers).every((answer) => isJsonValue(answer))) return false;
@@ -3569,6 +3604,19 @@ function isMetadata(value) {
 function assertMetadata(value, argument) {
   if (!isMetadata(value)) throw new TypeError(`${argument} must be a JSON-safe metadata object`);
 }
+function assertEntryPhases(value, argument = "entryPhases") {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new TypeError(`${argument} must be a non-empty array`);
+  }
+  for (const item of value) {
+    if (!isRecord3(item) || typeof item.phase !== "string" || item.phase.trim() === "") {
+      throw new TypeError(`${argument} items must contain a non-blank phase name`);
+    }
+    if (item.payload !== void 0) {
+      assertJsonValue(item.payload, `${argument}.payload`);
+    }
+  }
+}
 function isText(value) {
   return isRecord3(value) && value.type === "text" && typeof value.text === "string";
 }
@@ -3763,14 +3811,16 @@ function encodeIdempotencyScope(storeIncarnation, scope) {
   if (typeof storeIncarnation !== "string" || storeIncarnation.length === 0) throw new TypeError("storeIncarnation must be non-empty");
   return canonicalJson([storeIncarnation, ...scope]);
 }
-function canonicalStartRunRequest(input, metadata, phasePayload, pinnedConfigToken) {
+function canonicalStartRunRequest(input, metadata, phasePayload, pinnedConfigToken, entryPhases) {
   const normalized = normalizeUserInput(input);
   if (metadata !== void 0) assertUtf8ByteLimit(canonicalJson(metadata), METADATA_JSON_BYTES, "run.metadata");
   if (phasePayload !== void 0) assertUtf8ByteLimit(canonicalJson(phasePayload), MESSAGE_CONTENT_JSON_BYTES, "run.phasePayload");
+  if (entryPhases !== void 0) assertUtf8ByteLimit(canonicalJson(entryPhases), MESSAGE_CONTENT_JSON_BYTES, "run.entryPhases");
   return canonicalJson({
     input: normalized,
     ...metadata === void 0 ? {} : { metadata },
     ...phasePayload === void 0 ? {} : { phasePayload },
+    ...entryPhases === void 0 ? {} : { entryPhases },
     ...pinnedConfigToken === void 0 ? {} : { pinnedConfigToken }
   });
 }
@@ -6165,6 +6215,12 @@ var AgentRuntime = class _AgentRuntime {
   }
   async start(agentId, input, options) {
     this.assertOpen();
+    if (options.phasePayload !== void 0 && options.entryPhases !== void 0) {
+      throw new TypeError("phasePayload and entryPhases are mutually exclusive");
+    }
+    if (options.entryPhases !== void 0) {
+      assertEntryPhases(options.entryPhases);
+    }
     const agent = await this.requireAgent(agentId);
     if (!agent.activatedAt || !agent.currentConfigToken) throw new RuntimeError("agent_not_found", { agentId });
     let phasePayload;
@@ -6196,6 +6252,7 @@ var AgentRuntime = class _AgentRuntime {
       input,
       ...options.metadata === void 0 ? {} : { metadata: options.metadata },
       ...phasePayload === void 0 ? {} : { phasePayload },
+      ...options.entryPhases === void 0 ? {} : { entryPhases: options.entryPhases },
       ...pinnedConfigToken === agent.currentConfigToken ? {} : { pinnedConfigToken },
       idempotencyKey: options.idempotencyKey
     });
@@ -6478,10 +6535,34 @@ var AgentRuntime = class _AgentRuntime {
         maxAttempts: config.maxAttempts,
         checkpoint: claim.run.checkpoint,
         ...claim.run.phasePayload === void 0 ? {} : { initialPhasePayload: claim.run.phasePayload },
+        ...claim.run.entryPhases === void 0 ? {} : { entryPhases: claim.run.entryPhases },
         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);
@@ -6588,14 +6669,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);
@@ -6644,22 +6717,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;
@@ -7877,10 +7934,14 @@ var InMemoryStore = class _InMemoryStore {
   createRun(lease, input) {
     this.assertOwner(lease);
     this.requireAgent(input.agentId);
+    if (input.phasePayload !== void 0 && input.entryPhases !== void 0) {
+      throw new TypeError("phasePayload and entryPhases are mutually exclusive");
+    }
     const normalizedInput = normalizeUserInput(input.input);
     if (input.phasePayload !== void 0) assertJsonValue(input.phasePayload, "run.phasePayload");
+    if (input.entryPhases !== void 0) assertEntryPhases(input.entryPhases, "run.entryPhases");
     const scope = createIdempotencyScope("start_run", input.agentId, input.idempotencyKey);
-    const payload = canonicalStartRunRequest(normalizedInput, input.metadata, input.phasePayload, input.pinnedConfigToken);
+    const payload = canonicalStartRunRequest(normalizedInput, input.metadata, input.phasePayload, input.pinnedConfigToken, input.entryPhases);
     const replay = this.replay(scope, payload);
     if (replay) return clone(replay);
     const waitingRun = isControlMetadata(input.metadata) ? void 0 : [...this.runs.values()].find((candidate) => candidate.agentId === input.agentId && candidate.state === "input_required");
@@ -7936,6 +7997,7 @@ var InMemoryStore = class _InMemoryStore {
       input: clone(normalizedInput),
       ...input.metadata ? { metadata: clone(input.metadata) } : {},
       ...input.phasePayload === void 0 ? {} : { phasePayload: clone(input.phasePayload) },
+      ...input.entryPhases === void 0 ? {} : { entryPhases: clone(input.entryPhases) },
       ...input.pinnedConfigToken === void 0 ? {} : { pinnedConfigToken: input.pinnedConfigToken },
       createdAt: timestamp,
       updatedAt: timestamp
@@ -8435,6 +8497,7 @@ var InMemoryStore = class _InMemoryStore {
       input: clone(run.input),
       ...run.metadata ? { metadata: clone(run.metadata) } : {},
       ...run.phasePayload === void 0 ? {} : { phasePayload: clone(run.phasePayload) },
+      ...run.entryPhases === void 0 ? {} : { entryPhases: clone(run.entryPhases) },
       messageCount: this.messagesForRun(run.id).length,
       toolCallCount: [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id).length,
       ...run.currentPhaseId === void 0 ? {} : { currentPhaseId: run.currentPhaseId },

package/package.json

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