cortena-ui 1.6.0 → 1.7.0

package/src/agent-chat/store.ts

@@ -44,6 +44,7 @@ import type {
   AgentChatEvent,
   AgentChatHistoryResponse,
   AgentChatMessage,
+  AgentChatSendInput,
   AgentChatStep,
   AgentSession,
   AgentSessionsListResponse,
@@ -141,7 +142,18 @@ type Action =
   | { kind: "approval/denied"; id: string }
   | { kind: "approval/failed"; request: AgentApprovalRequest; message: string }
   | { kind: "session"; key: string | null }
-  | { kind: "send"; message: AgentChatMessage | null; runId: string; sessionKey: string }
+  | {
+      kind: "send";
+      message: AgentChatMessage | null;
+      runId: string;
+      sessionKey: string;
+      /**
+       * A regenerate: no new bubble, but the user turn being asked again is
+       * moved onto this run by id, so the transcript still reads Q then A.
+       */
+      reanchor?: string;
+    }
+  | { kind: "message/remove"; id: string }
   | { kind: "send/failed"; message: string }
   | { kind: "abort" }
   | { kind: "history/loading" }
@@ -152,7 +164,13 @@ type Action =
       hasMore: boolean;
       records: number;
     }
-  | { kind: "history/older"; messages: AgentChatMessage[]; hasMore: boolean; records: number }
+  | {
+      kind: "history/older";
+      sessionKey: string;
+      messages: AgentChatMessage[];
+      hasMore: boolean;
+      records: number;
+    }
   | { kind: "history/failed" }
   | { kind: "sessions/loading" }
   | { kind: "sessions/loaded"; sessions: AgentSession[] }
