@meistrari/chat-nuxt 1.3.0 → 1.5.0

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/db/schema/conversations.d.ts

@@ -88,6 +88,23 @@ export declare const conversations: import("drizzle-orm/pg-core").PgTableWithCol
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        telaAgentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tela_agent_id";
+            tableName: "conversations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         model: import("drizzle-orm/pg-core").PgColumn<{
             name: "model";
             tableName: "conversations";

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

@@ -6,6 +6,7 @@ export const conversations = chatSchema.table("conversations", {
   userId: text("user_id").notNull(),
   title: text("title").notNull().default("Nova conversa"),
   threadSessionId: text("thread_session_id"),
+  telaAgentId: text("tela_agent_id"),
   model: text("model").default("claude-sonnet-4-5"),
   appliedSettingsAt: timestamp("applied_settings_at", { withTimezone: true }),
   appliedSettingsSnapshot: jsonb("applied_settings_snapshot").$type(),
@@ -15,5 +16,6 @@ export const conversations = chatSchema.table("conversations", {
 }, (table) => [
   index("idx_conversations_workspace").on(table.workspaceId),
   index("idx_conversations_user").on(table.userId),
-  index("idx_conversations_updated").on(table.updatedAt)
+  index("idx_conversations_updated").on(table.updatedAt),
+  index("idx_conversations_workspace_tela_agent_updated").on(table.workspaceId, table.telaAgentId, table.updatedAt)
 ]);

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

@@ -11,7 +11,7 @@ export type ExternalSkill = {
     name: string;
     description: string;
     runtime: string;
-    allowedTools: string[];
+    allowedTools: readonly string[];
     isPublic: boolean;
     addedBy: {
         userId: string;

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-context.d.ts

@@ -4,6 +4,11 @@ export type ChatContext = {
     user: AppSession['user'];
     workspaceId: string;
 };
+export type ChatRuntimeContext = ChatContext & {
+    telaAgentId: string | null;
+};
 export declare function resolveRequestedWorkspaceId(requestedWorkspaceId: string | null | undefined): string | null;
+export declare function resolveRequestedTelaAgentId(requestedTelaAgentId: string | null | undefined): string | null;
 export declare function resolveChatContextFromSession(session: AppSession, requestedWorkspaceId?: string | null): ChatContext;
 export declare function resolveChatContext(event: H3Event): ChatContext;
+export declare function resolveChatRuntimeContext(event: H3Event): ChatRuntimeContext;

package/dist/runtime/server/utils/chat-context.js

@@ -1,9 +1,22 @@
 import { createError, getHeader } from "h3";
 import { requireUser } from "#chat-runtime/server/utils/auth";
+const TELA_AGENT_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 export function resolveRequestedWorkspaceId(requestedWorkspaceId) {
   const normalized = requestedWorkspaceId?.trim();
   return normalized || null;
 }
+export function resolveRequestedTelaAgentId(requestedTelaAgentId) {
+  const normalized = requestedTelaAgentId?.trim();
+  if (!normalized)
+    return null;
+  if (!TELA_AGENT_ID_PATTERN.test(normalized)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid Tela agent ID"
+    });
+  }
+  return normalized;
+}
 export function resolveChatContextFromSession(session, requestedWorkspaceId) {
   const normalizedRequestedWorkspaceId = resolveRequestedWorkspaceId(requestedWorkspaceId);
   if (normalizedRequestedWorkspaceId && normalizedRequestedWorkspaceId !== session.workspace.id) {
@@ -22,3 +35,10 @@ export function resolveChatContext(event) {
   const requestedWorkspaceId = getHeader(event, "x-chat-workspace-id");
   return resolveChatContextFromSession(session, requestedWorkspaceId);
 }
+export function resolveChatRuntimeContext(event) {
+  const context = resolveChatContext(event);
+  return {
+    ...context,
+    telaAgentId: resolveRequestedTelaAgentId(getHeader(event, "x-chat-tela-agent-id"))
+  };
+}

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/server/utils/conversation-agent-turn.d.ts

@@ -0,0 +1,39 @@
+import type { H3Event } from 'h3';
+import { schema } from '#chat-runtime/server/db';
+import type { useDb } from '#chat-runtime/server/db';
+import type { ChatRuntimeContext } from '#chat-runtime/server/utils/chat-context';
+import type { FileUploadInput, MessageFile } from '#chat-runtime/types/chat';
+import type { AgentApiChatPayload, ContinueSessionPayload } from '#chat-runtime/types/agent';
+import type { TelaAgentExecutionInput, TelaAgentRunPayload } from '#chat-runtime/types/tela-agent';
+type DbInstance = ReturnType<typeof useDb>;
+type ConversationRecord = typeof schema.conversations.$inferSelect;
+type AgentTurnOperation = 'send' | 'retry';
+type AgentTurnFiles = FileUploadInput[] | MessageFile[] | null | undefined;
+export type PreparedDefaultAgentTurn = {
+    needsNewThread: boolean;
+    effectiveModel?: string;
+    settingsTimestamp: Date;
+    messageTitle: string;
+    createPayload: AgentApiChatPayload;
+    continuePayload: ContinueSessionPayload;
+};
+export declare function buildTelaAgentTurnPayload(event: H3Event, conversation: Pick<ConversationRecord, 'threadSessionId' | 'telaAgentId'>, content: string, files?: FileUploadInput[] | MessageFile[] | null, agentInputs?: TelaAgentExecutionInput[] | null): Promise<TelaAgentRunPayload>;
+export declare function queueTelaAgentTurn(event: H3Event, db: DbInstance, options: {
+    conversation: ConversationRecord;
+    conversationId: string;
+    assistantMessageId: string;
+    payload: TelaAgentRunPayload;
+    titleContent: string;
+    operation: AgentTurnOperation;
+}): void;
+export declare function prepareDefaultAgentTurn(event: H3Event, db: DbInstance, context: ChatRuntimeContext, options: {
+    conversation: ConversationRecord;
+    conversationId: string;
+    content: string;
+    files?: AgentTurnFiles;
+    requestedModel?: string;
+    workspaceSettingsSnapshot?: unknown;
+}): Promise<PreparedDefaultAgentTurn>;
+export declare function resolveDefaultAgentEnvironmentVariables(event: H3Event, context: ChatRuntimeContext, logContext: Record<string, unknown>, failureMessage: string): Promise<Record<string, string>>;
+export declare function withEnvironmentVariables(payload: AgentApiChatPayload, environmentVariables: Record<string, string>): AgentApiChatPayload;
+export {};

package/dist/runtime/server/utils/conversation-agent-turn.js

@@ -0,0 +1,170 @@
+import { and, eq, isNull } from "drizzle-orm";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { schema } from "#chat-runtime/server/db";
+import { buildMessageWithContext, renderSystemPrompt, truncateTitle } from "#chat-runtime/server/utils/chat-message-builder";
+import {
+  getConversationAppliedSettings,
+  getWorkspaceSettingsUpdatedAt,
+  parseWorkspaceSettingsSnapshot,
+  resolveWorkspaceSettings,
+  serializeResolvedWorkspaceSettings
+} from "#chat-runtime/server/utils/chat-workspace-settings";
+import { logger } from "#chat-runtime/server/utils/logger";
+import { getTelaAgent, runTelaAgent } from "#chat-runtime/server/utils/tela-agent-api";
+import { toTelaAgentAttachments, toTelaAgentInputSchema } from "#chat-runtime/server/utils/tela-agent-session";
+import { resolveWorkspaceCredentials } from "#chat-runtime/server/utils/workspace";
+import { resolveChatNuxtFeatures } from "#chat-runtime/utils/features";
+import { mergeFileUrls } from "#chat-runtime/utils/file";
+import { isValidModel } from "#chat-runtime/types/chat";
+function getFileVaultRef(file) {
+  return file.vaultReference?.trim() || (file.url.startsWith("vault://") ? file.url : null);
+}
+function filterMappedFiles(files, inputSchema) {
+  const mappedVaultRefs = new Set(
+    inputSchema.filter((input) => input.type === "file").map((input) => input.vaultRef)
+  );
+  if (mappedVaultRefs.size === 0)
+    return files ?? [];
+  return (files ?? []).filter((file) => {
+    const vaultRef = getFileVaultRef(file);
+    return !vaultRef || !mappedVaultRefs.has(vaultRef);
+  });
+}
+export async function buildTelaAgentTurnPayload(event, conversation, content, files, agentInputs) {
+  let inputSchema = agentInputs ?? [];
+  let attachmentFiles = filterMappedFiles(files, inputSchema);
+  if (inputSchema.length === 0 && conversation.telaAgentId && files?.length) {
+    const agentResult = await getTelaAgent(event, conversation.telaAgentId);
+    if (agentResult.success) {
+      const fileInputCount = agentResult.data.inputSchema.filter((input) => input.type === "file" && input.name.trim()).length;
+      inputSchema = toTelaAgentInputSchema(files, agentResult.data.inputSchema);
+      if (inputSchema.length > 0) {
+        attachmentFiles = [];
+      } else if (fileInputCount > 1) {
+        logger.warn({
+          agentId: conversation.telaAgentId,
+          fileInputCount
+        }, "Tela agent file input auto-mapping skipped");
+      }
+    } else {
+      logger.warn({ agentId: conversation.telaAgentId, error: agentResult.error }, "Tela agent metadata fetch failed");
+    }
+  }
+  const attachments = toTelaAgentAttachments(attachmentFiles);
+  return {
+    message: content.trim(),
+    ...conversation.threadSessionId ? { sessionId: conversation.threadSessionId } : {},
+    ...inputSchema.length > 0 ? { inputSchema } : {},
+    ...attachments.length > 0 ? { attachments } : {}
+  };
+}
+export function queueTelaAgentTurn(event, db, options) {
+  const needsNewThread = options.conversation.threadSessionId === null;
+  const logContext = {
+    conversationId: options.conversationId,
+    messageId: options.assistantMessageId
+  };
+  const telaAgentId = options.conversation.telaAgentId;
+  if (!telaAgentId) {
+    logger.error(logContext, "Tela agent turn queued without agent id");
+    void db.update(schema.messages).set({
+      content: "Erro: Agente Tela n\xE3o configurado",
+      status: "failed"
+    }).where(eq(schema.messages.id, options.assistantMessageId));
+    return;
+  }
+  runTelaAgent(event, telaAgentId, options.payload).then(async (result) => {
+    if (result.success) {
+      await db.update(schema.conversations).set({
+        ...needsNewThread ? { title: truncateTitle(options.titleContent) } : {},
+        threadSessionId: result.sessionId,
+        model: null,
+        appliedSettingsAt: null,
+        appliedSettingsSnapshot: null,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(eq(schema.conversations.id, options.conversationId));
+    } else {
+      logger.warn({ ...logContext, error: result.error }, options.operation === "retry" ? "Tela agent retry failed" : "Tela agent run failed");
+      await db.update(schema.messages).set({
+        content: `Erro: ${result.error}`,
+        status: "failed"
+      }).where(eq(schema.messages.id, options.assistantMessageId));
+    }
+  }).catch(async (error) => {
+    logger.error({ ...logContext, error: error.message }, options.operation === "retry" ? "Tela agent retry threw exception" : "Tela agent run threw exception");
+    await db.update(schema.messages).set({
+      content: "Erro: Falha ao conectar ao agente",
+      status: "failed"
+    }).where(eq(schema.messages.id, options.assistantMessageId));
+  });
+}
+export async function prepareDefaultAgentTurn(event, db, context, options) {
+  const explicitSettings = !options.conversation.appliedSettingsSnapshot && options.workspaceSettingsSnapshot !== void 0 ? parseWorkspaceSettingsSnapshot(options.workspaceSettingsSnapshot) : void 0;
+  const trustedSettings = options.conversation.appliedSettingsSnapshot || explicitSettings ? null : await resolveWorkspaceSettings(event, context, db);
+  const appliedSettings = getConversationAppliedSettings(options.conversation, trustedSettings, explicitSettings);
+  const settingsTimestamp = getWorkspaceSettingsUpdatedAt(appliedSettings);
+  const snapshotSettings = explicitSettings ?? trustedSettings;
+  if (!options.conversation.appliedSettingsSnapshot && snapshotSettings) {
+    await db.update(schema.conversations).set({
+      appliedSettingsAt: getWorkspaceSettingsUpdatedAt(snapshotSettings),
+      appliedSettingsSnapshot: serializeResolvedWorkspaceSettings(snapshotSettings),
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(and(
+      eq(schema.conversations.id, options.conversationId),
+      isNull(schema.conversations.appliedSettingsSnapshot)
+    ));
+  }
+  const needsNewThread = options.conversation.threadSessionId === null;
+  const effectiveModel = options.requestedModel ?? (isValidModel(options.conversation.model) ? options.conversation.model : void 0);
+  const content = options.content.trim();
+  const knowledgeSources = appliedSettings.knowledgeSources ?? null;
+  const hasKnowledgeSources = knowledgeSources !== null && knowledgeSources.length > 0;
+  const externalSkillRefs = appliedSettings.externalSkills?.map((skill) => skill.ref) ?? [];
+  const skills = externalSkillRefs.length > 0 ? externalSkillRefs : void 0;
+  const fileUrls = mergeFileUrls(appliedSettings.contextFiles, options.files);
+  const { vaultUrl } = useRuntimeConfig();
+  const messageWithContext = buildMessageWithContext(
+    content,
+    appliedSettings.systemMessage ?? null,
+    knowledgeSources,
+    needsNewThread,
+    needsNewThread ? renderSystemPrompt(vaultUrl) : ""
+  );
+  return {
+    needsNewThread,
+    effectiveModel,
+    settingsTimestamp,
+    messageTitle: truncateTitle(options.content),
+    createPayload: {
+      message: messageWithContext,
+      fileUrls,
+      model: effectiveModel,
+      customTools: appliedSettings.canvasTools?.length ? { canvas: appliedSettings.canvasTools } : void 0,
+      tools: hasKnowledgeSources ? { workstationQueryTool: true } : void 0,
+      skills
+    },
+    continuePayload: {
+      content,
+      fileUrls,
+      model: effectiveModel
+    }
+  };
+}
+export async function resolveDefaultAgentEnvironmentVariables(event, context, logContext, failureMessage) {
+  if (!resolveChatNuxtFeatures(useRuntimeConfig()).credentials)
+    return {};
+  try {
+    return await resolveWorkspaceCredentials(event, context.workspaceId);
+  } catch (error) {
+    logger.warn({ ...logContext, error }, failureMessage);
+    return {};
+  }
+}
+export function withEnvironmentVariables(payload, environmentVariables) {
+  if (Object.keys(environmentVariables).length === 0)
+    return payload;
+  return {
+    ...payload,
+    environmentVariables
+  };
+}

package/dist/runtime/server/utils/conversation-message-files.d.ts

@@ -0,0 +1,10 @@
+import type { useDb } from '#chat-runtime/server/db';
+import type { MessageFile } from '#chat-runtime/types/chat';
+type DbInstance = ReturnType<typeof useDb>;
+type MessageUpdateWithFiles = {
+    content?: string;
+    status?: string;
+    files?: MessageFile[];
+};
+export declare function attachNewAssistantFilesToMessageUpdate(db: DbInstance, conversationId: string, updateData: MessageUpdateWithFiles, authToken: string): Promise<void>;
+export {};

package/dist/runtime/server/utils/conversation-message-files.js

@@ -0,0 +1,77 @@
+import { and, eq, isNotNull } from "drizzle-orm";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { APIKeyAuthStrategy, VaultFile } from "@meistrari/vault-sdk";
+import { schema } from "#chat-runtime/server/db";
+import { logger } from "#chat-runtime/server/utils/logger";
+import { detectFilesInText } from "#chat-runtime/utils/file";
+async function getExistingMessageFileUrls(db, conversationId) {
+  const messagesWithFiles = await db.select({ files: schema.messages.files }).from(schema.messages).where(and(
+    eq(schema.messages.conversationId, conversationId),
+    isNotNull(schema.messages.files)
+  ));
+  const urls = /* @__PURE__ */ new Set();
+  for (const message of messagesWithFiles) {
+    if (Array.isArray(message.files)) {
+      for (const file of message.files) {
+        if (file?.url) {
+          urls.add(file.url);
+        }
+      }
+    }
+  }
+  return urls;
+}
+async function extractAssistantFiles(content, authToken) {
+  const detected = detectFilesInText(content);
+  const vaultFiles = detected.filter((file) => file.type === "vault");
+  if (vaultFiles.length === 0)
+    return [];
+  const { vaultUrl } = useRuntimeConfig();
+  return Promise.all(
+    vaultFiles.map(async (file) => {
+      let name = file.name;
+      let mimeType = file.mimeType !== "unknown" ? file.mimeType : void 0;
+      let size;
+      if (vaultUrl) {
+        try {
+          const authStrategy = new APIKeyAuthStrategy(authToken);
+          const vaultFile = await VaultFile.fromVaultReference({
+            reference: file.reference,
+            config: { authStrategy, vaultUrl }
+          });
+          await vaultFile.populateMetadata();
+          if (vaultFile.metadata?.originalFileName) {
+            name = vaultFile.metadata.originalFileName;
+          }
+          if (vaultFile.metadata?.mimeType) {
+            mimeType = vaultFile.metadata.mimeType;
+          }
+          if (vaultFile.metadata?.size) {
+            size = vaultFile.metadata.size;
+          }
+        } catch {
+          logger.debug({ reference: file.reference }, "Vault metadata fetch failed for assistant file");
+        }
+      }
+      return {
+        url: file.reference,
+        name,
+        mimeType,
+        source: "assistant",
+        size
+      };
+    })
+  );
+}
+export async function attachNewAssistantFilesToMessageUpdate(db, conversationId, updateData, authToken) {
+  if (!updateData.content || updateData.status !== "completed")
+    return;
+  const assistantFiles = await extractAssistantFiles(updateData.content, authToken);
+  if (assistantFiles.length === 0)
+    return;
+  const existingUrls = await getExistingMessageFileUrls(db, conversationId);
+  const newFiles = assistantFiles.filter((file) => !existingUrls.has(file.url));
+  if (newFiles.length > 0) {
+    updateData.files = newFiles;
+  }
+}

package/dist/runtime/server/utils/conversation-message-sync.d.ts

@@ -0,0 +1,31 @@
+import type { useDb } from '#chat-runtime/server/db';
+import type { AgentApiSession, MessageStatus, ReasoningItem } from '#chat-runtime/types/agent';
+import type { ChatRuntimeContext } from '#chat-runtime/server/utils/chat-context';
+import type { Message, MessageFile } from '#chat-runtime/types/chat';
+import type { TelaAgentUsageValues } from '#chat-runtime/server/utils/tela-agent-session';
+type DbInstance = ReturnType<typeof useDb>;
+export type MessageUpdate = {
+    reasoningData?: ReasoningItem[];
+    externalUuid?: string;
+    content?: string;
+    status?: MessageStatus;
+    ttft?: string;
+    updatedAt?: Date;
+    files?: MessageFile[];
+};
+type MessageUpdateResponse = {
+    messages: Message[];
+    newFiles?: MessageFile[];
+};
+export declare function mapAgentApiSessionToMessageUpdate(agentSession: AgentApiSession, options: {
+    pendingMessage: Pick<Message, 'ttft' | 'createdAt'>;
+    lastAssistantMessage?: Pick<Message, 'externalUuid'> | null;
+    userMessage?: Pick<Message, 'createdAt'> | null;
+    now?: Date;
+}): MessageUpdate;
+export declare function hasMessageUpdate(updateData: MessageUpdate): boolean;
+export declare function isTerminalMessageUpdate(updateData: MessageUpdate): boolean;
+export declare function buildMessageUpdateResponse(messages: Message[], messageId: string, updateData: MessageUpdate): MessageUpdateResponse;
+export declare function trackTelaAgentConversationUsage(db: DbInstance, context: ChatRuntimeContext, conversationId: string, sessionId: string, usage: TelaAgentUsageValues | null): void;
+export declare function trackAgentApiConversationUsage(db: DbInstance, context: ChatRuntimeContext, conversationId: string, sessionId: string, agentSession: AgentApiSession): void;
+export {};