@meistrari/chat-nuxt 1.4.0 → 1.5.0

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

@@ -1,25 +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,
-  parseWorkspaceSettingsSnapshot,
-  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);
@@ -35,41 +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 explicitSettings = !conversation.appliedSettingsSnapshot && body.workspaceSettingsSnapshot !== void 0 ? parseWorkspaceSettingsSnapshot(body.workspaceSettingsSnapshot) : void 0;
-  const trustedSettings = conversation.appliedSettingsSnapshot || explicitSettings ? null : await resolveWorkspaceSettings(event, context, db);
-  const appliedSettings = getConversationAppliedSettings(conversation, trustedSettings, explicitSettings);
+  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);
-  const snapshotSettings = explicitSettings ?? trustedSettings;
-  if (!conversation.appliedSettingsSnapshot && snapshotSettings) {
-    await db.update(schema.conversations).set({
-      appliedSettingsAt: getWorkspaceSettingsUpdatedAt(snapshotSettings),
-      appliedSettingsSnapshot: serializeResolvedWorkspaceSettings(snapshotSettings),
-      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,
@@ -98,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 {
@@ -158,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 || "",

package/dist/runtime/server/db/schema/conversations.d.ts

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

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

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

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

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

package/dist/runtime/server/utils/chat-context.d.ts

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

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

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

package/dist/runtime/server/utils/conversation-agent-turn.d.ts

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