@arcote.tech/arc-chat 0.5.1 → 0.5.2

package/src/react/use-chat.ts

@@ -1,260 +1 @@
-import { useState, useCallback, useRef, useEffect } from "react";
-import type {
-  ChatStreamEvent,
-  ToolCall,
-  ToolResult,
-} from "@arcote.tech/arc-ai";
-import type { ChatMessageData, ToolUse } from "@arcote.tech/arc-ds";
-
-// ─── Config ─────────────────────────────────────────────────────
-
-export interface UseChatConfig {
-  chatName: string;
-  baseUrl?: string;
-  identifyBy?: string;
-  onClientToolCall?: (toolCalls: ToolCall[]) => Promise<ToolResult[]>;
-  onToolUse?: (toolCall: ToolCall, result: string) => ToolUse | undefined;
-  queries?: {
-    getByScope: (params: { scopeId: string }) => readonly [any[] | undefined, boolean];
-  };
-  mutations?: {
-    sendMessage: (params: Record<string, any>) => Promise<any>;
-  };
-}
-
-// ─── Return Type ────────────────────────────────────────────────
-
-export interface UseChatReturn {
-  messages: ChatMessageData[];
-  isStreaming: boolean;
-  sendMessage: (content: string, options: { model: string }) => Promise<void>;
-  setMessages: React.Dispatch<React.SetStateAction<ChatMessageData[]>>;
-}
-
-// ─── Hook ───────────────────────────────────────────────────────
-
-export function useChat(config: UseChatConfig): UseChatReturn {
-  const [messages, setMessages] = useState<ChatMessageData[]>([]);
-  const [isStreaming, setIsStreaming] = useState(false);
-
-  const configRef = useRef(config);
-  configRef.current = config;
-
-  // Sync identifyBy and load history
-  const scopeId = config.identifyBy;
-  const historyResult = config.queries?.getByScope(
-    scopeId ? { scopeId } : { scopeId: "" },
-  );
-  const historyData = scopeId ? historyResult?.[0] : undefined;
-
-  useEffect(() => {
-    if (!historyData || historyData.length === 0 || isStreaming) return;
-
-    const mapped: ChatMessageData[] = historyData.map((msg) => ({
-      id: msg._id,
-      role: msg.role as "user" | "assistant",
-      content: msg.content,
-    }));
-
-    setMessages(mapped);
-  }, [historyData?.length, scopeId]);
-
-  // Cleanup
-  const eventSourceRef = useRef<EventSource | null>(null);
-  useEffect(() => {
-    return () => {
-      eventSourceRef.current?.close();
-    };
-  }, []);
-
-  const sendMessage = useCallback(
-    async (content: string, options: { model: string }) => {
-      if (isStreaming) return;
-
-      const { mutations, chatName, baseUrl, onClientToolCall, onToolUse } =
-        configRef.current;
-      const currentScopeId = configRef.current.identifyBy;
-
-      if (!mutations || !currentScopeId) {
-        console.error("useChat: mutations or identifyBy not provided");
-        return;
-      }
-
-      setIsStreaming(true);
-
-      const userMsgId = `user_${Date.now()}`;
-      setMessages((prev) => [
-        ...prev,
-        { id: userMsgId, role: "user", content },
-      ]);
-
-      try {
-        const sendResult = await mutations.sendMessage({
-          scopeId: currentScopeId,
-          content,
-          model: options.model,
-        });
-
-        const { sessionId } = sendResult as { sessionId: string; messageId: string };
-        if (!sessionId) {
-          throw new Error("No sessionId returned from sendMessage");
-        }
-
-        const routeBase = baseUrl ?? "";
-        const streamUrl = `${routeBase}/route/chat/${chatName}/stream/${sessionId}`;
-
-        const response = await fetch(streamUrl, {
-          credentials: "include",
-          headers: { Accept: "text/event-stream" },
-        });
-
-        if (!response.ok) {
-          throw new Error(`Stream connection failed: ${response.status}`);
-        }
-
-        const assistantMsgId = `assistant_${Date.now()}`;
-        setMessages((prev) => [
-          ...prev,
-          { id: assistantMsgId, role: "assistant", content: "", isStreaming: true },
-        ]);
-
-        const reader = response.body!.getReader();
-        const decoder = new TextDecoder();
-        let partialLine = "";
-        const toolUses: ToolUse[] = [];
-
-        const processEvent = async (event: ChatStreamEvent) => {
-          switch (event.type) {
-            case "content_delta":
-              if (event.content) {
-                setMessages((prev) =>
-                  prev.map((msg) =>
-                    msg.id === assistantMsgId
-                      ? { ...msg, content: msg.content + event.content }
-                      : msg,
-                  ),
-                );
-              }
-              break;
-
-            case "server_tool_result":
-              if (event.toolResult && event.toolCall) {
-                const toolUse = onToolUse?.(event.toolCall, event.toolResult.content);
-                if (toolUse) {
-                  toolUses.push(toolUse);
-                  setMessages((prev) =>
-                    prev.map((msg) =>
-                      msg.id === assistantMsgId
-                        ? { ...msg, toolUses: [...toolUses] }
-                        : msg,
-                    ),
-                  );
-                }
-              }
-              break;
-
-            case "client_tool_request":
-              if (event.toolCalls && onClientToolCall) {
-                try {
-                  const results = await onClientToolCall(event.toolCalls);
-
-                  const toolsUrl = `${routeBase}/route/chat/${chatName}/tools/${sessionId}`;
-                  await fetch(toolsUrl, {
-                    method: "POST",
-                    credentials: "include",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({ toolResults: results }),
-                  });
-
-                  for (const tc of event.toolCalls) {
-                    const result = results.find((r) => r.toolCallId === tc.id);
-                    if (result) {
-                      const toolUse = onToolUse?.(tc, result.content);
-                      if (toolUse) toolUses.push(toolUse);
-                    }
-                  }
-
-                  if (toolUses.length > 0) {
-                    setMessages((prev) =>
-                      prev.map((msg) =>
-                        msg.id === assistantMsgId
-                          ? { ...msg, toolUses: [...toolUses] }
-                          : msg,
-                      ),
-                    );
-                  }
-                } catch (err) {
-                  console.error("Client tool execution failed:", err);
-                }
-              }
-              break;
-
-            case "done":
-              setMessages((prev) =>
-                prev.map((msg) =>
-                  msg.id === assistantMsgId
-                    ? { ...msg, isStreaming: false }
-                    : msg,
-                ),
-              );
-              setIsStreaming(false);
-              break;
-
-            case "error":
-              setMessages((prev) =>
-                prev.map((msg) =>
-                  msg.id === assistantMsgId
-                    ? { ...msg, content: msg.content || event.error || "An error occurred", isStreaming: false }
-                    : msg,
-                ),
-              );
-              setIsStreaming(false);
-              break;
-          }
-        };
-
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) break;
-
-          const text = partialLine + decoder.decode(value, { stream: true });
-          const lines = text.split("\n");
-          partialLine = lines.pop() ?? "";
-
-          for (const line of lines) {
-            if (line.startsWith("data: ")) {
-              try {
-                const event = JSON.parse(line.slice(6)) as ChatStreamEvent;
-                await processEvent(event);
-              } catch {}
-            }
-          }
-        }
-
-        if (partialLine.startsWith("data: ")) {
-          try {
-            const event = JSON.parse(partialLine.slice(6)) as ChatStreamEvent;
-            await processEvent(event);
-          } catch {}
-        }
-
-        setIsStreaming(false);
-        setMessages((prev) =>
-          prev.map((msg) =>
-            msg.id === assistantMsgId ? { ...msg, isStreaming: false } : msg,
-          ),
-        );
-      } catch (err) {
-        const errorMsg = err instanceof Error ? err.message : "Unknown error";
-        setMessages((prev) => [
-          ...prev,
-          { id: `error_${Date.now()}`, role: "assistant" as const, content: `Error: ${errorMsg}` },
-        ]);
-        setIsStreaming(false);
-      }
-    },
-    [isStreaming],
-  );
-
-  return { messages, isStreaming, sendMessage, setMessages };
-}
+// Removed — use chat().toReactComponent() instead.

