@meistrari/chat-nuxt 1.0.0

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

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+export declare const agentApiQueryResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    sessionId: z.ZodString;
+}, z.core.$catchall<z.ZodUnknown>>, z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodString;
+}, z.core.$catchall<z.ZodUnknown>>], "success">;
+export type AgentApiQueryResponse = z.infer<typeof agentApiQueryResponseSchema>;
+declare const messageContentSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_use">;
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    tool_use_id: z.ZodString;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodAny>]>;
+    is_error: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodString;
+}, z.core.$catchall<z.ZodUnknown>>]>;
+export type MessageContent = z.infer<typeof messageContentSchema>;
+export declare const reasoningItemSchema: z.ZodObject<{
+    type: z.ZodString;
+    uuid: z.ZodString;
+    message: z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_use">;
+            id: z.ZodString;
+            name: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_result">;
+            tool_use_id: z.ZodString;
+            content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodAny>]>;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodString;
+        }, z.core.$catchall<z.ZodUnknown>>]>>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+    timestamp: z.ZodNumber;
+    session_id: z.ZodString;
+    timeElapsed: z.ZodNumber;
+    parent_tool_use_id: z.ZodNullable<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type ReasoningItem = z.infer<typeof reasoningItemSchema>;
+export declare const agentApiSessionSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    status: z.ZodString;
+    reasoning: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        message: z.ZodObject<{
+            role: z.ZodString;
+            content: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"tool_use">;
+                id: z.ZodString;
+                name: z.ZodString;
+                input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"tool_result">;
+                tool_use_id: z.ZodString;
+                content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodAny>]>;
+                is_error: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>]>>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+        timestamp: z.ZodNumber;
+        session_id: z.ZodString;
+        timeElapsed: z.ZodNumber;
+        parent_tool_use_id: z.ZodNullable<z.ZodString>;
+    }, z.core.$catchall<z.ZodUnknown>>>>;
+    result: z.ZodOptional<z.ZodObject<{
+        usage: z.ZodObject<{
+            duration: z.ZodNumber;
+            turns: z.ZodNumber;
+            completionTokens: z.ZodNumber;
+            promptTokens: z.ZodNumber;
+            totalTokens: z.ZodNumber;
+            completionCost: z.ZodNumber;
+            promptCost: z.ZodNumber;
+            totalCost: z.ZodNumber;
+        }, z.core.$catchall<z.ZodUnknown>>;
+        usageBreakdown: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            cacheReadInputTokens: z.ZodNullable<z.ZodNumber>;
+            cacheCreationInputTokens: z.ZodNullable<z.ZodNumber>;
+            serviceTier: z.ZodNullable<z.ZodString>;
+            cacheCreation: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            serverToolUse: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            modelUsage: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                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>>;
+                webSearchRequests: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                costUSD: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                contextWindow: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strip>>>;
+            totalCostUsd: z.ZodNullable<z.ZodNumber>;
+            calculatedCostUsd: z.ZodNullable<z.ZodNumber>;
+            consideredCalculatedCost: z.ZodBoolean;
+            durationMs: z.ZodNullable<z.ZodNumber>;
+            durationApiMs: z.ZodNullable<z.ZodNumber>;
+            numTurns: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        content: z.ZodOptional<z.ZodString>;
+        structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, 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 AgentApiSession = z.infer<typeof agentApiSessionSchema>;
+export type AgentSessionStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type AgentApiChatPayload = {
+    message: string;
+    fileUrls?: string[];
+    maxRounds?: number;
+    model?: string;
+    customTools?: {
+        canvas: {
+            variables?: Record<string, {
+                description: string;
+                name: string;
+                type: 'text' | 'file';
+            }>;
+            description: string;
+            name: string;
+            canvasId: string;
+        }[];
+    };
+    tools?: {
+        workstationQueryTool?: boolean;
+    };
+    environmentVariables?: Record<string, string>;
+    skills?: string[];
+};
+export type ContinueSessionPayload = {
+    content: string;
+    fileUrls?: string[];
+    model?: string;
+};
+export type MessageStatus = 'pending' | 'completed' | 'failed';
+export type CanvasTool = {
+    canvasId: string;
+    name: string;
+    description: string;
+    variables?: Record<string, {
+        name: string;
+        description: string;
+        type: 'text' | 'file';
+    }>;
+};
+export {};

package/dist/runtime/types/agent.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+export const agentApiQueryResponseSchema = z.discriminatedUnion("success", [
+  z.object({
+    success: z.literal(true),
+    sessionId: z.string()
+  }).catchall(z.unknown()),
+  z.object({
+    success: z.literal(false),
+    error: z.string()
+  }).catchall(z.unknown())
+]);
+const textContentSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
+});
+const toolUseContentSchema = z.object({
+  type: z.literal("tool_use"),
+  id: z.string(),
+  name: z.string(),
+  input: z.record(z.string(), z.unknown())
+});
+const toolResultContentSchema = z.object({
+  type: z.literal("tool_result"),
+  tool_use_id: z.string(),
+  content: z.union([z.string(), z.array(z.any())]),
+  is_error: z.boolean().optional()
+});
+const unknownContentSchema = z.object({
+  type: z.string()
+}).catchall(z.unknown());
+const messageContentSchema = z.union([
+  textContentSchema,
+  toolUseContentSchema,
+  toolResultContentSchema,
+  unknownContentSchema
+]);
+const reasoningMessageSchema = z.object({
+  role: z.string(),
+  content: z.array(messageContentSchema)
+}).catchall(z.unknown());
+export const reasoningItemSchema = z.object({
+  type: z.string(),
+  uuid: z.string(),
+  message: reasoningMessageSchema,
+  timestamp: z.number(),
+  session_id: z.string(),
+  timeElapsed: z.number(),
+  parent_tool_use_id: z.string().nullable()
+}).catchall(z.unknown());
+export const agentApiSessionSchema = z.object({
+  sessionId: z.string(),
+  status: z.string(),
+  reasoning: z.array(reasoningItemSchema).nullable(),
+  result: z.object({
+    usage: z.object({
+      duration: z.number(),
+      turns: z.number(),
+      completionTokens: z.number(),
+      promptTokens: z.number(),
+      totalTokens: z.number(),
+      completionCost: z.number(),
+      promptCost: z.number(),
+      totalCost: z.number()
+    }).catchall(z.unknown()),
+    usageBreakdown: z.object({
+      inputTokens: z.number().nullable(),
+      outputTokens: z.number().nullable(),
+      cacheReadInputTokens: z.number().nullable(),
+      cacheCreationInputTokens: z.number().nullable(),
+      serviceTier: z.string().nullable(),
+      cacheCreation: z.record(z.string(), z.unknown()).nullable(),
+      serverToolUse: z.record(z.string(), z.unknown()).nullable(),
+      modelUsage: z.record(z.string(), z.object({
+        inputTokens: z.number().nullable().optional(),
+        outputTokens: z.number().nullable().optional(),
+        cacheReadInputTokens: z.number().nullable().optional(),
+        cacheCreationInputTokens: z.number().nullable().optional(),
+        webSearchRequests: z.number().nullable().optional(),
+        costUSD: z.number().nullable().optional(),
+        contextWindow: z.number().nullable().optional()
+      })).nullable(),
+      totalCostUsd: z.number().nullable(),
+      calculatedCostUsd: z.number().nullable(),
+      consideredCalculatedCost: z.boolean(),
+      durationMs: z.number().nullable(),
+      durationApiMs: z.number().nullable(),
+      numTurns: z.number().nullable()
+    }).optional(),
+    content: z.string().optional(),
+    structuredContent: z.record(z.string(), z.any()).optional()
+  }).catchall(z.unknown()).optional(),
+  error: z.string().optional(),
+  createdAt: z.number().optional(),
+  updatedAt: z.number().optional()
+}).catchall(z.unknown());

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

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

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

