@meistrari/chat-nuxt 1.2.3 → 1.3.0

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

@@ -2,31 +2,32 @@
 import { provideEmbedConfig, useEmbedConfig } from "../../composables/useEmbedConfig";
 import ChatEmbedInner from "./ChatEmbedInner.vue";
 const props = defineProps({
-  workspaceId: { type: String, required: true },
   workspaceSettings: { type: null, required: false },
   conversationId: { type: [String, null], required: false },
   initialConversationId: { type: [String, null], required: false, default: null },
   hideSidebar: { type: Boolean, required: false, default: true },
   user: { type: [Object, null], required: false },
-  features: { type: Object, required: false }
+  features: { type: Object, required: false },
+  loadingMessages: { type: [Array, null], required: false },
+  loadingMessagesMode: { type: [String, null], required: false }
 });
 defineEmits(["update:conversationId"]);
 const parentEmbedConfig = useEmbedConfig();
-if (import.meta.dev && parentEmbedConfig) {
-  watchEffect(() => {
-    const parentWorkspaceId = parentEmbedConfig.workspaceId.value.trim();
-    const propWorkspaceId = props.workspaceId.trim();
-    if (parentWorkspaceId && propWorkspaceId && parentWorkspaceId !== propWorkspaceId) {
-      console.warn(`[MeistrariChatEmbed] workspaceId prop (${propWorkspaceId}) differs from parent embed config (${parentWorkspaceId}); using prop value for this embed.`);
-    }
-  });
-}
-provideEmbedConfig(props, { syncGlobal: !parentEmbedConfig });
+const { activeOrganization } = useTelaApplicationAuth();
+const workspaceId = computed(() => activeOrganization.value?.id?.trim() ?? "");
+provideEmbedConfig({
+  workspaceId,
+  workspaceSettings: computed(() => props.workspaceSettings),
+  hideSidebar: computed(() => props.hideSidebar),
+  loadingMessages: computed(() => props.loadingMessages),
+  loadingMessagesMode: computed(() => props.loadingMessagesMode)
+}, { syncGlobal: !parentEmbedConfig });
 </script>
 
 <template>
     <!-- Force a clean state namespace when the workspace changes. -->
     <ChatEmbedInner
+        v-if="workspaceId"
         :key="workspaceId"
         :conversation-id="conversationId"
         :initial-conversation-id="initialConversationId"

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

