nixamp 0.27.2 → 0.27.3

package/src/event-writer.ts

@@ -0,0 +1,126 @@
+import { Guard } from "./guard.ts";
+
+export interface EventDraft { title: string; description: string; topic: string }
+export interface WriterInput extends EventDraft {
+  hostName: string; startsAt: string; timezone: string; duration: string; recurrence: string;
+}
+export interface EventDraftResult { draft: EventDraft; provider: "openai" | "claude" }
+export class EventWriterError extends Error {
+  constructor(message: string, readonly status: number, readonly retryAfter?: number) { super(message); }
+}
+class Refused extends EventWriterError {
+  constructor() { super("The writer could not draft these notes. Try rephrasing the event details.", 422); }
+}
+
+const LIMITS = {title: 160, description: 5000, topic: 100, hostName: 100, startsAt: 40, timezone: 100, duration: 20, recurrence: 20} as const;
+export function writerInput(value: unknown): WriterInput {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new EventWriterError("Send event details as an object.", 400);
+  const source = value as Record<string, unknown>;
+  const result = {} as WriterInput;
+  for (const key of Object.keys(LIMITS) as Array<keyof WriterInput>) {
+    const field = source[key] ?? "";
+    if (typeof field !== "string" || field.length > LIMITS[key]) throw new EventWriterError(`The ${key} field is too long or is not text.`, 422);
+    result[key] = field.trim();
+  }
+  if (!result.title && !result.description && !result.topic) throw new EventWriterError("Add a title, description, or topic first, then click Write with AI.", 422);
+  return result;
+}
+
+const SCHEMA = {
+  type: "object", properties: { title: {type: "string"}, description: {type: "string"}, topic: {type: "string"} },
+  required: ["title", "description", "topic"], additionalProperties: false,
+};
+const INSTRUCTIONS = `You write useful, welcoming event details for BackToSchool.help, a live learning platform.
+Use the supplied form text as the writing prompt. Rough notes and requests in that text describe what the host wants to teach.
+Return a clear title (at most 160 characters), a description (at most 5000 characters, usually 100–250 words), and a short topic (at most 100 characters).
+Write in the language of the host's notes. Describe what students will learn and what will happen, using only information supported by the notes.
+Keep concrete names and facts. Do not invent dates, prices, qualifications, prerequisites, links, credentials, or promises. Omit unknown logistics. Do not expand into unrelated subjects.
+The schedule and host name are context only; never propose changing them. Return plain text in the required JSON fields, with no HTML. Short paragraphs or simple bullet lists are fine.`;
+
+function draftFrom(text: string): EventDraft {
+  const value: unknown = JSON.parse(text);
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid draft");
+  const row = value as Record<string, unknown>;
+  const draft = {} as EventDraft;
+  for (const key of ["title", "description", "topic"] as const) {
+    const field = row[key];
+    if (typeof field !== "string" || !field.trim() || field.length > LIMITS[key]) throw new Error("invalid draft");
+    draft[key] = field.trim();
+  }
+  return draft;
+}
+
+export interface EventWriterOptions {
+  openaiKey?: string; anthropicKey?: string;
+  openaiModel?: string; claudeModel?: string;
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+}
+
+/** Server-side only. Drafting has no access to the event store and cannot publish. */
+export class EventWriter {
+  private readonly guard = new Guard();
+  private readonly active = new Set<string>();
+  constructor(private readonly options: EventWriterOptions) {}
+
+  async draft(accountId: string, value: unknown, signal?: AbortSignal): Promise<EventDraftResult> {
+    if (!accountId) throw new EventWriterError("Sign in to use the AI writer.", 401);
+    const input = writerInput(value);
+    if (!this.options.openaiKey && !this.options.anthropicKey) throw new EventWriterError("The AI writer is temporarily unavailable. You can keep writing here.", 503);
+    if (this.active.has(accountId)) throw new EventWriterError("A draft is already being written. Wait for it or cancel it first.", 429, 5);
+    if (this.active.size >= 4) throw new EventWriterError("The AI writer is busy. Try again in a moment.", 503, 10);
+    const limit = this.guard.check(accountId, {allowed: 6, windowMs: 10 * 60_000});
+    if (!limit.ok) throw new EventWriterError("You have requested several drafts. Try again in a few minutes.", 429, limit.retryAfter);
+    this.active.add(accountId);
+    try {
+      for (const provider of ["openai", "claude"] as const) {
+        const key = provider === "openai" ? this.options.openaiKey : this.options.anthropicKey;
+        if (!key) continue;
+        if (signal?.aborted) throw new EventWriterError("Draft cancelled.", 499);
+        try {
+          const draft = await this.generate(provider, key, input, signal);
+          if (signal?.aborted) throw new EventWriterError("Draft cancelled.", 499);
+          return {draft, provider};
+        }
+        catch (error) {
+          if (signal?.aborted) throw new EventWriterError("Draft cancelled.", 499);
+          // Refusals are a response to the content, not a provider outage.
+          if (error instanceof Refused) throw error;
+          // Never log prompts, credentials, or a provider's raw response body.
+          console.warn(`nixamp: event writer ${provider} request failed`);
+        }
+      }
+      throw new EventWriterError("The AI writer could not finish this draft. Your text is unchanged; please try again.", 503);
+    } finally { this.active.delete(accountId); }
+  }
+
+  private async generate(provider: "openai" | "claude", key: string, input: WriterInput, signal?: AbortSignal): Promise<EventDraft> {
+    const timeout = AbortSignal.timeout(this.options.timeoutMs ?? 25_000);
+    const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+    const prompt = JSON.stringify(input);
+    const openai = provider === "openai";
+    const response = await (this.options.fetch ?? globalThis.fetch)(openai ? "https://api.openai.com/v1/responses" : "https://api.anthropic.com/v1/messages", {
+      method: "POST", signal: requestSignal,
+      headers: { "content-type": "application/json", ...(openai ? {authorization: `Bearer ${key}`} : {"x-api-key": key, "anthropic-version": "2023-06-01"}) },
+      body: JSON.stringify(openai ? {
+        model: this.options.openaiModel ?? "gpt-5-mini", store: false,
+        instructions: INSTRUCTIONS, input: [{role: "user", content: prompt}],
+        reasoning: {effort: "minimal"}, max_output_tokens: 2048,
+        text: {format: {type: "json_schema", name: "event_draft", strict: true, schema: SCHEMA}},
+      } : {
+        model: this.options.claudeModel ?? "claude-haiku-4-5", max_tokens: 2048,
+        system: INSTRUCTIONS, messages: [{role: "user", content: prompt}],
+        output_config: {format: {type: "json_schema", schema: SCHEMA}},
+      }),
+    });
+    if (!response.ok) { await response.body?.cancel(); throw new Error("provider unavailable"); }
+    const body = await response.json() as Record<string, unknown>;
+    const blocks = openai
+      ? (Array.isArray(body["output"]) ? body["output"].flatMap(item => item?.type === "message" && Array.isArray(item.content) ? item.content : []) : [])
+      : (Array.isArray(body["content"]) ? body["content"] : []);
+    if (body["stop_reason"] === "refusal" || blocks.some(block => block?.type === "refusal")) throw new Refused();
+    if (openai ? body["status"] !== "completed" : body["stop_reason"] !== "end_turn") throw new Error("incomplete draft");
+    const text = blocks.filter(block => block?.type === (openai ? "output_text" : "text")).map(block => typeof block.text === "string" ? block.text : "").join("");
+    return draftFrom(text);
+  }
+}

