@meistrari/chat-nuxt 1.4.0 → 1.5.0

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;

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

@@ -1,74 +1,23 @@
 import { createError, defineEventHandler, getQuery, getRouterParam } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
-import { and, asc, eq, gt, isNotNull } from "drizzle-orm";
-import { APIKeyAuthStrategy, VaultFile } from "@meistrari/vault-sdk";
+import { and, asc, eq, gt } from "drizzle-orm";
 import { schema, useDb } from "#chat-runtime/server/db";
-import { extractContentFromSession, getAgentDataToken, getSessionStatus } from "#chat-runtime/server/utils/agent-api";
-import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
-import { detectFilesInText } from "#chat-runtime/utils/file";
+import { getAgentDataToken, getSessionStatus } from "#chat-runtime/server/utils/agent-api";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { attachNewAssistantFilesToMessageUpdate } from "#chat-runtime/server/utils/conversation-message-files";
+import {
+  buildMessageUpdateResponse,
+  hasMessageUpdate,
+  isTerminalMessageUpdate,
+  mapAgentApiSessionToMessageUpdate,
+  trackAgentApiConversationUsage,
+  trackTelaAgentConversationUsage
+} from "#chat-runtime/server/utils/conversation-message-sync";
+import { conversationScopeConditions } from "#chat-runtime/server/utils/conversation-scope";
+import { getTelaAgentSession } from "#chat-runtime/server/utils/tela-agent-api";
+import { mapTelaAgentSessionToMessageUpdate, mapTelaAgentUsage } from "#chat-runtime/server/utils/tela-agent-session";
 import { logger } from "#chat-runtime/server/utils/logger";
