@arcote.tech/arc-chat 0.5.0 → 0.5.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-chat",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "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.0",
-    "@arcote.tech/arc-ai": "^0.5.0",
-    "@arcote.tech/arc-auth": "^0.5.0",
-    "@arcote.tech/arc-ds": "^0.5.0",
-    "@arcote.tech/platform": "^0.5.0",
+    "@arcote.tech/arc": "^0.5.2",
+    "@arcote.tech/arc-ai": "^0.5.2",
+    "@arcote.tech/arc-auth": "^0.5.2",
+    "@arcote.tech/arc-ds": "^0.5.2",
+    "@arcote.tech/platform": "^0.5.2",
     "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;
@@ -41,11 +42,16 @@ export const createMessageAggregate = <
     role: string(),
     content: string(),
     model: string().optional(),
-    toolCalls: string().optional(),
-    toolResults: string().optional(),
+    toolName: string().optional(),
+    toolCallId: string().optional(),
+    sessionId: string().optional(),
+    previousResponseId: string().optional(),
+    isGenerating: boolean().optional(),
     usage: string().optional(),
     createdAt: date(),
   })
+
+    // ─── messageSent — user sends a message ─────────────────────
     .publicEvent(
       "messageSent",
       {
@@ -54,7 +60,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,22 +70,24 @@ export const createMessageAggregate = <
           role: p.role,
           content: p.content,
           model: p.model,
+          sessionId: p.sessionId,
+          isGenerating: p.isGenerating,
           createdAt: event.createdAt,
         });
       },
     )
 
+    // ─── assistantResponded — AI generates text ─────────────────
     .publicEvent(
-      "assistantMessageCompleted",
+      "assistantResponded",
       {
         messageId,
         scopeId,
         sessionId: string(),
         content: 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;
@@ -87,28 +96,122 @@ export const createMessageAggregate = <
           role: "assistant",
           content: p.content,
           model: p.model,
-          toolCalls: p.toolCalls,
-          toolResults: p.toolResults,
-          usage: p.usage,
+          sessionId: p.sessionId,
+          previousResponseId: p.previousResponseId,
+          isGenerating: p.isGenerating,
           createdAt: event.createdAt,
         });
       },
     )
 
+    // ─── toolCalled — AI invokes a tool ─────────────────────────
+    .publicEvent(
+      "toolCalled",
+      {
+        messageId,
+        scopeId,
+        sessionId: string(),
+        toolName: string(),
+        toolCallId: string(),
+        content: string(),
+        previousResponseId: string().optional(),
+      },
+      async (ctx, event) => {
+        const p = event.payload;
+        await ctx.set(p.messageId, {
+          scopeId: p.scopeId,
+          role: "tool_call",
+          content: p.content,
+          toolName: p.toolName,
+          toolCallId: p.toolCallId,
+          sessionId: p.sessionId,
+          previousResponseId: p.previousResponseId,
+          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;
+        await ctx.set(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 +220,168 @@ export const createMessageAggregate = <
             content: params.content,
             model: params.model,
           });
-
-          return {
-            messageId: userMsgId,
-            sessionId,
-          };
+          return { messageId: userMsgId, sessionId };
         }),
-    ))
+      ),
+    )
 
+    // ─── saveAssistantMessage ─────��─────────────────────────────
     .mutateMethod(
-      "completeAssistantMessage",
+      "saveAssistantMessage",
       (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(),
+        content: string(),
+        model: string().optional(),
+        previousResponseId: string().optional(),
+        isGenerating: boolean().optional(),
+      }).handle(
+        ONLY_SERVER &&
         (async (ctx, params) => {
-          const assistantMsgId = messageId.generate();
-          await ctx.assistantMessageCompleted.emit({
-            messageId: assistantMsgId,
+          const msgId = messageId.generate();
+          await ctx.assistantResponded.emit({
+            messageId: msgId,
             scopeId: params.scopeId,
             sessionId: params.sessionId,
             content: params.content,
             model: params.model,
-            toolCalls: params.toolCalls,
-            toolResults: params.toolResults,
+            previousResponseId: params.previousResponseId,
+            isGenerating: params.isGenerating,
+          });
+          return { messageId: msgId };
+        }),
+      ),
+    )
+
+    // ─── saveToolCall ────────────���──────────────────────────────
+    .mutateMethod(
+      "saveToolCall",
+      (fn) => fn.withParams({
+        scopeId,
+        sessionId: string(),
+        toolName: string(),
+        toolCallId: string(),
+        content: string(),
+        previousResponseId: string().optional(),
+      }).handle(
+        ONLY_SERVER &&
+        (async (ctx, params) => {
+          const msgId = messageId.generate();
+          await ctx.toolCalled.emit({
+            messageId: msgId,
+            scopeId: params.scopeId,
+            sessionId: params.sessionId,
+            toolName: params.toolName,
+            toolCallId: params.toolCallId,
+            content: params.content,
+            previousResponseId: params.previousResponseId,
+          });
+          return { messageId: msgId };
+        }),
+      ),
+    )
+
+    // ─── saveToolResult — server tool executed ──────────────────
+    .mutateMethod(
+      "saveToolResult",
+      (fn) => fn.withParams({
+        scopeId,
+        sessionId: string(),
+        toolName: string(),
+        toolCallId: string(),
+        content: string(),
+        isError: boolean().optional(),
+      }).handle(
+        ONLY_SERVER &&
+        (async (ctx, params) => {
+          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,
+            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 greeting ──────────────
+    .mutateMethod(
+      "startStage",
+      (fn) => fn.withParams({
+        scopeId,
+        model: string().optional(),
+      }).handle(
+        ONLY_SERVER &&
+        (async (ctx, params) => {
+          const userMsgId = messageId.generate();
+          const sessionId = `session_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+
+          await ctx.messageSent.emit({
+            messageId: userMsgId,
+            scopeId: params.scopeId,
+            sessionId,
+            role: "user",
+            content: "Rozpocznij ten etap. Przywitaj się i zadaj pierwsze pytanie.",
+            model: params.model ?? "gpt-5.4-nano",
+          });
+          return { messageId: userMsgId, sessionId };
+        }),
+      ),
+    )
 
+    // ─── getByScope ─────────────────────────────────────────────
     .clientQuery(
       "getByScope",
       (fn) => fn
@@ -162,7 +391,7 @@ export const createMessageAggregate = <
         ),
     )
 
-    .protectBy(userToken, (p) => ({ accountId: p.accountId }));
+    .protectBy(userToken, (p: { workspaceId: string }) => ({ scopeId: p.workspaceId }));
 };
 
 export type MessageAggregate = ReturnType<typeof createMessageAggregate>;