@dexto/tui 1.6.2

package/dist/hooks/useAgentEvents.cjs

@@ -0,0 +1,382 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useAgentEvents_exports = {};
+__export(useAgentEvents_exports, {
+  useAgentEvents: () => useAgentEvents
+});
+module.exports = __toCommonJS(useAgentEvents_exports);
+var import_react = require("react");
+var import_events = require("events");
+var import_core = require("@dexto/core");
+var import_idGenerator = require("../utils/idGenerator.js");
+function extractTextContent(content) {
+  return content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+}
+function useAgentEvents({
+  agent,
+  setMessages,
+  setPendingMessages,
+  setUi,
+  setSession,
+  setInput,
+  setApproval,
+  setApprovalQueue,
+  setQueuedMessages,
+  currentSessionId,
+  buffer
+}) {
+  const externalTriggerRef = (0, import_react.useRef)({ active: false, sessionId: null, messageId: null });
+  (0, import_react.useEffect)(() => {
+    const controller = new AbortController();
+    const { signal } = controller;
+    (0, import_events.setMaxListeners)(25, signal);
+    agent.on(
+      "llm:switched",
+      (payload) => {
+        if (payload.newConfig?.model) {
+          setSession((prev) => ({
+            ...prev,
+            modelName: (0, import_core.getModelDisplayName)(
+              payload.newConfig.model,
+              payload.newConfig.provider
+            )
+          }));
+        }
+      },
+      { signal }
+    );
+    agent.on(
+      "service:event",
+      (payload) => {
+        if (payload.service !== "orchestration" || payload.event !== "tasks-updated") {
+          return;
+        }
+        if (payload.sessionId && payload.sessionId !== currentSessionId) {
+          return;
+        }
+        const data = payload.data;
+        if (data.tasks) {
+          setUi((prev) => {
+            const runningCount = typeof data.runningCount === "number" ? data.runningCount : prev.backgroundTasksRunning;
+            return {
+              ...prev,
+              backgroundTasks: data.tasks ?? prev.backgroundTasks,
+              backgroundTasksRunning: runningCount
+            };
+          });
+        } else if (typeof data.runningCount === "number") {
+          setUi((prev) => ({
+            ...prev,
+            backgroundTasksRunning: data.runningCount ?? prev.backgroundTasksRunning
+          }));
+        }
+      },
+      { signal }
+    );
+    agent.on(
+      "tool:background",
+      (payload) => {
+        if (payload.sessionId !== currentSessionId) {
+          return;
+        }
+        const messageId = `tool-${payload.toolCallId}`;
+        setMessages(
+          (prev) => prev.map((message) => {
+            if (message.id !== messageId) {
+              return message;
+            }
+            return {
+              ...message,
+              toolStatus: "running",
+              toolResult: "Background task started",
+              isBackground: true
+            };
+          })
+        );
+      },
+      { signal }
+    );
+    agent.on(
+      "tool:background-completed",
+      (payload) => {
+        if (payload.sessionId !== currentSessionId) {
+          return;
+        }
+        const messageId = `tool-${payload.toolCallId}`;
+        setMessages(
+          (prev) => prev.map((message) => {
+            if (message.id !== messageId) {
+              return message;
+            }
+            return {
+              ...message,
+              toolStatus: "finished",
+              toolResult: "Background task completed",
+              isBackground: true
+            };
+          })
+        );
+      },
+      { signal }
+    );
+    agent.on(
+      "session:reset",
+      () => {
+        setMessages([]);
+        setApproval(null);
+        setApprovalQueue([]);
+        setQueuedMessages([]);
+        setUi((prev) => ({ ...prev, activeOverlay: "none" }));
+      },
+      { signal }
+    );
+    agent.on(
+      "session:created",
+      (payload) => {
+        if (payload.switchTo) {
+          if (process.stdout.isTTY) {
+            process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+          }
+          setMessages([]);
+          setPendingMessages([]);
+          setApproval(null);
+          setApprovalQueue([]);
+          setQueuedMessages([]);
+          buffer.setText("");
+          setInput((prev) => ({
+            ...prev,
+            value: "",
+            history: [],
+            historyIndex: -1,
+            draftBeforeHistory: "",
+            images: [],
+            pastedBlocks: [],
+            pasteCounter: 0
+          }));
+          if (payload.sessionId === null) {
+            setSession((prev) => ({ ...prev, id: null, hasActiveSession: false }));
+          } else {
+            setSession((prev) => ({
+              ...prev,
+              id: payload.sessionId,
+              hasActiveSession: true
+            }));
+          }
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "none",
+            historySearch: {
+              isActive: false,
+              query: "",
+              matchIndex: 0,
+              originalInput: "",
+              lastMatch: ""
+            }
+          }));
+        }
+      },
+      { signal }
+    );
+    agent.on(
+      "context:cleared",
+      () => {
+        setApproval(null);
+        setApprovalQueue([]);
+        setQueuedMessages([]);
+        setUi((prev) => ({ ...prev, activeOverlay: "none" }));
+      },
+      { signal }
+    );
+    agent.on(
+      "context:compacting",
+      (payload) => {
+        if (payload.sessionId !== currentSessionId) return;
+        setUi((prev) => ({ ...prev, isCompacting: true }));
+      },
+      { signal }
+    );
+    agent.on(
+      "context:compacted",
+      (payload) => {
+        if (payload.sessionId !== currentSessionId) return;
+        setUi((prev) => ({ ...prev, isCompacting: false }));
+        const reductionPercent = payload.originalTokens > 0 ? Math.round(
+          (payload.originalTokens - payload.compactedTokens) / payload.originalTokens * 100
+        ) : 0;
+        const compactionContent = `\u{1F4E6} Context compacted
+   ${payload.originalMessages} messages \u2192 ${payload.compactedMessages} messages
+   ~${payload.originalTokens.toLocaleString()} \u2192 ~${payload.compactedTokens.toLocaleString()} tokens (${reductionPercent}% reduction)`;
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: compactionContent,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+      },
+      { signal }
+    );
+    agent.on(
+      "message:queued",
+      (payload) => {
+        if (!payload.sessionId) return;
+        agent.getQueuedMessages(payload.sessionId).then((messages) => {
+          setQueuedMessages(messages);
+        }).catch(() => {
+        });
+      },
+      { signal }
+    );
+    agent.on(
+      "message:removed",
+      (payload) => {
+        setQueuedMessages((prev) => prev.filter((m) => m.id !== payload.id));
+      },
+      { signal }
+    );
+    agent.on(
+      "run:invoke",
+      (payload) => {
+        if (payload.sessionId !== currentSessionId) {
+          return;
+        }
+        const messageId = (0, import_idGenerator.generateMessageId)("assistant");
+        externalTriggerRef.current = {
+          active: true,
+          sessionId: payload.sessionId,
+          messageId
+        };
+        const promptText = extractTextContent(payload.content);
+        const sourceLabel = payload.source === "scheduler" ? "\u23F0 Scheduled Task" : payload.source === "a2a" ? "\u{1F916} A2A Request" : payload.source === "api" ? "\u{1F50C} API Request" : "\u{1F4E5} External Request";
+        const triggerTimestamp = /* @__PURE__ */ new Date();
+        const scheduleName = typeof payload.metadata?.scheduleName === "string" ? payload.metadata.scheduleName : null;
+        const triggerLabel = scheduleName ? `${sourceLabel}: ${scheduleName}` : sourceLabel;
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: triggerLabel,
+            timestamp: triggerTimestamp,
+            styledType: "external-trigger",
+            styledData: {
+              label: triggerLabel,
+              source: payload.source ?? "external",
+              timestamp: triggerTimestamp
+            }
+          },
+          {
+            id: (0, import_idGenerator.generateMessageId)("user"),
+            role: "user",
+            content: promptText,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+        setUi((prev) => ({
+          ...prev,
+          isProcessing: true,
+          isThinking: true
+        }));
+        setPendingMessages([
+          {
+            id: messageId,
+            role: "assistant",
+            content: "",
+            timestamp: /* @__PURE__ */ new Date(),
+            isStreaming: true
+          }
+        ]);
+      },
+      { signal }
+    );
+    agent.on(
+      "llm:chunk",
+      (payload) => {
+        if (!externalTriggerRef.current.active || payload.sessionId !== externalTriggerRef.current.sessionId) {
+          return;
+        }
+        if (payload.chunkType !== "text") {
+          return;
+        }
+        setPendingMessages(
+          (prev) => prev.map(
+            (msg) => msg.id === externalTriggerRef.current.messageId ? { ...msg, content: msg.content + payload.content } : msg
+          )
+        );
+        setUi((prev) => prev.isThinking ? { ...prev, isThinking: false } : prev);
+      },
+      { signal }
+    );
+    agent.on(
+      "llm:thinking",
+      (payload) => {
+        if (!externalTriggerRef.current.active || payload.sessionId !== externalTriggerRef.current.sessionId) {
+          return;
+        }
+        setUi((prev) => ({ ...prev, isThinking: true }));
+      },
+      { signal }
+    );
+    agent.on(
+      "run:complete",
+      (payload) => {
+        if (!externalTriggerRef.current.active || payload.sessionId !== externalTriggerRef.current.sessionId) {
+          return;
+        }
+        setPendingMessages((prev) => {
+          const pendingMsg = prev.find(
+            (m) => m.id === externalTriggerRef.current.messageId
+          );
+          if (pendingMsg) {
+            setMessages((msgs) => [...msgs, { ...pendingMsg, isStreaming: false }]);
+          }
+          return prev.filter((m) => m.id !== externalTriggerRef.current.messageId);
+        });
+        setUi((prev) => ({
+          ...prev,
+          isProcessing: false,
+          isThinking: false
+        }));
+        externalTriggerRef.current = { active: false, sessionId: null, messageId: null };
+      },
+      { signal }
+    );
+    return () => {
+      controller.abort();
+    };
+  }, [
+    agent,
+    setMessages,
+    setPendingMessages,
+    setUi,
+    setSession,
+    setInput,
+    setApproval,
+    setApprovalQueue,
+    setQueuedMessages,
+    currentSessionId,
+    buffer
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAgentEvents
+});