@@ -0,0 +1,81 @@
+import type { InferSelectModel } from 'drizzle-orm';
+import type { conversations, messages, ContextFile as SchemaContextFile, MessageFile as SchemaMessageFile } from '#chat-runtime/server/db/schema';
+export type ContextFile = SchemaContextFile;
+export type MessageFile = SchemaMessageFile;
+export type Conversation = InferSelectModel<typeof conversations>;
+export type Message = InferSelectModel<typeof messages>;
+export type ConversationWithMessages = Conversation & {
+    messages: Message[];
+};
+export type MessageRole = 'user' | 'assistant';
+export type FileUploadInput = {
+    url: string;
+    name: string;
+    mimeType?: string;
+    vaultReference?: string;
+    size?: number;
+};
+export declare const AVAILABLE_MODELS: readonly [{
+    readonly value: "claude-sonnet-4-5";
+    readonly label: "Sonnet 4.5";
+    readonly description: "High performant agent for complex tasks";
+}, {
+    readonly value: "claude-sonnet-4-6";
+    readonly label: "Sonnet 4.6";
+    readonly description: "Fast and intelligent agent";
+}, {
+    readonly value: "claude-haiku-4-5";
+    readonly label: "Haiku 4.5";
+    readonly description: "Fast and efficient agent for simple tasks";
+}, {
+    readonly value: "claude-opus-4-5";
+    readonly label: "Opus 4.5";
+    readonly description: "Most powerful agent for complex tasks";
+}, {
+    readonly value: "claude-opus-4-6";
+    readonly label: "Opus 4.6";
+    readonly description: "Top-tier agent with extended thinking";
+}];
+export type ModelOption = typeof AVAILABLE_MODELS[number]['value'];
+export declare const DEFAULT_MODEL: ModelOption;
+export declare const VALID_MODEL_VALUES: readonly ModelOption[];
+export declare function isValidModel(value: unknown): value is ModelOption;
+export type TopbarTab = 'chat' | 'files' | 'usage';
+export type ConversationFile = {
+    id: string;
+    url: string;
+    name: string;
+    mimeType: string;
+    vaultReference?: string;
+    source: 'context' | 'message';
+    messageId?: string;
+    messageRole?: MessageRole;
+    createdAt?: Date;
+    size?: number;
+};
+export type ConversationFilesResponse = {
+    files: ConversationFile[];
+    summary: {
+        total: number;
+    };
+};
+export type MentionItem = {
+    id: string;
+    label: string;
+    description?: string;
+    icon: string;
+    category: 'file' | 'skill' | 'canvas';
+    variables?: Record<string, {
+        name: string;
+        description: string;
+        type: 'text' | 'file';
+    }>;
+};
+export type KnowledgeSource = {
+    type: 'workstation';
+    id: string;
+    name: string;
+    projectId: string;
+    description?: string;
+    taskCount?: number;
+};

