@meistrari/chat-nuxt 3.10.0 → 3.11.0

package/dist/runtime/messages/components/chat-message-bubble.vue.d.ts

@@ -1,11 +1,20 @@
 import type { Message } from '../../types/schemas/chat/conversations.js';
 type __VLS_Props = {
     message: Message;
+    streamActive?: boolean;
+    /**
+     * Stand-in steps shown while this turn is still working towards its first
+     * output. They yield as soon as the run emits real reasoning or content.
+     */
+    preparingSteps?: readonly string[] | null;
+    showTtft?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     retry: (messageId: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onRetry?: ((messageId: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    showTtft: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/messages/components/chat-message-list.d.vue.ts

@@ -8,11 +8,16 @@ type __VLS_Props = {
      * own spacing. Defaults to `page`.
      */
     variant?: 'page' | 'widget' | 'mobile';
+    streamingActiveMessageId?: string | null;
+    preparingSteps?: readonly string[] | null;
+    showTtft?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     retry: (messageId: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onRetry?: ((messageId: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    showTtft: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/messages/components/chat-message-list.vue

@@ -2,7 +2,10 @@
 const props = defineProps({
   messages: { type: Array, required: true },
   loading: { type: Boolean, required: false },
-  variant: { type: String, required: false }
+  variant: { type: String, required: false },
+  streamingActiveMessageId: { type: [String, null], required: false },
+  preparingSteps: { type: [Array, null], required: false },
+  showTtft: { type: Boolean, required: false, default: true }
 });
 const emit = defineEmits(["retry"]);
 const conversationRef = ref(null);
@@ -18,7 +21,10 @@ function scrollToBottom() {
 const hasPendingMessage = computed(
   () => props.messages.some((message) => message.status === "pending")
 );
-watch(() => props.messages.length, scrollToBottom);
+watch(
+  () => [props.messages.length, props.messages.at(-1)?.content.length ?? 0],
+  scrollToBottom
+);
 onMounted(scrollToBottom);
 </script>
 
@@ -47,6 +53,9 @@ onMounted(scrollToBottom);
                     v-for="message in messages"
                     :key="message.id"
                     :message="message"
+                    :stream-active="message.id === streamingActiveMessageId"
+                    :preparing-steps="message.role === 'assistant' && message.status === 'pending' ? preparingSteps : null"
+                    :show-ttft="showTtft"
                     @retry="emit('retry', $event)"
                 />
                 <p

package/dist/runtime/messages/components/chat-message-list.vue.d.ts

@@ -8,11 +8,16 @@ type __VLS_Props = {
      * own spacing. Defaults to `page`.
      */
     variant?: 'page' | 'widget' | 'mobile';
+    streamingActiveMessageId?: string | null;
+    preparingSteps?: readonly string[] | null;
+    showTtft?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     retry: (messageId: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onRetry?: ((messageId: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    showTtft: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/messages/components/reasoning/chat-reasoning-thought.d.vue.ts

@@ -1,10 +1,11 @@
-import type { ReasoningStep } from '../../reasoning.js';
+import { type ReasoningStep } from '../../reasoning.js';
 type __VLS_Props = {
     reasoningData: ReasoningStep[];
     completed: boolean;
     animate?: boolean;
     createdAt: Date | string;
     updatedAt?: Date | string | null;
+    preparingSteps?: readonly string[] | null;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/messages/components/reasoning/chat-reasoning-thought.vue

@@ -1,4 +1,5 @@
 <script setup>
+import { resolveDisplayedReasoning } from "../../reasoning";
 import { resolveToolTitle } from "../../tool-registry";
 import ChatReasoningSteps from "./chat-reasoning-steps.vue";
 const props = defineProps({
@@ -6,7 +7,8 @@ const props = defineProps({
   completed: { type: Boolean, required: true },
   animate: { type: Boolean, required: false },
   createdAt: { type: [Date, String], required: true },
-  updatedAt: { type: [Date, String, null], required: false }
+  updatedAt: { type: [Date, String, null], required: false },
+  preparingSteps: { type: [Array, null], required: false }
 });
 const SUCCESS_ANIMATION_DURATION_MS = 1e3;
 const DOT_ANIMATION_INTERVAL_MS = 500;
@@ -23,11 +25,10 @@ let dotInterval;
 let timerInterval;
 const storageKey = computed(() => `reasoning-timer-${new Date(props.createdAt).getTime()}`);
 const showGradient = computed(() => !props.completed && !isExpanded.value);
-const groupedReasoning = computed(() => {
-  if (!props.reasoningData || !Array.isArray(props.reasoningData))
-    return [];
-  return props.reasoningData;
-});
+const displayedReasoning = computed(
+  () => resolveDisplayedReasoning(props.reasoningData, props.preparingSteps)
+);
+const groupedReasoning = computed(() => displayedReasoning.value);
 const hasReasoning = computed(() => groupedReasoning.value.length > 0);
 const lastStep = computed(() => {
   const steps = groupedReasoning.value;
@@ -247,7 +248,7 @@ onUnmounted(() => {
                     :class="{ 'with-gradient': showGradient }"
                 >
                     <ChatReasoningSteps
-                        :reasoning-data="reasoningData"
+                        :reasoning-data="displayedReasoning"
                         :animate="animate && !completed"
                         :completed="completed"
                         :is-preview-mode="true"
@@ -262,7 +263,7 @@ onUnmounted(() => {
                     mb-16px
                 >
                     <ChatReasoningSteps
-                        :reasoning-data="reasoningData"
+                        :reasoning-data="displayedReasoning"
                         :animate="animate && !completed"
                         :completed="completed"
                     />

package/dist/runtime/messages/components/reasoning/chat-reasoning-thought.vue.d.ts

@@ -1,10 +1,11 @@
-import type { ReasoningStep } from '../../reasoning.js';
+import { type ReasoningStep } from '../../reasoning.js';
 type __VLS_Props = {
     reasoningData: ReasoningStep[];
     completed: boolean;
     animate?: boolean;
     createdAt: Date | string;
     updatedAt?: Date | string | null;
+    preparingSteps?: readonly string[] | null;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/messages/composables/chat.d.ts

@@ -4,6 +4,7 @@ import type { FileUploadInput } from '../../types/schemas/chat/files.js';
 import type { SendMessageBody } from '../../types/schemas/chat/messages.js';
 import type { TelaAgentExecutionInput } from '../../types/schemas/integrations/tela-agent-api.js';
 export declare function resolveTelaAgentInputs(messageInputs: TelaAgentExecutionInput[] | undefined, configuredInputs: DeepReadonly<TelaAgentExecutionInput[]> | null | undefined): SendMessageBody['agentInputs'];
+export declare function resolveStreamingContent(authoritative: string, provisional: string): string;
 export declare function useChat(): {
     currentConversation: any;
     messages: any;
@@ -12,15 +13,20 @@ export declare function useChat(): {
     error: any;
     isPolling: any;
     hasPendingMessage: any;
+    streamingActiveMessageId: any;
+    preparingSteps: any;
     cancelling: any;
     generatingTitle: any;
     animatedTitle: any;
     loadConversation: (id: string) => Promise<void>;
     setConversation: (conv: Conversation | ConversationWithMessages) => void;
+    adoptConversation: (conv: Conversation) => void;
     setConversationModel: (model: string | null) => void;
     pendingModelSelection: any;
-    sendMessage: (content: string, files?: FileUploadInput[], agentInputs?: TelaAgentExecutionInput[]) => Promise<Message | null>;
-    retryMessage: (messageId: string) => Promise<boolean>;
+    sendMessage: (content: string, files?: FileUploadInput[], agentInputs?: TelaAgentExecutionInput[], prepare?: (signal: AbortSignal) => Promise<{
+        wakeSessionId?: string;
+    }>) => Promise<Message | null>;
+    retryMessage: (messageId: string, wakeSessionId?: string) => Promise<boolean>;
     cancelConversation: () => Promise<boolean>;
     startPolling: () => void;
     stopPolling: () => void;

package/dist/runtime/messages/composables/chat.js

@@ -20,13 +20,22 @@ import { getChatApiErrorCode, getChatApiErrorMessage } from "../../shared/chat-a
 import { useChatApi } from "../../shared/composables/chat-api.js";
 import { useConversationFileActions } from "../../files/composables/conversation-files.js";
 import { useEmbedConfig } from "../../embed/composables/embed-config.js";
+import { CHAT_PREPARING_STEPS, nextChatPreparingStepDelay } from "../../embed/loading-messages.js";
 import { usePolling } from "../../shared/composables/polling.js";
 import { terminalMessageTransitions, useChatMessageTerminal } from "./chat-message-terminal.js";
+import { useDirectStream } from "./use-direct-stream.js";
 const WORKSPACE_AGENT_NOT_READY_TEXT = "O agente deste workspace ainda n\xE3o foi configurado no Tela. Abra as configura\xE7\xF5es do workspace para criar o agente.";
 export function resolveTelaAgentInputs(messageInputs, configuredInputs) {
   const inputs = messageInputs ?? configuredInputs;
   return inputs === void 0 || inputs === null ? void 0 : inputs.map((input) => ({ ...input }));
 }
+export function resolveStreamingContent(authoritative, provisional) {
+  if (provisional.startsWith(authoritative))
+    return provisional;
+  if (authoritative.startsWith(provisional))
+    return authoritative;
+  return authoritative || provisional;
+}
 export function useChat() {
   const chatApi = useChatApi();
   const chatMessageTerminal = useChatMessageTerminal();
@@ -60,6 +69,34 @@ export function useChat() {
   });
   const loading = ref(false);
   const sending = ref(false);
+  const gateHolding = ref(false);
+  const preparingSteps = ref([]);
+  let preparingTimer;
+  let gateController = null;
+  let sendStartedAt = 0;
+  let standInOutputAtMs = null;
+  function clearPreparingSteps() {
+    if (preparingTimer)
+      clearTimeout(preparingTimer);
+    preparingTimer = void 0;
+    preparingSteps.value = [];
+    standInOutputAtMs = null;
+  }
+  function schedulePreparingStep(index) {
+    if (index >= CHAT_PREPARING_STEPS.length)
+      return;
+    const delay = nextChatPreparingStepDelay(index);
+    if (index === 0)
+      standInOutputAtMs = delay;
+    preparingTimer = setTimeout(() => {
+      preparingSteps.value = CHAT_PREPARING_STEPS.slice(0, index + 1);
+      schedulePreparingStep(index + 1);
+    }, delay);
+  }
+  function schedulePreparingSteps() {
+    clearPreparingSteps();
+    schedulePreparingStep(0);
+  }
   const error = ref(null);
   const titleGenerated = ref(false);
   const generatingTitle = ref(false);
@@ -67,12 +104,29 @@ export function useChat() {
   const hasPendingMessage = computed(
     () => messages.value.some((m) => m.status === "pending")
   );
+  const streamingMessageId = ref(null);
+  let requestDurableRecovery = () => {
+  };
+  const directStream = useDirectStream({
+    onResult: () => requestDurableRecovery(),
+    onDisconnect: () => requestDurableRecovery()
+  });
+  const streamingActiveMessageId = computed(
+    () => directStream.activity.value === "active" ? streamingMessageId.value : null
+  );
   const reasoningCache = createReasoningCache();
-  const processedMessages = computed(() => resolveReasoningDisplayMessages(messages.value, reasoningCache));
+  const processedMessages = computed(() => {
+    const resolved = resolveReasoningDisplayMessages(messages.value, reasoningCache);
+    const messageId = streamingMessageId.value;
+    const content = directStream.streamingText.value;
+    if (!messageId || !content)
+      return resolved;
+    return resolved.map((message) => message.id === messageId && message.status === "pending" ? { ...message, content: resolveStreamingContent(message.content, content) } : message);
+  });
   const stopCondition = computed(() => !hasPendingMessage.value);
   let pollGeneration = 0;
   const pollMessages = async () => {
-    if (!currentConversation.value)
+    if (!currentConversation.value || gateHolding.value)
       return;
     const generation = pollGeneration;
     try {
@@ -84,6 +138,13 @@ export function useChat() {
         return;
       const terminalMessages = terminalMessageTransitions(messages.value, response.messages);
       messages.value = response.messages;
+      const latestSessionId = response.messages.findLast((message) => message.agentSessionId)?.agentSessionId;
+      if (latestSessionId && currentConversation.value.threadSessionId === null) {
+        currentConversation.value = {
+          ...currentConversation.value,
+          threadSessionId: latestSessionId
+        };
+      }
       for (const terminalMessage of terminalMessages)
         chatMessageTerminal.emit(terminalMessage);
       if (response.newFiles && response.newFiles.length > 0) {
@@ -123,6 +184,10 @@ export function useChat() {
     pollGeneration++;
     endPolling();
   }
+  requestDurableRecovery = () => {
+    startPolling();
+    void pollMessages();
+  };
   const pendingModelBuckets = useState("chat-pending-model-selection", () => ({}));
   const pendingModelSelection = computed({
     get: () => {
@@ -142,7 +207,15 @@ export function useChat() {
       return;
     currentConversation.value = { ...conversation, model };
   };
+  const adoptConversation = (conv) => {
+    currentConversation.value = { ...conv, messages: messages.value };
+    titleGenerated.value = false;
+  };
   const setConversation = (conv) => {
+    if (currentConversation.value && currentConversation.value.id !== conv.id) {
+      directStream.disconnect();
+      streamingMessageId.value = null;
+    }
     const conversationMessages = "messages" in conv ? conv.messages : [];
     currentConversation.value = { ...conv, messages: conversationMessages };
     messages.value = conversationMessages;
@@ -163,8 +236,14 @@ export function useChat() {
       if (shouldTreatLoadedConversationTitleAsGenerated(data.messages)) {
         titleGenerated.value = true;
       }
-      if (data.messages.some((m) => m.status === "pending")) {
+      const pendingAssistant = data.messages.findLast((m) => m.role === "assistant" && m.status === "pending");
+      if (pendingAssistant) {
+        streamingMessageId.value = pendingAssistant.id;
+        directStream.beginMessage();
         startPolling();
+      } else {
+        streamingMessageId.value = null;
+        directStream.disconnect();
       }
     } catch (err) {
       currentConversation.value = null;
@@ -176,15 +255,18 @@ export function useChat() {
       loading.value = false;
     }
   };
-  const sendMessage = async (content, files, agentInputs) => {
-    if (!currentConversation.value)
+  const sendMessage = async (content, files, agentInputs, prepare) => {
+    if (!currentConversation.value && !prepare)
       return null;
     sending.value = true;
     error.value = null;
+    sendStartedAt = Date.now();
+    schedulePreparingSteps();
     const filesWithSource = files?.map((f) => ({ ...f, source: "user" })) ?? null;
+    const conversationId = currentConversation.value?.id ?? "";
     const optimisticUserMessage = {
       id: crypto.randomUUID(),
-      conversationId: currentConversation.value.id,
+      conversationId,
       role: "user",
       content,
       status: "completed",
@@ -198,7 +280,7 @@ export function useChat() {
     };
     const optimisticAssistantMessage = {
       id: crypto.randomUUID(),
-      conversationId: currentConversation.value.id,
+      conversationId,
       role: "assistant",
       content: "",
       status: "pending",
@@ -210,28 +292,68 @@ export function useChat() {
       createdAt: /* @__PURE__ */ new Date(),
       updatedAt: null
     };
+    streamingMessageId.value = optimisticAssistantMessage.id;
+    directStream.beginMessage();
     messages.value = [...messages.value, optimisticUserMessage, optimisticAssistantMessage];
+    const controller = new AbortController();
+    gateController = controller;
     try {
+      let wakeSessionId;
+      if (prepare) {
+        gateHolding.value = true;
+        try {
+          wakeSessionId = (await prepare(controller.signal)).wakeSessionId;
+        } finally {
+          gateHolding.value = false;
+        }
+      }
+      if (controller.signal.aborted)
+        throw new DOMException("Aborted", "AbortError");
+      if (!currentConversation.value)
+        throw new Error("Erro ao enviar mensagem");
       const resolvedAgentInputs = resolveTelaAgentInputs(agentInputs, embedConfig?.telaAgentInputs?.value);
       const body = {
         content,
         files,
-        ...resolvedAgentInputs !== void 0 ? { agentInputs: resolvedAgentInputs } : {}
+        ...resolvedAgentInputs !== void 0 ? { agentInputs: resolvedAgentInputs } : {},
+        ...wakeSessionId ? { wakeSessionId } : {},
+        clientTiming: {
+          // Everything the gate held goes in here: whatever the server
+          // measures, the user has already been waiting this long.
+          sinceSendMs: Math.max(0, Date.now() - sendStartedAt),
+          ...standInOutputAtMs !== null ? { standInOutputAtMs } : {}
+        }
       };
-      const response = await $fetch(
-        chatApi.path(`/conversations/${currentConversation.value.id}/messages`),
-        chatApi.withChatHeaders({
-          method: "POST",
-          body
-        })
-      );
-      messages.value = messages.value.map((msg) => {
-        if (msg.id === optimisticUserMessage.id)
-          return response.userMessage;
-        if (msg.id === optimisticAssistantMessage.id)
-          return response.assistantMessage;
-        return msg;
-      });
+      const acceptMessagePair = (response2) => {
+        messages.value = messages.value.map((msg) => {
+          if (msg.id === optimisticUserMessage.id)
+            return response2.userMessage;
+          if (msg.id === optimisticAssistantMessage.id)
+            return response2.assistantMessage;
+          return msg;
+        });
+        streamingMessageId.value = response2.assistantMessage.id;
+      };
+      let response;
+      let acceptedByStream = false;
+      try {
+        response = await directStream.connectMessage(
+          chatApi.path(`/conversations/${currentConversation.value.id}/messages/stream`),
+          chatApi.withChatHeaders({
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body)
+          }),
+          acceptMessagePair
+        );
+        acceptedByStream = true;
+      } catch {
+        response = await $fetch(
+          chatApi.path(`/conversations/${currentConversation.value.id}/messages`),
+          chatApi.withChatHeaders({ method: "POST", body })
+        );
+        acceptMessagePair(response);
+      }
       if (files && files.length > 0) {
         addFilesToConversation(
           currentConversation.value.id,
@@ -240,29 +362,46 @@ export function useChat() {
           "user"
         );
       }
-      startPolling();
+      if (!acceptedByStream)
+        startPolling();
       return response.userMessage;
     } catch (err) {
       messages.value = messages.value.filter(
         (msg) => msg.id !== optimisticUserMessage.id && msg.id !== optimisticAssistantMessage.id
       );
+      streamingMessageId.value = null;
+      clearPreparingSteps();
+      directStream.disconnect();
       stopPolling();
+      if (err instanceof DOMException && err.name === "AbortError")
+        return null;
       const message = getChatApiErrorCode(err) === "workspace_agent_not_ready" ? WORKSPACE_AGENT_NOT_READY_TEXT : err instanceof Error ? err.message : "Erro ao enviar mensagem";
       error.value = message;
       Sentry.captureException(err);
       return null;
     } finally {
       sending.value = false;
+      gateHolding.value = false;
+      if (gateController === controller)
+        gateController = null;
     }
   };
   const clearConversation = () => {
     stopPolling();
+    gateController?.abort();
+    streamingMessageId.value = null;
+    clearPreparingSteps();
+    directStream.disconnect();
     currentConversation.value = null;
     messages.value = [];
     error.value = null;
   };
   const cancelling = ref(false);
   const cancelConversation = async () => {
+    if (gateHolding.value) {
+      gateController?.abort();
+      return true;
+    }
     if (!currentConversation.value || !hasPendingMessage.value)
       return false;
     cancelling.value = true;
@@ -278,6 +417,8 @@ export function useChat() {
         return false;
       }
       messages.value = markPendingAssistantMessagesInterrupted(messages.value);
+      streamingMessageId.value = null;
+      directStream.disconnect();
       stopPolling();
       return true;
     } catch (err) {
@@ -304,6 +445,8 @@ export function useChat() {
         messages: []
       };
       messages.value = [];
+      streamingMessageId.value = null;
+      directStream.disconnect();
       return true;
     } catch (err) {
       const message = err instanceof Error ? err.message : "Erro ao limpar conversa";
@@ -312,7 +455,7 @@ export function useChat() {
       return false;
     }
   };
-  const retryMessage = async (messageId) => {
+  const retryMessage = async (messageId, wakeSessionId) => {
     if (!currentConversation.value)
       return false;
     error.value = null;
@@ -320,15 +463,22 @@ export function useChat() {
     if (!retry)
       return false;
     messages.value = retry.messages;
+    streamingMessageId.value = messageId;
+    directStream.beginMessage();
     try {
       await $fetch(
         chatApi.path(`/conversations/${currentConversation.value.id}/messages/${messageId}/retry`),
-        chatApi.withChatHeaders({ method: "POST" })
+        chatApi.withChatHeaders({
+          method: "POST",
+          body: wakeSessionId ? { wakeSessionId } : {}
+        })
       );
       startPolling();
       return true;
     } catch (err) {
       messages.value = restoreAssistantMessageAfterRetryFailure(messages.value, retry.originalMessage);
+      streamingMessageId.value = null;
+      directStream.disconnect();
       const errorMessage = getChatApiErrorCode(err) === "workspace_agent_not_ready" ? WORKSPACE_AGENT_NOT_READY_TEXT : err instanceof Error ? err.message : "Erro ao reenviar mensagem";
       error.value = errorMessage;
       Sentry.captureException(err);
@@ -400,6 +550,8 @@ export function useChat() {
   };
   watch(hasPendingMessage, (isPending, wasPending) => {
     if (wasPending && !isPending) {
+      streamingMessageId.value = null;
+      directStream.disconnect();
       void generateTitle();
     }
   });
@@ -414,11 +566,14 @@ export function useChat() {
     error: readonly(error),
     isPolling: readonly(isPolling),
     hasPendingMessage,
+    streamingActiveMessageId,
+    preparingSteps: readonly(preparingSteps),
     cancelling: readonly(cancelling),
     generatingTitle: readonly(generatingTitle),
     animatedTitle: readonly(animatedTitle),
     loadConversation,
     setConversation,
+    adoptConversation,
     setConversationModel,
     pendingModelSelection,
     sendMessage,

package/dist/runtime/messages/composables/use-direct-stream.d.ts

@@ -0,0 +1,41 @@
+import type { SendMessageResponse } from '../../types/schemas/chat/messages.js';
+export type DirectStreamActivity = 'idle' | 'connected' | 'active';
+export type SseFrame = {
+    event?: string;
+    data: string;
+};
+export type MessagePartsEvent = {
+    kind: 'message-parts';
+    runId: string;
+    deltaSeq: number;
+    parentToolUseId?: string | null;
+    event: Record<string, unknown>;
+};
+export type MessagePartsAccumulator = {
+    runId: string | null;
+    lastDeltaSeq: number;
+    textByIndex: Record<number, string>;
+    thinkingByIndex: Record<number, string>;
+};
+export declare function parseSseFrames(source: string): {
+    frames: SseFrame[];
+    rest: string;
+};
+export declare function createMessagePartsAccumulator(runId?: string | null): MessagePartsAccumulator;
+export declare function applyMessagePartsEvent(accumulator: MessagePartsAccumulator, input: MessagePartsEvent): {
+    text: string;
+    thinking: string;
+    changed: boolean;
+};
+export declare function useDirectStream(options?: {
+    onResult?: () => void;
+    onDisconnect?: () => void;
+}): {
+    activity: any;
+    streamingText: any;
+    streamingThinking: any;
+    activeRunId: any;
+    connectMessage: (url: string, init: RequestInit, onAccepted: (response: SendMessageResponse) => void) => Promise<SendMessageResponse>;
+    beginMessage: () => void;
+    disconnect: (reset?: boolean) => void;
+};