@meistrari/chat-nuxt 1.0.0

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

@@ -0,0 +1,131 @@
+import { and, asc, eq } from "drizzle-orm";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+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 db = useDb();
+  const conversationId = getRouterParam(event, "id");
+  const authToken = getAgentDataToken(event);
+  const { vaultUrl } = useRuntimeConfig();
+  if (!conversationId || !/^[0-9a-f-]{36}$/i.test(conversationId)) {
+    throw createError({
+      statusCode: 400,
+      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)
+  ));
+  if (!conversation) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Conversation not found"
+    });
+  }
+  const conversationMessages = await db.select({
+    id: schema.messages.id,
+    role: schema.messages.role,
+    createdAt: schema.messages.createdAt,
+    files: schema.messages.files,
+    content: schema.messages.content
+  }).from(schema.messages).where(eq(schema.messages.conversationId, conversationId)).orderBy(asc(schema.messages.createdAt));
+  const messagesWithFiles = conversationMessages.filter((msg) => Array.isArray(msg.files) && msg.files.length > 0);
+  const files = [];
+  const resolvedVaultRefs = /* @__PURE__ */ new Set();
+  const vaultRefEntries = [];
+  const seenInContent = /* @__PURE__ */ new Set();
+  for (const msg of conversationMessages) {
+    if (msg.content.trim() === "")
+      continue;
+    const vaultRefs = [...new Set(extractVaultReferences(msg.content))];
+    for (const reference of vaultRefs) {
+      if (!seenInContent.has(reference)) {
+        seenInContent.add(reference);
+        vaultRefEntries.push({ reference, msg });
+      }
+    }
+  }
+  if (vaultUrl && vaultRefEntries.length > 0) {
+    const resolved = await Promise.all(
+      vaultRefEntries.map(async ({ reference, msg }) => {
+        try {
+          const vaultFile = await VaultFile.fromVaultReference({
+            reference,
+            config: {
+              authStrategy: new APIKeyAuthStrategy(authToken),
+              vaultUrl
+            }
+          });
+          await vaultFile.populateMetadata();
+          const permalinks = await vaultFile.getPermalinks();
+          let permalink = permalinks.find((p) => !p.expiresAt);
+          if (!permalink) {
+            permalink = await vaultFile.createPermalink();
+          }
+          return {
+            id: generateFileId(reference),
+            url: permalink.url.toString(),
+            vaultReference: reference,
+            name: vaultFile.metadata?.originalFileName ?? "unknown",
+            mimeType: vaultFile.metadata?.mimeType ?? "application/octet-stream",
+            source: "message",
+            messageId: msg.id,
+            messageRole: msg.role === "user" || msg.role === "assistant" ? msg.role : void 0,
+            createdAt: msg.createdAt,
+            size: vaultFile.metadata?.size ?? 0
+          };
+        } catch (error) {
+          logger.error({ reference, error }, "Failed to resolve vault reference");
+          return null;
+        }
+      })
+    );
+    for (const file of resolved) {
+      if (file) {
+        files.push(file);
+        resolvedVaultRefs.add(file.vaultReference);
+      }
+    }
+  }
+  for (const message of messagesWithFiles) {
+    if (!Array.isArray(message.files))
+      continue;
+    for (const file of message.files) {
+      if (!file || typeof file !== "object" || !file.url || !file.name) {
+        continue;
+      }
+      const ref = file.vaultReference ?? file.url;
+      if (resolvedVaultRefs.has(ref))
+        continue;
+      resolvedVaultRefs.add(ref);
+      files.push({
+        id: generateFileId(file.url),
+        url: file.url,
+        name: file.name,
+        vaultReference: file.vaultReference ?? file.url,
+        mimeType: file.mimeType ?? "application/octet-stream",
+        source: "message",
+        messageId: message.id,
+        messageRole: message.role === "user" || message.role === "assistant" ? message.role : void 0,
+        createdAt: message.createdAt,
+        size: file.size
+      });
+    }
+  }
+  files.sort((a, b) => {
+    const dateA = a.createdAt?.getTime() ?? 0;
+    const dateB = b.createdAt?.getTime() ?? 0;
+    return dateB - dateA;
+  });
+  return {
+    files,
+    summary: {
+      total: files.length
+    }
+  };
+});

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,35 @@
+import { eq, and } from "drizzle-orm";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+import { getAgentDataToken, deleteSession } from "#chat-runtime/server/utils/agent-api";
+import { logger } from "#chat-runtime/server/utils/logger";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatContext(event);
+  const token = getAgentDataToken(event);
+  const db = useDb();
+  const id = getRouterParam(event, "id");
+  if (!id) {
+    throw createError({
+      statusCode: 400,
+      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();
+  if (!deleted) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Conversation not found"
+    });
+  }
+  logger.info({ conversationId: id, workspaceId: context.workspaceId }, "Conversation deleted");
+  if (deleted.threadSessionId) {
+    deleteSession(token, deleted.threadSessionId).catch(() => {
+    });
+  }
+  return { success: true };
+});

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,34 @@
+import { eq, and, asc } from "drizzle-orm";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatContext(event);
+  const db = useDb();
+  const id = getRouterParam(event, "id");
+  if (!id) {
+    throw createError({
+      statusCode: 400,
+      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;
+  if (!conversation) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Conversation not found"
+    });
+  }
+  return {
+    ...conversation,
+    messages
+  };
+});

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,54 @@
+import { eq, and } from "drizzle-orm";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+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 db = useDb();
+  const id = getRouterParam(event, "id");
+  if (!id) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Conversation ID is required"
+    });
+  }
+  const body = await readBody(event);
+  if (body.title === void 0 && body.model === void 0) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "At least one field is required to update"
+    });
+  }
+  if (body.title !== void 0 && !body.title?.trim()) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Title cannot be empty"
+    });
+  }
+  if (body.model !== void 0 && body.model !== null && !isValidModel(body.model)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid model"
+    });
+  }
+  const updateData = { updatedAt: /* @__PURE__ */ new Date() };
+  if (body.title !== void 0)
+    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();
+  if (!updated) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Conversation not found"
+    });
+  }
+  logger.debug({ conversationId: id }, "Conversation title updated");
+  return updated;
+});

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,168 @@
+import { eq, and, lt, desc, isNull } 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 {
+  getConversationAppliedSettings,
+  getWorkspaceSettingsUpdatedAt,
+  resolveWorkspaceSettings,
+  serializeResolvedWorkspaceSettings
+} from "#chat-runtime/server/utils/chat-workspace-settings";
+import { resolveWorkspaceCredentials } from "#chat-runtime/server/utils/workspace";
+import { mergeFileUrls } from "#chat-runtime/utils/file";
+import { isValidModel } from "#chat-runtime/types/chat";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatContext(event);
+  const token = getAgentDataToken(event);
+  const db = useDb();
+  const conversationId = getRouterParam(event, "id");
+  const messageId = getRouterParam(event, "messageId");
+  if (!conversationId || !messageId) {
+    throw createError({
+      statusCode: 400,
+      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)
+    )
+  );
+  if (!conversation) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Conversation not found"
+    });
+  }
+  const [failedMessage] = await db.select().from(schema.messages).where(
+    and(
+      eq(schema.messages.id, messageId),
+      eq(schema.messages.conversationId, conversationId),
+      eq(schema.messages.role, "assistant"),
+      eq(schema.messages.status, "failed")
+    )
+  );
+  if (!failedMessage) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Failed message not found"
+    });
+  }
+  const [userMessage] = await db.select().from(schema.messages).where(
+    and(
+      eq(schema.messages.conversationId, conversationId),
+      eq(schema.messages.role, "user"),
+      lt(schema.messages.createdAt, failedMessage.createdAt)
+    )
+  ).orderBy(desc(schema.messages.createdAt)).limit(1);
+  if (!userMessage) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "User message not found"
+    });
+  }
+  await db.update(schema.messages).set({
+    content: "",
+    status: "pending",
+    reasoningData: null,
+    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)
+    ));
+  }
+  const processAgent = async () => {
+    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");
+        }
+        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 (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,
+            updatedAt: /* @__PURE__ */ new Date()
+          }).where(eq(schema.conversations.id, conversationId));
+        } else {
+          logger.warn({ conversationId, messageId, error: result.error }, "Agent thread creation failed on retry");
+          await db.update(schema.messages).set({
+            content: `Erro: ${result.error}`,
+            status: "failed"
+          }).where(eq(schema.messages.id, messageId));
+        }
+      } else {
+        const result = await continueSession(token, conversation.threadSessionId, {
+          content: userMessage.content.trim(),
+          fileUrls,
+          model: effectiveModel
+        });
+        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));
+        }
+        await db.update(schema.conversations).set({
+          ...effectiveModel ? { model: 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"}`,
+        status: "failed"
+      }).where(eq(schema.messages.id, messageId));
+    }
+  };
+  void processAgent();
+  const [updatedMessage] = await db.select().from(schema.messages).where(eq(schema.messages.id, messageId));
+  return updatedMessage;
+});

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,220 @@
+import { and, asc, eq, gt, isNotNull } from "drizzle-orm";
+import { APIKeyAuthStrategy, VaultFile } from "@meistrari/vault-sdk";
+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 { 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 token = getAgentDataToken(event);
+  const db = useDb();
+  const conversationId = getRouterParam(event, "id");
+  const query = getQuery(event);
+  const after = query.after;
+  if (!conversationId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Conversation ID is required"
+    });
+  }
+  const conditions = [eq(schema.messages.conversationId, conversationId)];
+  if (after) {
+    const afterDate = new Date(after);
+    if (!Number.isNaN(afterDate.getTime())) {
+      conditions.push(gt(schema.messages.createdAt, afterDate));
+    }
+  }
+  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.messages).where(and(...conditions)).orderBy(asc(schema.messages.createdAt))
+  ]);
+  const [conversation] = conversationResult;
+  if (!conversation) {
+    throw createError({
+      statusCode: 404,
+      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, newReasoning);
+          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 };
+      }
+    }
+  }
+  return { messages };
+});

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;