package/dist/runtime/types/chat.js

@@ -0,0 +1,12 @@
+export const AVAILABLE_MODELS = [
+  { value: "claude-sonnet-4-5", label: "Sonnet 4.5", description: "High performant agent for complex tasks" },
+  { value: "claude-sonnet-4-6", label: "Sonnet 4.6", description: "Fast and intelligent agent" },
+  { value: "claude-haiku-4-5", label: "Haiku 4.5", description: "Fast and efficient agent for simple tasks" },
+  { value: "claude-opus-4-5", label: "Opus 4.5", description: "Most powerful agent for complex tasks" },
+  { value: "claude-opus-4-6", label: "Opus 4.6", description: "Top-tier agent with extended thinking" }
+];
+export const DEFAULT_MODEL = "claude-sonnet-4-6";
+export const VALID_MODEL_VALUES = AVAILABLE_MODELS.map((m) => m.value);
+export function isValidModel(value) {
+  return typeof value === "string" && VALID_MODEL_VALUES.includes(value);
+}

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

@@ -0,0 +1,8 @@
+export type WorkspaceCredential = {
+    id: string;
+    key: string;
+    createdBy: string;
+    updatedBy: string;
+    createdAt: string;
+    updatedAt: string;
+};

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

@@ -0,0 +1,4 @@
+export interface CsvData {
+    headers: string[];
+    rows: string[][];
+}

package/dist/runtime/types/external-skills.d.ts

@@ -0,0 +1,8 @@
+export type DiscoveredSkill = {
+    ref: string;
+    name: string;
+    description: string;
+    runtime: string;
+    allowedTools: string[];
+    isPublic: boolean;
+};

package/dist/runtime/types/feature-flags.d.ts

