@pylonsync/create-pylon 0.19.0 → 0.20.0

package/templates/ai-chat/components/chat/sidebar.tsx

@@ -0,0 +1,288 @@
+"use client";
+
+import React, { useMemo, useState } from "react";
+import { siteConfig } from "@/lib/site.config";
+import { groupConversations, type ConversationRow } from "@/lib/chat";
+import { BrandMark, CloseIcon, ComposeIcon, PencilIcon, SearchIcon, SignOutIcon, TrashIcon } from "./icons";
+
+export type Account = { kind: "guest" } | { kind: "user"; email: string | null };
+
+export interface SidebarProps {
+  conversations: ConversationRow[];
+  currentId: string | null;
+  now: number;
+  account: Account;
+  onSelect: (id: string) => void;
+  onNew: () => void;
+  onRename: (id: string, title: string) => void;
+  onDelete: (id: string) => void;
+  onSignIn: () => void;
+  onSignOut: () => void;
+  // Mobile drawer: shows a close button when set.
+  onClose?: () => void;
+}
+
+export function Sidebar({
+  conversations,
+  currentId,
+  now,
+  account,
+  onSelect,
+  onNew,
+  onRename,
+  onDelete,
+  onSignIn,
+  onSignOut,
+  onClose,
+}: SidebarProps) {
+  const [filter, setFilter] = useState("");
+  const groups = useMemo(() => {
+    const f = filter.trim().toLowerCase();
+    const rows = f ? conversations.filter((c) => c.title.toLowerCase().includes(f)) : conversations;
+    return groupConversations(rows, now);
+  }, [conversations, filter, now]);
+
+  return (
+    <div className="flex h-full flex-col">
+      <div className="flex h-14 items-center justify-between px-3">
+        <button
+          type="button"
+          onClick={onNew}
+          className="press flex items-center gap-2.5 rounded-xl px-1.5 py-1 transition-colors duration-200 hover:bg-hover"
+        >
+          <BrandMark size={26} />
+          <span className="text-[15.5px] font-semibold tracking-[-0.015em] text-ink">{siteConfig.brand.name}</span>
+        </button>
+        {onClose ? (
+          <button
+            type="button"
+            onClick={onClose}
+            aria-label="Close sidebar"
+            className="press flex size-9 items-center justify-center rounded-xl text-ink-2 hover:bg-hover"
+          >
+            <CloseIcon size={18} />
+          </button>
+        ) : null}
+      </div>
+
+      <div className="space-y-1 px-3 pb-2">
+        <button
+          type="button"
+          onClick={onNew}
+          className="press flex h-10 w-full items-center gap-2.5 rounded-xl px-3 text-[14px] font-medium text-ink transition-colors duration-200 hover:bg-hover"
+        >
+          <ComposeIcon size={17} />
+          New chat
+        </button>
+        <label className="flex h-10 items-center gap-2.5 rounded-xl px-3 text-ink-3 transition-colors duration-200 focus-within:bg-hover hover:bg-hover">
+          <SearchIcon size={17} />
+          <input
+            value={filter}
+            onChange={(e) => setFilter(e.target.value)}
+            placeholder="Search chats"
+            aria-label="Search chats"
+            className="w-full bg-transparent text-[14px] text-ink outline-none placeholder:text-ink-3"
+          />
+        </label>
+      </div>
+
+      <nav className="sidebar-scroll min-h-0 flex-1 overflow-y-auto px-3 pb-4" aria-label="Conversations">
+        {groups.length === 0 ? (
+          <p className="px-3 py-6 text-[13px] leading-relaxed text-ink-3">
+            {filter ? "No chats match that search." : "Your chats appear here."}
+          </p>
+        ) : (
+          groups.map((g) => (
+            <section key={g.label} className="mt-4 first:mt-2">
+              <h3 className="px-3 pb-1 text-[12px] font-medium text-ink-3">{g.label}</h3>
+              <ul className="space-y-px">
+                {g.items.map((c) => (
+                  <ConversationItem
+                    key={c.id}
+                    convo={c}
+                    active={c.id === currentId}
+                    onSelect={() => onSelect(c.id)}
+                    onRename={(t) => onRename(c.id, t)}
+                    onDelete={() => onDelete(c.id)}
+                  />
+                ))}
+              </ul>
+            </section>
+          ))
+        )}
+      </nav>
+
+      <AccountPanel account={account} onSignIn={onSignIn} onSignOut={onSignOut} />
+    </div>
+  );
+}
+
+function ConversationItem({
+  convo,
+  active,
+  onSelect,
+  onRename,
+  onDelete,
+}: {
+  convo: ConversationRow;
+  active: boolean;
+  onSelect: () => void;
+  onRename: (title: string) => void;
+  onDelete: () => void;
+}) {
+  const [editing, setEditing] = useState(false);
+  const [draft, setDraft] = useState(convo.title);
+  const [confirming, setConfirming] = useState(false);
+
+  function commit() {
+    setEditing(false);
+    const t = draft.trim();
+    if (t && t !== convo.title) onRename(t);
+    else setDraft(convo.title);
+  }
+
+  if (editing) {
+    return (
+      <li>
+        <input
+          autoFocus
+          value={draft}
+          onChange={(e) => setDraft(e.target.value)}
+          onBlur={commit}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") commit();
+            if (e.key === "Escape") {
+              setDraft(convo.title);
+              setEditing(false);
+            }
+          }}
+          aria-label="Chat title"
+          className="h-9 w-full rounded-xl bg-surface px-3 text-[14px] text-ink outline-none ring-1 ring-brand/40"
+        />
+      </li>
+    );
+  }
+
+  return (
+    <li className="group/item relative">
+      <button
+        type="button"
+        onClick={onSelect}
+        aria-current={active ? "page" : undefined}
+        title={convo.title}
+        className={
+          "flex h-9 w-full items-center gap-2 rounded-xl pl-3 pr-2 text-left text-[14px] transition-colors duration-200 " +
+          (active ? "bg-active text-ink" : "text-ink-2 hover:bg-hover hover:text-ink")
+        }
+      >
+        <span className="min-w-0 flex-1 truncate">{convo.title || "New chat"}</span>
+        {convo.example ? (
+          <span className="shrink-0 rounded-md bg-hover px-1.5 py-px text-[11px] text-ink-3 group-hover/item:hidden">
+            Example
+          </span>
+        ) : null}
+      </button>
+      <div
+        className={
+          "absolute right-1 top-1/2 -translate-y-1/2 items-center gap-px rounded-lg pl-3 " +
+          (confirming ? "flex" : "hidden group-focus-within/item:flex group-hover/item:flex") +
+          (active ? " fade-active" : " fade-hover")
+        }
+      >
+        {confirming ? (
+          <>
+            <button
+              type="button"
+              onClick={() => {
+                setConfirming(false);
+                onDelete();
+              }}
+              className="h-7 rounded-lg px-2 text-[12.5px] font-medium text-danger hover:bg-danger/10"
+            >
+              Delete
+            </button>
+            <button
+              type="button"
+              onClick={() => setConfirming(false)}
+              className="h-7 rounded-lg px-2 text-[12.5px] text-ink-2 hover:bg-hover"
+            >
+              Cancel
+            </button>
+          </>
+        ) : (
+          <>
+            <button
+              type="button"
+              onClick={() => {
+                setDraft(convo.title);
+                setEditing(true);
+              }}
+              aria-label="Rename chat"
+              className="flex size-7 items-center justify-center rounded-lg text-ink-3 hover:bg-hover hover:text-ink"
+            >
+              <PencilIcon size={15} />
+            </button>
+            <button
+              type="button"
+              onClick={() => setConfirming(true)}
+              aria-label="Delete chat"
+              className="flex size-7 items-center justify-center rounded-lg text-ink-3 hover:bg-hover hover:text-danger"
+            >
+              <TrashIcon size={15} />
+            </button>
+          </>
+        )}
+      </div>
+    </li>
+  );
+}
+
+function AccountPanel({
+  account,
+  onSignIn,
+  onSignOut,
+}: {
+  account: Account;
+  onSignIn: () => void;
+  onSignOut: () => void;
+}) {
+  if (account.kind === "guest") {
+    return (
+      <div className="border-t border-line p-3">
+        <div className="rounded-2xl bg-surface/70 p-3.5 ring-1 ring-line">
+          <p className="text-[13.5px] font-medium text-ink">You are using a guest session</p>
+          <p className="mt-1 text-[12.5px] leading-relaxed text-ink-3">
+            Chats are saved in this browser. Sign in to keep them on every device.
+          </p>
+          <button
+            type="button"
+            onClick={onSignIn}
+            className="press mt-3 flex h-9 w-full items-center justify-center rounded-xl bg-ink text-[13.5px] font-medium text-bg transition-opacity duration-200 hover:opacity-90"
+          >
+            Sign in or create account
+          </button>
+        </div>
+      </div>
+    );
+  }
+  const email = account.email ?? "Signed in";
+  return (
+    <div className="border-t border-line p-3">
+      <div className="flex items-center gap-3 rounded-xl px-2 py-1.5">
+        <span className="flex size-8 shrink-0 items-center justify-center rounded-full bg-brand-soft text-[13px] font-semibold uppercase text-brand">
+          {email.slice(0, 1)}
+        </span>
+        <span className="min-w-0 flex-1 truncate text-[13.5px] text-ink">{email}</span>
+        <button
+          type="button"
+          onClick={onSignOut}
+          aria-label="Sign out"
+          title="Sign out"
+          className="press flex size-8 items-center justify-center rounded-lg text-ink-3 hover:bg-hover hover:text-ink"
+        >
+          <SignOutIcon size={17} />
+        </button>
+      </div>
+    </div>
+  );
+}

