@perstack/react 0.0.53 → 0.0.54

package/dist/src/index.js

@@ -1,677 +1,679 @@
-import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
-import { BASE_SKILL_PREFIX, createBaseToolActivity, createGeneralToolActivity } from '@perstack/core';
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { BASE_SKILL_PREFIX, createBaseToolActivity, createGeneralToolActivity } from "@perstack/core";
 
-// src/hooks/use-job-stream.ts
-
-// src/utils/stream.ts
-var isAbortError = (err) => err instanceof DOMException && err.name === "AbortError";
+//#region src/utils/stream.ts
+const isAbortError = (err) => err instanceof DOMException && err.name === "AbortError";
+/**
+* Consumes an SSE stream with abort-safe iteration and error normalization.
+*
+* Handles the connection lifecycle shared by all streaming hooks:
+* 1. Calls `connect` to obtain an async iterable
+* 2. Iterates events, stopping on signal abort
+* 3. Filters out AbortError (normal cleanup), surfaces all others
+*/
 async function consumeStream(connect, jobId, signal, onEvent) {
-  const events = await connect(jobId, signal);
-  for await (const event of events) {
-    if (signal.aborted) break;
-    onEvent(event);
-  }
+	const events = await connect(jobId, signal);
+	for await (const event of events) {
+		if (signal.aborted) break;
+		onEvent(event);
+	}
 }
-var TOOL_RESULT_EVENT_TYPES = /* @__PURE__ */ new Set(["resolveToolResults", "attemptCompletion"]);
+
+//#endregion
+//#region src/utils/event-to-activity.ts
+const TOOL_RESULT_EVENT_TYPES = new Set(["resolveToolResults", "attemptCompletion"]);
+/**
+* Converts a tool call and result to an Activity.
+* Delegates to core's createBaseToolActivity/createGeneralToolActivity to avoid duplication.
+*/
 function toolToActivity(toolCall, toolResult, reasoning, meta) {
-  const { skillName, toolName } = toolCall;
-  const baseActivity = skillName.startsWith(BASE_SKILL_PREFIX) ? createBaseToolActivity(toolName, toolCall, toolResult, reasoning) : createGeneralToolActivity(skillName, toolName, toolCall, toolResult, reasoning);
-  return {
-    ...baseActivity,
-    id: meta.id,
-    expertKey: meta.expertKey,
-    runId: meta.runId,
-    previousActivityId: meta.previousActivityId,
-    delegatedBy: meta.delegatedBy
-  };
+	const { skillName, toolName } = toolCall;
+	return {
+		...skillName.startsWith(BASE_SKILL_PREFIX) ? createBaseToolActivity(toolName, toolCall, toolResult, reasoning) : createGeneralToolActivity(skillName, toolName, toolCall, toolResult, reasoning),
+		id: meta.id,
+		expertKey: meta.expertKey,
+		runId: meta.runId,
+		previousActivityId: meta.previousActivityId,
+		delegatedBy: meta.delegatedBy
+	};
 }
 function createInitialActivityProcessState() {
-  return {
-    tools: /* @__PURE__ */ new Map(),
-    runStates: /* @__PURE__ */ new Map()
-  };
+	return {
+		tools: /* @__PURE__ */ new Map(),
+		runStates: /* @__PURE__ */ new Map()
+	};
 }
 function getOrCreateRunState(state, runId, expertKey) {
-  let runState = state.runStates.get(runId);
-  if (!runState) {
-    runState = {
-      expertKey,
-      queryLogged: false,
-      completionLogged: false,
-      isComplete: false,
-      pendingDelegateCount: 0
-    };
-    state.runStates.set(runId, runState);
-  }
-  return runState;
+	let runState = state.runStates.get(runId);
+	if (!runState) {
+		runState = {
+			expertKey,
+			queryLogged: false,
+			completionLogged: false,
+			isComplete: false,
+			pendingDelegateCount: 0
+		};
+		state.runStates.set(runId, runState);
+	}
+	return runState;
 }
-var isRunEvent = (event) => "type" in event && "expertKey" in event;
-var isCompleteStreamingReasoningEvent = (event) => "type" in event && event.type === "completeStreamingReasoning";
-var isToolCallsEvent = (event) => event.type === "callTools" && "toolCalls" in event;
-var isStopRunByDelegateEvent = (event) => event.type === "stopRunByDelegate" && "checkpoint" in event;
-var isStopRunByInteractiveToolEvent = (event) => event.type === "stopRunByInteractiveTool" && "checkpoint" in event;
-var isToolResultsEvent = (event) => event.type === "resolveToolResults" && "toolResults" in event;
-var isToolResultEvent = (event) => TOOL_RESULT_EVENT_TYPES.has(event.type) && "toolResult" in event;
+const isRunEvent = (event) => "type" in event && "expertKey" in event;
+const isCompleteStreamingReasoningEvent = (event) => "type" in event && event.type === "completeStreamingReasoning";
+const isToolCallsEvent = (event) => event.type === "callTools" && "toolCalls" in event;
+const isStopRunByDelegateEvent = (event) => event.type === "stopRunByDelegate" && "checkpoint" in event;
+const isStopRunByInteractiveToolEvent = (event) => event.type === "stopRunByInteractiveTool" && "checkpoint" in event;
+const isToolResultsEvent = (event) => event.type === "resolveToolResults" && "toolResults" in event;
+const isToolResultEvent = (event) => TOOL_RESULT_EVENT_TYPES.has(event.type) && "toolResult" in event;
+/**
+* Wraps multiple activities in a ParallelActivitiesGroup with shared reasoning.
+* If only one activity, returns it directly.
+*/
 function wrapInGroupIfParallel(activities, reasoning, meta) {
-  if (activities.length <= 1) {
-    return activities;
-  }
-  const activitiesWithoutReasoning = activities.map((a) => {
-    const { reasoning: _, ...rest } = a;
-    return rest;
-  });
-  const group = {
-    type: "parallelGroup",
-    id: `parallel-${activities[0].id}`,
-    expertKey: meta.expertKey,
-    runId: meta.runId,
-    reasoning,
-    activities: activitiesWithoutReasoning
-  };
-  return [group];
+	if (activities.length <= 1) return activities;
+	const activitiesWithoutReasoning = activities.map((a) => {
+		const { reasoning: _, ...rest } = a;
+		return rest;
+	});
+	return [{
+		type: "parallelGroup",
+		id: `parallel-${activities[0].id}`,
+		expertKey: meta.expertKey,
+		runId: meta.runId,
+		reasoning,
+		activities: activitiesWithoutReasoning
+	}];
 }