@@ -0,0 +1,7 @@
+export declare const FEATURE_FLAGS: {
+    readonly ENABLE_CANCEL_GENERATION: "enable-cancel-generation";
+    readonly ENABLE_USAGE_TAB: "enable-usage-tab";
+    readonly ENABLE_DEBUG_MODE: "enable-debug-mode";
+    readonly ENABLE_MODEL_SELECTOR: "enable-model-selector";
+};
+export type FeatureFlagKey = typeof FEATURE_FLAGS[keyof typeof FEATURE_FLAGS];

package/dist/runtime/types/feature-flags.js

@@ -0,0 +1,6 @@
+export const FEATURE_FLAGS = {
+  ENABLE_CANCEL_GENERATION: "enable-cancel-generation",
+  ENABLE_USAGE_TAB: "enable-usage-tab",
+  ENABLE_DEBUG_MODE: "enable-debug-mode",
+  ENABLE_MODEL_SELECTOR: "enable-model-selector"
+};

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

@@ -0,0 +1,17 @@
+export interface ToolUse {
+    id: string;
+    name: string;
+    input?: Record<string, unknown>;
+    description?: string;
+}
+export interface ToolResult {
+    id: string;
+    output: string;
+    isError: boolean;
+}
+export type ToolGroup = {
+    type: 'tool_group';
+    toolUse: ToolUse;
+    toolResult?: ToolResult;
+};
+export type ReasoningStep = string | ToolGroup;

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