package/templates/ai-chat/functions/_beginTurn.ts

@@ -0,0 +1,145 @@
+import { mutation, v } from "@pylonsync/functions";
+import { siteConfig } from "../lib/site.config";
+import {
+  buildHistory,
+  isStaleStream,
+  STALE_STREAM_MS,
+  RATE_WINDOW_MS,
+  replyLimit,
+  sortMessages,
+  type LlmTurn,
+  type MessageRow,
+} from "../lib/chat";
+
+// Internal: the write half of starting a reply, called by `respond`. In one
+// transaction it checks ownership, the hourly limits, and that the caller has
+// no other generation running; stores the user's message (or, on
+// regenerate, removes the last reply); and inserts the assistant message the
+// stream fills. Returns the transcript to send to the model.
+export default mutation({
+  internal: true,
+  auth: "guest",
+  args: {
+    conversationId: v.string(),
+    content: v.optional(v.string()),
+    regenerate: v.optional(v.boolean()),
+    model: v.string(),
+    streamId: v.optional(v.string()),
+  },
+  async handler(ctx, args): Promise<{ messageId: string; history: LlmTurn[] }> {
+    const userId = ctx.auth.userId;
+    if (!userId) throw ctx.error("UNAUTHENTICATED", "A session is required.");
+
+    const convo = (await ctx.db.unsafe.get("Conversation", args.conversationId)) as
+      | { userId: string; example?: boolean }
+      | null;
+    if (!convo || convo.userId !== userId) {
+      throw ctx.error("NOT_FOUND", "Conversation not found.");
+    }
+    if (convo.example) {
+      throw ctx.error("EXAMPLE_READ_ONLY", "Example conversations are read-only. Start a new chat.");
+    }
+
+    // Serializes turn starts, so two tabs (or two guest sessions) cannot both
+    // pass the limit and busy checks below at the same moment.
+    await ctx.db.advisoryLock(ctx.auth.isGuest ? "ai-chat:turn:guests" : `ai-chat:turn:${userId}`);
+
+    // Limits and the busy check read ReplyLog, which regenerate and delete
+    // never remove.
+    const now = Date.now();
+    const since = new Date(now - RATE_WINDOW_MS).toISOString();
+    const mine = (await ctx.db.unsafe.query("ReplyLog", {
+      userId,
+      createdAt: { $gt: since },
+    })) as { createdAt: string; finishedAt?: string | null }[];
+    if (mine.length >= replyLimit(ctx.auth.isGuest)) {
+      throw ctx.error(
+        "RATE_LIMITED",
+        ctx.auth.isGuest
+          ? "Hourly limit reached. Sign in for a higher limit, or try again later."
+          : "Hourly limit reached. Try again later.",
+      );
+    }
+    if (ctx.auth.isGuest) {
+      const guests = (await ctx.db.unsafe.query("ReplyLog", {
+        isGuest: true,
+        createdAt: { $gt: since },
+        $limit: siteConfig.chat.repliesPerHour.allGuests,
+      })) as unknown[];
+      if (guests.length >= siteConfig.chat.repliesPerHour.allGuests) {
+        throw ctx.error("RATE_LIMITED", "Guest replies are busy right now. Sign in, or try again later.");
+      }
+    }
+    // One generation per person at a time. A stopped reply still counts until
+    // its provider call ends, because the call keeps running on the server.
+    if (mine.some((r) => !r.finishedAt && now - Date.parse(r.createdAt) < STALE_STREAM_MS)) {
+      throw ctx.error("BUSY", "A reply is already being written. Wait for it to finish.");
+    }
+
+    const rows = sortMessages(
+      ((await ctx.db.unsafe.query("Message", { conversationId: args.conversationId })) as unknown as MessageRow[]).filter(
+        (m) => m.userId === userId,
+      ),
+    );
+    if (rows.some((m) => m.status === "streaming" && !isStaleStream(m, now))) {
+      throw ctx.error("BUSY", "A reply is already being written in this conversation.");
+    }
+
+    // Message writes are denied to clients by policy. Every write below is
+    // scoped to the conversation the caller was just checked to own.
+    let transcript = rows;
+    if (args.regenerate) {
+      const last = rows[rows.length - 1];
+      if (last?.role === "assistant") {
+        await ctx.db.unsafe.delete("Message", last.id);
+        transcript = rows.slice(0, -1);
+      }
+      if (transcript[transcript.length - 1]?.role !== "user") {
+        throw ctx.error("INVALID_ARGS", "There is no message to answer.");
+      }
+    } else {
+      const text = (args.content ?? "").trim();
+      if (text.length === 0) throw ctx.error("INVALID_ARGS", "The message is empty.");
+      if (text.length > siteConfig.chat.maxInputChars) {
+        throw ctx.error("INVALID_ARGS", "The message is too long.");
+      }
+      const createdAt = new Date(now).toISOString();
+      const id = await ctx.db.unsafe.insert("Message", {
+        conversationId: args.conversationId,
+        userId,
+        role: "user",
+        content: text,
+        status: "done",
+        createdAt,
+      });
+      transcript = [
+        ...rows,
+        { id, conversationId: args.conversationId, userId, role: "user", content: text, status: "done", createdAt },
+      ];
+    }
+
+    // One millisecond after the user's message, so the pair sorts in order.
+    const messageId = await ctx.db.unsafe.insert("Message", {
+      conversationId: args.conversationId,
+      userId,
+      role: "assistant",
+      content: "",
+      status: "streaming",
+      streamId: args.streamId ?? null,
+      model: args.model,
+      createdAt: new Date(now + 1).toISOString(),
+    });
+    await ctx.db.unsafe.insert("ReplyLog", {
+      userId,
+      messageId,
+      isGuest: ctx.auth.isGuest,
+      model: args.model,
+      createdAt: new Date(now).toISOString(),
+    });
+    await ctx.db.unsafe.update("Conversation", args.conversationId, {
+      updatedAt: new Date(now).toISOString(),
+    });
+
+    return { messageId, history: buildHistory(transcript) };
+  },
+});