-async function getExistingFileUrls(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((f) => f.type === "vault");
-  if (vaultFiles.length === 0)
-    return [];
-  const { vaultUrl } = useRuntimeConfig();
-  const filesWithMetadata = await 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
-      };
-    })
-  );
-  return filesWithMetadata;
-}
 export default defineEventHandler(async (event) => {
-  const context = resolveChatContext(event);
+  const context = resolveChatRuntimeContext(event);
   const token = getAgentDataToken(event);
   const db = useDb();
   const conversationId = getRouterParam(event, "id");
@@ -88,12 +37,7 @@ export default defineEventHandler(async (event) => {
     }
   }
   const [conversationResult, messages] = await Promise.all([
-    db.select().from(schema.conversations).where(
-      and(
-        eq(schema.conversations.id, conversationId),
-        eq(schema.conversations.workspaceId, context.workspaceId)
-      )
-    ),
+    db.select().from(schema.conversations).where(conversationScopeConditions(context, conversationId)),
     db.select().from(schema.messages).where(and(...conditions)).orderBy(asc(schema.messages.createdAt))
   ]);
   const [conversation] = conversationResult;
@@ -103,120 +47,70 @@ export default defineEventHandler(async (event) => {
       statusMessage: "Conversation not found"
     });
   }
-  const pendingMessage = messages.find((m) => m.status === "pending");
-  const lastAssistantMessage = messages.findLast((m) => m.role === "assistant" && m.status === "completed");
-  if (pendingMessage && conversation.threadSessionId) {
-    logger.debug({ conversationId, messageId: pendingMessage.id, sessionId: conversation.threadSessionId }, "Polling pending message");
-    const sessionResult = await getSessionStatus(token, conversation.threadSessionId);
-    if (sessionResult.success) {
-      const agentSession = sessionResult.data;
-      const updateData = {};
-      const lastSyncedUuid = lastAssistantMessage?.externalUuid;
-      const lastSyncedIndex = lastSyncedUuid ? agentSession.reasoning?.findIndex((r) => r.uuid === lastSyncedUuid) ?? -1 : -1;
-      const newReasoning = agentSession.reasoning?.slice(lastSyncedIndex + 1);
-      const hasNewReasoning = newReasoning && newReasoning.length > 0;
-      if (hasNewReasoning) {
-        updateData.reasoningData = newReasoning;
-        const lastReasoningItem = newReasoning.at(-1);
-        if (lastReasoningItem?.uuid) {
-          updateData.externalUuid = lastReasoningItem.uuid;
-        }
-        if (!pendingMessage.ttft) {
-          const userMessage = messages.findLast((m) => m.role === "user");
-          if (userMessage) {
-            const ttft = Date.now() - userMessage.createdAt.getTime();
-            updateData.ttft = String(ttft);
-          }
-        }
-      }
-      if (agentSession.status === "completed" || agentSession.status === "waiting_messages") {
-        if (hasNewReasoning) {
-          const content = extractContentFromSession(agentSession);
-          updateData.content = content;
-          updateData.status = "completed";
-          updateData.updatedAt = /* @__PURE__ */ new Date();
-          logger.info({ conversationId, messageId: pendingMessage.id, status: "completed" }, "Message completed");
-          const assistantFiles = await extractAssistantFiles(content, token);
-          if (assistantFiles.length > 0) {
-            const existingUrls = await getExistingFileUrls(db, conversationId);
-            const newFiles = assistantFiles.filter((f) => !existingUrls.has(f.url));
-            if (newFiles.length > 0) {
-              updateData.files = newFiles;
-            }
-          }
-        }
-      } else if (agentSession.status === "failed") {
-        const errorContent = agentSession.error || "Agent execution failed";
-        updateData.content = `Error: ${errorContent}`;
-        updateData.status = agentSession.status;
-        updateData.updatedAt = /* @__PURE__ */ new Date();
-        logger.warn({ conversationId, messageId: pendingMessage.id, status: "failed" }, "Message failed");
-      }
-      if (Object.keys(updateData).length > 0) {
-        await db.update(schema.messages).set(updateData).where(eq(schema.messages.id, pendingMessage.id));
-        if ((updateData.status === "completed" || updateData.status === "failed") && agentSession.result?.usage) {
-          const usage = agentSession.result.usage;
-          const breakdown = agentSession.result?.usageBreakdown;
-          const serverToolUse = breakdown?.serverToolUse;
-          const webSearchRequests = typeof serverToolUse?.web_search_requests === "number" ? serverToolUse.web_search_requests : null;
-          const webFetchRequests = typeof serverToolUse?.web_fetch_requests === "number" ? serverToolUse.web_fetch_requests : null;
-          void db.insert(schema.conversationUsage).values({
-            workspaceId: context.workspaceId,
-            conversationId,
-            promptTokens: usage.promptTokens ?? 0,
-            completionTokens: usage.completionTokens ?? 0,
-            totalTokens: usage.totalTokens ?? 0,
-            promptCost: String(usage.promptCost ?? 0),
-            completionCost: String(usage.completionCost ?? 0),
-            totalCost: String(usage.totalCost ?? 0),
-            durationMs: usage.duration ?? null,
-            turns: usage.turns ?? null,
-            userId: context.user.id,
-            userEmail: context.user.email ?? null,
-            model: agentSession.model ?? null,
-            sessionId: conversation.threadSessionId,
-            cacheReadInputTokens: breakdown?.cacheReadInputTokens ?? null,
-            cacheCreationInputTokens: breakdown?.cacheCreationInputTokens ?? null,
-            modelUsage: breakdown?.modelUsage ?? null,
-            durationApiMs: breakdown?.durationApiMs ?? null,
-            webSearchRequests,
-            webFetchRequests
-          }).onConflictDoUpdate({
-            target: schema.conversationUsage.conversationId,
-            set: {
-              promptTokens: usage.promptTokens ?? 0,
-              completionTokens: usage.completionTokens ?? 0,
-              totalTokens: usage.totalTokens ?? 0,
-              promptCost: String(usage.promptCost ?? 0),
-              completionCost: String(usage.completionCost ?? 0),
-              totalCost: String(usage.totalCost ?? 0),
-              durationMs: usage.duration ?? null,
-              turns: usage.turns ?? null,
-              model: agentSession.model ?? null,
-              cacheReadInputTokens: breakdown?.cacheReadInputTokens ?? null,
-              cacheCreationInputTokens: breakdown?.cacheCreationInputTokens ?? null,
-              modelUsage: breakdown?.modelUsage ?? null,
-              durationApiMs: breakdown?.durationApiMs ?? null,
-              webSearchRequests,
-              webFetchRequests,
-              updatedAt: /* @__PURE__ */ new Date()
-            }
-          }).catch((error) => {
-            console.warn("Failed to track conversation usage:", error);
-          });
-        }
-        const updatedMessages = messages.map(
-          (m) => m.id === pendingMessage.id ? { ...m, ...updateData } : m
-        );
-        if (updateData.files && updateData.files.length > 0) {
-          return {
-            messages: updatedMessages,
-            newFiles: updateData.files
-          };
-        }
-        return { messages: updatedMessages };
-      }
+  const pendingMessage = messages.find((message) => message.status === "pending");
+  const lastAssistantMessage = messages.findLast((message) => message.role === "assistant" && message.status === "completed");
+  if (!pendingMessage || !conversation.threadSessionId) {
+    return { messages };
+  }
+  logger.debug({ conversationId, messageId: pendingMessage.id, sessionId: conversation.threadSessionId }, "Polling pending message");
+  if (conversation.telaAgentId) {
+    const sessionResult2 = await getTelaAgentSession(event, conversation.threadSessionId);
+    if (!sessionResult2.success) {
+      return { messages };
+    }
+    const agentSession2 = sessionResult2.data;
+    const userMessage2 = messages.findLast((message) => message.role === "user");
+    const updateData2 = mapTelaAgentSessionToMessageUpdate(agentSession2, {
+      lastSyncedStepId: pendingMessage.externalUuid ?? lastAssistantMessage?.externalUuid,
+      existingReasoningData: Array.isArray(pendingMessage.reasoningData) ? pendingMessage.reasoningData : null,
+      pendingMessageTtft: pendingMessage.ttft,
+      userMessageCreatedAt: userMessage2?.createdAt ?? null
+    });
+    await attachNewAssistantFilesToMessageUpdate(db, conversationId, updateData2, token);
+    if (!hasMessageUpdate(updateData2)) {
+      return { messages };
     }
+    await db.update(schema.messages).set(updateData2).where(eq(schema.messages.id, pendingMessage.id));
+    if (isTerminalMessageUpdate(updateData2)) {
+      trackTelaAgentConversationUsage(
+        db,
+        context,
+        conversationId,
+        conversation.threadSessionId,
+        mapTelaAgentUsage(agentSession2)
+      );
+    }
+    return buildMessageUpdateResponse(messages, pendingMessage.id, updateData2);
+  }
+  const sessionResult = await getSessionStatus(token, conversation.threadSessionId);
+  if (!sessionResult.success) {
+    return { messages };
+  }
+  const agentSession = sessionResult.data;
+  const userMessage = messages.findLast((message) => message.role === "user");
+  const updateData = mapAgentApiSessionToMessageUpdate(agentSession, {
+    pendingMessage,
+    lastAssistantMessage,
+    userMessage
+  });
+  if (updateData.status === "completed") {
+    logger.info({ conversationId, messageId: pendingMessage.id, status: "completed" }, "Message completed");
+  } else if (updateData.status === "failed") {
+    logger.warn({ conversationId, messageId: pendingMessage.id, status: "failed" }, "Message failed");
+  }
+  await attachNewAssistantFilesToMessageUpdate(db, conversationId, updateData, token);
+  if (!hasMessageUpdate(updateData)) {
+    return { messages };
+  }
+  await db.update(schema.messages).set(updateData).where(eq(schema.messages.id, pendingMessage.id));
+  if (isTerminalMessageUpdate(updateData)) {
+    trackAgentApiConversationUsage(
+      db,
+      context,
+      conversationId,
+      conversation.threadSessionId,
+      agentSession
+    );
   }
-  return { messages };
+  return buildMessageUpdateResponse(messages, pendingMessage.id, updateData);
 });