create-inox-app 0.1.0

package/dist/templates/presets/ai-chat-app/apps/web/app/api/chat/route.ts

@@ -0,0 +1,266 @@
+import {
+  convertToModelMessages,
+  createUIMessageStream,
+  createUIMessageStreamResponse,
+  streamText,
+  type UIMessage,
+} from "ai";
+import { eq } from "drizzle-orm";
+import { startActiveObservation } from "@langfuse/tracing";
+import { nanoid } from "nanoid";
+import { after } from "next/server";
+import { z } from "zod";
+
+import { langfuseSpanProcessor } from "@/instrumentation";
+import { auth } from "@/lib/auth";
+import { db } from "@/lib/db";
+import { chatMessage, chatSession } from "@/lib/db/schema";
+import { logger } from "@/lib/logger";
+import { openrouter } from "@/lib/openrouter";
+import { inputGuardrail } from "./input-guardrail";
+
+const MODEL_ID = "gpt-oss-120b";
+const TITLE_MODEL_ID = "gpt-oss-20b";
+
+const model = openrouter(MODEL_ID, {
+  extraBody: {
+    provider: { order: ["Cerebras", "Groq"], allow_fallbacks: true },
+  },
+});
+
+const titleModel = openrouter(TITLE_MODEL_ID);
+
+const chatRequestSchema = z.object({
+  messages: z.array(
+    z.looseObject({
+      id: z.string(),
+      role: z.enum(["user", "assistant", "system"]),
+      parts: z.array(z.looseObject({ type: z.string() })),
+    }),
+  ),
+  chatId: z.string(),
+});
+
+const extractLastUserText = (messages: UIMessage[]): string | null => {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg?.role !== "user") continue;
+
+    for (const part of msg.parts) {
+      if (part.type === "text") return part.text;
+    }
+  }
+  return null;
+};
+
+const extractLastUserMessage = (messages: UIMessage[]): UIMessage | null => {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "user") return messages[i];
+  }
+  return null;
+};
+
+export const POST = async (req: Request): Promise<Response> => {
+  const start = performance.now();
+  const ctx: Record<string, unknown> = {
+    request_id: nanoid(),
+    method: req.method,
+    path: "/api/chat",
+    model: MODEL_ID,
+    outcome: "error",
+  };
+
+  try {
+    const session = await auth.api.getSession({ headers: req.headers });
+    if (!session) {
+      ctx.outcome = "unauthorized";
+      return new Response("Unauthorized", { status: 401 });
+    }
+    ctx.user_id = session.user.id;
+
+    const body = await req.json();
+    const parsed = chatRequestSchema.safeParse(body);
+    if (!parsed.success) {
+      ctx.outcome = "invalid_request";
+      return new Response("Invalid request body", { status: 400 });
+    }
+
+    const { messages, chatId } = parsed.data as { messages: UIMessage[]; chatId: string };
+    ctx.message_count = messages.length;
+    ctx.chat_id = chatId;
+
+    const userText = extractLastUserText(messages);
+    if (userText) {
+      ctx.user_text_prefix = userText.slice(0, 100);
+    }
+
+    const response = await startActiveObservation(
+      "chat-handler",
+      async (span) => {
+        span.updateTrace({
+          name: "chat-response",
+          userId: session.user.id,
+          sessionId: chatId,
+          input: userText,
+          metadata: { messageCount: messages.length },
+        });
+        span.update({ input: userText });
+
+        if (userText) {
+          const guardrailStart = performance.now();
+          const guardrail = await inputGuardrail(userText);
+          ctx.guardrail_duration_ms = Math.round(performance.now() - guardrailStart);
+          ctx.guardrail_safe = guardrail.isSafe;
+          ctx.guardrail_category = guardrail.category;
+          ctx.guardrail_confidence = guardrail.confidence;
+
+          if (!guardrail.isSafe) {
+            ctx.outcome = "rejected";
+            const rejectionText =
+              "I'm sorry, but I can't help with that request. I'm here to assist with knowledge management questions. Could you try rephrasing your message?";
+            span.updateTrace({ output: rejectionText });
+            span.update({ output: rejectionText });
+            span.end();
+            const partId = nanoid();
+            return createUIMessageStreamResponse({
+              stream: createUIMessageStream({
+                execute: ({ writer }) => {
+                  writer.write({ type: "start" });
+                  writer.write({ type: "start-step" });
+                  writer.write({ type: "text-start", id: partId });
+                  writer.write({ type: "text-delta", delta: rejectionText, id: partId });
+                  writer.write({ type: "text-end", id: partId });
+                  writer.write({ type: "finish-step" });
+                  writer.write({ type: "finish", finishReason: "stop" });
+                },
+              }),
+            });
+          }
+        }
+
+        const existing = await db
+          .select({ id: chatSession.id })
+          .from(chatSession)
+          .where(eq(chatSession.id, chatId))
+          .limit(1);
+
+        const isNewChat = existing.length === 0;
+
+        if (isNewChat) {
+          await db.insert(chatSession).values({
+            id: chatId,
+            userId: session.user.id,
+            title: "New Chat",
+          });
+        }
+
+        const lastUserMsg = extractLastUserMessage(messages);
+        if (lastUserMsg) {
+          await db
+            .insert(chatMessage)
+            .values({
+              id: lastUserMsg.id,
+              chatSessionId: chatId,
+              role: "user",
+              parts: lastUserMsg.parts,
+            })
+            .onConflictDoNothing();
+        }
+
+        const modelMessages = await convertToModelMessages(messages);
+
+        const result = streamText({
+          model,
+          messages: modelMessages,
+          experimental_telemetry: { isEnabled: true, functionId: "chat-completion" },
+          onFinish: ({ text }) => {
+            span.updateTrace({ output: text });
+            span.update({ output: text });
+            span.end();
+          },
+        });
+
+        ctx.outcome = "streamed";
+
+        const stream = createUIMessageStream({
+          execute: async ({ writer }) => {
+            writer.merge(result.toUIMessageStream());
+
+            await result.text;
+
+            if (isNewChat && userText) {
+              try {
+                const titleResult = streamText({
+                  model: titleModel,
+                  system:
+                    "You are a conversation titler. Given context from a conversation, generate a very short, concise title that captures the essence of the conversation. The title should be a few words at most — like a chat label or subject line. Respond with only the title, nothing else.",
+                  prompt: `User message: ${userText}\n\nTitle:`,
+                  experimental_telemetry: { isEnabled: true, functionId: "title-generation" },
+                });
+
+                let fullTitle = "";
+                for await (const delta of titleResult.textStream) {
+                  fullTitle += delta;
+                  writer.write({
+                    type: "data-title-update" as const,
+                    data: { chatId, title: fullTitle },
+                    transient: true,
+                  });
+                }
+
+                const trimmedTitle = fullTitle.trim();
+                if (trimmedTitle) {
+                  await db
+                    .update(chatSession)
+                    .set({ title: trimmedTitle, updatedAt: new Date() })
+                    .where(eq(chatSession.id, chatId));
+
+                  writer.write({
+                    type: "data-title-final" as const,
+                    data: { chatId, title: trimmedTitle },
+                    transient: true,
+                  });
+                }
+              } catch {
+                logger.error({ chat_id: chatId, msg: "title generation failed" });
+              }
+            }
+          },
+          onFinish: async ({ responseMessage }) => {
+            await db.insert(chatMessage).values({
+              id: responseMessage.id,
+              chatSessionId: chatId,
+              role: "assistant",
+              parts: responseMessage.parts,
+            });
+
+            await db
+              .update(chatSession)
+              .set({ updatedAt: new Date() })
+              .where(eq(chatSession.id, chatId));
+          },
+        });
+
+        return createUIMessageStreamResponse({ stream });
+      },
+      { endOnExit: false },
+    );
+
+    after(async () => {
+      await langfuseSpanProcessor.forceFlush();
+    });
+
+    return response;
+  } catch (error) {
+    ctx.outcome = "error";
+    if (error instanceof Error) {
+      ctx.error_name = error.name;
+      ctx.error_message = error.message;
+    }
+    return new Response("Internal Server Error", { status: 500 });
+  } finally {
+    ctx.duration_ms = Math.round(performance.now() - start);
+    const level = ctx.outcome === "error" ? "error" : "info";
+    logger[level](ctx);
+  }
+};

