@meistrari/chat-nuxt 4.8.0-rc.0 → 4.8.0-rc.1

package/README.md

@@ -205,8 +205,10 @@ it takes precedence over both legacy flags as a whole.
 
 Supply model IDs available to the configured agent and effort levels supported
 by those models. Both profiles may use the same model. An explicit `null` effort
-uses the agent's configured effort. Profile selection sends model and effort in
-one update; a failed update restores both values. Sending waits for that update.
+uses the agent's configured effort. Profile selection keeps both settings local
+until the next send or fresh retry. That request persists the settings and records
+each changed field in the conversation history. Reloading discards unsent choices;
+a rejected admission restores the prior persisted settings.
 
 In `simple` mode, new conversations start with the `default` profile, regardless
 of `defaultModel` and `defaultReasoningEffort`. A selection stays within the current

package/dist/module.json

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

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

@@ -23,10 +23,6 @@ import {
   resolveTelaAgentInputs,
   useChat
 } from "../../messages/composables/chat";
-import {
-  ensureConversationUsesSelectedModel,
-  MODEL_UPDATE_FAILED_MESSAGE
-} from "../../messages/model-availability";
 import { useChatAction } from "../../messages/composables/chat-action";
 import { useChatApi } from "../../shared/composables/chat-api";
 import { useConversationFiles } from "../../files/composables/conversation-files";