package/src/routes/chat-stream-route.ts

@@ -1,25 +1,19 @@
 import { route } from "@arcote.tech/arc";
 import type { Token } from "@arcote.tech/arc-auth";
-import { getStreamSession } from "../streaming/stream-registry";
+import { subscribe } from "../streaming/stream-registry";
 
 export function createChatStreamRoute(config: {
   name: string;
   userToken: Token;
 }) {
   return route(`${config.name}ChatStream`)
-    .path(`/chat/${config.name}/stream/:sessionId`)
+    .path(`/chat/${config.name}/stream/:streamId`)
     .protectBy(config.userToken, () => true)
     .handle({
       GET: async (_ctx, _req: Request, params: Record<string, string>) => {
-        const session = getStreamSession(params.sessionId);
-        if (!session) {
-          return new Response(
-            JSON.stringify({ error: "Session not found" }),
-            { status: 404, headers: { "Content-Type": "application/json" } },
-          );
-        }
+        const stream = subscribe(params.streamId);
 
-        return new Response(session.createReadableStream(), {
+        return new Response(stream, {
           headers: {
             "Content-Type": "text/event-stream",
             "Cache-Control": "no-cache",

package/src/streaming/stream-registry.ts

@@ -1,146 +1,114 @@
-import type { ChatStreamEvent, ToolResult } from "@arcote.tech/arc-ai";
+import type { ChatStreamEvent } from "@arcote.tech/arc-ai";
 
-// ─── Stream Session ─────────────────────────────────────────────
+// ─── ChatStreamManager — per message ID streaming ──────────────
 
-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;
+const streams = new Map<string, Set<ReadableStreamDefaultController<Uint8Array>>>();
+const keepAliveIntervals = new Map<string, ReturnType<typeof setInterval>>();
+const encoder = new TextEncoder();
 
-  function encode(event: ChatStreamEvent): Uint8Array {
-    return encoder.encode(`data: ${JSON.stringify(event)}\n\n`);
-  }
+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 encodePing(): Uint8Array {
+  return encoder.encode(`: ping\n\n`);
+}
 
-  function cleanup() {
-    if (keepAliveInterval) {
-      clearInterval(keepAliveInterval);
-      keepAliveInterval = null;
+export function broadcast(messageId: string, event: ChatStreamEvent): void {
+  const controllers = streams.get(messageId);
+  if (!controllers) return;
+  const data = encode(event);
+  for (const controller of controllers) {
+    try {
+      controller.enqueue(data);
+    } catch {
+      controllers.delete(controller);
     }
   }
+}
 
-  const session: StreamSession = {
-    sessionId,
-
-    push(event: ChatStreamEvent) {
-      if (closed) return;
-      buffer.push(event);
-      if (controller) {
-        try {
-          controller.enqueue(encode(event));
-        } catch {
-          // Client disconnected, ignore
-        }
+export function subscribe(messageId: string): ReadableStream<Uint8Array> {
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      let set = streams.get(messageId);
+      if (!set) {
+        set = new Set();
+        streams.set(messageId, set);
       }
-    },
-
-    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));
+      set.add(controller);
+
+      // Start keep-alive if not running
+      if (!keepAliveIntervals.has(messageId)) {
+        const interval = setInterval(() => {
+          const s = streams.get(messageId);
+          if (s && s.size > 0) {
+            const ping = encodePing();
+            for (const c of s) {
+              try { c.enqueue(ping); } catch { s.delete(c); }
+            }
+          } else {
+            cleanup(messageId);
           }
-
-          startKeepAlive();
-        },
-        cancel() {
-          controller = null;
-          cleanup();
-        },
-      });
+        }, 5000);
+        keepAliveIntervals.set(messageId, interval);
+      }
     },
+    cancel() {
+      // One client disconnected — don't cleanup everything
+    },
+  });
+}
 
-    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);
+export function endStream(messageId: string): void {
+  const controllers = streams.get(messageId);
+  if (controllers) {
+    const done = encode({ type: "done", sessionId: messageId } as any);
+    for (const controller of controllers) {
+      try {
+        controller.enqueue(done);
+        controller.close();
+      } catch {}
+    }
+  }
+  cleanup(messageId);
+}
 
-        toolResultsResolve = (results) => {
-          clearTimeout(timer);
-          toolResultsResolve = null;
-          resolve(results);
-        };
-      });
-    },
+export function hasActiveStream(messageId: string): boolean {
+  const s = streams.get(messageId);
+  return !!s && s.size > 0;
+}
 
-    resolveClientToolResults(results: ToolResult[]) {
-      if (toolResultsResolve) {
-        toolResultsResolve(results);
-      }
-    },
+function cleanup(messageId: string): void {
+  const interval = keepAliveIntervals.get(messageId);
+  if (interval) {
+    clearInterval(interval);
+    keepAliveIntervals.delete(messageId);
+  }
+  streams.delete(messageId);
+}
 
-    close() {
-      if (closed) return;
-      closed = true;
-      cleanup();
-      if (controller) {
-        try {
-          controller.close();
-        } catch {
-          // Already closed
-        }
-        controller = null;
-      }
-    },
+// ─── Legacy exports (for respondToTool compatibility) ───────────
+// TODO: remove after full migration
 
-    isClosed() {
-      return closed;
-    },
-  };
+export interface StreamSession {
+  readonly sessionId: string;
+  push(event: ChatStreamEvent): void;
+  close(): void;
+  isClosed(): boolean;
+}
 