package/dist/templates/presets/ai-chat-app/apps/web/app/api/chat/sessions/[id]/messages/route.ts

@@ -0,0 +1,38 @@
+import { asc, eq } from "drizzle-orm";
+
+import { auth } from "@/lib/auth";
+import { db } from "@/lib/db";
+import { chatMessage, chatSession } from "@/lib/db/schema";
+
+type RouteParams = { params: Promise<{ id: string }> };
+
+export const GET = async (req: Request, { params }: RouteParams): Promise<Response> => {
+  const session = await auth.api.getSession({ headers: req.headers });
+  if (!session) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+
+  const { id } = await params;
+
+  const chatSessionRow = await db
+    .select({ userId: chatSession.userId })
+    .from(chatSession)
+    .where(eq(chatSession.id, id))
+    .limit(1);
+
+  if (chatSessionRow.length === 0 || chatSessionRow[0].userId !== session.user.id) {
+    return new Response("Not Found", { status: 404 });
+  }
+
+  const messages = await db
+    .select({
+      id: chatMessage.id,
+      role: chatMessage.role,
+      parts: chatMessage.parts,
+    })
+    .from(chatMessage)
+    .where(eq(chatMessage.chatSessionId, id))
+    .orderBy(asc(chatMessage.createdAt));
+
+  return Response.json(messages);
+};

