@agent-native/core 0.117.2 → 0.118.0

package/corpus/toolkit/src/chat-history/ChatHistoryRail.tsx

@@ -1,11 +1,17 @@
 import { IconDots, IconPlus } from "@tabler/icons-react";
-import { useEffect, useMemo, useState } from "react";
+import type { ReactNode } from "react";
 
+import { ActionButton, IconButton } from "../design-system/components.js";
+import { DesignSystemErrorBoundary } from "../design-system/error-boundary.js";
 import {
   ChatHistoryList,
   type ChatHistoryItem,
   type ChatHistoryListProps,
 } from "./ChatHistoryList.js";
+import {
+  type ChatHistoryRailController,
+  useChatHistoryRailController,
+} from "./useChatHistoryRailController.js";
 
 export interface ChatHistoryRailLabels {
   newChat: string;
@@ -22,63 +28,71 @@ export interface ChatHistoryRailProps extends Omit<
   railLabels: ChatHistoryRailLabels;
   previewCount?: number;
   expandedCount?: number;
+  /**
+   * Product-level presentation slot for design systems that want to replace
+   * the rail wholesale. State and actions still come from the same controller
+   * as the default view.
+   */
+  renderRail?: (context: ChatHistoryRailRenderContext) => ReactNode;
 }
 