+/**
+* Processes a RunEvent and produces Activity or ParallelActivitiesGroup items.
+* Only processes RunEvent (state machine transitions), not RuntimeEvent.
+*
+* @param state - Mutable processing state
+* @param event - The event to process
+* @param addActivity - Callback to add a new Activity or ParallelActivitiesGroup
+*/
 function processRunEventToActivity(state, event, addActivity) {
-  if (isCompleteStreamingReasoningEvent(event)) {
-    const reasoningEvent = event;
-    const { runId, text, expertKey } = reasoningEvent;
-    const runState2 = state.runStates.get(runId);
-    if (runState2) {
-      runState2.completedReasoning = text;
-    } else {
-      state.runStates.set(runId, {
-        expertKey,
-        queryLogged: false,
-        completionLogged: false,
-        isComplete: false,
-        pendingDelegateCount: 0,
-        completedReasoning: text
-      });
-    }
-    return;
-  }
-  if (!isRunEvent(event)) {
-    return;
-  }
-  const runState = getOrCreateRunState(state, event.runId, event.expertKey);
-  if (event.type === "startRun") {
-    const startRunEvent = event;
-    const userMessage = startRunEvent.inputMessages.find((m) => m.type === "userMessage");
-    const queryText = userMessage?.contents?.find((c) => c.type === "textPart")?.text;
-    if (!runState.delegatedBy) {
-      const delegatedByInfo = startRunEvent.initialCheckpoint?.delegatedBy;
-      if (delegatedByInfo) {
-        runState.delegatedBy = {
-          expertKey: delegatedByInfo.expert.key,
-          runId: delegatedByInfo.runId
-        };
-      }
-    }
-    const isDelegationReturn = startRunEvent.initialCheckpoint?.status === "stoppedByDelegate" || startRunEvent.initialCheckpoint?.status === "stoppedByInteractiveTool";
-    if (queryText && !runState.queryLogged && !isDelegationReturn) {
-      const activityId = `query-${event.runId}`;
-      addActivity({
-        type: "query",
-        id: activityId,
-        expertKey: event.expertKey,
-        runId: event.runId,
-        previousActivityId: runState.lastActivityId,
-        delegatedBy: runState.delegatedBy,
-        text: queryText
-      });
-      runState.lastActivityId = activityId;
-      runState.queryLogged = true;
-    }
-    return;
-  }
-  if (event.type === "resumeFromStop") {
-    if (!runState.delegatedBy) {
-      const resumeEvent = event;
-      const delegatedByInfo = resumeEvent.checkpoint?.delegatedBy;
-      if (delegatedByInfo) {
-        runState.delegatedBy = {
-          expertKey: delegatedByInfo.expert.key,
-          runId: delegatedByInfo.runId
-        };
-      }
-    }
-    return;
-  }
-  if (event.type === "retry") {
-    const retryEvent = event;
-    const activityId = `retry-${event.id}`;
-    addActivity({
-      type: "retry",
-      id: activityId,
-      expertKey: event.expertKey,
-      runId: event.runId,
-      previousActivityId: runState.lastActivityId,
-      delegatedBy: runState.delegatedBy,
-      reasoning: runState.completedReasoning,
-      error: retryEvent.reason,
-      message: ""
-    });
-    runState.lastActivityId = activityId;
-    runState.completedReasoning = void 0;
-    return;
-  }
-  if (event.type === "completeRun") {
-    if (!runState.completionLogged) {
-      const text = event.text ?? "";
-      const activityId = `completion-${event.runId}`;
-      addActivity({
-        type: "complete",
-        id: activityId,
-        expertKey: event.expertKey,
-        runId: event.runId,
-        previousActivityId: runState.lastActivityId,
-        delegatedBy: runState.delegatedBy,
-        reasoning: runState.completedReasoning,
-        text
-      });
-      runState.lastActivityId = activityId;
-      runState.completionLogged = true;
-      runState.isComplete = true;
-      runState.completedReasoning = void 0;
-    }
-    return;
-  }
-  if (event.type === "stopRunByError") {
-    const errorEvent = event;
-    const activityId = `error-${event.id}`;
-    addActivity({
-      type: "error",
-      id: activityId,
-      expertKey: event.expertKey,
-      runId: event.runId,
-      previousActivityId: runState.lastActivityId,
-      delegatedBy: runState.delegatedBy,
-      errorName: errorEvent.error.name,
-      error: errorEvent.error.message,
-      isRetryable: errorEvent.error.isRetryable
-    });
-    runState.lastActivityId = activityId;
-    runState.isComplete = true;
-    runState.completedReasoning = void 0;
-    return;
-  }
-  if (isToolCallsEvent(event)) {
-    for (const toolCall of event.toolCalls) {
-      if (!state.tools.has(toolCall.id)) {
-        state.tools.set(toolCall.id, { id: toolCall.id, toolCall, logged: false });
-      }
-    }
-  }
-  if (isStopRunByDelegateEvent(event)) {
-    const reasoning = runState.completedReasoning;
-    const delegations = event.checkpoint.delegateTo ?? [];
-    runState.pendingDelegateCount += delegations.length;
-    const delegateActivities = [];
-    for (const delegation of delegations) {
-      const existingTool = state.tools.get(delegation.toolCallId);
-      if (!existingTool || !existingTool.logged) {
-        if (existingTool) {
-          existingTool.logged = true;
-        }
-        const activityId = `delegate-${delegation.toolCallId}`;
-        delegateActivities.push({
-          type: "delegate",
-          id: activityId,
-          expertKey: event.expertKey,
-          runId: event.runId,
-          previousActivityId: runState.lastActivityId,
-          delegatedBy: runState.delegatedBy,
-          delegateExpertKey: delegation.expert.key,
-          query: delegation.query,
-          reasoning
-        });
-        runState.lastActivityId = activityId;
-      }
-    }
-    const wrapped = wrapInGroupIfParallel(delegateActivities, reasoning, {
-      expertKey: event.expertKey,
-      runId: event.runId,
-      delegatedBy: runState.delegatedBy
-    });
-    for (const item of wrapped) {
-      addActivity(item);
-    }
-    runState.completedReasoning = void 0;
-    return;
-  }
-  if (isStopRunByInteractiveToolEvent(event)) {
-    const reasoning = runState.completedReasoning;
-    const pendingToolCalls = event.checkpoint.pendingToolCalls ?? [];
-    const interactiveActivities = [];
-    for (const toolCall of pendingToolCalls) {
-      const existingTool = state.tools.get(toolCall.id);
-      if (!existingTool || !existingTool.logged) {
-        if (existingTool) {
-          existingTool.logged = true;
-        }
-        const activityId = `interactive-${toolCall.id}`;
-        interactiveActivities.push({
-          type: "interactiveTool",
-          id: activityId,
-          expertKey: event.expertKey,
-          runId: event.runId,
-          previousActivityId: runState.lastActivityId,
-          delegatedBy: runState.delegatedBy,
-          skillName: toolCall.skillName,
-          toolName: toolCall.toolName,
-          args: toolCall.args,
-          reasoning
-        });
-        runState.lastActivityId = activityId;
-      }
-    }
-    const wrapped = wrapInGroupIfParallel(interactiveActivities, reasoning, {
-      expertKey: event.expertKey,
-      runId: event.runId,
-      delegatedBy: runState.delegatedBy
-    });
-    for (const item of wrapped) {
-      addActivity(item);
-    }
-    runState.completedReasoning = void 0;
-    return;
-  }
-  if (isToolResultsEvent(event)) {
-    const reasoning = runState.completedReasoning;
-    const toolActivities = [];
-    for (const toolResult of event.toolResults) {
-      const tool = state.tools.get(toolResult.id);
-      if (tool && !tool.logged) {
-        const activityId = `action-${tool.id}`;
-        const activity = toolToActivity(tool.toolCall, toolResult, reasoning, {
-          id: activityId,
-          expertKey: event.expertKey,
-          runId: event.runId,
-          previousActivityId: runState.lastActivityId,
-          delegatedBy: runState.delegatedBy
-        });
-        toolActivities.push(activity);
-        runState.lastActivityId = activityId;
-        tool.logged = true;
-      }
-    }
-    if (toolActivities.length > 0) {
-      const wrapped = wrapInGroupIfParallel(toolActivities, reasoning, {
-        expertKey: event.expertKey,
-        runId: event.runId,
-        delegatedBy: runState.delegatedBy
-      });
-      for (const item of wrapped) {
-        addActivity(item);
-      }
-      runState.completedReasoning = void 0;
-    }
-  } else if (isToolResultEvent(event)) {
-    const { toolResult } = event;
-    const tool = state.tools.get(toolResult.id);
-    if (tool && !tool.logged) {
-      const activityId = `action-${tool.id}`;
-      const activity = toolToActivity(tool.toolCall, toolResult, runState.completedReasoning, {
-        id: activityId,
-        expertKey: event.expertKey,
-        runId: event.runId,
-        previousActivityId: runState.lastActivityId,
-        delegatedBy: runState.delegatedBy
-      });
-      addActivity(activity);
-      runState.lastActivityId = activityId;
-      tool.logged = true;
-      runState.completedReasoning = void 0;
-    }
-  }
+	if (isCompleteStreamingReasoningEvent(event)) {
+		const { runId, text, expertKey } = event;
+		const runState = state.runStates.get(runId);
+		if (runState) runState.completedReasoning = text;
+		else state.runStates.set(runId, {
+			expertKey,
+			queryLogged: false,
+			completionLogged: false,
+			isComplete: false,
+			pendingDelegateCount: 0,
+			completedReasoning: text
+		});
+		return;
+	}
+	if (!isRunEvent(event)) return;
+	const runState = getOrCreateRunState(state, event.runId, event.expertKey);
+	if (event.type === "startRun") {
+		const startRunEvent = event;
+		const queryText = startRunEvent.inputMessages.find((m) => m.type === "userMessage")?.contents?.find((c) => c.type === "textPart")?.text;
+		if (!runState.delegatedBy) {
+			const delegatedByInfo = startRunEvent.initialCheckpoint?.delegatedBy;
+			if (delegatedByInfo) runState.delegatedBy = {
+				expertKey: delegatedByInfo.expert.key,
+				runId: delegatedByInfo.runId
+			};
+		}
+		const isDelegationReturn = startRunEvent.initialCheckpoint?.status === "stoppedByDelegate" || startRunEvent.initialCheckpoint?.status === "stoppedByInteractiveTool";
+		if (queryText && !runState.queryLogged && !isDelegationReturn) {
+			const activityId = `query-${event.runId}`;
+			addActivity({
+				type: "query",
+				id: activityId,
+				expertKey: event.expertKey,
+				runId: event.runId,
+				previousActivityId: runState.lastActivityId,
+				delegatedBy: runState.delegatedBy,
+				text: queryText
+			});
+			runState.lastActivityId = activityId;
+			runState.queryLogged = true;
+		}
+		return;
+	}
+	if (event.type === "resumeFromStop") {
+		if (!runState.delegatedBy) {
+			const delegatedByInfo = event.checkpoint?.delegatedBy;
+			if (delegatedByInfo) runState.delegatedBy = {
+				expertKey: delegatedByInfo.expert.key,
+				runId: delegatedByInfo.runId
+			};
+		}
+		return;
+	}
+	if (event.type === "retry") {
+		const retryEvent = event;
+		const activityId = `retry-${event.id}`;
+		addActivity({
+			type: "retry",
+			id: activityId,
+			expertKey: event.expertKey,
+			runId: event.runId,
+			previousActivityId: runState.lastActivityId,
+			delegatedBy: runState.delegatedBy,
+			reasoning: runState.completedReasoning,
+			error: retryEvent.reason,
+			message: ""
+		});
+		runState.lastActivityId = activityId;
+		runState.completedReasoning = void 0;
+		return;
+	}
+	if (event.type === "completeRun") {
+		if (!runState.completionLogged) {
+			const text = event.text ?? "";
+			const activityId = `completion-${event.runId}`;
+			addActivity({
+				type: "complete",
+				id: activityId,
+				expertKey: event.expertKey,
+				runId: event.runId,
+				previousActivityId: runState.lastActivityId,
+				delegatedBy: runState.delegatedBy,
+				reasoning: runState.completedReasoning,
+				text
+			});
+			runState.lastActivityId = activityId;
+			runState.completionLogged = true;
+			runState.isComplete = true;
+			runState.completedReasoning = void 0;
+		}
+		return;
+	}
+	if (event.type === "stopRunByError") {
+		const errorEvent = event;
+		const activityId = `error-${event.id}`;
+		addActivity({
+			type: "error",
+			id: activityId,
+			expertKey: event.expertKey,
+			runId: event.runId,
+			previousActivityId: runState.lastActivityId,
+			delegatedBy: runState.delegatedBy,
+			errorName: errorEvent.error.name,
+			error: errorEvent.error.message,
+			isRetryable: errorEvent.error.isRetryable
+		});
+		runState.lastActivityId = activityId;
+		runState.isComplete = true;
+		runState.completedReasoning = void 0;
+		return;
+	}
+	if (isToolCallsEvent(event)) {
+		for (const toolCall of event.toolCalls) if (!state.tools.has(toolCall.id)) state.tools.set(toolCall.id, {
+			id: toolCall.id,
+			toolCall,
+			logged: false
+		});
+	}
+	if (isStopRunByDelegateEvent(event)) {
+		const reasoning = runState.completedReasoning;
+		const delegations = event.checkpoint.delegateTo ?? [];
+		runState.pendingDelegateCount += delegations.length;
+		const delegateActivities = [];
+		for (const delegation of delegations) {
+			const existingTool = state.tools.get(delegation.toolCallId);
+			if (!existingTool || !existingTool.logged) {
+				if (existingTool) existingTool.logged = true;
+				const activityId = `delegate-${delegation.toolCallId}`;
+				delegateActivities.push({
+					type: "delegate",
+					id: activityId,
+					expertKey: event.expertKey,
+					runId: event.runId,
+					previousActivityId: runState.lastActivityId,
+					delegatedBy: runState.delegatedBy,
+					delegateExpertKey: delegation.expert.key,
+					query: delegation.query,
+					reasoning
+				});
+				runState.lastActivityId = activityId;
+			}
+		}
+		const wrapped = wrapInGroupIfParallel(delegateActivities, reasoning, {
+			expertKey: event.expertKey,
+			runId: event.runId,
+			delegatedBy: runState.delegatedBy
+		});
+		for (const item of wrapped) addActivity(item);
+		runState.completedReasoning = void 0;
+		return;
+	}
+	if (isStopRunByInteractiveToolEvent(event)) {
+		const reasoning = runState.completedReasoning;
+		const pendingToolCalls = event.checkpoint.pendingToolCalls ?? [];
+		const interactiveActivities = [];
+		for (const toolCall of pendingToolCalls) {
+			const existingTool = state.tools.get(toolCall.id);
+			if (!existingTool || !existingTool.logged) {
+				if (existingTool) existingTool.logged = true;
+				const activityId = `interactive-${toolCall.id}`;
+				interactiveActivities.push({
+					type: "interactiveTool",
+					id: activityId,
+					expertKey: event.expertKey,
+					runId: event.runId,
+					previousActivityId: runState.lastActivityId,
+					delegatedBy: runState.delegatedBy,
+					skillName: toolCall.skillName,
+					toolName: toolCall.toolName,
+					args: toolCall.args,
+					reasoning
+				});
+				runState.lastActivityId = activityId;
+			}
+		}
+		const wrapped = wrapInGroupIfParallel(interactiveActivities, reasoning, {
+			expertKey: event.expertKey,
+			runId: event.runId,
+			delegatedBy: runState.delegatedBy
+		});
+		for (const item of wrapped) addActivity(item);
+		runState.completedReasoning = void 0;
+		return;
+	}
+	if (isToolResultsEvent(event)) {
+		const reasoning = runState.completedReasoning;
+		const toolActivities = [];
+		for (const toolResult of event.toolResults) {
+			const tool = state.tools.get(toolResult.id);
+			if (tool && !tool.logged) {
+				const activityId = `action-${tool.id}`;
+				const activity = toolToActivity(tool.toolCall, toolResult, reasoning, {
+					id: activityId,
+					expertKey: event.expertKey,
+					runId: event.runId,
+					previousActivityId: runState.lastActivityId,
+					delegatedBy: runState.delegatedBy
+				});
+				toolActivities.push(activity);
+				runState.lastActivityId = activityId;
+				tool.logged = true;
+			}
+		}
+		if (toolActivities.length > 0) {
+			const wrapped = wrapInGroupIfParallel(toolActivities, reasoning, {
+				expertKey: event.expertKey,
+				runId: event.runId,
+				delegatedBy: runState.delegatedBy
+			});
+			for (const item of wrapped) addActivity(item);
+			runState.completedReasoning = void 0;
+		}
+	} else if (isToolResultEvent(event)) {
+		const { toolResult } = event;
+		const tool = state.tools.get(toolResult.id);
+		if (tool && !tool.logged) {
+			const activityId = `action-${tool.id}`;
+			addActivity(toolToActivity(tool.toolCall, toolResult, runState.completedReasoning, {
+				id: activityId,
+				expertKey: event.expertKey,
+				runId: event.runId,
+				previousActivityId: runState.lastActivityId,
+				delegatedBy: runState.delegatedBy
+			}));
+			runState.lastActivityId = activityId;
+			tool.logged = true;
+			runState.completedReasoning = void 0;
+		}
+	}
 }
 