@@ -95,9 +91,6 @@ const {
   createConversation,
   deleteConversation,
   renameConversation,
-  updateConversationModel,
-  updateConversationReasoningEffort,
-  updateConversationExecutionProfile,
   duplicateConversation,
   forkConversation,
   moveConversationToGroup,
@@ -227,10 +220,7 @@ const {
   loadConversation,
   setConversation,
   adoptConversation,
-  setConversationModel,
   pendingModelSelection,
-  setConversationReasoningEffort,
-  setConversationExecutionProfile,
   pendingReasoningEffortSelection,
   sendMessage,
   flushOutboundQueue,
@@ -247,114 +237,42 @@ const {
   onQueuedSendFailed: restoreQueuedSend
 });
 const agentWake = harnessAdapter?.requiresSandboxWake === false ? null : useAgentWake();
-const modelUpdateInFlight = ref(null);
-const reasoningEffortUpdateInFlight = ref(null);
-const REASONING_EFFORT_UPDATE_FAILED_MESSAGE = "N\xE3o foi poss\xEDvel atualizar o esfor\xE7o de racioc\xEDnio da conversa";
 watch(chatError, (message) => {
   if (message)
     statusToast.update({ text: message, icon: "i-ph-warning" });
 });
 const { total, files: conversationFiles, loading: conversationFilesLoading } = useConversationFiles(activeConversationId);
-function persistConversationModel(conversation, value, wakeAgent) {
-  const previousModel = conversation.model;
-  setConversationModel(value);
-  const update = updateConversationModel(conversation.id, value).then(async (updated) => {
-    if (!updated && currentConversation.value?.id === conversation.id && currentConversation.value.model === value) {
-      setConversationModel(previousModel);
-    } else if (agentWake && updated && value && wakeAgent && !chatApi.conversationV2Enabled) {
-      if (conversation.threadSessionId)
-        await agentWake.ensureReady(conversation.threadSessionId, value);
-      else
-        await agentWake.wake(void 0, value);
-    }
-    return updated;
-  });
-  const trackedUpdate = update.finally(() => {
-    if (modelUpdateInFlight.value === trackedUpdate)
-      modelUpdateInFlight.value = null;
-  });
-  modelUpdateInFlight.value = trackedUpdate;
-  return trackedUpdate;
-}
-async function waitForPendingModelUpdate() {
-  while (modelUpdateInFlight.value) {
-    const update = modelUpdateInFlight.value;
-    if (!await update)
-      throw new Error(MODEL_UPDATE_FAILED_MESSAGE);
-  }
-}
-function persistConversationReasoningEffort(conversation, value) {
-  const previousEffort = conversation.reasoningEffort ?? null;
-  setConversationReasoningEffort(value);
-  const update = updateConversationReasoningEffort(conversation.id, value).then((updated) => {
-    if (!updated && currentConversation.value?.id === conversation.id && (currentConversation.value.reasoningEffort ?? null) === value) {
-      setConversationReasoningEffort(previousEffort);
-    }
-    return updated;
-  });
-  const trackedUpdate = update.finally(() => {
-    if (reasoningEffortUpdateInFlight.value === trackedUpdate)
-      reasoningEffortUpdateInFlight.value = null;
-  });
-  reasoningEffortUpdateInFlight.value = trackedUpdate;
-  return trackedUpdate;
-}
-async function waitForPendingReasoningEffortUpdate() {
-  while (reasoningEffortUpdateInFlight.value) {
-    const update = reasoningEffortUpdateInFlight.value;
-    if (!await update)
-      throw new Error(REASONING_EFFORT_UPDATE_FAILED_MESSAGE);
-  }
-}
 function resolveSelectedModel(value) {
   return nativeModels ? nativeModels.resolve(value) : value;
 }
+const draftModel = ref(void 0);
+const draftReasoningEffort = ref(void 0);
+watch(() => currentConversation.value?.id, () => {
+  draftModel.value = void 0;
+  draftReasoningEffort.value = void 0;
+}, { flush: "sync" });
 const selectedModel = computed({
-  get: () => resolveSelectedModel(
-    currentConversation.value ? currentConversation.value.model : pendingModelSelection.value
-  ),
+  get: () => resolveSelectedModel(draftModel.value !== void 0 ? draftModel.value : currentConversation.value ? currentConversation.value.model : pendingModelSelection.value),
   set: (value) => {
-    const resolvedValue = resolveSelectedModel(value);
-    pendingModelSelection.value = resolvedValue;
-    const conversation = currentConversation.value;
-    if (conversation && conversation.model !== resolvedValue)
-      void persistConversationModel(conversation, resolvedValue, true);
+    const resolved = resolveSelectedModel(value);
+    pendingModelSelection.value = resolved;
+    draftModel.value = resolved;
   }
 });
 const selectedReasoningEffort = computed({
-  get: () => currentConversation.value ? currentConversation.value.reasoningEffort ?? null : pendingReasoningEffortSelection.value,
+  get: () => draftReasoningEffort.value !== void 0 ? draftReasoningEffort.value : currentConversation.value ? currentConversation.value.reasoningEffort ?? null : pendingReasoningEffortSelection.value,
   set: (value) => {
     pendingReasoningEffortSelection.value = value;
-    const conversation = currentConversation.value;
-    if (conversation && (conversation.reasoningEffort ?? null) !== value)
-      void persistConversationReasoningEffort(conversation, value);
+    draftReasoningEffort.value = value;
   }
 });
 function selectExecutionProfile(profile) {
-  if (modelUpdateInFlight.value || reasoningEffortUpdateInFlight.value)
-    return;
-  const conversation = currentConversation.value;
-  if (!conversation) {
-    pendingModelSelection.value = profile.model;
+  draftModel.value = resolveSelectedModel(profile.model);
+  draftReasoningEffort.value = profile.reasoningEffort;
+  if (!currentConversation.value) {
+    pendingModelSelection.value = draftModel.value;
     pendingReasoningEffortSelection.value = profile.reasoningEffort;
-    return;
   }
-  const previous = { model: conversation.model, reasoningEffort: conversation.reasoningEffort ?? null };
-  setConversationExecutionProfile(profile);
-  const update = updateConversationExecutionProfile(conversation.id, profile).then((updated) => {
-    if (!updated) {
-      if (currentConversation.value?.id === conversation.id && currentConversation.value.model === profile.model && (currentConversation.value.reasoningEffort ?? null) === profile.reasoningEffort) {
-        setConversationExecutionProfile(previous);
-      }
-      statusToast.update({ text: "N\xE3o foi poss\xEDvel atualizar o modo de resposta da conversa", icon: "i-ph-warning" });
-    }
-    return updated;
-  });
-  const trackedUpdate = update.finally(() => {
-    if (modelUpdateInFlight.value === trackedUpdate)
-      modelUpdateInFlight.value = null;
-  });
-  modelUpdateInFlight.value = trackedUpdate;
 }
 const filesCount = computed(() => total.value);
 const showDetailsPanel = computed(() => !!currentConversation.value && !isMobile.value && !props.compact);
@@ -441,6 +359,8 @@ async function ensureConversationLoaded(conversationId) {
   }
 }
 function resetConversation(shouldEmit = true) {
+  draftModel.value = void 0;
+  draftReasoningEffort.value = void 0;
   clearConversation();
   agentWake?.consume();
   if (agentWake && !chatApi.conversationV2Enabled)
@@ -622,14 +542,14 @@ async function handleSend(content, files, agentInputs) {
     restoreQueuedSend({ content: prepared?.retryContent?.() ?? content, files, agentInputs: resolvedAgentInputs });
 }
 async function dispatchMessage(outbound, files, resolvedAgentInputs) {
+  const executionSettings = { model: selectedModel.value, reasoningEffort: selectedReasoningEffort.value };
   if (props.sendBlocked)
     return false;
   let claimedWakeSessionId;
   const sent = await sendMessage(outbound, files.length > 0 ? files : void 0, resolvedAgentInputs, async (signal) => {
     if (!activeConversationId.value || !currentConversation.value) {
       const conversation2 = await createConversation({
-        model: selectedModel.value,
-        reasoningEffort: selectedReasoningEffort.value,
+        ...executionSettings,
         ...resolvedAgentInputs !== void 0 ? { agentInputs: resolvedAgentInputs } : {}
       });
       if (!conversation2)
@@ -640,36 +560,29 @@ async function dispatchMessage(outbound, files, resolvedAgentInputs) {
       adoptConversation(grouped ? { ...conversation2, groupId } : conversation2);
       updateConversationId(conversation2.id);
     }
-    await waitForPendingModelUpdate();
-    await waitForPendingReasoningEffortUpdate();
     const conversation = currentConversation.value;
     if (!conversation)
       throw new Error("Erro ao preparar conversa");
-    await (nativeModels?.ensureSelectedModel ?? ensureConversationUsesSelectedModel)(
-      conversation.model,
-      selectedModel.value,
-      (value) => persistConversationModel(conversation, value, false)
-    );
     if (!agentWake || chatApi.conversationV2Enabled)
-      return {};
+      return { executionSettings };
     if (conversation.threadSessionId && resolvedFeatures.value.chatOutboundQueue) {
-      const wake = await agentWake.ensureReady(conversation.threadSessionId, selectedModel.value);
+      const wake = await agentWake.ensureReady(conversation.threadSessionId, executionSettings.model);
       if (wake.status !== "ready") {
         if (wake.wokenSandbox && !wake.wokenSandbox.rewakeable)
-          return { defer: true };
+          return { defer: true, executionSettings };
         throw new Error("N\xE3o foi poss\xEDvel acordar o agente. Tente novamente.");
       }
-      return {};
+      return { executionSettings };
     }
     if (!conversation.threadSessionId) {
       await agentWake.waitUntilSettled(signal);
       if (agentWake.state.value === "idle")
-        await agentWake.wake(void 0, selectedModel.value);
+        await agentWake.wake(void 0, executionSettings.model);
     }
     claimedWakeSessionId = claimableWakeSessionId();
     if (!conversation.threadSessionId && !claimedWakeSessionId)
       throw new Error("N\xE3o foi poss\xEDvel acordar o agente. Tente novamente.");
-    return claimedWakeSessionId ? { wakeSessionId: claimedWakeSessionId } : {};
+    return { executionSettings, ...claimedWakeSessionId ? { wakeSessionId: claimedWakeSessionId } : {} };
   });
   if (sent && claimedWakeSessionId)
     agentWake?.consume();
@@ -712,26 +625,21 @@ async function handleCancel() {
   await cancelConversation();
 }
 async function handleRetry(messageId) {
+  const executionSettings = { model: selectedModel.value, reasoningEffort: selectedReasoningEffort.value };
   await retryMessage(messageId, async () => {
-    await waitForPendingModelUpdate();
-    await waitForPendingReasoningEffortUpdate();
     const conversation = currentConversation.value;
     if (!conversation)
       throw new Error("Erro ao preparar conversa");
-    await (nativeModels?.ensureSelectedModel ?? ensureConversationUsesSelectedModel)(
-      conversation.model,
-      selectedModel.value,
-      (value) => persistConversationModel(conversation, value, false)
-    );
     if (!agentWake || chatApi.conversationV2Enabled)
-      return;
+      return { executionSettings };
     if (conversation.threadSessionId) {
-      const wake = await agentWake.ensureReady(conversation.threadSessionId, selectedModel.value);
+      const wake = await agentWake.ensureReady(conversation.threadSessionId, executionSettings.model);
       if (wake.status !== "ready")
         throw new Error("N\xE3o foi poss\xEDvel acordar o agente. Tente novamente.");
     } else {
       agentWake.consume();
     }
+    return { executionSettings };
   });
 }
 async function handleNewConversation(groupId) {
@@ -818,30 +726,35 @@ function handleShare(conversationId) {
   if (id)
     void copyConversationLink(id);
 }
-const forkEvents = shallowRef([]);
+const persistedConversationEvents = shallowRef([]);
 const displayConversationEvents = computed(() => [...new Map([
-  ...forkEvents.value,
+  ...persistedConversationEvents.value,
   ...props.conversationEvents ?? []
 ].filter((event) => event.conversationId === currentConversation.value?.id).map((event) => [event.id, event])).values()]);
 watch([
   () => currentConversation.value?.id,
-  () => JSON.stringify(chatApi.withChatHeaders().headers)
-], async ([conversationId], _previous, onCleanup) => {
-  forkEvents.value = [];
-  if (!conversationId || !chatApi.conversationV2Enabled)
+  () => JSON.stringify(chatApi.withChatHeaders().headers),
+  () => JSON.stringify(messages.value.filter((message) => message.role === "user").map((message) => [message.id, message.createdAt, message.externalUuid])),
+  () => isPolling.value
+], async ([conversationId], previous, onCleanup) => {
+  if (conversationId !== previous?.[0] || JSON.stringify(chatApi.withChatHeaders().headers) !== previous?.[1])
+    persistedConversationEvents.value = [];
+  if (!conversationId)
     return;
-  const controller = new AbortController();
-  onCleanup(() => controller.abort());
+  let current = true;
+  onCleanup(() => {
+    current = false;
+  });
   try {
     const { events } = await $fetch(
       chatApi.path(`/conversations/${conversationId}/events`),
-      chatApi.withChatHeaders({ signal: controller.signal })
+      chatApi.withChatHeaders()
     );
-    if (!controller.signal.aborted)
-      forkEvents.value = events.filter((event) => event.type === "conversation_forked");
+    if (current)
+      persistedConversationEvents.value = events;
   } catch {
-    if (!controller.signal.aborted)
-      statusToast.update({ text: "Erro ao carregar a origem da conversa", icon: "i-ph-warning" });
+    if (current)
+      statusToast.update({ text: "Erro ao carregar os eventos da conversa", icon: "i-ph-warning" });
   }
 }, { immediate: true });
 const forking = ref(false);

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

@@ -33,10 +33,13 @@ export declare function useChat(options?: Parameters<typeof useSharedChat>[0]):
     sendMessage: (content: string, files?: FileUploadInput[], agentInputs?: TelaAgentExecutionInput[], prepare?: (signal: AbortSignal) => Promise<{
         wakeSessionId?: string;
         defer?: boolean;
+        executionSettings?: ExecutionSettings;
     }>, queuedSend?: import("../../../messages/composables/outbound-queue.js").QueuedSend) => Promise<Message | null>;
     flushOutboundQueue: (wakeSessionId?: string) => Promise<Message | null>;
     failOutboundQueue: (message: string) => boolean;
-    retryMessage: (messageId: string, prepare?: () => Promise<void>) => Promise<boolean>;
+    retryMessage: (messageId: string, prepare?: () => Promise<{
+        executionSettings?: ExecutionSettings;
+    } | void>) => Promise<boolean>;
     cancelConversation: () => Promise<boolean>;
     startPolling: () => void;
     reconnect: () => void;

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

@@ -4,7 +4,7 @@ import { type DeepReadonly, type MaybeRefOrGetter, type Ref } from 'vue';
 import type { Conversation, ConversationWithMessages, Message } from '../../types/schemas/chat/conversations.js';
 import { type ChatReasoningEffort } from '../../types/schemas/chat/models.js';
 import type { FileUploadInput, MessageFile } from '../../types/schemas/chat/files.js';
-import type { SendMessageBody } from '../../types/schemas/chat/messages.js';
+import type { ExecutionSettings, SendMessageBody } from '../../types/schemas/chat/messages.js';
 import type { TelaAgentExecutionInput } from '../../types/schemas/integrations/tela-agent-api.js';
 import { useDirectStream } from './use-direct-stream.js';
 import { type QueuedSend } from './outbound-queue.js';
@@ -56,10 +56,13 @@ export declare function useChat(options?: {
     sendMessage: (content: string, files?: FileUploadInput[], agentInputs?: TelaAgentExecutionInput[], prepare?: (signal: AbortSignal) => Promise<{
         wakeSessionId?: string;
         defer?: boolean;
+        executionSettings?: ExecutionSettings;
     }>, queuedSend?: QueuedSend) => Promise<Message | null>;
     flushOutboundQueue: (wakeSessionId?: string) => Promise<Message | null>;
     failOutboundQueue: (message: string) => boolean;
-    retryMessage: (messageId: string, prepare?: () => Promise<void>) => Promise<boolean>;
+    retryMessage: (messageId: string, prepare?: () => Promise<{
+        executionSettings?: ExecutionSettings;
+    } | void>) => Promise<boolean>;
     cancelConversation: () => Promise<boolean>;
     startPolling: () => void;
     reconnect: () => void;

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

@@ -565,6 +565,7 @@ export function useChat(options = {}, adapter = {}) {
       messages.value = [...messages.value, optimisticUserMessage, optimisticAssistantMessage];
     const controller = new AbortController();
     gateController = controller;
+    let executionSettings = queuedSend?.executionSettings;
     let v2AdmissionRequested = false;
     try {
       let wakeSessionId = queuedSend?.wakeSessionId;
@@ -573,6 +574,7 @@ export function useChat(options = {}, adapter = {}) {
         gateHolding.value = true;
         try {
           const prepared = await prepare(controller.signal);
+          executionSettings = prepared.executionSettings;
           wakeSessionId = prepared.wakeSessionId;
           defer = prepared.defer === true;
         } finally {
@@ -589,6 +591,7 @@ export function useChat(options = {}, adapter = {}) {
           content,
           files,
           agentInputs,
+          executionSettings,
           wakeSessionId,
           optimisticIds: { user: optimisticUserMessage.id, assistant: optimisticAssistantMessage.id },
           queuedAt: Date.now(),
@@ -601,6 +604,7 @@ export function useChat(options = {}, adapter = {}) {
       const resolvedAgentInputs = resolveTelaAgentInputs(agentInputs, embedConfig?.telaAgentInputs?.value);
       const body = {
         content,
+        ...executionSettings ? { executionSettings } : {},
         files,
         ...resolvedAgentInputs !== void 0 ? { agentInputs: resolvedAgentInputs } : {},
         ...wakeSessionId ? { wakeSessionId } : {},
@@ -630,6 +634,7 @@ export function useChat(options = {}, adapter = {}) {
       let response;
       if (chatApi.conversationV2Enabled) {
         const v2Body = {
+          ...executionSettings ? { executionSettings } : {},
           messageId: optimisticUserMessage.id,
           content,
           files,
@@ -696,6 +701,7 @@ export function useChat(options = {}, adapter = {}) {
               content,
               files,
               agentInputs,
+              executionSettings,
               wakeSessionId: void 0,
               optimisticIds: { user: optimisticUserMessage.id, assistant: optimisticAssistantMessage.id },
               queuedAt,
@@ -719,6 +725,7 @@ export function useChat(options = {}, adapter = {}) {
           content,
           files,
           agentInputs,
+          executionSettings,
           wakeSessionId: queuedSend?.wakeSessionId,
           optimisticIds: { user: optimisticUserMessage.id, assistant: optimisticAssistantMessage.id },
           queuedAt: queuedSend?.queuedAt ?? Date.now(),
@@ -917,8 +924,9 @@ export function useChat(options = {}, adapter = {}) {
     error.value = null;
     let retry = null;
     try {
+      let prepared;
       if (prepare)
-        await prepare();
+        prepared = await prepare();
       if (currentConversation.value?.id !== conversationId)
         return false;
       retry = beginAssistantMessageRetry(messages.value, messageId);
@@ -929,7 +937,7 @@ export function useChat(options = {}, adapter = {}) {
       directStream.beginMessage();
       const retriedMessage = await $fetch(
         chatApi.path(`/conversations/${conversationId}/messages/${messageId}/retry`),
-        chatApi.withChatHeaders({ method: "POST" })
+        chatApi.withChatHeaders({ method: "POST", ...prepared?.executionSettings ? { body: { executionSettings: prepared.executionSettings } } : {} })
       );
       if (currentConversation.value?.id !== conversationId)
         return true;

package/dist/runtime/messages/composables/outbound-queue.d.ts

@@ -1,7 +1,9 @@
+import type { ExecutionSettings } from '../../types/schemas/chat/messages.js';
 import type { FileUploadInput } from '../../types/schemas/chat/files.js';
 import type { TelaAgentExecutionInput } from '../../types/schemas/integrations/tela-agent-api.js';
 import type { ComputedRef } from 'vue';
 export interface QueuedSend {
+    executionSettings?: ExecutionSettings;
     content: string;
     files: FileUploadInput[] | undefined;
     agentInputs: TelaAgentExecutionInput[] | undefined;

package/dist/runtime/messages/conversation-timeline.js

@@ -22,6 +22,16 @@ export function mergeConversationTimeline(messages, events = []) {
       return left.kind === "event" ? -1 : 1;
     return left.id.localeCompare(right.id);
   });
+  for (const item of [...items]) {
+    if (item.kind !== "event" || !["model_changed", "reasoning_effort_changed"].includes(item.value.type))
+      continue;
+    const messageIndex = items.findIndex((candidate) => candidate.kind === "message" && candidate.id === item.value.payload.messageId && candidate.value.conversationId === item.value.conversationId);
+    if (messageIndex === -1)
+      continue;
+    items.splice(items.indexOf(item), 1);
+    const targetIndex = items.findIndex((candidate) => candidate.kind === "message" && candidate.id === item.value.payload.messageId);
+    items.splice(targetIndex, 0, item);
+  }
   for (const event of events ?? []) {
     const source = getConversationForkSource(event);
     if (!source)

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

@@ -82,6 +82,16 @@ export declare const sendMessageV2BodySchema: z.ZodObject<{
         sinceSendMs: z.ZodNumber;
         standInOutputAtMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
+    executionSettings: z.ZodOptional<z.ZodObject<{
+        model: z.ZodNullable<z.ZodString>;
+        reasoningEffort: z.ZodNullable<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type SendMessageV2Body = z.infer<typeof sendMessageV2BodySchema>;
 export declare const sendMessageV2ResponseSchema: z.ZodObject<{

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

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { telaAgentExecutionInputSchema } from '../integrations/tela-agent-api';
 import { messageSchema } from './conversations';
 import { fileUploadInputSchema } from './files';
-import { sendMessageClientTimingSchema } from './messages';
+import { executionSettingsSchema, sendMessageClientTimingSchema } from './messages';
 export const conversationRuntimeStateSchema = z.enum(['blocked', 'waiting_messages']);
 export const turnRuntimeStateNameSchema = z.enum([
     'accepted',
@@ -33,6 +33,7 @@ export const sendMessageV2BodySchema = z.strictObject({
     files: z.array(fileUploadInputSchema).optional(),
     agentInputs: z.array(telaAgentExecutionInputSchema).optional(),
     clientTiming: sendMessageClientTimingSchema.optional(),
+    executionSettings: executionSettingsSchema.optional(),
 });
 export const sendMessageV2ResponseSchema = z.object({
     userMessage: messageSchema,

package/dist/runtime/types/schemas/chat/conversations.d.ts

@@ -317,6 +317,25 @@ export declare const agentInputsChangedConversationEventSchema: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strip>;
 export type AgentInputsChangedConversationEvent = z.infer<typeof agentInputsChangedConversationEventSchema>;
+export declare const executionSettingsChangedPayloadSchema: z.ZodObject<{
+    messageId: z.ZodString;
+    previousModel: z.ZodNullable<z.ZodString>;
+    model: z.ZodNullable<z.ZodString>;
+    previousReasoningEffort: z.ZodNullable<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
+    reasoningEffort: z.ZodNullable<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
+}, z.core.$strip>;
 export declare const conversationEventsResponseSchema: z.ZodObject<{
     events: z.ZodArray<z.ZodObject<{
         id: z.ZodString;

package/dist/runtime/types/schemas/chat/conversations.js

@@ -86,6 +86,13 @@ export const agentInputsChangedConversationEventSchema = conversationEventSchema
         agentInputs: z.array(telaAgentExecutionInputSchema),
     }),
 });
+export const executionSettingsChangedPayloadSchema = z.object({
+    messageId: z.string().uuid(),
+    previousModel: z.string().nullable(),
+    model: z.string().nullable(),
+    previousReasoningEffort: chatReasoningEffortSchema.nullable(),
+    reasoningEffort: chatReasoningEffortSchema.nullable(),
+});
 export const conversationEventsResponseSchema = z.object({
     events: z.array(conversationEventSchema),
 });

package/dist/runtime/types/schemas/chat/messages.d.ts

@@ -50,8 +50,41 @@ export declare const sendMessageClientTimingSchema: z.ZodObject<{
     standInOutputAtMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type SendMessageClientTiming = z.infer<typeof sendMessageClientTimingSchema>;
+export declare const executionSettingsSchema: z.ZodObject<{
+    model: z.ZodNullable<z.ZodString>;
+    reasoningEffort: z.ZodNullable<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
+}, z.core.$strict>;
+export type ExecutionSettings = z.infer<typeof executionSettingsSchema>;
+export declare const retryMessageBodySchema: z.ZodObject<{
+    executionSettings: z.ZodOptional<z.ZodObject<{
+        model: z.ZodNullable<z.ZodString>;
+        reasoningEffort: z.ZodNullable<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const sendMessageBodySchema: z.ZodObject<{
     content: z.ZodString;
+    executionSettings: z.ZodOptional<z.ZodObject<{
+        model: z.ZodNullable<z.ZodString>;
+        reasoningEffort: z.ZodNullable<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+    }, z.core.$strict>>;
     files: z.ZodOptional<z.ZodArray<z.ZodObject<{
         url: z.ZodString;
         name: z.ZodString;

package/dist/runtime/types/schemas/chat/messages.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { telaAgentExecutionInputSchema, wokenSandboxStatusSchema } from '../integrations/tela-agent-api';
+import { chatModelSchema, chatReasoningEffortSchema } from './models';
 import { messageSchema } from './conversations';
 import { fileUploadInputSchema, messageFileSchema } from './files';
 import { messageRoleSchema, messageStatusSchema } from './primitives';
@@ -45,8 +46,16 @@ export const sendMessageClientTimingSchema = z.strictObject({
      */
     standInOutputAtMs: z.number().int().min(0).max(600_000).optional(),
 });
+export const executionSettingsSchema = z.strictObject({
+    model: chatModelSchema.nullable(),
+    reasoningEffort: chatReasoningEffortSchema.nullable(),
+});
+export const retryMessageBodySchema = z.strictObject({
+    executionSettings: executionSettingsSchema.optional(),
+});
 export const sendMessageBodySchema = z.strictObject({
     content: z.string(),
+    executionSettings: executionSettingsSchema.optional(),
     files: z.array(fileUploadInputSchema).optional(),
     agentInputs: z.array(telaAgentExecutionInputSchema).optional(),
     wakeSessionId: z.string().uuid().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/chat-nuxt",
-  "version": "4.8.0-rc.0",
+  "version": "4.8.0-rc.1",
   "type": "module",
   "exports": {
     ".": {