-/**
- * Compact recent-chat rail for app sidebars. Hosts own thread persistence,
- * sorting, routing, and mutations; the rail only owns progressive disclosure.
- */
-export function ChatHistoryRail({
-  items,
-  onNewChat,
-  railLabels,
-  previewCount = 5,
-  expandedCount = 15,
-  className,
-  emptyLabel,
-  ...listProps
-}: ChatHistoryRailProps) {
-  const [expanded, setExpanded] = useState(false);
-  const collapsedLimit = Math.max(1, previewCount);
-  const expandedLimit = Math.max(collapsedLimit, expandedCount);
-  const canExpand = items.length > collapsedLimit;
-  const visibleItems = useMemo(
-    () => items.slice(0, expanded ? expandedLimit : collapsedLimit),
-    [collapsedLimit, expanded, expandedLimit, items],
-  );
+export interface ChatHistoryRailRenderContext {
+  controller: ChatHistoryRailController<ChatHistoryItem>;
+  listProps: Omit<
+    ChatHistoryListProps,
+    "footer" | "items" | "sections" | "variant"
+  >;
+}
 
-  useEffect(() => {
-    if (!canExpand) setExpanded(false);
-  }, [canExpand]);
+export type DefaultChatHistoryRailViewProps = ChatHistoryRailRenderContext;
+
+export function DefaultChatHistoryRailView({
+  controller,
+  listProps,
+}: ChatHistoryRailRenderContext) {
+  const {
+    canExpand,
+    disclosureLabel,
+    expanded,
+    newChatLabel,
+    onNewChat,
+    toggleExpanded,
+    visibleItems,
+  } = controller;
+  const { className, emptyLabel, ...rest } = listProps;
 
   const footer = (
     <div className="an-chat-history-rail__footer">
-      <button
+      <ActionButton
         type="button"
         className="an-chat-history-rail__new-chat"
-        onClick={onNewChat}
+        emphasis="ghost"
+        size="compact"
+        leadingIcon={
+          <IconPlus size={13} strokeWidth={1.8} aria-hidden="true" />
+        }
+        onPress={onNewChat}
       >
-        <IconPlus size={13} strokeWidth={1.8} aria-hidden="true" />
-        <span>{railLabels.newChat}</span>
-      </button>
+        <span>{newChatLabel}</span>
+      </ActionButton>
       {canExpand && (
-        <button
+        <IconButton
           type="button"
           className="an-chat-history-rail__disclosure"
-          onClick={() => setExpanded((current) => !current)}
+          size="compact"
+          icon={<IconDots size={14} strokeWidth={1.8} aria-hidden="true" />}
+          onPress={toggleExpanded}
           aria-expanded={expanded}
-          aria-label={expanded ? railLabels.showLess : railLabels.showMore}
-          title={expanded ? railLabels.showLess : railLabels.showMore}
-        >
-          <IconDots size={14} strokeWidth={1.8} aria-hidden="true" />
-        </button>
+          label={disclosureLabel}
+          title={disclosureLabel}
+        />
       )}
     </div>
   );
 
   return (
     <ChatHistoryList
-      {...listProps}
+      {...rest}
       items={visibleItems}
       footer={footer}
       emptyLabel={emptyLabel ?? null}
@@ -87,3 +101,50 @@ export function ChatHistoryRail({
     />
   );
 }
+
+/**
+ * Compact recent-chat rail for app sidebars. Hosts own thread persistence,
+ * sorting, routing, and mutations; the rail only owns progressive disclosure.
+ */
+export function ChatHistoryRail({
+  items,
+  onNewChat,
+  railLabels,
+  previewCount = 5,
+  expandedCount = 15,
+  renderRail,
+  className,
+  emptyLabel,
+  ...listProps
+}: ChatHistoryRailProps) {
+  const controller = useChatHistoryRailController({
+    items,
+    onNewChat,
+    labels: railLabels,
+    previewCount,
+    expandedCount,
+  });
+  const context: ChatHistoryRailRenderContext = {
+    controller,
+    listProps: { ...listProps, className, emptyLabel },
+  };
+  const fallback = <DefaultChatHistoryRailView {...context} />;
+
+  return renderRail ? (
+    <DesignSystemErrorBoundary component="ChatHistoryRail" fallback={fallback}>
+      <ChatHistoryRailCustomView renderRail={renderRail} context={context} />
+    </DesignSystemErrorBoundary>
+  ) : (
+    fallback
+  );
+}
+
+function ChatHistoryRailCustomView({
+  renderRail,
+  context,
+}: {
+  renderRail: NonNullable<ChatHistoryRailProps["renderRail"]>;
+  context: ChatHistoryRailRenderContext;
+}) {
+  return renderRail(context);
+}

package/corpus/toolkit/src/chat-history/index.ts

@@ -7,6 +7,15 @@ export {
 } from "./ChatHistoryList.js";
 export {
   ChatHistoryRail,
+  DefaultChatHistoryRailView,
+  type DefaultChatHistoryRailViewProps,
   type ChatHistoryRailLabels,
   type ChatHistoryRailProps,
+  type ChatHistoryRailRenderContext,
 } from "./ChatHistoryRail.js";
+export {
+  type ChatHistoryRailController,
+  type ChatHistoryRailControllerLabels,
+  type UseChatHistoryRailControllerOptions,
+  useChatHistoryRailController,
+} from "./useChatHistoryRailController.js";

package/corpus/toolkit/src/chat-history/useChatHistoryRailController.ts

@@ -0,0 +1,76 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+
+export interface ChatHistoryRailControllerLabels {
+  newChat: string;
+  showMore: string;
+  showLess: string;
+}
+
+export interface UseChatHistoryRailControllerOptions<Item> {
+  items: readonly Item[];
+  onNewChat: () => void;
+  labels: ChatHistoryRailControllerLabels;
+  previewCount?: number;
+  expandedCount?: number;
+}
+
+export interface ChatHistoryRailController<Item> {
+  expanded: boolean;
+  collapsedLimit: number;
+  expandedLimit: number;
+  visibleItems: Item[];
+  canExpand: boolean;
+  newChatLabel: string;
+  disclosureLabel: string;
+  onNewChat: () => void;
+  toggleExpanded: () => void;
+  resetExpanded: () => void;
+}
+
+function normalizeLimit(value: number | undefined, fallback: number): number {
+  if (value === undefined || !Number.isFinite(value)) return fallback;
+  return Math.max(1, Math.floor(value));
+}
+
+export function useChatHistoryRailController<Item>({
+  items,
+  onNewChat,
+  labels,
+  previewCount,
+  expandedCount,
+}: UseChatHistoryRailControllerOptions<Item>): ChatHistoryRailController<Item> {
+  const [expandedState, setExpandedState] = useState(false);
+  const collapsedLimit = normalizeLimit(previewCount, 5);
+  const expandedLimit = Math.max(
+    collapsedLimit,
+    normalizeLimit(expandedCount, 15),
+  );
+  const canExpand = items.length > collapsedLimit;
+  const expanded = canExpand && expandedState;
+  const visibleItems = useMemo(
+    () => items.slice(0, expanded ? expandedLimit : collapsedLimit),
+    [collapsedLimit, expanded, expandedLimit, items],
+  );
+
+  useEffect(() => {
+    if (!canExpand) setExpandedState(false);
+  }, [canExpand]);
+
+  const toggleExpanded = useCallback(() => {
+    if (canExpand) setExpandedState((current) => !current);
+  }, [canExpand]);
+  const resetExpanded = useCallback(() => setExpandedState(false), []);
+
+  return {
+    expanded,
+    collapsedLimit,
+    expandedLimit,
+    visibleItems,
+    canExpand,
+    newChatLabel: labels.newChat,
+    disclosureLabel: expanded ? labels.showLess : labels.showMore,
+    onNewChat,
+    toggleExpanded,
+    resetExpanded,
+  };
+}

package/corpus/toolkit/src/chat-history.css

@@ -113,12 +113,14 @@
   justify-content: center;
   flex: 0 0 auto;
   width: 30px;
+  height: auto;
   min-height: 30px;
 }
 
 .an-chat-history-rail__new-chat {
   flex: 1 1 auto;
   gap: 8px;
+  height: auto;
   min-width: 0;
   min-height: 30px;
   padding: 6px 10px;

package/corpus/toolkit/src/composer/ComposerPlusMenu.tsx

@@ -490,14 +490,17 @@ function ComposerPlusMenuFull({
       <Popover open={open} onOpenChange={setOpen}>
         <Tooltip>
           <TooltipTrigger asChild>
-            <PopoverTrigger asChild>
-              <button
-                type="button"
-                className="shrink-0 flex h-7 w-7 items-center justify-center rounded-md text-muted-foreground hover:text-foreground hover:bg-accent/50 disabled:opacity-30 disabled:cursor-not-allowed"
-              >
-                <IconPlus className="h-4 w-4" />
-              </button>
-            </PopoverTrigger>
+            <span className="inline-flex shrink-0">
+              <PopoverTrigger asChild>
+                <button
+                  type="button"
+                  aria-label="Add..."
+                  className="shrink-0 flex h-7 w-7 items-center justify-center rounded-md text-muted-foreground hover:text-foreground hover:bg-accent/50 disabled:opacity-30 disabled:cursor-not-allowed"
+                >
+                  <IconPlus className="h-4 w-4" />
+                </button>
+              </PopoverTrigger>
+            </span>
           </TooltipTrigger>
           <TooltipContent>Add...</TooltipContent>
         </Tooltip>

package/corpus/toolkit/src/composer/PromptComposer.tsx

@@ -519,6 +519,7 @@ function PromptComposerInner({
     resolvedModelStatusChecksEnabled,
   );
   const missingApiKey = agentEngineConfigured.missing;
+  const agentEngineUnavailable = agentEngineConfigured.state === "unavailable";
   const [missingKeyBouncePulse, setMissingKeyBouncePulse] = useState(0);
   const bounceMissingKeySetup = useCallback(() => {
     setMissingKeyBouncePulse((pulse) => pulse + 1);
@@ -542,8 +543,13 @@ function PromptComposerInner({
               timeoutMs: SUBMIT_ENGINE_STATUS_TIMEOUT_MS,
             },
           );
-    if (state !== "missing") return true;
-    bounceMissingKeySetup();
+    if (state === "missing") {
+      bounceMissingKeySetup();
+      return false;
+    }
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new Event("agent-engine:configured-changed"));
+    }
     return false;
   }, [
     agentEngineConfigured.state,
@@ -551,6 +557,11 @@ function PromptComposerInner({
     modelsAdapter,
     resolvedModelStatusChecksEnabled,
   ]);
+  const retryAgentEngineStatus = useCallback(() => {
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new Event("agent-engine:configured-changed"));
+    }
+  }, []);
 
   useEffect(() => {
     if (!autoFocus) return;
@@ -613,21 +624,31 @@ function PromptComposerInner({
       <AgentComposerFrame
         className={cn(
           "text-start",
-          missingApiKey && "cursor-pointer",
+          (missingApiKey || agentEngineUnavailable) && "cursor-pointer",
           className,
         )}
         rootClassName={rootClassName}
         style={style}
         rootStyle={rootStyle}
         layoutVariant={layoutVariant}
-        onClick={missingApiKey ? bounceMissingKeySetup : undefined}
+        onClick={
+          missingApiKey
+            ? bounceMissingKeySetup
+            : agentEngineUnavailable
+              ? retryAgentEngineStatus
+              : undefined
+        }
       >
         <PromptAttachmentStrip />
         <TiptapComposer
           focusRef={handleRef}
-          disabled={disabled || missingApiKey}
+          disabled={disabled || missingApiKey || agentEngineUnavailable}
           placeholder={
-            missingApiKey ? "Connect AI above to continue..." : placeholder
+            missingApiKey
+              ? "Connect AI above to continue..."
+              : agentEngineUnavailable
+                ? "Unable to check AI connection. Click to retry."
+                : placeholder
           }
           initialText={initialText}
           initialTextKey={initialTextKey}

package/corpus/toolkit/src/composer/useRealtimeVoiceMode.tsx

@@ -484,6 +484,75 @@ export function createRealtimeVoiceGreetingStarter(
   };
 }
 
+export interface RealtimeVoiceResponseCoordinator {
+  request: (event?: Record<string, unknown>) => void;
+  handleEvent: (event: RealtimeServerEvent) => void;
+  handleError: (message?: string) => boolean;
+  reset: () => void;
+}
+
+export function createRealtimeVoiceResponseCoordinator(
+  send: (event: Record<string, unknown>) => void,
+): RealtimeVoiceResponseCoordinator {
+  let active = false;
+  let requestInFlight = false;
+  let pending: Record<string, unknown> | undefined;
+
+  const flush = () => {
+    if (active || requestInFlight || !pending) return;
+    const event = pending;
+    pending = undefined;
+    requestInFlight = true;
+    send(event);
+  };
+
+  return {
+    request(event = { type: "response.create" }) {
+      pending = event;
+      flush();
+    },
+    handleEvent(event) {
+      if (event.type === "response.created") {
+        active = true;
+        requestInFlight = false;
+        return;
+      }
+      if (
+        event.type === "response.done" ||
+        event.type === "response.cancelled" ||
+        event.type === "response.failed"
+      ) {
+        active = false;
+        requestInFlight = false;
+        const response = event.response;
+        const status =
+          response && typeof response === "object"
+            ? (response as { status?: unknown }).status
+            : undefined;
+        if (event.type === "response.failed" || status === "failed") {
+          pending = undefined;
+          return;
+        }
+        flush();
+      }
+    },
+    handleError(message) {
+      if (!message || !/active response.*in progress/i.test(message)) {
+        return false;
+      }
+      pending ??= { type: "response.create" };
+      requestInFlight = false;
+      active = true;
+      return true;
+    },
+    reset() {
+      active = false;
+      requestInFlight = false;
+      pending = undefined;
+    },
+  };
+}
+
 /**
  * Voice mode owns the chat only temporarily. Restore the captured transcript
  * when it is still the user's active thread (or the chat has no active thread)
@@ -936,22 +1005,11 @@ export function createRealtimeVoiceToolManifestCoordinator(
 export function extractRealtimeVoiceFunctionCalls(
   event: RealtimeServerEvent,
 ): Array<{ name: string; callId: string; argumentsText: string }> {
-  if (event.type === "response.function_call_arguments.done") {
-    const name = typeof event.name === "string" ? event.name : "";
-    const callId = typeof event.call_id === "string" ? event.call_id : "";
-    if (!name || !callId) return [];
-    return [
-      {
-        name,
-        callId,
-        argumentsText:
-          typeof event.arguments === "string" ? event.arguments : "{}",
-      },
-    ];
-  }
   if (event.type !== "response.done") return [];
   const response = event.response;
   if (!response || typeof response !== "object") return [];
+  const status = (response as { status?: unknown }).status;
+  if (status !== undefined && status !== "completed") return [];
   const output = (response as { output?: unknown }).output;
   if (!Array.isArray(output)) return [];
   return output.flatMap((item) => {
@@ -1141,13 +1199,24 @@ function useRealtimeVoiceModeController(
   const preferencesHydratedRef = useRef(false);
   const preferencesEditedRef = useRef(false);
   const preferenceWriteChainRef = useRef<Promise<void>>(Promise.resolve());
-  const toolManifestCoordinator = useMemo(
+  const responseCoordinator = useMemo(
     () =>
-      createRealtimeVoiceToolManifestCoordinator((event) => {
+      createRealtimeVoiceResponseCoordinator((event) => {
         sendDataChannelEvent(channelRef.current, event);
       }),
     [],
   );
+  const toolManifestCoordinator = useMemo(
+    () =>
+      createRealtimeVoiceToolManifestCoordinator((event) => {
+        if (event.type === "response.create") {
+          responseCoordinator.request(event);
+        } else {
+          sendDataChannelEvent(channelRef.current, event);
+        }
+      }),
+    [responseCoordinator],
+  );
   const switchMicrophoneRef = useRef<
     (deviceId: string, force?: boolean) => Promise<void>
   >(async () => undefined);
@@ -1461,8 +1530,9 @@ function useRealtimeVoiceModeController(
     if (audioContext) void audioContext.close().catch(() => undefined);
     audioLevels.reset();
     handledCallsRef.current.clear();
+    responseCoordinator.reset();
     toolManifestCoordinator.reset();
-  }, [audioLevels, toolManifestCoordinator]);
+  }, [audioLevels, responseCoordinator, toolManifestCoordinator]);
 
   const fail = useCallback(
     (message: string, options?: { openKeySettings?: boolean }) => {
@@ -1537,13 +1607,14 @@ function useRealtimeVoiceModeController(
   const greetingStarter = useMemo(
     () =>
       createRealtimeVoiceGreetingStarter((event) => {
-        sendDataChannelEvent(channelRef.current, event);
+        responseCoordinator.request(event);
       }),
-    [],
+    [responseCoordinator],
   );
 
   const handleServerEvent = useCallback(
     (event: RealtimeServerEvent) => {
+      responseCoordinator.handleEvent(event);
       transcriptSequencer.handle(event);
       const sessionTools = extractRealtimeVoiceSessionTools(event);
       if (sessionTools) toolManifestCoordinator.setSessionTools(sessionTools);
@@ -1562,6 +1633,7 @@ function useRealtimeVoiceModeController(
         transition("listening");
       } else if (event.type === "input_audio_buffer.speech_stopped") {
         transition("working");
+        responseCoordinator.request();
       } else if (event.type === "response.created") {
         // From this point onward the response is committed to audio output, so
         // changing voices risks violating Realtime's per-session voice lock.
@@ -1593,12 +1665,20 @@ function useRealtimeVoiceModeController(
             ? (response as { status?: unknown }).status
             : undefined;
         if (status === "failed") {
-          fail(
-            copy?.errors.responseFailed ??
-              "OpenAI could not complete the voice response.",
-          );
+          transportGenerationRef.current += 1;
+          handledCallsRef.current.clear();
+          responseCoordinator.reset();
+          toolManifestCoordinator.reset();
+          transition("listening");
           return;
         }
+      } else if (event.type === "response.failed") {
+        transportGenerationRef.current += 1;
+        handledCallsRef.current.clear();
+        responseCoordinator.reset();
+        toolManifestCoordinator.reset();
+        transition("listening");
+        return;
       } else if (event.type === "error") {
         const detail = event.error;
         const message =
@@ -1619,6 +1699,10 @@ function useRealtimeVoiceModeController(
         ) {
           return;
         }
+        if (responseCoordinator.handleError(message)) {
+          transition("working");
+          return;
+        }
         fail(
           message ||
             copy?.errors.sessionFailed ||
@@ -1641,6 +1725,7 @@ function useRealtimeVoiceModeController(
       syncAppState,
       transcriptSequencer,
       transition,
+      responseCoordinator,
       toolManifestCoordinator,
       updateLivePreferences,
     ],