@@ -0,0 +1,46 @@
+export type TelaProject = {
+    id: string;
+    title: string;
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type TelaCanvasVariable = {
+    name: string;
+    description?: string;
+    type: 'text' | 'file';
+};
+export type TelaCanvas = {
+    id: string;
+    title: string;
+    projectId: string;
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+    isFavorite?: boolean;
+    customTags?: string[];
+    promotedVersion?: {
+        variables: TelaCanvasVariable[];
+        workflowSpec?: unknown;
+    };
+};
+export type ProjectWithCanvas = {
+    project: TelaProject | null;
+    canvas: TelaCanvas[];
+};
+export type TelaWorkspaceStats = {
+    id: string;
+    title: string;
+    promptCount?: number;
+    projectCount?: number;
+};
+export type TelaWorkstation = {
+    id: string;
+    name: string;
+    promptId: string;
+    workspaceId: string;
+    description?: string;
+    taskCount?: number;
+    createdAt: string;
+    updatedAt: string;
+};

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

@@ -0,0 +1,20 @@
+export type WorkspaceSettings = {
+    disableStorage?: boolean;
+    dataRetentionHours?: number;
+    billing?: {
+        mode?: 'plan' | 'credits';
+        cvp?: number;
+    };
+};
+export type AccessibleWorkspace = {
+    id: string;
+    key: string;
+    title: string;
+    avatar_url: string | null;
+    createdAt: string;
+    updatedAt: string;
+    projectCount?: number;
+    promptCount?: number;
+    memberCount?: number;
+    settings?: WorkspaceSettings | null;
+};

package/dist/runtime/utils/calculate-usage.d.ts

@@ -0,0 +1,48 @@
+export interface SessionUsage {
+    duration: number;
+    turns: number;
+    completionTokens: number;
+    promptTokens: number;
+    totalTokens: number;
+    completionCost: number;
+    promptCost: number;
+    totalCost: number;
+}
+export type ModelUsageDisplay = {
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    cost: number;
+    contextWindow: number;
+    webSearchRequests: number;
+};
+export interface ConversationUsage {
+    tokens: {
+        prompt: number;
+        completion: number;
+        total: number;
+        cacheRead: number;
+        cacheCreation: number;
+    };
+    cost: {
+        prompt: number;
+        completion: number;
+        total: number;
+    };
+    duration: number;
+    turns: number;
+    models: ModelUsageDisplay[];
+    metrics: {
+        cacheHitRate: number;
+        costPerTurn: number;
+        webSearchRequests: number;
+        webFetchRequests: number;
+    };
+}
+export declare function extractUsageFromSession(sessionUsage: SessionUsage | undefined): ConversationUsage | null;
+export declare function formatTokenCount(count: number): string;
+export declare function formatCost(cost: number): string;
+export declare function formatCredits(credits: number): string;
+export declare function formatModelName(model: string): string;

package/dist/runtime/utils/calculate-usage.js

@@ -0,0 +1,63 @@
+export function extractUsageFromSession(sessionUsage) {
+  if (!sessionUsage) {
+    return null;
+  }
+  return {
+    tokens: {
+      prompt: sessionUsage.promptTokens,
+      completion: sessionUsage.completionTokens,
+      total: sessionUsage.totalTokens,
+      cacheRead: 0,
+      cacheCreation: 0
+    },
+    cost: {
+      prompt: sessionUsage.promptCost,
+      completion: sessionUsage.completionCost,
+      total: sessionUsage.totalCost
+    },
+    duration: sessionUsage.duration,
+    turns: sessionUsage.turns,
+    models: [],
+    metrics: {
+      cacheHitRate: 0,
+      costPerTurn: 0,
+      webSearchRequests: 0,
+      webFetchRequests: 0
+    }
+  };
+}
+export function formatTokenCount(count) {
+  if (count >= 1e6) {
+    const val = count / 1e6;
+    return `${val % 1 === 0 ? val.toFixed(0) : val.toFixed(2)}M`;
+  }
+  if (count >= 1e3) {
+    const val = count / 1e3;
+    return `${val % 1 === 0 ? val.toFixed(0) : val.toFixed(2)}K`;
+  }
+  return count.toString();
+}
+export function formatCost(cost) {
+  if (cost < 0.01) {
+    return `$${cost.toFixed(4)}`;
+  }
+  return `$${cost.toFixed(2)}`;
+}
+export function formatCredits(credits) {
+  return `${Math.round(credits)} cr\xE9ditos`;
+}
+export function formatModelName(model) {
+  const id = model.replace(/^claude-/, "");
+  const newFormat = id.match(/^(opus|sonnet|haiku)-(\d+)-(\d+)/);
+  if (newFormat) {
+    const [, family, major, minor] = newFormat;
+    return `Claude ${family.charAt(0).toUpperCase()}${family.slice(1)} ${major}.${minor}`;
+  }
+  const legacyFormat = id.match(/^(\d+)-(?:(\d+)-)?(opus|sonnet|haiku)/);
+  if (legacyFormat) {
+    const [, major, minor, family] = legacyFormat;
+    const version = minor ? `${major}.${minor}` : major;
+    return `Claude ${family.charAt(0).toUpperCase()}${family.slice(1)} ${version}`;
+  }
+  return id;
+}

package/dist/runtime/utils/code-detection.d.ts

@@ -0,0 +1 @@
+export declare function isCodeLike(content: string): boolean;

package/dist/runtime/utils/code-detection.js

@@ -0,0 +1,24 @@
+export function isCodeLike(content) {
+  if (!content || content.trim().length === 0)
+    return false;
+  const trimmed = content.trim();
+  if (/^\s*[\[{]/.test(trimmed) && /"[^"]+"\s*:/.test(trimmed))
+    return true;
+  if (/^\s+at\s+.+\(.+:\d+/m.test(content))
+    return true;
+  if (/^[-+]{3}\s+[ab]\//.test(content) || /^@@\s+[-+]/.test(content))
+    return true;
+  const codePatterns = [
+    /\bfunction\b|\bconst\b|\blet\b|\bvar\b|\bclass\b|\binterface\b|\breturn\b|\bimport\b|\bexport\b/,
+    /=>|===|!==|&&|\|\|/,
+    /\/\/.*|\/\*[\s\S]*?\*\//,
+    /^\s{2,}(if|for|while|switch|try|catch)\b/m,
+    /[{;}\]]\s*$/m
+  ];
+  const matches = codePatterns.filter((pattern) => pattern.test(content)).length;
+  if (matches >= 2)
+    return true;
+  if (matches >= 1 && content.split("\n").length > 6)
+    return true;
+  return false;
+}

package/dist/runtime/utils/export-conversation.d.ts

@@ -0,0 +1,2 @@
+import type { ConversationWithMessages } from '#chat-runtime/types/chat';
+export declare function exportConversationToMarkdown(conversation: ConversationWithMessages): void;