@mgamadeus/ddd-agents 0.1.0-alpha.23 → 0.1.0-alpha.24

package/dist/chunks/ConversationMessageInputComposerWidgets-BxyaFBA6.js

@@ -0,0 +1,631 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useSyncExternalStore, useContext, createContext, useMemo, useState, useRef, useEffect } from "react";
+import { a3 as useAgentsEnvironment, a6 as useAgentsStateDispatch, a7 as useAgentsStateSelector, z as classNames } from "./index-7Qc_3GbG.js";
+import { e as applySetCanvasCreatedEntityId, a as applyClearCanvas, d as applyResetCanvasForNewTurn, b as applyCloseCanvas, c as applyOpenCanvas } from "./canvas-reducers-Bfp_i7lc.js";
+import { T as CANVAS_VIABLE_MIN_WIDTH, h as ConversationWidgetContext, E as useConversationWidgetContext } from "./WebSearchResultsConversationWidget-as3p5bHw.js";
+import { s as storeOpenCanvas, c as clearStoredCanvas } from "./canvasStorage-EvQsGdto.js";
+import { j as conversationWidgetRegistry } from "./widget-name-resolver-BGN3HpoG.js";
+const EMPTY_AGENTS_CHAT_OPENING_REQUEST = {
+  userMessage: null,
+  startSignalText: null,
+  entryPointKey: null,
+  deepLinkedWidgetName: null
+};
+const INITIAL_AGENTS_CHAT_STATE = {
+  conversation: null,
+  messages: null,
+  conversationLoading: false,
+  conversationLoaded: false,
+  hasMoreOlder: false,
+  aiThinking: false,
+  error: null,
+  rateLimitRetryAfterSeconds: null,
+  requestedConversationId: null,
+  startingNewConversation: false,
+  pendingStartToken: null,
+  startTokenCount: 0,
+  openingRequest: EMPTY_AGENTS_CHAT_OPENING_REQUEST,
+  canvas: null,
+  lastClosedCanvas: null,
+  canvasMountCount: 0
+};
+const ConversationErrorType = {
+  AI_BUDGET: "AI_BUDGET",
+  /**
+   * HTTP 429 from an AI endpoint — a per-minute/hour/day usage quota was hit. Distinct from AI_BUDGET (monthly budget):
+   * this one clears on its own after the Retry-After window.
+   */
+  RATE_LIMIT: "RATE_LIMIT",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  CONVERSATION_NOT_FOUND: "CONVERSATION_NOT_FOUND",
+  /**
+   * The backend run FAILED (e.g. the model provider returned an error). The raw provider error is admin-only (never
+   * shown here); the owner gets a generic "something went wrong" card.
+   */
+  AGENT_ERROR: "AGENT_ERROR",
+  /**
+   * The conversation is COMPLETED/CANCELLED and refuses further owner input. Set from the server's stable error code
+   * `CONVERSATION_CLOSED` or by the chat's own pre-send guard; the error card owns the copy.
+   */
+  CONVERSATION_CLOSED: "CONVERSATION_CLOSED"
+};
+const readConversationErrorTypeOfRefusedSend = (error) => {
+  if (error.kind === "budget") return ConversationErrorType.AI_BUDGET;
+  if (error.kind === "rateLimit") return ConversationErrorType.RATE_LIMIT;
+  if (error.kind === "closed") return ConversationErrorType.CONVERSATION_CLOSED;
+  return ConversationErrorType.NETWORK_ERROR;
+};
+const mergeChatMessagesByIndex = (existing, incoming) => {
+  const messagesByIndex = /* @__PURE__ */ new Map();
+  const messagesWithoutIndex = [];
+  const collectMessage = (message) => {
+    if (message.indexInConversation != null) {
+      messagesByIndex.set(message.indexInConversation, message);
+    } else {
+      messagesWithoutIndex.push(message);
+    }
+  };
+  existing.forEach(collectMessage);
+  incoming.forEach(collectMessage);
+  const indexedMessages = Array.from(messagesByIndex.values()).sort(
+    (first, second) => (first.indexInConversation ?? 0) - (second.indexInConversation ?? 0)
+  );
+  return [...indexedMessages, ...messagesWithoutIndex];
+};
+const tagFreshChatMessages = (incoming, previousMessages) => {
+  const previousIds = new Set(previousMessages.map((message) => message.id).filter((id) => id != null));
+  return incoming.map((message) => ({ ...message, fresh: message.id != null && !previousIds.has(message.id) }));
+};
+const mergeMessagesPage = (loadedMessages, page, requestedConversationId) => {
+  const shownConversationId = loadedMessages?.find((message) => message.conversationId != null)?.conversationId;
+  const replacesShownConversation = shownConversationId != null && shownConversationId !== requestedConversationId;
+  const existingMessages = replacesShownConversation ? [] : loadedMessages ?? [];
+  const messagesByIndex = /* @__PURE__ */ new Map();
+  for (const existingMessage of existingMessages) {
+    if (existingMessage.indexInConversation != null) {
+      messagesByIndex.set(existingMessage.indexInConversation, existingMessage);
+    }
+  }
+  const hadMessagesBeforeMerge = existingMessages.length > 0;
+  const highestShownIndex = Math.max(-1, ...existingMessages.map((message) => message.indexInConversation ?? -1));
+  for (const incomingMessage of page) {
+    if (incomingMessage.indexInConversation == null) continue;
+    const previousMessage = messagesByIndex.get(incomingMessage.indexInConversation);
+    const isLiveArrival = hadMessagesBeforeMerge && previousMessage == null && incomingMessage.indexInConversation > highestShownIndex;
+    messagesByIndex.set(incomingMessage.indexInConversation, {
+      ...incomingMessage,
+      fresh: previousMessage?.fresh ?? isLiveArrival
+    });
+  }
+  return Array.from(messagesByIndex.values()).sort(
+    (first, second) => (first.indexInConversation ?? 0) - (second.indexInConversation ?? 0)
+  );
+};
+const withRefusedSendError = (state, error) => {
+  const conversationErrorType = readConversationErrorTypeOfRefusedSend(error);
+  return {
+    ...state,
+    error: conversationErrorType,
+    rateLimitRetryAfterSeconds: conversationErrorType === ConversationErrorType.RATE_LIMIT ? error.retryAfterSeconds ?? null : null
+  };
+};
+const mergeSendAnswer = (loadedMessages, answerMessages) => {
+  const messagesWithoutOptimisticMessage = loadedMessages ? loadedMessages.slice(0, loadedMessages.length - 1) : [];
+  return mergeChatMessagesByIndex(
+    messagesWithoutOptimisticMessage,
+    tagFreshChatMessages(answerMessages, messagesWithoutOptimisticMessage)
+  );
+};
+const withCanvasTransition = (state, applyCanvasTransition) => {
+  const nextState = { ...state };
+  applyCanvasTransition(nextState);
+  const changed = nextState.canvas !== state.canvas || nextState.lastClosedCanvas !== state.lastClosedCanvas || nextState.canvasMountCount !== state.canvasMountCount;
+  return changed ? nextState : state;
+};
+const reduceAgentsChatState = (state, event) => {
+  switch (event.type) {
+    case "reset":
+      return {
+        ...INITIAL_AGENTS_CHAT_STATE,
+        openingRequest: state.openingRequest,
+        canvasMountCount: state.canvasMountCount,
+        startTokenCount: state.startTokenCount
+      };
+    case "conversationMetadataRequested":
+    case "messagesPageRequested":
+      return state.requestedConversationId === event.conversationId ? state : { ...state, requestedConversationId: event.conversationId };
+    case "conversationMetadataReceived":
+      if (state.requestedConversationId === null || state.requestedConversationId !== event.conversationId) {
+        return state;
+      }
+      return { ...state, conversation: event.conversation, conversationLoaded: true };
+    case "conversationMetadataFailed":
+      return { ...state, conversationLoaded: true };
+    case "messagesPageReceived": {
+      if (state.requestedConversationId === null || state.requestedConversationId !== event.conversationId) {
+        return state;
+      }
+      if (state.conversation !== null && state.conversation.id !== event.conversationId) {
+        return state;
+      }
+      return {
+        ...state,
+        messages: mergeMessagesPage(state.messages, event.messages, event.conversationId),
+        hasMoreOlder: event.hasMoreOlder ?? state.hasMoreOlder,
+        conversationLoaded: true
+      };
+    }
+    case "messagePostRequested":
+      return {
+        ...state,
+        conversationLoading: true,
+        conversationLoaded: false,
+        aiThinking: true,
+        error: null,
+        rateLimitRetryAfterSeconds: null,
+        messages: [...state.messages ?? [], event.message]
+      };
+    case "messagePostReceived":
+      if (event.conversationId !== state.conversation?.id) {
+        return state;
+      }
+      return {
+        ...state,
+        messages: mergeSendAnswer(state.messages, event.posted.messages),
+        conversationLoading: false,
+        conversationLoaded: true,
+        error: null
+      };
+    case "messagePostFailed":
+      return withRefusedSendError(
+        { ...state, conversationLoading: false, conversationLoaded: true, aiThinking: false },
+        event.error
+      );
+    case "startRequested":
+      return {
+        ...state,
+        conversation: null,
+        conversationLoading: true,
+        conversationLoaded: false,
+        aiThinking: true,
+        error: null,
+        rateLimitRetryAfterSeconds: null,
+        startingNewConversation: true,
+        startTokenCount: state.startTokenCount + 1,
+        pendingStartToken: state.startTokenCount + 1,
+        // A signal-only start (an empty visible message carries the start signal) seeds no empty bubble.
+        messages: event.message.message ? [event.message] : []
+      };
+    case "startReceived": {
+      if (event.startToken !== state.pendingStartToken) {
+        return state;
+      }
+      const { started } = event;
+      if (started.reopenedExisting) {
+        return {
+          ...state,
+          conversation: started.conversation,
+          messages: [],
+          conversationLoading: false,
+          conversationLoaded: true,
+          aiThinking: false,
+          startingNewConversation: false,
+          pendingStartToken: null
+        };
+      }
+      return {
+        ...state,
+        conversation: started.conversation,
+        messages: mergeSendAnswer(state.messages, started.messages),
+        conversationLoading: false,
+        conversationLoaded: true,
+        startingNewConversation: false,
+        pendingStartToken: null
+      };
+    }
+    case "startFailed":
+      return withRefusedSendError(
+        {
+          ...state,
+          conversation: null,
+          conversationLoading: false,
+          conversationLoaded: true,
+          aiThinking: false,
+          startingNewConversation: false,
+          pendingStartToken: null
+        },
+        event.error
+      );
+    case "errorSet":
+      return state.error === event.error ? state : { ...state, error: event.error };
+    case "aiThinkingSet":
+      return state.aiThinking === event.aiThinking ? state : { ...state, aiThinking: event.aiThinking };
+    case "openingRequestSet":
+      return { ...state, openingRequest: { ...state.openingRequest, ...event.openingRequest } };
+    case "canvasOpened":
+      return withCanvasTransition(state, (nextState) => {
+        applyOpenCanvas(nextState, event.request);
+      });
+    case "canvasClosed":
+      return withCanvasTransition(state, (nextState) => applyCloseCanvas(nextState, event.byCustomer));
+    case "canvasResetForNewTurn":
+      return withCanvasTransition(state, applyResetCanvasForNewTurn);
+    case "canvasCleared":
+      return withCanvasTransition(state, applyClearCanvas);
+    case "canvasCreatedEntityIdSet":
+      return withCanvasTransition(state, (nextState) => {
+        applySetCanvasCreatedEntityId(nextState, event.created);
+      });
+  }
+};
+class AgentsChatStateContainer {
+  constructor(initialState = INITIAL_AGENTS_CHAT_STATE) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.getState = () => this.state;
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => {
+        this.listeners.delete(listener);
+      };
+    };
+    this.dispatch = (event) => {
+      const nextState = reduceAgentsChatState(this.state, event);
+      if (nextState === this.state) return;
+      this.state = nextState;
+      for (const notifyListener of [...this.listeners]) notifyListener();
+    };
+    this.state = initialState;
+  }
+}
+const createAgentsChatStore = (initialState) => new AgentsChatStateContainer(initialState);
+const AgentsChatStoreContext = createContext(null);
+const AgentsChatStoreProvider = (props) => {
+  const { chatStore, children } = props;
+  return /* @__PURE__ */ jsx(AgentsChatStoreContext.Provider, { value: chatStore, children });
+};
+const useAgentsChatStore = () => {
+  const chatStore = useContext(AgentsChatStoreContext);
+  if (chatStore === null) {
+    throw new Error("A chat component rendered outside AgentsChatStoreProvider: the app has to mount its chat store.");
+  }
+  return chatStore;
+};
+const useOptionalAgentsChatStore = () => useContext(AgentsChatStoreContext);
+const subscribeToNothing = () => () => void 0;
+const useAgentsChatSelector = (chatStore, selector, valueWithoutStore) => {
+  const subscribe = chatStore ? chatStore.subscribe : subscribeToNothing;
+  const readSelectedValue = useCallback(
+    () => chatStore ? selector(chatStore.getState()) : valueWithoutStore,
+    [chatStore, selector, valueWithoutStore]
+  );
+  return useSyncExternalStore(subscribe, readSelectedValue, readSelectedValue);
+};
+const useAgentsChatState = (selector) => useAgentsChatSelector(useAgentsChatStore(), selector);
+let agenticChatMountCount = 0;
+const selectCanvas = (state) => state.canvas;
+const selectLastClosedCanvas = (state) => state.lastClosedCanvas;
+const selectAiThinking = (state) => state.aiThinking;
+const selectRunState = (state) => state.conversation?.runState;
+const selectMessages = (state) => state.messages;
+const ChatStoreConversationWidgetProvider = (props) => {
+  const { chatStore, ...bodyProps } = props;
+  const canvas = useAgentsChatSelector(chatStore, selectCanvas);
+  const lastClosedCanvas = useAgentsChatSelector(chatStore, selectLastClosedCanvas);
+  const isConversationRunning = useAgentsChatSelector(chatStore, selectAiThinking);
+  const runState = useAgentsChatSelector(chatStore, selectRunState);
+  const messages = useAgentsChatSelector(chatStore, selectMessages);
+  const chatState = useMemo(
+    () => ({
+      canvas,
+      lastClosedCanvas,
+      isConversationRunning,
+      runState,
+      messages,
+      dispatchCanvasEvent: chatStore.dispatch
+    }),
+    [canvas, lastClosedCanvas, isConversationRunning, runState, messages, chatStore]
+  );
+  return /* @__PURE__ */ jsx(ConversationWidgetProviderBody, { ...bodyProps, chatState });
+};
+const SliceConversationWidgetProvider = (props) => {
+  const { sliceInstance, ...bodyProps } = props;
+  const dispatch = useAgentsStateDispatch();
+  const canvas = useAgentsStateSelector((state) => sliceInstance.selectState(state).canvas);
+  const lastClosedCanvas = useAgentsStateSelector((state) => sliceInstance.selectState(state).lastClosedCanvas);
+  const isConversationRunning = useAgentsStateSelector((state) => sliceInstance.selectState(state).aiThinking);
+  const runState = useAgentsStateSelector((state) => sliceInstance.selectState(state).conversation?.runState);
+  const messages = useAgentsStateSelector((state) => sliceInstance.selectState(state).messages);
+  const dispatchCanvasEvent = useCallback(
+    (event) => {
+      const { actions } = sliceInstance;
+      if (event.type === "canvasOpened") dispatch(actions.openCanvas(event.request));
+      else if (event.type === "canvasClosed") dispatch(actions.closeCanvas({ byCustomer: event.byCustomer }));
+      else if (event.type === "canvasResetForNewTurn") dispatch(actions.resetCanvasForNewTurn());
+      else if (event.type === "canvasCleared") dispatch(actions.clearCanvas());
+      else dispatch(actions.setCanvasCreatedEntityId(event.created));
+    },
+    [dispatch, sliceInstance]
+  );
+  const chatState = useMemo(
+    () => ({ canvas, lastClosedCanvas, isConversationRunning, runState, messages, dispatchCanvasEvent }),
+    [canvas, lastClosedCanvas, isConversationRunning, runState, messages, dispatchCanvasEvent]
+  );
+  return /* @__PURE__ */ jsx(ConversationWidgetProviderBody, { ...bodyProps, chatState });
+};
+const OwnChatStoreConversationWidgetProvider = (props) => {
+  const [ownChatStore] = useState(createAgentsChatStore);
+  return /* @__PURE__ */ jsx(ChatStoreConversationWidgetProvider, { ...props, chatStore: ownChatStore });
+};
+const ConversationWidgetProvider = (props) => {
+  const { sliceInstance, chatStore, ...bodyProps } = props;
+  const { defaultChatStatePartition } = useAgentsEnvironment();
+  const statePartition = sliceInstance ?? defaultChatStatePartition;
+  if (chatStore) return /* @__PURE__ */ jsx(ChatStoreConversationWidgetProvider, { ...bodyProps, chatStore });
+  if (statePartition) return /* @__PURE__ */ jsx(SliceConversationWidgetProvider, { ...bodyProps, sliceInstance: statePartition });
+  return /* @__PURE__ */ jsx(OwnChatStoreConversationWidgetProvider, { ...bodyProps });
+};
+const ConversationWidgetProviderBody = ({
+  children,
+  callbacks,
+  hostHasCanvasSurface = true,
+  chatState
+}) => {
+  const dispatch = useAgentsStateDispatch();
+  const { buildChatSurfaceOpenChangedAction } = useAgentsEnvironment();
+  const { canvas, lastClosedCanvas, isConversationRunning, runState, messages } = chatState;
+  const isConversationClosed = runState === "COMPLETED" || runState === "CANCELLED";
+  const dispatchCanvasEventRef = useRef(chatState.dispatchCanvasEvent);
+  dispatchCanvasEventRef.current = chatState.dispatchCanvasEvent;
+  const hostHasCanvasSurfaceRef = useRef(hostHasCanvasSurface);
+  hostHasCanvasSurfaceRef.current = hostHasCanvasSurface;
+  const buildChatSurfaceOpenChangedActionRef = useRef(buildChatSurfaceOpenChangedAction);
+  buildChatSurfaceOpenChangedActionRef.current = buildChatSurfaceOpenChangedAction;
+  useEffect(() => {
+    agenticChatMountCount += 1;
+    if (agenticChatMountCount === 1 && buildChatSurfaceOpenChangedActionRef.current) {
+      dispatch(buildChatSurfaceOpenChangedActionRef.current(true));
+    }
+    return () => {
+      agenticChatMountCount -= 1;
+      if (agenticChatMountCount === 0 && buildChatSurfaceOpenChangedActionRef.current) {
+        dispatch(buildChatSurfaceOpenChangedActionRef.current(false));
+      }
+    };
+  }, [dispatch]);
+  const callbacksRef = useRef(callbacks);
+  callbacksRef.current = callbacks;
+  const isComposerWidgetsControlled = callbacks.composerWidgets !== void 0;
+  const [internalComposerWidgets, setInternalComposerWidgets] = useState([]);
+  const composerWidgets = isComposerWidgetsControlled ? callbacks.composerWidgets : internalComposerWidgets;
+  const composerWidgetsStateRef = useRef({ composerWidgets, isComposerWidgetsControlled });
+  composerWidgetsStateRef.current = { composerWidgets, isComposerWidgetsControlled };
+  const publishComposerWidgets = useCallback((next) => {
+    if (composerWidgetsStateRef.current.isComposerWidgetsControlled) {
+      callbacksRef.current.onComposerWidgetsChange?.(next);
+    } else {
+      setInternalComposerWidgets(next);
+    }
+  }, []);
+  const addComposerWidget = useCallback(
+    (widgetName, fields) => {
+      const composerWidgetId = crypto.randomUUID();
+      publishComposerWidgets([
+        ...composerWidgetsStateRef.current.composerWidgets,
+        { composerWidgetId, widgetName, fields }
+      ]);
+      return composerWidgetId;
+    },
+    [publishComposerWidgets]
+  );
+  const replaceComposerWidgetFields = useCallback(
+    (composerWidgetId, fields) => {
+      publishComposerWidgets(
+        composerWidgetsStateRef.current.composerWidgets.map(
+          (widget) => widget.composerWidgetId === composerWidgetId ? { ...widget, fields } : widget
+        )
+      );
+    },
+    [publishComposerWidgets]
+  );
+  const removeComposerWidget = useCallback(
+    (composerWidgetId) => {
+      publishComposerWidgets(
+        composerWidgetsStateRef.current.composerWidgets.filter(
+          (widget) => widget.composerWidgetId !== composerWidgetId
+        )
+      );
+    },
+    [publishComposerWidgets]
+  );
+  const clearComposerWidgets = useCallback(() => {
+    publishComposerWidgets([]);
+  }, [publishComposerWidgets]);
+  const openCanvas = useCallback(
+    (request) => {
+      dispatchCanvasEventRef.current({
+        type: "canvasOpened",
+        request: {
+          ...request,
+          viewportViable: window.innerWidth >= CANVAS_VIABLE_MIN_WIDTH,
+          hostHasCanvasSurface: hostHasCanvasSurfaceRef.current
+        }
+      });
+    },
+    []
+  );
+  const closeCanvas = useCallback(
+    (byCustomer) => {
+      dispatchCanvasEventRef.current({ type: "canvasClosed", byCustomer });
+    },
+    []
+  );
+  const lastClosedCanvasRef = useRef(lastClosedCanvas);
+  lastClosedCanvasRef.current = lastClosedCanvas;
+  const reopenLastClosedCanvas = useCallback(() => {
+    const last = lastClosedCanvasRef.current;
+    if (last === null) return;
+    dispatchCanvasEventRef.current({
+      type: "canvasOpened",
+      request: {
+        canvasId: last.canvasId,
+        instanceId: last.instanceId,
+        anchor: last.anchor,
+        origin: "cardClick",
+        justDelivered: false,
+        viewportViable: window.innerWidth >= CANVAS_VIABLE_MIN_WIDTH,
+        hostHasCanvasSurface: hostHasCanvasSurfaceRef.current,
+        ...last.createdEntityId !== void 0 ? { createdEntityId: last.createdEntityId } : {}
+      }
+    });
+  }, []);
+  const setCanvasCreatedEntityId = useCallback(
+    (created) => {
+      dispatchCanvasEventRef.current({ type: "canvasCreatedEntityIdSet", created });
+    },
+    []
+  );
+  const storedCanvasConversationIdRef = useRef(void 0);
+  const conversationIdForStorage = callbacks.conversationId;
+  useEffect(() => {
+    if (canvas !== null) {
+      storeOpenCanvas(conversationIdForStorage, canvas);
+      storedCanvasConversationIdRef.current = conversationIdForStorage;
+      return;
+    }
+    if (storedCanvasConversationIdRef.current !== void 0 && storedCanvasConversationIdRef.current === conversationIdForStorage) {
+      clearStoredCanvas(conversationIdForStorage);
+    }
+    storedCanvasConversationIdRef.current = void 0;
+  }, [canvas, conversationIdForStorage]);
+  const resetCanvas = useCallback(() => {
+    dispatchCanvasEventRef.current({ type: "canvasCleared" });
+  }, []);
+  const resetCanvasForNewTurn = useCallback(() => {
+    dispatchCanvasEventRef.current({ type: "canvasResetForNewTurn" });
+  }, []);
+  const sendMessageToChat = useCallback((message) => {
+    return callbacksRef.current.sendMessageToChat?.(message);
+  }, []);
+  const prefillComposer = useCallback((text) => {
+    callbacksRef.current.prefillComposer?.(text);
+  }, []);
+  const injectSignal = useCallback((signalText, options) => {
+    return callbacksRef.current.injectSignal?.(signalText, options);
+  }, []);
+  const minimizeChatHost = useCallback(() => {
+    callbacksRef.current.minimizeChatHost?.();
+  }, []);
+  const contextValue = useMemo(
+    () => ({
+      canvas,
+      hostHasCanvasSurface,
+      lastClosedCanvas,
+      openCanvas,
+      closeCanvas,
+      reopenLastClosedCanvas,
+      setCanvasCreatedEntityId,
+      resetCanvas,
+      resetCanvasForNewTurn,
+      sendMessageToChat,
+      prefillComposer,
+      injectSignal,
+      minimizeChatHost,
+      chatAgentSpaceKey: callbacks.chatAgentSpaceKey,
+      isConversationRunning,
+      isConversationClosed,
+      conversationId: callbacks.conversationId,
+      composerWidgets,
+      addComposerWidget,
+      replaceComposerWidgetFields,
+      removeComposerWidget,
+      clearComposerWidgets,
+      onOpenConversation: callbacks.onOpenConversation,
+      onSwitchConversation: callbacks.onSwitchConversation,
+      isOnboardingSetupConversation: callbacks.isOnboardingSetupConversation ?? false,
+      messages
+    }),
+    [
+      canvas,
+      hostHasCanvasSurface,
+      lastClosedCanvas,
+      openCanvas,
+      closeCanvas,
+      reopenLastClosedCanvas,
+      setCanvasCreatedEntityId,
+      resetCanvas,
+      resetCanvasForNewTurn,
+      sendMessageToChat,
+      prefillComposer,
+      injectSignal,
+      minimizeChatHost,
+      callbacks.chatAgentSpaceKey,
+      isConversationRunning,
+      isConversationClosed,
+      callbacks.conversationId,
+      composerWidgets,
+      addComposerWidget,
+      replaceComposerWidgetFields,
+      removeComposerWidget,
+      clearComposerWidgets,
+      callbacks.onOpenConversation,
+      callbacks.onSwitchConversation,
+      callbacks.isOnboardingSetupConversation,
+      messages
+    ]
+  );
+  return /* @__PURE__ */ jsx(ConversationWidgetContext.Provider, { value: contextValue, children });
+};
+const stripReveal = "agents_stripReveal_6XAjCM";
+const stripRevealOpen = "agents_stripRevealOpen_sWkJwh";
+const stripRevealInner = "agents_stripRevealInner_C2VlV7";
+const strip = "agents_strip_rKQFvx";
+const styles = {
+  stripReveal,
+  stripRevealOpen,
+  stripRevealInner,
+  strip
+};
+const ConversationMessageInputComposerWidgets = (props) => {
+  const { testId = "chat-input" } = props;
+  const { composerWidgets, replaceComposerWidgetFields, removeComposerWidget } = useConversationWidgetContext();
+  const renderableWidgets = composerWidgets.flatMap((widget) => {
+    const entry = conversationWidgetRegistry.widgets.find((candidate) => candidate.name === widget.widgetName);
+    return entry?.composerComponent ? [{ widget, Component: entry.composerComponent }] : [];
+  });
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: classNames(styles.stripReveal, { [styles.stripRevealOpen]: renderableWidgets.length > 0 }),
+      "data-testid": `${testId}-composer-widgets-strip`,
+      children: /* @__PURE__ */ jsx("div", { className: styles.stripRevealInner, children: /* @__PURE__ */ jsx("div", { className: styles.strip, children: renderableWidgets.map(({ widget, Component }) => /* @__PURE__ */ jsx(
+        Component,
+        {
+          composerWidgetId: widget.composerWidgetId,
+          fields: widget.fields,
+          replaceFields: (nextFields) => replaceComposerWidgetFields(widget.composerWidgetId, nextFields),
+          remove: () => removeComposerWidget(widget.composerWidgetId),
+          testId: `${testId}-composer-widget-${widget.composerWidgetId}`
+        },
+        widget.composerWidgetId
+      )) }) })
+    }
+  );
+};
+export {
+  AgentsChatStateContainer as A,
+  ConversationWidgetProvider as C,
+  EMPTY_AGENTS_CHAT_OPENING_REQUEST as E,
+  INITIAL_AGENTS_CHAT_STATE as I,
+  ConversationMessageInputComposerWidgets as a,
+  ConversationErrorType as b,
+  createAgentsChatStore as c,
+  AgentsChatStoreProvider as d,
+  reduceAgentsChatState as e,
+  useAgentsChatState as f,
+  useAgentsChatStore as g,
+  useOptionalAgentsChatStore as h,
+  readConversationErrorTypeOfRefusedSend as r,
+  useAgentsChatSelector as u
+};
+//# sourceMappingURL=ConversationMessageInputComposerWidgets-BxyaFBA6.js.map