-// src/hooks/use-run.ts
-var STREAMING_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "startStreamingReasoning",
-  "streamReasoning",
-  "completeStreamingReasoning",
-  "startStreamingRunResult",
-  "streamRunResult",
-  "completeStreamingRunResult"
+//#endregion
+//#region src/hooks/use-run.ts
+const STREAMING_EVENT_TYPES = new Set([
+	"startStreamingReasoning",
+	"streamReasoning",
+	"completeStreamingReasoning",
+	"startStreamingRunResult",
+	"streamRunResult",
+	"completeStreamingRunResult"
 ]);
-var isStreamingEvent = (event) => "type" in event && "expertKey" in event && STREAMING_EVENT_TYPES.has(event.type);
+const isStreamingEvent = (event) => "type" in event && "expertKey" in event && STREAMING_EVENT_TYPES.has(event.type);
 function processStreamingEvent(event, prevState) {
-  const { runId, expertKey } = event;
-  switch (event.type) {
-    case "startStreamingReasoning": {
-      return {
-        newState: {
-          ...prevState,
-          runs: {
-            ...prevState.runs,
-            [runId]: {
-              expertKey,
-              reasoning: "",
-              isReasoningActive: true
-            }
-          }
-        },
-        handled: true
-      };
-    }
-    case "streamReasoning": {
-      return {
-        newState: {
-          ...prevState,
-          runs: {
-            ...prevState.runs,
-            [runId]: {
-              ...prevState.runs[runId],
-              expertKey,
-              reasoning: (prevState.runs[runId]?.reasoning ?? "") + event.delta
-            }
-          }
-        },
-        handled: true
-      };
-    }
-    case "completeStreamingReasoning": {
-      return {
-        newState: {
-          ...prevState,
-          runs: {
-            ...prevState.runs,
-            [runId]: {
-              ...prevState.runs[runId],
-              expertKey,
-              isReasoningActive: false
-            }
-          }
-        },
-        handled: false
-      };
-    }
-    case "startStreamingRunResult": {
-      return {
-        newState: {
-          ...prevState,
-          runs: {
-            ...prevState.runs,
-            [runId]: {
-              expertKey,
-              reasoning: void 0,
-              isReasoningActive: false,
-              runResult: "",
-              isRunResultActive: true
-            }
-          }
-        },
-        handled: true
-      };
-    }
-    case "streamRunResult": {
-      return {
-        newState: {
-          ...prevState,
-          runs: {
-            ...prevState.runs,
-            [runId]: {
-              ...prevState.runs[runId],
-              expertKey,
-              runResult: (prevState.runs[runId]?.runResult ?? "") + event.delta
-            }
-          }
-        },
-        handled: true
-      };
-    }
-    case "completeStreamingRunResult": {
-      return {
-        newState: {
-          ...prevState,
-          runs: {
-            ...prevState.runs,
-            [runId]: {
-              ...prevState.runs[runId],
-              expertKey,
-              isRunResultActive: false
-            }
-          }
-        },
-        handled: true
-      };
-    }
-    default:
-      return { newState: prevState, handled: false };
-  }
+	const { runId, expertKey } = event;
+	switch (event.type) {
+		case "startStreamingReasoning": return {
+			newState: {
+				...prevState,
+				runs: {
+					...prevState.runs,
+					[runId]: {
+						expertKey,
+						reasoning: "",
+						isReasoningActive: true
+					}
+				}
+			},
+			handled: true
+		};
+		case "streamReasoning": return {
+			newState: {
+				...prevState,
+				runs: {
+					...prevState.runs,
+					[runId]: {
+						...prevState.runs[runId],
+						expertKey,
+						reasoning: (prevState.runs[runId]?.reasoning ?? "") + event.delta
+					}
+				}
+			},
+			handled: true
+		};
+		case "completeStreamingReasoning": return {
+			newState: {
+				...prevState,
+				runs: {
+					...prevState.runs,
+					[runId]: {
+						...prevState.runs[runId],
+						expertKey,
+						isReasoningActive: false
+					}
+				}
+			},
+			handled: false
+		};
+		case "startStreamingRunResult": return {
+			newState: {
+				...prevState,
+				runs: {
+					...prevState.runs,
+					[runId]: {
+						expertKey,
+						reasoning: void 0,
+						isReasoningActive: false,
+						runResult: "",
+						isRunResultActive: true
+					}
+				}
+			},
+			handled: true
+		};
+		case "streamRunResult": return {
+			newState: {
+				...prevState,
+				runs: {
+					...prevState.runs,
+					[runId]: {
+						...prevState.runs[runId],
+						expertKey,
+						runResult: (prevState.runs[runId]?.runResult ?? "") + event.delta
+					}
+				}
+			},
+			handled: true
+		};
+		case "completeStreamingRunResult": return {
+			newState: {
+				...prevState,
+				runs: {
+					...prevState.runs,
+					[runId]: {
+						...prevState.runs[runId],
+						expertKey,
+						isRunResultActive: false
+					}
+				}
+			},
+			handled: true
+		};
+		default: return {
+			newState: prevState,
+			handled: false
+		};
+	}
 }
