@arcote.tech/arc-chat 0.5.1 → 0.5.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-chat",
   "type": "module",
-  "version": "0.5.1",
+  "version": "0.5.5",
   "private": false,
   "description": "Chat module with AI integration for Arc framework",
   "main": "./src/index.ts",
@@ -10,11 +10,11 @@
     "type-check": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.5.1",
-    "@arcote.tech/arc-ai": "^0.5.1",
-    "@arcote.tech/arc-auth": "^0.5.1",
-    "@arcote.tech/arc-ds": "^0.5.1",
-    "@arcote.tech/platform": "^0.5.1",
+    "@arcote.tech/arc": "^0.5.5",
+    "@arcote.tech/arc-ai": "^0.5.5",
+    "@arcote.tech/arc-auth": "^0.5.5",
+    "@arcote.tech/arc-ds": "^0.5.5",
+    "@arcote.tech/platform": "^0.5.5",
     "lucide-react": ">=0.400.0",
     "react": ">=18.0.0",
     "typescript": "^5.0.0"

package/src/aggregates/message.ts

@@ -1,15 +1,16 @@
 /// <reference path="../arc.d.ts" />
 import {
   aggregate,
+  boolean,
   date,
   id,
   string,
   type ArcId,
 } from "@arcote.tech/arc";
 import type { Token } from "@arcote.tech/arc-auth";
-import { createStreamSession } from "../streaming/stream-registry";
+// Stream sessions are managed by listeners, not mutations
 