package/dist/templates/presets/ai-chat-app/apps/web/app/api/chat/sessions/[id]/route.ts

@@ -0,0 +1,59 @@
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { auth } from "@/lib/auth";
+import { db } from "@/lib/db";
+import { chatSession } from "@/lib/db/schema";
+
+type RouteParams = { params: Promise<{ id: string }> };
+
+export const DELETE = async (req: Request, { params }: RouteParams): Promise<Response> => {
+  const session = await auth.api.getSession({ headers: req.headers });
+  if (!session) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+
+  const { id } = await params;
+
+  const deleted = await db
+    .delete(chatSession)
+    .where(and(eq(chatSession.id, id), eq(chatSession.userId, session.user.id)))
+    .returning({ id: chatSession.id });
+
+  if (deleted.length === 0) {
+    return new Response("Not Found", { status: 404 });
+  }
+
+  return new Response(null, { status: 204 });
+};
+
+const patchSchema = z.object({
+  title: z.string().min(1).max(255),
+});
+
+export const PATCH = async (req: Request, { params }: RouteParams): Promise<Response> => {
+  const session = await auth.api.getSession({ headers: req.headers });
+  if (!session) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+
+  const { id } = await params;
+
+  const body = await req.json();
+  const parsed = patchSchema.safeParse(body);
+  if (!parsed.success) {
+    return new Response("Invalid request body", { status: 400 });
+  }
+
+  const updated = await db
+    .update(chatSession)
+    .set({ title: parsed.data.title, updatedAt: new Date() })
+    .where(and(eq(chatSession.id, id), eq(chatSession.userId, session.user.id)))
+    .returning({ id: chatSession.id, title: chatSession.title });
+
+  if (updated.length === 0) {
+    return new Response("Not Found", { status: 404 });
+  }
+
+  return Response.json(updated[0]);
+};

package/dist/templates/presets/ai-chat-app/apps/web/app/api/chat/sessions/route.ts

@@ -0,0 +1,24 @@
+import { desc, eq } from "drizzle-orm";
+
+import { auth } from "@/lib/auth";
+import { db } from "@/lib/db";
+import { chatSession } from "@/lib/db/schema";
+
+export const GET = async (req: Request): Promise<Response> => {
+  const session = await auth.api.getSession({ headers: req.headers });
+  if (!session) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+
+  const sessions = await db
+    .select({
+      id: chatSession.id,
+      title: chatSession.title,
+      updatedAt: chatSession.updatedAt,
+    })
+    .from(chatSession)
+    .where(eq(chatSession.userId, session.user.id))
+    .orderBy(desc(chatSession.updatedAt));
+
+  return Response.json(sessions);
+};