package/templates/ai-chat/functions/_finishTurn.ts

@@ -0,0 +1,55 @@
+import { mutation, v } from "@pylonsync/functions";
+
+// Internal: store the final text of a reply, called by `respond` when the
+// provider call ends or fails. Ownership is checked against the ReplyLog row
+// `_beginTurn` wrote for the same caller, so the reply still lands after a
+// guest signs in and its messages move to the account.
+//
+// A reply the user stopped keeps the text they saw, but only when that text
+// is a prefix of what the model produced. Otherwise the stored text is the
+// model's own output cut to the same length, so a client cannot write words
+// into the assistant's turn.
+export default mutation({
+  internal: true,
+  auth: "guest",
+  args: {
+    messageId: v.string(),
+    content: v.string(),
+    status: v.string(),
+    errorCode: v.optional(v.string()),
+  },
+  async handler(ctx, args) {
+    // ReplyLog and Message are server-only for writes; the log row proves
+    // this caller started the generation.
+    const [log] = (await ctx.db.unsafe.query("ReplyLog", { messageId: args.messageId, $limit: 1 })) as {
+      id: string;
+      userId: string;
+    }[];
+    if (!log || log.userId !== ctx.auth.userId) return { ok: false };
+    await ctx.db.unsafe.update("ReplyLog", log.id, { finishedAt: new Date().toISOString() });
+
+    const msg = (await ctx.db.unsafe.get("Message", args.messageId)) as
+      | { status: string; content: string; conversationId: string }
+      | null;
+    if (!msg) return { ok: true };
+
+    if (msg.status === "stopped") {
+      const shown = msg.content;
+      const content = args.content.startsWith(shown) ? shown : args.content.slice(0, shown.length);
+      if (content !== shown) await ctx.db.unsafe.update("Message", args.messageId, { content });
+      return { ok: true };
+    }
+    if (msg.status !== "streaming") return { ok: true };
+
+    const status = args.status === "error" ? "error" : "done";
+    await ctx.db.unsafe.update("Message", args.messageId, {
+      content: args.content,
+      status,
+      errorCode: status === "error" ? (args.errorCode ?? "LLM_FAILED") : null,
+    });
+    await ctx.db.unsafe.update("Conversation", msg.conversationId, {
+      updatedAt: new Date().toISOString(),
+    });
+    return { ok: true };
+  },
+});

