@arcote.tech/arc-chat 0.4.7 → 0.5.0

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>;

package/src/react/chat-input.tsx

@@ -1,79 +0,0 @@
-import { Trans } from "@arcote.tech/platform";
-import { Box, Button, TextareaField, SearchSelect } from "@arcote.tech/arc-ds";
-import { Send, Globe } from "lucide-react";
-import { useState, type ReactNode } from "react";
-import type { ChatModel, SendMessageOptions } from "./types";
-
-interface ChatInputProps {
-  onSend: (message: string, options: SendMessageOptions) => void;
-  models: ChatModel[];
-  defaultModel?: string;
-  /** Extra toolbar content (e.g., attach menu) rendered after web search toggle */
-  toolbar?: ReactNode;
-}
-
-export function ChatInput({
-  onSend,
-  models,
-  defaultModel,
-  toolbar,
-}: ChatInputProps) {
-  const [message, setMessage] = useState("");
-  const [model, setModel] = useState(defaultModel ?? models[0]?.value ?? "");
-  const [webSearch, setWebSearch] = useState(false);
-
-  const handleSend = () => {
-    const text = message.trim();
-    if (!text) return;
-    onSend(text, { model, webSearch });
-    setMessage("");
-  };
-
-  return (
-    <Box className="p-3 space-y-2">
-      {/* Input + send */}
-      <div className="flex items-end gap-2">
-        <div className="flex-1">
-          <TextareaField
-            value={message}
-            onChange={(val) => setMessage(val ?? "")}
-            placeholder="Napisz wiadomość..."
-            rows={1}
-          />
-        </div>
-        <Button
-          size="sm"
-          icon={Send}
-          onClick={handleSend}
-          disabled={!message.trim()}
-        />
-      </div>
-
-      {/* Toolbar */}
-      <div className="flex items-center gap-1.5">
-        <div className="w-[130px]">
-          <SearchSelect
-            value={model}
-            onChange={setModel}
-            options={models}
-            placeholder="Model..."
-            position="absolute"
-            direction="up"
-            size="sm"
-            allowClear={false}
-          />
-        </div>
-
-        <Button
-          variant={webSearch ? "default" : "ghost"}
-          size="xs"
-          icon={Globe}
-          label={<Trans>Web</Trans>}
-          onClick={() => setWebSearch((v) => !v)}
-        />
-
-        {toolbar}
-      </div>
-    </Box>
-  );
-}

package/src/react/chat-message.tsx

@@ -1,100 +0,0 @@
-import { Trans } from "@arcote.tech/platform";
-import { Button } from "@arcote.tech/arc-ds";
-import { Bot, User, MessageSquare } from "lucide-react";
-import type { ChatMessageData } from "./types";
-import { ToolUseBlock } from "./tool-use-block";
-
-interface ChatMessageProps {
-  message: ChatMessageData;
-  onAnswerQuestions?: () => void;
-  onToolUseClick?: (link: string) => void;
-}
-
-export function ChatMessage({
-  message,
-  onAnswerQuestions,
-  onToolUseClick,
-}: ChatMessageProps) {
-  const isUser = message.role === "user";
-  const hasUnansweredQuestions =
-    message.questions && message.questions.length > 0;
-
-  return (
-    <div className={`flex gap-3 ${isUser ? "flex-row-reverse" : ""}`}>
-      {/* Avatar */}
-      <div
-        className={`flex h-7 w-7 shrink-0 items-center justify-center rounded-full mt-0.5 ${
-          isUser ? "bg-primary/10" : "bg-muted"
-        }`}
-      >
-        {isUser ? (
-          <User className="h-3.5 w-3.5 text-primary" />
-        ) : (
-          <Bot className="h-3.5 w-3.5 text-muted-foreground" />
-        )}
-      </div>
-
-      {/* Content */}
-      <div
-        className={`flex-1 min-w-0 space-y-2 ${isUser ? "text-right" : ""}`}
-      >
-        <div
-          className={`inline-block rounded-2xl px-4 py-2.5 text-sm leading-relaxed ${
-            isUser
-              ? "bg-primary/10 text-foreground rounded-tr-sm"
-              : "bg-card border border-border rounded-tl-sm"
-          }`}
-        >
-          {message.content.split("\n").map((line, i) => (
-            <p key={i} className={i > 0 ? "mt-1.5" : ""}>
-              {line.startsWith("• ") ? (
-                <span className="flex items-start gap-1.5 text-left">
-                  <span className="text-primary mt-px">•</span>
-                  <span>{line.slice(2)}</span>
-                </span>
-              ) : (
-                line
-              )}
-            </p>
-          ))}
-          {message.isStreaming && (
-            <span className="inline-block w-1.5 h-4 bg-foreground/60 animate-pulse ml-0.5 -mb-0.5" />
-          )}
-        </div>
-
-        {/* Tool uses */}
-        {message.toolUses && message.toolUses.length > 0 && (
-          <div className="space-y-1.5">
-            {message.toolUses.map((tu, i) => (
-              <ToolUseBlock
-                key={i}
-                toolUse={tu}
-                onClick={
-                  tu.link && onToolUseClick
-                    ? () => onToolUseClick(tu.link!)
-                    : undefined
-                }
-              />
-            ))}
-          </div>
-        )}
-
-        {/* Questions indicator */}
-        {hasUnansweredQuestions && onAnswerQuestions && (
-          <div className="flex items-center gap-2">
-            <span className="text-xs text-muted-foreground">
-              {message.questions!.length}{" "}
-              <Trans>pytań do odpowiedzenia</Trans>
-            </span>
-            <Button
-              size="xs"
-              icon={MessageSquare}
-              label={<Trans>Odpowiedz</Trans>}
-              onClick={onAnswerQuestions}
-            />
-          </div>
-        )}
-      </div>
-    </div>
-  );
-}

