@meistrari/chat-nuxt 1.3.0 → 1.5.0

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

@@ -0,0 +1,29 @@
+import type { Component, DeepReadonly } from 'vue';
+import type { WorkspaceSettings } from './workspace-settings-data.js';
+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 = {
+    conversationId?: string | null;
+    initialConversationId?: string | null;
+    hideSidebar?: boolean;
+    loadingMessages?: readonly string[] | null;
+    loadingMessagesMode?: ChatLoadingMessageMode | null;
+    customComponents?: Record<string, Component>;
+    customHtmlTags?: readonly string[];
+};
+export type DefaultChatEmbedProps = ChatEmbedSharedProps & {
+    telaAgentId?: undefined;
+    telaAgentInputs?: undefined;
+    workspaceSettings?: DeepReadonly<WorkspaceSettings> | WorkspaceSettings | null;
+    user?: ChatActor | null;
+    features?: Partial<ChatFeatureConfig>;
+};
+export type TelaAgentChatEmbedProps = ChatEmbedSharedProps & {
+    telaAgentId: string;
+    telaAgentInputs?: DeepReadonly<TelaAgentExecutionInput[]> | null;
+    workspaceSettings?: never;
+    user?: never;
+    features?: Partial<ChatFeatureConfig>;
+};
+export type MeistrariChatEmbedProps = DefaultChatEmbedProps | TelaAgentChatEmbedProps;

package/dist/runtime/types/tela-agent.d.ts

