@meistrari/chat-nuxt 1.3.0 → 1.5.0

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, 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 };
-      }
+  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);
 });

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

@@ -1,24 +1,21 @@
 import { createError, defineEventHandler, getRouterParam, readBody } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
-import { eq, and, isNull } from "drizzle-orm";
+import { eq } from "drizzle-orm";
 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 { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import {
+  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";
 import { logger } from "#chat-runtime/server/utils/logger";
-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";
+import { telaAgentExecutionInputSchema } from "#chat-runtime/types/tela-agent";
 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 body = await readBody(event);
@@ -34,39 +31,37 @@ export default defineEventHandler(async (event) => {
       statusMessage: "Message content is required"
     });
   }
-  if (body.model !== void 0 && !isValidModel(body.model)) {
+  const [conversation] = await db.select().from(schema.conversations).where(conversationScopeConditions(context, conversationId));
+  if (!conversation) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Conversation not found"
+    });
+  }
+  if (!conversation.telaAgentId && body.model !== void 0 && !isValidModel(body.model)) {
     throw createError({
       statusCode: 400,
       statusMessage: "Invalid model"
     });
   }
-  const [conversation] = await db.select().from(schema.conversations).where(
-    and(
-      eq(schema.conversations.id, conversationId),
-      eq(schema.conversations.workspaceId, context.workspaceId)
-    )
-  );
-  if (!conversation) {
+  const agentInputs = conversation.telaAgentId && body.agentInputs !== void 0 ? telaAgentExecutionInputSchema.array().safeParse(body.agentInputs) : null;
+  if (agentInputs && !agentInputs.success) {
     throw createError({
-      statusCode: 404,
-      statusMessage: "Conversation not found"
+      statusCode: 400,
+      statusMessage: "Invalid Tela agent inputs"
     });
   }
-  const effectiveModel = body.model ?? (isValidModel(conversation.model) ? conversation.model : void 0);
-  const trustedSettings = conversation.appliedSettingsSnapshot ? null : await resolveWorkspaceSettings(event, context, db);
-  const appliedSettings = getConversationAppliedSettings(conversation, trustedSettings);
+  const telaAgentPayload = conversation.telaAgentId ? await buildTelaAgentTurnPayload(event, conversation, body.content, body.files, agentInputs?.data) : null;
+  const defaultAgentTurn = conversation.telaAgentId ? null : await prepareDefaultAgentTurn(event, db, context, {
+    conversation,
+    conversationId,
+    content: body.content,
+    files: body.files,
+    requestedModel: body.model,
+    workspaceSettingsSnapshot: body.workspaceSettingsSnapshot
+  });
   const now = /* @__PURE__ */ new Date();
   const assistantCreatedAt = new Date(now.getTime() + 1);
-  if (!conversation.appliedSettingsSnapshot && trustedSettings) {
-    await db.update(schema.conversations).set({
-      appliedSettingsAt: getWorkspaceSettingsUpdatedAt(trustedSettings),
-      appliedSettingsSnapshot: serializeResolvedWorkspaceSettings(trustedSettings),
-      updatedAt: now
-    }).where(and(
-      eq(schema.conversations.id, conversationId),
-      isNull(schema.conversations.appliedSettingsSnapshot)
-    ));
-  }
   const [userMessages, assistantMessages] = await Promise.all([
     db.insert(schema.messages).values({
       conversationId,
@@ -95,49 +90,42 @@ export default defineEventHandler(async (event) => {
   }
   logger.info({ conversationId, userMessageId: userMessage.id, hasFiles: !!body.files?.length }, "Message sent");
   const assistantMessageId = assistantMessage.id;
-  const needsNewThread = conversation.threadSessionId === null;
-  const fileUrls = mergeFileUrls(appliedSettings.contextFiles, body.files);
-  const messageTitle = truncateTitle(body.content);
-  const knowledgeSources = appliedSettings.knowledgeSources ?? null;
-  const { vaultUrl } = useRuntimeConfig();
-  const messageWithContext = buildMessageWithContext(
-    body.content.trim(),
-    appliedSettings.systemMessage ?? null,
-    knowledgeSources,
-    needsNewThread,
-    needsNewThread ? renderSystemPrompt(vaultUrl) : ""
-  );
-  const canvasTools = appliedSettings.canvasTools;
-  const hasKnowledgeSources = knowledgeSources && knowledgeSources.length > 0;
-  const externalSkillRefs = appliedSettings.externalSkills?.map((skill) => skill.ref) ?? [];
-  const settingsTimestamp = getWorkspaceSettingsUpdatedAt(appliedSettings);
-  const skills = externalSkillRefs.length > 0 ? externalSkillRefs : void 0;
-  if (needsNewThread) {
-    let environmentVariables = {};
-    if (useChatNuxtFeatures().credentials) {
-      try {
-        environmentVariables = await resolveWorkspaceCredentials(event, context.workspaceId);
-      } catch (error) {
-        logger.warn({ conversationId, error }, "Failed to resolve workspace credentials, proceeding without env vars");
-      }
-    }
-    const hasEnvironmentVariables = Object.keys(environmentVariables).length > 0;
-    createChatAgentSession(token, {
-      message: messageWithContext,
-      fileUrls,
-      model: effectiveModel,
-      customTools: canvasTools?.length ? { canvas: canvasTools } : void 0,
-      tools: hasKnowledgeSources ? { workstationQueryTool: true } : void 0,
-      environmentVariables: hasEnvironmentVariables ? environmentVariables : void 0,
-      skills
-    }).then(async (result) => {
+  if (conversation.telaAgentId) {
+    queueTelaAgentTurn(event, db, {
+      conversation,
+      conversationId,
+      assistantMessageId,
+      payload: telaAgentPayload,
+      titleContent: body.content,
+      operation: "send"
+    });
+    return {
+      userMessage,
+      assistantMessage
+    };
+  }
+  if (!defaultAgentTurn) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to prepare agent turn"
+    });
+  }
+  const token = getAgentDataToken(event);
+  if (defaultAgentTurn.needsNewThread) {
+    const environmentVariables = await resolveDefaultAgentEnvironmentVariables(
+      event,
+      context,
+      { conversationId },
+      "Failed to resolve workspace credentials, proceeding without env vars"
+    );
+    createChatAgentSession(token, withEnvironmentVariables(defaultAgentTurn.createPayload, environmentVariables)).then(async (result) => {
       if (result.success) {
         logger.info({ conversationId, sessionId: result.sessionId }, "New agent thread created");
         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 {
@@ -155,20 +143,17 @@ export default defineEventHandler(async (event) => {
       }).where(eq(schema.messages.id, assistantMessageId));
     });
   } else {
-    continueSession(token, conversation.threadSessionId, {
-      content: body.content.trim(),
-      fileUrls,
-      model: effectiveModel
-    }).then(async (result) => {
+    continueSession(token, conversation.threadSessionId, defaultAgentTurn.continuePayload).then(async (result) => {
       if (!result.success) {
         logger.warn({ conversationId, sessionId: conversation.threadSessionId, error: result.error }, "Agent session continue failed");
         await db.update(schema.messages).set({
           content: `Erro: ${result.error}`,
           status: "failed"
         }).where(eq(schema.messages.id, assistantMessageId));
+        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(async (e) => {

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

@@ -1,10 +1,11 @@
 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 { getWorkspaceBilling, transformCostForBilling } from "#chat-runtime/server/utils/billing";
 export default defineEventHandler(async (event) => {
-  const context = resolveChatContext(event);
+  const context = resolveChatRuntimeContext(event);
   const db = useDb();
   const id = getRouterParam(event, "id");
   if (!id) {
@@ -13,12 +14,7 @@ export default defineEventHandler(async (event) => {
       statusMessage: "Conversation ID is required"
     });
   }
-  const [conversation] = await db.select({ id: schema.conversations.id }).from(schema.conversations).where(
-    and(
-      eq(schema.conversations.id, id),
-      eq(schema.conversations.workspaceId, context.workspaceId)
-    )
-  );
+  const [conversation] = await db.select({ id: schema.conversations.id }).from(schema.conversations).where(conversationScopeConditions(context, id));
   if (!conversation) {
     throw createError({
       statusCode: 404,

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

@@ -3,7 +3,7 @@ import { useRuntimeConfig } from "nitropack/runtime";
 import { createTelaClient } from "@meistrari/tela-sdk-js";
 import { logger } from "#chat-runtime/server/utils/logger";
 import { requireUser } from "#chat-runtime/server/utils/auth";
-import { useChatNuxtFeatures } from "#chat-runtime/utils/features";
+import { resolveChatNuxtFeatures } from "#chat-runtime/utils/features";
 const TITLE_CANVAS_ID = "ba06c4a0-ef05-4fb6-b4ef-5af3d63a1ba2";
 const FALLBACK_TITLE_MAX_LENGTH = 60;
 const FALLBACK_TITLE_DEFAULT = "New chat";
@@ -26,8 +26,9 @@ export default defineEventHandler(async (event) => {
       statusMessage: "userMessage and assistantResponse are required"
     });
   }
-  const { telaApiKey } = useRuntimeConfig();
-  const features = useChatNuxtFeatures();
+  const runtimeConfig = useRuntimeConfig();
+  const { telaApiKey } = runtimeConfig;
+  const features = resolveChatNuxtFeatures(runtimeConfig);
   if (!features.generateTitle || !telaApiKey) {
     const fallback = buildFallbackTitle(userMessage);
     logger.debug({ titleLength: fallback.length, reason: !features.generateTitle ? "feature-disabled" : "no-tela-api-key" }, "Title generated via fallback");

package/dist/runtime/server/api/conversations/index.get.js

@@ -1,12 +1,13 @@
 import { defineEventHandler } from "h3";
-import { desc, eq } from "drizzle-orm";
+import { desc } 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";
 export default defineEventHandler(async (event) => {
-  const context = resolveChatContext(event);
+  const context = resolveChatRuntimeContext(event);
   const db = useDb();
-  const conversations = await db.select().from(schema.conversations).where(eq(schema.conversations.workspaceId, context.workspaceId)).orderBy(desc(schema.conversations.updatedAt));
+  const conversations = await db.select().from(schema.conversations).where(conversationScopeConditions(context)).orderBy(desc(schema.conversations.updatedAt));
   logger.debug({ workspaceId: context.workspaceId, count: conversations.length }, "Conversations listed");
   return conversations;
 });

package/dist/runtime/server/api/conversations/index.post.js

@@ -1,10 +1,10 @@
 import { createError, defineEventHandler, getRequestHeader, readBody } from "h3";
 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 { 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();
   let body = {};
   const contentLength = getRequestHeader(event, "content-length");
@@ -19,7 +19,7 @@ export default defineEventHandler(async (event) => {
       });
     }
   }
-  if (body.model !== void 0 && body.model !== null && !isValidModel(body.model)) {
+  if (!context.telaAgentId && body.model !== void 0 && body.model !== null && !isValidModel(body.model)) {
     throw createError({
       statusCode: 400,
       statusMessage: "Invalid model"
@@ -29,7 +29,8 @@ export default defineEventHandler(async (event) => {
     workspaceId: context.workspaceId,
     userId: context.user.id,
     createdBy: context.user.email,
-    ...body.model ? { model: body.model } : {}
+    telaAgentId: context.telaAgentId,
+    ...context.telaAgentId ? { model: null } : body.model ? { model: body.model } : {}
   }).returning();
   if (!conversation) {
     throw createError({

package/dist/runtime/server/api/tela/agents/[id].get.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    id: any;
+    inputSchema: any;
+    isMultiturn: any;
+}>>;
+export default _default;

package/dist/runtime/server/api/tela/agents/[id].get.js

@@ -0,0 +1,25 @@
+import { createError, defineEventHandler, getRouterParam } from "h3";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { getTelaAgent } from "#chat-runtime/server/utils/tela-agent-api";
+export default defineEventHandler(async (event) => {
+  requireUser(event);
+  const agentId = getRouterParam(event, "id")?.trim();
+  if (!agentId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Agent ID is required"
+    });
+  }
+  const result = await getTelaAgent(event, agentId);
+  if (!result.success) {
+    throw createError({
+      statusCode: 502,
+      statusMessage: result.error
+    });
+  }
+  return {
+    id: result.data.id,
+    inputSchema: result.data.inputSchema,
+    isMultiturn: result.data.isMultiturn ?? null
+  };
+});

package/dist/runtime/server/api/workspace/settings.patch.js

@@ -55,7 +55,7 @@ export default defineEventHandler(async (event) => {
       name: skill.name,
       description: skill.description,
       runtime: skill.runtime,
-      allowedTools: skill.allowedTools,
+      allowedTools: [...skill.allowedTools],
       isPublic: skill.isPublic,
       addedByUserId: skill.addedBy?.userId || session.user.id,
       addedByUsername: skill.addedBy?.username || session.user.name || "",