+/**
+* Hook for managing Run state from RunEvent stream.
+*
+* Architecture:
+* - ExpertStateEvent → ActivityOrGroup[] (accumulated, append-only)
+* - StreamingEvent → StreamingState (latest only, for display)
+*
+* IMPORTANT: activities are append-only and never cleared.
+* This is required for compatibility with Ink's <Static> component.
+*/
 function useRun() {
-  const [activities, setActivities] = useState([]);
-  const [streaming, setStreaming] = useState({ runs: {} });
-  const [eventCount, setEventCount] = useState(0);
-  const [isComplete, setIsComplete] = useState(false);
-  const stateRef = useRef(createInitialActivityProcessState());
-  const clearStreaming = useCallback(() => {
-    setStreaming({ runs: {} });
-  }, []);
-  const handleStreamingEvent = useCallback((event) => {
-    let handled = false;
-    setStreaming((prev) => {
-      const result = processStreamingEvent(event, prev);
-      handled = result.handled;
-      return result.newState;
-    });
-    return handled;
-  }, []);
-  const processEvent = useCallback((event) => {
-    const newActivities = [];
-    const addActivity = (activity) => newActivities.push(activity);
-    processRunEventToActivity(stateRef.current, event, addActivity);
-    if (newActivities.length > 0) {
-      setActivities((prev) => [...prev, ...newActivities]);
-    }
-    const rootRunComplete = Array.from(stateRef.current.runStates.values()).some(
-      (rs) => rs.isComplete && !rs.delegatedBy
-    );
-    setIsComplete(rootRunComplete);
-  }, []);
-  const clearRunStreaming = useCallback((runId) => {
-    setStreaming((prev) => {
-      const { [runId]: _, ...rest } = prev.runs;
-      return { runs: rest };
-    });
-  }, []);
-  const addEvent = useCallback(
-    (event) => {
-      if (isStreamingEvent(event)) {
-        const handled = handleStreamingEvent(event);
-        if (handled) {
-          setEventCount((prev) => prev + 1);
-          return;
-        }
-      }
-      if ("type" in event && "runId" in event && (event.type === "completeRun" || event.type === "stopRunByError")) {
-        clearRunStreaming(event.runId);
-      }
-      processEvent(event);
-      setEventCount((prev) => prev + 1);
-    },
-    [handleStreamingEvent, clearRunStreaming, processEvent]
-  );
-  const appendHistoricalEvents = useCallback((historicalEvents) => {
-    const newActivities = [];
-    const addActivity = (activity) => newActivities.push(activity);
-    for (const event of historicalEvents) {
-      processRunEventToActivity(stateRef.current, event, addActivity);
-    }
-    if (newActivities.length > 0) {
-      setActivities((prev) => [...prev, ...newActivities]);
-    }
-    setEventCount((prev) => prev + historicalEvents.length);
-    const rootRunComplete = Array.from(stateRef.current.runStates.values()).some(
-      (rs) => rs.isComplete && !rs.delegatedBy
-    );
-    setIsComplete(rootRunComplete);
-  }, []);
-  return {
-    activities,
-    streaming,
-    isComplete,
-    eventCount,
-    addEvent,
-    appendHistoricalEvents,
-    clearStreaming
-  };
+	const [activities, setActivities] = useState([]);
+	const [streaming, setStreaming] = useState({ runs: {} });
+	const [eventCount, setEventCount] = useState(0);
+	const [isComplete, setIsComplete] = useState(false);
+	const stateRef = useRef(createInitialActivityProcessState());
+	const clearStreaming = useCallback(() => {
+		setStreaming({ runs: {} });
+	}, []);
+	const handleStreamingEvent = useCallback((event) => {
+		let handled = false;
+		setStreaming((prev) => {
+			const result = processStreamingEvent(event, prev);
+			handled = result.handled;
+			return result.newState;
+		});
+		return handled;
+	}, []);
+	const processEvent = useCallback((event) => {
+		const newActivities = [];
+		const addActivity = (activity) => newActivities.push(activity);
+		processRunEventToActivity(stateRef.current, event, addActivity);
+		if (newActivities.length > 0) setActivities((prev) => [...prev, ...newActivities]);
+		setIsComplete(Array.from(stateRef.current.runStates.values()).some((rs) => rs.isComplete && !rs.delegatedBy));
+	}, []);
+	const clearRunStreaming = useCallback((runId) => {
+		setStreaming((prev) => {
+			const { [runId]: _, ...rest } = prev.runs;
+			return { runs: rest };
+		});
+	}, []);
+	return {
+		activities,
+		streaming,
+		isComplete,
+		eventCount,
+		addEvent: useCallback((event) => {
+			if (isStreamingEvent(event)) {
+				if (handleStreamingEvent(event)) {
+					setEventCount((prev) => prev + 1);
+					return;
+				}
+			}
+			if ("type" in event && "runId" in event && (event.type === "completeRun" || event.type === "stopRunByError")) clearRunStreaming(event.runId);
+			processEvent(event);
+			setEventCount((prev) => prev + 1);
+		}, [
+			handleStreamingEvent,
+			clearRunStreaming,
+			processEvent
+		]),
+		appendHistoricalEvents: useCallback((historicalEvents) => {
+			const newActivities = [];
+			const addActivity = (activity) => newActivities.push(activity);
+			for (const event of historicalEvents) processRunEventToActivity(stateRef.current, event, addActivity);
+			if (newActivities.length > 0) setActivities((prev) => [...prev, ...newActivities]);
+			setEventCount((prev) => prev + historicalEvents.length);
+			setIsComplete(Array.from(stateRef.current.runStates.values()).some((rs) => rs.isComplete && !rs.delegatedBy));
+		}, []),
+		clearStreaming
+	};
 }
 