package/templates/ai-chat/functions/assistantStatus.ts

@@ -0,0 +1,13 @@
+import { query } from "@pylonsync/functions";
+import { providerStatus } from "../lib/provider";
+
+// Whether a model provider key is configured on the server. The UI uses it to
+// show setup steps before the first message. It returns two fields and never
+// any key material.
+export default query({
+  auth: "guest",
+  args: {},
+  async handler(ctx) {
+    return providerStatus(ctx.env);
+  },
+});

package/templates/ai-chat/functions/claimGuestHistory.ts

@@ -0,0 +1,39 @@
+import { mutation, v } from "@pylonsync/functions";
+import { hashClaimCode } from "../lib/claim";
+import { isGuestId } from "../lib/chat";
+
+// Move a guest's conversations to the signed-in account. The code comes from
+// `prepareGuestClaim`, which only the guest session could call, so holding it
+// proves the caller was that guest. Each code works once.
+export default mutation({
+  auth: "user",
+  args: { code: v.string() },
+  async handler(ctx, args) {
+    const userId = ctx.auth.userId;
+    if (!/^[0-9a-f]{64}$/.test(args.code)) return { moved: 0 };
+
+    // GuestClaim is server-only; the row is looked up by the code's hash.
+    const [claim] = (await ctx.db.unsafe.query("GuestClaim", {
+      codeHash: await hashClaimCode(args.code),
+      $limit: 1,
+    })) as { id: string; guestId: string; expiresAt: string }[];
+    if (!claim) return { moved: 0 };
+    await ctx.db.unsafe.delete("GuestClaim", claim.id);
+    if (Date.parse(claim.expiresAt) < Date.now() || !isGuestId(claim.guestId)) return { moved: 0 };
+
+    // Reassigns rows owned by the guest id the claim proved. Owner fields are
+    // readonly to clients; this server-side update is the one path that
+    // changes them.
+    const conversations = (await ctx.db.unsafe.query("Conversation", {
+      userId: claim.guestId,
+    })) as { id: string }[];
+    for (const c of conversations) {
+      await ctx.db.unsafe.update("Conversation", c.id, { userId });
+    }
+    const messages = (await ctx.db.unsafe.query("Message", { userId: claim.guestId })) as { id: string }[];
+    for (const m of messages) {
+      await ctx.db.unsafe.update("Message", m.id, { userId });
+    }
+    return { moved: conversations.length };
+  },
+});