-  sessions.set(sessionId, session);
-  return session;
+export function createStreamSession(sessionId: string): StreamSession {
+  let closed = false;
+  return {
+    sessionId,
+    push(event) { broadcast(sessionId, event); },
+    close() { closed = true; },
+    isClosed() { return closed; },
+  };
 }
 
 export function getStreamSession(sessionId: string): StreamSession | undefined {
-  return sessions.get(sessionId);
+  return undefined;
 }
 
-export function deleteStreamSession(sessionId: string): void {
-  const session = sessions.get(sessionId);
-  if (session) {
-    session.close();
-    sessions.delete(sessionId);
-  }
-}
+export function deleteStreamSession(sessionId: string): void {}

package/src/tools/ask-questions.tsx

@@ -0,0 +1,107 @@
+import { useEffect } from "react";
+import { tool } from "@arcote.tech/arc-ai";
+import { string, array, object } from "@arcote.tech/arc";
+import { ChatToolQuestion, QuestionTabs, useChatInput } from "@arcote.tech/arc-ds";
+import type { Question, QuestionAnswers } from "@arcote.tech/arc-ds";
+
+type AskQuestionsParams = {
+  readonly comment: string;
+  readonly questions: readonly {
+    readonly id: string;
+    readonly label: string;
+    readonly description: string;
+    readonly options: readonly string[];
+  }[];
+};
+
+function AskQuestionsView({
+  params,
+  respond,
+  calling,
+  result,
+}: {
+  params: AskQuestionsParams;
+  respond: (result: QuestionAnswers) => void;
+  calling: boolean;
+  result?: QuestionAnswers;
+}) {
+  const { registerInputOverride, clearInputOverride } = useChatInput();
+
+  useEffect(() => {
+    if (calling) {
+      const questions: Question[] = params.questions.map((q) => ({
+        id: q.id,
+        label: q.label,
+        description: q.description,
+        options: [...q.options],
+      }));
+
+      registerInputOverride(
+        <QuestionTabs
+          questions={questions}
+          onSubmit={(answers) => {
+            respond(answers);
+            clearInputOverride();
+          }}
+        />,
+      );
+    }
+
+    return () => clearInputOverride();
+  }, [calling]);
+
+  // Answered — show summary
+  if (!calling && result) {
+    const answers = result as Record<string, { selected?: string[]; text?: string }>;
+    return (
+      <ChatToolQuestion calling={false}>
+        {params.comment && (
+          <p className="text-sm mb-2">{params.comment}</p>
+        )}
+        <div className="space-y-1.5">
+          {Object.entries(answers).map(([questionId, answer]) => {
+            const question = params.questions.find((q) => q.id === questionId);
+            const selected = answer?.selected?.length ? answer.selected.join(", ") : "";
+            const text = answer?.text || "";
+            const value = [selected, text].filter(Boolean).join(" — ");
+            return value ? (
+              <div key={questionId}>
+                <span className="text-xs font-medium">{question?.label ?? questionId}: </span>
+                <span className="text-xs text-muted-foreground">{value}</span>
+              </div>
+            ) : null;
+          })}
+        </div>
+      </ChatToolQuestion>
+    );
+  }
+
+  // Waiting for response
+  return (
+    <ChatToolQuestion calling={true}>
+      {params.comment && (
+        <p className="text-sm mb-1">{params.comment}</p>
+      )}
+      <p className="text-xs text-muted-foreground">
+        Odpowiedz na pytania poniżej
+      </p>
+    </ChatToolQuestion>
+  );
+}
+
+export const askQuestions = tool("askQuestions")
+  .description(
+    "Zadaj użytkownikowi pytania z predefiniowanymi odpowiedziami. ZAWSZE podaj comment — krótki, entuzjastyczny komentarz do tego co użytkownik napisał.",
+  )
+  .withParams({
+    comment: string(),
+    questions: array(
+      object({
+        id: string(),
+        label: string(),
+        description: string(),
+        options: array(string()),
+      }),
+    ),
+  })
+  .view(AskQuestionsView as any);

