streamtrust 0.2.0 → 0.3.0

package/examples/vercel-ai/reference-app/app/api/chat/route.js

@@ -0,0 +1,86 @@
+import { randomUUID } from 'node:crypto';
+import { consumeStream, streamText } from 'ai';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { CHAT_ID, activePath, loadChat, saveChat } from '../../../lib/store.js';
+
+export const dynamic = 'force-dynamic';
+
+const provider = createOpenAICompatible({
+  name: 'model',
+  baseURL: process.env.MODEL_BASE_URL,
+  apiKey: process.env.MODEL_API_KEY,
+});
+
+const textOf = (message) =>
+  (message?.parts ?? [])
+    .filter((p) => p.type === 'text')
+    .map((p) => p.text)
+    .join('');
+
+export async function POST(req) {
+  const { id, trigger, message } = await req.json();
+  if (!CHAT_ID.test(id ?? ''))
+    return new Response('Invalid chat id', { status: 400 });
+  const chat = (await loadChat(id)) ?? { id, messages: [], activeLeafId: '' };
+  let parentId;
+  if (trigger === 'regenerate-message') {
+    const leaf = chat.messages.find((m) => m.id === chat.activeLeafId);
+    if (!leaf) return new Response('Nothing to regenerate', { status: 409 });
+    // Keep the previous answer as a sibling instead of overwriting history.
+    parentId = leaf.role === 'assistant' ? leaf.parentId : leaf.id;
+  } else {
+    const text = textOf(message);
+    if (!text) return new Response('Empty message', { status: 400 });
+    const userId =
+      message.id && !chat.messages.some((m) => m.id === message.id)
+        ? message.id
+        : randomUUID();
+    chat.messages.push({
+      id: userId,
+      parentId: chat.activeLeafId,
+      role: 'user',
+      text,
+      status: 'complete',
+    });
+    parentId = userId;
+  }
+  const history = activePath(chat, parentId)
+    .filter((m) => m.role === 'user' || m.status === 'complete')
+    .map((m) => ({ role: m.role, content: m.text }));
+  const assistantId = randomUUID();
+  chat.messages.push({
+    id: assistantId,
+    parentId,
+    role: 'assistant',
+    text: '',
+    status: 'streaming',
+  });
+  chat.activeLeafId = assistantId;
+  await saveChat(chat);
+
+  const result = streamText({
+    model: provider.chatModel(process.env.MODEL_NAME || 'fixture-model'),
+    messages: history,
+    maxRetries: 0,
+    // Stop in the browser aborts this request; propagate it to the model call.
+    abortSignal: req.signal,
+  });
+  return result.toUIMessageStreamResponse({
+    generateMessageId: () => assistantId,
+    onError: () => 'The model provider failed.',
+    // Keep consuming after a client disconnect so onEnd still records the outcome.
+    consumeSseStream: consumeStream,
+    async onEnd({ responseMessage, outcome }) {
+      const saved = await loadChat(id);
+      const target = saved.messages.find((m) => m.id === assistantId);
+      target.text = textOf(responseMessage);
+      target.status =
+        outcome.status === 'completed'
+          ? 'complete'
+          : outcome.status === 'aborted'
+            ? 'aborted'
+            : 'error';
+      await saveChat(saved);
+    },
+  });
+}

package/examples/vercel-ai/reference-app/app/chat/[id]/chat.jsx