-// src/hooks/use-job-stream.ts
+//#endregion
+//#region src/hooks/use-job-stream.ts
 function useJobStream(options) {
-  const { jobId, connect, enabled = true } = options;
-  const shouldConnect = Boolean(jobId && enabled);
-  const { activities, streaming, addEvent } = useRun();
-  const [isConnected, setIsConnected] = useState(false);
-  const [error, setError] = useState(null);
-  const addEventRef = useRef(addEvent);
-  addEventRef.current = addEvent;
-  const connectRef = useRef(connect);
-  connectRef.current = connect;
-  useEffect(() => {
-    if (!shouldConnect || !jobId) {
-      setIsConnected(false);
-      return;
-    }
-    const controller = new AbortController();
-    async function run() {
-      setError(null);
-      setIsConnected(true);
-      try {
-        await consumeStream(connectRef.current, jobId, controller.signal, (event) => {
-          addEventRef.current(event);
-        });
-      } catch (err) {
-        if (isAbortError(err)) return;
-        setError(err instanceof Error ? err : new Error(String(err)));
-      } finally {
-        setIsConnected(false);
-      }
-    }
-    run();
-    return () => {
-      controller.abort();
-    };
-  }, [shouldConnect, jobId]);
-  const latestActivity = useMemo(
-    () => activities.length > 0 ? activities[activities.length - 1] : null,
-    [activities]
-  );
-  return { activities, streaming, latestActivity, isConnected, error };
+	const { jobId, connect, enabled = true } = options;
+	const shouldConnect = Boolean(jobId && enabled);
+	const { activities, streaming, addEvent } = useRun();
+	const [isConnected, setIsConnected] = useState(false);
+	const [error, setError] = useState(null);
+	const addEventRef = useRef(addEvent);
+	addEventRef.current = addEvent;
+	const connectRef = useRef(connect);
+	connectRef.current = connect;
+	useEffect(() => {
+		if (!shouldConnect || !jobId) {
+			setIsConnected(false);
+			return;
+		}
+		const controller = new AbortController();
+		async function run() {
+			setError(null);
+			setIsConnected(true);
+			try {
+				await consumeStream(connectRef.current, jobId, controller.signal, (event) => {
+					addEventRef.current(event);
+				});
+			} catch (err) {
+				if (isAbortError(err)) return;
+				setError(err instanceof Error ? err : new Error(String(err)));
+			} finally {
+				setIsConnected(false);
+			}
+		}
+		run();
+		return () => {
+			controller.abort();
+		};
+	}, [shouldConnect, jobId]);
+	return {
+		activities,
+		streaming,
+		latestActivity: useMemo(() => activities.length > 0 ? activities[activities.length - 1] : null, [activities]),
+		isConnected,
+		error
+	};
 }