package/src/routes/tool-results-route.ts

@@ -1,49 +0,0 @@
-import { route } from "@arcote.tech/arc";
-import type { Token } from "@arcote.tech/arc-auth";
-import { getStreamSession } from "../streaming/stream-registry";
-
-export function createToolResultsRoute(config: {
-  name: string;
-  userToken: Token;
-}) {
-  return route(`${config.name}ChatToolResults`)
-    .path(`/chat/${config.name}/tools/:sessionId`)
-    .protectBy(config.userToken, () => true)
-    .handle({
-      POST: async (
-        _ctx,
-        req: Request,
-        params: Record<string, string>,
-      ) => {
-        const session = getStreamSession(params.sessionId);
-        if (!session) {
-          return new Response(
-            JSON.stringify({ error: "Session not found" }),
-            { status: 404, headers: { "Content-Type": "application/json" } },
-          );
-        }
-
-        if (session.isClosed()) {
-          return new Response(
-            JSON.stringify({ error: "Session already closed" }),
-            { status: 410, headers: { "Content-Type": "application/json" } },
-          );
-        }
-
-        const body = (await req.json()) as {
-          toolResults: Array<{
-            toolCallId: string;
-            name: string;
-            content: string;
-            isError: boolean;
-          }>;
-        };
-
-        session.resolveClientToolResults(body.toolResults);
-
-        return new Response(JSON.stringify({ ok: true }), {
-          headers: { "Content-Type": "application/json" },
-        });
-      },
-    });
-}