@@ -0,0 +1,243 @@
+import { z } from 'zod';
+export declare const telaAgentAttachmentSchema: z.ZodObject<{
+    vaultRef: z.ZodString;
+    filename: z.ZodString;
+}, z.core.$strip>;
+export declare const telaAgentInputVariableSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        text: "text";
+        file: "file";
+    }>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgentInputVariable = z.infer<typeof telaAgentInputVariableSchema>;
+export declare const telaAgentFileInputSchema: z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    name: z.ZodString;
+    vaultRef: z.ZodString;
+    filename: z.ZodString;
+    metadata: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const telaAgentTextInputSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    name: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const telaAgentExecutionInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    name: z.ZodString;
+    vaultRef: z.ZodString;
+    filename: z.ZodString;
+    metadata: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    name: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>], "type">;
+export type TelaAgentExecutionInput = z.infer<typeof telaAgentExecutionInputSchema>;
+export declare const telaAgentRunPayloadSchema: z.ZodObject<{
+    message: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        name: z.ZodString;
+        vaultRef: z.ZodString;
+        filename: z.ZodString;
+        metadata: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        name: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>], "type">>>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        vaultRef: z.ZodString;
+        filename: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgentRunPayload = z.infer<typeof telaAgentRunPayloadSchema>;
+export declare const telaAgentSchema: z.ZodObject<{
+    id: z.ZodString;
+    inputSchema: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            text: "text";
+            file: "file";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$catchall<z.ZodUnknown>>>>>, z.ZodTransform<{
+        [x: string]: unknown;
+        name: string;
+        type: "text" | "file";
+        id?: string | undefined;
+        required?: boolean | undefined;
+        description?: string | null | undefined;
+    }[], {
+        [x: string]: unknown;
+        name: string;
+        type: "text" | "file";
+        id?: string | undefined;
+        required?: boolean | undefined;
+        description?: string | null | undefined;
+    }[] | null | undefined>>;
+    isMultiturn: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgent = z.infer<typeof telaAgentSchema>;
+export declare const telaAgentRunResponseSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgentRunResponse = z.infer<typeof telaAgentRunResponseSchema>;
+export declare const telaAgentSessionStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    running: "running";
+    completed: "completed";
+    failed: "failed";
+    waiting_messages: "waiting_messages";
+    cancelled: "cancelled";
+}>;
+export type TelaAgentSessionStatus = z.infer<typeof telaAgentSessionStatusSchema>;
+export declare const telaAgentStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    eventId: z.ZodOptional<z.ZodString>;
+    inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    cacheReadInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    cacheCreationInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    calculatedCostUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgentStep = z.infer<typeof telaAgentStepSchema>;
+export declare const telaAgentUsageSchema: z.ZodObject<{
+    duration: z.ZodOptional<z.ZodNumber>;
+    turns: z.ZodOptional<z.ZodNumber>;
+    completionTokens: z.ZodOptional<z.ZodNumber>;
+    promptTokens: z.ZodOptional<z.ZodNumber>;
+    totalTokens: z.ZodOptional<z.ZodNumber>;
+    completionCost: z.ZodOptional<z.ZodNumber>;
+    promptCost: z.ZodOptional<z.ZodNumber>;
+    totalCost: z.ZodOptional<z.ZodNumber>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const telaAgentSessionSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        waiting_messages: "waiting_messages";
+        cancelled: "cancelled";
+    }>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString>;
+        inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        cacheReadInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        cacheCreationInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        calculatedCostUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+    nextCursor: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    result: z.ZodOptional<z.ZodObject<{
+        usage: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodOptional<z.ZodNumber>;
+            turns: z.ZodOptional<z.ZodNumber>;
+            completionTokens: z.ZodOptional<z.ZodNumber>;
+            promptTokens: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+            completionCost: z.ZodOptional<z.ZodNumber>;
+            promptCost: z.ZodOptional<z.ZodNumber>;
+            totalCost: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+        content: z.ZodOptional<z.ZodString>;
+        structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        childEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+    error: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    updatedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgentSession = z.infer<typeof telaAgentSessionSchema>;
+export declare const telaAgentRunApiResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        sessionId: z.ZodString;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const telaAgentApiResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        inputSchema: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                text: "text";
+                file: "file";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$catchall<z.ZodUnknown>>>>>, z.ZodTransform<{
+            [x: string]: unknown;
+            name: string;
+            type: "text" | "file";
+            id?: string | undefined;
+            required?: boolean | undefined;
+            description?: string | null | undefined;
+        }[], {
+            [x: string]: unknown;
+            name: string;
+            type: "text" | "file";
+            id?: string | undefined;
+            required?: boolean | undefined;
+            description?: string | null | undefined;
+        }[] | null | undefined>>;
+        isMultiturn: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const telaAgentSessionApiResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        sessionId: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            waiting_messages: "waiting_messages";
+            cancelled: "cancelled";
+        }>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            eventId: z.ZodOptional<z.ZodString>;
+            inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            cacheReadInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            cacheCreationInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            calculatedCostUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+        nextCursor: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        result: z.ZodOptional<z.ZodObject<{
+            usage: z.ZodOptional<z.ZodObject<{
+                duration: z.ZodOptional<z.ZodNumber>;
+                turns: z.ZodOptional<z.ZodNumber>;
+                completionTokens: z.ZodOptional<z.ZodNumber>;
+                promptTokens: z.ZodOptional<z.ZodNumber>;
+                totalTokens: z.ZodOptional<z.ZodNumber>;
+                completionCost: z.ZodOptional<z.ZodNumber>;
+                promptCost: z.ZodOptional<z.ZodNumber>;
+                totalCost: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+            content: z.ZodOptional<z.ZodString>;
+            structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            childEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+        error: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodOptional<z.ZodNumber>;
+        updatedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const telaAgentEndSessionApiResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        success: z.ZodBoolean;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$catchall<z.ZodUnknown>>;

package/dist/runtime/types/tela-agent.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+export const telaAgentAttachmentSchema = z.object({
+  vaultRef: z.string().startsWith("vault://"),
+  filename: z.string().min(1).max(255)
+});
+export const telaAgentInputVariableSchema = z.object({
+  id: z.string().optional(),
+  name: z.string().min(1),
+  type: z.enum(["file", "text"]),
+  required: z.boolean().optional(),
+  description: z.string().nullable().optional()
+}).catchall(z.unknown());
+export const telaAgentFileInputSchema = z.object({
+  type: z.literal("file"),
+  name: z.string().min(1),
+  vaultRef: z.string().startsWith("vault://"),
+  filename: z.string().min(1).max(255),
+  metadata: z.string().optional()
+});
+export const telaAgentTextInputSchema = z.object({
+  type: z.literal("text"),
+  name: z.string().min(1),
+  content: z.string()
+});
+export const telaAgentExecutionInputSchema = z.discriminatedUnion("type", [
+  telaAgentFileInputSchema,
+  telaAgentTextInputSchema
+]);
+export const telaAgentRunPayloadSchema = z.object({
+  message: z.string().min(1),
+  sessionId: z.string().optional(),
+  inputSchema: z.array(telaAgentExecutionInputSchema).optional(),
+  attachments: z.array(telaAgentAttachmentSchema).optional()
+}).catchall(z.unknown());
+export const telaAgentSchema = z.object({
+  id: z.string(),
+  inputSchema: z.array(telaAgentInputVariableSchema).nullable().optional().transform((value) => value ?? []),
+  isMultiturn: z.boolean().nullable().optional()
+}).catchall(z.unknown());
+export const telaAgentRunResponseSchema = z.object({
+  sessionId: z.string()
+}).catchall(z.unknown());
+export const telaAgentSessionStatusSchema = z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "waiting_messages",
+  "cancelled"
+]);
+export const telaAgentStepSchema = z.object({
+  id: z.string(),
+  eventId: z.string().optional(),
+  inputTokens: z.number().nullable().optional(),
+  outputTokens: z.number().nullable().optional(),
+  cacheReadInputTokens: z.number().nullable().optional(),
+  cacheCreationInputTokens: z.number().nullable().optional(),
+  calculatedCostUsd: z.number().nullable().optional()
+}).catchall(z.unknown());
+export const telaAgentUsageSchema = z.object({
+  duration: z.number().optional(),
+  turns: z.number().optional(),
+  completionTokens: z.number().optional(),
+  promptTokens: z.number().optional(),
+  totalTokens: z.number().optional(),
+  completionCost: z.number().optional(),
+  promptCost: z.number().optional(),
+  totalCost: z.number().optional()
+}).catchall(z.unknown());
+export const telaAgentSessionSchema = z.object({
+  sessionId: z.string(),
+  status: telaAgentSessionStatusSchema,
+  steps: z.array(telaAgentStepSchema),
+  nextCursor: z.number().nullable().optional(),
+  result: z.object({
+    usage: telaAgentUsageSchema.optional(),
+    content: z.string().optional(),
+    structuredContent: z.record(z.string(), z.unknown()).optional(),
+    childEventIds: z.array(z.string()).optional()
+  }).catchall(z.unknown()).optional(),
+  error: z.string().optional(),
+  createdAt: z.number().optional(),
+  updatedAt: z.number().optional()
+}).catchall(z.unknown());
+export const telaAgentRunApiResponseSchema = z.object({
+  data: telaAgentRunResponseSchema
+}).catchall(z.unknown());
+export const telaAgentApiResponseSchema = z.object({
+  data: telaAgentSchema
+}).catchall(z.unknown());
+export const telaAgentSessionApiResponseSchema = z.object({
+  data: telaAgentSessionSchema
+}).catchall(z.unknown());
+export const telaAgentEndSessionApiResponseSchema = z.object({
+  data: z.object({
+    success: z.boolean()
+  }).catchall(z.unknown())
+}).catchall(z.unknown());

