@rowan-agent/agent 0.6.0 → 0.6.1

package/dist/index.js

@@ -521,10 +521,10 @@ ${indent}</${tag}>`;
     return `${indent}<${tag}>${escapeXml(String(val))}</${tag}>`;
   }).join("\n");
 }
-function buildPhaseDirectiveMessage(phase, output, toolUseId) {
+function buildPhaseDirectiveMessage(phase, output) {
   const parts = [];
-  parts.push(`<phase name="${escapeXml(phase.name)}">`);
-  parts.push(`  <content>${phase.content}</content>`);
+  parts.push(`<phase_content name="${escapeXml(phase.name)}">`);
+  parts.push(phase.content);
   if (output.results && output.results.length > 0) {
     parts.push(`  <prev_phase_outputs>`);
     if (output.instruction) {
@@ -539,13 +539,8 @@ function buildPhaseDirectiveMessage(phase, output, toolUseId) {
     }
     parts.push(`  </prev_phase_outputs>`);
   }
-  parts.push(`</phase>`);
-  return [{
-    type: "tool_result",
-    toolUseId,
-    content: parts.join("\n"),
-    isError: false
-  }];
+  parts.push(`</phase_content>`);
+  return parts.join("\n");
 }
 
 // src/harness/phases/loader.ts
@@ -1366,11 +1361,17 @@ function compactMessages(messages, options = {}) {
   );
   const recentStart = Math.max(messages.length - keepRecent, firstUserIdx + 1);
   const oldMessages = messages.slice(firstUserIdx >= 0 ? firstUserIdx + 1 : 0, recentStart);
-  if (oldMessages.length < minCompact) {
+  const protectedPhaseMessages = oldMessages.filter(
+    (message) => message.metadata?.kind === "phase_prompt"
+  );
+  const summarizableMessages = oldMessages.filter(
+    (message) => message.metadata?.kind !== "phase_prompt"
+  );
+  if (summarizableMessages.length < minCompact) {
     return { compacted: false, messages };
   }
   const recentMessages = messages.slice(recentStart);
-  const summary = buildSummary(oldMessages);
+  const summary = buildSummary(summarizableMessages);
   const result = [];
   if (firstUserIdx >= 0) {
     result.push(messages[firstUserIdx]);
@@ -1380,14 +1381,15 @@ function compactMessages(messages, options = {}) {
 
 ${summary}`, {
       type: "compaction_summary",
-      compactedCount: oldMessages.length
+      compactedCount: summarizableMessages.length
     })
   );
+  result.push(...protectedPhaseMessages);
   result.push(...recentMessages);
   return {
     compacted: true,
     messages: result,
-    summarizedCount: oldMessages.length,
+    summarizedCount: summarizableMessages.length,
     summary
   };
 }
@@ -1417,17 +1419,20 @@ function applyFirstDecision(route, output) {
   if (first.reason) output.routeReason = first.reason;
   if (first.payload !== void 0) output.payload = normalizePayload(first.payload);
 }
