@meistrari/chat-nuxt 3.17.0-rc.6 → 3.17.0-rc.7

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@meistrari/chat-nuxt",
   "configKey": "chatNuxt",
-  "version": "3.17.0-rc.6",
+  "version": "3.17.0-rc.7",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/runtime/embed/components/chat-embed-inner.vue

@@ -219,7 +219,7 @@ function persistConversationModel(conversation, value, wakeAgent) {
   const update = updateConversationModel(conversation.id, value).then(async (updated) => {
     if (!updated && currentConversation.value?.id === conversation.id && currentConversation.value.model === value) {
       setConversationModel(previousModel);
-    } else if (updated && value && wakeAgent) {
+    } else if (updated && value && wakeAgent && !chatApi.conversationV2Enabled) {
       if (conversation.threadSessionId)
         await agentWake.ensureReady(conversation.threadSessionId, value);
       else
@@ -325,6 +325,10 @@ function updateConversationId(nextConversationId) {
 }
 async function ensureConversationLoaded(conversationId) {
   if (currentConversation.value?.id === conversationId) {
+    if (chatApi.conversationV2Enabled) {
+      startPolling();
+      return;
+    }
     if (currentConversation.value.threadSessionId)
       void agentWake.ensureReady(currentConversation.value.threadSessionId, selectedModel.value);
     else
@@ -346,6 +350,10 @@ async function ensureConversationLoaded(conversationId) {
       });
       return;
     }
+    if (chatApi.conversationV2Enabled) {
+      startPolling();
+      return;
+    }
     if (currentConversation.value.threadSessionId)
       void agentWake.ensureReady(currentConversation.value.threadSessionId, selectedModel.value);
     else
@@ -360,7 +368,8 @@ async function ensureConversationLoaded(conversationId) {
 function resetConversation(shouldEmit = true) {
   clearConversation();
   agentWake.consume();
-  void agentWake.wake(void 0, selectedModel.value);
+  if (!chatApi.conversationV2Enabled)
+    void agentWake.wake(void 0, selectedModel.value);
   activeTab.value = "chat";
   closeFilesPanel();
   closePreview();
@@ -549,6 +558,8 @@ async function handleSend(content, files, agentInputs) {
       selectedModel.value,
       (value) => persistConversationModel(conversation, value, false)
     );
+    if (chatApi.conversationV2Enabled)
+      return {};
     if (conversation.threadSessionId && resolvedFeatures.value.chatOutboundQueue) {
       const wake = await agentWake.ensureReady(conversation.threadSessionId, selectedModel.value);
       if (wake.status !== "ready") {

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

@@ -42,6 +42,8 @@ export function resolveStreamingContent(authoritative, provisional) {
 }
 export function useChat(options = {}) {
   const chatApi = useChatApi();
+  const runtimeBlocked = ref(false);
+  let streamConnecting = false;
   const chatMessageTerminal = useChatMessageTerminal();
   const embedConfig = useEmbedConfig();
   const { user: authUser, activeOrganization } = useChatAuth();
@@ -152,7 +154,7 @@ export function useChat(options = {}) {
   const pendingStreamReconciliationIds = ref(/* @__PURE__ */ new Set());
   const pendingRealResultIds = ref(/* @__PURE__ */ new Set());
   const composerLocked = computed(
-    () => hasPendingMessage.value || pendingRealResultIds.value.size > 0 || outbound.occupied.value
+    () => hasPendingMessage.value || runtimeBlocked.value || pendingRealResultIds.value.size > 0 || outbound.occupied.value
   );
   const queuedMessageContent = computed(() => outbound.slot.value?.content ?? null);
   let requestDurableRecovery = () => {
@@ -213,8 +215,24 @@ export function useChat(options = {}) {
     return resolveReasoningDisplayMessages(overlaid, reasoningCache);
   });
   const stopCondition = computed(
-    () => !hasPendingMessage.value && pendingStreamReconciliationIds.value.size === 0
+    () => !runtimeBlocked.value && !hasPendingMessage.value && pendingStreamReconciliationIds.value.size === 0
   );
+  async function attachConversationStream(conversationId) {
+    if (streamConnecting || directStream.activity.value !== "idle")
+      return;
+    streamConnecting = true;
+    try {
+      await directStream.connectConversation(
+        chatApi.runtimePath(`/conversations/${conversationId}/stream`),
+        chatApi.withChatHeaders(),
+        streamingMessageId.value ?? void 0
+      );
+    } catch (err) {
+      Sentry.captureException(err);
+    } finally {
+      streamConnecting = false;
+    }
+  }
   let pollGeneration = 0;
   const pollMessages = async () => {
     if (!currentConversation.value)
@@ -222,13 +240,20 @@ export function useChat(options = {}) {
     if (gateHolding.value && !outboundQueueEnabled.value)
       return;
     const generation = pollGeneration;
+    const conversationId = currentConversation.value.id;
     try {
+      const runtime = chatApi.conversationV2Enabled ? await $fetch(
+        chatApi.runtimePath(`/conversations/${conversationId}/runtime`),
+        chatApi.withChatHeaders()
+      ) : null;
       const response = await $fetch(
-        chatApi.path(`/conversations/${currentConversation.value.id}/messages`),
+        chatApi.path(`/conversations/${conversationId}/messages`),
         chatApi.withChatHeaders()
       );
-      if (generation !== pollGeneration)
+      if (generation !== pollGeneration || currentConversation.value?.id !== conversationId)
         return;
+      if (runtime)
+        runtimeBlocked.value = runtime.conversation.runtimeState === "blocked";
       if (response.agentSession) {
         agentSessionStatus.value = response.agentSession.status;
         agentSessionExecutable.value = response.agentSession.executable;
@@ -261,6 +286,10 @@ export function useChat(options = {}) {
       pendingStreamReconciliationIds.value = remainingReconciliationIds;
       pendingRealResultIds.value = remainingRealResultIds;
       messages.value = reconciledMessages;
+      if (runtime?.turn && runtimeBlocked.value && reconciledMessages.some((message) => message.id === runtime.turn?.id)) {
+        streamingMessageId.value = runtime.turn.id;
+        void attachConversationStream(conversationId);
+      }
       const latestSessionId = reconciledMessages.findLast((message) => message.agentSessionId)?.agentSessionId;
       if (latestSessionId && currentConversation.value.threadSessionId === null) {
         currentConversation.value = {
@@ -330,7 +359,8 @@ export function useChat(options = {}) {
   }
   requestDurableRecovery = () => {
     startPolling();
-    void pollMessages();
+    if (!chatApi.conversationV2Enabled)
+      void pollMessages();
   };
   const pendingModelBuckets = useState("chat-pending-model-selection", () => ({}));
   const pendingModelSelection = computed({
@@ -371,6 +401,7 @@ export function useChat(options = {}) {
     currentConversation.value = { ...conv, messages: messages.value };
   };
   const setConversation = (conv) => {
+    runtimeBlocked.value = false;
     if (currentConversation.value && currentConversation.value.id !== conv.id) {
       directStream.disconnect();
       streamingMessageId.value = null;
@@ -386,6 +417,11 @@ export function useChat(options = {}) {
     error.value = null;
   };
   const loadConversation = async (id) => {
+    if (chatApi.conversationV2Enabled) {
+      stopPolling();
+      directStream.disconnect();
+    }
+    runtimeBlocked.value = false;
     loading.value = true;
     error.value = null;
     try {
@@ -404,6 +440,8 @@ export function useChat(options = {}) {
         streamingMessageId.value = pendingAssistant.id;
         directStream.beginMessage();
         startPolling();
+        if (chatApi.conversationV2Enabled)
+          await pollMessages();
       } else {
         streamingMessageId.value = null;
         directStream.disconnect();
@@ -423,7 +461,7 @@ export function useChat(options = {}) {
       return null;
     if (outboundQueueEnabled.value && outbound.occupied.value && !queuedSend)
       return null;
-    if (!queuedSend && (sending.value || hasPendingMessage.value || pendingRealResultIds.value.size > 0))
+    if (!queuedSend && (sending.value || runtimeBlocked.value || hasPendingMessage.value || pendingRealResultIds.value.size > 0))
       return null;
     suspendPollingForSend();
     sending.value = true;
@@ -468,6 +506,7 @@ export function useChat(options = {}) {
       messages.value = [...messages.value, optimisticUserMessage, optimisticAssistantMessage];
     const controller = new AbortController();
     gateController = controller;
+    let v2AdmissionRequested = false;
     try {
       let wakeSessionId = queuedSend?.wakeSessionId;
       let defer = false;
@@ -486,7 +525,7 @@ export function useChat(options = {}) {
       if (!currentConversation.value)
         throw new Error("Erro ao enviar mensagem");
       const sessionReady2 = currentConversation.value.threadSessionId ? agentSessionStatus.value === "waiting_messages" && agentSessionExecutable.value : null;
-      if (outboundQueueEnabled.value && !queuedSend && (defer || sessionReady2 === false)) {
+      if (!chatApi.conversationV2Enabled && outboundQueueEnabled.value && !queuedSend && (defer || sessionReady2 === false)) {
         outbound.enqueue({
           content,
           files,
@@ -530,29 +569,52 @@ export function useChat(options = {}) {
         startPolling();
       };
       let response;
-      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
+      if (chatApi.conversationV2Enabled) {
+        const v2Body = {
+          messageId: optimisticUserMessage.id,
+          content,
+          files,
+          ...resolvedAgentInputs !== void 0 ? { agentInputs: resolvedAgentInputs } : {},
+          clientTiming: body.clientTiming
+        };
+        const conversationId2 = currentConversation.value.id;
+        v2AdmissionRequested = true;
+        const accepted = await $fetch(
+          chatApi.runtimePath(`/conversations/${conversationId2}/messages`),
+          chatApi.withChatHeaders({ method: "POST", body: v2Body, retry: 1 })
         );
-      } catch (streamError) {
-        const statusCode = getChatApiErrorStatus(streamError);
-        if (statusCode !== null && statusCode >= 400 && statusCode < 500)
-          throw streamError;
-        if (outboundQueueEnabled.value) {
-          startPolling();
-          return optimisticUserMessage;
+        response = accepted;
+        if (currentConversation.value?.id !== conversationId2)
+          return accepted.userMessage;
+        runtimeBlocked.value = accepted.conversation.runtimeState === "blocked";
+        acceptMessagePair(accepted);
+        if (runtimeBlocked.value)
+          void attachConversationStream(conversationId2);
+      } else {
+        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
+          );
+        } catch (streamError) {
+          const statusCode = getChatApiErrorStatus(streamError);
+          if (statusCode !== null && statusCode >= 400 && statusCode < 500)
+            throw streamError;
+          if (outboundQueueEnabled.value) {
+            startPolling();
+            return optimisticUserMessage;
+          }
+          response = await $fetch(
+            chatApi.path(`/conversations/${currentConversation.value.id}/messages`),
+            chatApi.withChatHeaders({ method: "POST", body })
+          );
+          acceptMessagePair(response);
         }
-        response = await $fetch(
-          chatApi.path(`/conversations/${currentConversation.value.id}/messages`),
-          chatApi.withChatHeaders({ method: "POST", body })
-        );
-        acceptMessagePair(response);
       }
       if (files && files.length > 0) {
         addFilesToConversation(
@@ -565,9 +627,15 @@ export function useChat(options = {}) {
       return response.userMessage;
     } catch (err) {
       const code = getChatApiErrorCode(err);
+      const status = getChatApiErrorStatus(err);
+      if (v2AdmissionRequested && !controller.signal.aborted && (status === null || status === 408 || status === 429 || status >= 500)) {
+        error.value = "Confirma\xE7\xE3o do envio pendente. Reconectando \xE0 conversa\u2026";
+        startPolling();
+        return optimisticUserMessage;
+      }
       const queuedAttempts = (queuedSend?.attempts ?? 0) + 1;
       const queuedAgeMs = Date.now() - (queuedSend?.queuedAt ?? Date.now());
-      if (outboundQueueEnabled.value && (code === "turn_in_progress" || code === "sandbox_not_woken") && queuedAttempts < 3 && queuedAgeMs <= 9e4) {
+      if (!chatApi.conversationV2Enabled && outboundQueueEnabled.value && (code === "turn_in_progress" || code === "sandbox_not_woken") && queuedAttempts < 3 && queuedAgeMs <= 9e4) {
         outbound.replace({
           content,
           files,
@@ -648,6 +716,7 @@ export function useChat(options = {}) {
       void flushOutboundQueue();
   });
   const clearConversation = () => {
+    runtimeBlocked.value = false;
     stopPolling();
     gateController?.abort();
     streamingMessageId.value = null;
@@ -682,11 +751,30 @@ export function useChat(options = {}) {
       gateController?.abort();
       return true;
     }
-    if (!currentConversation.value || !hasPendingMessage.value)
+    if (!currentConversation.value || !hasPendingMessage.value || chatApi.conversationV2Enabled && sending.value)
       return false;
     cancelling.value = true;
     error.value = null;
     try {
+      if (chatApi.conversationV2Enabled) {
+        const conversationId = currentConversation.value.id;
+        const runtime = await $fetch(
+          chatApi.runtimePath(`/conversations/${conversationId}/runtime`),
+          chatApi.withChatHeaders()
+        );
+        if (currentConversation.value?.id !== conversationId)
+          return false;
+        const pending = messages.value.findLast((message) => message.role === "assistant" && message.status === "pending");
+        if (runtime.turn?.id === pending?.id && runtime.turn?.state !== "failed") {
+          const result2 = await $fetch(
+            chatApi.runtimePath(`/conversations/${conversationId}/cancel`),
+            chatApi.withChatHeaders({ method: "POST" })
+          );
+          if (currentConversation.value?.id === conversationId)
+            await pollMessages();
+          return result2.cancelled;
+        }
+      }
       const result = await $fetch(
         chatApi.path(`/conversations/${currentConversation.value.id}/cancel`),
         chatApi.withChatHeaders({ method: "POST" })

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

@@ -43,6 +43,7 @@ export declare function useDirectStream(options?: {
     streamingThinking: any;
     activeRunId: any;
     connectMessage: (url: string, init: RequestInit, onAccepted: (response: SendMessageResponse) => void) => Promise<SendMessageResponse>;
+    connectConversation: (url: string, init: RequestInit, expectedAssistantMessageId?: string) => Promise<void>;
     beginMessage: () => void;
     disconnect: (reset?: boolean) => void;
 };

package/dist/runtime/messages/composables/use-direct-stream.js

@@ -137,7 +137,7 @@ export function useDirectStream(options = {}) {
     if (reset)
       resetAccumulator();
   }
-  async function connectMessage(url, init, onAccepted) {
+  async function connectStream(url, init, onAccepted, expectedAssistantMessageId) {
     if (import.meta.server)
       throw new Error("Message streaming is unavailable during server rendering");
     abortController?.abort();
@@ -170,6 +170,8 @@ export function useDirectStream(options = {}) {
         abortController = null;
       throw new Error("Message stream response has no body");
     }
+    if (controller.signal.aborted)
+      throw new DOMException("Aborted", "AbortError");
     activity.value = "connected";
     let resolveAccepted;
     let rejectAccepted;
@@ -177,7 +179,9 @@ export function useDirectStream(options = {}) {
       resolveAccepted = resolve;
       rejectAccepted = reject;
     });
-    let accepted = false;
+    let accepted = !onAccepted;
+    if (accepted)
+      resolveAccepted();
     let optimisticResultReported = false;
     let terminalEventObserved = false;
     let terminalReported = false;
@@ -244,6 +248,8 @@ export function useDirectStream(options = {}) {
             if (frame.data === "[DONE]")
               continue;
             if (frame.event === "message-accepted") {
+              if (!onAccepted)
+                continue;
               try {
                 const messagePair = reviveMessagePair(JSON.parse(frame.data));
                 accepted = true;
@@ -262,6 +268,11 @@ export function useDirectStream(options = {}) {
             }
             if (!isRecord(event) || typeof event.kind !== "string")
               continue;
+            if (event.kind === "conversation-state" && expectedAssistantMessageId && event.assistantMessageId !== expectedAssistantMessageId) {
+              controller.abort();
+              requestRecovery();
+              break;
+            }
             activity.value = "active";
             if (event.kind === "result") {
               settleResult(event.status);
@@ -301,8 +312,11 @@ export function useDirectStream(options = {}) {
         if (!accepted)
           rejectAccepted(error);
       } finally {
-        if (abortController === controller)
+        if (abortController === controller) {
           abortController = null;
+          if (!onAccepted)
+            activity.value = "idle";
+        }
         if (accepted && !terminalEventObserved && !controller.signal.aborted)
           requestRecovery();
       }
@@ -315,7 +329,8 @@ export function useDirectStream(options = {}) {
     streamingText: readonly(streamingText),
     streamingThinking: readonly(streamingThinking),
     activeRunId: readonly(activeRunId),
-    connectMessage,
+    connectMessage: (url, init, onAccepted) => connectStream(url, init, onAccepted),
+    connectConversation: (url, init, expectedAssistantMessageId) => connectStream(url, { ...init, method: "GET" }, void 0, expectedAssistantMessageId),
     beginMessage,
     disconnect
   };

package/dist/runtime/server/api/v2/conversations/[...path].d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/v2/conversations/[...path].js

@@ -0,0 +1,2 @@
+import { defineChatApiProxyHandler, prefixProxyPath } from "../../../utils/chat-api-proxy.js";
+export default defineChatApiProxyHandler((path) => prefixProxyPath("conversations", path), { apiVersion: "v2" });

package/dist/runtime/server/utils/chat-api-proxy.d.ts

@@ -1,6 +1,12 @@
 import type { H3Event } from 'h3';
+export type ChatApiVersion = 'v1' | 'v2';
+export declare function resolveChatBasePath(basePath: string, apiVersion: ChatApiVersion): string;
 export declare function mapVaultProxyPath(path: string): string;
 export declare function mapWorkspaceProxyPath(path: string): string;
 export declare function prefixProxyPath(prefix: string, path: string): string;
-export declare function proxyChatApiRequest(event: H3Event, targetPath: string): Promise<any>;
-export declare function defineChatApiProxyHandler(resolveTargetPath: (path: string) => string): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export declare function proxyChatApiRequest(event: H3Event, targetPath: string, options?: {
+    apiVersion?: ChatApiVersion;
+}): Promise<any>;
+export declare function defineChatApiProxyHandler(resolveTargetPath: (path: string) => string, options?: {
+    apiVersion?: ChatApiVersion;
+}): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;

package/dist/runtime/server/utils/chat-api-proxy.js

@@ -1,4 +1,4 @@
-import { AGENT_API_V5_CONFIG_KEY, PREPARED_AGENT_RUNTIME_CONFIG_KEY, SECRETLESS_EXECUTION_CONFIG_KEY } from "../../types/schemas/chat/chat-config.js";
+import { AGENT_API_V5_CONFIG_KEY, CONVERSATION_V2_CONFIG_KEY, PREPARED_AGENT_RUNTIME_CONFIG_KEY, SECRETLESS_EXECUTION_CONFIG_KEY } from "../../types/schemas/chat/chat-config.js";
 import { createError, defineEventHandler, getHeader, getRequestURL, getRouterParam, proxyRequest } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
 import { resolveAuthToken } from "./auth-token.js";
@@ -43,10 +43,20 @@ function resolveChatApiUrl(event) {
   }
   return chatApiUrl;
 }
-function buildTargetUrl(event, targetPath) {
+export function resolveChatBasePath(basePath, apiVersion) {
+  const versionSuffix = `${apiVersion}/chat`;
+  if (basePath.endsWith("v1/chat")) {
+    return apiVersion === "v1" ? basePath : joinProxyPath(basePath.slice(0, -"v1/chat".length), versionSuffix);
+  }
+  if (basePath.endsWith("v1")) {
+    return apiVersion === "v1" ? joinProxyPath(basePath, "chat") : joinProxyPath(basePath.slice(0, -"v1".length), versionSuffix);
+  }
+  return joinProxyPath(basePath, versionSuffix);
+}
+function buildTargetUrl(event, targetPath, apiVersion = "v1") {
   const base = new URL(resolveChatApiUrl(event));
   const basePath = normalizeProxyPath(base.pathname);
-  const chatBasePath = basePath.endsWith("v1/chat") ? basePath : basePath.endsWith("v1") ? joinProxyPath(basePath, "chat") : joinProxyPath(basePath, "v1/chat");
+  const chatBasePath = resolveChatBasePath(basePath, apiVersion);
   base.pathname = `/${joinProxyPath(chatBasePath, targetPath)}`;
   base.search = getRequestURL(event).search;
   return base.toString();
@@ -60,7 +70,10 @@ function buildProxyHeaders(event) {
     });
   }
   const config = useRuntimeConfig(event);
-  const chatConfig = { [PREPARED_AGENT_RUNTIME_CONFIG_KEY]: true };
+  const chatConfig = {
+    [PREPARED_AGENT_RUNTIME_CONFIG_KEY]: true,
+    [CONVERSATION_V2_CONFIG_KEY]: true
+  };
   if (config.chatNuxt?.secretlessExecution) {
     chatConfig[SECRETLESS_EXECUTION_CONFIG_KEY] = true;
   }
@@ -110,8 +123,8 @@ export function mapWorkspaceProxyPath(path) {
 export function prefixProxyPath(prefix, path) {
   return joinProxyPath(prefix, path);
 }
-export async function proxyChatApiRequest(event, targetPath) {
-  return proxyRequest(event, buildTargetUrl(event, targetPath), {
+export async function proxyChatApiRequest(event, targetPath, options = {}) {
+  return proxyRequest(event, buildTargetUrl(event, targetPath, options.apiVersion ?? "v1"), {
     fetchOptions: {
       redirect: "manual"
     },
@@ -119,9 +132,9 @@ export async function proxyChatApiRequest(event, targetPath) {
     streamRequest: true
   });
 }
-export function defineChatApiProxyHandler(resolveTargetPath) {
+export function defineChatApiProxyHandler(resolveTargetPath, options = {}) {
   return defineEventHandler((event) => {
     const path = getRouterParam(event, "path") || "";
-    return proxyChatApiRequest(event, resolveTargetPath(path));
+    return proxyChatApiRequest(event, resolveTargetPath(path), options);
   });
 }

package/dist/runtime/shared/composables/chat-api.d.ts

@@ -1,5 +1,7 @@
 export declare function useChatApi(): {
     path: (routePath: string) => string;
+    runtimePath: (routePath: string) => string;
+    conversationV2Enabled: boolean;
     withChatHeaders: <const T extends Record<string, any>>(options?: T) => T & {
         headers?: Record<string, string>;
     };

package/dist/runtime/shared/composables/chat-api.js

@@ -38,6 +38,8 @@ export function useChatApi() {
   }
   return {
     path,
+    runtimePath: (routePath) => `/api/v2${routePath}`,
+    conversationV2Enabled: true,
     withChatHeaders
   };
 }

package/dist/runtime/types/schemas/chat/chat-config.d.ts

@@ -1,3 +1,4 @@
 export declare const PREPARED_AGENT_RUNTIME_CONFIG_KEY = "prepared-agent-runtime";
 export declare const SECRETLESS_EXECUTION_CONFIG_KEY = "secretless-execution";
 export declare const AGENT_API_V5_CONFIG_KEY = "agent-api-v5";
+export declare const CONVERSATION_V2_CONFIG_KEY = "conversation-v2";

package/dist/runtime/types/schemas/chat/chat-config.js

@@ -1,3 +1,4 @@
 export const PREPARED_AGENT_RUNTIME_CONFIG_KEY = 'prepared-agent-runtime';
 export const SECRETLESS_EXECUTION_CONFIG_KEY = 'secretless-execution';
 export const AGENT_API_V5_CONFIG_KEY = 'agent-api-v5';
+export const CONVERSATION_V2_CONFIG_KEY = 'conversation-v2';

package/dist/runtime/types/schemas/chat/conversation-runtime.d.ts

@@ -0,0 +1,239 @@
+import { z } from 'zod';
+export declare const conversationRuntimeStateSchema: z.ZodEnum<{
+    waiting_messages: "waiting_messages";
+    blocked: "blocked";
+}>;
+export type ConversationRuntimeState = z.infer<typeof conversationRuntimeStateSchema>;
+export declare const turnRuntimeStateNameSchema: z.ZodEnum<{
+    running: "running";
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+    accepted: "accepted";
+    checking_session: "checking_session";
+    waiting_for_wake: "waiting_for_wake";
+    dispatching: "dispatching";
+    streaming: "streaming";
+}>;
+export type TurnRuntimeStateName = z.infer<typeof turnRuntimeStateNameSchema>;
+export declare const conversationWakeStateSchema: z.ZodEnum<{
+    failed: "failed";
+    waking: "waking";
+    parked: "parked";
+    ready: "ready";
+    stale: "stale";
+    checking: "checking";
+}>;
+export type ConversationWakeState = z.infer<typeof conversationWakeStateSchema>;
+export declare const wakeConversationResponseSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        failed: "failed";
+        waking: "waking";
+        parked: "parked";
+        ready: "ready";
+        stale: "stale";
+        checking: "checking";
+    }>;
+    sessionId: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type WakeConversationResponse = z.infer<typeof wakeConversationResponseSchema>;
+export declare const turnSnapshotSchema: z.ZodObject<{
+    id: z.ZodString;
+    state: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        accepted: "accepted";
+        checking_session: "checking_session";
+        waiting_for_wake: "waiting_for_wake";
+        dispatching: "dispatching";
+        streaming: "streaming";
+    }>;
+    sessionId: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type TurnSnapshot = z.infer<typeof turnSnapshotSchema>;
+export declare const sendMessageV2BodySchema: z.ZodObject<{
+    messageId: z.ZodString;
+    content: z.ZodString;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+        vaultReference: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    agentInputs: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        name: z.ZodString;
+        vaultRef: z.ZodString;
+        filename: z.ZodString;
+        metadata: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        name: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>], "type">>>;
+    clientTiming: z.ZodOptional<z.ZodObject<{
+        sinceSendMs: z.ZodNumber;
+        standInOutputAtMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SendMessageV2Body = z.infer<typeof sendMessageV2BodySchema>;
+export declare const sendMessageV2ResponseSchema: z.ZodObject<{
+    userMessage: z.ZodObject<{
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+        }>;
+        content: z.ZodString;
+        status: z.ZodNullable<z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+            failed: "failed";
+        }>>;
+        failReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reasoningData: z.ZodUnknown;
+        files: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            vaultReference: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            mimeType: z.ZodOptional<z.ZodString>;
+            source: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>;
+            size: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        externalUuid: z.ZodNullable<z.ZodString>;
+        ttft: z.ZodNullable<z.ZodString>;
+        createdBy: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodNullable<z.ZodDate>;
+    }, z.core.$strip>;
+    assistantMessage: z.ZodObject<{
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+        }>;
+        content: z.ZodString;
+        status: z.ZodNullable<z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+            failed: "failed";
+        }>>;
+        failReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reasoningData: z.ZodUnknown;
+        files: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            vaultReference: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            mimeType: z.ZodOptional<z.ZodString>;
+            source: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>;
+            size: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        externalUuid: z.ZodNullable<z.ZodString>;
+        ttft: z.ZodNullable<z.ZodString>;
+        createdBy: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodNullable<z.ZodDate>;
+    }, z.core.$strip>;
+    turn: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        state: z.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            accepted: "accepted";
+            checking_session: "checking_session";
+            waiting_for_wake: "waiting_for_wake";
+            dispatching: "dispatching";
+            streaming: "streaming";
+        }>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    conversation: z.ZodObject<{
+        runtimeState: z.ZodEnum<{
+            waiting_messages: "waiting_messages";
+            blocked: "blocked";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SendMessageV2Response = z.infer<typeof sendMessageV2ResponseSchema>;
+export declare const conversationRuntimeV2ResponseSchema: z.ZodObject<{
+    conversation: z.ZodObject<{
+        runtimeState: z.ZodEnum<{
+            waiting_messages: "waiting_messages";
+            blocked: "blocked";
+        }>;
+    }, z.core.$strip>;
+    turn: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        state: z.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            accepted: "accepted";
+            checking_session: "checking_session";
+            waiting_for_wake: "waiting_for_wake";
+            dispatching: "dispatching";
+            streaming: "streaming";
+        }>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ConversationRuntimeV2Response = z.infer<typeof conversationRuntimeV2ResponseSchema>;
+export declare const cancelConversationV2ResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    cancelled: z.ZodBoolean;
+    turn: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        state: z.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            accepted: "accepted";
+            checking_session: "checking_session";
+            waiting_for_wake: "waiting_for_wake";
+            dispatching: "dispatching";
+            streaming: "streaming";
+        }>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CancelConversationV2Response = z.infer<typeof cancelConversationV2ResponseSchema>;
+export declare const conversationRuntimeWebhookPayloadSchema: z.ZodObject<{
+    eventType: z.ZodEnum<{
+        "session.started": "session.started";
+        "session.completed": "session.completed";
+        "session.failed": "session.failed";
+        "session.cancelled": "session.cancelled";
+        "session.waiting_messages": "session.waiting_messages";
+    }>;
+    sessionId: z.ZodString;
+    status: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    failReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    result: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
+    deliveryId: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type ConversationRuntimeWebhookPayload = z.infer<typeof conversationRuntimeWebhookPayloadSchema>;
+export declare const conversationRuntimeWebhookResponseSchema: z.ZodObject<{
+    handled: z.ZodBoolean;
+}, z.core.$strip>;
+export type ConversationRuntimeWebhookResponse = z.infer<typeof conversationRuntimeWebhookResponseSchema>;

package/dist/runtime/types/schemas/chat/conversation-runtime.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { telaAgentExecutionInputSchema } from '../integrations/tela-agent-api';
+import { messageSchema } from './conversations';
+import { fileUploadInputSchema } from './files';
+import { sendMessageClientTimingSchema } from './messages';
+export const conversationRuntimeStateSchema = z.enum(['blocked', 'waiting_messages']);
+export const turnRuntimeStateNameSchema = z.enum([
+    'accepted',
+    'checking_session',
+    'waiting_for_wake',
+    'dispatching',
+    'running',
+    'streaming',
+    'completed',
+    'failed',
+    'cancelled',
+]);
+export const conversationWakeStateSchema = z.enum(['stale', 'checking', 'waking', 'ready', 'parked', 'failed']);
+export const wakeConversationResponseSchema = z.object({
+    state: conversationWakeStateSchema,
+    sessionId: z.string().nullable(),
+    error: z.string().nullable(),
+});
+export const turnSnapshotSchema = z.object({
+    id: z.string(),
+    state: turnRuntimeStateNameSchema,
+    sessionId: z.string().nullable(),
+    error: z.string().nullable(),
+});
+export const sendMessageV2BodySchema = z.strictObject({
+    messageId: z.string().uuid(),
+    content: z.string(),
+    files: z.array(fileUploadInputSchema).optional(),
+    agentInputs: z.array(telaAgentExecutionInputSchema).optional(),
+    clientTiming: sendMessageClientTimingSchema.optional(),
+});
+export const sendMessageV2ResponseSchema = z.object({
+    userMessage: messageSchema,
+    assistantMessage: messageSchema,
+    turn: turnSnapshotSchema.nullable(),
+    conversation: z.object({ runtimeState: conversationRuntimeStateSchema }),
+});
+export const conversationRuntimeV2ResponseSchema = z.object({
+    conversation: z.object({ runtimeState: conversationRuntimeStateSchema }),
+    turn: turnSnapshotSchema.nullable(),
+});
+export const cancelConversationV2ResponseSchema = z.object({
+    success: z.literal(true),
+    cancelled: z.boolean(),
+    turn: turnSnapshotSchema.nullable(),
+});
+export const conversationRuntimeWebhookPayloadSchema = z.object({
+    eventType: z.enum([
+        'session.started',
+        'session.completed',
+        'session.failed',
+        'session.cancelled',
+        'session.waiting_messages',
+    ]),
+    sessionId: z.string().min(1),
+    status: z.string().optional(),
+    error: z.string().nullable().optional(),
+    failReason: z.string().nullable().optional(),
+    result: z.union([z.string(), z.record(z.string(), z.unknown())]).nullable().optional(),
+    deliveryId: z.string().optional(),
+}).catchall(z.unknown());
+export const conversationRuntimeWebhookResponseSchema = z.object({
+    handled: z.boolean(),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/chat-nuxt",
-  "version": "3.17.0-rc.6",
+  "version": "3.17.0-rc.7",
   "type": "module",
   "exports": {
     ".": {
@@ -32,6 +32,8 @@
     "test:types": "pnpm build && tsc -p tsconfig.type-tests.json --noEmit",
     "smoke:pack": "./scripts/smoke-pack-consumer.sh",
     "smoke:browser": "./scripts/smoke-pack-consumer.sh --browser",
+    "smoke:browser:v1": "./scripts/smoke-pack-consumer.sh --browser-v1",
+    "smoke:browser:v2": "./scripts/smoke-pack-consumer.sh --browser-v2",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "lint:attrs": "! grep -rn '[a-z0-9-]![[:space:]>@\"'\"'\"']' --include='*.vue' src/runtime/ 2>/dev/null",