package/dist/runtime/types/workspace-settings-data.d.ts

@@ -0,0 +1,19 @@
+import type { ContextFile, ExternalSkill } from '../server/db/schema/workspace-settings.js';
+import type { CanvasTool } from './agent.js';
+import type { KnowledgeSource } from './chat.js';
+export type WorkspaceSettings = {
+    workspaceId: string;
+    systemMessage: string | null;
+    contextFiles: ContextFile[] | null;
+    canvasTools: CanvasTool[] | null;
+    knowledgeSources: KnowledgeSource[] | null;
+    externalSkills: ExternalSkill[] | null;
+    updatedAt: Date;
+};
+export type WorkspaceSettingsUpdate = {
+    systemMessage?: string | null;
+    contextFiles?: ContextFile[] | null;
+    canvasTools?: CanvasTool[] | null;
+    knowledgeSources?: KnowledgeSource[] | null;
+    externalSkills?: ExternalSkill[] | null;
+};

package/dist/runtime/types/workspace-settings.d.ts

@@ -1,3 +1,3 @@
 import type { ChatConfigurationSavePayload, ChatConfigurationTab } from '../embed/components/ChatConfigurationModal.vue.js';
-import type { WorkspaceSettings, WorkspaceSettingsUpdate } from '../composables/useWorkspaceSettings.js';
+import type { WorkspaceSettings, WorkspaceSettingsUpdate } from './workspace-settings-data.js';
 export type { ChatConfigurationSavePayload, ChatConfigurationTab, WorkspaceSettings, WorkspaceSettingsUpdate, };