package/templates/ai-chat/functions/createConversation.ts

@@ -0,0 +1,28 @@
+import { mutation, v } from "@pylonsync/functions";
+import { siteConfig } from "../lib/site.config";
+import { titleFromMessage } from "../lib/chat";
+
+// Start a conversation titled from its first message. Guests may call it, so a
+// visitor can chat before signing in. `respond` then adds the messages.
+export default mutation({
+  auth: "guest",
+  args: { firstMessage: v.string() },
+  async handler(ctx, args) {
+    const text = args.firstMessage.trim();
+    if (text.length === 0) throw ctx.error("INVALID_ARGS", "The message is empty.");
+    if (text.length > siteConfig.chat.maxInputChars) {
+      throw ctx.error("INVALID_ARGS", "The message is too long.");
+    }
+    const now = new Date().toISOString();
+    // Conversation inserts are denied to clients by policy; this function is
+    // the one place that creates them, stamped with the caller's id.
+    const id = await ctx.db.unsafe.insert("Conversation", {
+      userId: ctx.auth.userId,
+      title: titleFromMessage(text),
+      example: false,
+      createdAt: now,
+      updatedAt: now,
+    });
+    return { id };
+  },
+});

package/templates/ai-chat/functions/deleteConversation.ts

@@ -1,31 +1,26 @@
 import { mutation, v } from "@pylonsync/functions";
 