+
+//#endregion
+//#region src/hooks/use-job-streams.ts
 function useJobStreams(options) {
-  const { jobs, connect } = options;
-  const [states, setStates] = useState(/* @__PURE__ */ new Map());
-  const controllersRef = useRef(/* @__PURE__ */ new Map());
-  const activityStateRef = useRef(/* @__PURE__ */ new Map());
-  const connectRef = useRef(connect);
-  connectRef.current = connect;
-  const connectToJob = useCallback(async (jobId, signal) => {
-    setStates((prev) => {
-      const next = new Map(prev);
-      next.set(jobId, { latestActivity: null, isConnected: true });
-      return next;
-    });
-    let state = activityStateRef.current.get(jobId);
-    if (!state) {
-      state = createInitialActivityProcessState();
-      activityStateRef.current.set(jobId, state);
-    }
-    try {
-      await consumeStream(connectRef.current, jobId, signal, (event) => {
-        let latestActivity = null;
-        processRunEventToActivity(state, event, (activity) => {
-          latestActivity = activity;
-        });
-        if (latestActivity) {
-          setStates((prev) => {
-            const next = new Map(prev);
-            next.set(jobId, { latestActivity, isConnected: true });
-            return next;
-          });
-        }
-      });
-    } catch (err) {
-      if (isAbortError(err)) return;
-      console.error(`Stream connection failed for job ${jobId}:`, err);
-    } finally {
-      setStates((prev) => {
-        const current = prev.get(jobId);
-        if (!current) return prev;
-        const next = new Map(prev);
-        next.set(jobId, { ...current, isConnected: false });
-        return next;
-      });
-    }
-  }, []);
-  useEffect(() => {
-    const enabledIds = new Set(jobs.filter((j) => j.enabled).map((j) => j.id));
-    for (const [jobId, controller] of controllersRef.current) {
-      if (!enabledIds.has(jobId)) {
-        controller.abort();
-        controllersRef.current.delete(jobId);
-        activityStateRef.current.delete(jobId);
-        setStates((prev) => {
-          const next = new Map(prev);
-          next.delete(jobId);
-          return next;
-        });
-      }
-    }
-    for (const jobId of enabledIds) {
-      if (!controllersRef.current.has(jobId)) {
-        const controller = new AbortController();
-        controllersRef.current.set(jobId, controller);
-        connectToJob(jobId, controller.signal);
-      }
-    }
-  }, [jobs, connectToJob]);
-  useEffect(() => {
-    return () => {
-      for (const controller of controllersRef.current.values()) {
-        controller.abort();
-      }
-      controllersRef.current.clear();
-      activityStateRef.current.clear();
-    };
-  }, []);
-  return states;
+	const { jobs, connect } = options;
+	const [states, setStates] = useState(/* @__PURE__ */ new Map());
+	const controllersRef = useRef(/* @__PURE__ */ new Map());
+	const activityStateRef = useRef(/* @__PURE__ */ new Map());
+	const connectRef = useRef(connect);
+	connectRef.current = connect;
+	const connectToJob = useCallback(async (jobId, signal) => {
+		setStates((prev) => {
+			const next = new Map(prev);
+			next.set(jobId, {
+				latestActivity: null,
+				isConnected: true
+			});
+			return next;
+		});
+		let state = activityStateRef.current.get(jobId);
+		if (!state) {
+			state = createInitialActivityProcessState();
+			activityStateRef.current.set(jobId, state);
+		}
+		try {
+			await consumeStream(connectRef.current, jobId, signal, (event) => {
+				let latestActivity = null;
+				processRunEventToActivity(state, event, (activity) => {
+					latestActivity = activity;
+				});
+				if (latestActivity) setStates((prev) => {
+					const next = new Map(prev);
+					next.set(jobId, {
+						latestActivity,
+						isConnected: true
+					});
+					return next;
+				});
+			});
+		} catch (err) {
+			if (isAbortError(err)) return;
+			console.error(`Stream connection failed for job ${jobId}:`, err);
+		} finally {
+			setStates((prev) => {
+				const current = prev.get(jobId);
+				if (!current) return prev;
+				const next = new Map(prev);
+				next.set(jobId, {
+					...current,
+					isConnected: false
+				});
+				return next;
+			});
+		}
+	}, []);
+	useEffect(() => {
+		const enabledIds = new Set(jobs.filter((j) => j.enabled).map((j) => j.id));
+		for (const [jobId, controller] of controllersRef.current) if (!enabledIds.has(jobId)) {
+			controller.abort();
+			controllersRef.current.delete(jobId);
+			activityStateRef.current.delete(jobId);
+			setStates((prev) => {
+				const next = new Map(prev);
+				next.delete(jobId);
+				return next;
+			});
+		}
+		for (const jobId of enabledIds) if (!controllersRef.current.has(jobId)) {
+			const controller = new AbortController();
+			controllersRef.current.set(jobId, controller);
+			connectToJob(jobId, controller.signal);
+		}
+	}, [jobs, connectToJob]);
+	useEffect(() => {
+		return () => {
+			for (const controller of controllersRef.current.values()) controller.abort();
+			controllersRef.current.clear();
+			activityStateRef.current.clear();
+		};
+	}, []);
+	return states;
 }
 