-// ─── ID ──────────────────────────────────────────────────────────
+// ─── ID ──────────────���───────────────────────────────────────────
 
 export const createMessageId = <const Name extends string>(data: {
   name: Name;
@@ -27,6 +28,21 @@ export type MessageAggregateData = {
   scopeId: ArcId<any>;
   accountId: ArcId<any>;
   userToken: Token;
+  /**
+   * Optional scope restriction function used by the message aggregate's
+   * `.protectBy()` call. Receives the token payload and returns an object
+   * of field→value restrictions (see Arc protectBy contract).
+   *
+   * Default: `(p) => ({ scopeId: p.workspaceId })` — assumes the chat is
+   * identified by the workspace id (matches the strategy use-case where
+   * `chat(...).identifyBy(workspaceId)`).
+   *
+   * Chats identified by anything else (e.g. `contentTopicId`) should pass
+   * `() => ({})` — no per-field restriction. The protection token itself
+   * still gates access; cross-scope leakage is bounded by the aggregate
+   * this chat belongs to.
+   */
+  protectCheck?: (payload: any) => Record<string, unknown>;
 };
 
 export const createMessageAggregate = <
@@ -34,18 +50,38 @@ export const createMessageAggregate = <
 >(
   data: Data,
 ) => {
-  const { messageId, scopeId, userToken } = data;
+  const { messageId, scopeId, userToken, protectCheck } = data;
+  const scopeCheck =
+    protectCheck ?? ((p: { workspaceId: string }) => ({ scopeId: p.workspaceId }));
 
   return aggregate(`${data.name}Messages`, messageId, {
     scopeId,
     role: string(),
-    content: string(),
+    /** User message text, or tool_result content. Empty for assistant rows. */
+    content: string().optional(),
+    /**
+     * Assistant message blocks — JSON-serialized AssistantContentBlock[].
+     * Preserves text/tool_call ordering produced by the model in a single
+     * provider response. Empty for non-assistant rows.
+     */
+    blocks: string().optional(),
     model: string().optional(),
-    toolCalls: string().optional(),
-    toolResults: string().optional(),
+    /** Tool result rows: name + id of the tool call this responds to. */
+    toolName: string().optional(),
+    toolCallId: string().optional(),
+    sessionId: string().optional(),
+    /**
+     * For assistant rows: provider-issued response ID for THIS turn. Used by
+     * the listener to anchor `previous_response_id` continuation requests on
+     * the next turn (OpenAI Responses API).
+     */
+    previousResponseId: string().optional(),
+    isGenerating: boolean().optional(),
     usage: string().optional(),
     createdAt: date(),
   })
+
+    // ─── messageSent — user sends a message ─────────────────────
     .publicEvent(
       "messageSent",
       {
@@ -54,7 +90,8 @@ export const createMessageAggregate = <
         sessionId: string(),
         role: string(),
         content: string(),
-        model: string(),
+        model: string().optional(),
+        isGenerating: boolean().optional(),
       },
       async (ctx, event) => {
         const p = event.payload;
@@ -63,52 +100,126 @@ export const createMessageAggregate = <
           role: p.role,
           content: p.content,
           model: p.model,
+          sessionId: p.sessionId,
+          isGenerating: p.isGenerating,
           createdAt: event.createdAt,
         });
       },
     )
 
+    // ─── assistantResponded — AI generates one turn ─────────────
+    // The `blocks` field is the JSON-serialized AssistantContentBlock[]
+    // produced by the provider for this single turn — text and tool_call
+    // blocks interleaved in the order the model emitted them.
     .publicEvent(
-      "assistantMessageCompleted",
+      "assistantResponded",
       {
         messageId,
         scopeId,
         sessionId: string(),
-        content: string(),
+        blocks: string(),
         model: string().optional(),
-        toolCalls: string().optional(),
-        toolResults: string().optional(),
-        usage: string().optional(),
+        previousResponseId: string().optional(),
+        isGenerating: boolean().optional(),
       },
       async (ctx, event) => {
         const p = event.payload;
         await ctx.set(p.messageId, {
           scopeId: p.scopeId,
           role: "assistant",
-          content: p.content,
+          blocks: p.blocks,
           model: p.model,
-          toolCalls: p.toolCalls,
-          toolResults: p.toolResults,
-          usage: p.usage,
+          sessionId: p.sessionId,
+          previousResponseId: p.previousResponseId,
+          isGenerating: p.isGenerating,
+          createdAt: event.createdAt,
+        });
+      },
+    )
+
+    // ─── toolExecuted — server tool returns result ──────────────
+    .publicEvent(
+      "toolExecuted",
+      {
+        messageId,
+        scopeId,
+        sessionId: string(),
+        toolName: string(),
+        toolCallId: string(),
+        content: string(),
+        isError: boolean().optional(),
+      },
+      async (ctx, event) => {
+        const p = event.payload;
+        await ctx.set(p.messageId, {
+          scopeId: p.scopeId,
+          role: "tool_result",
+          content: p.content,
+          toolName: p.toolName,
+          toolCallId: p.toolCallId,
+          sessionId: p.sessionId,
+          createdAt: event.createdAt,
+        });
+      },
+    )
+
+    // ─── userResponded — user answers interactive tool ──────────
+    .publicEvent(
+      "userResponded",
+      {
+        messageId,
+        scopeId,
+        sessionId: string(),
+        toolName: string(),
+        toolCallId: string(),
+        content: string(),
+      },
+      async (ctx, event) => {
+        const p = event.payload;
+        await ctx.set(p.messageId, {
+          scopeId: p.scopeId,
+          role: "tool_result",
+          content: p.content,
+          toolName: p.toolName,
+          toolCallId: p.toolCallId,
+          sessionId: p.sessionId,
           createdAt: event.createdAt,
         });
       },
     )
 
+    // ─── generationCompleted — AI loop finished ─────────────────
+    .publicEvent(
+      "generationCompleted",
+      {
+        messageId,
+        sessionId: string(),
+        usage: string().optional(),
+      },
+      async (ctx, event) => {
+        const p = event.payload;
+        // PARTIAL update — `ctx.set` replaces the whole row and would null
+        // out scopeId/role/blocks. Use `modify` to only flip isGenerating.
+        await ctx.modify(p.messageId, {
+          isGenerating: false,
+          usage: p.usage,
+        } as any);
+      },
+    )
+
+    // ─── sendMessage — user sends message, creates session ──────
     .mutateMethod(
       "sendMessage",
       (fn) => fn.withParams({
-          scopeId,
-          content: string().minLength(1),
-          model: string(),
-        }).handle(
-      ONLY_SERVER &&
+        scopeId,
+        content: string().minLength(1),
+        model: string(),
+      }).handle(
+        ONLY_SERVER &&
         (async (ctx, params) => {
           const userMsgId = messageId.generate();
           const sessionId = `session_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
 
-          createStreamSession(sessionId);
-
           await ctx.messageSent.emit({
             messageId: userMsgId,
             scopeId: params.scopeId,
@@ -117,42 +228,177 @@ export const createMessageAggregate = <
             content: params.content,
             model: params.model,
           });
+          return { messageId: userMsgId, sessionId };
+        }),
+      ),
+    )
 
-          return {
-            messageId: userMsgId,
-            sessionId,
-          };
+    // ─── saveAssistantMessage ───────────────────────────────────
+    // `blocks` is the JSON-serialized AssistantContentBlock[] from the
+    // provider's response — single source of truth for the model's output.
+    .mutateMethod(
+      "saveAssistantMessage",
+      (fn) => fn.withParams({
+        scopeId,
+        sessionId: string(),
+        blocks: string(),
+        model: string().optional(),
+        previousResponseId: string().optional(),
+        isGenerating: boolean().optional(),
+      }).handle(
+        ONLY_SERVER &&
+        (async (ctx, params) => {
+          const msgId = messageId.generate();
+          await ctx.assistantResponded.emit({
+            messageId: msgId,
+            scopeId: params.scopeId,
+            sessionId: params.sessionId,
+            blocks: params.blocks,
+            model: params.model,
+            previousResponseId: params.previousResponseId,
+            isGenerating: params.isGenerating,
+          });
+          return { messageId: msgId };
         }),
-    ))
+      ),
+    )
 
+    // ─── saveToolResult — server tool executed ──────────────────
     .mutateMethod(
-      "completeAssistantMessage",
+      "saveToolResult",
       (fn) => fn.withParams({
-          scopeId,
-          sessionId: string(),
-          content: string(),
-          model: string().optional(),
-          toolCalls: string().optional(),
-          toolResults: string().optional(),
-          usage: string().optional(),
-        }).handle(
-      ONLY_SERVER &&
+        scopeId,
+        sessionId: string(),
+        toolName: string(),
+        toolCallId: string(),
+        content: string(),
+        isError: boolean().optional(),
+      }).handle(
+        ONLY_SERVER &&
         (async (ctx, params) => {
-          const assistantMsgId = messageId.generate();
-          await ctx.assistantMessageCompleted.emit({
-            messageId: assistantMsgId,
+          const msgId = messageId.generate();
+          await ctx.toolExecuted.emit({
+            messageId: msgId,
             scopeId: params.scopeId,
             sessionId: params.sessionId,
+            toolName: params.toolName,
+            toolCallId: params.toolCallId,
             content: params.content,
-            model: params.model,
-            toolCalls: params.toolCalls,
-            toolResults: params.toolResults,
+            isError: params.isError,
+          });
+          return { messageId: msgId };
+        }),
+      ),
+    )
+
+    // ─── completeGeneration ─────────────────────────────────────
+    .mutateMethod(
+      "completeGeneration",
+      (fn) => fn.withParams({
+        generationMessageId: messageId,
+        sessionId: string(),
+        usage: string().optional(),
+      }).handle(
+        ONLY_SERVER &&
+        (async (ctx, params) => {
+          await ctx.generationCompleted.emit({
+            messageId: params.generationMessageId,
+            sessionId: params.sessionId,
             usage: params.usage,
           });
-          return { messageId: assistantMsgId };
+          return { ok: true };
         }),
-    ))
+      ),
+    )
+
+    // ─── respondToTool — user answers interactive tool ──────────
+    .mutateMethod(
+      "respondToTool",
+      (fn) => fn.withParams({
+        scopeId,
+        toolCallId: string(),
+        toolName: string(),
+        result: string(),
+      }).handle(
+        ONLY_SERVER &&
+        (async (ctx, params) => {
+          const msgId = messageId.generate();
+          const sessionId = `session_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+
+          await ctx.userResponded.emit({
+            messageId: msgId,
+            scopeId: params.scopeId,
+            sessionId,
+            toolName: params.toolName,
+            toolCallId: params.toolCallId,
+            content: params.result,
+          });
+          return { messageId: msgId, sessionId };
+        }),
+      ),
+    )
+
+    // ─── startStage — initiate stage with a default priming prompt ─
+    // Stored as role="system" so the UI timeline hides it, but the AI
+    // generation listener still picks it up as a conversational turn
+    // (mapped to "user" for LLM providers that don't support system role
+    // mid-conversation — see ai-generation-listener buildHistory).
+    .mutateMethod(
+      "startStage",
+      (fn) => fn.withParams({
+        scopeId,
+        model: string().optional(),
+      }).handle(
+        ONLY_SERVER &&
+        (async (ctx, params) => {
+          const msgId = messageId.generate();
+          const sessionId = `session_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+
+          await ctx.messageSent.emit({
+            messageId: msgId,
+            scopeId: params.scopeId,
+            sessionId,
+            role: "system",
+            content: "Rozpocznij ten etap. Przywitaj się i zadaj pierwsze pytanie.",
+            model: params.model ?? "gpt-5.4-mini",
+          });
+          return { messageId: msgId, sessionId };
+        }),
+      ),
+    )
+
+    // ─── systemMessage — inject a developer-supplied priming prompt ─
+    // Used by stage onEnter hooks to inject context-aware welcome prompts
+    // (e.g. "User finished identity — greet them and ask about goals").
+    // Stored with role="system" — the UI filters it out of the timeline
+    // (see chat-component Restore timeline loop) while the AI generation
+    // listener still sees it in history as a conversational turn.
+    .mutateMethod(
+      "systemMessage",
+      (fn) => fn.withParams({
+        scopeId,
+        content: string().minLength(1),
+        model: string().optional(),
+      }).handle(
+        ONLY_SERVER &&
+        (async (ctx, params) => {
+          const msgId = messageId.generate();
+          const sessionId = `session_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+
+          await ctx.messageSent.emit({
+            messageId: msgId,
+            scopeId: params.scopeId,
+            sessionId,
+            role: "system",
+            content: params.content,
+            model: params.model ?? "gpt-5.4-mini",
+          });
+          return { messageId: msgId, sessionId };
+        }),
+      ),
+    )
 
+    // ─── getByScope ─────────────────────────────────────────────
     .clientQuery(
       "getByScope",
       (fn) => fn
@@ -162,7 +408,7 @@ export const createMessageAggregate = <
         ),
     )
 
-    .protectBy(userToken, (p) => ({ accountId: p.accountId }));
+    .protectBy(userToken, scopeCheck as any);
 };
 
 export type MessageAggregate = ReturnType<typeof createMessageAggregate>;