@arcote.tech/arc-chat 0.4.9 → 0.5.1

package/src/streaming/stream-registry.ts

@@ -0,0 +1,146 @@
+import type { ChatStreamEvent, ToolResult } from "@arcote.tech/arc-ai";
+
+// ─── Stream Session ─────────────────────────────────────────────
+
+export interface StreamSession {
+  readonly sessionId: string;
+  push(event: ChatStreamEvent): void;
+  createReadableStream(): ReadableStream<Uint8Array>;
+  waitForClientToolResults(timeoutMs?: number): Promise<ToolResult[]>;
+  resolveClientToolResults(results: ToolResult[]): void;
+  close(): void;
+  isClosed(): boolean;
+}
+
+// ─── Registry ───────────────────────────────────────────────────
+
+const sessions = new Map<string, StreamSession>();
+
+export function createStreamSession(sessionId: string): StreamSession {
+  const existing = sessions.get(sessionId);
+  if (existing) return existing;
+
+  let controller: ReadableStreamDefaultController<Uint8Array> | null = null;
+  let closed = false;
+  const encoder = new TextEncoder();
+  const buffer: ChatStreamEvent[] = [];
+
+  // Client tool results coordination
+  let toolResultsResolve: ((results: ToolResult[]) => void) | null = null;
+
+  // Keep-alive interval
+  let keepAliveInterval: ReturnType<typeof setInterval> | null = null;
+
+  function encode(event: ChatStreamEvent): Uint8Array {
+    return encoder.encode(`data: ${JSON.stringify(event)}\n\n`);
+  }
+
+  function startKeepAlive() {
+    keepAliveInterval = setInterval(() => {
+      if (controller && !closed) {
+        try {
+          controller.enqueue(encoder.encode(`: ping\n\n`));
+        } catch {
+          // Controller closed, clean up
+          cleanup();
+        }
+      }
+    }, 5000);
+  }
+
+  function cleanup() {
+    if (keepAliveInterval) {
+      clearInterval(keepAliveInterval);
+      keepAliveInterval = null;
+    }
+  }
+
+  const session: StreamSession = {
+    sessionId,
+
+    push(event: ChatStreamEvent) {
+      if (closed) return;
+      buffer.push(event);
+      if (controller) {
+        try {
+          controller.enqueue(encode(event));
+        } catch {
+          // Client disconnected, ignore
+        }
+      }
+    },
+
+    createReadableStream(): ReadableStream<Uint8Array> {
+      return new ReadableStream<Uint8Array>({
+        start(ctrl) {
+          controller = ctrl;
+
+          // Replay buffered events for late-connecting clients
+          for (const event of buffer) {
+            ctrl.enqueue(encode(event));
+          }
+
+          startKeepAlive();
+        },
+        cancel() {
+          controller = null;
+          cleanup();
+        },
+      });
+    },
+
+    waitForClientToolResults(timeoutMs = 60_000): Promise<ToolResult[]> {
+      return new Promise<ToolResult[]>((resolve, reject) => {
+        const timer = setTimeout(() => {
+          toolResultsResolve = null;
+          reject(new Error("Client tool results timeout"));
+        }, timeoutMs);
+
+        toolResultsResolve = (results) => {
+          clearTimeout(timer);
+          toolResultsResolve = null;
+          resolve(results);
+        };
+      });
+    },
+
+    resolveClientToolResults(results: ToolResult[]) {
+      if (toolResultsResolve) {
+        toolResultsResolve(results);
+      }
+    },
+
+    close() {
+      if (closed) return;
+      closed = true;
+      cleanup();
+      if (controller) {
+        try {
+          controller.close();
+        } catch {
+          // Already closed
+        }
+        controller = null;
+      }
+    },
+
+    isClosed() {
+      return closed;
+    },
+  };
+
+  sessions.set(sessionId, session);
+  return session;
+}
+
+export function getStreamSession(sessionId: string): StreamSession | undefined {
+  return sessions.get(sessionId);
+}
+
+export function deleteStreamSession(sessionId: string): void {
+  const session = sessions.get(sessionId);
+  if (session) {
+    session.close();
+    sessions.delete(sessionId);
+  }
+}