package/src/live-api.ts

@@ -1,3 +1,4 @@
+import { EventWriterError, type EventWriter } from "./event-writer.ts";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { tokenFrom, type Account, type Accounts } from "./accounts.ts";
 import {
@@ -26,6 +27,7 @@ import { HAND_RAISE_STATES, RoomError, type Rooms } from "./rooms.ts";
 
 export interface LiveApiOptions {
   events: LiveEvents;
+  eventWriter?: EventWriter;
   accounts?: Accounts;
   layouts?: Layouts;
   rooms?: Rooms;
@@ -52,13 +54,13 @@ function json(response: ServerResponse, code: number, body: unknown): void {
   response.end(value);
 }
 
-async function body(request: IncomingMessage): Promise<Record<string, unknown>> {
+async function body(request: IncomingMessage, limit = 64 * 1024): Promise<Record<string, unknown>> {
   const chunks: Buffer[] = [];
   let size = 0;
   for await (const chunk of request) {
     const buffer = chunk as Buffer;
     size += buffer.length;
-    if (size > 64 * 1024) throw new LiveEventError("body too large", 413);
+    if (size > limit) throw new LiveEventError("body too large", 413);
     chunks.push(buffer);
   }
   try {
@@ -256,6 +258,21 @@ export async function handleLiveApi(
       !path.startsWith("/api/v1/layout-presets")) return false;
 
   try {
+    if (path === "/api/v1/events/ai-draft") {
+      if (request.method !== "POST") { json(response, 405, {error: "POST only"}); return true; }
+      const account = await requiredAccount(request, response, options);
+      if (!account) return true;
+      if (!options.eventWriter) { json(response, 503, {error: "The AI writer is temporarily unavailable. You can keep writing here."}); return true; }
+      const input = await body(request, 12 * 1024);
+      const controller = new AbortController();
+      const closed = () => controller.abort();
+      response.once("close", closed);
+      try {
+        const result = await options.eventWriter.draft(account.id, input, controller.signal);
+        if (!response.destroyed) json(response, 200, result);
+      } finally { response.off("close", closed); }
+      return true;
+    }
     if (path === "/api/v1/events") {
       if (request.method === "GET") {
         const account = await signedIn(request, options.accounts);
@@ -624,6 +641,13 @@ export async function handleLiveApi(
     json(response, 404, { error: "no such endpoint" });
     return true;
   } catch (error) {
+    if (error instanceof EventWriterError) {
+      if (!response.destroyed) {
+        if (error.retryAfter) response.setHeader("retry-after", String(error.retryAfter));
+        json(response, error.status, {error: error.message});
+      }
+      return true;
+    }
     if (error instanceof LiveEventError || error instanceof LayoutError || error instanceof RoomError) {
       json(response, error.status, { error: error.message });
       return true;

package/src/live-interpreter.ts

@@ -1,3 +1,4 @@
+import { audioError, transientAudioError } from "./live-recovery.ts";
 import { encodeWav } from "./pcm-wav.ts";
 import type { SpeakerTranscript, SpeakerTurn } from "./speaker-turns.ts";
 export interface Caption { channel: string; at: number; until: number; text: string; language?: string; original?: string; sourceLanguage?: string; speaker?: string; voiceProfile?: "lower" | "higher" | "unknown"; }
@@ -58,17 +59,20 @@ export class Interpreter {
   private controller: AbortController | null = null;
   private translating: number | null = null;
   private translationController: AbortController | null = null;
+  private recognitionFailures = 0;
+  private translationFailures = 0;
   private translations: { lines: Caption[]; language: string; target: string; until: number }[] = [];
   constructor(private readonly options: {
     language: () => string; speakers: () => boolean; voices: () => VoiceChoice[];
     channel: () => string; lines: (lines: Caption[]) => void;
-    status: (text: string) => void; failed: () => void;
+    status: (text: string) => void; failed: (message: string) => void;
     fetcher?: typeof fetch;
   }) {}
 
   reset(): void {
     this.generation++; this.controller?.abort(); this.translationController?.abort();
     this.pending = null; this.running = null; this.translating = null;
+    this.recognitionFailures = this.translationFailures = 0;
     this.translations = []; this.committedUntil = null; this.tracker.reset();
   }
   push(window: AudioWindow): void {
@@ -79,7 +83,7 @@ export class Interpreter {
   private async json(path: string, init: RequestInit, signal: AbortSignal): Promise<any> {
     const response = await (this.options.fetcher ?? fetch)(path, { ...init, signal });
     const body = await response.json();
-    if (!response.ok) throw new Error(body.error || "Audio translation is unavailable.");
+    if (!response.ok) throw audioError(body.error || "Audio translation is unavailable.", response.status);
     return body;
   }
   private async run(generation: number): Promise<void> {
@@ -87,60 +91,68 @@ export class Interpreter {
     try {
       while (this.pending && generation === this.generation) {
         const window = this.pending; this.pending = null;
-        if (Date.now() - window.until > 12_000) continue;
-        const controller = new AbortController(); this.controller = controller;
-        const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)]);
-        const speakers = this.options.speakers(), target = this.options.language();
-        const heard = await this.json(speakers ? "/api/v1/speech/speakers" : "/api/v1/speech/transcribe?live=1", {
-          method: "POST", headers: { "content-type": "audio/wav" }, body: new Uint8Array(encodeWav(speakers ? window.samples : window.samples.slice(-80_000))),
-        }, signal) as SpeakerTranscript & { text?: string };
-        if (generation !== this.generation) return;
-        const language = heard.language;
-        let lines: Caption[] = [];
-        if (speakers) {
-          const links = this.tracker.reconcile(heard.turns ?? [], window.at, this.options.voices());
-          // The watermark follows emitted words, not the newest capture
-          // interval: an overlapping window can recover audio that arrived
-          // while recognition/translation was busy. Keep unfinished phrases
-          // in that overlap so short capture intervals do not split every
-          // sentence (especially damaging when German changes word order).
-          const cutoff = this.committedUntil ?? window.freshAt;
-          const turns = heard.turns ?? [];
-          for (const [index, turn] of turns.entries()) {
-            const speaker = links.get(turn.speaker)!;
-            const words = turn.words.filter(word =>
-              window.at + (word.start + word.end) * 500 >= cutoff &&
-              (window.at + word.end * 1000 <= window.until - 100 || /[.!?。！？]$/.test(word.text)));
-            let phrase: typeof words = [];
-            const emit = (): void => {
-              if (!phrase.length) return;
-              lines.push({ channel: this.options.channel(), at: window.at + phrase[0]!.start * 1000,
-                until: window.at + phrase.at(-1)!.end * 1000, text: phrase.map(word => word.text).join(" ").trim(),
-                language, speaker: speaker.id, voiceProfile: turn.profile });
-              phrase = [];
-            };
-            for (const word of words) {
-              if (phrase.length && word.start - phrase.at(-1)!.end >= 0.45) emit();
-              phrase.push(word);
-              if (/[.!?。！？]$/.test(word.text) || phrase.map(word => word.text).join(" ").length >= 400) emit();
+        try {
+          if (Date.now() - window.until > 12_000) continue;
+          const controller = new AbortController(); this.controller = controller;
+          const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)]);
+          const speakers = this.options.speakers(), target = this.options.language();
+          const heard = await this.json(speakers ? "/api/v1/speech/speakers" : "/api/v1/speech/transcribe?live=1", {
+            method: "POST", headers: { "content-type": "audio/wav" }, body: new Uint8Array(encodeWav(speakers ? window.samples : window.samples.slice(-80_000))),
+          }, signal) as SpeakerTranscript & { text?: string };
+          if (generation !== this.generation) return;
+          this.recognitionFailures = 0;
+          const language = heard.language;
+          let lines: Caption[] = [];
+          if (speakers) {
+            const links = this.tracker.reconcile(heard.turns ?? [], window.at, this.options.voices());
+            // The watermark follows emitted words, not the newest capture
+            // interval: an overlapping window can recover audio that arrived
+            // while recognition/translation was busy. Keep unfinished phrases
+            // in that overlap so short capture intervals do not split every
+            // sentence (especially damaging when German changes word order).
+            const cutoff = this.committedUntil ?? window.freshAt;
+            const turns = heard.turns ?? [];
+            for (const [index, turn] of turns.entries()) {
+              const speaker = links.get(turn.speaker)!;
+              const words = turn.words.filter(word =>
+                window.at + (word.start + word.end) * 500 >= cutoff &&
+                (window.at + word.end * 1000 <= window.until - 100 || /[.!?。！？]$/.test(word.text)));
+              let phrase: typeof words = [];
+              const emit = (): void => {
+                if (!phrase.length) return;
+                lines.push({ channel: this.options.channel(), at: window.at + phrase[0]!.start * 1000,
+                  until: window.at + phrase.at(-1)!.end * 1000, text: phrase.map(word => word.text).join(" ").trim(),
+                  language, speaker: speaker.id, voiceProfile: turn.profile });
+                phrase = [];
+              };
+              for (const word of words) {
+                if (phrase.length && word.start - phrase.at(-1)!.end >= 0.45) emit();
+                phrase.push(word);
+                if (/[.!?。！？]$/.test(word.text) || phrase.map(word => word.text).join(" ").length >= 400) emit();
+              }
+              if (phrase.length && (index < turns.length - 1 ||
+                window.until - (window.at + phrase.at(-1)!.end * 1000) >= 350 ||
+                window.until - (window.at + phrase[0]!.start * 1000) >= 3000)) emit();
             }
-            if (phrase.length && (index < turns.length - 1 ||
-              window.until - (window.at + phrase.at(-1)!.end * 1000) >= 350 ||
-              window.until - (window.at + phrase[0]!.start * 1000) >= 3000)) emit();
+          } else if (heard.text) {
+            lines = [{ channel: this.options.channel(), at: window.freshAt, until: window.until, text: heard.text, language }];
           }
-        } else if (heard.text) {
-          lines = [{ channel: this.options.channel(), at: window.freshAt, until: window.until, text: heard.text, language }];
+          if (!lines.length) continue;
+          this.committedUntil = Math.max(this.committedUntil ?? window.freshAt, ...lines.map(line => line.until));
+          // Drop expired work instead of turning off an otherwise healthy stream.
+          this.translations = this.translations.filter(item => Date.now() - item.until <= 12_000).slice(-11);
+          this.translations.push({ lines, language, target, until: window.until });
+          // Recognition of the next audio window can proceed while the text
+          // model translates this phrase. Voice synthesis is a third stage.
+          if (this.translating === null) void this.translate(this.generation);
+        } catch (error) {
+          if (generation !== this.generation) return;
+          if (!transientAudioError(error) || ++this.recognitionFailures >= 3) throw error;
+          this.options.status("Speech recognition interrupted · listening for the next phrase…");
         }
-        if (!lines.length) continue;
-        this.committedUntil = Math.max(this.committedUntil ?? window.freshAt, ...lines.map(line => line.until));
-        if (this.translations.length >= 12) throw new Error("Translation fell behind. Try again after the language model has warmed up.");
-        this.translations.push({ lines, language, target, until: window.until });
-        // Recognition of the next audio window can proceed while the text
-        // model translates this phrase. Voice synthesis is a third stage.
-        if (this.translating === null) void this.translate(this.generation);
       }
     } catch (error) {
-      if (generation === this.generation) { this.reset(); this.options.failed(); this.options.status(error instanceof Error ? error.message : "Live translation stopped."); }
+      if (generation === this.generation) { const message = error instanceof Error ? error.message : "Live translation stopped."; this.reset(); this.options.failed(message); this.options.status(message); }
     } finally { if (this.running === generation) this.running = null; }
   }
 
@@ -149,26 +161,33 @@ export class Interpreter {
     try {
       while (this.translations.length && generation === this.generation) {
         const item = this.translations.shift()!;
-        let { lines } = item;
-        const { language, target, until } = item;
-        if (Date.now() - until > 12_000) throw new Error("Translation fell behind. Try again after the language model has warmed up.");
-        const controller = new AbortController(); this.translationController = controller;
-        if (target && language !== target) {
-          if (!language) throw new Error("The audio language could not be detected. Waiting for clearer speech.");
-          const translated = await this.json("/api/v1/translate?live=1", {
-            method: "POST", headers: { "content-type": "application/json" },
-            body: JSON.stringify({ texts: lines.map(line => line.text), from: language, to: target }),
-          }, AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)])) as { texts: string[] };
-          if (translated.texts.length !== lines.length || translated.texts.some(text => !text.trim())) throw new Error("Translation omitted a phrase. Enable translated audio again to retry.");
-          lines = lines.map((line, i) => ({ ...line, original: line.text, sourceLanguage: language, language: target, text: translated.texts[i]! }));
+        try {
+          let { lines } = item;
+          const { language, target, until } = item;
+          if (Date.now() - until > 12_000) continue;
+          const controller = new AbortController(); this.translationController = controller;
+          if (target && language !== target) {
+            if (!language) throw audioError("The audio language could not be detected. Waiting for clearer speech.", 502);
+            const translated = await this.json("/api/v1/translate?live=1", {
+              method: "POST", headers: { "content-type": "application/json" },
+              body: JSON.stringify({ texts: lines.map(line => line.text), from: language, to: target }),
+            }, AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)])) as { texts: string[] };
+            if (translated.texts.length !== lines.length || translated.texts.some(text => !text.trim())) throw audioError("Translation omitted a phrase. Waiting for the next phrase.", 502);
+            lines = lines.map((line, i) => ({ ...line, original: line.text, sourceLanguage: language, language: target, text: translated.texts[i]! }));
+          }
+          if (generation !== this.generation) return;
+          if (Date.now() - until > 12_000) continue;
+          this.translationFailures = 0;
+          this.options.lines(lines.flatMap(line => splitCaption(line)));
+          this.options.status(target ? `${language} → ${target} · live translation` : `Original audio language: ${language || "detecting…"}`);
+        } catch (error) {
+          if (generation !== this.generation) return;
+          if (!transientAudioError(error) || ++this.translationFailures >= 3) throw error;
+          this.options.status("Translation interrupted · catching up with live speech…");
         }
-        if (generation !== this.generation) return;
-        if (Date.now() - until > 12_000) throw new Error("Translation fell behind. Try again after the language model has warmed up.");
-        this.options.lines(lines.flatMap(line => splitCaption(line)));
-        this.options.status(target ? `${language} → ${target} · live translation` : `Original audio language: ${language || "detecting…"}`);
       }
     } catch (error) {
-      if (generation === this.generation) { this.reset(); this.options.failed(); this.options.status(error instanceof Error ? error.message : "Live translation stopped."); }
+      if (generation === this.generation) { const message = error instanceof Error ? error.message : "Live translation stopped."; this.reset(); this.options.failed(message); this.options.status(message); }
     } finally { if (this.translating === generation) this.translating = null; }
   }
 }

package/src/live-recovery.ts

@@ -0,0 +1,10 @@
+/** Access, billing and throttling failures are terminal. Only transient service
+ * and transport failures may recover, with a bounded consecutive failure count. */
+export function transientAudioError(error: unknown): boolean {
+  const status = (error as { status?: number } | null)?.status;
+  if (typeof status === "number") return [408, 502, 503, 504].includes(status);
+  return error instanceof TypeError || (error instanceof Error && ["AbortError", "TimeoutError"].includes(error.name));
+}
+export function audioError(message: string, status: number): Error & { status: number } {
+  return Object.assign(new Error(message), { status });
+}

package/src/mail-sender.ts

@@ -0,0 +1,12 @@
+export interface MailSender { apiKey: string; from: string }
+export interface BrandedMailSender extends MailSender { backtoschool?: MailSender }
+
+/** Only the exact school origins select its verified sender and credentials. */
+export function mailSender(options: BrandedMailSender, link: string): MailSender {
+  try {
+    const url = new URL(link);
+    if (options.backtoschool && url.protocol === "https:" &&
+      ["backtoschool.help", "www.backtoschool.help"].includes(url.hostname)) return options.backtoschool;
+  } catch { /* A malformed link never changes the sender. */ }
+  return options;
+}

package/src/notify.ts

@@ -1,3 +1,5 @@
+import { mailSender, type BrandedMailSender } from "./mail-sender.ts";
+
 /**
  * Telling followers a broadcaster went live, wherever they are.
  *
@@ -119,27 +121,28 @@ export async function notifyAll(
  * blocked, and no dependency: a fetch is the whole client.
  */
 export function resendEmail(
-  { apiKey, from, fetch = globalThis.fetch, onEvent }: {
-    apiKey: string;
-    from: string;
+  { apiKey, from, backtoschool, reason = "You are getting this because you follow them on nixamp.", fetch = globalThis.fetch, onEvent }: BrandedMailSender & {
+    reason?: string;
     fetch?: typeof globalThis.fetch;
     onEvent?: (message: string) => void;
   },
 ): (to: string, note: Notification) => Promise<boolean> {
   return async (to, note) => {
     try {
+      const sender = mailSender({apiKey, from, backtoschool}, note.url);
       const response = await fetch("https://api.resend.com/emails", {
         method: "POST",
-        headers: { authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
+        headers: { authorization: `Bearer ${sender.apiKey}`, "content-type": "application/json" },
+        signal: AbortSignal.timeout(15_000),
         body: JSON.stringify({
-          from,
+          from: sender.from,
           to: [to],
           subject: note.title,
-          text: `${note.body}\n\n${note.url}\n\nYou are getting this because you follow them on nixamp.`,
+          text: `${note.body}\n\n${note.url}\n\n${reason}`,
           html:
             `<p>${escapeHtml(note.body)}</p>` +
             `<p><a href="${escapeHtml(note.url)}">${escapeHtml(note.url)}</a></p>` +
-            `<p style="color:#666;font-size:12px">You are getting this because you follow them on nixamp.</p>`,
+            `<p style="color:#666;font-size:12px">${escapeHtml(reason)}</p>`,
         }),
       });
       if (!response.ok) {

package/src/password-reset.ts

@@ -1,6 +1,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import type { Queryable } from "./follows.ts";
 import type { Tokens } from "./tokens.ts";
+import { mailSender, type BrandedMailSender } from "./mail-sender.ts";
 
 export const RESET_MESSAGE = "If an account exists for that email, you’ll receive a password reset link shortly.";
 export const RESET_INVALID = "This reset link is invalid, expired, or already used. Request a new link.";
@@ -115,17 +116,16 @@ export class PasswordResets {
 }
 
 /** Transactional recovery mail has no follower footer and never logs a token. */
-export function resendPasswordReset(options: {
-  apiKey: string; from: string; fetch?: typeof globalThis.fetch;
-}): ResetMail {
+export function resendPasswordReset(options: BrandedMailSender & { fetch?: typeof globalThis.fetch }): ResetMail {
   return async (email, link) => {
     const host = new URL(link).hostname;
+    const sender = mailSender(options, link);
     const response = await (options.fetch ?? globalThis.fetch)("https://api.resend.com/emails", {
       method: "POST",
-      headers: { authorization: `Bearer ${options.apiKey}`, "content-type": "application/json" },
+      headers: { authorization: `Bearer ${sender.apiKey}`, "content-type": "application/json" },
       signal: AbortSignal.timeout(15_000),
       body: JSON.stringify({
-        from: options.from, to: [email], subject: `Reset your ${host} password`,
+        from: sender.from, to: [email], subject: `Reset your ${host} password`,
         text: `Someone requested a password reset for your account on ${host}.\n\nChoose a new password using this link:\n${link}\n\nThis link expires in ${LIFETIME_MS / 60_000} minutes and works once. Resetting your password signs out existing sessions.\n\nIf you did not request this, you can ignore this email. Your password will stay the same.`,
       }),
     });

package/src/server.ts

@@ -87,6 +87,7 @@ import { createThrottle, presentedCredential, type Throttle } from "@profullstac
 import { Durable } from "./durable.ts";
 import { notifyAll, resendEmail, webPush, type Notification } from "./notify.ts";
 import { inviteSubject, inviteText, isEmail, isPhone, watchLink } from "./invite.ts";
+import { EventWriter } from "./event-writer.ts";
 import { handleLiveApi } from "./live-api.ts";
 import { LiveEvents, eventStructuredData, isTicketed, type LiveEvent } from "./live-events.ts";
 import { Tickets, needsTicket, ticketFrom, ticketsFromEnv } from "./tickets.ts";
@@ -1759,6 +1760,7 @@ export interface HandlerOptions {
   settingsSync?: SettingsSync;
   /** Scheduled and live sessions, kept by NixAmp and shared by branded clients. */
   events?: LiveEvents;
+  eventWriter?: EventWriter;
   /** Versioned panel layouts, including event and user overrides. */
   layouts?: Layouts;
   /** Persistent participation state that must not be coupled to live audio. */
@@ -1944,6 +1946,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
 
     if (options.events && await handleLiveApi(request, response, url, {
       events: options.events,
+      ...(options.eventWriter ? {eventWriter: options.eventWriter} : {}),
       ...(options.accounts ? { accounts: options.accounts } : {}),
       ...(options.layouts ? { layouts: options.layouts } : {}),
       ...(options.rooms ? { rooms: options.rooms } : {}),
@@ -6123,6 +6126,10 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
   const favorites = pool ? new Favorites(pool) : undefined;
   const settingsSync = pool ? new SettingsSync(pool) : undefined;
   const nixampSite = (process.env["NIXAMP_SITE"] ?? DEFAULT_DIRECTORY).replace(/\/+$/, "");
+  const schoolMailKey = process.env["BACKTOSCHOOL_RESEND_API_KEY"] ?? process.env["RESEND_API_KEY"];
+  const schoolMail = schoolMailKey && process.env["BACKTOSCHOOL_MAIL_FROM"] ? {
+    apiKey: schoolMailKey, from: process.env["BACKTOSCHOOL_MAIL_FROM"],
+  } : undefined;
   const events = pool ? new LiveEvents(pool) : undefined;
   const layouts = pool ? new Layouts(pool) : undefined;
   const rooms = pool ? new Rooms(pool) : undefined;
@@ -6651,7 +6658,10 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     ...(follows ? { follows, vapidPublicKey } : {}),
     ...(favorites ? { favorites } : {}),
     ...(settingsSync ? { settingsSync } : {}),
-    ...(events ? { events } : {}),
+    ...(events ? { events, eventWriter: new EventWriter({
+      openaiKey: process.env["OPENAI_API_KEY"], anthropicKey: process.env["ANTHROPIC_API_KEY"],
+      openaiModel: process.env["NIXAMP_WRITER_OPENAI_MODEL"], claudeModel: process.env["NIXAMP_WRITER_CLAUDE_MODEL"],
+    }) } : {}),
     ...(layouts ? { layouts } : {}),
     ...(rooms ? { rooms } : {}),
     ...(trollbox ? { trollbox } : {}),
@@ -6668,6 +6678,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
       resetMail: resendPasswordReset({
         apiKey: process.env["RESEND_API_KEY"],
         from: process.env["NIXAMP_MAIL_FROM"] ?? "nixamp <notifications@nixamp.com>",
+        backtoschool: schoolMail,
       }),
     } : {}),
     // Other people's OpenProfiles, read for the voice a line is spoken in,
@@ -6692,6 +6703,8 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
                   email: resendEmail({
                     apiKey: process.env["RESEND_API_KEY"],
                     from: process.env["NIXAMP_MAIL_FROM"] ?? "nixamp <notifications@nixamp.com>",
+                    backtoschool: schoolMail,
+                    reason: "You received this email because a host invited you to join a live session.",
                     onEvent: (message) => console.log(message),
                   }),
                 }