@perstack/react 0.0.33

package/dist/src/index.js

@@ -0,0 +1,640 @@
+import { useState, useRef, useCallback } from 'react';
+import { BASE_SKILL_PREFIX, createBaseToolActivity, createGeneralToolActivity } from '@perstack/core';
+
+// src/hooks/use-run.ts
+var TOOL_RESULT_EVENT_TYPES = /* @__PURE__ */ new Set(["resolveToolResults", "attemptCompletion"]);
+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
+  };
+}
+function createInitialActivityProcessState() {
+  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;
+}
+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 isToolResultsEvent = (event) => event.type === "resolveToolResults" && "toolResults" in event;
+var isToolResultEvent = (event) => TOOL_RESULT_EVENT_TYPES.has(event.type) && "toolResult" in event;
+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];
+}
+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 (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;
+    }
+  }
+}
+
+// src/hooks/use-run.ts
+var STREAMING_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "startStreamingReasoning",
+  "streamReasoning",
+  "completeStreamingReasoning",
+  "startStreamingRunResult",
+  "streamRunResult",
+  "completeStreamingRunResult"
+]);
+var 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": {
+      if (event.type !== "streamReasoning") {
+        return { newState: prevState, handled: false };
+      }
+      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": {
+      if (event.type !== "streamRunResult") {
+        return { newState: prevState, handled: false };
+      }
+      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 };
+  }
+}
+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
+  };
+}
+
+// src/types/runtime-state.ts
+function createInitialRuntimeState() {
+  return {
+    skills: /* @__PURE__ */ new Map(),
+    dockerContainers: /* @__PURE__ */ new Map(),
+    streaming: { runs: {} }
+  };
+}
+
+// src/hooks/use-runtime.ts
+var RUNTIME_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "initializeRuntime",
+  "skillStarting",
+  "skillConnected",
+  "skillDisconnected",
+  "skillStderr",
+  "dockerBuildProgress",
+  "dockerContainerStatus",
+  "proxyAccess"
+]);
+var isRuntimeEvent = (event) => "type" in event && RUNTIME_EVENT_TYPES.has(event.type);
+function useRuntime() {
+  const [runtimeState, setRuntimeState] = useState(createInitialRuntimeState);
+  const handleRuntimeEvent = useCallback((event) => {
+    if (!isRuntimeEvent(event)) {
+      return false;
+    }
+    switch (event.type) {
+      case "initializeRuntime": {
+        if (event.type !== "initializeRuntime") return false;
+        setRuntimeState((prev) => ({
+          ...prev,
+          query: event.query,
+          expertName: event.expertName,
+          model: event.model,
+          runtime: event.runtime,
+          runtimeVersion: event.runtimeVersion
+        }));
+        return true;
+      }
+      case "skillStarting": {
+        if (event.type !== "skillStarting") return false;
+        setRuntimeState((prev) => {
+          const skills = new Map(prev.skills);
+          skills.set(event.skillName, { name: event.skillName, status: "starting" });
+          return { ...prev, skills };
+        });
+        return true;
+      }
+      case "skillConnected": {
+        if (event.type !== "skillConnected") return false;
+        setRuntimeState((prev) => {
+          const skills = new Map(prev.skills);
+          skills.set(event.skillName, {
+            name: event.skillName,
+            status: "connected",
+            serverInfo: event.serverInfo
+          });
+          return { ...prev, skills };
+        });
+        return true;
+      }
+      case "skillDisconnected": {
+        if (event.type !== "skillDisconnected") return false;
+        setRuntimeState((prev) => {
+          const skills = new Map(prev.skills);
+          skills.set(event.skillName, { name: event.skillName, status: "disconnected" });
+          return { ...prev, skills };
+        });
+        return true;
+      }
+      case "skillStderr":
+        return true;
+      case "dockerBuildProgress": {
+        if (event.type !== "dockerBuildProgress") return false;
+        setRuntimeState((prev) => ({
+          ...prev,
+          dockerBuild: {
+            stage: event.stage,
+            service: event.service,
+            message: event.message,
+            progress: event.progress
+          }
+        }));
+        return true;
+      }
+      case "dockerContainerStatus": {
+        if (event.type !== "dockerContainerStatus") return false;
+        setRuntimeState((prev) => {
+          const dockerContainers = new Map(prev.dockerContainers);
+          dockerContainers.set(event.service, {
+            status: event.status,
+            service: event.service,
+            message: event.message
+          });
+          return { ...prev, dockerContainers };
+        });
+        return true;
+      }
+      case "proxyAccess": {
+        if (event.type !== "proxyAccess") return false;
+        setRuntimeState((prev) => ({
+          ...prev,
+          proxyAccess: {
+            action: event.action,
+            domain: event.domain,
+            port: event.port,
+            reason: event.reason
+          }
+        }));
+        return true;
+      }
+      default:
+        return false;
+    }
+  }, []);
+  const resetRuntimeState = useCallback(() => {
+    setRuntimeState(createInitialRuntimeState());
+  }, []);
+  return {
+    runtimeState,
+    handleRuntimeEvent,
+    resetRuntimeState
+  };
+}
+
+// src/utils/group-by-run.ts
+function getActivityProps(activityOrGroup) {
+  if (activityOrGroup.type === "parallelGroup") {
+    const firstActivity = activityOrGroup.activities[0];
+    return {
+      runId: activityOrGroup.runId,
+      expertKey: activityOrGroup.expertKey,
+      delegatedBy: firstActivity?.delegatedBy
+    };
+  }
+  return activityOrGroup;
+}
+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));
+}
+
+export { createInitialActivityProcessState, createInitialRuntimeState, groupActivitiesByRun, processRunEventToActivity, toolToActivity, useRun, useRuntime };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map