package/src/aggregates/conversation.ts

@@ -1,151 +0,0 @@
-/// <reference path="../arc.d.ts" />
-import {
-  aggregate,
-  date,
-  id,
-  number,
-  string,
-  type ArcId,
-} from "@arcote.tech/arc";
-import type { Token } from "@arcote.tech/arc-auth";
-
-// ─── ID ──────────────────────────────────────────────────────────
-
-export const createConversationId = <const Name extends string>(data: {
-  name: Name;
-}) => id(`${data.name}Conversation`);
-
-export type ConversationId<Name extends string = string> = ReturnType<
-  typeof createConversationId<Name>
->;
-
-// ─── Aggregate ───────────────────────────────────────────────────
-
-export type ConversationAggregateData = {
-  name: string;
-  conversationId: ArcId<any>;
-  accountId: ArcId<any>;
-  userToken: Token;
-};
-
-export const createConversationAggregate = <
-  const Data extends ConversationAggregateData,
->(
-  data: Data,
-) => {
-  const { conversationId, accountId, userToken } = data;
-
-  return aggregate(
-    `${data.name}Conversations`,
-    conversationId,
-    {
-      accountId,
-      title: string(),
-      model: string(),
-      createdAt: date(),
-      lastMessageAt: date().optional(),
-      messageCount: number(),
-    },
-  )
-    .publicEvent(
-      "conversationCreated",
-      {
-        conversationId,
-        accountId,
-        title: string(),
-        model: string(),
-      },
-      async (ctx, event) => {
-        const p = event.payload;
-        await ctx.set(p.conversationId, {
-          accountId: p.accountId,
-          title: p.title,
-          model: p.model,
-          createdAt: event.createdAt,
-          messageCount: 0,
-        });
-      },
-    )
-
-    .publicEvent(
-      "conversationRenamed",
-      {
-        conversationId,
-        title: string(),
-      },
-      async (ctx, event) => {
-        await ctx.modify(event.payload.conversationId, {
-          title: event.payload.title,
-        });
-      },
-    )
-
-    .publicEvent(
-      "conversationUpdated",
-      {
-        conversationId,
-        messageCount: number(),
-      },
-      async (ctx, event) => {
-        await ctx.modify(event.payload.conversationId, {
-          lastMessageAt: event.createdAt,
-          messageCount: event.payload.messageCount,
-        });
-      },
-    )
-
-    .mutateMethod(
-      "create",
-      {
-        params: {
-          title: string().optional(),
-          model: string(),
-        },
-      },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          const cId = conversationId.generate();
-          const aId = ctx.$auth.params.accountId;
-
-          await ctx.conversationCreated.emit({
-            conversationId: cId,
-            accountId: accountId.parse(aId),
-            title: params.title ?? "New conversation",
-            model: params.model,
-          });
-
-          return { conversationId: cId };
-        }),
-    )
-
-    .mutateMethod(
-      "rename",
-      {
-        params: {
-          _id: conversationId,
-          title: string().minLength(1),
-        },
-      },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          await ctx.conversationRenamed.emit({
-            conversationId: params._id,
-            title: params.title,
-          });
-
-          return { success: true };
-        }),
-    )
-
-    .clientQuery("getAll", async (ctx) => ctx.$query.find({}))
-    .clientQuery(
-      "getById",
-      async (ctx, params: { _id: string }) =>
-        ctx.$query.findOne({ _id: params._id }),
-    )
-
-    .protectBy(userToken, (p) => ({ accountId: p.accountId }))
-;
-};
-
-export type ConversationAggregate = ReturnType<typeof createConversationAggregate>;