@@ -0,0 +1,69 @@
+'use client';
+import { useState } from 'react';
+import { useChat } from '@ai-sdk/react';
+import { DefaultChatTransport } from 'ai';
+
+const FAILED = 'The model provider failed.';
+
+export default function Chat({ id, initialMessages }) {
+  const [input, setInput] = useState('');
+  const { messages, sendMessage, regenerate, stop, status, error } = useChat({
+    id,
+    messages: initialMessages,
+    transport: new DefaultChatTransport({
+      api: '/api/chat',
+      // The server owns history; send only the trigger and the newest message.
+      prepareSendMessagesRequest: ({ id, messages, trigger }) => ({
+        body: { id, trigger, message: messages.at(-1) },
+      }),
+    }),
+  });
+  const busy = status === 'submitted' || status === 'streaming';
+  const last = messages.at(-1);
+  return (
+    <main>
+      <div data-testid="messages">
+        {messages.map((m) => (
+          <div key={m.id} data-role={m.role} style={{ margin: '12px 0' }}>
+            <strong>{m.role === 'user' ? 'You' : 'Assistant'}: </strong>
+            {m.parts
+              .filter((p) => p.type === 'text')
+              .map((p) => p.text)
+              .join('')}
+            {m.metadata?.status === 'aborted' && <em> (stopped)</em>}
+            {m.metadata?.status === 'error' && <p role="alert">{FAILED}</p>}
+          </div>
+        ))}
+        {error && <p role="alert">{FAILED}</p>}
+      </div>
+      <form
+        onSubmit={(e) => {
+          e.preventDefault();
+          if (!input.trim() || busy) return;
+          sendMessage({ text: input });
+          setInput('');
+        }}
+      >
+        <input
+          aria-label="Message"
+          value={input}
+          onChange={(e) => setInput(e.target.value)}
+          style={{ width: '70%' }}
+        />
+        <button type="submit" disabled={busy}>
+          Send
+        </button>
+        {busy && (
+          <button type="button" onClick={() => stop()}>
+            Stop
+          </button>
+        )}
+        {!busy && (error || last?.role === 'assistant') && (
+          <button type="button" onClick={() => regenerate()}>
+            Regenerate
+          </button>
+        )}
+      </form>
+    </main>
+  );
+}

package/examples/vercel-ai/reference-app/app/chat/[id]/page.jsx

@@ -0,0 +1,20 @@
+import { notFound } from 'next/navigation';
+import { CHAT_ID, activePath, loadChat } from '../../../lib/store.js';
+import Chat from './chat.jsx';
+
+export const dynamic = 'force-dynamic';
+
+export default async function ChatPage({ params }) {
+  const { id } = await params;
+  if (!CHAT_ID.test(id)) notFound();
+  const chat = await loadChat(id);
+  const initialMessages = chat
+    ? activePath(chat).map((m) => ({
+        id: m.id,
+        role: m.role,
+        parts: [{ type: 'text', text: m.text }],
+        metadata: { status: m.status },
+      }))
+    : [];
+  return <Chat id={id} initialMessages={initialMessages} />;
+}

package/examples/vercel-ai/reference-app/app/layout.jsx

@@ -0,0 +1,18 @@
+export const metadata = { title: 'AI SDK reference chat' };
+
+export default function RootLayout({ children }) {
+  return (
+    <html lang="en">
+      <body
+        style={{
+          fontFamily: 'system-ui',
+          maxWidth: 720,
+          margin: '40px auto',
+          padding: 16,
+        }}
+      >
+        {children}
+      </body>
+    </html>
+  );
+}

package/examples/vercel-ai/reference-app/app/page.jsx

@@ -0,0 +1,8 @@
+import { randomUUID } from 'node:crypto';
+import { redirect } from 'next/navigation';
+
+export const dynamic = 'force-dynamic';
+
+export default function Home() {
+  redirect(`/chat/${randomUUID()}`);
+}

package/examples/vercel-ai/reference-app/lib/store.js

@@ -0,0 +1,37 @@
+// File-backed chat store: the reference app's authoritative state.
+// Messages are append-only with parent links, so regeneration adds a sibling branch.
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export const CHAT_ID = /^[a-zA-Z0-9_-]{1,64}$/;
+
+function dir() {
+  if (!process.env.CHAT_STORE_DIR)
+    throw new Error('CHAT_STORE_DIR is required');
+  return process.env.CHAT_STORE_DIR;
+}
+
+export async function loadChat(id) {
+  try {
+    return JSON.parse(await readFile(join(dir(), `${id}.json`), 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+export async function saveChat(chat) {
+  await mkdir(dir(), { recursive: true });
+  const tmp = join(dir(), `.${chat.id}.${randomUUID()}.tmp`);
+  await writeFile(tmp, JSON.stringify(chat));
+  await rename(tmp, join(dir(), `${chat.id}.json`));
+}
+
+// The branch currently shown to the user: root → activeLeafId.
+export function activePath(chat, leafId = chat.activeLeafId) {
+  const byId = new Map(chat.messages.map((m) => [m.id, m]));
+  const path = [];
+  for (let m = byId.get(leafId); m; m = byId.get(m.parentId)) path.unshift(m);
+  return path;
+}

package/examples/vercel-ai/reference-app/next.config.mjs

@@ -0,0 +1,9 @@
+import { fileURLToPath } from 'node:url';
+
+const root = fileURLToPath(new URL('.', import.meta.url));
+
+// Pin the workspace root: this app usually sits inside a verification project with its own lockfile.
+export default {
+  outputFileTracingRoot: root,
+  turbopack: { root },
+};