kyd-shared-badge 0.3.38 → 0.3.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kyd-shared-badge",
-  "version": "0.3.38",
+  "version": "0.3.39",
   "private": false,
   "main": "./src/index.ts",
   "module": "./src/index.ts",

package/src/lib/routes.ts

@@ -20,6 +20,7 @@ import { createSession } from './chat-store';
 
 export const runtime = 'nodejs';
 
+
 export async function chatStreamRoute(req: NextRequest, userId: string, companyId?: string) {
   try {
 
@@ -41,43 +42,99 @@ export async function chatStreamRoute(req: NextRequest, userId: string, companyI
     const graphData = await getReportGraphData(badgeId);
     const system = buildAllContextPrompt(cleaned, graphData, { concise: true });
     const history = await getHistory(sessionId, 20);
+    const apiKey = process.env.OPENROUTER_API_KEY;
+    if (!apiKey) {
+      return Response.json({ error: 'Server misconfigured: missing OPENROUTER_API_KEY' }, { status: 500 });
+    }
+
+    const chatMessages = [
+      { role: 'system', content: system },
+      ...history.map((m: any) => ({ role: m.role, content: m.content })),
+      { role: 'user', content },
+    ];
+
+    const upstream = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model: 'openai/o4-mini',
+        messages: chatMessages,
+        stream: true,
+        max_tokens: 1024,
+      }),
+    });
+
+    if (!upstream.ok || !upstream.body) {
+      const errText = await upstream.text().catch(() => '');
+      return Response.json({ error: `Upstream error: ${upstream.status}`, details: errText }, { status: 502 });
+    }
 
-    const openrouter = createOpenAI({
-      apiKey: process.env.OPENROUTER_API_KEY,
-      baseURL: 'https://openrouter.ai/api/v1',
+    const encoder = new TextEncoder();
+    let sseBuffer = '';
+    let assistantText = '';
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        const reader = upstream.body!.getReader();
+        const decoder = new TextDecoder();
+        const pump = async (): Promise<void> => {
+          try {
+            const { value, done } = await reader.read();
+            if (done) {
+              try { if (assistantText) await putMessage({ sessionId, role: 'assistant', content: assistantText }); } catch {}
+              controller.close();
+              return;
+            }
+            sseBuffer += decoder.decode(value, { stream: true });
+            const lines = sseBuffer.split(/\r?\n/);
+            sseBuffer = lines.pop() ?? '';
+            for (const l of lines) {
+              const line = l.trim();
+              if (!line.startsWith('data:')) continue;
+              const data = line.slice(5).trim();
+              if (!data) continue;
+              if (data === '[DONE]') {
+                try { if (assistantText) await putMessage({ sessionId, role: 'assistant', content: assistantText }); } catch {}
+                controller.close();
+                return;
+              }
+              try {
+                const json = JSON.parse(data);
+                const delta = json?.choices?.[0]?.delta?.content ?? '';
+                if (delta) {
+                  assistantText += delta;
+                  controller.enqueue(encoder.encode(delta));
+                }
+              } catch {}
+            }
+            pump();
+          } catch (err) {
+            controller.error(err);
+          }
+        };
+        pump();
+      },
+      cancel() {
+        try { (upstream as any).body?.cancel?.(); } catch {}
+      },
     });
 
-    const result = await streamText({
-      model: openrouter('openai/o4-mini'),
-      system,
-      messages: [...history, { role: 'user' as const, content }],
-      maxTokens: 1024,
-      temperature: 0.2,
-      // onFinish: async ({ text }: { text: string }) => {
-      //   // Attempt to capture evidence block if present (UI also parses, but cache server-side)
-      //   const evidence = tryParseEvidenceServer(text);
-      //   await putMessage({ sessionId, role: 'assistant', content: text, evidenceJson: evidence || undefined });
-      // },
+    return new Response(stream, {
+      headers: {
+        'Content-Type': 'text/plain; charset=utf-8',
+        'Cache-Control': 'no-cache, no-transform',
+        'X-Accel-Buffering': 'no',
+      },
     });
 
-    return result.toTextStreamResponse();
   } catch (e) {
     console.error('chat error', e);
     return new Response('An error occurred. Please try again.', { status: 500 });
   }
 }
 
-// function tryParseEvidenceServer(text: string): any | null {
-//   try {
-//     const start = text.indexOf('```json');
-//     const end = text.indexOf('```', start + 7);
-//     const raw = start >= 0 && end > start ? text.slice(start + 7, end).trim() : text.trim();
-//     const obj = JSON.parse(raw);
-//     if (obj && obj.type === 'evidence' && Array.isArray(obj.claims)) return obj;
-//   } catch {}
-//   return null;
-// }
-
 export async function createSessionRoute(req: NextRequest, userId: string, companyId?: string) {
   try {
     const body = await req.json().catch(() => ({}));