package/dist/runtime/utils/agent-input-readiness.d.ts

@@ -0,0 +1,14 @@
+import type { TelaAgentInputVariable } from '../types/tela-agent.js';
+export type AgentInputPendingFile = {
+    inputName?: string | null;
+};
+export type AgentInputReadiness = {
+    ready: boolean;
+    missingRequiredInputs: boolean;
+    hasUnmappedFiles: boolean;
+};
+export declare function getAgentInputReadiness(options: {
+    inputVariables: readonly TelaAgentInputVariable[];
+    inputTexts: Record<string, string | undefined>;
+    files: readonly AgentInputPendingFile[];
+}): AgentInputReadiness;

package/dist/runtime/utils/agent-input-readiness.js

@@ -0,0 +1,15 @@
+export function getAgentInputReadiness(options) {
+  const inputVariables = options.inputVariables.filter((input) => input.name.trim());
+  const fileInputs = inputVariables.filter((input) => input.type === "file");
+  const textInputs = inputVariables.filter((input) => input.type === "text");
+  const fileInputNames = new Set(fileInputs.map((input) => input.name));
+  const missingRequiredFileInput = fileInputs.filter((input) => input.required).some((input) => !options.files.some((file) => file.inputName === input.name));
+  const missingRequiredTextInput = textInputs.filter((input) => input.required).some((input) => (options.inputTexts[input.name] ?? "").trim().length === 0);
+  const hasUnmappedFiles = fileInputs.length > 0 && options.files.some((file) => !file.inputName || !fileInputNames.has(file.inputName));
+  const missingRequiredInputs = missingRequiredFileInput || missingRequiredTextInput;
+  return {
+    ready: !missingRequiredInputs && !hasUnmappedFiles,
+    missingRequiredInputs,
+    hasUnmappedFiles
+  };
+}

package/dist/runtime/utils/custom-markdown-components.d.ts

@@ -0,0 +1,9 @@
+import { type Component } from 'vue';
+import type { BaseNode } from 'markstream-vue';
+export type CustomMarkdownNode = BaseNode & {
+    attrs?: [string, unknown][];
+    content?: string;
+};
+export declare function customMarkdownNodeProps(node: CustomMarkdownNode): Record<string, unknown>;
+export declare function wrapCustomMarkdownComponent(component: Component, tagName?: string): Component;
+export declare function wrapCustomMarkdownComponents(components: Record<string, Component>): Record<string, Component>;

package/dist/runtime/utils/custom-markdown-components.js

