make meeting creation user level

src/app/actions/cancelMeeting.ts

@@ -0,0 +1,25 @@
+'use server'
+import { getGoogleCalendarClient, getGoogleCalendarId } from '~/server/googleCalendar'
+
+export async function cancelMeeting({ eventId }: { eventId: string }) {
+	try {
+		const calendar = getGoogleCalendarClient()
+
+		await calendar.events.delete({
+			calendarId: getGoogleCalendarId(),
+			eventId,
+		})
+
+		return {
+			success: true,
+			eventId,
+			message: 'Meeting removed from Gregor availability calendar.',
+		}
+	} catch (error) {
+		console.error('Failed to cancel meeting:', error)
+		return {
+			success: false,
+			error: 'Failed to remove the meeting from Gregor availability calendar.',
+		}
+	}
+}

src/app/actions/scheduleMeeting.ts

@@ -1,7 +1,34 @@
 'use server'
-import { clerkClient, auth } from '@clerk/nextjs/server'
-import { google } from 'googleapis'
 import { env } from '~/env'
+import { getGoogleCalendarClient, getGoogleCalendarId } from '~/server/googleCalendar'
+
+function googleCalendarDate(date: Date) {
+	return date.toISOString().replace(/[-:]|\.\d{3}/g, '')
+}
+
+function createGoogleCalendarTemplateLink({
+	title,
+	description,
+	startTime,
+	endTime,
+	gregorEmail,
+}: {
+	title: string
+	description: string
+	startTime: Date
+	endTime: Date
+	gregorEmail: string
+}) {
+	const params = new URLSearchParams({
+		action: 'TEMPLATE',
+		text: title,
+		dates: `${googleCalendarDate(startTime)}/${googleCalendarDate(endTime)}`,
+		details: description,
+		add: gregorEmail,
+	})
+
+	return `https://calendar.google.com/calendar/render?${params.toString()}`
+}
 
 export async function scheduleMeeting({
 	title,
@@ -19,56 +46,39 @@ export async function scheduleMeeting({
 	attendeeName?: string
 }) {
 	try {
-		const clerk = await clerkClient()
-		const userAuth = await auth()
-		const user = await clerk.users.getUser(userAuth.userId?userAuth.userId:"")
-		// Get admin's Google OAuth token to create the event on Gregor's calendar
-		const adminTokenResponse = await clerk.users.getUserOauthAccessToken(
-			env.ADMIN_USER_CLERK_ID,
-			'oauth_google',
-		)
-		const adminToken = adminTokenResponse.data[0]
-
-		if (!adminToken?.token) {
-			return { success: false, error: 'Admin Google Calendar not connected. Ensure the admin account is linked with Google and has calendar scope enabled.' }
-		}
-
-		// Try to resolve visitor's Google email for the invite
-		let visitorEmail: string | undefined = attendeeEmail
-		if (!visitorEmail) {
-			visitorEmail = user?.emailAddresses.at(0)?.emailAddress ?? undefined
-		}
-
-		const oAuth2Client = new google.auth.OAuth2()
-		oAuth2Client.setCredentials({ access_token: adminToken.token })
-		const calendar = google.calendar({ version: 'v3', auth: oAuth2Client })
+		const calendar = getGoogleCalendarClient()
 
 		const startTime = new Date(dateTime)
 		const endTime = new Date(startTime.getTime() + durationMinutes * 60 * 1000)
+		const attendeeNote = attendeeEmail
+			? `\n\nVisitor: ${attendeeName ?? 'Unknown'} <${attendeeEmail}>`
+			: ''
+		const eventDescription = `${description}${attendeeNote}`
 
-		const attendees: { email: string; displayName?: string }[] = []
-		if (visitorEmail) {
-			attendees.push({ email: visitorEmail, displayName: attendeeName })
-		}
-
-		const event = await calendar.events.insert({
-			calendarId: 'primary',
-			sendUpdates: 'all',
-			requestBody: {
+		const eventRequest = {
 			summary: title,
-				description,
+			description: eventDescription,
 			start: { dateTime: startTime.toISOString(), timeZone: 'UTC' },
 			end: { dateTime: endTime.toISOString(), timeZone: 'UTC' },
-				attendees,
-			},
-			sendNotifications: true
+		}
+		const event = await calendar.events.insert({
+			calendarId: getGoogleCalendarId(),
+			requestBody: eventRequest,
+		})
+
+		const addToCalendarLink = createGoogleCalendarTemplateLink({
+			title,
+			description,
+			startTime,
+			endTime,
+			gregorEmail: env.GREGOR_MEETING_EMAIL,
 		})
 
 		return {
 			success: true,
 			eventId: event.data.id,
-			htmlLink: event.data.htmlLink,
-			message: `Meeting "${title}" scheduled for ${startTime.toLocaleString()}${visitorEmail ? `. Invite sent to ${visitorEmail}.` : '.'}`,
+			addToCalendarLink,
+			message: `Meeting "${title}" scheduled for ${startTime.toLocaleString()}.${attendeeEmail ? ` Visitor email noted: ${attendeeEmail}.` : ''} The add-to-calendar link invites ${env.GREGOR_MEETING_EMAIL}.`,
 		}
 	} catch (error) {
 		console.error('Failed to schedule meeting:', error)

src/app/api/chat/route.ts

@@ -1,14 +1,12 @@
 import { auth } from '@clerk/nextjs/server'
 import { createOpenAI } from '@ai-sdk/openai'
-import { streamText, tool, convertToModelMessages, stepCountIs, type UIMessage } from 'ai'
-import { success, z } from 'zod'
+import { streamText, convertToModelMessages, stepCountIs, type UIMessage } from 'ai'
 import { eq, and } from 'drizzle-orm'
 import { env } from '~/env'
 import { db } from '~/server/db'
 import { chatSession, chatMessage } from '~/server/dbschema/schema'
 import { servTrpc } from '~/app/_trpc/ServerClient'
-import { scheduleMeeting } from '~/app/actions/scheduleMeeting'
-import currentTime from '~/app/actions/currentTime';
+import { createChatTools } from '~/server/ai/tools'
 
 const openai = createOpenAI({ apiKey: env.OPENAI_API_KEY })
 
@@ -31,7 +29,17 @@ export async function POST(req: Request) {
 
 	if (!session) return new Response('Session not found', { status: 404 })
 
-	const systemPrompt = await servTrpc.chat.getSystemPrompt() || 'You are an AI recruiter assistant.'
+	const configuredSystemPrompt = await servTrpc.chat.getSystemPrompt() || 'You are an AI recruiter assistant.'
+	const systemPrompt = `${configuredSystemPrompt}
+
+Runtime context:
+- Current server time: ${new Date().toISOString()}.
+- Default meeting timezone: Europe/Berlin.
+- For availability questions like "next open spot", call getAvailability once. It defaults to checking from now. Use nextAvailableSlot for the next opening, or the first item in availableSlots if needed. Do not call getAvailability again just to get more slots.
+- After scheduleMeeting succeeds, include only the returned addToCalendarLink for the visitor. Format it as a Markdown link like [Add this meeting to your Google Calendar](URL); do not paste the raw URL. Explain briefly that this link lets them add the meeting to their own calendar and invite Gregor. Do not mention internal Google Calendar event links.
+- You can remove meetings from Gregor's availability calendar with cancelMeeting only when you have the exact eventId from a previous scheduleMeeting result. If a visitor asks to reschedule and you have both the old eventId and a confirmed new slot, call cancelMeeting once for the old event and scheduleMeeting once for the new event. If you do not have the old eventId, ask for clarification instead of guessing.
+- When rescheduling, make clear that cancelMeeting only removes the old slot from Gregor's availability calendar. If the visitor already added the old link to their own calendar, they may need to remove that copy themselves.
+- Do not calculate or invent calendar availability yourself.`
 	const model = await servTrpc.chat.getModel()
 
 	// Save the latest user message
@@ -50,42 +58,14 @@ export async function POST(req: Request) {
 		model: openai(model),
 		system: systemPrompt,
 		messages: await convertToModelMessages(messages),
-		tools: {
-			scheduleMeeting: tool({
-				description: 'Schedule a meeting with Gregor Lohaus and add it to his Google Calendar',
-				inputSchema: z.object({
-					title: z.string().describe('Meeting title, make something up if not provided'),
-					description: z.string().describe('Meeting description / agenda,  make something up if not provided'),
-					dateTime: z
-						.string()
-						.describe(
-							'ISO 8601 datetime for the meeting start, e.g. 2025-04-01T10:00:00',
-						),
-					durationMinutes: z
-						.number()
-						.int()
-						.min(15)
-						.max(120)
-						.describe('Duration of the meeting in minutes, if none provided ask if 20 minutes is ok'),
-					attendeeEmail: z
-						.string()
-						.email()
-						.optional()
-						.describe('Optional Email of the visitor to invite (if provided)'),
-					attendeeName: z.string().optional().describe('Name of the visitor'),
-				}),
-				execute: async (input) => scheduleMeeting({ ...input }),
-			}),
-			getCurrentUnixTime: tool({
-				description: 'Get the current unix time to reference for meeting dates',
-				inputSchema: z.object({
-					none: z.string().optional().describe("no inputs are needed")
-				}),
-				execute: async () => currentTime()
-			})
-		},
-		stopWhen: stepCountIs(5),
+		tools: createChatTools(),
+		stopWhen: stepCountIs(3),
 		onFinish: async ({ text, finishReason }) => {
+			console.log('[ai:chat:onFinish]', {
+				finishReason,
+				hasText: Boolean(text),
+				textLength: text.length,
+			})
 			if (text && finishReason === 'stop') {
 				await db.insert(chatMessage).values({
 					sessionId,

src/app/chat/_components/AssistantMessage.tsx

@@ -1,6 +1,25 @@
 import type { UIMessage } from "ai";
 import { ClientMdx } from "~/components/ClientMdx";
 
+function toolLabel(type: string) {
+	switch (type) {
+		case "tool-searchSiteContent":
+			return "Searching site content";
+		case "tool-getRelevantExperience":
+			return "Finding relevant experience";
+		case "tool-getProjectDetails":
+			return "Loading project details";
+		case "tool-getAvailability":
+			return "Checking availability";
+		case "tool-cancelMeeting":
+			return "Removing meeting";
+		case "tool-getCurrentUnixTime":
+			return "Checking current time";
+		default:
+			return "Using tool";
+	}
+}
+
 export const AssistantMessage = (props: { message: UIMessage }) => {
   let message = props.message;
   return (
@@ -10,7 +29,7 @@ export const AssistantMessage = (props: { message: UIMessage }) => {
     >
       <div
         className=
-        'max-w-[80%] px-4 py-2 text-sm space-y-2 bg-muted'
+        'max-w-[80%] min-w-0 px-4 py-2 text-sm space-y-2 bg-muted break-words [overflow-wrap:anywhere] [&_a]:break-all [&_pre]:max-w-full [&_pre]:overflow-x-auto'
       >
         {message.parts.map((part, i) => {
           if (part.type === 'text') {
@@ -23,7 +42,7 @@ export const AssistantMessage = (props: { message: UIMessage }) => {
 	              type: 'tool-scheduleMeeting'
 	              state: string
 	              input: unknown
-              output?: { success: boolean; message?: string; htmlLink?: string; error?: string }
+	              output?: { success: boolean; error?: string }
 	            }
             if (toolPart.state === 'input-available' || toolPart.state === 'input-streaming') {
               return (
@@ -34,29 +53,64 @@ export const AssistantMessage = (props: { message: UIMessage }) => {
 	            }
 	            if (toolPart.state === 'output-available' && toolPart.output) {
 	              const result = toolPart.output
+	              if (result.success) return null
 	              return (
 	                <div key={i} className="text-xs mt-1 p-2 bg-background/20 rounded">
-                  {result.success ? (
-                    <span>
-                      ✓ {result.message}{' '}
-                      {result.htmlLink && (
-                        <a
-                          href={result.htmlLink}
-                          target="_blank"
-                          rel="noopener noreferrer"
-                          className="underline"
-                        >
-                          View event
-                        </a>
-                      )}
-                    </span>
-                  ) : (
 	                  <span>✗ {result.error}</span>
-                  )}
                 </div>
 	              )
 	            }
 	          }
+	          if (part.type === 'tool-cancelMeeting') {
+	            const toolPart = part as unknown as {
+	              type: 'tool-cancelMeeting'
+	              state: string
+	              output?: { success: boolean; error?: string }
+	            }
+	            if (toolPart.state === 'input-available' || toolPart.state === 'input-streaming') {
+	              return (
+	                <p key={i} className="text-xs opacity-70 italic">
+	                  Removing meeting…
+	                </p>
+	              )
+	            }
+	            if (toolPart.state === 'output-available' && toolPart.output) {
+	              if (toolPart.output.success) return null
+	              return (
+	                <div key={i} className="text-xs mt-1 p-2 bg-background/20 rounded">
+	                  <span>✗ {toolPart.output.error}</span>
+	                </div>
+	              )
+	            }
+	          }
+	          if (part.type.startsWith('tool-')) {
+	            const toolPart = part as unknown as {
+	              type: string
+	              state: string
+	              output?: { success?: boolean; results?: unknown[]; matches?: unknown[]; availableSlots?: unknown[]; project?: unknown; error?: string }
+	            }
+	            if (toolPart.state === 'input-available' || toolPart.state === 'input-streaming') {
+	              return (
+	                <p key={i} className="text-xs opacity-70 italic">
+	                  {toolLabel(toolPart.type)}...
+	                </p>
+	              )
+	            }
+	            if (toolPart.state === 'output-available') {
+	              const count = toolPart.output?.results?.length
+	                ?? toolPart.output?.matches?.length
+	                ?? toolPart.output?.availableSlots?.length
+	              return (
+	                <p key={i} className="text-xs opacity-70 italic">
+	                  {toolPart.output?.success === false
+	                    ? (toolPart.output.error ?? `${toolLabel(toolPart.type)} failed`)
+	                    : count != null
+	                      ? `${toolLabel(toolPart.type)} complete (${count})`
+	                      : `${toolLabel(toolPart.type)} complete`}
+	                </p>
+	              )
+	            }
+	          }
 	          return null
 	        })}
       </div>

src/app/chat/_components/ChatInterface.tsx

@@ -1,5 +1,5 @@
 'use client'
-import { useState, useEffect } from 'react'
+import { useState, useEffect, useRef } from 'react'
 import { useChat } from '@ai-sdk/react'
 import { DefaultChatTransport, type UIMessage } from 'ai'
 import { Button } from '~/components/ui/button'
@@ -54,7 +54,7 @@ function addInitMessage(messageArray: UIMessage[]) {
 			role: 'assistant',
 			parts: [{
 				type: 'text',
-				text: "Hi im gregors ai assistant,you can ask me to provide general information or to schedule a meeting."
+				text: "Hi, I'm Gregor's AI assistant. Ask me about his experience, projects, blog posts, or availability for a meeting."
 			}],
 		})
 	}
@@ -83,14 +83,21 @@ function AuthenticatedChatInterface({ dbMessages, sessionId }: ChatInterfaceProp
 		sendMessage({ text })
 	}
 	const gsapContext = useGsapContext()
+	const didInitialScroll = useRef(false)
 	useEffect(() => {
-		let scroller = gsapContext?.getScroller()
-		if (scroller instanceof Window) {
-			return;
+		const scroller = gsapContext?.getScroller()
+		if (!scroller || scroller instanceof Window) {
+			return
 		}
-		console.log(scroller?.scrollHeight)
-		scroller?.scrollTo({ behavior: 'smooth', top: scroller.scrollHeight })
-	}, [messages])
+		// Jump instantly on first open so the chat starts pinned to the bottom;
+		// animate subsequent updates. Defer a frame so the messages have laid out
+		// (and any streaming content has grown) before we measure scrollHeight.
+		const behavior: ScrollBehavior = didInitialScroll.current ? 'smooth' : 'auto'
+		didInitialScroll.current = true
+		requestAnimationFrame(() => {
+			scroller.scrollTo({ behavior, top: scroller.scrollHeight })
+		})
+	}, [messages, status])
 	return (
 		<div className="flex flex-col h-full">
 			{messages &&
@@ -114,7 +121,7 @@ function AuthenticatedChatInterface({ dbMessages, sessionId }: ChatInterfaceProp
 				</div>
 			)}
 
-			<div className="p-4 border-t flex flex-row gap-2">
+			<div className="p-4 border-t flex flex-row gap-2 shrink-0">
 				<Textarea
 					name='message'
 					value={input}

src/app/chat/_components/Messages.tsx

@@ -6,7 +6,7 @@ import { ScrollArea } from '~/components/ui/scroll-area';
 import { memo } from 'react';
 const Messages = memo(({messages,status}: { messages: UIMessage[],status:ChatStatus}) => {
   return (
-    <ScrollArea data-scroller-priority='1' className="w-full h-[90%] max-w-4xl mx-auto">
+    <ScrollArea data-scroller-priority='1' className="w-full flex-1 min-h-0 max-w-4xl mx-auto">
       {messages.map((message, i) => (
         <Card.AnimatedCard scrollOnly={true} key={i}>
           <Card.CardContent>

src/app/chat/_components/UserMessage.tsx

@@ -14,7 +14,7 @@ export const UserMessage = (props:{message: UIMessage}) => {
     >
       <div
         className=
-        'max-w-[80%] px-4 py-2 text-sm space-y-2 bg-primary'
+        'max-w-[80%] min-w-0 px-4 py-2 text-sm space-y-2 bg-primary break-words whitespace-pre-wrap [overflow-wrap:anywhere]'
       >
       {message}
       </div>

src/app/chat/page.tsx

@@ -9,11 +9,11 @@ export default function ChatPage() {
 	const {messages,session,isLoading,error} = useMessages()
 	useTimeLine(messages)
 	return (
-		<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 px-10 lg:px-0 w-full h-full max-w-4xl mx-auto pt-10 pb-4">
 					<AnimatedPageTitle position={0}>
 						<span>Talk To My </span> <span> AI-Assistant</span>
 					</AnimatedPageTitle>
-					<div className='flex items-center h-[80%] w-full my-auto w-full'>
+					<div className='flex flex-1 min-h-0 w-full'>
 					{!isLoading &&
 					<ChatInterface sessionId={session?.id} dbMessages={messages ?? []}/>
 					}

src/app/layout.tsx

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

src/components/mdx-components.tsx

@@ -100,12 +100,19 @@ function PullQuote({ children }: { children: ReactNode }) {
 }
 
 function ExternalLink(props: ComponentPropsWithoutRef<"a">) {
-  const href = props.href ?? "";
-  const isExternal = /^https?:\/\//.test(href);
+  const { className, ...rest } = props;
 
-  if (!isExternal) return <a {...props} />;
-
-  return <a {...props} target="_blank" rel="noreferrer" />;
+  return (
+    <a
+      {...rest}
+      target="_blank"
+      rel="noreferrer"
+      className={cn(
+        "text-sky-600 underline underline-offset-4 hover:text-sky-700 dark:text-sky-400 dark:hover:text-sky-300",
+        className,
+      )}
+    />
+  );
 }
 
 const blockComponents = new Set<unknown>([Callout, Figure, PullQuote, TagList]);

src/env.js

@@ -31,6 +31,10 @@ export const env = createEnv({
 		CLERK_SECRET_KEY: z.string(),
 		ADMIN_USER_CLERK_ID: z.string(),
 		OPENAI_API_KEY: z.string(),
+		GOOGLE_SERVICE_ACCOUNT_EMAIL: z.string().email(),
+		GOOGLE_SERVICE_ACCOUNT_PRIVATE_KEY: z.string(),
+		GOOGLE_CALENDAR_ID: z.string(),
+		GREGOR_MEETING_EMAIL: z.string().email(),
 		NODE_ENV: z
 			.enum(["development", "test", "production"])
 			.default("development"),
@@ -72,6 +76,10 @@ export const env = createEnv({
 		POSTGRES_PRISMA_URL: process.env.POSTGRES_PRISMA_URL,
 		ADMIN_USER_CLERK_ID: process.env.ADMIN_USER_CLERK_ID,
 		OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+		GOOGLE_SERVICE_ACCOUNT_EMAIL: process.env.GOOGLE_SERVICE_ACCOUNT_EMAIL,
+		GOOGLE_SERVICE_ACCOUNT_PRIVATE_KEY: process.env.GOOGLE_SERVICE_ACCOUNT_PRIVATE_KEY,
+		GOOGLE_CALENDAR_ID: process.env.GOOGLE_CALENDAR_ID,
+		GREGOR_MEETING_EMAIL: process.env.GREGOR_MEETING_EMAIL,
 		NEXT_PUBLIC_ADMIN_USER_CLERK_ID: process.env.NEXT_PUBLIC_ADMIN_USER_CLERK_ID,
 		CLERK_SECRET_KEY: process.env.CLERK_SECRET_KEY,
 		NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY: process.env.NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY,

src/server/ai/tools.ts

@@ -0,0 +1,586 @@
+import "server-only";
+
+import { tool } from "ai";
+import { desc } from "drizzle-orm";
+import { z } from "zod";
+import { cancelMeeting } from "~/app/actions/cancelMeeting";
+import { scheduleMeeting } from "~/app/actions/scheduleMeeting";
+import { db } from "~/server/db";
+import { blogPost, music } from "~/server/dbschema/schema";
+import { getGoogleCalendarClient, getGoogleCalendarId } from "~/server/googleCalendar";
+
+const contentTypeSchema = z.enum(["cv", "project", "blog", "music"]);
+
+type ContentType = z.infer<typeof contentTypeSchema>;
+
+type SearchResult = {
+	type: ContentType;
+	title: string;
+	snippet: string;
+	url: string;
+	score: number;
+	metadata?: Record<string, unknown>;
+};
+
+type ProjectWithStack = Awaited<ReturnType<typeof loadProjects>>[number];
+
+function stripMarkup(value: string | null | undefined) {
+	return (value ?? "")
+		.replace(/```[\s\S]*?```/g, " ")
+		.replace(/`([^`]+)`/g, "$1")
+		.replace(/<[^>]+>/g, " ")
+		.replace(/[#*_~[\]()>-]/g, " ")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+function tokenize(value: string) {
+	return Array.from(new Set(value.toLowerCase().match(/[a-z0-9+#.-]+/g) ?? []));
+}
+
+function scoreText(query: string, title: string, body: string, extraTerms: string[] = []) {
+	const normalizedQuery = query.trim().toLowerCase();
+	const titleLower = title.toLowerCase();
+	const bodyLower = body.toLowerCase();
+	const tokens = tokenize(query);
+	let score = 0;
+
+	if (normalizedQuery && titleLower.includes(normalizedQuery)) score += 40;
+	if (normalizedQuery && bodyLower.includes(normalizedQuery)) score += 20;
+
+	for (const token of tokens) {
+		if (titleLower.includes(token)) score += 12;
+		if (bodyLower.includes(token)) score += 6;
+		if (extraTerms.some((term) => term.toLowerCase() === token)) score += 10;
+	}
+
+	return score;
+}
+
+const projectCatalogTerms = new Set(["project", "projects", "portfolio", "work"]);
+const genericQuestionTerms = new Set([
+	"a",
+	"about",
+	"all",
+	"any",
+	"are",
+	"can",
+	"current",
+	"do",
+	"give",
+	"have",
+	"list",
+	"me",
+	"of",
+	"on",
+	"show",
+	"site",
+	"tell",
+	"the",
+	"there",
+	"these",
+	"this",
+	"what",
+	"which",
+	"you",
+]);
+
+function isProjectCatalogQuery(query: string) {
+	const tokens = tokenize(query);
+	if (!tokens.some((token) => projectCatalogTerms.has(token))) return false;
+	return tokens.every((token) => projectCatalogTerms.has(token) || genericQuestionTerms.has(token));
+}
+
+function snippet(value: string, query: string, maxLength = 240) {
+	const text = stripMarkup(value);
+	if (text.length <= maxLength) return text;
+
+	const tokens = tokenize(query);
+	const lower = text.toLowerCase();
+	const firstMatch = tokens
+		.map((token) => lower.indexOf(token))
+		.filter((index) => index >= 0)
+		.sort((a, b) => a - b)[0] ?? 0;
+	const start = Math.max(0, firstMatch - 60);
+	const excerpt = text.slice(start, start + maxLength).trim();
+
+	return `${start > 0 ? "..." : ""}${excerpt}${start + maxLength < text.length ? "..." : ""}`;
+}
+
+function uniqueByUrl(results: SearchResult[]) {
+	const seen = new Set<string>();
+	return results.filter((result) => {
+		const key = `${result.type}:${result.url}:${result.title}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+
+async function loadCvEntries() {
+	const categories = await db.query.cvCategory.findMany({
+		orderBy: (fields, { asc }) => [asc(fields.layoutPosition), asc(fields.name)],
+		with: {
+			cvEntry: {
+				orderBy: (fields, { desc }) => [desc(fields.toTime), desc(fields.fromTime)],
+			},
+		},
+	});
+
+	return categories.flatMap((category) =>
+		category.cvEntry.map((entry) => ({
+			...entry,
+			categoryName: category.name ?? "CV",
+		})),
+	);
+}
+
+async function loadProjects() {
+	return db.query.project.findMany({
+		orderBy: (fields, { asc }) => [asc(fields.orderPos), asc(fields.title), asc(fields.id)],
+		with: {
+			techStack: true,
+		},
+	});
+}
+
+async function buildSearchResults(query: string, types: ContentType[]) {
+	const selected = new Set(types);
+	const results: SearchResult[] = [];
+
+	if (selected.has("cv")) {
+		const entries = await loadCvEntries();
+		for (const entry of entries) {
+			const body = stripMarkup(`${entry.categoryName} ${entry.description ?? ""}`);
+			const score = scoreText(query, entry.title, body);
+			if (score > 0 || !query.trim()) {
+				results.push({
+					type: "cv",
+					title: entry.title,
+					snippet: snippet(body, query),
+					url: "/cv",
+					score,
+					metadata: {
+						category: entry.categoryName,
+						fromTime: entry.fromTime,
+						toTime: entry.toTime,
+					},
+				});
+			}
+		}
+	}
+
+	if (selected.has("project")) {
+		const projects = await loadProjects();
+		const catalogQuery = isProjectCatalogQuery(query);
+		for (const [index, item] of projects.entries()) {
+			const stackItems = item.techStack?.stackItems ?? [];
+			const body = stripMarkup(`${item.description ?? ""} ${stackItems.join(" ")}`);
+			const score = catalogQuery ? 1000 - index : scoreText(query, item.title, body, stackItems);
+			if (score > 0 || !query.trim() || catalogQuery) {
+				results.push({
+					type: "project",
+					title: item.title,
+					snippet: snippet(body || item.title, query),
+					url: `/projects#${item.id}`,
+					score,
+					metadata: {
+						id: item.id,
+						stackItems,
+						sourceType: item.sourceType,
+						releaseStatus: item.releaseStatus,
+						sourceLink: item.sourceLink,
+						releaseLink: item.releaseLink,
+					},
+				});
+			}
+		}
+	}
+
+	if (selected.has("blog")) {
+		const posts = await db
+			.select({
+				slug: blogPost.slug,
+				title: blogPost.title,
+				date: blogPost.date,
+				description: blogPost.description,
+				tags: blogPost.tags,
+			})
+			.from(blogPost)
+			.orderBy(desc(blogPost.date), desc(blogPost.createdAt));
+
+		for (const post of posts) {
+			const tags = post.tags ?? [];
+			const body = stripMarkup(`${post.description ?? ""} ${tags.join(" ")}`);
+			const score = scoreText(query, post.title, body, tags);
+			if (score > 0 || !query.trim()) {
+				results.push({
+					type: "blog",
+					title: post.title,
+					snippet: snippet(body || post.title, query),
+					url: `/blog/${post.slug}`,
+					score,
+					metadata: {
+						slug: post.slug,
+						date: post.date,
+						tags,
+					},
+				});
+			}
+		}
+	}
+
+	if (selected.has("music")) {
+		const tracks = await db.select().from(music).orderBy(desc(music.createdAt));
+		for (const track of tracks) {
+			const body = stripMarkup(track.description);
+			const score = scoreText(query, track.title, body);
+			if (score > 0 || !query.trim()) {
+				results.push({
+					type: "music",
+					title: track.title,
+					snippet: snippet(body || track.fileName, query),
+					url: "/music",
+					score,
+					metadata: {
+						id: track.id,
+						fileName: track.fileName,
+						hasStream: Boolean(track.streamUrl),
+					},
+				});
+			}
+		}
+	}
+
+	return uniqueByUrl(results).sort((a, b) => b.score - a.score || a.title.localeCompare(b.title));
+}
+
+function projectMatches(projectItem: ProjectWithStack, idOrTitle: string) {
+	const normalized = idOrTitle.trim().toLowerCase();
+	const title = projectItem.title.toLowerCase();
+	return projectItem.id === idOrTitle || title === normalized || title.includes(normalized);
+}
+
+function matchedTerms(text: string, terms: string[]) {
+	const lower = text.toLowerCase();
+	return terms.filter((term) => lower.includes(term.toLowerCase()));
+}
+
+function parseDate(value: string | undefined, fallback: Date) {
+	if (!value?.trim()) return fallback;
+	const date = new Date(value);
+	return Number.isNaN(date.getTime()) ? fallback : date;
+}
+
+function safeTimeZone(value: string | undefined) {
+	const timeZone = value?.trim() || "Europe/Berlin";
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone }).format(new Date());
+		return timeZone;
+	} catch {
+		return "Europe/Berlin";
+	}
+}
+
+function isLikelyEmail(value: string) {
+	return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+}
+
+function overlaps(
+	start: Date,
+	end: Date,
+	busy: Array<{ start: Date; end: Date }>,
+) {
+	return busy.some((item) => start < item.end && end > item.start);
+}
+
+function getZonedParts(date: Date, timeZone: string) {
+	const formatter = new Intl.DateTimeFormat("en-US", {
+		timeZone,
+		weekday: "short",
+		hourCycle: "h23",
+		hour: "2-digit",
+		minute: "2-digit",
+	});
+	const parts = Object.fromEntries(formatter.formatToParts(date).map((part) => [part.type, part.value]));
+	return {
+		weekday: parts.weekday ?? "",
+		hour: Number(parts.hour ?? 0),
+		minute: Number(parts.minute ?? 0),
+	};
+}
+
+function isInsideWorkingHours(start: Date, end: Date, timeZone: string, workdayStartHour: number, workdayEndHour: number) {
+	const startParts = getZonedParts(start, timeZone);
+	const endParts = getZonedParts(end, timeZone);
+	const weekend = startParts.weekday === "Sat" || startParts.weekday === "Sun";
+	const startMinutes = startParts.hour * 60 + startParts.minute;
+	const endMinutes = endParts.hour * 60 + endParts.minute;
+
+	return !weekend && startMinutes >= workdayStartHour * 60 && endMinutes <= workdayEndHour * 60;
+}
+
+function availabilitySlots({
+	rangeStart,
+	rangeEnd,
+	busy,
+	durationMinutes,
+	timeZone,
+	workdayStartHour,
+	workdayEndHour,
+}: {
+	rangeStart: Date;
+	rangeEnd: Date;
+	busy: Array<{ start: Date; end: Date }>;
+	durationMinutes: number;
+	timeZone: string;
+	workdayStartHour: number;
+	workdayEndHour: number;
+}) {
+	const slots: Array<{ start: string; end: string }> = [];
+	const stepMinutes = 30;
+	const durationMs = durationMinutes * 60 * 1000;
+	const cursor = new Date(Math.ceil(rangeStart.getTime() / (stepMinutes * 60 * 1000)) * stepMinutes * 60 * 1000);
+
+	while (cursor.getTime() + durationMs <= rangeEnd.getTime() && slots.length < 10) {
+		const end = new Date(cursor.getTime() + durationMs);
+		if (
+			isInsideWorkingHours(cursor, end, timeZone, workdayStartHour, workdayEndHour)
+			&& !overlaps(cursor, end, busy)
+		) {
+			slots.push({ start: cursor.toISOString(), end: end.toISOString() });
+		}
+		cursor.setMinutes(cursor.getMinutes() + stepMinutes);
+	}
+
+	return slots;
+}
+
+function logAvailability(requestId: string, message: string, data?: Record<string, unknown>) {
+	console.log(`[ai:getAvailability:${requestId}] ${message}`, data ?? "");
+}
+
+export function createChatTools() {
+	return {
+		scheduleMeeting: tool({
+			description: "Schedule a meeting with Gregor Lohaus and add it to his Google Calendar. Use getAvailability first when the user asks for a meeting at a flexible or uncertain time.",
+			inputSchema: z.object({
+				title: z.string().describe("Meeting title, make something up if not provided"),
+				description: z.string().describe("Meeting description / agenda, make something up if not provided"),
+				dateTime: z
+					.string()
+					.describe("ISO 8601 datetime for the meeting start, e.g. 2026-06-18T10:00:00+02:00"),
+				durationMinutes: z
+					.number()
+					.int()
+					.min(15)
+					.max(120)
+					.describe("Duration of the meeting in minutes, if none provided ask if 20 minutes is ok"),
+				attendeeEmail: z
+					.string()
+					.optional()
+					.describe("Optional email of the visitor to invite, if provided"),
+				attendeeName: z.string().optional().describe("Name of the visitor"),
+			}),
+			execute: async (input) => {
+				if (input.attendeeEmail && !isLikelyEmail(input.attendeeEmail)) {
+					return {
+						success: false,
+						error: "The attendee email does not look valid. Ask the visitor to provide a valid email address before scheduling.",
+					};
+				}
+
+				return scheduleMeeting({ ...input });
+			},
+		}),
+		cancelMeeting: tool({
+			description: "Remove a previously scheduled meeting from Gregor's dedicated availability calendar. Use only when you have the exact eventId returned by scheduleMeeting.",
+			inputSchema: z.object({
+				eventId: z.string().min(1).describe("Google Calendar event id returned by a previous scheduleMeeting tool call."),
+			}),
+			execute: async ({ eventId }) => cancelMeeting({ eventId }),
+		}),
+		searchSiteContent: tool({
+			description: "Search Gregor Lohaus's own website content across CV entries, projects, blog posts, and music. Use this for questions about Gregor's work, skills, writing, projects, or site content. For broad questions about Gregor's projects, use types ['project'] so the tool returns the project catalog.",
+			inputSchema: z.object({
+				query: z.string().describe("Search query, skill, technology, topic, or phrase."),
+				types: z.array(contentTypeSchema).optional().describe("Optional content types to search. Omit to search all site content."),
+				limit: z.number().int().min(1).max(12).optional().describe("Maximum number of results to return."),
+			}),
+			execute: async ({ query, types, limit }) => {
+				const results = await buildSearchResults(query, types?.length ? types : ["cv", "project", "blog", "music"]);
+				return {
+					success: true,
+					query,
+					results: results.slice(0, limit ?? 8).map(({ score, ...result }) => result),
+				};
+			},
+		}),
+		getRelevantExperience: tool({
+			description: "Find Gregor's most relevant CV entries and projects for a role, skill set, seniority, or domain. Use this for recruiter-style qualification questions.",
+			inputSchema: z.object({
+				role: z.string().optional().describe("Role or job title, such as full-stack engineer or React Native developer."),
+				skills: z.array(z.string()).optional().describe("Technologies, tools, or skills to match."),
+				domain: z.string().optional().describe("Product or business domain to match, if any."),
+				seniority: z.string().optional().describe("Seniority or responsibility level to match, if any."),
+				limit: z.number().int().min(1).max(10).optional().describe("Maximum matching entries to return."),
+			}),
+			execute: async ({ role, skills, domain, seniority, limit }) => {
+				const terms = [role, domain, seniority, ...(skills ?? [])].filter((value): value is string => Boolean(value?.trim()));
+				const query = terms.join(" ");
+				const results = await buildSearchResults(query, ["cv", "project"]);
+				const selected = results.slice(0, limit ?? 6);
+
+				return {
+					success: true,
+					query,
+					matches: selected.map(({ score, ...result }) => ({
+						...result,
+						matchedTerms: matchedTerms(`${result.title} ${result.snippet} ${(result.metadata?.stackItems as string[] | undefined)?.join(" ") ?? ""}`, terms),
+						whyRelevant: result.type === "project"
+							? "Project match based on title, description, and technology stack."
+							: "CV match based on experience title, category, and description.",
+					})),
+				};
+			},
+		}),
+		getProjectDetails: tool({
+			description: "Get detailed information for one of Gregor's projects, including description, stack, source link, release link, and project page URL.",
+			inputSchema: z.object({
+				idOrTitle: z.string().min(1).describe("Project id, exact title, or partial project title."),
+			}),
+			execute: async ({ idOrTitle }) => {
+				const projects = await loadProjects();
+				const found = projects.find((item) => projectMatches(item, idOrTitle));
+
+				if (!found) {
+					return {
+						success: false,
+						error: `No project matched "${idOrTitle}".`,
+						suggestions: projects.slice(0, 5).map((item) => ({
+							id: item.id,
+							title: item.title,
+							url: `/projects#${item.id}`,
+						})),
+					};
+				}
+
+				return {
+					success: true,
+					project: {
+						id: found.id,
+						title: found.title,
+						description: stripMarkup(found.description),
+						sourceType: found.sourceType,
+						sourceLink: found.sourceLink,
+						releaseStatus: found.releaseStatus,
+						releaseLink: found.releaseLink,
+						stackItems: found.techStack?.stackItems ?? [],
+						url: `/projects#${found.id}`,
+					},
+				};
+			},
+		}),
+		getAvailability: tool({
+			description: "Check Gregor's Google Calendar availability and suggest open meeting slots. Use this directly for questions like 'when is the next open spot?' or 'what times are available?'. If no date range is provided, it checks from now. Use before scheduling when the requested time is flexible.",
+			inputSchema: z.object({
+				fromDateTime: z.string().optional().describe("ISO 8601 range start. Defaults to now."),
+				toDateTime: z.string().optional().describe("ISO 8601 range end. Defaults to 14 days after the range start."),
+				durationMinutes: z.number().int().min(15).max(120).optional().describe("Desired meeting duration. Defaults to 30 minutes."),
+				timeZone: z.string().optional().describe("IANA time zone for working-hours filtering. Defaults to Europe/Berlin."),
+				workdayStartHour: z.number().int().min(0).max(23).optional().describe("Earliest local start hour. Defaults to 9."),
+				workdayEndHour: z.number().int().min(1).max(24).optional().describe("Latest local end hour. Defaults to 17."),
+			}),
+			execute: async (input) => {
+				const requestId = crypto.randomUUID();
+				logAvailability(requestId, "start", {
+					input,
+				});
+
+				const durationMinutes = input.durationMinutes ?? 30;
+				const timeZone = safeTimeZone(input.timeZone);
+				const workdayStartHour = input.workdayStartHour ?? 9;
+				const workdayEndHour = Math.max(input.workdayEndHour ?? 17, workdayStartHour + 1);
+				const rangeStart = parseDate(input.fromDateTime, new Date());
+				const defaultEnd = new Date(rangeStart.getTime() + 14 * 24 * 60 * 60 * 1000);
+				const requestedEnd = parseDate(input.toDateTime, defaultEnd);
+				const maxEnd = new Date(rangeStart.getTime() + 31 * 24 * 60 * 60 * 1000);
+				const rangeEnd = requestedEnd <= rangeStart ? defaultEnd : requestedEnd > maxEnd ? maxEnd : requestedEnd;
+				logAvailability(requestId, "resolved range", {
+					durationMinutes,
+					timeZone,
+					workdayStartHour,
+					workdayEndHour,
+					rangeStart: rangeStart.toISOString(),
+					rangeEnd: rangeEnd.toISOString(),
+				});
+
+				const calendar = getGoogleCalendarClient();
+				const calendarId = getGoogleCalendarId();
+				logAvailability(requestId, "service account calendar ready", {
+					calendarId,
+				});
+
+				let busy: Array<{ start: Date; end: Date }>;
+				try {
+					logAvailability(requestId, "freebusy request");
+					const response = await calendar.freebusy.query({
+						requestBody: {
+							timeMin: rangeStart.toISOString(),
+							timeMax: rangeEnd.toISOString(),
+							timeZone,
+							items: [{ id: calendarId }],
+						},
+					});
+					busy = (response.data.calendars?.[calendarId]?.busy ?? [])
+						.map((item) => ({
+							start: parseDate(item.start ?? undefined, rangeStart),
+							end: parseDate(item.end ?? undefined, rangeStart),
+						}))
+						.filter((item) => item.end > item.start);
+					logAvailability(requestId, "freebusy response", {
+						busyCount: busy.length,
+					});
+				} catch (error) {
+					console.error(`[ai:getAvailability:${requestId}] freebusy failed`, error);
+					return {
+						success: false,
+						error: "Failed to read Gregor's Google Calendar availability.",
+					};
+				}
+
+				const availableSlots = availabilitySlots({
+					rangeStart,
+					rangeEnd,
+					busy,
+					durationMinutes,
+					timeZone,
+					workdayStartHour,
+					workdayEndHour,
+				});
+				logAvailability(requestId, "complete", {
+					busyCount: busy.length,
+					availableSlotCount: availableSlots.length,
+					firstAvailableSlot: availableSlots[0],
+				});
+				const nextAvailableSlot = availableSlots[0] ?? null;
+
+				return {
+					success: true,
+					range: {
+						start: rangeStart.toISOString(),
+						end: rangeEnd.toISOString(),
+						timeZone,
+					},
+					durationMinutes,
+					busy: busy.map((item) => ({
+						start: item.start.toISOString(),
+						end: item.end.toISOString(),
+					})),
+					nextAvailableSlot,
+					availableSlots,
+				};
+			},
+		}),
+	};
+}

src/server/googleCalendar.ts

@@ -0,0 +1,20 @@
+import "server-only";
+
+import { google } from "googleapis";
+import { env } from "~/env";
+
+const calendarScope = "https://www.googleapis.com/auth/calendar";
+
+export function getGoogleCalendarClient() {
+	const auth = new google.auth.JWT({
+		email: env.GOOGLE_SERVICE_ACCOUNT_EMAIL,
+		key: env.GOOGLE_SERVICE_ACCOUNT_PRIVATE_KEY.replace(/\\n/g, "\n"),
+		scopes: [calendarScope],
+	});
+
+	return google.calendar({ version: "v3", auth });
+}
+
+export function getGoogleCalendarId() {
+	return env.GOOGLE_CALENDAR_ID;
+}