@@ -218,7 +236,13 @@ function reduce(state: AgentChatState, action: Action): AgentChatState {
       return {
         ...state,
         sessionKey: action.sessionKey,
-        messages: action.message ? [...state.messages, action.message] : state.messages,
+        messages: action.message
+          ? [...state.messages, action.message]
+          : action.reanchor
+            ? state.messages.map((m) =>
+                m.id === action.reanchor ? { ...m, runId: action.runId } : m,
+              )
+            : state.messages,
         streaming: true,
         streamText: "",
         streamThinkingText: "",
@@ -237,6 +261,10 @@ function reduce(state: AgentChatState, action: Action): AgentChatState {
         approvals: [],
         error: null,
       };
+    case "message/remove":
+      // The bubble a regenerate replaces. Dropped before the new run starts so
+      // the answer takes its place rather than appending a second one.
+      return { ...state, messages: state.messages.filter((m) => m.id !== action.id) };
     case "send/failed":
       return {
         ...state,
@@ -273,6 +301,16 @@ function reduce(state: AgentChatState, action: Action): AgentChatState {
     case "history/loading":
       return { ...state, loadingHistory: true };
     case "history/loaded":
+      // A load for a session that is no longer the one on screen. Two loads
+      // race whenever a host switches sessions quickly — resume A, resume B,
+      // A's reply lands last — and applying it put A's transcript under B's
+      // key. The load that matters is the one for the CURRENT key; every other
+      // reply is stale and is dropped whole. `null` is included on purpose: a
+      // host that cleared the session while a load was in flight must not be
+      // put back into it by the reply.
+      if (action.sessionKey !== state.sessionKey) {
+        return { ...state, loadingHistory: false };
+      }
       if (
         wouldShrinkHistory({
           currentSessionKey: state.sessionKey,
@@ -303,6 +341,13 @@ function reduce(state: AgentChatState, action: Action): AgentChatState {
         streamA2ui: [],
       };
     case "history/older":
+      // The same rule as `history/loaded`: a page that was asked for under a
+      // key that is no longer the current one — the host switched sessions
+      // while it was in flight — must not be prepended to the transcript
+      // that is on screen now.
+      if (action.sessionKey !== state.sessionKey) {
+        return { ...state, loadingHistory: false };
+      }
       return {
         ...state,
         messages: [...action.messages, ...state.messages],
@@ -929,16 +974,68 @@ export interface UseAgentChatOptions {
   /** Skip reading and writing `sessionStorage`; for a transient mount. */
   ephemeral?: boolean;
   thinking?: "low" | "medium" | "high";
+  /**
+   * Mint the key for a brand-new session. Defaults to `mintSessionKey(client.agentId)`,
+   * which binds the session to this client's agent template. A host whose
+   * sessions are bound some other way — cortenaweb lets the user pick an agent
+   * per chat, and a chat with no pick is bound server-side to the default —
+   * supplies its own.
+   */
+  mintSessionKey?: () => string;
+  /**
+   * Read the stored session key back on mount. Default `true`. A host whose
+   * URL names the session — `/chat/<key>` — is the source of truth itself and
+   * passes `false`: the key is still WRITTEN, so the rule "one window, one
+   * session" holds, but nothing is restored under the URL's feet and no
+   * history is fetched for a session the page is about to leave.
+   */
+  restoreSession?: boolean;
+  /**
+   * Fetch `sessions.list` on mount and after each send. Default `true`. A host
+   * with its own session list — cortenaweb's sidebar — passes `false` and the
+   * hook makes no session calls at all; `sessions` stays empty.
+   */
+  listSessions?: boolean;
+}
+
+/** What `send` accepts beside the text and the attachments. */
+export interface AgentChatSendOptions {
+  /** The model for this run; the composer's selector. */
+  model?: AgentChatSendInput["model"];
+  /** Overrides the hook-level `thinking` for this run. */
+  thinking?: AgentChatSendInput["thinking"];
 }
 
 export interface UseAgentChatResult extends AgentChatState {
-  send: (text: string, attachments?: unknown[]) => void;
+  send: (text: string, attachments?: unknown[], options?: AgentChatSendOptions) => void;
   sendAction: (action: NonNullable<Parameters<AgentChatClient["send"]>[0]["a2uiAction"]>) => void;
+  /** A click inside a rendered MCP App, as the next run's input. No user bubble. */
+  sendMcpAppAction: (action: NonNullable<AgentChatSendInput["mcpAppAction"]>) => void;
   abort: () => void;
   resolveApproval: (id: string, decision: AgentApprovalDecision) => void;
   newSession: () => void;
   resumeSession: (key: string) => void;
-  loadOlder: () => void;
+  /**
+   * Leave the session without starting another. The transcript empties, the
+   * stored key is removed and the next `send` mints a fresh key — which is
+   * what a host's "New chat" wants when the URL should not change until the
+   * first message goes out. `newSession` mints immediately; this does not.
+   */
+  clearSession: () => void;
+  /**
+   * Ask again for the message this one answered: the bubble is dropped and the
+   * user turn before it is sent again, so the new answer takes its place. Also
+   * the Retry on a failed turn. A no-op while a run is live or when nothing
+   * precedes the message.
+   */
+  regenerate: (messageId: string) => void;
+  /**
+   * Ask for the next page of older history. `true` when a load was started;
+   * `false` when there is nothing to do — no session, a load already in
+   * flight, or no more history — so a caller that saves scroll position
+   * before a prepend knows whether one is coming.
+   */
+  loadOlder: () => boolean;
   refreshSessions: () => void;
 }
 
@@ -947,6 +1044,9 @@ export function useAgentChat({
   storageScope,
   ephemeral,
   thinking,
+  mintSessionKey: mintKey,
+  restoreSession = true,
+  listSessions = true,
 }: UseAgentChatOptions): UseAgentChatResult {
   const [state, dispatch] = React.useReducer(reduce, EMPTY);
   const stateRef = React.useRef(state);
@@ -973,6 +1073,9 @@ export function useAgentChat({
   }, [client]);
 
   const refreshSessions = React.useCallback(() => {
+    if (!listSessions) {
+      return;
+    }
     dispatch({ kind: "sessions/loading" });
     void client
       .request<AgentSessionsListResponse>("sessions.list", { includeDerivedTitles: true })
@@ -988,7 +1091,7 @@ export function useAgentChat({
         dispatch({ kind: "sessions/loaded", sessions: [] });
         dispatch({ kind: "error", message: errorText(err) });
       });
-  }, [client]);
+  }, [client, listSessions]);
 
   const loadHistory = React.useCallback(
     (sessionKey: string) => {
@@ -1018,7 +1121,7 @@ export function useAgentChat({
       return;
     }
     restored.current = true;
-    const stored = ephemeral ? null : readStoredSessionKey(storageScope);
+    const stored = ephemeral || !restoreSession ? null : readStoredSessionKey(storageScope);
     const key = stored && isSessionOfAgent(stored, client.agentId) ? stored : null;
     if (key) {
       dispatch({ kind: "session", key });
@@ -1032,7 +1135,7 @@ export function useAgentChat({
       loadHistory(key);
     }
     refreshSessions();
-  }, [client, ephemeral, loadHistory, refreshSessions, storageScope]);
+  }, [client, ephemeral, loadHistory, refreshSessions, restoreSession, storageScope]);
 
   /**
    * Keep the per-window store in step with the strip, on a debounce.
@@ -1086,7 +1189,12 @@ export function useAgentChat({
   );
 
   const run = React.useCallback(
-    (text: string, extra: Partial<Parameters<AgentChatClient["send"]>[0]> = {}) => {
+    (
+      text: string,
+      extra: Partial<Parameters<AgentChatClient["send"]>[0]> = {},
+      /** The user message this run asks again, instead of a new bubble. */
+      reanchor?: string,
+    ) => {
       const current = stateRef.current;
       // One run at a time. A second `send` on a streaming session opens a
       // second stream into one store: two sets of deltas overwrite each
@@ -1097,7 +1205,8 @@ export function useAgentChat({
       if (current.streaming) {
         return;
       }
-      const sessionKey = current.sessionKey ?? mintSessionKey(client.agentId);
+      const sessionKey =
+        current.sessionKey ?? (mintKey ? mintKey() : mintSessionKey(client.agentId));
       if (!current.sessionKey && !ephemeral) {
         writeStoredSessionKey(storageScope, sessionKey);
       }
@@ -1106,10 +1215,19 @@ export function useAgentChat({
       // for it would put `{"name":"createTask"}` in the transcript as though
       // the user had said it.
       const message: AgentChatMessage | null =
-        text || (!extra.a2uiAction && !extra.mcpAppAction)
-          ? { id: runId, role: "user", text, timestamp: Date.now(), runId }
+        !reanchor && (text || (!extra.a2uiAction && !extra.mcpAppAction))
+          ? {
+              id: runId,
+              role: "user",
+              text,
+              timestamp: Date.now(),
+              runId,
+              // On the bubble from the start, so the host's strip draws what
+              // was attached before the transcript is persisted.
+              ...(extra.attachments?.length ? { attachmentItems: extra.attachments } : {}),
+            }
           : null;
-      dispatch({ kind: "send", message, runId, sessionKey });
+      dispatch({ kind: "send", message, runId, sessionKey, ...(reanchor ? { reanchor } : {}) });
       void client
         .send({
           sessionKey,
@@ -1121,12 +1239,16 @@ export function useAgentChat({
         .then(() => refreshSessions())
         .catch((err: unknown) => dispatch({ kind: "send/failed", message: errorText(err) }));
     },
-    [client, ephemeral, refreshSessions, storageScope, thinking],
+    [client, ephemeral, mintKey, refreshSessions, storageScope, thinking],
   );
 
   const send = React.useCallback(
-    (text: string, attachments?: unknown[]) => {
-      run(text, attachments?.length ? { attachments } : {});
+    (text: string, attachments?: unknown[], options?: AgentChatSendOptions) => {
+      run(text, {
+        ...(attachments?.length ? { attachments } : {}),
+        ...(options?.model ? { model: options.model } : {}),
+        ...(options?.thinking ? { thinking: options.thinking } : {}),
+      });
     },
     [run],
   );
@@ -1138,6 +1260,43 @@ export function useAgentChat({
     [run],
   );
 
+  const sendMcpAppAction = React.useCallback(
+    (mcpAppAction: NonNullable<AgentChatSendInput["mcpAppAction"]>) => {
+      run("", { mcpAppAction });
+    },
+    [run],
+  );
+
+  const regenerate = React.useCallback(
+    (messageId: string) => {
+      const { messages, streaming } = stateRef.current;
+      if (streaming) {
+        return;
+      }
+      const index = messages.findIndex((m) => m.id === messageId);
+      if (index < 1) {
+        return;
+      }
+      let question: AgentChatMessage | null = null;
+      for (let i = index - 1; i >= 0; i -= 1) {
+        const candidate = messages[i];
+        if (candidate?.role === "user" && !candidate.isToolMessage) {
+          question = candidate;
+          break;
+        }
+      }
+      if (question === null) {
+        return;
+      }
+      dispatch({ kind: "message/remove", id: messageId });
+      // The question is already in the transcript. It is re-sent, not
+      // re-drawn: the existing bubble is moved onto the new run so the
+      // transcript reads Q then the new A, not Q, Q, A.
+      run(question.text, {}, question.id);
+    },
+    [run],
+  );
+
   const abort = React.useCallback(() => {
     const { runId, sessionKey } = stateRef.current;
     dispatch({ kind: "abort" });
@@ -1180,8 +1339,15 @@ export function useAgentChat({
   );
 
   const newSession = React.useCallback(() => {
-    setSession(mintSessionKey(client.agentId));
-  }, [client, setSession]);
+    setSession(mintKey ? mintKey() : mintSessionKey(client.agentId));
+  }, [client, mintKey, setSession]);
+
+  const clearSession = React.useCallback(() => {
+    dispatch({ kind: "session", key: null });
+    if (!ephemeral) {
+      writeStoredSessionKey(storageScope, null);
+    }
+  }, [ephemeral, storageScope]);
 
   const resumeSession = React.useCallback(
     (key: string) => {
@@ -1191,15 +1357,16 @@ export function useAgentChat({
     [loadHistory, setSession],
   );
 
-  const loadOlder = React.useCallback(() => {
+  const loadOlder = React.useCallback((): boolean => {
     const current = stateRef.current;
     if (!current.sessionKey || current.loadingHistory || !current.hasMoreHistory) {
-      return;
+      return false;
     }
+    const sessionKey = current.sessionKey;
     dispatch({ kind: "history/loading" });
     void client
       .request<AgentChatHistoryResponse>("chat.history", {
-        sessionKey: current.sessionKey,
+        sessionKey,
         limit: 100,
         // Records, not bubbles. See `historyCount`.
         offset: current.historyCount,
@@ -1208,22 +1375,27 @@ export function useAgentChat({
         const records = response?.messages ?? [];
         dispatch({
           kind: "history/older",
+          sessionKey,
           messages: parseHistoryMessages(records),
           hasMore: response?.hasMore ?? false,
           records: records.length,
         });
       })
       .catch(() => dispatch({ kind: "history/failed" }));
+    return true;
   }, [client]);
 
   return {
     ...state,
     send,
     sendAction,
+    sendMcpAppAction,
     abort,
     resolveApproval,
     newSession,
     resumeSession,
+    clearSession,
+    regenerate,
     loadOlder,
     refreshSessions,
   };

package/src/agent-chat/types.ts

@@ -57,7 +57,18 @@ export interface AgentChatMessage {
   role: "user" | "assistant";
   text: string;
   timestamp: number;
+  /** Attachment names or references, as a transcript record carries them. */
   attachments?: string[];
+  /**
+   * What the user attached to this turn, as the host's composer shaped it.
+   * `unknown[]` because the shape is the host's — cortenaweb sends
+   * `{ fileName, mimeType, content }` objects — and this package only asks
+   * whether there are any. Set on the user message `send` adds, so the bubble
+   * can draw the strip before the transcript is persisted. Separate from
+   * `attachments` so that field keeps its `string[]` shape for every consumer
+   * already reading it.
+   */
+  attachmentItems?: unknown[];
   /** The chain of thought behind this turn, collapsed by default. */
   thinkingText?: string;
   isError?: boolean;

package/src/components/agent-chat-popup.tsx

@@ -40,7 +40,7 @@ import { Maximize2, Minimize2, X } from "lucide-react";
 import * as React from "react";
 import { BrandMark } from "@/components/app-shell";
 import { Button } from "@/components/button";
-import { AgentChat, type AgentChatProps } from "@/components/agent-chat";
+import { AgentChat, type AgentChatOwnedProps } from "@/components/agent-chat";
 import { viewStorageKey, windowSessionStorage } from "@/agent-chat/session";
 import type { AgentChatClient } from "@/agent-chat/types";
 import { cn } from "@/lib/cn";
@@ -56,8 +56,8 @@ export interface AgentChatPopupExtension {
 
 export interface AgentChatPopupProps
   extends Omit<
-    AgentChatProps,
-    "agentName" | "storageScope" | "className" | "headerSlot" | "client"
+    AgentChatOwnedProps,
+    "agentName" | "storageScope" | "className" | "headerSlot" | "client" | "chat"
   > {
   extension: AgentChatPopupExtension;
   /** The transport. Its `agentId` is the template slug the sessions belong to. */