-// deleteConversation — remove a conversation AND all its messages in one
-// transaction. The client could delete the Conversation row itself (it's
-// owner-scoped), but that would orphan the messages; this cascades. Gated to the
-// owner: it verifies the conversation belongs to the caller before deleting.
-export default mutation<{ conversationId: string }, { ok: boolean; deleted: number }>({
-  auth: "user",
-  args: { conversationId: v.id("Conversation") },
+// Delete a conversation and its messages in one transaction. Only the owner
+// can delete; a missing or foreign id returns `deleted: 0` without saying
+// which.
+export default mutation({
+  auth: "guest",
+  args: { conversationId: v.string() },
   async handler(ctx, args) {
-    const convo = (await ctx.db.get("Conversation", args.conversationId)) as
+    const convo = (await ctx.db.unsafe.get("Conversation", args.conversationId)) as
       | { userId: string }
       | null;
-    if (!convo) return { ok: true, deleted: 0 };
-    if (convo.userId !== ctx.auth.userId) {
-      throw ctx.error("POLICY_DENIED", "You can only delete your own conversations.");
-    }
+    if (!convo || convo.userId !== ctx.auth.userId) return { ok: true, deleted: 0 };
 
-    const messages = (await ctx.db.unsafe.list("Message")) as unknown as {
-      id: string;
-      conversationId: string;
-    }[];
+    // Reads by conversation id, then checks each row's owner as well.
+    const messages = (await ctx.db.unsafe.query("Message", {
+      conversationId: args.conversationId,
+    })) as { id: string; userId: string }[];
     let deleted = 0;
     for (const m of messages) {
-      if (m.conversationId === args.conversationId) {
-        await ctx.db.unsafe.delete("Message", m.id);
-        deleted++;
-      }
+      if (m.userId !== ctx.auth.userId) continue;
+      await ctx.db.unsafe.delete("Message", m.id);
+      deleted++;
     }
     await ctx.db.unsafe.delete("Conversation", args.conversationId);
     return { ok: true, deleted };

package/templates/ai-chat/functions/prepareGuestClaim.ts

@@ -0,0 +1,32 @@
+import { mutation } from "@pylonsync/functions";
+import { hashClaimCode, newClaimCode, CLAIM_TTL_MS } from "../lib/claim";
+
+// Called by a guest right before signing in. Returns a one-time code that
+// `claimGuestHistory` accepts after sign-in to move this guest's
+// conversations to the account. Only the SHA-256 hash of the code is stored,
+// and the code expires after 15 minutes.
+export default mutation({
+  auth: "guest",
+  args: {},
+  async handler(ctx) {
+    const guestId = ctx.auth.userId;
+    if (!ctx.auth.isGuest || !guestId) return { code: null };
+
+    const code = newClaimCode();
+    // GuestClaim is denied to clients in every direction by policy.
+    const stale = (await ctx.db.unsafe.query("GuestClaim", { guestId })) as { id: string }[];
+    for (const row of stale) await ctx.db.unsafe.delete("GuestClaim", row.id);
+    // Claims from guests who never signed in expire; clear a batch of them.
+    const expired = (await ctx.db.unsafe.query("GuestClaim", {
+      expiresAt: { $lt: new Date().toISOString() },
+      $limit: 50,
+    })) as { id: string }[];
+    for (const row of expired) await ctx.db.unsafe.delete("GuestClaim", row.id);
+    await ctx.db.unsafe.insert("GuestClaim", {
+      guestId,
+      codeHash: await hashClaimCode(code),
+      expiresAt: new Date(Date.now() + CLAIM_TTL_MS).toISOString(),
+    });
+    return { code };
+  },
+});

package/templates/ai-chat/functions/renameConversation.ts

@@ -0,0 +1,19 @@
+import { mutation, v } from "@pylonsync/functions";
+import { cleanTitle } from "../lib/chat";
+
+// Rename one of the caller's conversations. Titles are trimmed to 80
+// characters.
+export default mutation({
+  auth: "guest",
+  args: { conversationId: v.string(), title: v.string() },
+  async handler(ctx, args) {
+    const title = cleanTitle(args.title.slice(0, 400));
+    if (!title) throw ctx.error("INVALID_ARGS", "The title is empty.");
+    const convo = (await ctx.db.unsafe.get("Conversation", args.conversationId)) as { userId: string } | null;
+    if (!convo || convo.userId !== ctx.auth.userId) throw ctx.error("NOT_FOUND", "Conversation not found.");
+    // Conversation updates are denied to clients by policy; ownership is
+    // checked above.
+    await ctx.db.unsafe.update("Conversation", args.conversationId, { title });
+    return { ok: true, title };
+  },
+});