@meistrari/chat-nuxt 1.4.0 → 1.5.1

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

@@ -1,11 +1,12 @@
 import { createError, defineEventHandler, getRouterParam } from "h3";
-import { eq, and, asc } from "drizzle-orm";
+import { eq, asc } from "drizzle-orm";
 import { useDb, schema } from "#chat-runtime/server/db";
-import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { conversationScopeConditions } from "#chat-runtime/server/utils/conversation-scope";
 import { getWorkspaceSettingsUpdatedAt, resolveWorkspaceSettings, serializeResolvedWorkspaceSettings } from "#chat-runtime/server/utils/chat-workspace-settings";
 import { logger } from "#chat-runtime/server/utils/logger";
 export default defineEventHandler(async (event) => {
-  const context = resolveChatContext(event);
+  const context = resolveChatRuntimeContext(event);
   const db = useDb();
   const id = getRouterParam(event, "id");
   if (!id) {
@@ -14,28 +15,25 @@ export default defineEventHandler(async (event) => {
       statusMessage: "Conversation ID is required"
     });
   }
-  const [original] = await db.select().from(schema.conversations).where(
-    and(
-      eq(schema.conversations.id, id),
-      eq(schema.conversations.workspaceId, context.workspaceId)
-    )
-  ).limit(1);
+  const [original] = await db.select().from(schema.conversations).where(conversationScopeConditions(context, id)).limit(1);
   if (!original) {
     throw createError({
       statusCode: 404,
       statusMessage: "Conversation not found"
     });
   }
-  const trustedSettings = original.appliedSettingsSnapshot ? original.appliedSettingsSnapshot : await resolveWorkspaceSettings(event, context, db);
+  const trustedSettings = original.telaAgentId ? null : original.appliedSettingsSnapshot ?? await resolveWorkspaceSettings(event, context, db);
   const duplicated = await db.transaction(async (tx) => {
     const [newConversation] = await tx.insert(schema.conversations).values({
       workspaceId: context.workspaceId,
       userId: context.user.id,
       title: `${original.title} (copy)`,
       createdBy: context.user.email,
-      model: original.model,
-      appliedSettingsAt: getWorkspaceSettingsUpdatedAt(trustedSettings),
-      appliedSettingsSnapshot: serializeResolvedWorkspaceSettings(trustedSettings)
+      telaAgentId: original.telaAgentId,
+      threadSessionId: null,
+      model: original.telaAgentId ? null : original.model,
+      appliedSettingsAt: trustedSettings ? getWorkspaceSettingsUpdatedAt(trustedSettings) : null,
+      appliedSettingsSnapshot: trustedSettings ? serializeResolvedWorkspaceSettings(trustedSettings) : null
     }).returning();
     if (!newConversation) {
       throw createError({

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

@@ -1,14 +1,15 @@
 import { createError, defineEventHandler, getRouterParam } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
-import { and, asc, eq } from "drizzle-orm";
+import { asc, eq } from "drizzle-orm";
 import { useDb, schema } from "#chat-runtime/server/db";
-import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { conversationScopeConditions } from "#chat-runtime/server/utils/conversation-scope";
 import { APIKeyAuthStrategy, extractVaultReferences, VaultFile } from "@meistrari/vault-sdk";
 import { getAgentDataToken } from "#chat-runtime/server/utils/agent-api";
 import { generateFileId } from "#chat-runtime/utils/file";
 import { logger } from "#chat-runtime/server/utils/logger";
 export default defineEventHandler(async (event) => {
-  const context = resolveChatContext(event);
+  const context = resolveChatRuntimeContext(event);
   const db = useDb();
   const conversationId = getRouterParam(event, "id");
   const authToken = getAgentDataToken(event);
@@ -19,10 +20,7 @@ export default defineEventHandler(async (event) => {
       statusMessage: "Invalid conversation ID format"
     });
   }
-  const [conversation] = await db.select().from(schema.conversations).where(and(
-    eq(schema.conversations.id, conversationId),
-    eq(schema.conversations.workspaceId, context.workspaceId)
-  ));
+  const [conversation] = await db.select().from(schema.conversations).where(conversationScopeConditions(context, conversationId));
   if (!conversation) {
     throw createError({
       statusCode: 404,

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

@@ -1,12 +1,12 @@
 import { createError, defineEventHandler, getRouterParam } from "h3";
-import { eq, and } from "drizzle-orm";
 import { useDb, schema } from "#chat-runtime/server/db";
-import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { conversationScopeConditions } from "#chat-runtime/server/utils/conversation-scope";
 import { getAgentDataToken, deleteSession } from "#chat-runtime/server/utils/agent-api";
+import { endTelaAgentSession } from "#chat-runtime/server/utils/tela-agent-api";
 import { logger } from "#chat-runtime/server/utils/logger";
 export default defineEventHandler(async (event) => {
-  const context = resolveChatContext(event);
-  const token = getAgentDataToken(event);
+  const context = resolveChatRuntimeContext(event);
   const db = useDb();
   const id = getRouterParam(event, "id");
   if (!id) {
@@ -15,12 +15,7 @@ export default defineEventHandler(async (event) => {
       statusMessage: "Conversation ID is required"
     });
   }
-  const [deleted] = await db.delete(schema.conversations).where(
-    and(
-      eq(schema.conversations.id, id),
-      eq(schema.conversations.workspaceId, context.workspaceId)
-    )
-  ).returning();
+  const [deleted] = await db.delete(schema.conversations).where(conversationScopeConditions(context, id)).returning();
   if (!deleted) {
     throw createError({
       statusCode: 404,
@@ -29,8 +24,14 @@ export default defineEventHandler(async (event) => {
   }
   logger.info({ conversationId: id, workspaceId: context.workspaceId }, "Conversation deleted");
   if (deleted.threadSessionId) {
-    deleteSession(token, deleted.threadSessionId).catch(() => {
-    });
+    if (deleted.telaAgentId) {
+      endTelaAgentSession(event, deleted.threadSessionId).catch(() => {
+      });
+    } else {
+      const token = getAgentDataToken(event);
+      deleteSession(token, deleted.threadSessionId).catch(() => {
+      });
+    }
   }
   return { success: true };
 });

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

@@ -1,9 +1,10 @@
 import { createError, defineEventHandler, getRouterParam } from "h3";
-import { eq, and, asc } from "drizzle-orm";
+import { eq, asc } from "drizzle-orm";
 import { useDb, schema } from "#chat-runtime/server/db";
-import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { conversationScopeConditions } from "#chat-runtime/server/utils/conversation-scope";
 export default defineEventHandler(async (event) => {
-  const context = resolveChatContext(event);
+  const context = resolveChatRuntimeContext(event);
   const db = useDb();
   const id = getRouterParam(event, "id");
   if (!id) {
@@ -12,22 +13,14 @@ export default defineEventHandler(async (event) => {
       statusMessage: "Conversation ID is required"
     });
   }
-  const [conversationResult, messages] = await Promise.all([
-    db.select().from(schema.conversations).where(
-      and(
-        eq(schema.conversations.id, id),
-        eq(schema.conversations.workspaceId, context.workspaceId)
-      )
-    ),
-    db.select().from(schema.messages).where(eq(schema.messages.conversationId, id)).orderBy(asc(schema.messages.createdAt))
-  ]);
-  const [conversation] = conversationResult;
+  const [conversation] = await db.select().from(schema.conversations).where(conversationScopeConditions(context, id));
   if (!conversation) {
     throw createError({
       statusCode: 404,
       statusMessage: "Conversation not found"
     });
   }
+  const messages = await db.select().from(schema.messages).where(eq(schema.messages.conversationId, id)).orderBy(asc(schema.messages.createdAt));
   return {
     ...conversation,
     messages

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

@@ -1,11 +1,11 @@
 import { createError, defineEventHandler, getRouterParam, readBody } from "h3";
-import { eq, and } from "drizzle-orm";
 import { useDb, schema } from "#chat-runtime/server/db";
-import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { conversationScopeConditions } from "#chat-runtime/server/utils/conversation-scope";
 import { logger } from "#chat-runtime/server/utils/logger";
 import { isValidModel } from "#chat-runtime/types/chat";
 export default defineEventHandler(async (event) => {
-  const context = resolveChatContext(event);
+  const context = resolveChatRuntimeContext(event);
   const db = useDb();
   const id = getRouterParam(event, "id");
   if (!id) {
@@ -27,7 +27,13 @@ export default defineEventHandler(async (event) => {
       statusMessage: "Title cannot be empty"
     });
   }
-  if (body.model !== void 0 && body.model !== null && !isValidModel(body.model)) {
+  if (context.telaAgentId && body.model !== void 0) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Model cannot be updated for Tela-agent conversations"
+    });
+  }
+  if (!context.telaAgentId && body.model !== void 0 && body.model !== null && !isValidModel(body.model)) {
     throw createError({
       statusCode: 400,
       statusMessage: "Invalid model"
@@ -38,12 +44,7 @@ export default defineEventHandler(async (event) => {
     updateData.title = body.title.trim();
   if (body.model !== void 0)
     updateData.model = body.model;
-  const [updated] = await db.update(schema.conversations).set(updateData).where(
-    and(
-      eq(schema.conversations.id, id),
-      eq(schema.conversations.workspaceId, context.workspaceId)
-    )
-  ).returning();
+  const [updated] = await db.update(schema.conversations).set(updateData).where(conversationScopeConditions(context, id)).returning();
   if (!updated) {
     throw createError({
       statusCode: 404,

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

@@ -1,24 +1,19 @@
 import { createError, defineEventHandler, getRouterParam } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
-import { eq, and, lt, desc, isNull } from "drizzle-orm";
+import { eq, and, lt, desc } from "drizzle-orm";
 import { logger } from "#chat-runtime/server/utils/logger";
 import { useDb, schema } from "#chat-runtime/server/db";
-import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
-import { buildMessageWithContext, renderSystemPrompt, truncateTitle } from "#chat-runtime/server/utils/chat-message-builder";
-import { getAgentDataToken, createChatAgentSession, continueSession } from "#chat-runtime/server/utils/agent-api";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
 import {
-  getConversationAppliedSettings,
-  getWorkspaceSettingsUpdatedAt,
-  resolveWorkspaceSettings,
-  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";
+  buildTelaAgentTurnPayload,
+  prepareDefaultAgentTurn,
+  queueTelaAgentTurn,
+  resolveDefaultAgentEnvironmentVariables,
+  withEnvironmentVariables
+} from "#chat-runtime/server/utils/conversation-agent-turn";
+import { conversationScopeConditions } from "#chat-runtime/server/utils/conversation-scope";
+import { getAgentDataToken, createChatAgentSession, continueSession } from "#chat-runtime/server/utils/agent-api";
 export default defineEventHandler(async (event) => {
-  const context = resolveChatContext(event);
-  const token = getAgentDataToken(event);
+  const context = resolveChatRuntimeContext(event);
   const db = useDb();
   const conversationId = getRouterParam(event, "id");
   const messageId = getRouterParam(event, "messageId");
@@ -28,12 +23,7 @@ export default defineEventHandler(async (event) => {
       statusMessage: "Conversation ID and Message ID are required"
     });
   }
-  const [conversation] = await db.select().from(schema.conversations).where(
-    and(
-      eq(schema.conversations.id, conversationId),
-      eq(schema.conversations.workspaceId, context.workspaceId)
-    )
-  );
+  const [conversation] = await db.select().from(schema.conversations).where(conversationScopeConditions(context, conversationId));
   if (!conversation) {
     throw createError({
       statusCode: 404,
@@ -67,6 +57,7 @@ export default defineEventHandler(async (event) => {
       statusMessage: "User message not found"
     });
   }
+  const telaAgentPayload = conversation.telaAgentId ? await buildTelaAgentTurnPayload(event, conversation, userMessage.content, userMessage.files ?? void 0) : null;
   await db.update(schema.messages).set({
     content: "",
     status: "pending",
@@ -74,64 +65,42 @@ export default defineEventHandler(async (event) => {
     files: null
   }).where(eq(schema.messages.id, messageId));
   logger.info({ conversationId, messageId }, "Message retry initiated");
-  const trustedSettings = conversation.appliedSettingsSnapshot ? null : await resolveWorkspaceSettings(event, context, db);
-  const appliedSettings = getConversationAppliedSettings(conversation, trustedSettings);
-  const needsNewThread = conversation.threadSessionId === null;
-  const fileUrls = mergeFileUrls(appliedSettings.contextFiles, userMessage.files);
-  const knowledgeSources = appliedSettings.knowledgeSources ?? null;
-  const hasKnowledgeSources = knowledgeSources !== null && knowledgeSources.length > 0;
-  const { vaultUrl } = useRuntimeConfig();
-  const messageWithContext = buildMessageWithContext(
-    userMessage.content.trim(),
-    appliedSettings.systemMessage ?? null,
-    knowledgeSources,
-    needsNewThread,
-    needsNewThread ? renderSystemPrompt(vaultUrl) : ""
-  );
-  const canvasTools = appliedSettings.canvasTools;
-  const externalSkillRefs = appliedSettings.externalSkills?.map((skill) => skill.ref) ?? [];
-  const skills = externalSkillRefs.length > 0 ? externalSkillRefs : void 0;
-  const effectiveModel = isValidModel(conversation.model) ? conversation.model : void 0;
-  const messageTitle = truncateTitle(userMessage.content);
-  const settingsTimestamp = getWorkspaceSettingsUpdatedAt(appliedSettings);
-  if (!conversation.appliedSettingsSnapshot && trustedSettings) {
-    await db.update(schema.conversations).set({
-      appliedSettingsAt: settingsTimestamp,
-      appliedSettingsSnapshot: serializeResolvedWorkspaceSettings(trustedSettings),
-      updatedAt: /* @__PURE__ */ new Date()
-    }).where(and(
-      eq(schema.conversations.id, conversationId),
-      isNull(schema.conversations.appliedSettingsSnapshot)
-    ));
+  if (conversation.telaAgentId) {
+    queueTelaAgentTurn(event, db, {
+      conversation,
+      conversationId,
+      assistantMessageId: messageId,
+      payload: telaAgentPayload,
+      titleContent: userMessage.content,
+      operation: "retry"
+    });
+    const [updatedMessage2] = await db.select().from(schema.messages).where(eq(schema.messages.id, messageId));
+    return updatedMessage2;
   }
+  const token = getAgentDataToken(event);
+  const defaultAgentTurn = await prepareDefaultAgentTurn(event, db, context, {
+    conversation,
+    conversationId,
+    content: userMessage.content,
+    files: userMessage.files
+  });
   const processAgent = async () => {
     try {
-      if (needsNewThread) {
-        let environmentVariables = {};
-        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, {
-          message: messageWithContext,
-          fileUrls,
-          model: effectiveModel,
-          customTools: canvasTools?.length ? { canvas: canvasTools } : void 0,
-          tools: hasKnowledgeSources ? { workstationQueryTool: true } : void 0,
-          environmentVariables: hasEnvironmentVariables ? environmentVariables : void 0,
-          skills
-        });
+      if (defaultAgentTurn.needsNewThread) {
+        const environmentVariables = await resolveDefaultAgentEnvironmentVariables(
+          event,
+          context,
+          { conversationId, messageId },
+          "Failed to resolve workspace credentials on retry, proceeding without env vars"
+        );
+        const result = await createChatAgentSession(token, withEnvironmentVariables(defaultAgentTurn.createPayload, environmentVariables));
         if (result.success) {
           logger.info({ conversationId, messageId, sessionId: result.sessionId }, "New agent thread created on retry");
           await db.update(schema.conversations).set({
             threadSessionId: result.sessionId,
-            title: messageTitle,
-            appliedSettingsAt: settingsTimestamp,
-            model: effectiveModel ?? null,
+            title: defaultAgentTurn.messageTitle,
+            appliedSettingsAt: defaultAgentTurn.settingsTimestamp,
+            model: defaultAgentTurn.effectiveModel ?? null,
             updatedAt: /* @__PURE__ */ new Date()
           }).where(eq(schema.conversations.id, conversationId));
         } else {
@@ -142,27 +111,24 @@ export default defineEventHandler(async (event) => {
           }).where(eq(schema.messages.id, messageId));
         }
       } else {
-        const result = await continueSession(token, conversation.threadSessionId, {
-          content: userMessage.content.trim(),
-          fileUrls,
-          model: effectiveModel
-        });
+        const result = await continueSession(token, conversation.threadSessionId, defaultAgentTurn.continuePayload);
         if (!result.success) {
           logger.warn({ conversationId, messageId, error: result.error }, "Agent session continue failed on retry");
           await db.update(schema.messages).set({
             content: `Erro: ${result.error}`,
             status: "failed"
           }).where(eq(schema.messages.id, messageId));
+          return;
         }
         await db.update(schema.conversations).set({
-          ...effectiveModel ? { model: effectiveModel } : {},
+          ...defaultAgentTurn.effectiveModel ? { model: defaultAgentTurn.effectiveModel } : {},
           updatedAt: /* @__PURE__ */ new Date()
         }).where(eq(schema.conversations.id, conversationId));
       }
     } catch (error) {
       logger.error({ error }, "Failed to process agent retry");
       await db.update(schema.messages).set({
-        content: `Erro: ${needsNewThread ? "Falha ao conectar ao agente" : "Falha ao continuar a sess\xE3o"}`,
+        content: `Erro: ${defaultAgentTurn.needsNewThread ? "Falha ao conectar ao agente" : "Falha ao continuar a sess\xE3o"}`,
         status: "failed"
       }).where(eq(schema.messages.id, messageId));
     }

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

@@ -1,15 +1,2 @@
-type MessageFile = {
-    url: string;
-    name: string;
-    mimeType?: string;
-    source: 'user' | 'assistant';
-    size?: number;
-};
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    messages: any;
-    newFiles: MessageFile[];
-} | {
-    messages: any;
-    newFiles?: undefined;
-}>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
 export default _default;