package/dist/hooks/useAgentEvents.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Hook for managing agent event bus subscriptions for NON-STREAMING events.
+ *
+ * Streaming events (llm:thinking, llm:chunk, llm:response, llm:tool-call, llm:tool-result,
+ * llm:error, run:complete, message:dequeued) are handled via agent.stream() iterator in processStream.
+ *
+ * This hook handles:
+ * - approval:request - Tool/command confirmation requests
+ * - llm:switched - Model change notifications
+ * - session:reset - Conversation reset
+ * - session:created - New session creation (e.g., from /clear)
+ * - context:compacting - Context compaction starting (from /compact or auto)
+ * - context:compacted - Context compaction finished
+ * - message:queued - New message added to queue
+ * - message:removed - Message removed from queue (e.g., up arrow edit)
+ * - run:invoke - External trigger (scheduler, A2A, API) starting a run
+ * - run:complete (for external triggers) - External run finished
+ *
+ * Uses AbortController pattern for cleanup.
+ */
+import type React from 'react';
+import { type DextoAgent, type QueuedMessage } from '@dexto/core';
+import type { Message, UIState, SessionState, InputState } from '../state/types.js';
+import type { ApprovalRequest } from '../components/ApprovalPrompt.js';
+import type { TextBuffer } from '../components/shared/text-buffer.js';
+interface UseAgentEventsProps {
+    agent: DextoAgent;
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+    setPendingMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+    setUi: React.Dispatch<React.SetStateAction<UIState>>;
+    setSession: React.Dispatch<React.SetStateAction<SessionState>>;
+    setInput: React.Dispatch<React.SetStateAction<InputState>>;
+    setApproval: React.Dispatch<React.SetStateAction<ApprovalRequest | null>>;
+    setApprovalQueue: React.Dispatch<React.SetStateAction<ApprovalRequest[]>>;
+    setQueuedMessages: React.Dispatch<React.SetStateAction<QueuedMessage[]>>;
+    /** Current session ID for filtering events */
+    currentSessionId: string | null;
+    /** Text buffer for input (source of truth) - needed to clear on session reset */
+    buffer: TextBuffer;
+}
+/**
+ * Subscribes to agent event bus for non-streaming events only.
+ * Streaming events are handled via agent.stream() iterator.
+ *
+ * Also handles external triggers (run:invoke) from scheduler, A2A, etc.
+ */
+export declare function useAgentEvents({ agent, setMessages, setPendingMessages, setUi, setSession, setInput, setApproval, setApprovalQueue, setQueuedMessages, currentSessionId, buffer, }: UseAgentEventsProps): void;
+export {};
+//# sourceMappingURL=useAgentEvents.d.ts.map

package/dist/hooks/useAgentEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAgentEvents.d.ts","sourceRoot":"","sources":["../../src/hooks/useAgentEvents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,EAEH,KAAK,UAAU,EACf,KAAK,aAAa,EAErB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEtE,UAAU,mBAAmB;IACzB,KAAK,EAAE,UAAU,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAC7D,kBAAkB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACpE,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IACrD,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;IAC3D,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC,CAAC;IAC1E,gBAAgB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;IAC1E,iBAAiB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;IACzE,8CAA8C;IAC9C,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,iFAAiF;IACjF,MAAM,EAAE,UAAU,CAAC;CACtB;AAYD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAC3B,KAAK,EACL,WAAW,EACX,kBAAkB,EAClB,KAAK,EACL,UAAU,EACV,QAAQ,EACR,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,MAAM,GACT,EAAE,mBAAmB,GAAG,IAAI,CA6d5B"}