@rowan-agent/agent 0.14.2 → 0.15.0

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)) {
@@ -3337,7 +3357,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 +3386,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 +3423,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 +3521,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 +3597,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 +3804,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 +6208,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 +6245,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,6 +6528,7 @@ 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,
@@ -6624,7 +6675,7 @@ var AgentRuntime = class _AgentRuntime {
         const isToolCallInteraction = result.interactions?.some((i) => i.toolCallId !== void 0);
         const output = isToolCallInteraction ? void 0 : latestAssistant(
           run,
-          result.messages.slice(modelMessages.length),
+          result.messages,
           modelMessages.length
         );
         const prompt = isToolCallInteraction ? void 0 : output ?? (result.interactions[0]?.prompt ? promptMessage(run, result.interactions[0].prompt, result.messages.length) : void 0);
@@ -6643,7 +6694,7 @@ var AgentRuntime = class _AgentRuntime {
         return;
       }
       if (result.type === "completed") {
-        const output = latestAssistant(run, result.messages.slice(modelMessages.length), modelMessages.length);
+        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);
@@ -7344,10 +7395,10 @@ var DurableRun = class {
 function promptMessage(run, prompt, sequence) {
   return { id: createId("msg"), agentId: run.agentId, runId: run.id, role: "assistant", content: prompt, sequenceWithinRun: sequence, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
-function latestAssistant(run, messages, sequence, interrupted = false) {
-  const message = [...messages].reverse().find((candidate) => candidate.role === "assistant");
+function latestAssistant(run, messages, historyLength, interrupted = false) {
+  const message = [...messages.slice(historyLength)].reverse().find((candidate) => candidate.role === "assistant");
   if (!message) return void 0;
-  return projectAssistantMessage(message, run.agentId, run.id, sequence, { interrupted });
+  return projectAssistantMessage(message, run.agentId, run.id, historyLength, { interrupted });
 }
 function hasVisibleAssistantText(message) {
   return typeof message.content === "string" ? message.content.length > 0 : message.content.some((part) => part.type === "text" && part.text.length > 0);
@@ -7877,10 +7928,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 +7991,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
@@ -8360,6 +8416,8 @@ var InMemoryStore = class _InMemoryStore {
     const run = this.requireRun(input.runId);
     if (input.expectedRevision !== void 0) this.assertRevision(run, input.expectedRevision);
     if (input.output !== void 0) {
+      const existing = this.messages.get(input.output.id);
+      if (existing && existing.runId !== run.id) throw new TypeError("cancelled output message id belongs to another Run");
       if (!isAssistantMessage(input.output) || input.output.agentId !== run.agentId || input.output.runId !== run.id || input.output.interrupted !== true) {
         throw new TypeError("cancelled output must be an interrupted AssistantMessage from this Run");
       }
@@ -8433,6 +8491,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.2",
+  "version": "0.15.0",
   "license": "MIT",
   "repository": {
     "type": "git",