@meistrari/chat-nuxt 1.5.1 → 1.7.0

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

@@ -30,6 +30,7 @@ export default defineEventHandler(async (event) => {
     userId: context.user.id,
     createdBy: context.user.email,
     telaAgentId: context.telaAgentId,
+    conversationScope: context.conversationScope,
     ...context.telaAgentId ? { model: null } : body.model ? { model: body.model } : {}
   }).returning();
   if (!conversation) {

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

@@ -105,6 +105,23 @@ export declare const conversations: import("drizzle-orm/pg-core").PgTableWithCol
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        conversationScope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "conversation_scope";
+            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

@@ -7,6 +7,7 @@ export const conversations = chatSchema.table("conversations", {
   title: text("title").notNull().default("Nova conversa"),
   threadSessionId: text("thread_session_id"),
   telaAgentId: text("tela_agent_id"),
+  conversationScope: text("conversation_scope"),
   model: text("model").default("claude-sonnet-4-5"),
   appliedSettingsAt: timestamp("applied_settings_at", { withTimezone: true }),
   appliedSettingsSnapshot: jsonb("applied_settings_snapshot").$type(),

package/dist/runtime/server/utils/agent-api.js

@@ -2,11 +2,12 @@ import { createError } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
 import { agentApiQueryResponseSchema, agentApiSessionSchema } from "#chat-runtime/types/agent";
 import { logger } from "#chat-runtime/server/utils/logger";
+import { resolveAuthToken } from "#chat-runtime/server/utils/auth-token";
 const getConfig = () => useRuntimeConfig();
 export function getAgentDataToken(event) {
-  const cookieToken = event.context.auth?.token;
-  if (cookieToken) {
-    return cookieToken;
+  const token = resolveAuthToken(event);
+  if (token) {
+    return token;
   }
   throw createError({
     statusCode: 401,

package/dist/runtime/server/utils/agent-environment.d.ts

@@ -0,0 +1,8 @@
+import type { H3Event } from 'h3';
+import type { ChatRuntimeContext } from '#chat-runtime/server/utils/chat-context';
+export type AgentEnvironmentResolverContext = ChatRuntimeContext & {
+    conversationId: string;
+    skills: readonly string[];
+};
+export type AgentEnvironmentVariables = Record<string, string>;
+export declare function resolveHostAgentEnvironmentVariables(event: H3Event, context: AgentEnvironmentResolverContext, logContext: Record<string, unknown>): Promise<AgentEnvironmentVariables>;

package/dist/runtime/server/utils/agent-environment.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import registeredAgentEnvironmentResolver from "#chat-agent-environment-resolver";
+import { logger } from "#chat-runtime/server/utils/logger";
+const agentEnvironmentVariablesSchema = z.record(z.string(), z.string()).nullable().optional();
+function getRegisteredAgentEnvironmentResolver() {
+  const resolver = registeredAgentEnvironmentResolver;
+  return typeof resolver === "function" ? resolver : null;
+}
+function parseAgentEnvironmentVariables(value, logContext) {
+  const parsed = agentEnvironmentVariablesSchema.safeParse(value);
+  if (!parsed.success) {
+    logger.warn({
+      ...logContext,
+      issues: parsed.error.issues
+    }, "Agent environment resolver returned an invalid payload");
+    return {};
+  }
+  return parsed.data ?? {};
+}
+export async function resolveHostAgentEnvironmentVariables(event, context, logContext) {
+  const resolver = getRegisteredAgentEnvironmentResolver();
+  if (!resolver) {
+    return {};
+  }
+  try {
+    return parseAgentEnvironmentVariables(await resolver(event, context), logContext);
+  } catch (error) {
+    logger.warn({
+      ...logContext,
+      error
+    }, "Agent environment resolver failed, proceeding without host env vars");
+    return {};
+  }
+}

package/dist/runtime/server/utils/auth-token.d.ts

@@ -0,0 +1,2 @@
+import { type H3Event } from 'h3';
+export declare function resolveAuthToken(event: H3Event): string | undefined;

package/dist/runtime/server/utils/auth-token.js

@@ -0,0 +1,21 @@
+import { getCookie } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+const DEFAULT_FIRST_PARTY_JWT_COOKIE_NAME = "tela-jwt";
+function resolveFirstPartyJwtCookieName(event) {
+  const config = useRuntimeConfig(event);
+  return config.public?.telaAuth?.jwtCookieName || DEFAULT_FIRST_PARTY_JWT_COOKIE_NAME;
+}
+export function resolveAuthToken(event) {
+  const auth = event.context.auth;
+  if (auth?.token) {
+    return auth.token;
+  }
+  if (!auth?.user || !auth.workspace) {
+    return void 0;
+  }
+  const token = getCookie(event, resolveFirstPartyJwtCookieName(event));
+  if (token) {
+    auth.token = token;
+  }
+  return token;
+}

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

@@ -6,9 +6,11 @@ export type ChatContext = {
 };
 export type ChatRuntimeContext = ChatContext & {
     telaAgentId: string | null;
+    conversationScope: 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 resolveRequestedConversationScope(requestedConversationScope: 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,6 +1,7 @@
 import { createError, getHeader } from "h3";
 import { requireUser } from "#chat-runtime/server/utils/auth";
 const TELA_AGENT_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+const CONVERSATION_SCOPE_PATTERN = /^[A-Za-z0-9._:/-]{1,200}$/;
 export function resolveRequestedWorkspaceId(requestedWorkspaceId) {
   const normalized = requestedWorkspaceId?.trim();
   return normalized || null;
@@ -17,6 +18,18 @@ export function resolveRequestedTelaAgentId(requestedTelaAgentId) {
   }
   return normalized;
 }
+export function resolveRequestedConversationScope(requestedConversationScope) {
+  const normalized = requestedConversationScope?.trim();
+  if (!normalized)
+    return null;
+  if (!CONVERSATION_SCOPE_PATTERN.test(normalized)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid conversation scope"
+    });
+  }
+  return normalized;
+}
 export function resolveChatContextFromSession(session, requestedWorkspaceId) {
   const normalizedRequestedWorkspaceId = resolveRequestedWorkspaceId(requestedWorkspaceId);
   if (normalizedRequestedWorkspaceId && normalizedRequestedWorkspaceId !== session.workspace.id) {
@@ -39,6 +52,7 @@ export function resolveChatRuntimeContext(event) {
   const context = resolveChatContext(event);
   return {
     ...context,
-    telaAgentId: resolveRequestedTelaAgentId(getHeader(event, "x-chat-tela-agent-id"))
+    telaAgentId: resolveRequestedTelaAgentId(getHeader(event, "x-chat-tela-agent-id")),
+    conversationScope: resolveRequestedConversationScope(getHeader(event, "x-chat-conversation-scope"))
   };
 }

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

@@ -34,6 +34,11 @@ export declare function prepareDefaultAgentTurn(event: H3Event, db: DbInstance,
     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 resolveDefaultAgentEnvironmentVariables(event: H3Event, context: ChatRuntimeContext, options: {
+    conversationId: string;
+    skills?: readonly string[];
+    logContext: Record<string, unknown>;
+    credentialsFailureMessage: string;
+}): Promise<Record<string, string>>;
 export declare function withEnvironmentVariables(payload: AgentApiChatPayload, environmentVariables: Record<string, string>): AgentApiChatPayload;
 export {};

package/dist/runtime/server/utils/conversation-agent-turn.js

@@ -2,6 +2,7 @@ import { and, eq, isNull } from "drizzle-orm";
 import { useRuntimeConfig } from "nitropack/runtime";
 import { schema } from "#chat-runtime/server/db";
 import { buildMessageWithContext, renderSystemPrompt, truncateTitle } from "#chat-runtime/server/utils/chat-message-builder";
+import { resolveHostAgentEnvironmentVariables } from "#chat-runtime/server/utils/agent-environment";
 import {
   getConversationAppliedSettings,
   getWorkspaceSettingsUpdatedAt,
@@ -150,15 +151,33 @@ export async function prepareDefaultAgentTurn(event, db, context, options) {
     }
   };
 }
-export async function resolveDefaultAgentEnvironmentVariables(event, context, logContext, failureMessage) {
-  if (!resolveChatNuxtFeatures(useRuntimeConfig()).credentials)
-    return {};
-  try {
-    return await resolveWorkspaceCredentials(event, context.workspaceId);
-  } catch (error) {
-    logger.warn({ ...logContext, error }, failureMessage);
-    return {};
+export async function resolveDefaultAgentEnvironmentVariables(event, context, options) {
+  let credentialVariables = {};
+  const logContext = {
+    workspaceId: context.workspaceId,
+    conversationId: options.conversationId,
+    ...options.logContext
+  };
+  if (resolveChatNuxtFeatures(useRuntimeConfig()).credentials) {
+    try {
+      credentialVariables = await resolveWorkspaceCredentials(event, context.workspaceId);
+    } catch (error) {
+      logger.warn({ ...logContext, error }, options.credentialsFailureMessage);
+    }
   }
+  const hostVariables = await resolveHostAgentEnvironmentVariables(
+    event,
+    {
+      ...context,
+      conversationId: options.conversationId,
+      skills: options.skills ?? []
+    },
+    logContext
+  );
+  return {
+    ...credentialVariables,
+    ...hostVariables
+  };
 }
 export function withEnvironmentVariables(payload, environmentVariables) {
   if (Object.keys(environmentVariables).length === 0)

package/dist/runtime/server/utils/conversation-scope.js

@@ -3,7 +3,8 @@ import { schema } from "#chat-runtime/server/db";
 export function conversationScopeConditions(context, conversationId) {
   const conditions = [
     eq(schema.conversations.workspaceId, context.workspaceId),
-    context.telaAgentId ? eq(schema.conversations.telaAgentId, context.telaAgentId) : isNull(schema.conversations.telaAgentId)
+    context.telaAgentId ? eq(schema.conversations.telaAgentId, context.telaAgentId) : isNull(schema.conversations.telaAgentId),
+    context.conversationScope ? eq(schema.conversations.conversationScope, context.conversationScope) : isNull(schema.conversations.conversationScope)
   ];
   if (conversationId) {
     conditions.unshift(eq(schema.conversations.id, conversationId));

package/dist/runtime/server/utils/tela-api.js

@@ -1,9 +1,10 @@
 import { createError } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
 import { logger } from "#chat-runtime/server/utils/logger";
+import { resolveAuthToken } from "#chat-runtime/server/utils/auth-token";
 export async function telaFetch(event, path, options) {
   const config = useRuntimeConfig();
-  const token = event.context.auth?.token;
+  const token = resolveAuthToken(event);
   if (!token) {
     throw createError({ statusCode: 401, statusMessage: "No auth token" });
   }

package/dist/runtime/server/utils/workspace.js

@@ -1,6 +1,7 @@
 import { useRuntimeConfig } from "nitropack/runtime";
 import { eq } from "drizzle-orm";
 import { schema } from "#chat-runtime/server/db";
+import { resolveAuthToken } from "#chat-runtime/server/utils/auth-token";
 import { telaFetch } from "#chat-runtime/server/utils/tela-api";
 export async function getWorkspaceSettings(db, workspaceId) {
   const [settings] = await db.select().from(schema.workspaceSettings).where(eq(schema.workspaceSettings.workspaceId, workspaceId));
@@ -8,6 +9,7 @@ export async function getWorkspaceSettings(db, workspaceId) {
 }
 export async function resolveWorkspaceCredentials(event, workspaceId) {
   const config = useRuntimeConfig();
+  const token = resolveAuthToken(event);
   return await telaFetch(
     event,
     `/workspaces/${workspaceId}/credentials/resolve`,
@@ -15,7 +17,7 @@ export async function resolveWorkspaceCredentials(event, workspaceId) {
       headers: {
         "X-Service-Name": "chat-app",
         "X-Service-Key": config.chatAppServiceKey,
-        "x-data-token": event.context.auth?.token ?? ""
+        "x-data-token": token ?? ""
       }
     }
   ) ?? {};

package/dist/runtime/types/chat-agent-environment-resolver.d.ts

@@ -0,0 +1,4 @@
+declare module '#chat-agent-environment-resolver' {
+    const resolver: unknown
+    export default resolver
+}

package/dist/runtime/types/chat-auth.d.ts

@@ -0,0 +1,35 @@
+import type { Ref } from 'vue'
+
+type ChatAuthUser = {
+    id: string
+    email?: string | null
+    name?: string | null
+    image?: string | null
+}
+
+type ChatAuthMemberUser = {
+    name: string
+    email: string
+    image?: string
+}
+
+type ChatAuthMember = {
+    id: string
+    userId: string
+    user: ChatAuthMemberUser
+}
+
+type ChatAuthOrganization = {
+    id: string
+    name?: string
+    logo?: string | null
+    members?: ChatAuthMember[]
+}
+
+export function useChatAuth(): {
+    user: Ref<ChatAuthUser | null>
+    activeOrganization: Ref<ChatAuthOrganization | null>
+    getToken: () => Promise<string | null | undefined>
+    getAvailableOrganizations: () => Promise<ChatAuthOrganization[]>
+    switchOrganization: (organizationId: string) => Promise<void>
+}

package/dist/runtime/types/embed.d.ts

@@ -4,26 +4,45 @@ import type { TelaAgentExecutionInput } from './tela-agent.js';
 import type { ChatLoadingMessageMode } from '../utils/chat-loading-messages.js';
 import type { ChatActor, ChatFeatureConfig } from '../utils/tela-chat.js';
 export type ChatEmbedSharedProps = {
+    /** Controlled conversation id. Use with `v-model:conversation-id` when the host owns active conversation state. */
     conversationId?: string | null;
+    /** Conversation id to open once on mount when `conversationId` is uncontrolled. */
     initialConversationId?: string | null;
+    /** Technical scope that isolates conversation history within the current workspace and runtime. */
+    conversationScope?: string | null;
+    /** Hide the conversation list and render only the active chat surface. */
     hideSidebar?: boolean;
+    /** Custom pending-response messages shown while the assistant is working. */
     loadingMessages?: readonly string[] | null;
+    /** How custom loading messages rotate. Defaults to ordered behavior when omitted. */
     loadingMessagesMode?: ChatLoadingMessageMode | null;
+    /** Custom markdown component renderers keyed by markdown node or tag name. */
     customComponents?: Record<string, Component>;
+    /** Extra HTML tags allowed by the markdown renderer. */
     customHtmlTags?: readonly string[];
 };
 export type DefaultChatEmbedProps = ChatEmbedSharedProps & {
+    /** Omitted in default chat mode. Set this to switch to Tela agent mode. */
     telaAgentId?: undefined;
+    /** Tela agent inputs are only accepted in Tela agent mode. */
     telaAgentInputs?: undefined;
+    /** Optional host-provided workspace settings. When omitted, chat-nuxt loads workspace settings itself. */
     workspaceSettings?: DeepReadonly<WorkspaceSettings> | WorkspaceSettings | null;
+    /** Optional display identity for messages created by the current user. */
     user?: ChatActor | null;
+    /** Optional UI feature toggles for the default chat runtime. */
     features?: Partial<ChatFeatureConfig>;
 };
 export type TelaAgentChatEmbedProps = ChatEmbedSharedProps & {
+    /** Tela agent id that switches the embed into Tela agent runtime mode. */
     telaAgentId: string;
+    /** Inputs sent with each Tela agent run. Non-null values hide the variables panel. */
     telaAgentInputs?: DeepReadonly<TelaAgentExecutionInput[]> | null;
+    /** Not accepted in Tela agent mode because the Tela agent owns runtime settings. */
     workspaceSettings?: never;
+    /** Not accepted in Tela agent mode because execution identity comes from the Tela agent runtime. */
     user?: never;
+    /** Optional UI feature toggles that are still supported in Tela agent mode. */
     features?: Partial<ChatFeatureConfig>;
 };
 export type MeistrariChatEmbedProps = DefaultChatEmbedProps | TelaAgentChatEmbedProps;

package/dist/runtime/utils/tela-chat.d.ts

@@ -17,7 +17,9 @@ export type ChatActor = {
 };
 export declare function normalizeConversationId(value: string | null | undefined): string | null;
 export declare function normalizeTelaAgentId(value: string | null | undefined): string | null;
-export declare function resolveChatStateScope(workspaceId: string | null | undefined, telaAgentId: string | null | undefined): string;
+export declare function normalizeConversationScope(value: string | null | undefined): string | null;
+export declare function resolveConversationScopeKeySegment(value: string | null | undefined): string;
+export declare function resolveChatStateScope(workspaceId: string | null | undefined, telaAgentId: string | null | undefined, conversationScope?: string | null): string;
 export declare function resolveChatFeatures(features?: Partial<ChatFeatureConfig>): ResolvedChatFeatureConfig;
 export declare function resolveConversationCreator(conversationUserId: string | null | undefined, options: {
     currentUser?: ChatActor | null;

package/dist/runtime/utils/tela-chat.js

@@ -9,10 +9,19 @@ export function normalizeTelaAgentId(value) {
   const normalized = value?.trim();
   return normalized || null;
 }
-export function resolveChatStateScope(workspaceId, telaAgentId) {
+export function normalizeConversationScope(value) {
+  const normalized = value?.trim();
+  return normalized || null;
+}
+export function resolveConversationScopeKeySegment(value) {
+  const normalizedConversationScope = normalizeConversationScope(value);
+  return normalizedConversationScope ? `value:${normalizedConversationScope}` : "none";
+}
+export function resolveChatStateScope(workspaceId, telaAgentId, conversationScope) {
   const normalizedWorkspaceId = workspaceId?.trim() || "default";
   const normalizedTelaAgentId = normalizeTelaAgentId(telaAgentId);
-  return normalizedTelaAgentId ? `${normalizedWorkspaceId}:tela-agent:${normalizedTelaAgentId}` : `${normalizedWorkspaceId}:default-chat`;
+  const runtimeScope = normalizedTelaAgentId ? `${normalizedWorkspaceId}:tela-agent:${normalizedTelaAgentId}` : `${normalizedWorkspaceId}:default-chat`;
+  return `${runtimeScope}:scope:${resolveConversationScopeKeySegment(conversationScope)}`;
 }
 export function resolveChatFeatures(features) {
   return {

package/drizzle/0015_illegal_blindfold.sql

@@ -0,0 +1 @@
+ALTER TABLE "chat"."conversations" ADD COLUMN "conversation_scope" text;