@meistrari/chat-nuxt 1.3.0 → 1.4.0

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@meistrari/chat-nuxt",
   "configKey": "chatNuxt",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/runtime/components/MeistrariChatEmbed.d.vue.ts

@@ -1,5 +1,6 @@
-import type { DeepReadonly } from 'vue';
+import type { Component, DeepReadonly } from 'vue';
 import type { WorkspaceSettings } from '../composables/useWorkspaceSettings.js';
+import type { ChatActionPayload } from '../composables/useChatAction.js';
 import type { ChatLoadingMessageMode } from '../utils/chat-loading-messages.js';
 import type { ChatActor, ChatFeatureConfig } from '../utils/tela-chat.js';
 type __VLS_Props = {
@@ -11,11 +12,15 @@ type __VLS_Props = {
     features?: Partial<ChatFeatureConfig>;
     loadingMessages?: readonly string[] | null;
     loadingMessagesMode?: ChatLoadingMessageMode | null;
+    customComponents?: Record<string, Component>;
+    customHtmlTags?: readonly string[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:conversationId": (value: string | null) => any;
+    action: (payload: ChatActionPayload) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:conversationId"?: ((value: string | null) => any) | undefined;
+    onAction?: ((payload: ChatActionPayload) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/MeistrariChatEmbed.vue

@@ -7,9 +7,11 @@ defineProps({
   hideSidebar: { type: Boolean, required: false },
   features: { type: Object, required: false },
   loadingMessages: { type: [Array, null], required: false },
-  loadingMessagesMode: { type: [String, null], required: false }
+  loadingMessagesMode: { type: [String, null], required: false },
+  customComponents: { type: Object, required: false },
+  customHtmlTags: { type: Array, required: false }
 });
-defineEmits(["update:conversationId"]);
+defineEmits(["update:conversationId", "action"]);
 </script>
 
 <template>
@@ -22,6 +24,9 @@ defineEmits(["update:conversationId"]);
         :features="features"
         :loading-messages="loadingMessages"
         :loading-messages-mode="loadingMessagesMode"
+        :custom-components="customComponents"
+        :custom-html-tags="customHtmlTags"
         @update:conversation-id="$emit('update:conversationId', $event)"
+        @action="$emit('action', $event)"
     />
 </template>

package/dist/runtime/components/MeistrariChatEmbed.vue.d.ts

@@ -1,5 +1,6 @@
-import type { DeepReadonly } from 'vue';
+import type { Component, DeepReadonly } from 'vue';
 import type { WorkspaceSettings } from '../composables/useWorkspaceSettings.js';
+import type { ChatActionPayload } from '../composables/useChatAction.js';
 import type { ChatLoadingMessageMode } from '../utils/chat-loading-messages.js';
 import type { ChatActor, ChatFeatureConfig } from '../utils/tela-chat.js';
 type __VLS_Props = {
@@ -11,11 +12,15 @@ type __VLS_Props = {
     features?: Partial<ChatFeatureConfig>;
     loadingMessages?: readonly string[] | null;
     loadingMessagesMode?: ChatLoadingMessageMode | null;
+    customComponents?: Record<string, Component>;
+    customHtmlTags?: readonly string[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:conversationId": (value: string | null) => any;
+    action: (payload: ChatActionPayload) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:conversationId"?: ((value: string | null) => any) | undefined;
+    onAction?: ((payload: ChatActionPayload) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/app-markdown-render.d.vue.ts

@@ -4,12 +4,14 @@ type __VLS_Props = {
     renderCodeBlocksAsPre?: boolean;
     typewriter?: boolean;
     customComponents?: Record<string, Component>;
+    customHtmlTags?: readonly string[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     content: string | null;
+    customComponents: Record<string, Component>;
+    customHtmlTags: readonly string[];
     renderCodeBlocksAsPre: boolean;
     typewriter: boolean;
-    customComponents: Record<string, Component>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/app-markdown-render.vue

@@ -2,16 +2,18 @@
 import MarkdownRender, { getMarkdown, parseMarkdownToStructure, removeCustomComponents, setCustomComponents } from "markstream-vue";
 import MermaidDiagram from "./renderers/mermaid-diagram.vue";
 import { transformMarkdownNodes } from "../utils/markdown-nodes";
+import { wrapCustomMarkdownComponents } from "../utils/custom-markdown-components";
 const props = defineProps({
   content: { type: [String, null], required: false, default: "" },
   renderCodeBlocksAsPre: { type: Boolean, required: false, default: false },
   typewriter: { type: Boolean, required: false, default: true },
-  customComponents: { type: Object, required: false, default: () => ({}) }
+  customComponents: { type: Object, required: false, default: () => ({}) },
+  customHtmlTags: { type: Array, required: false, default: () => [] }
 });
 const attrs = useAttrs();
-const markdown = getMarkdown();
 const instance = getCurrentInstance();
 const scopeId = `app-markdown-render-${instance?.uid ?? Math.random().toString(36).slice(2)}`;
+const markdown = computed(() => getMarkdown(scopeId, { customHtmlTags: props.customHtmlTags }));
 function escapeSingleDollarSigns(text) {
   return text.replace(/(```[\s\S]*?```|``+[^`]*``+|`[^`]*`|!?\[(?:[^\[\]]|\[[^\[\]]*\])*\]\([^)]*\))|(?<![$\\])\$(?!\$)/g, (_match, codeSpan) => {
     if (codeSpan)
@@ -19,14 +21,23 @@ function escapeSingleDollarSigns(text) {
     return "\\$";
   });
 }
+const parseOptions = computed(() => {
+  const tags = props.customHtmlTags;
+  return tags && tags.length > 0 ? { customHtmlTags: [...tags] } : void 0;
+});
 const nodes = computed(() => {
-  const parsedNodes = parseMarkdownToStructure(escapeSingleDollarSigns(props.content ?? ""), markdown);
+  const parsedNodes = parseMarkdownToStructure(
+    escapeSingleDollarSigns(props.content ?? ""),
+    markdown.value,
+    parseOptions.value
+  );
   return transformMarkdownNodes(parsedNodes);
 });
+const customMarkdownComponents = computed(() => wrapCustomMarkdownComponents(props.customComponents));
 watchEffect(() => {
   setCustomComponents(scopeId, {
     mermaid: MermaidDiagram,
-    ...props.customComponents
+    ...customMarkdownComponents.value
   });
 });
 onBeforeUnmount(() => {

package/dist/runtime/components/app-markdown-render.vue.d.ts

@@ -4,12 +4,14 @@ type __VLS_Props = {
     renderCodeBlocksAsPre?: boolean;
     typewriter?: boolean;
     customComponents?: Record<string, Component>;
+    customHtmlTags?: readonly string[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     content: string | null;
+    customComponents: Record<string, Component>;
+    customHtmlTags: readonly string[];
     renderCodeBlocksAsPre: boolean;
     typewriter: boolean;
-    customComponents: Record<string, Component>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/chat/message-bubble.vue

@@ -7,6 +7,12 @@ const props = defineProps({
 const emit = defineEmits(["retry"]);
 const { user } = useTelaApplicationAuth();
 const { getMemberByEmail } = useWorkspaceMembers();
+const embedConfig = useEmbedConfig();
+const mergedCustomComponents = computed(() => ({
+  link: ChatVaultLink,
+  ...embedConfig?.customComponents.value ?? {}
+}));
+const mergedCustomHtmlTags = computed(() => embedConfig?.customHtmlTags.value ?? []);
 const senderMember = computed(() => {
   const createdBy = props.message.createdBy?.trim();
   if (!createdBy) {
@@ -241,7 +247,8 @@ const hasDetectedFiles = computed(() => contentSegments.value.some((s) => s.type
                                 <AppMarkdownRender
                                     :id="`message-${message.id}-segment-${index}`"
                                     :content="segment.content"
-                                    :custom-components="{ link: ChatVaultLink }"
+                                    :custom-components="mergedCustomComponents"
+                                    :custom-html-tags="mergedCustomHtmlTags"
                                     :render-code-blocks-as-pre="true"
                                     :typewriter="shouldAnimate"
                                 />
@@ -259,7 +266,8 @@ const hasDetectedFiles = computed(() => contentSegments.value.some((s) => s.type
                     <ClientOnly v-else>
                         <AppMarkdownRender
                             :content="displayContent"
-                            :custom-components="{ link: ChatVaultLink }"
+                            :custom-components="mergedCustomComponents"
+                            :custom-html-tags="mergedCustomHtmlTags"
                             :render-code-blocks-as-pre="true"
                             :typewriter="shouldAnimate"
                             text-black-900

package/dist/runtime/composables/useChat.js

@@ -307,11 +307,18 @@ export function useChat() {
     };
     messages.value = [...messages.value, optimisticUserMessage, optimisticAssistantMessage];
     try {
+      const workspaceSettingsSnapshot = embedConfig?.workspaceSettings.value;
+      const body = {
+        content,
+        files,
+        model,
+        ...workspaceSettingsSnapshot !== void 0 ? { workspaceSettingsSnapshot } : {}
+      };
       const response = await $fetch(
         chatApi.path(`/conversations/${currentConversation.value.id}/messages`),
         chatApi.withChatHeaders({
           method: "POST",
-          body: { content, files, model }
+          body
         })
       );
       messages.value = messages.value.map((msg) => {

package/dist/runtime/composables/useChatAction.d.ts

@@ -0,0 +1,10 @@
+export type ChatActionPayload = {
+    name: string;
+    data: unknown;
+    messageId?: string;
+};
+export type ChatActionHandler = (payload: ChatActionPayload) => void;
+export declare function provideChatAction(handler: ChatActionHandler): void;
+export declare function useChatAction(): {
+    emit(name: string, data?: unknown, messageId?: string): void;
+};

package/dist/runtime/composables/useChatAction.js

@@ -0,0 +1,12 @@
+const CHAT_ACTION_KEY = Symbol("chat-nuxt:action");
+export function provideChatAction(handler) {
+  provide(CHAT_ACTION_KEY, handler);
+}
+export function useChatAction() {
+  const handler = inject(CHAT_ACTION_KEY, null);
+  return {
+    emit(name, data, messageId) {
+      handler?.({ name, data, messageId });
+    }
+  };
+}

package/dist/runtime/composables/useEmbedConfig.d.ts

@@ -1,4 +1,4 @@
-import type { DeepReadonly, MaybeRefOrGetter, Ref } from 'vue';
+import type { Component, DeepReadonly, MaybeRefOrGetter, Ref } from 'vue';
 import type { ChatLoadingMessageMode } from '../utils/chat-loading-messages.js';
 import type { WorkspaceSettings } from './useWorkspaceSettings.js';
 export type EmbedConfig = {
@@ -7,6 +7,8 @@ export type EmbedConfig = {
     hideSidebar: Ref<boolean>;
     loadingMessages: Ref<readonly string[] | null | undefined>;
     loadingMessagesMode: Ref<ChatLoadingMessageMode | null | undefined>;
+    customComponents: Ref<Record<string, Component> | undefined>;
+    customHtmlTags: Ref<readonly string[] | undefined>;
 };
 type EmbedConfigInput = {
     workspaceId: MaybeRefOrGetter<string>;
@@ -14,6 +16,8 @@ type EmbedConfigInput = {
     hideSidebar?: MaybeRefOrGetter<boolean | undefined>;
     loadingMessages?: MaybeRefOrGetter<readonly string[] | null | undefined>;
     loadingMessagesMode?: MaybeRefOrGetter<ChatLoadingMessageMode | null | undefined>;
+    customComponents?: MaybeRefOrGetter<Record<string, Component> | undefined>;
+    customHtmlTags?: MaybeRefOrGetter<readonly string[] | undefined>;
 };
 type ProvideEmbedConfigOptions = {
     syncGlobal?: boolean;

package/dist/runtime/composables/useEmbedConfig.js

@@ -1,4 +1,9 @@
 const EMBED_CONFIG_KEY = "embed-config";
+function useGlobalCustomComponentsState() {
+  const nuxtApp = useNuxtApp();
+  nuxtApp._chatEmbedConfigCustomComponents ??= shallowRef(void 0);
+  return nuxtApp._chatEmbedConfigCustomComponents;
+}
 function useGlobalEmbedConfigState() {
   return {
     provided: useState("chat-embed-config-provided", () => false),
@@ -6,7 +11,9 @@ function useGlobalEmbedConfigState() {
     workspaceSettings: useState("chat-embed-config-workspace-settings", () => void 0),
     hideSidebar: useState("chat-embed-config-hide-sidebar", () => void 0),
     loadingMessages: useState("chat-embed-config-loading-messages", () => void 0),
-    loadingMessagesMode: useState("chat-embed-config-loading-messages-mode", () => void 0)
+    loadingMessagesMode: useState("chat-embed-config-loading-messages-mode", () => void 0),
+    customComponents: useGlobalCustomComponentsState(),
+    customHtmlTags: useState("chat-embed-config-custom-html-tags", () => void 0)
   };
 }
 export function provideEmbedConfig(input, options = {}) {
@@ -15,7 +22,9 @@ export function provideEmbedConfig(input, options = {}) {
     workspaceSettings: computed(() => toValue(input.workspaceSettings)),
     hideSidebar: computed(() => toValue(input.hideSidebar) ?? true),
     loadingMessages: computed(() => toValue(input.loadingMessages)),
-    loadingMessagesMode: computed(() => toValue(input.loadingMessagesMode))
+    loadingMessagesMode: computed(() => toValue(input.loadingMessagesMode)),
+    customComponents: computed(() => toValue(input.customComponents)),
+    customHtmlTags: computed(() => toValue(input.customHtmlTags))
   };
   const globalConfig = useGlobalEmbedConfigState();
   if (options.syncGlobal ?? true) {
@@ -26,6 +35,8 @@ export function provideEmbedConfig(input, options = {}) {
       globalConfig.hideSidebar.value = config.hideSidebar.value;
       globalConfig.loadingMessages.value = config.loadingMessages.value;
       globalConfig.loadingMessagesMode.value = config.loadingMessagesMode.value;
+      globalConfig.customComponents.value = config.customComponents.value;
+      globalConfig.customHtmlTags.value = config.customHtmlTags.value;
     });
   }
   provide(EMBED_CONFIG_KEY, config);
@@ -42,6 +53,8 @@ export function useEmbedConfig() {
     workspaceSettings: computed(() => globalConfig.workspaceSettings.value),
     hideSidebar: computed(() => globalConfig.hideSidebar.value ?? true),
     loadingMessages: computed(() => globalConfig.loadingMessages.value),
-    loadingMessagesMode: computed(() => globalConfig.loadingMessagesMode.value)
+    loadingMessagesMode: computed(() => globalConfig.loadingMessagesMode.value),
+    customComponents: computed(() => globalConfig.customComponents.value),
+    customHtmlTags: computed(() => globalConfig.customHtmlTags.value)
   };
 }

package/dist/runtime/embed/components/ChatEmbed.d.vue.ts

@@ -1,4 +1,5 @@
-import type { DeepReadonly } from 'vue';
+import type { Component, DeepReadonly } from 'vue';
+import { type ChatActionPayload } from '../../composables/useChatAction.js';
 import type { WorkspaceSettings } from '../../composables/useWorkspaceSettings.js';
 import type { ChatLoadingMessageMode } from '../../utils/chat-loading-messages.js';
 import type { ChatActor, ChatFeatureConfig } from '../../utils/tela-chat.js';
@@ -12,11 +13,15 @@ type __VLS_Props = {
     features?: Partial<ChatFeatureConfig>;
     loadingMessages?: readonly string[] | null;
     loadingMessagesMode?: ChatLoadingMessageMode | null;
+    customComponents?: Record<string, Component>;
+    customHtmlTags?: readonly string[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:conversationId": (value: string | null) => any;
+    action: (payload: ChatActionPayload) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:conversationId"?: ((value: string | null) => any) | undefined;
+    onAction?: ((payload: ChatActionPayload) => any) | undefined;
 }>, {
     initialConversationId: string | null;
     hideSidebar: boolean;

package/dist/runtime/embed/components/ChatEmbed.vue

@@ -1,5 +1,6 @@
 <script setup>
 import { provideEmbedConfig, useEmbedConfig } from "../../composables/useEmbedConfig";
+import { provideChatAction } from "../../composables/useChatAction";
 import ChatEmbedInner from "./ChatEmbedInner.vue";
 const props = defineProps({
   workspaceSettings: { type: null, required: false },
@@ -9,9 +10,11 @@ const props = defineProps({
   user: { type: [Object, null], required: false },
   features: { type: Object, required: false },
   loadingMessages: { type: [Array, null], required: false },
-  loadingMessagesMode: { type: [String, null], required: false }
+  loadingMessagesMode: { type: [String, null], required: false },
+  customComponents: { type: Object, required: false },
+  customHtmlTags: { type: Array, required: false }
 });
-defineEmits(["update:conversationId"]);
+const emit = defineEmits(["update:conversationId", "action"]);
 const parentEmbedConfig = useEmbedConfig();
 const { activeOrganization } = useTelaApplicationAuth();
 const workspaceId = computed(() => activeOrganization.value?.id?.trim() ?? "");
@@ -20,8 +23,13 @@ provideEmbedConfig({
   workspaceSettings: computed(() => props.workspaceSettings),
   hideSidebar: computed(() => props.hideSidebar),
   loadingMessages: computed(() => props.loadingMessages),
-  loadingMessagesMode: computed(() => props.loadingMessagesMode)
+  loadingMessagesMode: computed(() => props.loadingMessagesMode),
+  customComponents: computed(() => props.customComponents),
+  customHtmlTags: computed(() => props.customHtmlTags)
 }, { syncGlobal: !parentEmbedConfig });
+provideChatAction((payload) => {
+  emit("action", payload);
+});
 </script>
 
 <template>

package/dist/runtime/embed/components/ChatEmbed.vue.d.ts

@@ -1,4 +1,5 @@
-import type { DeepReadonly } from 'vue';
+import type { Component, DeepReadonly } from 'vue';
+import { type ChatActionPayload } from '../../composables/useChatAction.js';
 import type { WorkspaceSettings } from '../../composables/useWorkspaceSettings.js';
 import type { ChatLoadingMessageMode } from '../../utils/chat-loading-messages.js';
 import type { ChatActor, ChatFeatureConfig } from '../../utils/tela-chat.js';
@@ -12,11 +13,15 @@ type __VLS_Props = {
     features?: Partial<ChatFeatureConfig>;
     loadingMessages?: readonly string[] | null;
     loadingMessagesMode?: ChatLoadingMessageMode | null;
+    customComponents?: Record<string, Component>;
+    customHtmlTags?: readonly string[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:conversationId": (value: string | null) => any;
+    action: (payload: ChatActionPayload) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:conversationId"?: ((value: string | null) => any) | undefined;
+    onAction?: ((payload: ChatActionPayload) => any) | undefined;
 }>, {
     initialConversationId: string | null;
     hideSidebar: boolean;

package/dist/runtime/server/api/conversations/[id]/messages/index.get.js

@@ -131,7 +131,7 @@ export default defineEventHandler(async (event) => {
       }
       if (agentSession.status === "completed" || agentSession.status === "waiting_messages") {
         if (hasNewReasoning) {
-          const content = extractContentFromSession(agentSession, newReasoning);
+          const content = extractContentFromSession(agentSession);
           updateData.content = content;
           updateData.status = "completed";
           updateData.updatedAt = /* @__PURE__ */ new Date();

package/dist/runtime/server/api/conversations/[id]/messages/index.post.js

@@ -9,6 +9,7 @@ import { logger } from "#chat-runtime/server/utils/logger";
 import {
   getConversationAppliedSettings,
   getWorkspaceSettingsUpdatedAt,
+  parseWorkspaceSettingsSnapshot,
   resolveWorkspaceSettings,
   serializeResolvedWorkspaceSettings
 } from "#chat-runtime/server/utils/chat-workspace-settings";
@@ -53,14 +54,16 @@ export default defineEventHandler(async (event) => {
     });
   }
   const effectiveModel = body.model ?? (isValidModel(conversation.model) ? conversation.model : void 0);
-  const trustedSettings = conversation.appliedSettingsSnapshot ? null : await resolveWorkspaceSettings(event, context, db);
-  const appliedSettings = getConversationAppliedSettings(conversation, trustedSettings);
+  const explicitSettings = !conversation.appliedSettingsSnapshot && body.workspaceSettingsSnapshot !== void 0 ? parseWorkspaceSettingsSnapshot(body.workspaceSettingsSnapshot) : void 0;
+  const trustedSettings = conversation.appliedSettingsSnapshot || explicitSettings ? null : await resolveWorkspaceSettings(event, context, db);
+  const appliedSettings = getConversationAppliedSettings(conversation, trustedSettings, explicitSettings);
   const now = /* @__PURE__ */ new Date();
   const assistantCreatedAt = new Date(now.getTime() + 1);
-  if (!conversation.appliedSettingsSnapshot && trustedSettings) {
+  const snapshotSettings = explicitSettings ?? trustedSettings;
+  if (!conversation.appliedSettingsSnapshot && snapshotSettings) {
     await db.update(schema.conversations).set({
-      appliedSettingsAt: getWorkspaceSettingsUpdatedAt(trustedSettings),
-      appliedSettingsSnapshot: serializeResolvedWorkspaceSettings(trustedSettings),
+      appliedSettingsAt: getWorkspaceSettingsUpdatedAt(snapshotSettings),
+      appliedSettingsSnapshot: serializeResolvedWorkspaceSettings(snapshotSettings),
       updatedAt: now
     }).where(and(
       eq(schema.conversations.id, conversationId),

package/dist/runtime/server/db/index.js

@@ -1,6 +1,7 @@
 import { mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
 import { useRuntimeConfig } from "nitropack/runtime";
+import { sql } from "drizzle-orm";
 import postgres from "postgres";
 import { drizzle as drizzlePostgres } from "drizzle-orm/postgres-js";
 import { migrate as migratePostgres } from "drizzle-orm/postgres-js/migrator";
@@ -9,6 +10,9 @@ import { CHAT_SCHEMA_NAME } from "./schema/_schema.js";
 import { logger } from "../utils/logger.js";
 let dbInstance = null;
 let dbInitPromise = null;
+const LEGACY_MIGRATIONS_SCHEMA = "drizzle";
+const MIGRATIONS_TABLE = "__drizzle_migrations";
+const MIGRATIONS_LEDGER_LOCK_KEY = 581073927;
 export function isPgliteUrl(url) {
   return url.startsWith("pglite:") || url.startsWith("file:");
 }
@@ -25,6 +29,59 @@ function resolvePgliteDataDir(url) {
   return url;
 }
 const IGNORED_NOTICE_CODES = /* @__PURE__ */ new Set(["42P06", "42P07"]);
+function getRows(result) {
+  if (Array.isArray(result)) {
+    return result;
+  }
+  if (result && typeof result === "object" && "rows" in result && Array.isArray(result.rows)) {
+    return result.rows;
+  }
+  return [];
+}
+async function tableExists(db, schemaName, tableName) {
+  const result = await db.execute(sql`
+        select exists (
+            select 1
+            from information_schema.tables
+            where table_schema = ${schemaName}
+                and table_name = ${tableName}
+        ) as "exists"
+    `);
+  const [row] = getRows(result);
+  return row?.exists ?? false;
+}
+async function tableHasRows(db, schemaName, tableName) {
+  const result = await db.execute(sql`
+        select exists (
+            select 1
+            from ${sql.identifier(schemaName)}.${sql.identifier(tableName)}
+        ) as "exists"
+    `);
+  const [row] = getRows(result);
+  return row?.exists ?? false;
+}
+async function seedChatMigrationsLedger(db) {
+  await db.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(CHAT_SCHEMA_NAME)}`);
+  await db.execute(sql`
+        CREATE TABLE IF NOT EXISTS ${sql.identifier(CHAT_SCHEMA_NAME)}.${sql.identifier(MIGRATIONS_TABLE)} (
+            id SERIAL PRIMARY KEY,
+            hash text NOT NULL,
+            created_at bigint
+        )
+    `);
+  if (await tableHasRows(db, CHAT_SCHEMA_NAME, MIGRATIONS_TABLE)) {
+    return;
+  }
+  if (!await tableExists(db, LEGACY_MIGRATIONS_SCHEMA, MIGRATIONS_TABLE)) {
+    return;
+  }
+  await db.execute(sql`
+        INSERT INTO ${sql.identifier(CHAT_SCHEMA_NAME)}.${sql.identifier(MIGRATIONS_TABLE)} ("hash", "created_at")
+        SELECT "hash", "created_at"
+        FROM ${sql.identifier(LEGACY_MIGRATIONS_SCHEMA)}.${sql.identifier(MIGRATIONS_TABLE)}
+        ORDER BY "created_at"
+    `);
+}
 async function initPostgresAsync(databaseUrl, migrationsDir) {
   const client = postgres(databaseUrl, {
     max: 10,
@@ -36,6 +93,10 @@ async function initPostgresAsync(databaseUrl, migrationsDir) {
   });
   const db = drizzlePostgres(client, { schema });
   if (migrationsDir) {
+    await db.transaction(async (tx) => {
+      await tx.execute(sql`SELECT pg_advisory_xact_lock(${MIGRATIONS_LEDGER_LOCK_KEY})`);
+      await seedChatMigrationsLedger(tx);
+    });
     await migratePostgres(db, { migrationsFolder: migrationsDir, migrationsSchema: CHAT_SCHEMA_NAME });
     logger.info({ migrationsSchema: CHAT_SCHEMA_NAME }, "Postgres connection pool initialized and migrations applied");
   } else {
@@ -54,6 +115,7 @@ async function initPgliteAsync(databaseUrl, migrationsDir) {
   const client = new PGlite(dataDir);
   const db = drizzle(client, { schema });
   if (migrationsDir) {
+    await seedChatMigrationsLedger(db);
     await migrate(db, { migrationsFolder: migrationsDir, migrationsSchema: CHAT_SCHEMA_NAME });
     logger.info({ dataDir, migrationsSchema: CHAT_SCHEMA_NAME }, "pglite database initialized and migrated");
   } else {

package/dist/runtime/server/utils/agent-api.d.ts

@@ -36,4 +36,4 @@ export declare function cancelSession(token: string, sessionId: string): Promise
     error: string;
 }>;
 export declare function extractContentFromReasoning(reasoning: ReasoningItem[]): string;
-export declare function extractContentFromSession(session: AgentApiSession, turnReasoning?: ReasoningItem[]): string;
+export declare function extractContentFromSession(session: AgentApiSession): string;

package/dist/runtime/server/utils/agent-api.js

@@ -150,11 +150,8 @@ export function extractContentFromReasoning(reasoning) {
   }
   return "";
 }
-export function extractContentFromSession(session, turnReasoning) {
-  if (turnReasoning !== void 0) {
-    return extractContentFromReasoning(turnReasoning);
-  }
-  if (session.result?.content) {
+export function extractContentFromSession(session) {
+  if (typeof session.result?.content === "string") {
     return session.result.content;
   }
   if (session.result?.structuredContent) {

package/dist/runtime/server/utils/chat-workspace-settings.d.ts

@@ -8,8 +8,9 @@ export declare function normalizeResolvedWorkspaceSettings(settings: ResolvedWor
 export declare function serializeResolvedWorkspaceSettings(settings: ResolvedWorkspaceSettings): ResolvedWorkspaceSettings;
 export declare function getConversationAppliedSettings(conversation: {
     appliedSettingsSnapshot?: ResolvedWorkspaceSettingsInput | null;
-}, trustedSettings?: ResolvedWorkspaceSettingsInput | null): ResolvedWorkspaceSettings;
+}, trustedSettings?: ResolvedWorkspaceSettingsInput | null, explicitSettings?: ResolvedWorkspaceSettingsInput | null): ResolvedWorkspaceSettings;
 export declare function hasMaterialWorkspaceSettingsMismatch(currentSettings: ResolvedWorkspaceSettingsInput | null | undefined, trustedSettings: ResolvedWorkspaceSettingsInput | null | undefined): boolean;
+export declare function parseWorkspaceSettingsSnapshot(settings: unknown): ResolvedWorkspaceSettings;
 export declare function resolveDefaultWorkspaceSettings(db: DbInstance, workspaceId: string): Promise<ResolvedWorkspaceSettings>;
 export declare function resolveWorkspaceSettings(event: H3Event, context: ChatContext, db: DbInstance): Promise<ResolvedWorkspaceSettings>;
 export declare function getWorkspaceSettingsUpdatedAt(settings: ResolvedWorkspaceSettings): Date;

package/dist/runtime/server/utils/chat-workspace-settings.js

@@ -40,10 +40,13 @@ export function serializeResolvedWorkspaceSettings(settings) {
     updatedAt: settings.updatedAt instanceof Date ? settings.updatedAt.toISOString() : settings.updatedAt
   };
 }
-export function getConversationAppliedSettings(conversation, trustedSettings) {
+export function getConversationAppliedSettings(conversation, trustedSettings, explicitSettings) {
   if (conversation.appliedSettingsSnapshot) {
     return normalizeResolvedWorkspaceSettings(conversation.appliedSettingsSnapshot);
   }
+  if (explicitSettings !== void 0) {
+    return normalizeResolvedWorkspaceSettings(explicitSettings);
+  }
   return normalizeResolvedWorkspaceSettings(trustedSettings);
 }
 export function hasMaterialWorkspaceSettingsMismatch(currentSettings, trustedSettings) {
@@ -69,6 +72,12 @@ function parseResolverResult(settings) {
   }
   return normalizeResolvedWorkspaceSettings(parsedSettings.data);
 }
+export function parseWorkspaceSettingsSnapshot(settings) {
+  if (settings === null) {
+    return normalizeResolvedWorkspaceSettings(null);
+  }
+  return parseResolverResult(settings);
+}
 export async function resolveDefaultWorkspaceSettings(db, workspaceId) {
   const [settings, skillRows] = await Promise.all([
     db.select().from(schema.workspaceSettings).where(eq(schema.workspaceSettings.workspaceId, workspaceId)),

package/dist/runtime/utils/custom-markdown-components.d.ts

@@ -0,0 +1,9 @@
+import { type Component } from 'vue';
+import type { BaseNode } from 'markstream-vue';
+export type CustomMarkdownNode = BaseNode & {
+    attrs?: [string, unknown][];
+    content?: string;
+};
+export declare function customMarkdownNodeProps(node: CustomMarkdownNode): Record<string, unknown>;
+export declare function wrapCustomMarkdownComponent(component: Component, tagName?: string): Component;
+export declare function wrapCustomMarkdownComponents(components: Record<string, Component>): Record<string, Component>;

package/dist/runtime/utils/custom-markdown-components.js

@@ -0,0 +1,54 @@
+import { defineComponent, h } from "vue";
+function camelizeAttributeName(name) {
+  return name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+export function customMarkdownNodeProps(node) {
+  const attrProps = {};
+  for (const attr of node.attrs ?? []) {
+    const [name, value] = attr;
+    if (!name)
+      continue;
+    const propName = camelizeAttributeName(name);
+    if (propName === "node")
+      continue;
+    attrProps[propName] = value;
+  }
+  return { node, ...attrProps };
+}
+function customMarkdownComponentAdapterName(tagName, component) {
+  if (typeof component === "function" && component.name)
+    return component.name;
+  if (typeof component === "object" && component) {
+    const namedComponent = component;
+    return namedComponent.displayName ?? namedComponent.name ?? tagName;
+  }
+  return tagName;
+}
+export function wrapCustomMarkdownComponent(component, tagName = "unknown") {
+  return defineComponent({
+    name: `CustomMarkdownComponentAdapter(${customMarkdownComponentAdapterName(tagName, component)})`,
+    props: {
+      node: {
+        type: Object,
+        required: true
+      }
+    },
+    setup(props, { attrs }) {
+      return () => h(
+        component,
+        {
+          ...attrs,
+          ...customMarkdownNodeProps(props.node)
+        },
+        {
+          default: () => props.node.content ?? ""
+        }
+      );
+    }
+  });
+}
+export function wrapCustomMarkdownComponents(components) {
+  return Object.fromEntries(
+    Object.entries(components).map(([name, component]) => [name, wrapCustomMarkdownComponent(component, name)])
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/chat-nuxt",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "type": "module",
   "exports": {
     ".": {