@arcote.tech/arc-chat 0.7.19 → 0.7.21

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

@@ -5,19 +5,33 @@ import { subscribe } from "../streaming/stream-registry";
 export function createChatStreamRoute(config: {
   name: string;
   userToken: Token;
+  /** Message aggregate tego chatu — używany do lazy repair przy 410. */
+  messageElement: any;
 }) {
+  const { messageElement } = config;
   return route(`${config.name}ChatStream`)
     .path(`/chat/${config.name}/stream/:messageId`)
     .protectBy(config.userToken, () => true)
+    .mutate([messageElement])
     .handle({
-      GET: async (_ctx, _req: Request, params: Record<string, string>) => {
+      GET: async (ctx: any, _req: Request, params: Record<string, string>) => {
         const result = subscribe(params.messageId);
         if (!result) {
           // Brak in-memory streamu: generacja zakończona poza grace window
-          // ALBO proces zrestartował się mid-stream. Klient rozróżnia
-          // sytuacje po `isGenerating` w DB: jeśli row ma `isGenerating=false`
-          // → użyj final `blocks`, jeśli `true` → "Generation interrupted"
-          // + retry.
+          // ALBO proces zrestartował się mid-stream. Lazy repair: jeśli row
+          // w DB nadal ma `isGenerating=true` i jest wystarczająco stary
+          // (nie ściga się ze świeżym startStream), flipujemy go trwale na
+          // `interrupted` — pierwszy klient, który odkryje sierotę, naprawia
+          // ją dla wszystkich (cross-client, przeżywa F5). Walidacja wieku
+          // i stanu rowa siedzi w mutacji `markInterrupted` (no-op gdy
+          // warunki niespełnione), więc wołamy ją przy każdym 410.
+          try {
+            await ctx.mutate(messageElement).markInterrupted({
+              messageId: params.messageId,
+            });
+          } catch {
+            // Best-effort: klient i tak obsłuży 410 retry/interrupted path.
+          }
           return new Response(
             JSON.stringify({
               error: "stream_not_found",

package/src/streaming/blocks-reducer.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "bun:test";
+import type { AssistantContentBlock } from "@arcote.tech/arc-ai";
+import { applyStreamEvent, type StreamBlocksEvent } from "./blocks-reducer";
+
+function replay(
+  base: AssistantContentBlock[],
+  events: StreamBlocksEvent[],
+): AssistantContentBlock[] {
+  return events.reduce(applyStreamEvent, base);
+}
+
+/** Reprezentatywny turn: tekst → tool call → args → dalszy tekst. */
+const TURN_EVENTS: StreamBlocksEvent[] = [
+  { type: "text_delta", textDelta: "Cześć" },
+  { type: "text_delta", textDelta: ", już " },
+  { type: "text_delta", textDelta: "sprawdzam." },
+  { type: "tool_call_pending", toolCallId: "tc1", toolCallName: "search" },
+  {
+    type: "tool_call_arguments_delta",
+    toolCallId: "tc1",
+    // argumentsDelta nie mutuje blocks — identity
+  },
+  {
+    type: "tool_call_arguments_complete",
+    toolCallId: "tc1",
+    toolCallName: "search",
+    arguments: { query: "arc" },
+  },
+  { type: "usage_update" },
+  { type: "tool_call_pending", toolCallId: "tc2" },
+  {
+    type: "tool_call_arguments_complete",
+    toolCallId: "tc2",
+    toolCallName: "lateName",
+    arguments: { a: 1 },
+  },
+  { type: "text_delta", textDelta: "Drugi blok tekstu" },
+  { type: "done" },
+];
+
+describe("applyStreamEvent — semantyka bloków", () => {
+  it("text_delta dokleja do ostatniego text blocka lub tworzy nowy", () => {
+    let blocks: AssistantContentBlock[] = [];
+    blocks = applyStreamEvent(blocks, { type: "text_delta", textDelta: "a" });
+    blocks = applyStreamEvent(blocks, { type: "text_delta", textDelta: "b" });
+    expect(blocks).toEqual([{ type: "text", text: "ab" }]);
+
+    blocks = applyStreamEvent(blocks, {
+      type: "tool_call_pending",
+      toolCallId: "t1",
+    });
+    blocks = applyStreamEvent(blocks, { type: "text_delta", textDelta: "c" });
+    expect(blocks).toEqual([
+      { type: "text", text: "ab" },
+      { type: "tool_call", id: "t1", name: "", arguments: {} },
+      { type: "text", text: "c" },
+    ]);
+  });
+
+  it("pusty text_delta jest identity", () => {
+    const blocks: AssistantContentBlock[] = [{ type: "text", text: "x" }];
+    expect(applyStreamEvent(blocks, { type: "text_delta" })).toBe(blocks);
+  });
+
+  it("tool_call_arguments_complete aktualizuje args i nazwę po toolCallId", () => {
+    const blocks = replay([], [
+      { type: "tool_call_pending", toolCallId: "t1" },
+      {
+        type: "tool_call_arguments_complete",
+        toolCallId: "t1",
+        toolCallName: "named",
+        arguments: { x: 1 },
+      },
+    ]);
+    expect(blocks).toEqual([
+      { type: "tool_call", id: "t1", name: "named", arguments: { x: 1 } },
+    ]);
+  });
+
+  it("tool_call_arguments_complete dla nieznanego id jest identity", () => {
+    const blocks: AssistantContentBlock[] = [{ type: "text", text: "x" }];
+    expect(
+      applyStreamEvent(blocks, {
+        type: "tool_call_arguments_complete",
+        toolCallId: "ghost",
+        arguments: {},
+      }),
+    ).toBe(blocks);
+  });
+
+  it("eventy nie kształtujące blocks są identity (ta sama referencja)", () => {
+    const blocks: AssistantContentBlock[] = [{ type: "text", text: "x" }];
+    for (const type of [
+      "init",
+      "tool_call_arguments_delta",
+      "tool_call_executed",
+      "interactive_tool_request",
+      "usage_update",
+      "done",
+      "error",
+    ]) {
+      expect(applyStreamEvent(blocks, { type })).toBe(blocks);
+    }
+  });
+
+  it("nigdy nie mutuje wejścia", () => {
+    const base: AssistantContentBlock[] = [
+      { type: "text", text: "stary" },
+      { type: "tool_call", id: "t1", name: "n", arguments: { a: 1 } },
+    ];
+    const frozen = JSON.stringify(base);
+    replay(base, TURN_EVENTS);
+    expect(JSON.stringify(base)).toBe(frozen);
+  });
+});
+
+describe("applyStreamEvent — inwariant reconnectu (snapshot + replay)", () => {
+  it("snapshot w dowolnym punkcie K + replay reszty == pełny replay", () => {
+    const full = replay([], TURN_EVENTS);
+    for (let k = 0; k <= TURN_EVENTS.length; k++) {
+      const snapshot = replay([], TURN_EVENTS.slice(0, k));
+      const resumed = replay(snapshot, TURN_EVENTS.slice(k));
+      expect(resumed).toEqual(full);
+    }
+  });
+});

package/src/streaming/blocks-reducer.ts

@@ -0,0 +1,88 @@
+import type { AssistantContentBlock } from "@arcote.tech/arc-ai";
+
+// ─── Shared stream→blocks reducer ────────────────────────────────
+//
+// Jedyna implementacja semantyki "jak eventy streamu budują
+// AssistantContentBlock[]". Używana w DWÓCH miejscach:
+//   - serwer: `stream-registry.publish()` akumuluje `currentBlocks`,
+//   - klient: hook overlayów aplikuje delty na bazie z eventu `init`.
+//
+// Inwariant reconnectu: snapshot blocks w dowolnym punkcie K + replay
+// eventów od K == pełny replay wszystkich eventów. Dzięki temu `init`
+// (snapshot) + dalsze delty dają na kliencie identyczny stan co na
+// serwerze — bez sekwencerów i bufora replay.
+
+/**
+ * Strukturalny podzbiór eventu streamu — pasuje zarówno do
+ * `PublishableEvent` (serwer), jak i `ChatStreamEvent` (klient/SSE).
+ */
+export interface StreamBlocksEvent {
+  type: string;
+  textDelta?: string;
+  toolCallId?: string;
+  toolCallName?: string;
+  arguments?: Record<string, unknown>;
+}
+
+/**
+ * Czysta funkcja: zwraca NOWĄ tablicę blocks z zaaplikowanym eventem
+ * (structural sharing — niezmienione bloki są reused). Eventy nie
+ * mutujące blocks (`done`, `usage_update`, `tool_call_arguments_delta`,
+ * `error`, ...) zwracają wejściową tablicę bez zmian.
+ *
+ * Nigdy nie mutuje wejścia — snapshoty trzymane przez subskrybentów
+ * (event `init`) i poprzednie stany Reacta pozostają nietknięte.
+ */
+export function applyStreamEvent(
+  blocks: AssistantContentBlock[],
+  event: StreamBlocksEvent,
+): AssistantContentBlock[] {
+  switch (event.type) {
+    case "text_delta": {
+      if (!event.textDelta) return blocks;
+      const last = blocks[blocks.length - 1];
+      if (last && last.type === "text") {
+        return [
+          ...blocks.slice(0, -1),
+          { type: "text", text: last.text + event.textDelta },
+        ];
+      }
+      return [...blocks, { type: "text", text: event.textDelta }];
+    }
+
+    case "tool_call_pending": {
+      if (!event.toolCallId) return blocks;
+      return [
+        ...blocks,
+        {
+          type: "tool_call",
+          id: event.toolCallId,
+          name: event.toolCallName ?? "",
+          arguments: {},
+        },
+      ];
+    }
+
+    case "tool_call_arguments_complete": {
+      if (!event.toolCallId) return blocks;
+      const idx = blocks.findIndex(
+        (b) => b.type === "tool_call" && b.id === event.toolCallId,
+      );
+      if (idx === -1) return blocks;
+      const block = blocks[idx] as Extract<
+        AssistantContentBlock,
+        { type: "tool_call" }
+      >;
+      const next = blocks.slice();
+      next[idx] = {
+        ...block,
+        arguments: event.arguments ?? {},
+        name: event.toolCallName ?? block.name,
+      };
+      return next;
+    }
+
+    default:
+      return blocks;
+  }
+}

package/src/streaming/stream-registry.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "bun:test";
+import {
+  finalize,
+  getCurrentBlocks,
+  isActive,
+  publish,
+  startStream,
+  subscribe,
+} from "./stream-registry";
+
+let nextId = 0;
+const freshId = () => `msg_test_${nextId++}`;
+
+describe("stream-registry — akumulacja przez shared reducer", () => {
+  it("publish akumuluje currentBlocks identycznie jak reducer", () => {
+    const id = freshId();
+    startStream(id);
+    publish(id, { type: "text_delta", textDelta: "Hej" });
+    publish(id, { type: "text_delta", textDelta: "!" });
+    publish(id, { type: "tool_call_pending", toolCallId: "t1", toolCallName: "x" });
+    publish(id, {
+      type: "tool_call_arguments_complete",
+      toolCallId: "t1",
+      arguments: { q: 1 },
+    });
+    expect(getCurrentBlocks(id)).toEqual([
+      { type: "text", text: "Hej!" },
+      { type: "tool_call", id: "t1", name: "x", arguments: { q: 1 } },
+    ]);
+    finalize(id);
+  });
+
+  it("snapshot z subscribe() jest stabilny mimo kolejnych publishy", () => {
+    const id = freshId();
+    startStream(id);
+    publish(id, { type: "text_delta", textDelta: "abc" });
+
+    const sub = subscribe(id);
+    expect(sub).not.toBeNull();
+    const snapshot = sub!.currentBlocks;
+    expect(snapshot).toEqual([{ type: "text", text: "abc" }]);
+
+    publish(id, { type: "text_delta", textDelta: "def" });
+    publish(id, { type: "tool_call_pending", toolCallId: "t1" });
+
+    // Immutable reducer: snapshot nietknięty, registry poszło dalej.
+    expect(snapshot).toEqual([{ type: "text", text: "abc" }]);
+    expect(getCurrentBlocks(id)).toEqual([
+      { type: "text", text: "abcdef" },
+      { type: "tool_call", id: "t1", name: "", arguments: {} },
+    ]);
+    finalize(id);
+  });
+
+  it("publish po finalize jest no-opem", () => {
+    const id = freshId();
+    startStream(id);
+    publish(id, { type: "text_delta", textDelta: "a" });
+    finalize(id);
+    expect(isActive(id)).toBe(false);
+    publish(id, { type: "text_delta", textDelta: "b" });
+    expect(getCurrentBlocks(id)).toEqual([{ type: "text", text: "a" }]);
+  });
+});

package/src/streaming/stream-registry.ts

@@ -6,12 +6,14 @@ import type {
   ToolCall,
   ToolResult,
 } from "@arcote.tech/arc-ai";
+import { applyStreamEvent } from "./blocks-reducer";
 
 // ─── Per-message in-memory stream registry ──────────────────────────
 //
 // Live state of an in-progress assistant message lives ONLY here, never in
 // DB. `currentBlocks` accumulates text + tool_call blocks as the LLM streams.
-// Each `publish()` mutates it AND broadcasts the SSE event to subscribers.
+// Each `publish()` applies the shared `applyStreamEvent` reducer (immutable)
+// AND broadcasts the SSE event to subscribers.
 // A new subscriber receives `{ type: "init", currentBlocks }` as the first
 // event — that's the snapshot of the in-memory state — and then live events.
 //
@@ -26,11 +28,13 @@ import type {
 
 interface MessageStream {
   messageId: string;
+  /**
+   * Akumulowany stan bloków — aktualizowany WYŁĄCZNIE przez immutable
+   * `applyStreamEvent` (shared reducer, ten sam kod co klient). Każdy
+   * publish podmienia referencję; wcześniej rozdane snapshoty (`init`)
+   * pozostają nietknięte.
+   */
   currentBlocks: AssistantContentBlock[];
-  toolCallsById: Map<
-    string,
-    Extract<AssistantContentBlock, { type: "tool_call" }>
-  >;
   subscribers: Set<ReadableStreamDefaultController<Uint8Array>>;
   keepAliveInterval?: ReturnType<typeof setInterval>;
   /**
@@ -88,7 +92,6 @@ export function startStream(messageId: string): void {
   const s: MessageStream = {
     messageId,
     currentBlocks: [],
-    toolCallsById: new Map(),
     subscribers: new Set(),
     finalized: false,
   };
@@ -156,8 +159,13 @@ export type PublishableEvent =
   | { type: "error"; error: string; executionCount?: number };
 
 /**
- * Mutate the in-memory `currentBlocks` for the relevant event types, then
- * broadcast the event to all active subscribers as SSE.
+ * Apply the event to the in-memory `currentBlocks` (via the shared
+ * `applyStreamEvent` reducer — the same code the client runs on SSE
+ * events), then broadcast the event to all active subscribers as SSE.
+ *
+ * Events that don't shape blocks (`tool_call_arguments_delta`,
+ * `tool_call_executed`, `interactive_tool_request`, `usage_update`,
+ * `error`) are broadcast-only — the reducer returns the input unchanged.
  *
  * No-op if the stream has been finalized or never started (race with a
  * client disconnect / listener teardown).
@@ -166,42 +174,7 @@ export function publish(messageId: string, event: PublishableEvent): void {
   const s = streams.get(messageId);
   if (!s || s.finalized) return;
 
-  switch (event.type) {
-    case "text_delta": {
-      const last = s.currentBlocks[s.currentBlocks.length - 1];
-      if (last && last.type === "text") {
-        last.text += event.textDelta;
-      } else {
-        s.currentBlocks.push({ type: "text", text: event.textDelta });
-      }
-      break;
-    }
-    case "tool_call_pending": {
-      const block: Extract<AssistantContentBlock, { type: "tool_call" }> = {
-        type: "tool_call",
-        id: event.toolCallId,
-        name: event.toolCallName ?? "",
-        arguments: {},
-      };
-      s.currentBlocks.push(block);
-      s.toolCallsById.set(event.toolCallId, block);
-      break;
-    }
-    case "tool_call_arguments_complete": {
-      const block = s.toolCallsById.get(event.toolCallId);
-      if (block) {
-        block.arguments = event.arguments;
-        if (event.toolCallName) block.name = event.toolCallName;
-      }
-      break;
-    }
-    // tool_call_arguments_delta, tool_call_executed, interactive_tool_request,
-    // usage_update, error — broadcast-only. They don't mutate `currentBlocks`:
-    //  - args_delta is incremental JSON the listener replaces via args_complete
-    //  - executed / interactive_tool_request relate to tool execution flow
-    //    (tool_result rows exist separately in DB)
-    //  - usage_update / error are transient signals to the UI
-  }
+  s.currentBlocks = applyStreamEvent(s.currentBlocks, event);
 
   const payload = { ...event, messageId } as ChatStreamEvent;
   const data = encode(payload);
@@ -232,11 +205,10 @@ export function subscribe(messageId: string): {
   const s = streams.get(messageId);
   if (!s) return null;
 
-  // Deep snapshot — the subscriber sees a stable `init` payload even if the
-  // listener mutates `currentBlocks` on a parallel publish.
-  const snapshot: AssistantContentBlock[] = JSON.parse(
-    JSON.stringify(s.currentBlocks),
-  );
+  // Stable snapshot for free: `applyStreamEvent` never mutates — every
+  // publish swaps the `currentBlocks` reference, so the array we capture
+  // here can't change under the subscriber.
+  const snapshot: AssistantContentBlock[] = s.currentBlocks;
 
   const stream = new ReadableStream<Uint8Array>({
     start(controller) {

package/src/tools/ask-questions.tsx

@@ -39,10 +39,13 @@ function AskQuestionsView({
   const { registerInputOverride, clearInputOverride } = useChatInput();
   const { answerBelowLabel } = useChatLabels();
 
+  // Dep po TREŚCI pytań, nie referencji: derywacja timeline'u tworzy nowe
+  // obiekty params przy każdym przeliczeniu, a effect ma się odpalić tylko
+  // gdy pytania faktycznie dotrą / zmienią się (np. zamontowano komponent
+  // zanim argumenty toola się zestreamowały).
+  const questionsKey = JSON.stringify(params.questions ?? null);
+
   useEffect(() => {
-    // `params.questions` może być undefined podczas streamingu tool args —
-    // partial JSON nie ma jeszcze tablicy. Czekamy aż streaming skończy
-    // wypełniać argumenty.
     if (calling && Array.isArray(params.questions)) {
       const questions: Question[] = params.questions.map((q) => ({
         id: q.id,
@@ -63,7 +66,7 @@ function AskQuestionsView({
     }
 
     return () => clearInputOverride();
-  }, [calling]);
+  }, [calling, questionsKey]);
 
   // Answered — show summary
   if (!calling && result) {

package/src/react/use-chat.ts

@@ -1 +0,0 @@
-// Removed — use chat().toReactComponent() instead.