-// src/utils/group-by-run.ts
+//#endregion
+//#region src/utils/group-by-run.ts
+/**
+* Extract base properties from ActivityOrGroup for grouping.
+*/
 function getActivityProps(activityOrGroup) {
-  if (activityOrGroup.type === "parallelGroup") {
-    const firstActivity = activityOrGroup.activities[0];
-    return {
-      runId: activityOrGroup.runId,
-      expertKey: activityOrGroup.expertKey,
-      delegatedBy: firstActivity?.delegatedBy
-    };
-  }
-  return activityOrGroup;
+	if (activityOrGroup.type === "parallelGroup") {
+		const firstActivity = activityOrGroup.activities[0];
+		return {
+			runId: activityOrGroup.runId,
+			expertKey: activityOrGroup.expertKey,
+			delegatedBy: firstActivity?.delegatedBy
+		};
+	}
+	return activityOrGroup;
 }
+/**
+* Groups activities by their runId while preserving order.
+*
+* This function groups activities so that each run can be displayed in its own
+* visual section (e.g., separate <Static> components in Ink).
+*
+* @param activities - Array of activities or groups to group
+* @returns Array of RunGroup objects, ordered by first appearance
+*/
 function groupActivitiesByRun(activities) {
-  const groupMap = /* @__PURE__ */ new Map();
-  const order = [];
-  for (const activityOrGroup of activities) {
-    const { runId, expertKey, delegatedBy } = getActivityProps(activityOrGroup);
-    if (!groupMap.has(runId)) {
-      groupMap.set(runId, {
-        runId,
-        expertKey,
-        activities: [],
-        delegatedBy
-      });
-      order.push(runId);
-    }
-    const group = groupMap.get(runId);
-    group.activities.push(activityOrGroup);
-  }
-  return order.map((runId) => groupMap.get(runId));
+	const groupMap = /* @__PURE__ */ new Map();
+	const order = [];
+	for (const activityOrGroup of activities) {
+		const { runId, expertKey, delegatedBy } = getActivityProps(activityOrGroup);
+		if (!groupMap.has(runId)) {
+			groupMap.set(runId, {
+				runId,
+				expertKey,
+				activities: [],
+				delegatedBy
+			});
+			order.push(runId);
+		}
+		groupMap.get(runId).activities.push(activityOrGroup);
+	}
+	return order.map((runId) => groupMap.get(runId));
 }
 
+//#endregion
 export { createInitialActivityProcessState, groupActivitiesByRun, processRunEventToActivity, toolToActivity, useJobStream, useJobStreams, useRun };
-//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map