package/dist/templates/presets/ai-chat-app/apps/web/app/api/health/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from "next/server";
+
+import { env } from "@/env";
+import { pool } from "@/lib/db";
+
+export async function GET(): Promise<NextResponse> {
+  try {
+    await pool.query("SELECT 1");
+
+    return NextResponse.json({
+      status: "ok",
+      version: env.SOURCE_VERSION,
+      uptime: process.uptime(),
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error("Health check failed:", message);
+
+    return NextResponse.json({ status: "error", error: message }, { status: 503 });
+  }
+}

package/dist/templates/presets/ai-chat-app/apps/web/app/chat/[id]/page.tsx

@@ -0,0 +1,54 @@
+"use client";
+
+import type { UIMessage } from "ai";
+
+import { useParams } from "next/navigation";
+import { useEffect, useState } from "react";
+
+import { ChatView } from "@/components/chat-view";
+import { Spinner } from "@/components/ui/spinner";
+
+export default function ExistingChatPage() {
+  const { id } = useParams<{ id: string }>();
+  const [initialMessages, setInitialMessages] = useState<UIMessage[] | null>(null);
+  const [error, setError] = useState(false);
+
+  useEffect(() => {
+    setInitialMessages(null);
+    setError(false);
+
+    const loadMessages = async () => {
+      try {
+        const res = await fetch(`/api/chat/sessions/${id}/messages`);
+        if (!res.ok) {
+          setError(true);
+          return;
+        }
+        const data: UIMessage[] = await res.json();
+        setInitialMessages(data);
+      } catch {
+        setError(true);
+      }
+    };
+
+    loadMessages();
+  }, [id]);
+
+  if (error) {
+    return (
+      <div className="flex h-dvh items-center justify-center text-muted-foreground">
+        Chat not found
+      </div>
+    );
+  }
+
+  if (!initialMessages) {
+    return (
+      <div className="flex h-dvh items-center justify-center">
+        <Spinner className="size-6 text-muted-foreground" />
+      </div>
+    );
+  }
+
+  return <ChatView key={id} chatId={id} initialMessages={initialMessages} />;
+}

package/dist/templates/presets/ai-chat-app/apps/web/app/chat/layout.tsx

@@ -0,0 +1,23 @@
+import { redirect } from "next/navigation";
+
+import { AppSidebar } from "@/components/app-sidebar";
+import { ChatSessionsProvider } from "@/components/chat-sessions-provider";
+import { SidebarInset, SidebarProvider } from "@/components/ui/sidebar";
+import { getSession } from "@/lib/auth-session";
+
+export default async function ChatLayout({ children }: { children: React.ReactNode }) {
+  const session = await getSession();
+
+  if (!session) {
+    redirect("/login");
+  }
+
+  return (
+    <ChatSessionsProvider>
+      <SidebarProvider>
+        <AppSidebar />
+        <SidebarInset>{children}</SidebarInset>
+      </SidebarProvider>
+    </ChatSessionsProvider>
+  );
+}

package/dist/templates/presets/ai-chat-app/apps/web/app/chat/page.tsx

@@ -0,0 +1,9 @@
+"use client";
+
+import { ChatView } from "@/components/chat-view";
+import { useChatSessions } from "@/components/chat-sessions-provider";
+
+export default function NewChatPage() {
+  const { newChatKey } = useChatSessions();
+  return <ChatView key={`new-${newChatKey}`} />;
+}

package/dist/templates/presets/ai-chat-app/apps/web/app/error.tsx

@@ -0,0 +1,20 @@
+"use client";
+
+export default function Error({
+  reset,
+}: {
+  error: Error & { digest?: string };
+  reset: () => void;
+}) {
+  return (
+    <div className="flex min-h-dvh flex-col items-center justify-center gap-4 p-4">
+      <h2 className="text-xl font-semibold">Something went wrong</h2>
+      <button
+        onClick={reset}
+        className="rounded-md bg-primary px-4 py-2 text-sm text-primary-foreground hover:bg-primary/90"
+      >
+        Try again
+      </button>
+    </div>
+  );
+}

package/dist/templates/presets/ai-chat-app/apps/web/app/global-error.tsx

@@ -0,0 +1,42 @@
+"use client";
+
+export default function GlobalError({
+  reset,
+}: {
+  error: Error & { digest?: string };
+  reset: () => void;
+}) {
+  return (
+    <html lang="en">
+      <body>
+        <div
+          style={{
+            display: "flex",
+            minHeight: "100dvh",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            gap: "1rem",
+            padding: "1rem",
+          }}
+        >
+          <h2 style={{ fontSize: "1.25rem", fontWeight: 600 }}>Something went wrong</h2>
+          <button
+            onClick={reset}
+            style={{
+              padding: "0.5rem 1rem",
+              borderRadius: "0.375rem",
+              backgroundColor: "#171717",
+              color: "#fafafa",
+              fontSize: "0.875rem",
+              cursor: "pointer",
+              border: "none",
+            }}
+          >
+            Try again
+          </button>
+        </div>
+      </body>
+    </html>
+  );
+}