-function injectPhaseContent(phase, output, messageManager) {
+function injectPhaseContent(phase, output, messages, mirror) {
   try {
     const phaseContent = phase.filePath ? readPhaseContent(phase) : phase.content ?? phase.description ?? "";
     const content = buildPhaseDirectiveMessage(
       { name: phase.id, content: phaseContent },
-      output,
-      `phase_${phase.id}`
+      output
     );
-    const msgId = messageManager.start("tool", content, { phase: phase.id });
-    messageManager.end(msgId);
-    return msgId;
+    const message = createMessage("user", content, {
+      kind: "phase_prompt",
+      phase: phase.id
+    });
+    messages.push(message);
+    if (mirror && mirror !== messages) mirror.push(message);
+    return message.id;
   } catch {
     return void 0;
   }
@@ -1590,12 +1595,16 @@ async function startPhaseLoop(config, state) {
   return runPhaseLoop(config, state, registry);
 }
 async function runPhaseLoop(config, state, registry) {
-  let currentPhaseId = registry.entryPhaseId;
-  let isContinuing = false;
-  let previousPayload = void 0;
-  let previousPhaseMsgId = void 0;
-  let previousResults = [];
-  let pendingInstruction = void 0;
+  const resumingSuspendedRun = state.status === "suspended" && Boolean(state.currentPhase);
+  let currentPhaseId = resumingSuspendedRun ? state.currentPhase : registry.entryPhaseId;
+  let isContinuing = resumingSuspendedRun ? state.continuation?.isContinuing ?? true : false;
+  if (resumingSuspendedRun) {
+    state.status = "running";
+  }
+  let previousPayload = resumingSuspendedRun ? state.continuation?.previousPayload : void 0;
+  let previousPhaseMsgId = resumingSuspendedRun ? state.continuation?.previousPhaseMessageId : void 0;
+  let previousResults = resumingSuspendedRun ? state.continuation?.previousResults?.map((result) => ({ ...result })) ?? [] : [];
+  let pendingInstruction = resumingSuspendedRun ? state.continuation?.pendingInstruction : void 0;
   while (currentPhaseId) {
     const availablePhases = [];
     for (const [, phase2] of registry.phases) {
@@ -1603,6 +1612,8 @@ async function runPhaseLoop(config, state, registry) {
     }
     const abortResult = LoopGuard.checkAbort(config.signal);
     if (abortResult.stopReason !== "none") {
+      removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      previousPhaseMsgId = void 0;
       return completeRun(config, state, createOutcome.aborted());
     }
     state.metrics.iterations++;
@@ -1640,6 +1651,10 @@ async function runPhaseLoop(config, state, registry) {
       messages: messageManager.visible(),
       tools: phaseTools,
       skills: phaseSkills,
+      invocation: {
+        mode: "serial",
+        instanceId: currentPhaseId
+      },
       state: {
         current: currentPhaseId,
         available: Array.from(registry.phases.keys()),
@@ -1656,10 +1671,14 @@ async function runPhaseLoop(config, state, registry) {
       const extBefore = await config.beforePhase(currentPhaseId, phaseContext);
       if (extBefore.abort) {
         config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
+        removePhaseMessage(config.context.messages, previousPhaseMsgId);
+        previousPhaseMsgId = void 0;
         return completeRun(config, state, extBefore.abort);
       }
       if (extBefore.skip) {
         config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
+        removePhaseMessage(config.context.messages, previousPhaseMsgId);
+        previousPhaseMsgId = void 0;
         if (extBefore.skip.route === "stop") {
           return completeRun(config, state, {
             id: "skip",
@@ -1673,21 +1692,26 @@ async function runPhaseLoop(config, state, registry) {
         phaseContext = extBefore.input;
       }
     }
-    removePhaseMessage(config.context.messages, previousPhaseMsgId);
-    previousPhaseMsgId = void 0;
-    if (enteringNewPhase) {
-      previousPhaseMsgId = injectPhaseContent(phase, { results: previousResults, instruction: pendingInstruction }, messageManager);
+    const phaseMessageIsPresent = previousPhaseMsgId !== void 0 && config.context.messages.some((message) => message.id === previousPhaseMsgId);
+    if (enteringNewPhase || !phaseMessageIsPresent) {
+      removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      removePhaseMessage(phaseContext.messages, previousPhaseMsgId);
+      previousPhaseMsgId = void 0;
+      previousPhaseMsgId = injectPhaseContent(
+        phase,
+        { results: previousResults, instruction: pendingInstruction },
+        config.context.messages,
+        phaseContext.messages
+      );
       previousResults = [];
       pendingInstruction = void 0;
     }
     const runtime = { phase, config, state, execution, messageManager, registry, context: phaseContext };
     let output = await executePhase(runtime);
-    let routeToolCalled = false;
     let routeDecision;
     if (output.toolCalls && output.toolCalls.length > 0) {
       routeDecision = extractRouteCall(output.toolCalls);
       if (routeDecision) {
-        routeToolCalled = true;
         applyFirstDecision(routeDecision, output);
       }
     }
@@ -1695,6 +1719,8 @@ async function runPhaseLoop(config, state, registry) {
       const extAfter = await config.afterPhase(currentPhaseId, output);
       if (extAfter.abort) {
         config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
+        removePhaseMessage(config.context.messages, previousPhaseMsgId);
+        previousPhaseMsgId = void 0;
         return completeRun(config, state, extAfter.abort);
       }
       if (extAfter.retry && (phase.run || phase.factory)) {
@@ -1717,8 +1743,27 @@ async function runPhaseLoop(config, state, registry) {
           previousPhaseMsgId = void 0;
           return completeRun(config, state, createOutcome.aborted());
         }
-        config.emit?.({ type: "user_prompt_requested", phase: currentPhaseId, ts: createTimestamp() });
-        const userMessages = await config.waitForInput();
+        const requestedAt = createTimestamp();
+        const inputRequest = {
+          phase: currentPhaseId,
+          prompt: output.message,
+          requestedAt
+        };
+        config.emit?.({
+          type: "user_prompt_requested",
+          phase: currentPhaseId,
+          ts: requestedAt
+        });
+        state.status = "suspended";
+        state.continuation = {
+          isContinuing,
+          previousPayload,
+          previousResults: previousResults.map((result) => ({ ...result })),
+          pendingInstruction,
+          previousPhaseMessageId: previousPhaseMsgId
+        };
+        const userMessages = await config.waitForInput(state, inputRequest);
+        state.status = "running";
         const abortResult2 = LoopGuard.checkAbort(config.signal);
         if (abortResult2.stopReason !== "none") {
           config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
@@ -1729,13 +1774,12 @@ async function runPhaseLoop(config, state, registry) {
         for (const message of userMessages) {
           config.context.messages.push(message);
         }
-        removePhaseMessage(config.context.messages, previousPhaseMsgId);
-        previousPhaseMsgId = void 0;
         isContinuing = true;
         continue;
       }
       config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
       removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      previousPhaseMsgId = void 0;
       return completeRun(config, state, createOutcome.default(output, config.context.messages));
     }
     if (output.route === "continue") {
@@ -1747,6 +1791,8 @@ async function runPhaseLoop(config, state, registry) {
       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);
@@ -1754,7 +1800,20 @@ async function runPhaseLoop(config, state, registry) {
         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, context, availablePhases, currentPhaseId);
+        const promise = executeParallelPhase(
+          config,
+          state,
+          registry,
+          pt,
+          payload,
+          context,
+          availablePhases,
+          instanceId,
+          groupId,
+          i,
+          count,
+          currentPhaseId
+        );
         parallelTasks.set(instanceId, { promise, phaseId: target.phase });
       }
       const successfulResults = await waitForBackgroundTasks(parallelTasks);
@@ -1762,6 +1821,8 @@ async function runPhaseLoop(config, state, registry) {
       pendingInstruction = routeDecision.instruction;
       const entryPhaseId = phase.target ?? registry.entryPhaseId;
       if (entryPhaseId === "stop") {
+        removePhaseMessage(config.context.messages, previousPhaseMsgId);
+        previousPhaseMsgId = void 0;
         return completeRun(config, state, createTerminalOutcome(phase, output, config.context.messages));
       }
       currentPhaseId = entryPhaseId;
@@ -1777,12 +1838,14 @@ async function runPhaseLoop(config, state, registry) {
       nextRoute = "stop";
     }
     if (nextRoute === "stop") {
-      if (routeToolCalled) removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      previousPhaseMsgId = void 0;
       return completeRun(config, state, createTerminalOutcome(phase, output, config.context.messages));
     }
     const targetPhaseId = nextRoute;
     if (!registry.phases.has(targetPhaseId)) {
       removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      previousPhaseMsgId = void 0;
       return completeRun(config, state, createOutcome.phaseNotFound(output));
     }
     state.metrics.phaseTransitions.push({
@@ -1999,17 +2062,25 @@ function createPhaseExecution(config, state, allTools, phase, messageManager, to
     }
   };
 }
-async function executeParallelPhase(config, state, registry, phase, payload, context, availablePhases, currentPhaseId) {
+async function executeParallelPhase(config, state, registry, phase, payload, context, availablePhases, instanceId, groupId, index, count, sourcePhaseId) {
   const messages = [...context];
   const allTools = buildToolsWithRouting(config, availablePhases);
   const phaseTools = phase.tools ? allTools.filter((t) => t.name === PhaseRouteTool || phase.tools.includes(t.name)) : allTools;
   const phaseSkills = phase.skills ? config.context.skills.filter((s) => phase.skills.includes(s.name)) : config.context.skills;
-  const systemPrompt = phase.isolated ? readPhaseContent(phase) : config.context.systemPrompt;
+  const systemPrompt = config.context.systemPrompt;
   const phaseContext = {
     systemPrompt,
     messages,
     tools: phaseTools,
     skills: phaseSkills,
+    invocation: {
+      mode: "parallel",
+      instanceId,
+      groupId,
+      index,
+      count,
+      sourcePhaseId
+    },
     state: {
       current: phase.id,
       available: Array.from(registry.phases.keys()),
@@ -2018,10 +2089,10 @@ async function executeParallelPhase(config, state, registry, phase, payload, con
     }
   };
   const messageManager = createMessageManager({ messages }, config.emit, config.onMessage);
-  const phaseMsgId = phase.isolated ? void 0 : injectPhaseContent(
+  const phaseMsgId = injectPhaseContent(
     phase,
-    { results: payload !== void 0 ? [{ name: currentPhaseId, output: payload }] : [] },
-    messageManager
+    { results: payload !== void 0 ? [{ name: sourcePhaseId, output: payload }] : [] },
+    messages
   );
   const toolExecutionManager = createToolExecutionManager(config.emit);
   const execution = createPhaseExecution(config, state, phaseTools, phase, messageManager, toolExecutionManager, registry);
@@ -2030,7 +2101,7 @@ async function executeParallelPhase(config, state, registry, phase, payload, con
   if (phaseMsgId) removePhaseMessage(messages, phaseMsgId);
   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.id, payload: resultPayload, content: output.message };
+  return { instanceId, phaseId: phase.id, payload: resultPayload, content: output.message };
 }
 async function waitForBackgroundTasks(backgroundTasks) {
   const entries = Array.from(backgroundTasks.entries());
@@ -3224,19 +3295,29 @@ var AgentExecution = class {
   runWithMessage(message, options, internalHooks = {}) {
     const activeRun = this.activeRun;
     if (activeRun?.resume) {
+      if (internalHooks.onSuspend) activeRun.onSuspend = internalHooks.onSuspend;
       activeRun.resume([message]);
       return activeRun.promise;
     }
     if (activeRun) {
       return Promise.reject(new Error("Agent is already running."));
     }
-    this.appendMessage(message);
+    if (!this.options.context.messages.some((candidate) => candidate.id === message.id)) {
+      this.appendMessage(message);
+    }
     return this.run(options, internalHooks);
   }
   /** Internal Runtime seam: executes one leased Agent Input. */
-  async executeAgentInput(input, runId, control) {
+  async executeAgentInput(input, runId, control, executionState) {
     this.runtimeRunId = runId;
-    const internal = { onSuspend: control.suspend };
+    this.options.sessionState = executionState ? restoreSessionState(executionState) : void 0;
+    const internal = {
+      onSuspend: (reason, state, inputRequest) => control.suspend(
+        reason,
+        state ? snapshotExecutionState(state) : void 0,
+        inputRequest
+      )
+    };
     try {
       return (await this.runWithMessage(input, void 0, internal)).outcome;
     } finally {
@@ -3473,18 +3554,20 @@ var AgentExecution = class {
     }
     const abortController = new AbortController();
     let suspensionRequested = false;
-    const waitForInput = () => {
-      if (!suspensionRequested) {
-        suspensionRequested = true;
-        void hooks.onSuspend?.("Agent requested input.");
-      }
-      return new Promise((resolve7) => {
+    const waitForInput = (state, inputRequest) => {
+      const waiting = new Promise((resolve7) => {
         const activeRun = this.activeRun;
         activeRun.resume = (messages) => {
           activeRun.resume = void 0;
+          suspensionRequested = false;
           resolve7(messages);
         };
       });
+      if (!suspensionRequested) {
+        suspensionRequested = true;
+        void this.activeRun?.onSuspend?.("Agent requested input.", state, inputRequest);
+      }
+      return waiting;
     };
     const promise = Promise.resolve().then(() => executor({ signal: abortController.signal, waitForInput })).catch((error) => {
       this.handleRunFailure(error, abortController.signal.aborted);
@@ -3492,7 +3575,7 @@ var AgentExecution = class {
     }).finally(() => {
       this.finishRun();
     });
-    this.activeRun = { promise, abortController };
+    this.activeRun = { promise, abortController, onSuspend: hooks.onSuspend };
     this.state.running = true;
     return promise;
   }
@@ -3525,7 +3608,8 @@ var AgentExecution = class {
       const extensions = resolved.extensions ?? [];
       await this.loadExtensions(extensions, resolved.cwd);
       const runContext = prepareAgentContext(resolved.context, this.extensionRunner);
-      const entryPhaseId = this.state.initialized ? DEFAULT_PHASE_ID : runContext.phases?.entryPhaseId ?? DEFAULT_PHASE_ID;
+      const resumingSuspendedRun = resolved.sessionState?.status === "suspended";
+      const entryPhaseId = resumingSuspendedRun ? resolved.sessionState?.currentPhase || runContext.phases?.entryPhaseId || DEFAULT_PHASE_ID : this.state.initialized ? DEFAULT_PHASE_ID : runContext.phases?.entryPhaseId ?? DEFAULT_PHASE_ID;
       const loopContext = {
         ...runContext,
         phases: {
@@ -3570,6 +3654,7 @@ var AgentExecution = class {
         model: resolved.model,
         stream: resolved.stream,
         maxAttempts: resolved.maxAttempts,
+        sessionState: resolved.sessionState,
         signal,
         beforeToolCall,
         afterToolCall,
@@ -3594,7 +3679,8 @@ var AgentExecution = class {
       this.options = {
         ...resolved,
         sessionId: result.sessionId,
-        context: nextContext
+        context: nextContext,
+        sessionState: void 0
       };
       return result;
     }, internalHooks);
@@ -3602,6 +3688,9 @@ var AgentExecution = class {
   abort(reason = "Aborted by caller.") {
     this.abortLocal(reason);
   }
+  isSuspended() {
+    return Boolean(this.activeRun?.resume);
+  }
   abortLocal(reason) {
     const activeRun = this.activeRun;
     activeRun?.resume?.([]);
@@ -3676,6 +3765,50 @@ ${additionalInstructions}` : content;
     };
   }
 };
+function restoreSessionState(state) {
+  const persisted = parsePersistedExecutionState(state);
+  return {
+    ...persisted,
+    status: "suspended",
+    metrics: {
+      ...persisted.metrics,
+      phaseTransitions: persisted.metrics.phaseTransitions.map((transition) => ({ ...transition }))
+    },
+    ...persisted.continuation ? {
+      continuation: {
+        ...persisted.continuation,
+        previousResults: persisted.continuation.previousResults.map((result) => ({ ...result }))
+      }
+    } : {}
+  };
+}
+function snapshotExecutionState(state) {
+  return {
+    version: 1,
+    currentPhase: state.currentPhase,
+    attempt: state.attempt,
+    metrics: {
+      ...state.metrics,
+      phaseTransitions: state.metrics.phaseTransitions.map((transition) => ({ ...transition }))
+    },
+    ...state.continuation ? {
+      continuation: {
+        ...state.continuation,
+        previousResults: state.continuation.previousResults.map((result) => ({ ...result }))
+      }
+    } : {}
+  };
+}
+function parsePersistedExecutionState(state) {
+  if (!state || state.version !== 1 || typeof state.currentPhase !== "string" || typeof state.attempt !== "number") {
+    throw new Error("Invalid Agent Run execution checkpoint.");
+  }
+  const metrics = state.metrics;
+  if (!metrics || !Array.isArray(metrics.phaseTransitions)) {
+    throw new Error("Invalid Agent Run execution checkpoint metrics.");
+  }
+  return state;
+}
 function clonePhaseRegistry(registry) {
   return {
     phases: new Map(registry.phases),
@@ -3755,6 +3888,8 @@ async function attachAgent(input) {
     phases: input.options.context.phases
   };
   const persistInput = async (message) => {
+    const context2 = await input.manager.buildAgentContext();
+    if (context2.messages.some((candidate) => candidate.id === message.id)) return;
     await input.manager.appendMessage(message);
   };
   let execution;
@@ -3813,7 +3948,9 @@ async function attachAgent(input) {
     agent,
     binding: {
       abort: (reason) => execution.abortFromRuntime(reason),
-      execute: (message, runId, control) => execution.executeAgentInput(message, runId, control)
+      isSuspended: () => execution.isSuspended(),
+      persistInput,
+      execute: (message, runId, control, executionState) => execution.executeAgentInput(message, runId, control, executionState)
     }
   };
 }
@@ -4240,8 +4377,8 @@ var LocalJsonlSessionManager = class _LocalJsonlSessionManager {
   }
 };
 
-// src/harness/session/provider.ts
-var InMemorySessionProvider = class {
+// src/harness/session/store.ts
+var InMemorySessionStore = class {
   sessions = /* @__PURE__ */ new Map();
   async create(input) {
     const session = InMemorySessionManager.create(input);
@@ -4252,7 +4389,7 @@ var InMemorySessionProvider = class {
     return this.sessions.get(sessionId);
   }
 };
-var LocalJsonlSessionProvider = class {
+var JsonlSessionStore = class {
   constructor(sessionsDir) {
     this.sessionsDir = sessionsDir;
   }
@@ -4268,6 +4405,9 @@ var LocalJsonlSessionProvider = class {
   }
 };
 
+// src/runtime/agent-runtime.ts
+import { createModelStream } from "@rowan-agent/models";
+
 // src/runtime/tool-runtime.ts
 function failed(toolCall, message) {
   return {
@@ -4469,6 +4609,9 @@ var AgentRun = class _AgentRun {
   get state() {
     return this.current.state;
   }
+  get inputRequest() {
+    return this.current.inputRequest ? structuredClone(this.current.inputRequest) : void 0;
+  }
   async getStatus() {
     const run = await this.host.getRun(this.id);
     if (run) this.notify(run);
@@ -4533,8 +4676,8 @@ var AgentRuntime = class _AgentRuntime {
   leaseDurationMs;
   leaseRenewalIntervalMs;
   toolRuntime;
-  factories;
   bindings = /* @__PURE__ */ new Map();
+  agents = /* @__PURE__ */ new Map();
   runHandles = /* @__PURE__ */ new Map();
   runWaiters = /* @__PURE__ */ new Map();
   pendingRuns = [];
@@ -4555,10 +4698,6 @@ var AgentRuntime = class _AgentRuntime {
     this.leaseDurationMs = options.leaseDurationMs ?? 6e4;
     this.leaseRenewalIntervalMs = options.leaseRenewalIntervalMs ?? Math.max(1, Math.floor(this.leaseDurationMs / 2));
     this.toolRuntime = new ToolRuntime(options.stateStore, options.toolPolicy, () => this.publishEvents());
-    this.factories = options.factories instanceof Map ? new Map([...options.factories.entries()].map(([id, factory]) => [String(id), factory])) : new Map(Object.entries(options.factories ?? {}));
-    for (const id of this.factories.keys()) {
-      if (id.trim().length === 0) throw new Error("Factory ID must not be empty.");
-    }
   }
   static async start(options) {
     if (activeRuntime) {
@@ -4593,20 +4732,16 @@ var AgentRuntime = class _AgentRuntime {
   }
   async createAgent(options) {
     this.assertRunning();
-    if (options.factoryId !== void 0 && options.factoryId.trim().length === 0) {
-      throw new Error("Factory ID must not be empty.");
-    }
+    assertAgentOptions(options);
     const provider = this.sessionProvider;
     if (!provider) throw new Error("Agent Runtime requires a SessionManager provider to create an Agent.");
     const manager = await provider.create({
       systemPrompt: options.context.systemPrompt,
-      input: options.input ?? "",
+      input: "",
       skills: options.context.skills
     });
-    if (options.input) await manager.appendMessage(createMessage("user", options.input));
     const record = await this.stateStore.createAgent({
-      sessionId: manager.getSessionId(),
-      ...options.factoryId ? { factoryId: options.factoryId } : {}
+      sessionId: manager.getSessionId()
     });
     this.pausedAgents.delete(record.id);
     const agent = await this.attachAgent(record, manager, options);
@@ -4615,6 +4750,7 @@ var AgentRuntime = class _AgentRuntime {
   }
   async reconstructAgent(agentId, options) {
     this.assertRunning();
+    assertAgentOptions(options);
     const record = await this.stateStore.getAgent(agentId);
     if (!record) throw new Error(`Agent not found: ${agentId}.`);
     if (record.state === "paused") this.pausedAgents.add(record.id);
@@ -4630,10 +4766,19 @@ var AgentRuntime = class _AgentRuntime {
   async stop() {
     if (this.stopped) return;
     this.stopped = true;
-    for (const binding of this.bindings.values()) {
-      binding.abort("Agent Runtime stopped.");
+    let suspendedAgents;
+    try {
+      suspendedAgents = new Set(
+        (await this.stateStore.listRuns({ states: ["suspended"] })).map((run) => run.agentId)
+      );
+    } catch {
+      suspendedAgents = /* @__PURE__ */ new Set();
+    }
+    for (const [agentId, binding] of this.bindings) {
+      if (!suspendedAgents.has(agentId) && !binding.isSuspended()) binding.abort("Agent Runtime stopped.");
     }
     this.bindings.clear();
+    this.agents.clear();
     this.pendingRuns.length = 0;
     this.scheduledRunIds.clear();
     this.pausedAgents.clear();
@@ -4653,6 +4798,7 @@ var AgentRuntime = class _AgentRuntime {
       throw new Error(`Agent ${agentId} is already bound to a live Agent.`);
     }
     this.bindings.set(agentId, agent);
+    void this.pump();
     if (!this.pausedAgents.has(agentId)) void this.scheduleQueuedRuns(agentId);
   }
   registerRunHandle(runId, handle) {
@@ -4702,6 +4848,24 @@ var AgentRuntime = class _AgentRuntime {
     void this.pump();
     this.publishEvents();
   }
+  async getRun(runId) {
+    return this.stateStore.getRun(runId);
+  }
+  async listActiveRuns() {
+    return this.stateStore.listActiveRuns();
+  }
+  async listRuns(input) {
+    return this.stateStore.listRuns(input);
+  }
+  getAgent(agentId) {
+    return this.agents.get(agentId);
+  }
+  async getMessage(messageId) {
+    return this.stateStore.getMessage(messageId);
+  }
+  async getToolCall(toolCallId) {
+    return this.stateStore.getToolCall(toolCallId);
+  }
   async abortRun(runId, reason = "Agent Run aborted by caller.") {
     const run = await this.stateStore.getRun(runId);
     if (!run || ["completed", "failed", "cancelled"].includes(run.state)) return;
@@ -4722,6 +4886,11 @@ var AgentRuntime = class _AgentRuntime {
     this.publishEvents();
   }
   consumeEvents(consumerId, listener) {
+    const subscription = this.registerEventConsumer(consumerId, listener);
+    void subscription.caughtUp.catch(() => void 0);
+    return subscription;
+  }
+  registerEventConsumer(consumerId, listener) {
     this.assertRunning();
     if (consumerId.trim().length === 0) {
       throw new Error("Runtime Event Consumer ID must not be empty.");
@@ -4736,12 +4905,39 @@ var AgentRuntime = class _AgentRuntime {
       redeliver: false
     };
     this.eventSubscriptions.set(consumerId, subscription);
-    void this.deliverEvents(subscription).catch(() => void 0);
-    return () => {
+    let caughtUpSettled = false;
+    let resolveCaughtUp;
+    let rejectCaughtUp;
+    const caughtUp = new Promise((resolve7, reject) => {
+      resolveCaughtUp = resolve7;
+      rejectCaughtUp = reject;
+    });
+    const stop = () => {
       if (this.eventSubscriptions.get(consumerId) === subscription) {
         this.eventSubscriptions.delete(consumerId);
       }
+      if (!caughtUpSettled) {
+        caughtUpSettled = true;
+        const error = new Error("Runtime Event Consumer stopped before catch-up completed.");
+        error.name = "AbortError";
+        rejectCaughtUp(error);
+      }
     };
+    void this.deliverEvents(subscription).then(
+      () => {
+        if (!caughtUpSettled) {
+          caughtUpSettled = true;
+          resolveCaughtUp();
+        }
+      },
+      (error) => {
+        if (!caughtUpSettled) {
+          caughtUpSettled = true;
+          rejectCaughtUp(error);
+        }
+      }
+    );
+    return { caughtUp, stop };
   }
   async listEvents(cursor) {
     return this.stateStore.listEvents(cursor);
@@ -4752,32 +4948,6 @@ var AgentRuntime = class _AgentRuntime {
     for (const record of agents) {
       if (record.state === "paused") this.pausedAgents.add(record.id);
     }
-    for (const record of agents) {
-      if (record.state !== "active" || !record.factoryId) continue;
-      const factory = this.factories.get(String(record.factoryId));
-      if (!factory) {
-        await this.stateStore.recordEvent({ kind: "factory_missing", related: { agentId: record.id }, payload: { factoryId: record.factoryId } });
-        continue;
-      }
-      try {
-        const options = await factory({ agentId: record.id, sessionId: record.sessionId, factoryId: record.factoryId });
-        if (!options) {
-          await this.stateStore.recordEvent({
-            kind: "agent_recovery_failed",
-            related: { agentId: record.id },
-            payload: { factoryId: record.factoryId, error: "Factory returned no reconstruction options." }
-          });
-          continue;
-        }
-        await this.reconstructAgent(record.id, options);
-        await this.stateStore.recordEvent({ kind: "agent_recovered", related: { agentId: record.id }, payload: { factoryId: record.factoryId } });
-      } catch (error) {
-        await this.stateStore.recordEvent({ kind: "agent_recovery_failed", related: { agentId: record.id }, payload: { factoryId: record.factoryId, error: error instanceof Error ? error.message : String(error) } });
-      }
-    }
-    for (const record of await this.stateStore.listAgents()) {
-      if (this.bindings.has(record.id)) await this.scheduleQueuedRuns(record.id);
-    }
     this.publishEvents();
   }
   async scheduleQueuedRuns(agentId) {
@@ -4786,8 +4956,14 @@ var AgentRuntime = class _AgentRuntime {
     for (const run of runs) this.scheduleRun(agentId, run.id);
   }
   async attachAgent(record, manager, options) {
+    const model = { provider: options.model.provider, id: options.model.id };
+    const resolvedOptions = {
+      ...options,
+      model,
+      stream: options.stream ?? createModelStream(options.model)
+    };
     const attached = await attachAgent({
-      options,
+      options: resolvedOptions,
       agentId: record.id,
       sessionId: record.sessionId,
       manager,
@@ -4795,6 +4971,7 @@ var AgentRuntime = class _AgentRuntime {
       executeTool: (input) => this.toolRuntime.execute(input)
     });
     this.bindAgent(record.id, attached.binding);
+    this.agents.set(record.id, attached.agent);
     return attached.agent;
   }
   async submitAgentInput(agentId, input, persist) {
@@ -4802,6 +4979,7 @@ var AgentRuntime = class _AgentRuntime {
     if (!this.bindings.has(agentId)) throw new Error(`Agent ${agentId} has no live Agent Binding.`);
     const enqueued = await this.stateStore.enqueueAgentInput({ agentId, input });
     await persist();
+    if (enqueued.resumed) this.notifyRun(enqueued.run);
     const run = createAgentRun({
       register: (handle) => this.registerRunHandle(enqueued.run.id, handle),
       getRun: (runId) => this.stateStore.getRun(runId),
@@ -4849,10 +5027,10 @@ var AgentRuntime = class _AgentRuntime {
       suspendedResolve = resolve7;
     });
     const control = {
-      suspend: async (reason) => {
+      suspend: async (reason, executionState, inputRequest) => {
         if (suspended) return;
         suspended = true;
-        const current = await this.stateStore.suspendRun({ runId: job.runId, reason });
+        const current = await this.stateStore.suspendRun({ runId: job.runId, reason, executionState, inputRequest });
         this.notifyRun(current);
         this.publishEvents();
         suspendedResolve?.();
@@ -4871,6 +5049,11 @@ var AgentRuntime = class _AgentRuntime {
         leaseDurationMs: this.leaseDurationMs
       });
       this.notifyRun(leased.run);
+      try {
+        await binding.persistInput(leased.message.input);
+      } catch (error) {
+        throw new InfrastructureFailureError("Agent Input persistence failed.", { cause: error });
+      }
       renewalTimer = setInterval(() => {
         void this.stateStore.renewLease({
           runId: job.runId,
@@ -4884,7 +5067,7 @@ var AgentRuntime = class _AgentRuntime {
           failRenewal(failure);
         });
       }, this.leaseRenewalIntervalMs);
-      const execution = binding.execute(leased.message.input, job.runId, control);
+      const execution = binding.execute(leased.message.input, job.runId, control, leased.run.executionState);
       const outcome = await Promise.race([
         execution.then((value) => ({ kind: "terminal", value })).catch((error) => ({ kind: "error", error })),
         suspendedSignal.then(() => ({ kind: "suspended" })),
@@ -4976,8 +5159,21 @@ var AgentRuntime = class _AgentRuntime {
         );
         for (const event of events) {
           if (this.eventSubscriptions.get(subscription.consumerId) !== subscription) return;
-          await subscription.listener(structuredClone(event));
-          await this.stateStore.acknowledgeEvent(subscription.consumerId, event.id);
+          const disposition = await subscription.listener(structuredClone(event));
+          if (disposition?.type === "enqueue") {
+            const delivered = await this.stateStore.acknowledgeEventAndEnqueueAgentInput({
+              consumerId: subscription.consumerId,
+              eventId: event.id,
+              agentId: disposition.agentId,
+              input: disposition.input
+            });
+            if (delivered.enqueued) {
+              this.scheduleRun(delivered.enqueued.run.agentId, delivered.enqueued.run.id);
+              this.publishEvents();
+            }
+          } else {
+            await this.stateStore.acknowledgeEvent(subscription.consumerId, event.id);
+          }
         }
       } while (subscription.redeliver);
     } finally {
@@ -4988,11 +5184,25 @@ var AgentRuntime = class _AgentRuntime {
     if (this.stopped || activeRuntime !== this) throw new Error("Agent Runtime is stopped.");
   }
 };
+function isModelConfig(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return "protocol" in value && "baseUrl" in value && "apiKey" in value;
+}
+function assertAgentOptions(options) {
+  if (options.stream && isModelConfig(options.model)) {
+    throw new Error("AgentOptions accepts either a complete model config or a custom stream, not both.");
+  }
+}
 function isRetryableInfrastructureError(error) {
   if (error instanceof InfrastructureFailureError) return true;
   return typeof error === "object" && error !== null && "retryable" in error && error.retryable === true;
 }
 
+// src/runtime/domain.ts
+function runEventPayload(metadata, payload = {}) {
+  return metadata ? { ...payload, metadata: structuredClone(metadata) } : payload;
+}
+
 // src/runtime/memory-store.ts
 function clone2(value) {
   return structuredClone(value);
@@ -5021,7 +5231,6 @@ var InMemoryRuntimeStateStore = class {
     const agent = {
       id: createId("agt"),
       sessionId: input.sessionId,
-      ...input.factoryId ? { factoryId: input.factoryId } : {},
       state: "active",
       createdAt: timestamp,
       updatedAt: timestamp
@@ -5047,6 +5256,9 @@ var InMemoryRuntimeStateStore = class {
     return clone2(agent);
   }
   async enqueueAgentInput(input) {
+    return this.enqueueAgentInputState(input);
+  }
+  enqueueAgentInputState(input) {
     this.requireAgent(input.agentId);
     const suspended = [...this.runs.values()].filter((run2) => run2.agentId === input.agentId && run2.state === "suspended").sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];
     const { timestamp } = now();
@@ -5067,6 +5279,7 @@ var InMemoryRuntimeStateStore = class {
       suspended.state = "queued";
       suspended.messageId = messageId;
       delete suspended.suspensionReason;
+      delete suspended.inputRequest;
       suspended.updatedAt = timestamp;
       message.runId = suspended.id;
     }
@@ -5076,13 +5289,14 @@ var InMemoryRuntimeStateStore = class {
       messageId,
       state: "queued",
       attempt: 0,
+      ...suspended?.metadata ? { metadata: clone2(suspended.metadata) } : input.input.metadata ? { metadata: clone2(input.input.metadata) } : {},
       createdAt: timestamp,
       updatedAt: timestamp
     };
     this.messages.set(message.id, message);
     this.runs.set(run.id, suspended ?? run);
     this.recordEvent("message_enqueued", { agentId: input.agentId, messageId });
-    this.recordEvent("run_enqueued", { agentId: input.agentId, messageId, runId });
+    this.recordEvent("run_enqueued", { agentId: input.agentId, messageId, runId }, runEventPayload(suspended?.metadata ?? input.input.metadata));
     return { message: clone2(message), run: clone2(suspended ?? run), resumed: Boolean(suspended) };
   }
   async getMessage(messageId) {
@@ -5094,7 +5308,10 @@ var InMemoryRuntimeStateStore = class {
     return run ? clone2(run) : void 0;
   }
   async listRuns(input = {}) {
-    return clone2([...this.runs.values()].filter((run) => input.agentId === void 0 || run.agentId === input.agentId).filter((run) => !input.states || input.states.includes(run.state)).sort((a, b) => a.createdAt.localeCompare(b.createdAt)));
+    return clone2([...this.runs.values()].filter((run) => input.agentId === void 0 || run.agentId === input.agentId).filter((run) => !input.states || input.states.includes(run.state)).sort((a, b) => a.createdAt.localeCompare(b.createdAt) || String(a.id).localeCompare(String(b.id))));
+  }
+  async listActiveRuns() {
+    return this.listRuns({ states: ["queued", "running", "suspended"] });
   }
   async leaseRun(input) {
     const run = this.requireRun(input.runId);
@@ -5159,15 +5376,17 @@ var InMemoryRuntimeStateStore = class {
     const { timestamp } = now();
     run.state = "suspended";
     run.suspensionReason = input.reason;
+    if (input.inputRequest) run.inputRequest = clone2(input.inputRequest);
+    if (input.executionState) run.executionState = clone2(input.executionState);
     delete run.leaseId;
     run.updatedAt = timestamp;
     requireTransition("Runtime Message", message.id, message.state, "acknowledge", ["leased"]);
     message.state = "acknowledged";
     delete message.lease;
     message.updatedAt = timestamp;
-    this.recordEvent("run_suspended", { agentId: run.agentId, messageId: message.id, runId: run.id }, {
+    this.recordEvent("run_suspended", { agentId: run.agentId, messageId: message.id, runId: run.id }, runEventPayload(run.metadata, {
       reason: input.reason
-    });
+    }));
     return clone2(run);
   }
   async completeRun(input) {
@@ -5179,15 +5398,17 @@ var InMemoryRuntimeStateStore = class {
     const state = input.state ?? "completed";
     run.state = state;
     run.outcome = clone2(input.outcome);
+    delete run.inputRequest;
+    delete run.executionState;
     delete run.leaseId;
     run.updatedAt = timestamp;
     message.state = "acknowledged";
     delete message.lease;
     message.updatedAt = timestamp;
-    this.recordEvent("run_completed", { agentId: run.agentId, messageId: run.messageId, runId: run.id }, {
+    this.recordEvent("run_completed", { agentId: run.agentId, messageId: run.messageId, runId: run.id }, runEventPayload(run.metadata, {
       state,
       outcome: input.outcome
-    });
+    }));
     this.recordEvent("message_acknowledged", { agentId: message.agentId, messageId: message.id });
     return clone2(run);
   }
@@ -5218,16 +5439,18 @@ var InMemoryRuntimeStateStore = class {
     const { timestamp } = now();
     run.state = "failed";
     run.outcome = clone2(input.outcome);
+    delete run.inputRequest;
+    delete run.executionState;
     delete run.leaseId;
     run.updatedAt = timestamp;
     message.state = "dead_lettered";
     message.deadLetterReason = input.reason;
     delete message.lease;
     message.updatedAt = timestamp;
-    this.recordEvent("run_completed", { agentId: run.agentId, messageId: message.id, runId: run.id }, {
+    this.recordEvent("run_completed", { agentId: run.agentId, messageId: message.id, runId: run.id }, runEventPayload(run.metadata, {
       state: "failed",
       outcome: input.outcome
-    });
+    }));
     this.recordEvent("message_dead_lettered", { agentId: run.agentId, messageId: message.id }, {
       reason: input.reason
     });
@@ -5240,6 +5463,8 @@ var InMemoryRuntimeStateStore = class {
     const { timestamp } = now();
     run.state = "cancelled";
     run.outcome = clone2(input.outcome);
+    delete run.inputRequest;
+    delete run.executionState;
     delete run.leaseId;
     run.updatedAt = timestamp;
     if (message.state === "queued" || message.state === "leased") {
@@ -5247,9 +5472,10 @@ var InMemoryRuntimeStateStore = class {
       delete message.lease;
       message.updatedAt = timestamp;
     }
-    this.recordEvent("run_aborted", { agentId: run.agentId, messageId: message.id, runId: run.id }, {
+    this.recordEvent("run_aborted", { agentId: run.agentId, messageId: message.id, runId: run.id }, runEventPayload(run.metadata, {
+      state: "cancelled",
       outcome: input.outcome
-    });
+    }));
     return clone2(run);
   }
   async recoverExpiredLeases(input) {
@@ -5390,6 +5616,29 @@ var InMemoryRuntimeStateStore = class {
     this.eventCheckpoints.set(consumerId, checkpoint);
     return clone2(checkpoint);
   }
+  async acknowledgeEventAndEnqueueAgentInput(input) {
+    const event = this.events.find((candidate) => candidate.id === input.eventId);
+    if (!event) throw new Error(`Runtime Event not found: ${input.eventId}.`);
+    const current = this.eventCheckpoints.get(input.consumerId) ?? {
+      consumerId: input.consumerId,
+      sequence: 0,
+      updatedAt: createTimestamp(/* @__PURE__ */ new Date(0))
+    };
+    if (event.sequence <= current.sequence) return { checkpoint: clone2(current) };
+    if (event.sequence !== current.sequence + 1) {
+      throw new Error(`Runtime Event Consumer Checkpoint cannot advance from sequence ${current.sequence} to ${event.sequence}.`);
+    }
+    this.requireAgent(input.agentId);
+    const enqueued = this.enqueueAgentInputState(input);
+    const checkpoint = {
+      consumerId: input.consumerId,
+      sequence: event.sequence,
+      eventId: event.id,
+      updatedAt: createTimestamp()
+    };
+    this.eventCheckpoints.set(input.consumerId, checkpoint);
+    return { checkpoint: clone2(checkpoint), enqueued };
+  }
   requireAgent(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) {
@@ -5438,7 +5687,6 @@ var RUNTIME_SCHEMA_SQL = `
     CREATE TABLE IF NOT EXISTS agents (
       id TEXT PRIMARY KEY NOT NULL,
       session_id TEXT NOT NULL,
-      factory_id TEXT,
       state TEXT NOT NULL CHECK (state IN ('active', 'paused')),
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
@@ -5466,6 +5714,9 @@ var RUNTIME_SCHEMA_SQL = `
       lease_id TEXT,
       outcome_json TEXT,
       suspension_reason TEXT,
+      input_request_json TEXT,
+      execution_state_json TEXT,
+      metadata_json TEXT,
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
     );
@@ -5528,6 +5779,11 @@ function initializeRuntimeSchema(database) {
         database.run(sql);
       }
     }
+    try {
+      database.run("ALTER TABLE agent_runs ADD COLUMN metadata_json TEXT");
+    } catch (error) {
+      if (!(error instanceof Error) || !/duplicate column name/i.test(error.message)) throw error;
+    }
   });
   initialize();
 }
@@ -5572,15 +5828,14 @@ var SqliteRuntimeStateStore = class {
     const agent = {
       id: createId("agt"),
       sessionId: input.sessionId,
-      ...input.factoryId ? { factoryId: input.factoryId } : {},
       state: "active",
       createdAt: timestamp,
       updatedAt: timestamp
     };
     const create = this.database.transaction(() => {
       this.database.run(
-        "INSERT INTO agents (id, session_id, factory_id, state, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
-        [agent.id, agent.sessionId, agent.factoryId ?? null, agent.state, agent.createdAt, agent.updatedAt]
+        "INSERT INTO agents (id, session_id, state, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
+        [agent.id, agent.sessionId, agent.state, agent.createdAt, agent.updatedAt]
       );
       this.recordEvent("agent_created", { agentId: agent.id });
     });
@@ -5607,6 +5862,10 @@ var SqliteRuntimeStateStore = class {
     return clone3(updated);
   }
   async enqueueAgentInput(input) {
+    const enqueue = this.database.transaction(() => this.enqueueAgentInputState(input));
+    return clone3(enqueue());
+  }
+  enqueueAgentInputState(input) {
     this.requireAgent(input.agentId);
     const { timestamp } = timestampFor();
     const messageId = createId("rmsg");
@@ -5631,30 +5890,28 @@ var SqliteRuntimeStateStore = class {
       messageId,
       state: "queued",
       attempt: 0,
+      ...suspendedRow?.metadata_json ? { metadata: parse(suspendedRow.metadata_json) } : input.input.metadata ? { metadata: clone3(input.input.metadata) } : {},
       createdAt: timestamp,
       updatedAt: timestamp
     };
     if (suspendedRow) {
       message.runId = runId;
     }
-    const enqueue = this.database.transaction(() => {
-      this.insertMessage(message);
-      if (suspendedRow) {
-        this.database.run(
-          "UPDATE agent_runs SET message_id = ?, state = 'queued', lease_id = NULL, suspension_reason = NULL, updated_at = ? WHERE id = ?",
-          [messageId, timestamp, runId]
-        );
-      } else {
-        this.database.run(
-          "INSERT INTO agent_runs (id, agent_id, message_id, state, attempt, lease_id, outcome_json, suspension_reason, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
-          [run.id, run.agentId, run.messageId, run.state, run.attempt, null, null, null, run.createdAt, run.updatedAt]
-        );
-      }
-      this.recordEvent("message_enqueued", { agentId: input.agentId, messageId });
-      this.recordEvent("run_enqueued", { agentId: input.agentId, messageId, runId });
-    });
-    enqueue();
+    this.insertMessage(message);
+    if (suspendedRow) {
+      this.database.run(
+        "UPDATE agent_runs SET message_id = ?, state = 'queued', lease_id = NULL, suspension_reason = NULL, input_request_json = NULL, updated_at = ? WHERE id = ?",
+        [messageId, timestamp, runId]
+      );
+    } else {
+      this.database.run(
+        "INSERT INTO agent_runs (id, agent_id, message_id, state, attempt, lease_id, outcome_json, suspension_reason, input_request_json, execution_state_json, metadata_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        [run.id, run.agentId, run.messageId, run.state, run.attempt, null, null, null, null, null, run.metadata ? json(run.metadata) : null, run.createdAt, run.updatedAt]
+      );
+    }
+    this.recordEventInternal("message_enqueued", { agentId: input.agentId, messageId });
     const storedRun = this.requireRun(runId);
+    this.recordEventInternal("run_enqueued", { agentId: input.agentId, messageId, runId }, runEventPayload(storedRun.metadata));
     return { message: clone3(message), run: clone3(storedRun), resumed: Boolean(suspendedRow) };
   }
   async getMessage(messageId) {
@@ -5680,6 +5937,12 @@ var SqliteRuntimeStateStore = class {
     const rows = this.database.query(`SELECT * FROM agent_runs ${where} ORDER BY created_at, id`).all(...params);
     return rows.map((row) => this.runFromRow(row));
   }
+  async listActiveRuns() {
+    const rows = this.database.query(
+      "SELECT * FROM agent_runs WHERE state IN ('queued', 'running', 'suspended') ORDER BY created_at, id"
+    ).all();
+    return rows.map((row) => this.runFromRow(row));
+  }
   async leaseRun(input) {
     const lease = this.database.transaction(() => {
       const run2 = this.requireRun(input.runId);
@@ -5754,17 +6017,17 @@ var SqliteRuntimeStateStore = class {
       requireTransition2("Runtime Message", message.id, message.state, "acknowledge", ["leased"]);
       const { timestamp } = timestampFor();
       this.database.run(
-        "UPDATE agent_runs SET state = ?, lease_id = NULL, suspension_reason = ?, updated_at = ? WHERE id = ?",
-        ["suspended", input.reason ?? null, timestamp, current.id]
+        "UPDATE agent_runs SET state = ?, lease_id = NULL, suspension_reason = ?, input_request_json = ?, execution_state_json = ?, updated_at = ? WHERE id = ?",
+        ["suspended", input.reason ?? null, input.inputRequest ? json(input.inputRequest) : null, input.executionState ? json(input.executionState) : null, timestamp, current.id]
       );
       this.database.run(
         "UPDATE runtime_messages SET state = ?, updated_at = ? WHERE id = ?",
         ["acknowledged", timestamp, message.id]
       );
       this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
-      this.recordEvent("run_suspended", { agentId: current.agentId, messageId: message.id, runId: current.id }, {
+      this.recordEvent("run_suspended", { agentId: current.agentId, messageId: message.id, runId: current.id }, runEventPayload(current.metadata, {
         reason: input.reason
-      });
+      }));
       return this.requireRun(current.id);
     })();
     return clone3(run);
@@ -5778,7 +6041,7 @@ var SqliteRuntimeStateStore = class {
       const { timestamp } = timestampFor();
       const state = input.state ?? "completed";
       this.database.run(
-        "UPDATE agent_runs SET state = ?, lease_id = NULL, outcome_json = ?, updated_at = ? WHERE id = ?",
+        "UPDATE agent_runs SET state = ?, lease_id = NULL, outcome_json = ?, input_request_json = NULL, execution_state_json = NULL, updated_at = ? WHERE id = ?",
         [state, json(input.outcome), timestamp, current.id]
       );
       this.database.run(
@@ -5786,10 +6049,10 @@ var SqliteRuntimeStateStore = class {
         [timestamp, message.id]
       );
       this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
-      this.recordEvent("run_completed", { agentId: current.agentId, messageId: current.messageId, runId: current.id }, {
+      this.recordEvent("run_completed", { agentId: current.agentId, messageId: current.messageId, runId: current.id }, runEventPayload(current.metadata, {
         state,
         outcome: input.outcome
-      });
+      }));
       this.recordEvent("message_acknowledged", { agentId: message.agentId, messageId: message.id });
       return this.requireRun(current.id);
     })();
@@ -5828,7 +6091,7 @@ var SqliteRuntimeStateStore = class {
       requireTransition2("Runtime Message", message.id, message.state, "dead-letter", ["leased"]);
       const { timestamp } = timestampFor();
       this.database.run(
-        "UPDATE agent_runs SET state = 'failed', lease_id = NULL, outcome_json = ?, updated_at = ? WHERE id = ?",
+        "UPDATE agent_runs SET state = 'failed', lease_id = NULL, outcome_json = ?, input_request_json = NULL, execution_state_json = NULL, updated_at = ? WHERE id = ?",
         [json(input.outcome), timestamp, current.id]
       );
       this.database.run(
@@ -5836,10 +6099,10 @@ var SqliteRuntimeStateStore = class {
         [input.reason, timestamp, message.id]
       );
       this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
-      this.recordEvent("run_completed", { agentId: current.agentId, messageId: message.id, runId: current.id }, {
+      this.recordEvent("run_completed", { agentId: current.agentId, messageId: message.id, runId: current.id }, runEventPayload(current.metadata, {
         state: "failed",
         outcome: input.outcome
-      });
+      }));
       this.recordEvent("message_dead_lettered", { agentId: current.agentId, messageId: message.id }, {
         reason: input.reason
       });
@@ -5854,7 +6117,7 @@ var SqliteRuntimeStateStore = class {
       const message = this.requireMessage(current.messageId);
       const { timestamp } = timestampFor();
       this.database.run(
-        "UPDATE agent_runs SET state = 'cancelled', lease_id = NULL, outcome_json = ?, updated_at = ? WHERE id = ?",
+        "UPDATE agent_runs SET state = 'cancelled', lease_id = NULL, outcome_json = ?, input_request_json = NULL, execution_state_json = NULL, updated_at = ? WHERE id = ?",
         [json(input.outcome), timestamp, current.id]
       );
       if (message.state === "queued" || message.state === "leased") {
@@ -5864,9 +6127,10 @@ var SqliteRuntimeStateStore = class {
         ]);
       }
       this.database.run("DELETE FROM runtime_leases WHERE run_id = ?", [current.id]);
-      this.recordEvent("run_aborted", { agentId: current.agentId, messageId: message.id, runId: current.id }, {
+      this.recordEvent("run_aborted", { agentId: current.agentId, messageId: message.id, runId: current.id }, runEventPayload(current.metadata, {
+        state: "cancelled",
         outcome: input.outcome
-      });
+      }));
       return this.requireRun(current.id);
     })();
     return clone3(run);
@@ -6040,27 +6304,41 @@ var SqliteRuntimeStateStore = class {
     return clone3(this.eventCheckpoint(consumerId));
   }
   async acknowledgeEvent(consumerId, eventId) {
-    const checkpoint = this.database.transaction(() => {
-      const event = this.requireEvent(eventId);
-      const current = this.eventCheckpoint(consumerId);
-      if (event.sequence <= current.sequence) return current;
-      if (event.sequence !== current.sequence + 1) {
-        throw new Error(`Runtime Event Consumer Checkpoint cannot advance from sequence ${current.sequence} to ${event.sequence}.`);
-      }
-      const updatedAt = createTimestamp();
-      this.database.run(
-        `INSERT INTO runtime_event_consumers (consumer_id, sequence, event_id, updated_at)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(consumer_id) DO UPDATE SET
-           sequence = excluded.sequence,
-           event_id = excluded.event_id,
-           updated_at = excluded.updated_at`,
-        [consumerId, event.sequence, event.id, updatedAt]
-      );
-      return this.eventCheckpoint(consumerId);
-    })();
+    const acknowledge = this.database.transaction(() => this.acknowledgeEventState(consumerId, eventId));
+    const checkpoint = acknowledge();
     return clone3(checkpoint);
   }
+  async acknowledgeEventAndEnqueueAgentInput(input) {
+    const deliver = this.database.transaction(() => {
+      const event = this.requireEvent(input.eventId);
+      const current = this.eventCheckpoint(input.consumerId);
+      if (event.sequence <= current.sequence) return { checkpoint: current };
+      this.requireAgent(input.agentId);
+      const enqueued = this.enqueueAgentInputState(input);
+      const checkpoint = this.acknowledgeEventState(input.consumerId, input.eventId);
+      return { checkpoint, enqueued };
+    });
+    return clone3(deliver());
+  }
+  acknowledgeEventState(consumerId, eventId) {
+    const event = this.requireEvent(eventId);
+    const current = this.eventCheckpoint(consumerId);
+    if (event.sequence <= current.sequence) return current;
+    if (event.sequence !== current.sequence + 1) {
+      throw new Error(`Runtime Event Consumer Checkpoint cannot advance from sequence ${current.sequence} to ${event.sequence}.`);
+    }
+    const updatedAt = createTimestamp();
+    this.database.run(
+      `INSERT INTO runtime_event_consumers (consumer_id, sequence, event_id, updated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(consumer_id) DO UPDATE SET
+         sequence = excluded.sequence,
+         event_id = excluded.event_id,
+         updated_at = excluded.updated_at`,
+      [consumerId, event.sequence, event.id, updatedAt]
+    );
+    return this.eventCheckpoint(consumerId);
+  }
   insertMessage(message) {
     this.database.run(
       "INSERT INTO runtime_messages (id, agent_id, kind, payload_json, state, attempts, run_id, dead_letter_reason, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
@@ -6071,7 +6349,6 @@ var SqliteRuntimeStateStore = class {
     return {
       id: row.id,
       sessionId: row.session_id,
-      ...row.factory_id ? { factoryId: row.factory_id } : {},
       state: row.state,
       createdAt: row.created_at,
       updatedAt: row.updated_at
@@ -6111,6 +6388,9 @@ var SqliteRuntimeStateStore = class {
       ...row.lease_id ? { leaseId: row.lease_id } : {},
       ...row.outcome_json ? { outcome: parse(row.outcome_json) } : {},
       ...row.suspension_reason ? { suspensionReason: row.suspension_reason } : {},
+      ...row.input_request_json ? { inputRequest: parse(row.input_request_json) } : {},
+      ...row.execution_state_json ? { executionState: parse(row.execution_state_json) } : {},
+      ...row.metadata_json ? { metadata: parse(row.metadata_json) } : {},
       createdAt: row.created_at,
       updatedAt: row.updated_at
     };
@@ -6235,8 +6515,8 @@ export {
   AgentRun,
   AgentRuntime,
   InMemoryRuntimeStateStore,
-  InMemorySessionProvider,
-  LocalJsonlSessionProvider,
+  InMemorySessionStore,
+  JsonlSessionStore,
   SqliteRuntimeStateStore,
   createCoreTools,
   createMessage