@@ -0,0 +1,54 @@
+import { defineComponent, h } from "vue";
+function camelizeAttributeName(name) {
+  return name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+export function customMarkdownNodeProps(node) {
+  const attrProps = {};
+  for (const attr of node.attrs ?? []) {
+    const [name, value] = attr;
+    if (!name)
+      continue;
+    const propName = camelizeAttributeName(name);
+    if (propName === "node")
+      continue;
+    attrProps[propName] = value;
+  }
+  return { node, ...attrProps };
+}
+function customMarkdownComponentAdapterName(tagName, component) {
+  if (typeof component === "function" && component.name)
+    return component.name;
+  if (typeof component === "object" && component) {
+    const namedComponent = component;
+    return namedComponent.displayName ?? namedComponent.name ?? tagName;
+  }
+  return tagName;
+}
+export function wrapCustomMarkdownComponent(component, tagName = "unknown") {
+  return defineComponent({
+    name: `CustomMarkdownComponentAdapter(${customMarkdownComponentAdapterName(tagName, component)})`,
+    props: {
+      node: {
+        type: Object,
+        required: true
+      }
+    },
+    setup(props, { attrs }) {
+      return () => h(
+        component,
+        {
+          ...attrs,
+          ...customMarkdownNodeProps(props.node)
+        },
+        {
+          default: () => props.node.content ?? ""
+        }
+      );
+    }
+  });
+}
+export function wrapCustomMarkdownComponents(components) {
+  return Object.fromEntries(
+    Object.entries(components).map(([name, component]) => [name, wrapCustomMarkdownComponent(component, name)])
+  );
+}

package/dist/runtime/utils/features.d.ts

@@ -3,4 +3,13 @@ export interface ResolvedChatNuxtFeatures {
     generateTitle: boolean;
     credentials: boolean;
 }
+export interface ChatNuxtFeatureRuntimeConfig {
+    public?: {
+        chatNuxtFeatures?: Partial<ResolvedChatNuxtFeatures>;
+    };
+    chatNuxt?: {
+        features?: Partial<ResolvedChatNuxtFeatures>;
+    };
+}
+export declare function resolveChatNuxtFeatures(config?: ChatNuxtFeatureRuntimeConfig): ResolvedChatNuxtFeatures;
 export declare function useChatNuxtFeatures(): ResolvedChatNuxtFeatures;

package/dist/runtime/utils/features.js

@@ -1,15 +1,16 @@
-import { useRuntimeConfig } from "#imports";
 const DEFAULTS = {
   usage: true,
   generateTitle: false,
   credentials: false
 };
-export function useChatNuxtFeatures() {
-  const config = useRuntimeConfig();
-  const features = config.public.chatNuxtFeatures;
+export function resolveChatNuxtFeatures(config = {}) {
+  const features = config.chatNuxt?.features ?? config.public?.chatNuxtFeatures;
   return {
     usage: features?.usage ?? DEFAULTS.usage,
     generateTitle: features?.generateTitle ?? DEFAULTS.generateTitle,
     credentials: features?.credentials ?? DEFAULTS.credentials
   };
 }
+export function useChatNuxtFeatures() {
+  return resolveChatNuxtFeatures(useRuntimeConfig());
+}

package/dist/runtime/utils/file.js

@@ -3,6 +3,7 @@ const VAULT_REGEX = /(?<!\]\()vault:\/\/[^\s"'<>`\[\]()*_~]+/gi;
 const URL_REGEX = /https?:\/\/[^\s"'<>`\[\]()*_~]+/gi;
 const VAULT_PATTERN = new RegExp(`vault://${URL_CHAR_CLASS}`, "gi");
 const VAULT_PERMALINK_PATTERN = new RegExp(`https://(?:[a-z0-9-]+\\.)*(?:vault|api)\\.tela(?:staging)?\\.com/(?:[a-z0-9_-]+/)*permalinks/${URL_CHAR_CLASS}`, "gi");
+const MARKDOWN_LINK_PATTERN = /\[([^\]\n]*)\]\(([^)\s]+)(?:\s+["'][^)]*["'])?\)/g;
 const FILE_EXTENSIONS = {
   pdf: "application/pdf",
   doc: "application/msword",
@@ -257,12 +258,44 @@ function getPermalinkId(url) {
   const match = url.match(/permalinks\/([a-f0-9-]+)/);
   return match?.[1] ?? "Arquivo";
 }
+function overlapsFileMatch(start, end, fileMatches) {
+  return fileMatches.some((fileMatch) => start < fileMatch.end && end > fileMatch.start);
+}
+function collectMarkdownFileLinkMatches(text) {
+  const matches = [];
+  for (const match of text.matchAll(MARKDOWN_LINK_PATTERN)) {
+    const start = match.index;
+    if (text[start - 1] === "!")
+      continue;
+    const href = match[2];
+    if (!href)
+      continue;
+    const file = detectFileFromUrl(href);
+    if (!file)
+      continue;
+    matches.push({
+      start,
+      end: start + match[0].length,
+      file
+    });
+  }
+  return matches;
+}
 function detectFilesInText(text) {
   const files = [];
   const seen = /* @__PURE__ */ new Set();
-  const vaultMatches = text.match(VAULT_REGEX) ?? [];
-  for (const rawMatch of vaultMatches) {
-    const match = stripTrailingPunctuation(rawMatch);
+  const markdownFileLinkMatches = collectMarkdownFileLinkMatches(text);
+  for (const { file } of markdownFileLinkMatches) {
+    if (seen.has(file.reference))
+      continue;
+    seen.add(file.reference);
+    files.push(file);
+  }
+  for (const rawMatch of text.matchAll(VAULT_REGEX)) {
+    const match = stripTrailingPunctuation(rawMatch[0]);
+    const start = rawMatch.index;
+    if (overlapsFileMatch(start, start + match.length, markdownFileLinkMatches))
+      continue;
     if (seen.has(match))
       continue;
     seen.add(match);
@@ -278,9 +311,11 @@ function detectFilesInText(text) {
       hashParams
     });
   }
-  const urlMatches = text.match(URL_REGEX) ?? [];
-  for (const rawMatch of urlMatches) {
-    const match = stripTrailingPunctuation(rawMatch);
+  for (const rawMatch of text.matchAll(URL_REGEX)) {
+    const match = stripTrailingPunctuation(rawMatch[0]);
+    const start = rawMatch.index;
+    if (overlapsFileMatch(start, start + match.length, markdownFileLinkMatches))
+      continue;
     if (seen.has(match))
       continue;
     if (isVaultS3Url(match)) {
@@ -320,10 +355,12 @@ function detectFilesInText(text) {
 }
 function parseContentWithFiles(text) {
   const segments = [];
-  const fileMatches = [];
+  const fileMatches = collectMarkdownFileLinkMatches(text);
   for (const match of text.matchAll(VAULT_REGEX)) {
     const rawUrl = match[0];
     const url = stripTrailingPunctuation(rawUrl);
+    if (overlapsFileMatch(match.index, match.index + url.length, fileMatches))
+      continue;
     const hashParams = parseVaultHashParams(url);
     const filenameExt = hashParams?.filename?.split(".").pop()?.toLowerCase();
     const urlExt = getExtensionFromUrl(url);
@@ -343,6 +380,8 @@ function parseContentWithFiles(text) {
   for (const match of text.matchAll(URL_REGEX)) {
     const rawUrl = match[0];
     const url = stripTrailingPunctuation(rawUrl);
+    if (overlapsFileMatch(match.index, match.index + url.length, fileMatches))
+      continue;
     if (isVaultS3Url(url)) {
       const { name, mimeType } = getFileInfoFromVaultS3Url(url);
       fileMatches.push({

package/dist/runtime/utils/markdown-nodes.d.ts

@@ -20,3 +20,4 @@ export interface MarkdownGenericNode {
 export type MarkdownNode = MarkdownCodeBlockNode | MarkdownMermaidNode | MarkdownGenericNode;
 export declare function transformMarkdownNodes<T>(value: T): T;
 export declare function extractMermaidSource(node: MarkdownNode | null | undefined): string | undefined;
+export declare function jsonMarkdown(value: unknown): string;

package/dist/runtime/utils/markdown-nodes.js

@@ -38,3 +38,9 @@ export function extractMermaidSource(node) {
   }
   return normalizeMermaidSource(node);
 }
+export function jsonMarkdown(value) {
+  const json = JSON.stringify(value, null, 2);
+  return json ? `\`\`\`json
+${json}
+\`\`\`` : "";
+}

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

@@ -1,10 +1,14 @@
 export type ChatFeatureConfig = {
     showUsageTab?: boolean;
     showDebugOption?: boolean;
+    showModelSelector?: boolean;
+    showCancelButton?: boolean;
 };
 export type ResolvedChatFeatureConfig = {
     showUsageTab: boolean;
     showDebugOption: boolean;
+    showModelSelector: boolean;
+    showCancelButton: boolean;
 };
 export type ChatActor = {
     name?: string | null;
@@ -12,6 +16,8 @@ export type ChatActor = {
     image?: string | null;
 };
 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 resolveChatFeatures(features?: Partial<ChatFeatureConfig>): ResolvedChatFeatureConfig;
 export declare function resolveConversationCreator(conversationUserId: string | null | undefined, options: {
     currentUser?: ChatActor | null;