@meistrari/chat-nuxt 1.13.0 → 2.0.0

package/dist/runtime/workspace/composables/workspace-credentials.js

@@ -0,0 +1,177 @@
+import * as Sentry from "@sentry/nuxt";
+import { formatAbsoluteDate } from "../../shared/date-formatting.js";
+import { getChatApiErrorMessage } from "../../shared/chat-api-error.js";
+import { useStatusToast } from "../../shared/composables/status-toast.js";
+export function useWorkspaceCredentials(searchQuery) {
+  const credentials = useState("workspace-credentials", () => []);
+  const loading = useState("workspace-credentials-loading", () => false);
+  const showCreateModal = ref(false);
+  const editingCredential = ref(null);
+  const deletingCredential = ref(null);
+  const credentialForm = ref({ key: "", value: "" });
+  const credentialSaving = ref(false);
+  const credentialError = ref("");
+  const credentialDeleting = ref(false);
+  async function fetchCredentials() {
+    loading.value = true;
+    try {
+      const data = await $fetch("/api/workspace/credentials");
+      credentials.value = data ?? [];
+      return data;
+    } catch (e) {
+      Sentry.captureException(e);
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function createCredential(payload) {
+    try {
+      const data = await $fetch("/api/workspace/credentials", {
+        method: "POST",
+        body: payload
+      });
+      credentials.value = [...credentials.value, data].sort((a, b) => a.key.localeCompare(b.key));
+      return data;
+    } catch (e) {
+      Sentry.captureException(e);
+      throw e;
+    }
+  }
+  async function updateCredential(id, payload) {
+    try {
+      const data = await $fetch(`/api/workspace/credentials/${id}`, {
+        method: "PUT",
+        body: payload
+      });
+      credentials.value = credentials.value.map((s) => s.id === id ? data : s);
+      return data;
+    } catch (e) {
+      Sentry.captureException(e);
+      throw e;
+    }
+  }
+  async function deleteCredential(id) {
+    try {
+      await $fetch(`/api/workspace/credentials/${id}`, { method: "DELETE" });
+      credentials.value = credentials.value.filter((s) => s.id !== id);
+    } catch (e) {
+      Sentry.captureException(e);
+      throw e;
+    }
+  }
+  const filteredCredentials = computed(() => {
+    const query = searchQuery?.value?.trim().toLowerCase();
+    if (!query)
+      return credentials.value;
+    return credentials.value.filter(
+      (s) => s.key.toLowerCase().includes(query)
+    );
+  });
+  const credentialModalOpen = computed({
+    get: () => showCreateModal.value || !!editingCredential.value,
+    set: (val) => {
+      if (!val) {
+        showCreateModal.value = false;
+        editingCredential.value = null;
+      }
+    }
+  });
+  const deleteModalOpen = computed({
+    get: () => !!deletingCredential.value,
+    set: (val) => {
+      if (!val)
+        deletingCredential.value = null;
+    }
+  });
+  function openCreateModal() {
+    credentialForm.value = { key: "", value: "" };
+    credentialError.value = "";
+    showCreateModal.value = true;
+  }
+  function openEditModal(credential) {
+    editingCredential.value = credential;
+    credentialForm.value = { key: credential.key, value: "" };
+    credentialError.value = "";
+  }
+  function closeModal() {
+    showCreateModal.value = false;
+    editingCredential.value = null;
+  }
+  async function handleSave() {
+    credentialError.value = "";
+    if (editingCredential.value && !credentialForm.value.value) {
+      closeModal();
+      return;
+    }
+    credentialSaving.value = true;
+    const statusToast = useStatusToast();
+    try {
+      if (editingCredential.value) {
+        await updateCredential(editingCredential.value.id, { value: credentialForm.value.value });
+        statusToast.update({ text: "Credencial atualizada", icon: "i-ph-check" });
+      } else {
+        await createCredential(credentialForm.value);
+        statusToast.update({ text: "Credencial criada", icon: "i-ph-check" });
+      }
+      closeModal();
+    } catch (error) {
+      credentialError.value = getChatApiErrorMessage(error) ?? "Erro ao salvar credencial";
+    } finally {
+      credentialSaving.value = false;
+    }
+  }
+  async function handleDelete() {
+    if (!deletingCredential.value)
+      return;
+    credentialDeleting.value = true;
+    const statusToast = useStatusToast();
+    try {
+      await deleteCredential(deletingCredential.value.id);
+      statusToast.update({ text: "Credencial exclu\xEDda", icon: "i-ph-check" });
+      deletingCredential.value = null;
+    } catch (e) {
+      Sentry.captureException(e);
+      statusToast.update({ text: "Erro ao excluir credencial", icon: "i-ph-warning" });
+    } finally {
+      credentialDeleting.value = false;
+    }
+  }
+  function getMenuItems(credential) {
+    return [
+      { label: "Editar", icon: "i-ph-pencil-simple", click: () => openEditModal(credential) },
+      { label: "Excluir", icon: "i-ph-trash", click: () => {
+        deletingCredential.value = credential;
+      } }
+    ];
+  }
+  function formatLastRotated(updatedAt, createdAt) {
+    if (updatedAt === createdAt)
+      return "Nunca";
+    return formatAbsoluteDate(updatedAt);
+  }
+  return {
+    credentials: readonly(credentials),
+    loading: readonly(loading),
+    fetchCredentials,
+    createCredential,
+    updateCredential,
+    deleteCredential,
+    filteredCredentials,
+    credentialModalOpen,
+    deleteModalOpen,
+    credentialForm,
+    credentialSaving,
+    credentialDeleting,
+    credentialError,
+    editingCredential: readonly(editingCredential),
+    deletingCredential: readonly(deletingCredential),
+    openCreateModal,
+    openEditModal,
+    closeModal,
+    handleSave,
+    handleDelete,
+    getMenuItems,
+    formatLastRotated
+  };
+}

package/dist/runtime/workspace/composables/workspace-external-skills.d.ts

@@ -0,0 +1,22 @@
+import type { ExternalSkill } from '../../types/schemas/chat/workspace-settings.js';
+export declare function useWorkspaceExternalSkills(currentExternalSkills: Ref<readonly ExternalSkill[] | null | undefined> | ComputedRef<readonly ExternalSkill[] | null | undefined>, searchQuery?: Ref<string>): {
+    displayedSkills: any;
+    filteredSkills: any;
+    hasChanges: any;
+    isPending: (ref: string) => boolean;
+    addSkill: (skill: ExternalSkill) => void;
+    removeSkill: (ref: string) => void;
+    buildExternalSkills: () => ExternalSkill[] | null;
+    initialize: () => void;
+    skillModalOpen: any;
+    skillRefInput: any;
+    skillError: any;
+    discoveringSkills: any;
+    handleAddSkill: () => Promise<void>;
+    closeSkillModal: () => void;
+    handleAddSkillAndClose: () => Promise<void>;
+    getGitHubButtonText: () => string;
+    skillsConnection: any;
+    fetchGitHubConnection: () => Promise<void>;
+    connectGitHub: () => void;
+};

package/dist/runtime/workspace/composables/workspace-external-skills.js

@@ -0,0 +1,137 @@
+import { useChatAuth } from "#chat-auth";
+import { getChatApiErrorMessage } from "../../shared/chat-api-error.js";
+import { useGitHubSkills } from "./github-skills.js";
+export function useWorkspaceExternalSkills(currentExternalSkills, searchQuery) {
+  const { user } = useChatAuth();
+  const { connection: skillsConnection, fetchConnection: fetchGitHubConnection, connect: connectGitHub } = useGitHubSkills();
+  const pendingSkills = ref([]);
+  const removedRefs = ref([]);
+  const skillModalOpen = ref(false);
+  const skillRefInput = ref("");
+  const skillError = ref("");
+  const discoveringSkills = ref(false);
+  const displayedSkills = computed(() => {
+    const current = (currentExternalSkills.value ?? []).filter((s) => !removedRefs.value.includes(s.ref));
+    return [...current, ...pendingSkills.value];
+  });
+  const filteredSkills = computed(() => {
+    const query = searchQuery?.value?.trim().toLowerCase();
+    if (!query)
+      return displayedSkills.value;
+    return displayedSkills.value.filter(
+      (skill) => skill.name.toLowerCase().includes(query) || skill.ref.toLowerCase().includes(query)
+    );
+  });
+  const hasChanges = computed(() => {
+    return pendingSkills.value.length > 0 || removedRefs.value.length > 0;
+  });
+  function isPending(ref2) {
+    return pendingSkills.value.some((s) => s.ref === ref2);
+  }
+  function addSkill(skill) {
+    pendingSkills.value = [...pendingSkills.value, skill];
+  }
+  function removeSkill(ref2) {
+    const pendingIndex = pendingSkills.value.findIndex((s) => s.ref === ref2);
+    if (pendingIndex !== -1) {
+      pendingSkills.value = pendingSkills.value.filter((_, i) => i !== pendingIndex);
+      return;
+    }
+    removedRefs.value = [...removedRefs.value, ref2];
+  }
+  function buildExternalSkills() {
+    const currentSkills = (currentExternalSkills.value ?? []).filter((s) => !removedRefs.value.includes(s.ref)).map((s) => ({
+      ...s,
+      allowedTools: [...s.allowedTools],
+      addedBy: { ...s.addedBy }
+    }));
+    const finalSkills = [...currentSkills, ...pendingSkills.value];
+    return finalSkills.length > 0 ? finalSkills : null;
+  }
+  async function handleAddSkill() {
+    const inputRef = skillRefInput.value.trim();
+    if (!inputRef || discoveringSkills.value)
+      return;
+    skillError.value = "";
+    discoveringSkills.value = true;
+    try {
+      const metadata = await $fetch("/api/external-skills/discover", {
+        method: "POST",
+        body: { ref: inputRef }
+      });
+      const canonicalRef = metadata.ref;
+      if (displayedSkills.value.some((s) => s.ref === canonicalRef)) {
+        skillError.value = "Esta skill j\xE1 foi adicionada";
+        return;
+      }
+      const newSkill = {
+        ref: canonicalRef,
+        name: metadata.name,
+        description: metadata.description || "",
+        runtime: metadata.runtime || "unknown",
+        allowedTools: metadata.allowedTools || [],
+        isPublic: metadata.isPublic,
+        addedBy: {
+          userId: user.value?.id || "",
+          username: user.value?.name || skillsConnection.value.accountName || ""
+        },
+        addedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      addSkill(newSkill);
+      skillRefInput.value = "";
+    } catch (error) {
+      if (error.statusCode === 401)
+        skillError.value = "Reposit\xF3rio privado. Conecte um provedor para acessar.";
+      else if (error.statusCode === 404)
+        skillError.value = "Skill n\xE3o encontrada. Verifique se o caminho cont\xE9m um arquivo SKILL.md";
+      else
+        skillError.value = getChatApiErrorMessage(error) ?? "Erro ao buscar skill";
+    } finally {
+      discoveringSkills.value = false;
+    }
+  }
+  function closeSkillModal() {
+    skillModalOpen.value = false;
+    skillRefInput.value = "";
+    skillError.value = "";
+  }
+  async function handleAddSkillAndClose() {
+    await handleAddSkill();
+    if (!skillError.value)
+      closeSkillModal();
+  }
+  function getGitHubButtonText() {
+    if (skillsConnection.value.connected)
+      return "Gerenciar GitHub";
+    return "Conectar GitHub";
+  }
+  function initialize() {
+    pendingSkills.value = [];
+    removedRefs.value = [];
+    skillModalOpen.value = false;
+    skillRefInput.value = "";
+    skillError.value = "";
+    discoveringSkills.value = false;
+  }
+  return {
+    displayedSkills,
+    filteredSkills,
+    hasChanges,
+    isPending,
+    addSkill,
+    removeSkill,
+    buildExternalSkills,
+    initialize,
+    skillModalOpen,
+    skillRefInput,
+    skillError,
+    discoveringSkills,
+    handleAddSkill,
+    closeSkillModal,
+    handleAddSkillAndClose,
+    getGitHubButtonText,
+    skillsConnection,
+    fetchGitHubConnection,
+    connectGitHub
+  };
+}

package/dist/runtime/workspace/composables/workspace-knowledge-sources.d.ts

@@ -0,0 +1,11 @@
+import type { KnowledgeSource } from '../../types/schemas/chat/workspace-settings.js';
+import type { TelaCanvas, TelaProject, TelaWorkstation } from '../../types/schemas/integrations/tela-api.js';
+export declare function useWorkspaceKnowledgeSources(workstations: Ref<TelaWorkstation[]> | ComputedRef<TelaWorkstation[]>, canvas: Ref<TelaCanvas[]> | ComputedRef<TelaCanvas[]>, projects: Ref<TelaProject[]> | ComputedRef<TelaProject[]>, searchQuery: Ref<string>, currentKnowledgeSources: Ref<readonly KnowledgeSource[] | null | undefined> | ComputedRef<readonly KnowledgeSource[] | null | undefined>): {
+    selectedKnowledgeSourceIds: any;
+    filteredWorkstations: any;
+    hasChanges: any;
+    toggleKnowledgeSource: (sourceId: string) => void;
+    getProjectNameForWorkstation: (workstation: TelaWorkstation) => string;
+    buildKnowledgeSources: () => KnowledgeSource[];
+    initialize: () => void;
+};

package/dist/runtime/workspace/composables/workspace-settings.d.ts

@@ -0,0 +1,12 @@
+import type { WorkspaceSettingsResponse, WorkspaceSettingsUpdate } from '../../types/schemas/chat/workspace-settings.js';
+export declare function useWorkspaceSettings(): {
+    settings: any;
+    loading: any;
+    error: any;
+    fetchSettings: () => Promise<WorkspaceSettingsResponse>;
+    updateSettings: (updates: WorkspaceSettingsUpdate) => Promise<WorkspaceSettingsResponse>;
+    isModalOpen: any;
+    initialTab: any;
+    openModal: (tab?: string) => void;
+    closeModal: () => void;
+};

package/dist/runtime/workspace/composables/workspace-settings.js

@@ -0,0 +1,146 @@
+import * as Sentry from "@sentry/nuxt";
+import { workspaceSettingsResponseSchema } from "../../types/schemas/chat/workspace-settings.js";
+import { useChatAuth } from "#chat-auth";
+import { useChatApi } from "../../shared/composables/chat-api.js";
+import { useEmbedConfig } from "../../embed/composables/embed-config.js";
+function assertWorkspaceSettingsResponse(value) {
+  const parsedSettings = workspaceSettingsResponseSchema.safeParse(value);
+  if (!parsedSettings.success)
+    throw new Error("Invalid workspace settings response");
+  return parsedSettings.data;
+}
+export function useWorkspaceSettings() {
+  const chatApi = useChatApi();
+  const embedConfig = useEmbedConfig();
+  const { activeOrganization } = useChatAuth();
+  const workspaceScope = computed(() => embedConfig?.workspaceId.value.trim() || activeOrganization.value?.id?.trim() || "default");
+  const settingsBuckets = useState("workspace-settings", () => ({}));
+  const loadingBuckets = useState("workspace-settings-loading", () => ({}));
+  const errorBuckets = useState("workspace-settings-error", () => ({}));
+  const settings = computed({
+    get: () => settingsBuckets.value[workspaceScope.value] ?? null,
+    set: (value) => {
+      settingsBuckets.value = {
+        ...settingsBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  const loading = computed({
+    get: () => loadingBuckets.value[workspaceScope.value] ?? false,
+    set: (value) => {
+      loadingBuckets.value = {
+        ...loadingBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  const error = computed({
+    get: () => errorBuckets.value[workspaceScope.value] ?? null,
+    set: (value) => {
+      errorBuckets.value = {
+        ...errorBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  const isModalOpen = useState("workspace-settings-modal-open", () => false);
+  const initialTab = useState("workspace-settings-initial-tab", () => null);
+  const hasWorkspaceSettingsOverride = computed(() => embedConfig?.workspaceSettings.value !== void 0);
+  if (embedConfig !== null && hasWorkspaceSettingsOverride.value) {
+    settings.value = embedConfig.workspaceSettings.value;
+  }
+  if (embedConfig !== null) {
+    watch(() => embedConfig.workspaceSettings.value, (newSettings) => {
+      if (newSettings !== void 0) {
+        settings.value = newSettings;
+      }
+    });
+  }
+  function openModal(tab) {
+    if (tab)
+      initialTab.value = tab;
+    isModalOpen.value = true;
+  }
+  function closeModal() {
+    isModalOpen.value = false;
+    initialTab.value = null;
+  }
+  async function fetchSettings() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const currentSettings = settings.value;
+      let data;
+      if (hasWorkspaceSettingsOverride.value) {
+        return settings.value;
+      } else if (embedConfig !== null) {
+        data = assertWorkspaceSettingsResponse(
+          await $fetch(
+            chatApi.path("/workspace/settings"),
+            chatApi.withChatHeaders()
+          )
+        );
+      } else {
+        data = assertWorkspaceSettingsResponse(await $fetch("/api/workspace/settings"));
+      }
+      if (import.meta.dev && embedConfig !== null && currentSettings) {
+        const hydratedSettings = {
+          systemMessage: currentSettings.systemMessage,
+          contextFiles: currentSettings.contextFiles,
+          canvasTools: currentSettings.canvasTools,
+          knowledgeSources: currentSettings.knowledgeSources,
+          externalSkills: currentSettings.externalSkills
+        };
+        const trustedSettings = {
+          systemMessage: data.systemMessage,
+          contextFiles: data.contextFiles,
+          canvasTools: data.canvasTools,
+          knowledgeSources: data.knowledgeSources,
+          externalSkills: data.externalSkills
+        };
+        if (JSON.stringify(hydratedSettings) !== JSON.stringify(trustedSettings)) {
+          console.warn("[MeistrariChatEmbed] Hydrated workspace settings differ from trusted server settings");
+        }
+      }
+      settings.value = data;
+      return data;
+    } catch (e) {
+      Sentry.captureException(e);
+      error.value = "Falha ao carregar configura\xE7\xF5es";
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function updateSettings(updates) {
+    if (hasWorkspaceSettingsOverride.value)
+      return settings.value;
+    loading.value = true;
+    error.value = null;
+    try {
+      const path = embedConfig !== null ? chatApi.path("/workspace/settings") : "/api/workspace/settings";
+      const options = embedConfig !== null ? chatApi.withChatHeaders({ method: "PATCH", body: updates }) : { method: "PATCH", body: updates };
+      const data = assertWorkspaceSettingsResponse(await $fetch(path, options));
+      settings.value = data;
+      return data;
+    } catch (e) {
+      Sentry.captureException(e);
+      error.value = "Falha ao salvar configura\xE7\xF5es";
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return {
+    settings: readonly(settings),
+    loading: readonly(loading),
+    error: readonly(error),
+    fetchSettings,
+    updateSettings,
+    isModalOpen: readonly(isModalOpen),
+    initialTab: readonly(initialTab),
+    openModal,
+    closeModal
+  };
+}

package/dist/runtime/workspace/composables/workspace-tela-tools.d.ts

@@ -0,0 +1,13 @@
+import type { TelaCanvas, TelaProject } from '../../types/schemas/integrations/tela-api.js';
+import type { CanvasTool } from '../../types/schemas/tools/canvas.js';
+export declare function useWorkspaceTelaTools(canvas: Ref<TelaCanvas[]> | ComputedRef<TelaCanvas[]>, projects: Ref<TelaProject[]> | ComputedRef<TelaProject[]>, searchQuery: Ref<string>, currentCanvasTools: Ref<readonly CanvasTool[] | null | undefined> | ComputedRef<readonly CanvasTool[] | null | undefined>): {
+    selectedToolIds: any;
+    filteredCanvasTools: any;
+    allToolsSelected: any;
+    hasChanges: any;
+    toggleCanvasTool: (canvasId: string) => void;
+    toggleAllTools: (selected: boolean | "indeterminate") => void;
+    getProjectName: (projectId: string) => string;
+    buildCanvasTools: () => CanvasTool[];
+    initialize: () => void;
+};

package/dist/types.d.mts

@@ -4,6 +4,8 @@ import type { default as Module } from './module.mjs'
 
 export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
+export { type ChatActionPayload, type ChatActor, type ChatEmbedSharedProps, type ChatFeatureConfig, type DefaultChatEmbedProps, type MeistrariChatEmbedProps, type TelaAgentChatEmbedProps, type TelaAgentExecutionInput } from '../dist/runtime/types/embed.js'
+
 export { default } from './module.mjs'
 
-export { type ChatNuxtFeatures, type ChatNuxtModuleOptions } from './module.mjs'
+export { type ChatNuxtModuleOptions } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/chat-nuxt",
-  "version": "1.13.0",
+  "version": "2.0.0",
   "type": "module",
   "exports": {
     ".": {
@@ -8,82 +8,68 @@
       "import": "./dist/module.mjs"
     },
     "./components/MeistrariChatEmbed": {
-      "types": "./dist/runtime/components/MeistrariChatEmbed.vue.d.ts",
-      "import": "./dist/runtime/components/MeistrariChatEmbed.vue"
+      "types": "./dist/runtime/embed/components/meistrari-chat-embed.vue.d.ts",
+      "import": "./dist/runtime/embed/components/meistrari-chat-embed.vue"
     },
-    "./assets/css/*": "./dist/runtime/assets/css/*",
     "./types/*": {
       "types": "./dist/runtime/types/*.d.ts",
       "import": "./dist/runtime/types/*.js"
-    },
-    "./utils/*": {
-      "types": "./dist/runtime/utils/*.d.ts",
-      "import": "./dist/runtime/utils/*.js"
     }
   },
   "main": "./dist/module.mjs",
   "types": "./dist/types.d.mts",
   "files": [
-    "dist",
-    "drizzle"
+    "dist"
   ],
   "scripts": {
-    "build": "mkdir -p .nuxt && { [ -f .nuxt/tsconfig.json ] || printf '{}' > .nuxt/tsconfig.json; } && { [ -f .nuxt/tsconfig.server.json ] || printf '{}' > .nuxt/tsconfig.server.json; } && nuxt-module-build build",
+    "build": "mkdir -p .nuxt && { [ -f .nuxt/tsconfig.json ] || printf '{}' > .nuxt/tsconfig.json; } && { [ -f .nuxt/tsconfig.server.json ] || printf '{}' > .nuxt/tsconfig.server.json; } && nuxt-module-build build && node ./scripts/embed-local-schemas.mjs && node ./scripts/polish-embed-declarations.mjs",
     "dev:prepare": "nuxt-module-build build --stub",
     "test:types": "pnpm build && tsc -p tsconfig.type-tests.json --noEmit",
     "smoke:pack": "./scripts/smoke-pack-consumer.sh",
+    "smoke:browser": "./scripts/smoke-pack-consumer.sh --browser",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "lint:attrs": "! grep -rn '[a-z0-9-]![[:space:]>@\"'\"'\"']' --include='*.vue' src/runtime/components/ src/runtime/embed/components/ 2>/dev/null",
-    "typecheck": "cd ../.. && TYPECHECK_CWD=packages/chat-app ./scripts/typecheck.sh",
-    "db:generate": "drizzle-kit generate",
-    "db:migrate": "infisical run --env=dev -- ./scripts/drizzle.sh migrate",
-    "db:migrate:local": "./scripts/drizzle.sh migrate",
-    "db:studio": "infisical run --env=dev -- ./scripts/drizzle.sh studio"
+    "lint:attrs": "! grep -rn '[a-z0-9-]![[:space:]>@\"'\"'\"']' --include='*.vue' src/runtime/ 2>/dev/null",
+    "typecheck": "cd ../.. && TYPECHECK_CWD=packages/chat-app ./scripts/typecheck.sh"
   },
   "peerDependencies": {
     "nuxt": "^3.17.0",
     "vue": "^3.5.0"
   },
   "dependencies": {
-    "@electric-sql/pglite": "^0.2.15",
     "@iconify-json/ph": "^1.2.2",
     "@iconify/vue": "^5.0.0",
     "@meistrari/auth-nuxt": "3.5.0",
     "@meistrari/logger": "^2.1.3",
-    "@meistrari/mise-en-place": "^2.5.1",
-    "@meistrari/tela-sdk-js": "^2.8.0",
     "@meistrari/tela-build": "^1.30.0",
-    "@meistrari/vault-sdk": "^3.0.0",
     "@sentry/nuxt": "^10.0.0",
     "@vueuse/components": "^12.8.0",
     "@vueuse/core": "^12.8.0",
     "beautiful-mermaid": "^1.1.3",
     "dompurify": "^3.3.2",
-    "drizzle-orm": "^0.38.0",
     "h3": "^1.15.0",
     "markstream-vue": "0.0.3-beta.6",
     "mermaid": "^11.13.0",
     "motion": "^11.13.0",
     "nitropack": "^2.10.0",
     "pdfjs-dist": "^5.4.530",
-    "postgres": "^3.4.5",
     "posthog-js": "^1.364.2",
     "virtua": "^0.42.0",
-    "xlsx": "^0.18.5",
     "vue-i18n": "^11.0.0",
+    "xlsx": "^0.18.5",
     "zod": "^4.1.13"
   },
   "devDependencies": {
     "@antfu/eslint-config": "3.11.2",
+    "@meistrari/chat-schemas": "workspace:*",
     "@nuxt/module-builder": "^1.0.2",
     "@types/node": "^20.19.0",
     "dotenv-cli": "^11.0.0",
-    "drizzle-kit": "^0.30.0",
     "eslint": "9.16.0",
     "nuxt": "3.17.7",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
+    "playwright": "^1.61.0",
     "typescript": "^5.7.3",
     "vitest": "^3.2.1",
     "vue-tsc": "^3.2.6"

package/dist/runtime/components/AppStatusToast.vue

@@ -1,42 +0,0 @@
-<script setup>
-const statusToast = useStatusToast();
-</script>
-
-<template>
-    <Transition name="toast">
-        <div
-            v-if="statusToast.visible.value"
-            fixed
-            bottom-24px
-            left="50%"
-            translate-x="-50%"
-            z-1000
-            flex
-            items-center
-            gap-8px
-            px-16px
-            py-12px
-            bg-black-900
-            text-white
-            rounded-8px
-            shadow-lg
-        >
-            <span
-                v-if="statusToast.icon.value"
-                :class="statusToast.icon.value"
-                text-16px
-            />
-            <div
-                v-if="statusToast.loading.value"
-                i-ph-spinner
-                animate-spin
-                text-16px
-            />
-            <span body-14-regular>{{ statusToast.text.value }}</span>
-        </div>
-    </Transition>
-</template>
-
-<style scoped>
-.toast-enter-active,.toast-leave-active{transition:all .3s ease}.toast-enter-from,.toast-leave-to{opacity:0;transform:translateX(-50%) translateY(20px)}
-</style>