package/src/react/chat.tsx

@@ -1,117 +0,0 @@
-import { useState, useRef, useEffect, type ReactNode } from "react";
-import type {
-  ChatMessageData,
-  ChatModel,
-  QuestionAnswers,
-  SendMessageOptions,
-} from "./types";
-import { ChatMessage } from "./chat-message";
-import { ChatInput } from "./chat-input";
-import { QuestionTabs } from "./question-tabs";
-
-interface ChatProps {
-  /** Message history */
-  messages: ChatMessageData[];
-  /** Available AI models */
-  models: ChatModel[];
-  /** Default model to use */
-  defaultModel?: string;
-  /** Called when user sends a message */
-  onSend: (message: string, options: SendMessageOptions) => void;
-  /** Called when user submits answers to questions */
-  onAnswerQuestions?: (
-    messageId: string,
-    answers: QuestionAnswers,
-  ) => void;
-  /** Called when user clicks a tool use link */
-  onToolUseClick?: (link: string) => void;
-  /** Header content (title, description) */
-  header?: ReactNode;
-  /** Sidebar content (consultation plan, etc.) */
-  sidebar?: ReactNode;
-  /** Extra toolbar content for ChatInput (attach menu, etc.) */
-  toolbar?: ReactNode;
-  /** Max width class for the message area */
-  maxWidth?: string;
-}
-
-export function Chat({
-  messages,
-  models,
-  defaultModel,
-  onSend,
-  onAnswerQuestions,
-  onToolUseClick,
-  header,
-  sidebar,
-  toolbar,
-  maxWidth = "max-w-3xl",
-}: ChatProps) {
-  const [answeringMessageId, setAnsweringMessageId] = useState<string | null>(
-    null,
-  );
-  const messagesEndRef = useRef<HTMLDivElement>(null);
-
-  const answeringMessage = answeringMessageId
-    ? messages.find((m) => m.id === answeringMessageId)
-    : null;
-
-  // Auto-scroll on new messages
-  useEffect(() => {
-    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
-  }, [messages.length]);
-
-  return (
-    <div className="flex gap-6">
-      {/* Sidebar */}
-      {sidebar && (
-        <div className="hidden lg:block w-64 shrink-0 sticky top-24 self-start">
-          {sidebar}
-        </div>
-      )}
-
-      {/* Main chat area */}
-      <div className="flex-1 min-w-0 space-y-4">
-        {/* Header */}
-        {header}
-
-        {/* Messages */}
-        <div className={`${maxWidth} mx-auto space-y-4`}>
-          {messages.map((msg) => (
-            <ChatMessage
-              key={msg.id}
-              message={msg}
-              onAnswerQuestions={
-                msg.questions?.length
-                  ? () => setAnsweringMessageId(msg.id)
-                  : undefined
-              }
-              onToolUseClick={onToolUseClick}
-            />
-          ))}
-          <div ref={messagesEndRef} />
-        </div>
-
-        {/* Input area — sticky at bottom */}
-        <div className={`sticky bottom-0 ${maxWidth} mx-auto w-full pb-4`}>
-          {answeringMessage?.questions ? (
-            <QuestionTabs
-              questions={answeringMessage.questions}
-              onSubmit={(answers) => {
-                onAnswerQuestions?.(answeringMessageId!, answers);
-                setAnsweringMessageId(null);
-              }}
-            />
-          ) : (
-            <ChatInput
-              onSend={onSend}
-              models={models}
-              defaultModel={defaultModel}
-              toolbar={toolbar}
-            />
-          )}
-        </div>
-      </div>
-    </div>
-  );
-}