current time tool

src/app/@modal/(.)assistant/_components/ChatModal.tsx

@@ -10,21 +10,21 @@ type DBMessage = {
 }
 
 interface ChatModalProps {
-	sessionId: string
+	sessionId?: string
-	initialMessages: DBMessage[]
+	// initialMessages: DBMessage[]
 }
 
-export default function ChatModal({ sessionId, initialMessages }: ChatModalProps) {
+export default function ChatModal({ sessionId }: ChatModalProps) {
 	const router = useRouter()
 
 	return (
 		<Dialog modal={true} open onOpenChange={() => router.back()}>
 			<DialogContent className="w-full max-w-full rounded-none sm:max-w-full h-[100svh] lg:max-w-3xl lg:rounded-xl lg:h-[80vh] flex flex-col p-0 gap-0">
 				<DialogHeader className="p-4 border-b shrink-0">
-					<DialogTitle>AI Recruiter</DialogTitle>
+					<DialogTitle>Talk To My AI-Assistant</DialogTitle>
 				</DialogHeader>
 				<div className="flex-1 overflow-hidden min-h-0">
-					<ChatInterface sessionId={sessionId} initialMessages={initialMessages} />
+					<ChatInterface sessionId={sessionId} />
 				</div>
 			</DialogContent>
 		</Dialog>

src/app/@modal/(.)assistant/page.tsx

@@ -2,12 +2,13 @@
 import { Skeleton } from '~/components/ui/skeleton';
 import ChatModal from './_components/ChatModal'
 import { trpc } from '~/app/_trpc/Client'
+import { useTimeLine } from '~/app/_providers/GsapProvicer';
 
-export default function ChatModalPage() {
+export default function AssistantModalPage() {
 	const { data: session, error, isLoading } = trpc.chat.getSession.useQuery();
 	return (
 		<>
-			{session && <ChatModal sessionId={session.id} initialMessages={session.messages} />}
+			&& <ChatModal sessionId={session?.id} />
 			{error && <div>{error.message}</div>}
 			{isLoading && <Skeleton />}
 		</>

src/app/_components/Animated/AnimateIn.tsx

@@ -7,28 +7,54 @@ import { cn } from "~/lib/utils";
 const AnimateTextIn = ({
   children,
   animation = "type",
-  position,
+  position = 0,
+  tlId = undefined,
+  speed = 1,
+  scrollOnly = false,
   className
 }: {
   children: ReactNode,
   animation?: "type" | "slide",
-  position: gsap.Position,
+  position?: gsap.Position,
+  tlId?: string,
+  scrollOnly?: boolean,
+  speed?: number,
   className?: HTMLAttributes<HTMLDivElement>['className']
 }) => {
   const el = useRef<HTMLDivElement>(null)
   const gsapContext = useGsapContext();
   useGSAP(() => {
     const rect = el.current?.getBoundingClientRect()
-    const isInView = rect && rect.top < window.innerHeight
+    const scroller = gsapContext?.getScroller()
+    console.log(scroller)
+    let viewportTop = 0
+    let viewportBottom = window.innerHeight
+    if (scroller && scroller instanceof Element) {
+      const scrollerRect = scroller.getBoundingClientRect()
+      viewportTop = scrollerRect.top
+      viewportBottom = scrollerRect.top + scrollerRect.height
+    }
+    const isInView = rect && rect.bottom > viewportTop && rect.top < viewportBottom
+    console.log(isInView)
     const chars = new SplitText(el.current, { type: 'chars' })
-    gsapContext?.addAnimation(gsap.to(el.current, { opacity: 100, duration: 0 }), 0)
+    gsapContext?.addAnimation(gsap.to(el.current, { opacity: 100, duration: 0 }), 0, tlId)
     const fromVars = animation === "slide"
-      ? { opacity: 0, x: -10, duration: 0.2, stagger: { each: 0.08 }, ease: 'bounce.inOut', onComplete: () => chars.revert() }
+      ? { opacity: 0, x: -10, duration: 0.2 * speed, stagger: { each: 0.08 * speed }, ease: 'bounce.inOut', onComplete: () => chars.revert() }
-      : { opacity: 0, duration: 0.01, stagger: { each: 0.04 }, ease: 'bounce.inOut', onComplete: () => chars.revert()  }
+      : { opacity: 0, duration: 0.01 * speed, stagger: { each: 0.04 * speed }, ease: 'bounce.inOut', onComplete: () => chars.revert() }
-    if (isInView) {
+    if (isInView && !scrollOnly) {
-      gsapContext?.addAnimation(gsap.from(chars.chars, fromVars), position)
+      gsapContext?.addAnimation(gsap.from(chars.chars, fromVars), position, tlId)
     } else {
-      gsap.from(chars.chars, { ...fromVars, scrollTrigger: { trigger: el.current, start: 'top 85%', scroller: gsapContext?.getScroller() } })
+      gsap.from(chars.chars,
+        {
+          ...fromVars,
+          scrollTrigger: {
+            trigger: el.current,
+            start: 'top bottom',
+            end: 'bottom top',
+            toggleActions: "play reverse play reverse",
+            scroller
+          }
+        })
     }
   }, { dependencies: [] })
   return (

src/app/_components/ChatFAB.tsx

@@ -3,17 +3,23 @@ import Link from 'next/link'
 import { MessageCircle } from 'lucide-react'
 import { Show } from '@clerk/nextjs'
 import { Button } from '~/components/ui/button'
-
+import { usePathname } from 'next/navigation'
 export default function ChatFAB() {
+	const pathName = usePathname()
+	const isChat = pathName.indexOf('\/chat') > -1
 	return (
+		<>
+			{!isChat &&
 				<Show when="signed-in">
 					<div className="fixed bottom-6 right-6 z-50">
 						<Button asChild size="icon" className="h-14 w-14 rounded-full shadow-lg">
-					<Link href="/chat">
+							<Link href="/assistant">
 								<MessageCircle className="h-6 w-6" />
 							</Link>
 						</Button>
 					</div>
 				</Show>
+			}
+		</>
 	)
 }

src/app/_components/TopNav.tsx

@@ -24,7 +24,7 @@ export default function TopNav() {
 					</Button>
 					<Show when="signed-in">
 						<Button asChild className="flex h-10 lg:h-full w-full lg:w-20" variant="outline">
-							<a href="/chat"> Chat </a>
+							<Link href="/chat"> Chat </Link>
 						</Button>
 					</Show>
 				</div>

src/app/_providers/GsapProvicer.tsx

@@ -2,12 +2,13 @@
 import { useGSAP } from '@gsap/react'
 import gsap from 'gsap'
 import { SplitText } from 'gsap/SplitText'
-import { ScrollTrigger } from 'gsap/all'
+import { ScrollTrigger, GSDevTools } from 'gsap/all'
 import { createContext, useCallback, useContext, useEffect, useLayoutEffect, useRef, type ReactNode } from 'react'
 
 gsap.registerPlugin(useGSAP)
 gsap.registerPlugin(ScrollTrigger)
 gsap.registerPlugin(SplitText)
+gsap.registerPlugin(GSDevTools)
 const GsapContext = createContext<{
   addAnimation: (
     animation: gsap.core.TimelineChild,
@@ -22,7 +23,7 @@ export function useGsapContext() {
   return useContext(GsapContext)
 }
 
-export const useTimeLine = (dep?:any,all?:boolean) => {
+export const useTimeLine = (dep:any,all?:boolean) => {
   const gsapContext = useGsapContext()
     useEffect(() => {
       if (dep instanceof Array && all) {
@@ -48,10 +49,25 @@ export default function GsapProvider({ children }: { children: ReactNode }) {
   const tl = useRef<gsap.core.Timeline | null>(null)
   const scrollerRef = useRef<Element | Window | null>(null)
   const getScroller = useCallback(() => {
-    const cached = scrollerRef.current
+    // const cached = scrollerRef.current
-    if (!cached || (cached instanceof Element && !document.contains(cached))) {
+    // if (!cached || (cached instanceof Element && !document.contains(cached))) {
-      scrollerRef.current = document.querySelector('[data-slot="scroll-area-viewport"]') ?? window
+      let scrollers = document.querySelectorAll('[data-slot="scroll-area-viewport"]')
+      if (scrollers.length < 1) {
+        scrollerRef.current = window
+      } else {
+        let scrollerArray = Array.from(scrollers.values()).sort((a,b) => {
+          const s1 = a as HTMLDivElement;
+          const s2 = b as HTMLDivElement;
+          // using bitwise not (~~) to coerce NaN values to 0
+          const aPriority = ~~Number(s1.dataset?.scrollerPriority)
+          const bPriority = ~~Number(s2.dataset?.scrollerPriority)
+          return aPriority - bPriority;
+        })
+        let prioScroller = scrollerArray.pop();
+        scrollerRef.current = prioScroller || window;
       }
+
+    // }
     return scrollerRef.current
   }, [])
   useGSAP(() => {
@@ -66,7 +82,6 @@ export default function GsapProvider({ children }: { children: ReactNode }) {
     tl.current?.add(animation, position);
   },[])
   const resetTimeline = useCallback(() => {
-    console.log('resetting timeline')
     tl.current?.kill()
     tl.current?.revert()
     ScrollTrigger.getAll().forEach(st => st.kill())

src/app/api/chat/route.ts

@@ -1,7 +1,7 @@
 import { auth } from '@clerk/nextjs/server'
 import { createOpenAI } from '@ai-sdk/openai'
 import { streamText, tool, convertToModelMessages, stepCountIs, type UIMessage } from 'ai'
-import { z } from 'zod'
+import { success, z } from 'zod'
 import { eq, and } from 'drizzle-orm'
 import { env } from '~/env'
 import { db } from '~/server/db'
@@ -74,6 +74,11 @@ export async function POST(req: Request) {
 				}),
 				execute: async (input) => scheduleMeeting({ ...input, userId }),
 			}),
+			getCurrentUnixTime: tool({
+				description: 'Get the current unix time to reference for meeting dates',
+				inputSchema: z.undefined(),
+				execute: async () => { return {success: true, currentTime: Date.now()} }
+			})
 		},
 		stopWhen: stepCountIs(5),
 		onFinish: async ({ text, finishReason }) => {

src/app/assistant/page.tsx

@@ -0,0 +1,5 @@
+import { redirect } from 'next/navigation'
+
+export default function AssistantPage() {
+	redirect('/chat')
+}

src/app/chat/_components/AssistantMessage.tsx

@@ -16,7 +16,7 @@ export const AssistantMessage = (props: { message: UIMessage }) => {
         {message.parts.map((part, i) => {
           if (part.type === 'text') {
             return (
-              <Markdown>
+              <Markdown key={i}>
                 {part.text}
               </Markdown>
             )

src/app/chat/_components/ChatInterface.tsx

@@ -1,23 +1,25 @@
 'use client'
-import { useRef, useState, useEffect } from 'react'
+import {  useState, useEffect  } from 'react'
 import { useChat } from '@ai-sdk/react'
 import { DefaultChatTransport, type UIMessage } from 'ai'
 import { Button } from '~/components/ui/button'
 import { Textarea } from '~/components/ui/textarea'
-import { cn } from '~/lib/utils'
+import {
-import Markdown from 'react-markdown';
+	useGsapContext,
-import { AssistantMessage } from './AssistantMessage';
+} from '~/app/_providers/GsapProvicer';
-import { UserMessage } from './UserMessage';
+import Messages from './Messages'
-
+import { DeleteIcon } from 'lucide-react';
-type DBMessage = {
+import { trpc } from '~/app/_trpc/Client'
+import { Spinner } from '~/components/ui/spinner';
+interface DBMessage {
 	id: string
 	role: 'user' | 'assistant'
 	content: string
 }
 
 interface ChatInterfaceProps {
-	sessionId: string
+	sessionId?: string
-	initialMessages: DBMessage[]
+	// initialMessages: DBMessage[]
 }
 
 function toUIMessages(dbMessages: DBMessage[]): UIMessage[] {
@@ -27,60 +29,80 @@ function toUIMessages(dbMessages: DBMessage[]): UIMessage[] {
 		parts: [{ type: 'text' as const, text: m.content }],
 	}))
 }
-
+export default function ChatInterface({ sessionId }: ChatInterfaceProps) {
-export default function ChatInterface({ sessionId, initialMessages }: ChatInterfaceProps) {
+	const utils = trpc.useUtils();
-	const [input, setInput] = useState('')
+	const { data: dbMessages, refetch: refetchMessages  } = trpc.chat.getMessages.useQuery(sessionId ? sessionId : "")
-	const messagesEndRef = useRef<HTMLDivElement>(null)
+	const [messages, setMessages] = useState<UIMessage[]>([]);
-
+	function addMessage(newMessage: UIMessage) {
-	const { messages, sendMessage, status, error, clearError } = useChat({
+		setMessages(prev => [...prev, newMessage]);
-		transport: new DefaultChatTransport({
+	}
-			api: '/api/chat',
-			body: { sessionId },
-		}),
-		messages: toUIMessages(initialMessages),
-	})
-
-	const isLoading = status === 'submitted' || status === 'streaming'
-	const hasError = status === 'error'
-
 	useEffect(() => {
-		messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
+		setMessages(toUIMessages(dbMessages ?? []));
-	}, [messages])
+	}, [dbMessages]);
 
+	if (messages.at(0)?.id != 'init') {
+		messages.unshift({
+			id: "init",
+			role: 'assistant',
+			parts: [{
+				type: 'text',
+				text: "Hi im gregors ai assistant,you can ask me to provide general information or to schedule a meeting."
+			}],
+		})
+	}
+	const [input, setInput] = useState('')
+	const { sendMessage, status, error, clearError } = useChat({
+		transport: new DefaultChatTransport({
+			api: '/api/chat', body: { sessionId },
+		}),
+		messages: messages,
+	})
 	const handleSend = () => {
 		const text = input.trim()
-		if (!text || isLoading) return
+		if (!text || status != 'ready') return
 		setInput('')
 		sendMessage({ text })
+		addMessage({
+			id: "", role: "user", parts: [
+				{ type: 'text', text }
+			]
+		})
+		addMessage({
+			id: "", role: "assistant", parts: [
+				{ type: 'text', text: "Thinking..." }
+			]
+		})
 	}
-
+	const clearChatMutation = trpc.chat.clearChat.useMutation()
+	const handleClear = () => {
+		clearChatMutation.mutate(undefined, {
+			onSuccess: () => {
+				utils.chat.getMessages.invalidate()
+				refetchMessages()
+			}
+		})
+	}
+	const gsapContext = useGsapContext()
+	useEffect(() => {
+		console.log(status)
+		if (status == 'ready') {
+			utils.chat.getMessages.invalidate();
+			refetchMessages()
+		}
+	}, [status])
+	useEffect(() => {
+		let scroller = gsapContext?.getScroller()
+		if (scroller instanceof Window) {
+			return;
+		}
+		console.log(scroller?.scrollHeight)
+		scroller?.scrollTo({ behavior: 'smooth', top: scroller.scrollHeight })
+	}, [messages])
 	return (
 		<div className="flex flex-col h-full">
-			<div className="flex-1 overflow-y-auto p-4 space-y-4">
+			{messages && 
-				{messages.length === 0 && (
+				<Messages messages={messages} />
-					<div className="text-center text-muted-foreground py-12">
+			}
-						<p className="text-base font-medium mb-1">Hi! I'm Gregor's AI recruiter assistant.</p>
-						<p className="text-sm">Ask me about his skills and experience, or schedule a meeting!</p>
-					</div>
-				)}
-
-				{messages.map((message) => (
-					<>
-					{message.role == 'assistant' && <AssistantMessage message={message}/>}
-					{message.role == 'user' && <UserMessage message={message}/>}
-				</>
-				))}
-
-				{isLoading && (
-					<div className="flex justify-start">
-						<div className="bg-muted rounded-lg px-4 py-2 text-sm">
-							<span className="animate-pulse">Thinking…</span>
-						</div>
-					</div>
-				)}
-
-				<div ref={messagesEndRef} />
-			</div>
 
 			{error && (
 				<div className="mx-4 mb-2 flex items-start gap-2 rounded-lg border border-destructive/50 bg-destructive/10 px-3 py-2 text-sm text-destructive">
@@ -89,19 +111,20 @@ export default function ChatInterface({ sessionId, initialMessages }: ChatInterf
 							? 'OpenAI quota exceeded. Please try again later.'
 							: `Error: ${error.message}`}
 					</span>
-					<button
+					<Button
 						type="button"
 						onClick={clearError}
 						className="shrink-0 opacity-60 hover:opacity-100"
-						aria-label="Dismiss"
+						variant='destructive'
 					>
-						✕
+						<DeleteIcon />
-					</button>
+					</Button>
 				</div>
 			)}
 
-			<div className="p-4 border-t flex gap-2">
+			<div className="p-4 border-t flex flex-row gap-2">
 				<Textarea
+					name='message'
 					value={input}
 					onChange={(e) => setInput(e.target.value)}
 					placeholder="Ask about Gregor's experience or schedule a meeting…"
@@ -114,13 +137,24 @@ export default function ChatInterface({ sessionId, initialMessages }: ChatInterf
 						}
 					}}
 				/>
+				<div className='flex flex-col gap-2'>
 					<Button
 						onClick={handleSend}
-					disabled={isLoading || hasError || !input.trim()}
+						disabled={status != "ready" || !input.trim()}
-					className="self-end"
 					>
 						Send
 					</Button>
+					<Button
+						variant='destructive'
+						onClick={handleClear}
+						disabled={status != "ready" || clearChatMutation.isPending}
+					>
+						{clearChatMutation.isPending ?
+							<Spinner /> :
+							"Clear Chat"
+						}
+					</Button>
+				</div>
 			</div>
 		</div>
 	)

src/app/chat/_components/Messages.tsx

@@ -0,0 +1,25 @@
+import { type UIMessage } from 'ai'
+import * as Card from "~/components/ui/card"
+import AnimateTextIn from '~/app/_components/Animated/AnimateIn';
+import { UserMessage } from './UserMessage';
+import { AssistantMessage } from './AssistantMessage';
+import { ScrollArea } from '~/components/ui/scroll-area';
+import { useTimeLine } from '~/app/_providers/GsapProvicer';
+import {
+  memo
+  } from 'react';
+const Messages = memo(({ messages}: { messages: UIMessage[]}) => {
+  return (
+    <ScrollArea data-scroller-priority='1' className="w-full h-[90%] max-w-4xl mx-auto">
+      {messages.map((message, i) => (
+        <Card.AnimatedCard scrollOnly={true} tlId='chat' position={i * 0.2} key={i}>
+          <Card.CardContent>
+            {message.role == 'assistant' && <AssistantMessage message={message} />}
+            {message.role == 'user' && <UserMessage message={message} />}
+          </Card.CardContent>
+        </Card.AnimatedCard>
+      ))}
+    </ScrollArea>)
+})
+
+export default Messages;

src/app/chat/page.tsx

@@ -2,26 +2,22 @@
 import ChatInterface from './_components/ChatInterface'
 import { trpc } from '../_trpc/Client';
 import { Skeleton } from '~/components/ui/skeleton';
+import AnimatedPageTitle from '../_components/Animated/AnimatedPageTitle';
+import { useTimeLine } from '../_providers/GsapProvicer';
 
 export default function ChatPage() {
 	const { data: session, error, isLoading } = trpc.chat.getSession.useQuery();
+	useTimeLine(session)
 	return (
-		<div className="container max-w-2xl mx-auto h-screen pt-10 pb-4 flex flex-col">
+		<div className="flex flex-col px-10 lg:px-0 w-full h-full max-w-4xl mx-auto pt-10">
-			<div className="flex flex-col flex-1 bg-background border rounded-lg overflow-hidden">
+					<AnimatedPageTitle position={0}>
-				<div className="p-4 border-b flex items-center justify-between">
+						<span>Talk To My </span> <span> AI-Assistant</span>
-					<div>
+					</AnimatedPageTitle>
-						<h1 className="text-lg font-semibold">AI Recruiter</h1>
+					<div className='flex items-center h-[80%] my-auto w-full'>
-						<p className="text-xs text-muted-foreground">
+					<ChatInterface sessionId={session?.id} /> 
-							Chat with Gregor's AI assistant
-						</p>
-					</div>
-				</div>
-				<div className="flex-1 overflow-hidden">
-					{session && <ChatInterface sessionId={session?.id} initialMessages={session?.messages} /> }
 					{error && <div>{error.message}</div>}
 					{isLoading && <Skeleton/>}
 					</div>
 		</div>
-		</div>
 	)
 }

src/app/layout.tsx

@@ -47,7 +47,7 @@ export default async function RootLayout({
 							<ThemeProvider>
 							<AnimatedBackGroundContainer followSpeed={0.003} particleCount={100} orbitRadius={2000}>
 								<TopNav />
-								<main className="absolute lg:top-10 h-screen w-screen">
+								<main className="absolute lg:top-10 h-screen lg:h-[calc(100vh-var(--spacing)*10)] w-screen">
 									{children}
 								</main>
 								{modal}

src/components/ui/card.tsx

@@ -26,20 +26,40 @@ function AnimatedCard({
   className,
   position = 0,
   size = "default",
+  tlId = undefined,
+  scrollOnly = false,
   ...props
-}: React.ComponentProps<"div"> & { size?: "default" | "sm", position: gsap.Position }) {
+}: React.ComponentProps<"div"> & { size?: "default" | "sm", position: gsap.Position, tlId?: string, scrollOnly?: boolean }) {
   const gsapContext = useGsapContext()
   const ref = useRef<HTMLDivElement | null>(null)
   useGSAP(() => {
     const rect = ref.current?.getBoundingClientRect()
-    const isInView = rect && rect.top < window.innerHeight
-    const fromVars = { x: -100, opacity: 0, duration: 0.5 }
-    if (isInView) {
-      gsapContext?.addAnimation(gsap.from(ref.current, fromVars), position)
-    } else {
     const scroller = gsapContext?.getScroller()
-      console.log('scroller:', scroller)
+    console.log(scroller)
-      gsap.from(ref.current, { ...fromVars, scrollTrigger: { trigger: ref.current, start: 'top 85%', scroller } })
+    let viewportTop = 0
+    let viewportBottom = window.innerHeight
+    if (scroller && scroller instanceof Element) {
+      const scrollerRect = scroller.getBoundingClientRect()
+      viewportTop = scrollerRect.top
+      viewportBottom = scrollerRect.top + scrollerRect.height
+    }
+    const isInView = rect && rect.bottom > viewportTop && rect.top < viewportBottom
+    console.log(isInView)
+    const fromVars = { x: -100, opacity: 0, duration: 0.5 }
+    if (isInView && !scrollOnly) {
+      gsapContext?.addAnimation(gsap.from(ref.current, fromVars), position, tlId)
+    } else {
+      gsap.from(ref.current,
+        {
+          ...fromVars,
+          scrollTrigger: {
+            trigger: ref.current,
+            start: 'top bottom',
+            end: 'bottom top',
+            toggleActions: "play reverse play reverse",
+            scroller
+          }
+        })
     }
   }, { dependencies: [] })
   return (

src/server/routers/chat.ts

@@ -2,9 +2,11 @@ import { auth } from '@clerk/nextjs/server'
 import { publicProcedure, router } from "../trpc";
 import { TRPCError } from "@trpc/server";
 import { db } from '~/server/db'
-import { chatSession, systemSettings } from "../dbschema/schema";
+import { chatMessage,
+chatSession, systemSettings } from "../dbschema/schema";
 import { isAdmin } from '~/app/actions';
 import { z } from 'zod';
+import { eq } from 'drizzle-orm';
 export const chatRouter = router({
   getSession: publicProcedure.query(async () => {
     const { userId } = await auth();
@@ -12,9 +14,6 @@ export const chatRouter = router({
       throw new TRPCError({ message: "chat is only available to signed in users", code: 'UNAUTHORIZED' });
     }
     let session = await db.query.chatSession.findFirst({
-      with: {
-        messages: true
-      },
       where(fields, operators) {
         return operators.eq(fields.userId, userId)
       },
@@ -41,6 +40,33 @@ export const chatRouter = router({
       return session;
     }
   }),
+  getMessages: publicProcedure.input(z.string()).query(async ({input}) => {
+    let res = await db.query.chatMessage.findMany({
+      where(fields,operators) {
+        return operators.eq(fields.sessionId,input)
+      }
+    })
+    return res;
+  }),
+  clearChat: publicProcedure.mutation(async () => {
+    console.log("deleting session")
+    const { userId } = await auth();
+    if (userId == null) {
+      throw new TRPCError({ message: "chat is only available to signed in users", code: 'UNAUTHORIZED' });
+    }
+    let session = await db.query.chatSession.findFirst({
+      with: {
+        messages: true
+      },
+      where(fields, operators) {
+        return operators.eq(fields.userId, userId)
+      },
+    })
+    if (session != undefined) {
+      db.delete(chatMessage).where(eq(chatMessage.sessionId,session.id)).execute()
+    }
+
+  }),
   getSystemPrompt: publicProcedure.query(async () => {
     const row = await db.select().from(systemSettings).limit(1).then((r) => r[0])
     return row?.systemPropmt ?? ''