@@ -1,15 +1,17 @@
 import type { DeepReadonly } from 'vue';
 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';
 type EmbedUser = ChatActor;
 type __VLS_Props = {
-    workspaceId: string;
     workspaceSettings?: DeepReadonly<WorkspaceSettings> | WorkspaceSettings | null;
     conversationId?: string | null;
     initialConversationId?: string | null;
     hideSidebar?: boolean;
     user?: EmbedUser | null;
     features?: Partial<ChatFeatureConfig>;
+    loadingMessages?: readonly string[] | null;
+    loadingMessagesMode?: ChatLoadingMessageMode | null;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:conversationId": (value: string | null) => any;

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

@@ -28,7 +28,11 @@ const activeConversationId = ref(
 );
 const loadingConversationId = ref(null);
 const isReady = ref(false);
-const resolvedFeatures = computed(() => resolveChatFeatures(props.features));
+const moduleFeatures = useChatNuxtFeatures();
+const resolvedFeatures = computed(() => resolveChatFeatures({
+  showUsageTab: moduleFeatures.usage ?? props.features?.showUsageTab,
+  showDebugOption: props.features?.showDebugOption
+}));
 const dropZoneRef = ref(null);
 const activeTab = ref("chat");
 const messageInputRef = ref(null);

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

@@ -13,6 +13,7 @@ import {
   serializeResolvedWorkspaceSettings
 } from "#chat-runtime/server/utils/chat-workspace-settings";
 import { resolveWorkspaceCredentials } from "#chat-runtime/server/utils/workspace";
+import { useChatNuxtFeatures } from "#chat-runtime/utils/features";
 import { mergeFileUrls } from "#chat-runtime/utils/file";
 import { isValidModel } from "#chat-runtime/types/chat";
 export default defineEventHandler(async (event) => {
@@ -107,10 +108,12 @@ export default defineEventHandler(async (event) => {
     try {
       if (needsNewThread) {
         let environmentVariables = {};
-        try {
-          environmentVariables = await resolveWorkspaceCredentials(event, context.workspaceId);
-        } catch (error) {
-          logger.warn({ conversationId, messageId, error }, "Failed to resolve workspace credentials on retry, proceeding without env vars");
+        if (useChatNuxtFeatures().credentials) {
+          try {
+            environmentVariables = await resolveWorkspaceCredentials(event, context.workspaceId);
+          } catch (error) {
+            logger.warn({ conversationId, messageId, error }, "Failed to resolve workspace credentials on retry, proceeding without env vars");
+          }
         }
         const hasEnvironmentVariables = Object.keys(environmentVariables).length > 0;
         const result = await createChatAgentSession(token, {

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

@@ -13,6 +13,7 @@ import {
   serializeResolvedWorkspaceSettings
 } from "#chat-runtime/server/utils/chat-workspace-settings";
 import { resolveWorkspaceCredentials } from "#chat-runtime/server/utils/workspace";
+import { useChatNuxtFeatures } from "#chat-runtime/utils/features";
 import { mergeFileUrls } from "#chat-runtime/utils/file";
 import { isValidModel } from "#chat-runtime/types/chat";
 export default defineEventHandler(async (event) => {
@@ -113,10 +114,12 @@ export default defineEventHandler(async (event) => {
   const skills = externalSkillRefs.length > 0 ? externalSkillRefs : void 0;
   if (needsNewThread) {
     let environmentVariables = {};
-    try {
-      environmentVariables = await resolveWorkspaceCredentials(event, context.workspaceId);
-    } catch (error) {
-      logger.warn({ conversationId, error }, "Failed to resolve workspace credentials, proceeding without env vars");
+    if (useChatNuxtFeatures().credentials) {
+      try {
+        environmentVariables = await resolveWorkspaceCredentials(event, context.workspaceId);
+      } catch (error) {
+        logger.warn({ conversationId, error }, "Failed to resolve workspace credentials, proceeding without env vars");
+      }
     }
     const hasEnvironmentVariables = Object.keys(environmentVariables).length > 0;
     createChatAgentSession(token, {

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

@@ -31,7 +31,7 @@ export default defineEventHandler(async (event) => {
       eq(schema.conversationUsage.workspaceId, context.workspaceId)
     )
   );
-  const billing = await getWorkspaceBilling(context.workspaceId);
+  const billing = await getWorkspaceBilling(event);
   if (!usage) {
     return { usage: null, billing };
   }

package/dist/runtime/server/api/conversations/generate-title.post.js

@@ -3,7 +3,20 @@ import { useRuntimeConfig } from "nitropack/runtime";
 import { createTelaClient } from "@meistrari/tela-sdk-js";
 import { logger } from "#chat-runtime/server/utils/logger";
 import { requireUser } from "#chat-runtime/server/utils/auth";
+import { useChatNuxtFeatures } from "#chat-runtime/utils/features";
 const TITLE_CANVAS_ID = "ba06c4a0-ef05-4fb6-b4ef-5af3d63a1ba2";
+const FALLBACK_TITLE_MAX_LENGTH = 60;
+const FALLBACK_TITLE_DEFAULT = "New chat";
+function buildFallbackTitle(userMessage) {
+  const normalized = userMessage.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return FALLBACK_TITLE_DEFAULT;
+  }
+  if (normalized.length <= FALLBACK_TITLE_MAX_LENGTH) {
+    return normalized;
+  }
+  return `${normalized.slice(0, FALLBACK_TITLE_MAX_LENGTH - 1).trimEnd()}\u2026`;
+}
 export default defineEventHandler(async (event) => {
   requireUser(event);
   const { userMessage, assistantResponse } = await readBody(event);
@@ -14,11 +27,11 @@ export default defineEventHandler(async (event) => {
     });
   }
   const { telaApiKey } = useRuntimeConfig();
-  if (!telaApiKey) {
-    throw createError({
-      statusCode: 500,
-      statusMessage: "Tela API key not configured"
-    });
+  const features = useChatNuxtFeatures();
+  if (!features.generateTitle || !telaApiKey) {
+    const fallback = buildFallbackTitle(userMessage);
+    logger.debug({ titleLength: fallback.length, reason: !features.generateTitle ? "feature-disabled" : "no-tela-api-key" }, "Title generated via fallback");
+    return { title: fallback };
   }
   try {
     const tela = createTelaClient({

package/dist/runtime/server/api/workspace/usage.get.js

@@ -54,7 +54,7 @@ export default defineEventHandler(async (event) => {
   }).from(schema.conversationUsage).where(and(...conditions)).orderBy(desc(schema.conversationUsage.createdAt)).limit(limit + 1);
   const hasMore = records.length > limit;
   const paginatedRecords = records.slice(0, limit);
-  const billing = await getWorkspaceBilling(session.workspace.id);
+  const billing = await getWorkspaceBilling(event);
   const formattedRecords = paginatedRecords.map((r) => {
     const transformedCosts = transformCostForBilling({
       promptCost: Number(r.promptCost),

package/dist/runtime/server/db/index.d.ts

@@ -1,6 +1,23 @@
+import { drizzle as drizzlePostgres } from 'drizzle-orm/postgres-js';
+import type { PgliteDatabase } from 'drizzle-orm/pglite';
 import * as schema from './schema.js';
 export type { ContextFile, ExternalSkill } from './schema.js';
-export declare function useDb(): import("drizzle-orm/postgres-js").PostgresJsDatabase<Record<string, unknown>> & {
-    $client: import("postgres").Sql<{}>;
-};
+type PostgresDb = ReturnType<typeof drizzlePostgres<typeof schema>>;
+type PgliteDb = PgliteDatabase<typeof schema>;
+type AnyDb = PostgresDb | PgliteDb;
+export declare function isPgliteUrl(url: string): boolean;
+/**
+ * Eagerly initializes the database during Nitro startup. Idempotent. Both
+ * Postgres and pglite paths now run migrations on boot, so the chat-nuxt
+ * tables in the `chat` Postgres schema are guaranteed to exist before the
+ * first request hits a route that calls useDb().
+ */
+export declare function initDb(): Promise<AnyDb>;
+/**
+ * Returns the initialized database instance. initDb() must have already run
+ * via the boot plugin so migrations have been applied — bare useDb() now
+ * throws if called before init, regardless of driver, instead of silently
+ * skipping migrations on the Postgres path.
+ */
+export declare function useDb(): AnyDb;
 export { schema };

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

@@ -1,20 +1,97 @@
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
 import { useRuntimeConfig } from "nitropack/runtime";
 import postgres from "postgres";
-import { drizzle } from "drizzle-orm/postgres-js";
+import { drizzle as drizzlePostgres } from "drizzle-orm/postgres-js";
+import { migrate as migratePostgres } from "drizzle-orm/postgres-js/migrator";
 import * as schema from "./schema/index.js";
-import { logger } from "#chat-runtime/server/utils/logger";
+import { CHAT_SCHEMA_NAME } from "./schema/_schema.js";
+import { logger } from "../utils/logger.js";
 let dbInstance = null;
-export function useDb() {
+let dbInitPromise = null;
+export function isPgliteUrl(url) {
+  return url.startsWith("pglite:") || url.startsWith("file:");
+}
+function resolvePgliteDataDir(url) {
+  if (url.startsWith("pglite:")) {
+    return url.slice("pglite:".length);
+  }
+  if (url.startsWith("file://")) {
+    return url.slice("file://".length);
+  }
+  if (url.startsWith("file:")) {
+    return url.slice("file:".length);
+  }
+  return url;
+}
+const IGNORED_NOTICE_CODES = /* @__PURE__ */ new Set(["42P06", "42P07"]);
+async function initPostgresAsync(databaseUrl, migrationsDir) {
+  const client = postgres(databaseUrl, {
+    max: 10,
+    onnotice: (notice) => {
+      if (notice.code && IGNORED_NOTICE_CODES.has(notice.code))
+        return;
+      logger.info({ notice }, "Postgres notice");
+    }
+  });
+  const db = drizzlePostgres(client, { schema });
+  if (migrationsDir) {
+    await migratePostgres(db, { migrationsFolder: migrationsDir, migrationsSchema: CHAT_SCHEMA_NAME });
+    logger.info({ migrationsSchema: CHAT_SCHEMA_NAME }, "Postgres connection pool initialized and migrations applied");
+  } else {
+    logger.warn("Postgres connection pool initialized without migrations directory \u2014 schema may be out of date");
+  }
+  return db;
+}
+async function initPgliteAsync(databaseUrl, migrationsDir) {
+  const dataDir = resolvePgliteDataDir(databaseUrl);
+  await mkdir(dirname(dataDir), { recursive: true });
+  const [{ PGlite }, { drizzle }, { migrate }] = await Promise.all([
+    import("@electric-sql/pglite"),
+    import("drizzle-orm/pglite"),
+    import("drizzle-orm/pglite/migrator")
+  ]);
+  const client = new PGlite(dataDir);
+  const db = drizzle(client, { schema });
+  if (migrationsDir) {
+    await migrate(db, { migrationsFolder: migrationsDir, migrationsSchema: CHAT_SCHEMA_NAME });
+    logger.info({ dataDir, migrationsSchema: CHAT_SCHEMA_NAME }, "pglite database initialized and migrated");
+  } else {
+    logger.warn({ dataDir }, "pglite database initialized without migrations directory \u2014 schema may be empty");
+  }
+  return db;
+}
+export async function initDb() {
   if (dbInstance) {
     return dbInstance;
   }
-  const config = useRuntimeConfig();
-  if (!config.databaseUrl) {
-    throw new Error("DATABASE_URL is not configured");
+  if (dbInitPromise) {
+    return dbInitPromise;
+  }
+  dbInitPromise = (async () => {
+    const config = useRuntimeConfig();
+    const databaseUrl = config.databaseUrl;
+    const migrationsDir = config.chatNuxt?.migrationsDir ?? "";
+    if (!databaseUrl) {
+      throw new Error("DATABASE_URL is not configured and no pglite fallback path was set");
+    }
+    const db = isPgliteUrl(databaseUrl) ? await initPgliteAsync(databaseUrl, migrationsDir) : await initPostgresAsync(databaseUrl, migrationsDir);
+    dbInstance = db;
+    return db;
+  })();
+  try {
+    return await dbInitPromise;
+  } catch (error) {
+    dbInitPromise = null;
+    throw error;
+  }
+}
+export function useDb() {
+  if (dbInstance) {
+    return dbInstance;
   }
-  const client = postgres(config.databaseUrl, { max: 10 });
-  dbInstance = drizzle(client, { schema });
-  logger.info("Database connection pool initialized");
-  return dbInstance;
+  throw new Error(
+    "chat-nuxt database is not initialized. The chat-nuxt boot plugin should have called initDb() before any request \u2014 check that the module registered server/plugins/init-db.ts."
+  );
 }
 export { schema };

package/dist/runtime/server/db/schema/_schema.d.ts

@@ -0,0 +1,2 @@
+export declare const CHAT_SCHEMA_NAME = "chat";
+export declare const chatSchema: import("drizzle-orm/pg-core").PgSchema<"chat">;

package/dist/runtime/server/db/schema/_schema.js

@@ -0,0 +1,3 @@
+import { pgSchema } from "drizzle-orm/pg-core";
+export const CHAT_SCHEMA_NAME = "chat";
+export const chatSchema = pgSchema(CHAT_SCHEMA_NAME);

package/dist/runtime/server/db/schema/conversation-usage.d.ts

@@ -19,7 +19,7 @@ export type ModelUsageEntry = {
 };
 export declare const conversationUsage: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "conversation_usage";
-    schema: undefined;
+    schema: "chat";
     columns: {
         id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";

package/dist/runtime/server/db/schema/conversation-usage.js

@@ -1,6 +1,7 @@
-import { pgTable, uuid, text, timestamp, index, jsonb, integer, numeric, unique } from "drizzle-orm/pg-core";
+import { uuid, text, timestamp, index, jsonb, integer, numeric, unique } from "drizzle-orm/pg-core";
+import { chatSchema } from "./_schema.js";
 import { conversations } from "./conversations.js";
-export const conversationUsage = pgTable("conversation_usage", {
+export const conversationUsage = chatSchema.table("conversation_usage", {
   id: uuid("id").primaryKey().defaultRandom(),
   workspaceId: text("workspace_id").notNull(),
   conversationId: uuid("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),

package/dist/runtime/server/db/schema/conversations.d.ts

@@ -1,7 +1,7 @@
 import type { ResolvedWorkspaceSettings } from './workspace-settings.js';
 export declare const conversations: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "conversations";
-    schema: undefined;
+    schema: "chat";
     columns: {
         id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";

package/dist/runtime/server/db/schema/conversations.js

@@ -1,5 +1,6 @@
-import { pgTable, uuid, text, timestamp, index, jsonb } from "drizzle-orm/pg-core";
-export const conversations = pgTable("conversations", {
+import { uuid, text, timestamp, index, jsonb } from "drizzle-orm/pg-core";
+import { chatSchema } from "./_schema.js";
+export const conversations = chatSchema.table("conversations", {
   id: uuid("id").primaryKey().defaultRandom(),
   workspaceId: text("workspace_id").notNull(),
   userId: text("user_id").notNull(),

package/dist/runtime/server/db/schema/external-skills.d.ts

@@ -1,6 +1,6 @@
 export declare const externalSkills: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "external_skills";
-    schema: undefined;
+    schema: "chat";
     columns: {
         id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";

package/dist/runtime/server/db/schema/external-skills.js

@@ -1,7 +1,8 @@
-import { pgTable, text, timestamp, jsonb, boolean, serial, unique } from "drizzle-orm/pg-core";
+import { text, timestamp, jsonb, boolean, serial, unique } from "drizzle-orm/pg-core";
 import { relations } from "drizzle-orm";
+import { chatSchema } from "./_schema.js";
 import { workspaceSettings } from "./workspace-settings.js";
-export const externalSkills = pgTable("external_skills", {
+export const externalSkills = chatSchema.table("external_skills", {
   id: serial("id").primaryKey(),
   workspaceId: text("workspace_id").notNull(),
   ref: text("ref").notNull(),

package/dist/runtime/server/db/schema/index.d.ts

@@ -1,3 +1,4 @@
+export { CHAT_SCHEMA_NAME, chatSchema } from './_schema.js';
 export { conversationUsage, type ConversationUsageMetadata, type ModelUsageEntry } from './conversation-usage.js';
 export { conversations } from './conversations.js';
 export { type ExternalSkillInsert, type ExternalSkillRow, externalSkills, externalSkillsRelations } from './external-skills.js';

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

@@ -1,3 +1,4 @@
+export { CHAT_SCHEMA_NAME, chatSchema } from "./_schema.js";
 export { conversationUsage } from "./conversation-usage.js";
 export { conversations } from "./conversations.js";
 export { externalSkills, externalSkillsRelations } from "./external-skills.js";

package/dist/runtime/server/db/schema/messages.d.ts

@@ -8,7 +8,7 @@ export type MessageFile = {
 };
 export declare const messages: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "messages";
-    schema: undefined;
+    schema: "chat";
     columns: {
         id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";

package/dist/runtime/server/db/schema/messages.js

@@ -1,6 +1,7 @@
-import { pgTable, uuid, text, timestamp, index, jsonb } from "drizzle-orm/pg-core";
+import { uuid, text, timestamp, index, jsonb } from "drizzle-orm/pg-core";
+import { chatSchema } from "./_schema.js";
 import { conversations } from "./conversations.js";
-export const messages = pgTable("messages", {
+export const messages = chatSchema.table("messages", {
   id: uuid("id").primaryKey().defaultRandom(),
   conversationId: uuid("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
   role: text("role", { enum: ["user", "assistant"] }).notNull(),

package/dist/runtime/server/db/schema/workspace-settings.d.ts

@@ -29,7 +29,7 @@ export type ResolvedWorkspaceSettings = {
 };
 export declare const workspaceSettings: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "workspace_settings";
-    schema: undefined;
+    schema: "chat";
     columns: {
         workspaceId: import("drizzle-orm/pg-core").PgColumn<{
             name: "workspace_id";

package/dist/runtime/server/db/schema/workspace-settings.js

@@ -1,7 +1,8 @@
-import { pgTable, text, timestamp, jsonb } from "drizzle-orm/pg-core";
+import { text, timestamp, jsonb } from "drizzle-orm/pg-core";
 import { relations } from "drizzle-orm";
+import { chatSchema } from "./_schema.js";
 import { externalSkills } from "./external-skills.js";
-export const workspaceSettings = pgTable("workspace_settings", {
+export const workspaceSettings = chatSchema.table("workspace_settings", {
   workspaceId: text("workspace_id").primaryKey(),
   systemMessage: text("system_message"),
   contextFiles: jsonb("context_files").$type(),

package/dist/runtime/server/plugins/init-db.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/init-db.js

@@ -0,0 +1,11 @@
+import { defineNitroPlugin } from "nitropack/runtime";
+import { initDb } from "../db/index.js";
+import { logger } from "../utils/logger.js";
+export default defineNitroPlugin(async () => {
+  try {
+    await initDb();
+  } catch (error) {
+    logger.error({ error }, "Failed to initialize chat-nuxt database during Nitro boot");
+    throw error;
+  }
+});

package/dist/runtime/server/utils/billing.d.ts

@@ -1,3 +1,4 @@
+import type { H3Event } from 'h3';
 export type BillingConfig = {
     mode: 'plan';
     cvp: number;
@@ -9,13 +10,17 @@ export type WorkspaceInfo = {
     name: string;
 };
 /**
- * Fetch workspace info including billing settings from the auth API
+ * Fetch workspace info via the authenticated user's session.
+ *
+ * Calls auth-api's `whoAmI` with the user's `tela-access-token`, which returns
+ * the active organization (including the `settings` JSONB blob and `name`).
+ * No internal API key is required.
  */
-export declare function getWorkspaceInfo(workspaceId: string): Promise<WorkspaceInfo>;
+export declare function getWorkspaceInfo(event: H3Event): Promise<WorkspaceInfo>;
 /**
- * Fetch workspace billing settings from the auth API
+ * Fetch workspace billing settings via the authenticated user's session.
  */
-export declare function getWorkspaceBilling(workspaceId: string): Promise<BillingConfig>;
+export declare function getWorkspaceBilling(event: H3Event): Promise<BillingConfig>;
 export type UsageData = {
     promptCost: number;
     completionCost: number;
@@ -35,3 +40,20 @@ export type TransformedCosts = {
  * For 'credits' mode: calculates credits based on costs and token amounts
  */
 export declare function transformCostForBilling(usage: UsageData, billing: BillingConfig): TransformedCosts;
+export type DailyUsageRow = {
+    workspaceId: string;
+    totalTokens: number;
+    totalCost: number;
+    promptTokens: number;
+    completionTokens: number;
+    promptCost: number;
+    completionCost: number;
+    conversationCount: number;
+    userCount: number;
+};
+/**
+ * Aggregate per-workspace conversation usage between the given timestamps.
+ * Returns plain numeric rows so consumers can avoid pulling drizzle types
+ * across package boundaries.
+ */
+export declare function loadDailyUsageStats(start: Date, end: Date): Promise<DailyUsageRow[]>;

package/dist/runtime/server/utils/billing.js

@@ -1,4 +1,8 @@
-import { authApiFetch } from "#chat-runtime/server/utils/auth-api";
+import { getCookie } from "h3";
+import { and, gte, lte, sql } from "drizzle-orm";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { AuthClient } from "@meistrari/auth-nuxt/core";
+import { useDb, schema } from "#chat-runtime/server/db";
 import { logger } from "#chat-runtime/server/utils/logger";
 const DEFAULT_CVP = 1.5;
 function calculateCreditsUsed(inputCost, outputCost, inputAmount, outputAmount) {
@@ -13,27 +17,42 @@ function calculateCreditsUsed(inputCost, outputCost, inputAmount, outputAmount)
   );
   return credits;
 }
-export async function getWorkspaceInfo(workspaceId) {
+function defaultWorkspaceInfo(name) {
+  return {
+    billing: { mode: "plan", cvp: DEFAULT_CVP },
+    name: name ?? "workspace"
+  };
+}
+export async function getWorkspaceInfo(event) {
+  const fallbackName = event.context.auth?.workspace?.id;
+  const accessToken = event.context.auth?.token ?? getCookie(event, "tela-access-token");
+  if (!accessToken) {
+    return defaultWorkspaceInfo(fallbackName);
+  }
   try {
-    const response = await authApiFetch(`/organizations/${workspaceId}`);
-    const workspace = response.data;
-    const settings = workspace?.settings;
+    const config = useRuntimeConfig();
+    const authConfig = config.public.telaAuth;
+    const apiUrl = authConfig?.apiUrl;
+    if (!apiUrl) {
+      logger.warn("telaAuth.apiUrl not configured; falling back to default workspace info");
+      return defaultWorkspaceInfo(fallbackName);
+    }
+    const authClient = new AuthClient(apiUrl);
+    const { organization } = await authClient.application.whoAmI(accessToken, {});
+    const settings = organization?.settings;
     const billingSettings = settings?.billing;
     const billing = billingSettings?.mode === "credits" ? { mode: "credits" } : { mode: "plan", cvp: billingSettings?.cvp ?? DEFAULT_CVP };
     return {
       billing,
-      name: workspace?.title ?? workspaceId
+      name: organization?.name ?? fallbackName ?? "workspace"
     };
   } catch (error) {
-    logger.error(error, "Failed to fetch workspace info");
-    return {
-      billing: { mode: "plan", cvp: DEFAULT_CVP },
-      name: workspaceId
-    };
+    logger.error(error, "Failed to fetch workspace info via whoAmI");
+    return defaultWorkspaceInfo(fallbackName);
   }
 }
-export async function getWorkspaceBilling(workspaceId) {
-  const info = await getWorkspaceInfo(workspaceId);
+export async function getWorkspaceBilling(event) {
+  const info = await getWorkspaceInfo(event);
   return info.billing;
 }
 export function transformCostForBilling(usage, billing) {
@@ -66,3 +85,23 @@ export function transformCostForBilling(usage, billing) {
     totalCost: totalCredits
   };
 }
+export async function loadDailyUsageStats(start, end) {
+  const db = useDb();
+  const rows = await db.select({
+    workspaceId: schema.conversationUsage.workspaceId,
+    totalTokens: sql`SUM(${schema.conversationUsage.totalTokens})::int`,
+    totalCost: sql`SUM(${schema.conversationUsage.totalCost}::numeric)::float`,
+    promptTokens: sql`SUM(${schema.conversationUsage.promptTokens})::int`,
+    completionTokens: sql`SUM(${schema.conversationUsage.completionTokens})::int`,
+    promptCost: sql`SUM(${schema.conversationUsage.promptCost}::numeric)::float`,
+    completionCost: sql`SUM(${schema.conversationUsage.completionCost}::numeric)::float`,
+    conversationCount: sql`COUNT(DISTINCT ${schema.conversationUsage.conversationId})::int`,
+    userCount: sql`COUNT(DISTINCT ${schema.conversationUsage.userId})::int`
+  }).from(schema.conversationUsage).where(
+    and(
+      gte(schema.conversationUsage.createdAt, start),
+      lte(schema.conversationUsage.createdAt, end)
+    )
+  ).groupBy(schema.conversationUsage.workspaceId).orderBy(sql`SUM(${schema.conversationUsage.totalCost}::numeric) DESC`);
+  return rows;
+}

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

@@ -15,7 +15,7 @@ const contextFileSchema = z.object({
 const resolvedWorkspaceSettingsSchema = z.object({
   systemMessage: z.string().nullable().optional(),
   contextFiles: z.array(contextFileSchema).nullable().optional(),
-  canvasTools: z.array(z.object({ id: z.string() }).passthrough()).nullable().optional(),
+  canvasTools: z.array(z.object({ canvasId: z.string() }).passthrough()).nullable().optional(),
   knowledgeSources: z.array(z.object({ id: z.string() }).passthrough()).nullable().optional(),
   externalSkills: z.array(z.object({ ref: z.string(), name: z.string() }).passthrough()).nullable().optional(),
   updatedAt: z.union([z.string(), z.date()]).optional()

package/dist/runtime/utils/chat-loading-messages.d.ts

@@ -0,0 +1,12 @@
+export declare const DEFAULT_CHAT_LOADING_MESSAGES: readonly ["Analisando sua pergunta", "Processando informações", "Consultando base de conhecimento", "Organizando ideias", "Elaborando resposta", "Refinando detalhes", "Verificando contexto", "Conectando conceitos", "Preparando resultado", "Quase lá", "Finalizando análise", "Estruturando resposta"];
+export type ChatLoadingMessageMode = 'ordered' | 'random';
+export type ChatLoadingMessagesInput = {
+    loadingMessages?: readonly string[] | null;
+    loadingMessagesMode?: ChatLoadingMessageMode | null;
+};
+export type ResolvedChatLoadingMessages = {
+    mode: ChatLoadingMessageMode;
+    messages: readonly string[];
+};
+export declare function resolveChatLoadingMessages(input?: ChatLoadingMessagesInput | null): ResolvedChatLoadingMessages;
+export declare function getNextChatLoadingMessageIndex(mode: ChatLoadingMessageMode, messageCount: number, currentIndex: number, random?: () => number): number;