@perstack/react 0.0.58 → 0.0.59

package/dist/src/index.d.ts

@@ -1,4 +1,157 @@
-export { type ActivityProcessState, type JobStreamState, type JobStreamSummary, type RunResult, type StreamConnector, useJobStream, useJobStreams, useRun, } from "./hooks/index.js";
-export type { PerRunStreamingState, StreamingState } from "./types/index.js";
-export { type ActivityProcessState as UtilActivityProcessState, createInitialActivityProcessState, groupActivitiesByRun, processRunEventToActivity, type RunGroup, toolToActivity, } from "./utils/index.js";
+import { Activity, ActivityOrGroup, PerstackEvent, ToolCall, ToolResult } from "@perstack/core";
+
+//#region src/types/runtime-state.d.ts
+/** Per-run streaming state for real-time display */
+type PerRunStreamingState = {
+  /** Expert key for this run */expertKey: string; /** Accumulated reasoning text during extended thinking */
+  reasoning?: string; /** Accumulated run result text during generation */
+  runResult?: string; /** Whether reasoning is currently streaming */
+  isReasoningActive?: boolean; /** Whether run result is currently streaming */
+  isRunResultActive?: boolean;
+};
+/** Streaming state organized by run ID to support parallel execution */
+type StreamingState = {
+  /** Per-run streaming state, keyed by runId */runs: Record<string, PerRunStreamingState>;
+};
+//#endregion
+//#region src/utils/stream.d.ts
+type StreamConnector = (jobId: string, signal: AbortSignal) => Promise<AsyncIterable<PerstackEvent>>;
+//#endregion
+//#region src/hooks/use-job-stream.d.ts
+type JobStreamState = {
+  activities: ActivityOrGroup[];
+  streaming: StreamingState;
+  latestActivity: ActivityOrGroup | null;
+  isConnected: boolean;
+  error: Error | null;
+};
+declare function useJobStream(options: {
+  jobId: string | null;
+  connect: StreamConnector;
+  enabled?: boolean;
+}): JobStreamState;
+//#endregion
+//#region src/hooks/use-job-streams.d.ts
+type JobStreamSummary = {
+  latestActivity: ActivityOrGroup | null;
+  isConnected: boolean;
+};
+declare function useJobStreams(options: {
+  jobs: Array<{
+    id: string;
+    enabled: boolean;
+  }>;
+  connect: StreamConnector;
+}): Map<string, JobStreamSummary>;
+//#endregion
+//#region src/utils/event-to-activity.d.ts
+/**
+ * Converts a tool call and result to an Activity.
+ * Delegates to core's createBaseToolActivity/createGeneralToolActivity to avoid duplication.
+ */
+declare function toolToActivity(toolCall: ToolCall, toolResult: ToolResult, reasoning: string | undefined, meta: {
+  id: string;
+  expertKey: string;
+  runId: string;
+  previousActivityId?: string;
+  delegatedBy?: {
+    expertKey: string;
+    runId: string;
+  };
+}): Activity;
+type ToolState = {
+  id: string;
+  toolCall: ToolCall;
+  logged: boolean;
+};
+/**
+ * Per-run state to support parallel execution.
+ * Each run maintains its own independent state.
+ */
+type RunState = {
+  expertKey: string;
+  queryLogged: boolean;
+  completionLogged: boolean;
+  isComplete: boolean;
+  completedReasoning?: string;
+  lastActivityId?: string;
+  delegatedBy?: {
+    expertKey: string;
+    runId: string;
+  }; /** Track if this run has pending delegate tool calls (for delegation complete detection) */
+  pendingDelegateCount: number;
+};
+/**
+ * State for processing RunEvent stream into Activity[].
+ * This state tracks tool calls and their results to create complete Activity items.
+ *
+ * Supports the daisy chain architecture:
+ * - Within-Run ordering via lastActivityId (per-run state)
+ * - Cross-Run ordering via delegatedBy (per-run state)
+ *
+ * Note: `tools` is NOT cleared on new run to support delegation results
+ * that arrive after parent expert resumes with a new runId.
+ */
+type ActivityProcessState = {
+  /** Tool calls indexed by toolCallId - persisted across runs for delegation handling */tools: Map<string, ToolState>; /** Per-run state to support parallel execution */
+  runStates: Map<string, RunState>;
+};
+declare function createInitialActivityProcessState(): ActivityProcessState;
+/**
+ * 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
+ */
+declare function processRunEventToActivity(state: ActivityProcessState, event: PerstackEvent, addActivity: (activity: ActivityOrGroup) => void): void;
+//#endregion
+//#region src/hooks/use-run.d.ts
+type RunResult = {
+  /** Accumulated activities from RunEvent (may include ParallelActivitiesGroup) */activities: ActivityOrGroup[]; /** Current streaming state */
+  streaming: StreamingState; /** Whether the run is complete */
+  isComplete: boolean; /** Number of events processed */
+  eventCount: number; /** Add a new event to be processed */
+  addEvent: (event: PerstackEvent) => void; /** Append historical events (processes and appends to activities) */
+  appendHistoricalEvents: (events: PerstackEvent[]) => void; /** Clear streaming state */
+  clearStreaming: () => void;
+};
+/**
+ * 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.
+ */
+declare function useRun(): RunResult;
+//#endregion
+//#region src/utils/group-by-run.d.ts
+/**
+ * Represents a group of activities belonging to the same run
+ */
+type RunGroup = {
+  runId: string;
+  expertKey: string;
+  activities: ActivityOrGroup[];
+  delegatedBy?: {
+    expertKey: string;
+    runId: string;
+  };
+};
+/**
+ * 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
+ */
+declare function groupActivitiesByRun(activities: ActivityOrGroup[]): RunGroup[];
+//#endregion
+export { type ActivityProcessState, type ActivityProcessState as UtilActivityProcessState, type JobStreamState, type JobStreamSummary, type PerRunStreamingState, type RunGroup, type RunResult, type StreamConnector, type StreamingState, createInitialActivityProcessState, groupActivitiesByRun, processRunEventToActivity, toolToActivity, useJobStream, useJobStreams, useRun };
 //# sourceMappingURL=index.d.ts.map