@meistrari/chat-nuxt 4.10.0-rc.2 → 4.10.0-rc.21

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

@@ -5,6 +5,7 @@ import type { Conversation, ConversationWithMessages, Message } from '../../type
 import { type ChatReasoningEffort } from '../../types/schemas/chat/models.js';
 import type { FileUploadInput, MessageFile } from '../../types/schemas/chat/files.js';
 import type { ExecutionSettings, SendMessageBody } from '../../types/schemas/chat/messages.js';
+import type { SendMessageV2Body } from '../../types/schemas/chat/conversation-runtime.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';
@@ -23,6 +24,20 @@ export declare function useChat(options?: {
     outboundQueueEnabled?: MaybeRefOrGetter<boolean>;
     onQueuedSendCancelled?: (send: QueuedSend) => void;
     onQueuedSendFailed?: (send: QueuedSend) => void;
+    /** The server recorded this message (its acknowledgement or a later poll); the composer draft can go. */
+    onSendConfirmed?: (send: {
+        conversationId: string;
+        content: string;
+        messageId: string;
+    }) => void;
+    onSendPrepared?: (send: {
+        conversationId: string;
+        body: SendMessageV2Body;
+    }) => string;
+    onMessagesReceived?: (snapshot: {
+        conversationId: string;
+        messages: Message[];
+    }) => void;
 }, adapter?: ChatStateAdapter): {
     currentConversation: any;
     messages: any;

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

@@ -37,6 +37,8 @@ const POLL_INTERVAL_MS = 500;
 const POLL_MAX_BACKOFF_MS = 5e3;
 const CHAT_REQUEST_TIMEOUT_MS = 15e3;
 const CHAT_UNAVAILABLE_TEXT = "Chat temporariamente indispon\xEDvel. Tente novamente.";
+const SEND_PENDING_TEXT = "Confirma\xE7\xE3o do envio pendente. Reconectando \xE0 conversa\u2026";
+const SEND_UNCONFIRMED_TEXT = "Sua mensagem n\xE3o foi confirmada pelo servidor. Mantenha esta conversa aberta e use Reenviar para tentar de novo.";
 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;
@@ -249,6 +251,22 @@ export function useChat(options = {}, adapter = {}) {
   let consecutivePollFailures = 0;
   let pollOutageStartedAt = null;
   const pollInterval = ref(POLL_INTERVAL_MS);
+  let uncertainSend = null;
+  function confirmSend(conversationId, content, messageId) {
+    uncertainSend = null;
+    options.onSendConfirmed?.({ conversationId, content, messageId });
+  }
+  function confirmUncertainSend(conversationId, durableMessages) {
+    const pending = uncertainSend;
+    if (!pending || pending.conversationId !== conversationId)
+      return;
+    const recorded = durableMessages.find((message) => message.role === "user" && (pending.messageId ? message.externalUuid === pending.messageId : !pending.knownIds.has(message.id) && message.content === pending.content));
+    if (!recorded)
+      return;
+    if (error.value === SEND_PENDING_TEXT)
+      error.value = null;
+    confirmSend(conversationId, pending.content, pending.messageId ?? recorded.id);
+  }
   const pollMessages = async () => {
     if (!currentConversation.value)
       return;
@@ -268,7 +286,7 @@ export function useChat(options = {}, adapter = {}) {
       if (generation !== pollGeneration || currentConversation.value?.id !== conversationId)
         return;
       resetPollOutage();
-      if (error.value === CHAT_UNAVAILABLE_TEXT)
+      if (error.value === CHAT_UNAVAILABLE_TEXT || error.value === SEND_UNCONFIRMED_TEXT)
         error.value = null;
       if (runtime)
         runtimeBlocked.value = runtime.conversation.runtimeState === "blocked";
@@ -277,9 +295,11 @@ export function useChat(options = {}, adapter = {}) {
         agentSessionExecutable.value = response.agentSession.executable;
         agentSessionRewakeable.value = response.agentSession.rewakeable ?? false;
       }
+      options.onMessagesReceived?.({ conversationId, messages: response.messages });
+      confirmUncertainSend(conversationId, response.messages);
       const queuedV2Send = chatApi.conversationV2Enabled ? outbound.slot.value : null;
       if (queuedV2Send) {
-        const admitted = response.messages.some((message) => message.id === queuedV2Send.optimisticIds.user);
+        const admitted = response.messages.some((message) => message.role === "user" && message.externalUuid === queuedV2Send.optimisticIds.user);
         if (admitted) {
           outbound.clear();
           gateHolding.value = false;
@@ -354,7 +374,7 @@ export function useChat(options = {}, adapter = {}) {
       if (terminalError || outageExhausted) {
         const message = statusCode === 501 || !terminalError ? CHAT_UNAVAILABLE_TEXT : getChatApiErrorMessage(err) ?? "Erro ao atualizar mensagens";
         if (!terminalError || statusCode === 501 || outbound.occupied.value) {
-          error.value = message;
+          error.value = outbound.occupied.value ? SEND_UNCONFIRMED_TEXT : message;
           stopPolling();
           return;
         }
@@ -505,8 +525,10 @@ export function useChat(options = {}, adapter = {}) {
       );
       if (generation !== loadGeneration)
         return false;
+      options.onMessagesReceived?.({ conversationId: id, messages: data.messages });
       currentConversation.value = data;
       messages.value = data.messages;
+      confirmUncertainSend(id, data.messages);
       pendingStreamReconciliationIds.value = /* @__PURE__ */ new Set();
       pendingRealResultIds.value = /* @__PURE__ */ new Set();
       if (shouldTreatLoadedConversationTitleAsGenerated(data.messages))
@@ -622,6 +644,7 @@ export function useChat(options = {}, adapter = {}) {
         if (sentEmitted)
           return;
         sentEmitted = true;
+        confirmSend(response2.userMessage.conversationId, content, chatApi.conversationV2Enabled ? optimisticUserMessage.id : response2.userMessage.id);
         chatMessageSent.emit({
           conversationId: response2.userMessage.conversationId,
           messageId: response2.userMessage.id,
@@ -658,6 +681,13 @@ export function useChat(options = {}, adapter = {}) {
           clientTiming: body.clientTiming
         };
         const conversationId2 = currentConversation.value.id;
+        const preparedMessageId = options.onSendPrepared?.({ conversationId: conversationId2, body: v2Body });
+        if (preparedMessageId && preparedMessageId !== optimisticUserMessage.id) {
+          const previousId = optimisticUserMessage.id;
+          optimisticUserMessage.id = preparedMessageId;
+          v2Body.messageId = preparedMessageId;
+          messages.value = messages.value.map((message) => message.id === previousId ? optimisticUserMessage : message);
+        }
         v2AdmissionRequested = true;
         const accepted = await $fetch(
           chatApi.runtimePath(`/conversations/${conversationId2}/messages`),
@@ -687,6 +717,12 @@ export function useChat(options = {}, adapter = {}) {
           if (statusCode !== null && statusCode >= 400 && statusCode < 500)
             throw streamError;
           if (outboundQueueEnabled.value) {
+            uncertainSend = {
+              conversationId: currentConversation.value.id,
+              content,
+              messageId: null,
+              knownIds: new Set(messages.value.map((message) => message.id))
+            };
             startPolling();
             return optimisticUserMessage;
           }
@@ -725,12 +761,14 @@ export function useChat(options = {}, adapter = {}) {
               attempts
             });
             gateHolding.value = true;
-            error.value = "Confirma\xE7\xE3o do envio pendente. Reconectando \xE0 conversa\u2026";
+            error.value = SEND_PENDING_TEXT;
+            uncertainSend = { conversationId: currentConversation.value?.id ?? conversationId, content, messageId: optimisticUserMessage.id, knownIds: /* @__PURE__ */ new Set() };
             startPolling();
             return optimisticUserMessage;
           }
         } else {
-          error.value = "Confirma\xE7\xE3o do envio pendente. Reconectando \xE0 conversa\u2026";
+          error.value = SEND_PENDING_TEXT;
+          uncertainSend = { conversationId: currentConversation.value?.id ?? conversationId, content, messageId: optimisticUserMessage.id, knownIds: /* @__PURE__ */ new Set() };
           startPolling();
           return optimisticUserMessage;
         }
@@ -766,6 +804,8 @@ export function useChat(options = {}, adapter = {}) {
       clearPreparingSteps();
       directStream.disconnect();
       stopPolling();
+      if (uncertainSend?.messageId === optimisticUserMessage.id)
+        uncertainSend = null;
       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";
@@ -810,6 +850,8 @@ export function useChat(options = {}, adapter = {}) {
     clearPreparingSteps();
     directStream.disconnect();
     stopPolling();
+    if (uncertainSend?.messageId === queued.optimisticIds.user)
+      uncertainSend = null;
     error.value = message;
     options.onQueuedSendFailed?.(queued);
     return true;
@@ -853,6 +895,8 @@ export function useChat(options = {}, adapter = {}) {
       clearPreparingSteps();
       directStream.disconnect();
       stopPolling();
+      if (uncertainSend?.messageId === queued.optimisticIds.user)
+        uncertainSend = null;
       options.onQueuedSendCancelled?.(queued);
       return true;
     }

package/dist/runtime/messages/composer-draft.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Where the composer keeps the text of one conversation until the server
+ * confirms it recorded the message. Scoped to the user and workspace so a
+ * shared browser never shows one person's draft to another; `null` (no user
+ * yet) disables persistence.
+ */
+export declare function composerDraftStorageKey(owner: {
+    userId?: string | null;
+    workspaceId?: string | null;
+    telaAgentId?: string | null;
+    conversationScope?: string | null;
+}, conversationId: string | null): string | null;
+export declare function readComposerDraft(key: string | null): string;
+/** Empty text removes the draft. False when nothing was stored (no key, denied or full storage). */
+export declare function writeComposerDraft(key: string | null, text: string): boolean;
+export declare function composerDraftText(editor: HTMLElement | null): string;

package/dist/runtime/messages/composer-draft.js

@@ -0,0 +1,61 @@
+import { normalizeConversationScope, normalizeTelaAgentId } from "../conversations/scope.js";
+const DRAFT_KEY_PREFIX = "chat-composer-draft";
+export function composerDraftStorageKey(owner, conversationId) {
+  if (!owner.userId || !owner.workspaceId)
+    return null;
+  return `${DRAFT_KEY_PREFIX}:v2:${encodeURIComponent(JSON.stringify([owner.workspaceId, owner.userId, normalizeTelaAgentId(owner.telaAgentId), normalizeConversationScope(owner.conversationScope), conversationId]))}`;
+}
+export function readComposerDraft(key) {
+  if (!key)
+    return "";
+  try {
+    const stored = localStorage.getItem(key);
+    if (stored !== null)
+      return stored;
+    if (!key.startsWith(`${DRAFT_KEY_PREFIX}:v2:`))
+      return "";
+    const [workspaceId, userId, , , conversationId] = JSON.parse(decodeURIComponent(key.slice(`${DRAFT_KEY_PREFIX}:v2:`.length)));
+    const legacyKey = `${DRAFT_KEY_PREFIX}:${workspaceId}:${userId}:${conversationId ?? "new"}`;
+    const legacy = localStorage.getItem(legacyKey) ?? "";
+    if (legacy && writeComposerDraft(key, legacy))
+      localStorage.removeItem(legacyKey);
+    return legacy;
+  } catch {
+    return "";
+  }
+}
+export function writeComposerDraft(key, text) {
+  if (!key)
+    return false;
+  try {
+    if (text.trim())
+      localStorage.setItem(key, text);
+    else
+      localStorage.removeItem(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export function composerDraftText(editor) {
+  if (!editor)
+    return "";
+  let accumulated = false;
+  function read(node) {
+    if (node.nodeType === 3) {
+      const text = node.textContent ?? "";
+      accumulated ||= !!text;
+      return text;
+    }
+    const element = node;
+    if (node.nodeName === "BR") {
+      if (element.dataset.sentinel)
+        return "";
+      accumulated = true;
+      return "\n";
+    }
+    const prefix = node.nodeName === "DIV" && accumulated ? "\n" : "";
+    return prefix + Array.from(node.childNodes).map(read).join("");
+  }
+  return Array.from(editor.childNodes).map(read).join("").replace(/\u00A0/g, " ");
+}

package/dist/runtime/messages/composer-pending-send.d.ts

@@ -0,0 +1,8 @@
+import type { SendMessageV2Body } from '../types/schemas/chat/conversation-runtime.js';
+export declare function prepareComposerSend(key: string | null, text: string, request: SendMessageV2Body): string;
+export declare function confirmPendingComposerSend(key: string | null, messageId: string): void;
+export declare function reconcileComposerSend(key: string | null, messages: readonly {
+    id: string;
+    role: string;
+    externalUuid: string | null;
+}[]): void;

package/dist/runtime/messages/composer-pending-send.js

@@ -0,0 +1,34 @@
+import { readComposerDraft, writeComposerDraft } from "./composer-draft.js";
+function readPendingSend(key) {
+  if (!key)
+    return null;
+  try {
+    const value = JSON.parse(readComposerDraft(`${key}:pending-send`));
+    return typeof value?.messageId === "string" && typeof value.text === "string" && typeof value.fingerprint === "string" ? value : null;
+  } catch {
+    return null;
+  }
+}
+export function prepareComposerSend(key, text, request) {
+  if (!key || !text)
+    return request.messageId;
+  const fingerprint = JSON.stringify([request.content, request.files ?? [], request.agentInputs ?? null, request.executionSettings ?? null]);
+  const pending = readPendingSend(key);
+  if (pending?.fingerprint === fingerprint && pending.text === text)
+    return pending.messageId;
+  writeComposerDraft(`${key}:pending-send`, JSON.stringify({ messageId: request.messageId, text, fingerprint }));
+  return request.messageId;
+}
+export function confirmPendingComposerSend(key, messageId) {
+  const pending = readPendingSend(key);
+  if (!key || !pending || pending.messageId !== messageId)
+    return;
+  if (readComposerDraft(key) === pending.text)
+    writeComposerDraft(key, "");
+  writeComposerDraft(`${key}:pending-send`, "");
+}
+export function reconcileComposerSend(key, messages) {
+  const pending = readPendingSend(key);
+  if (pending && messages.some((message) => message.role === "user" && message.externalUuid === pending.messageId))
+    confirmPendingComposerSend(key, pending.messageId);
+}

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

@@ -51,7 +51,7 @@ export function mergeConversationTimeline(messages, events = [], controls) {
   }
   if (controls?.mode === "simple") {
     const seen = /* @__PURE__ */ new Set();
-    const labels = { default: "Padr\xE3o", deep: "Aprofundar", custom: "Personalizado" };
+    const labels = { default: "Padr\xE3o", deep: "Aprofundado", intensive: "Intensivo", custom: "Personalizado" };
     return items.flatMap((item) => {
       if (item.kind !== "event" || !["model_changed", "reasoning_effort_changed"].includes(item.value.type))
         return [item];

package/dist/runtime/rendering/components/openui/{markdown.d.vue.ts → markdown-prose.d.vue.ts}

@@ -1,7 +1,5 @@
 type __VLS_Props = {
-    props: {
-        text: string;
-    };
+    text: string;
     partial?: boolean;
 };
 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>;

package/dist/runtime/rendering/components/openui/{markdown.vue → markdown-prose.vue}

@@ -2,13 +2,13 @@
 import { OPENUI_MARKDOWN_COMPONENTS_KEY } from "../../openui/context";
 import { useWidgetProse } from "../../openui/use-widget-prose";
 const props = defineProps({
-  props: { type: Object, required: true },
+  text: { type: String, required: true },
   partial: { type: Boolean, required: false }
 });
 const customComponents = inject(OPENUI_MARKDOWN_COMPONENTS_KEY, ref({}));
-const content = useWidgetProse(() => props.props.text);
+const content = useWidgetProse(() => props.text);
 </script>
 
 <template>
-    <AppMarkdownRender :content="content" :final="!partial" :typewriter="false" :custom-components="customComponents" data-openui="markdown" />
+    <AppMarkdownRender :content="content" :final="!partial" :typewriter="false" :custom-components="customComponents" />
 </template>

package/dist/runtime/rendering/components/openui/{markdown.vue.d.ts → markdown-prose.vue.d.ts}

@@ -1,7 +1,5 @@
 type __VLS_Props = {
-    props: {
-        text: string;
-    };
+    text: string;
     partial?: boolean;
 };
 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>;

package/dist/runtime/rendering/components/openui-block.vue

@@ -1,73 +1,47 @@
 <script setup>
-import { formatWidgetContext, isSafeUrl } from "@meistrari/chat-ui-lang";
 import { CHAT_MESSAGE_CONTEXT_KEY, CHAT_MESSAGE_SEND_KEY } from "../../types/messages";
 import { useStatusToast } from "../../shared/composables/status-toast";
-import { copyWidgetText, runActionPlan } from "../openui/actions";
-import { OPENUI_CONTEXT_KEY, OPENUI_ERROR_REPORTER_KEY } from "../openui/context";
-import { useOpenuiProgram } from "../openui/program";
-import { renderNode } from "../openui/render";
+import { OPENUI_ERROR_REPORTER_KEY } from "../openui/context";
+import OpenuiCitation from "./openui/citation.vue";
+import OpenuiFileCard from "./openui/file-card.vue";
+import OpenuiImage from "./openui/image.vue";
+import OpenuiMarkdownProse from "./openui/markdown-prose.vue";
 const props = defineProps({
   node: { type: Object, required: true },
   loading: { type: Boolean, required: false }
 });
 const code = computed(() => props.node.code ?? props.node.content ?? "");
 const complete = computed(() => !props.loading && !props.node.loading);
-const program = useOpenuiProgram(code, complete);
 const send = inject(CHAT_MESSAGE_SEND_KEY, null);
 const message = inject(CHAT_MESSAGE_CONTEXT_KEY, null);
 const reportErrors = inject(OPENUI_ERROR_REPORTER_KEY, null);
-const answered = ref(false);
 const statusToast = useStatusToast();
 const interactive = computed(() => Boolean(
-  send && complete.value && !program.incomplete.value && !answered.value && (!message || message.role === "assistant" && message.isLatestMessage.value && !message.streaming.value)
+  send && (!message || message.role === "assistant" && message.isLatestMessage.value && !message.streaming.value)
 ));
-async function triggerAction(label, plan) {
-  if (!send || !interactive.value)
-    return false;
-  let sent = false;
-  const accepted = await runActionPlan(label, plan, {
-    send: async (text, context) => {
-      const ok = await send(`${text}${formatWidgetContext(context, { onDrop: (drop) => console.warn("[chat-nuxt] widget context dropped", drop) })}`);
-      sent = sent || ok;
-      return ok;
-    },
-    openUrl: (url) => {
-      if (isSafeUrl(url))
-        window.open(url, "_blank", "noopener");
-    },
-    custom: runCustomAction,
-    store: program.store,
-    stateDefaults: program.stateDefaults.value
-  });
-  if (sent)
-    answered.value = true;
-  return accepted;
+const host = {
+  prose: OpenuiMarkdownProse,
+  components: { FileCard: OpenuiFileCard, Image: OpenuiImage, Citation: OpenuiCitation }
+};
+async function sendMessage(text) {
+  return send ? await send(text) : false;
 }
-async function runCustomAction(name, params) {
-  if (name === "CopyText" && typeof params.text === "string") {
-    const copied = await copyWidgetText(params.text, (text) => navigator.clipboard.writeText(text));
-    if (!copied)
-      statusToast.update({ text: "N\xE3o foi poss\xEDvel copiar", icon: "i-ph-warning" });
-    return copied;
-  }
-  console.warn("[chat-nuxt] unsupported widget action", { name });
-  return false;
+function onErrors(errors, source) {
+  reportErrors?.(errors, source);
+}
+function onCopyFailed() {
+  statusToast.update({ text: "N\xE3o foi poss\xEDvel copiar", icon: "i-ph-warning" });
 }
-provide(OPENUI_CONTEXT_KEY, { renderNode, interactive, triggerAction });
-watch([program.errors, complete], ([errors, done]) => {
-  if (done && errors.length)
-    reportErrors?.(errors, code.value);
-}, { immediate: true });
-const Root = () => renderNode(program.root.value);
 </script>
 
 <template>
-    <div my-12px data-openui="block" :data-openui-incomplete="program.incomplete.value || void 0">
-        <Root v-if="program.root.value" />
-        <div v-else-if="!complete" flex flex-col gap-8px>
-            <TelaSkeleton h-20px w-40per />
-            <TelaSkeleton h-80px w-full />
-        </div>
-        <pre v-else body-12-regular text-secondary whitespace-pre-wrap data-openui="fallback">{{ code }}</pre>
-    </div>
+    <OpenuiWidget
+        :code="code"
+        :complete="complete"
+        :interactive="interactive"
+        :send="sendMessage"
+        :host="host"
+        @errors="onErrors"
+        @copy-failed="onCopyFailed"
+    />
 </template>

package/dist/runtime/rendering/openui/context.d.ts

@@ -1,22 +1,7 @@
-import type { ActionPlan, OpenUIError } from '@openuidev/lang-core';
-import type { Component, InjectionKey, Ref, VNode } from 'vue';
-export type RenderedNode = VNode | string | null | Array<VNode | string | null>;
-export interface OpenuiContext {
-    renderNode: (value: unknown) => RenderedNode;
-    /** Clicks are honoured only on the latest assistant message, after streaming ends. */
-    interactive: Ref<boolean>;
-    /** Resolves once the action finished; returns false when it was rejected. A widget answers once: after an accepted send, `interactive` turns false. */
-    triggerAction: (label: string, plan?: ActionPlan) => Promise<boolean>;
-}
-export declare const OPENUI_CONTEXT_KEY: InjectionKey<OpenuiContext>;
+import type { OpenUIError } from '@openuidev/lang-core';
+import type { Component, InjectionKey, Ref } from 'vue';
 export type OpenuiErrorReporter = (errors: OpenUIError[], code: string) => void;
 /** Optional: hosts inject this to collect parse and runtime errors per widget. */
 export declare const OPENUI_ERROR_REPORTER_KEY: InjectionKey<OpenuiErrorReporter>;
 /** Markdown node overrides of the surrounding message (vault links, citations), so prose inside widgets renders the same way. */
 export declare const OPENUI_MARKDOWN_COMPONENTS_KEY: InjectionKey<Ref<Record<string, Component>>>;
-export interface OpenuiFormState {
-    get: (name: string) => unknown;
-    set: (name: string, value: unknown) => void;
-}
-/** Provided by Form so its fields share one state bag. */
-export declare const OPENUI_FORM_KEY: InjectionKey<OpenuiFormState>;

package/dist/runtime/rendering/openui/context.js

@@ -1,4 +1,2 @@
-export const OPENUI_CONTEXT_KEY = Symbol("openui-context");
 export const OPENUI_ERROR_REPORTER_KEY = Symbol("openui-error-reporter");
 export const OPENUI_MARKDOWN_COMPONENTS_KEY = Symbol("openui-markdown-components");
-export const OPENUI_FORM_KEY = Symbol("openui-form");

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

@@ -1,7 +1,7 @@
 import type { H3Event } from 'h3';
 export declare function isEdgeHeader(name: string): boolean;
 export declare const fetchWithoutEdgeHeaders: typeof fetch;
-export type ChatApiVersion = 'v1' | 'v2';
+export type ChatApiVersion = 'v1' | 'v2' | 'v3';
 export declare function resolveChatBasePath(basePath: string, apiVersion: ChatApiVersion): string;
 export declare function mapVaultProxyPath(path: string): string;
 export declare function mapWorkspaceProxyPath(path: string): string;

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

@@ -1,4 +1,4 @@
-import { AGENT_API_V5_CONFIG_KEY, PRE_WAKE_CACHE_CONFIG_KEY, CONVERSATION_V2_CONFIG_KEY, PREPARED_AGENT_RUNTIME_CONFIG_KEY, ROUTE_CLAUDE_VIA_GATEWAY_CONFIG_KEY, SECRETLESS_EXECUTION_CONFIG_KEY } from "../../types/schemas/chat/chat-config.js";
+import { AGENT_API_V5_CONFIG_KEY, PRE_WAKE_CACHE_CONFIG_KEY, CONVERSATION_V2_CONFIG_KEY, PREPARED_AGENT_RUNTIME_CONFIG_KEY, ROUTE_CLAUDE_VIA_GATEWAY_CONFIG_KEY, SECRETLESS_EXECUTION_CONFIG_KEY, UI_LANGUAGE_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";
@@ -93,7 +93,8 @@ function buildProxyHeaders(event) {
   const config = useRuntimeConfig(event);
   const chatConfig = {
     [PREPARED_AGENT_RUNTIME_CONFIG_KEY]: true,
-    [CONVERSATION_V2_CONFIG_KEY]: true
+    [CONVERSATION_V2_CONFIG_KEY]: true,
+    [UI_LANGUAGE_CONFIG_KEY]: "web"
   };
   if (config.chatNuxt?.secretlessExecution) {
     chatConfig[SECRETLESS_EXECUTION_CONFIG_KEY] = true;

package/dist/runtime/types/composer.d.ts

@@ -1,4 +1,5 @@
 import type { Component, MaybeRef } from 'vue';
+import type { ChatExecutionProfile } from '../embed/execution-controls.js';
 /** Stable string key, also compatible with hosts providing the literal key. */
 export declare const CHAT_COMPOSER_EXTENSION_KEY = "chat-composer-extension";
 /** A synchronous, per-send snapshot owned by the host application. */
@@ -22,6 +23,11 @@ export interface ChatComposerCommand {
 }
 /** Provide above MeistrariChatEmbed to extend its composer without replacing it. */
 export interface ChatComposerExtension {
+    /** Consume a host draft after a new conversation's composer is ready; return null thereafter. */
+    takeInitialDraft?: () => {
+        content: string;
+        executionProfile?: ChatExecutionProfile;
+    } | null;
     /** Action next to the file menu. Receives the composer's `disabled` state. */
     component?: Component;
     /** Items inside the shared attachment strip. Receives `disabled` as well. */

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

@@ -1,3 +1,4 @@
+import type { UiProfile } from './ui-language';
 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";
@@ -6,7 +7,10 @@ export declare const PRE_WAKE_CACHE_CONFIG_KEY = "pre-wake-cache";
 export declare const ROUTE_CLAUDE_VIA_GATEWAY_CONFIG_KEY = "route-claude-via-gateway";
 export type ChatHarness = 'claude' | 'lightweight';
 export type ChatConfig = {
-    harness?: ChatHarness;
-    [key: string]: boolean | ChatHarness | undefined;
+    'harness'?: ChatHarness;
+    /** Catalogue profile of the client's surface; widgets are requested only when it is set. */
+    'ui-language'?: UiProfile;
+    [key: string]: boolean | ChatHarness | UiProfile | undefined;
 };
 export declare function resolveChatHarness(config?: Pick<ChatConfig, 'harness'>): ChatHarness;
+export declare const UI_LANGUAGE_CONFIG_KEY = "ui-language";

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

@@ -7,3 +7,4 @@ export const ROUTE_CLAUDE_VIA_GATEWAY_CONFIG_KEY = 'route-claude-via-gateway';
 export function resolveChatHarness(config) {
     return config?.harness === 'lightweight' ? 'lightweight' : 'claude';
 }
+export const UI_LANGUAGE_CONFIG_KEY = 'ui-language';

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

@@ -133,6 +133,10 @@ export declare const sendMessageV2ResponseSchema: z.ZodObject<{
             id: z.ZodEnum<{
                 openui: "openui";
             }>;
+            profile: z.ZodEnum<{
+                web: "web";
+                slack: "slack";
+            }>;
             libraryVersion: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>;
@@ -174,6 +178,10 @@ export declare const sendMessageV2ResponseSchema: z.ZodObject<{
             id: z.ZodEnum<{
                 openui: "openui";
             }>;
+            profile: z.ZodEnum<{
+                web: "web";
+                slack: "slack";
+            }>;
             libraryVersion: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>;

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

@@ -117,6 +117,10 @@ export declare const messageSchema: z.ZodObject<{
         id: z.ZodEnum<{
             openui: "openui";
         }>;
+        profile: z.ZodEnum<{
+            web: "web";
+            slack: "slack";
+        }>;
         libraryVersion: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
@@ -238,6 +242,10 @@ export declare const conversationWithMessagesSchema: z.ZodObject<{
             id: z.ZodEnum<{
                 openui: "openui";
             }>;
+            profile: z.ZodEnum<{
+                web: "web";
+                slack: "slack";
+            }>;
             libraryVersion: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;

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

@@ -160,6 +160,10 @@ export declare const sendMessageResponseSchema: z.ZodObject<{
             id: z.ZodEnum<{
                 openui: "openui";
             }>;
+            profile: z.ZodEnum<{
+                web: "web";
+                slack: "slack";
+            }>;
             libraryVersion: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>;
@@ -201,6 +205,10 @@ export declare const sendMessageResponseSchema: z.ZodObject<{
             id: z.ZodEnum<{
                 openui: "openui";
             }>;
+            profile: z.ZodEnum<{
+                web: "web";
+                slack: "slack";
+            }>;
             libraryVersion: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>;
@@ -245,6 +253,10 @@ export declare const messagePollResponseSchema: z.ZodObject<{
             id: z.ZodEnum<{
                 openui: "openui";
             }>;
+            profile: z.ZodEnum<{
+                web: "web";
+                slack: "slack";
+            }>;
             libraryVersion: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;