@arcote.tech/arc-chat 0.4.9 → 0.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-chat",
   "type": "module",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "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.4.9",
-    "@arcote.tech/arc-ai": "^0.4.9",
-    "@arcote.tech/arc-auth": "^0.4.9",
-    "@arcote.tech/arc-ds": "^0.4.9",
-    "@arcote.tech/platform": "^0.4.9",
+    "@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",
     "lucide-react": ">=0.400.0",
     "react": ">=18.0.0",
     "typescript": "^5.0.0"

package/src/aggregates/message.ts

@@ -7,7 +7,7 @@ import {
   type ArcId,
 } from "@arcote.tech/arc";
 import type { Token } from "@arcote.tech/arc-auth";
-import type { LLMProvider } from "@arcote.tech/arc-ai";
+import { createStreamSession } from "../streaming/stream-registry";
 
 // ─── ID ──────────────────────────────────────────────────────────
 
@@ -24,10 +24,9 @@ export type MessageId<Name extends string = string> = ReturnType<
 export type MessageAggregateData = {
   name: string;
   messageId: ArcId<any>;
-  conversationId: ArcId<any>;
+  scopeId: ArcId<any>;
   accountId: ArcId<any>;
   userToken: Token;
-  resolveProvider: (model: string) => LLMProvider | undefined;
 };
 
 export const createMessageAggregate = <
@@ -35,31 +34,35 @@ export const createMessageAggregate = <
 >(
   data: Data,
 ) => {
-  const { messageId, conversationId, userToken, resolveProvider } = data;
+  const { messageId, scopeId, userToken } = data;
 
   return aggregate(`${data.name}Messages`, messageId, {
-    conversationId,
+    scopeId,
     role: string(),
     content: string(),
+    model: string().optional(),
     toolCalls: string().optional(),
     toolResults: string().optional(),
-    completionId: string().optional(),
+    usage: string().optional(),
     createdAt: date(),
   })
     .publicEvent(
       "messageSent",
       {
         messageId,
-        conversationId,
+        scopeId,
+        sessionId: string(),
         role: string(),
         content: string(),
+        model: string(),
       },
       async (ctx, event) => {
         const p = event.payload;
         await ctx.set(p.messageId, {
-          conversationId: p.conversationId,
+          scopeId: p.scopeId,
           role: p.role,
           content: p.content,
+          model: p.model,
           createdAt: event.createdAt,
         });
       },
@@ -69,21 +72,24 @@ export const createMessageAggregate = <
       "assistantMessageCompleted",
       {
         messageId,
-        conversationId,
+        scopeId,
+        sessionId: string(),
         content: string(),
-        completionId: string().optional(),
+        model: string().optional(),
         toolCalls: string().optional(),
         toolResults: string().optional(),
+        usage: string().optional(),
       },
       async (ctx, event) => {
         const p = event.payload;
         await ctx.set(p.messageId, {
-          conversationId: p.conversationId,
+          scopeId: p.scopeId,
           role: "assistant",
           content: p.content,
-          completionId: p.completionId,
+          model: p.model,
           toolCalls: p.toolCalls,
           toolResults: p.toolResults,
+          usage: p.usage,
           createdAt: event.createdAt,
         });
       },
@@ -91,88 +97,72 @@ export const createMessageAggregate = <
 
     .mutateMethod(
       "sendMessage",
-      {
-        params: {
-          conversationId,
+      (fn) => fn.withParams({
+          scopeId,
           content: string().minLength(1),
-          model: string().optional(),
-          tools: string().optional(),
-          webSearch: string().optional(),
-        },
-      },
+          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,
-            conversationId: params.conversationId,
+            scopeId: params.scopeId,
+            sessionId,
             role: "user",
             content: params.content,
+            model: params.model,
           });
 
-          const history = await ctx.$query.find({
-            where: { conversationId: params.conversationId },
-          });
+          return {
+            messageId: userMsgId,
+            sessionId,
+          };
+        }),
+    ))
 
-          const messages = history.map((msg) => ({
-            role: msg.role as "user" | "assistant" | "system" | "tool",
-            content: msg.content,
-          }));
-
-          messages.push({ role: "user", content: params.content });
-
-          const model = params.model ?? "gpt-4o";
-
-          const provider = resolveProvider(model);
-          if (!provider) {
-            return { error: "PROVIDER_NOT_FOUND" as const };
-          }
-
-          try {
-            const toolDefs = params.tools
-              ? JSON.parse(params.tools)
-              : undefined;
-            const webSearch = params.webSearch === "true";
-
-            const result = await provider.complete({
-              model,
-              messages,
-              tools: toolDefs,
-              webSearch,
-            });
-
-            const assistantMsgId = messageId.generate();
-            await ctx.assistantMessageCompleted.emit({
-              messageId: assistantMsgId,
-              conversationId: params.conversationId,
-              content: result.content,
-              toolCalls: result.toolCalls.length
-                ? JSON.stringify(result.toolCalls)
-                : undefined,
-            });
-
-            return {
-              messageId: assistantMsgId,
-              content: result.content,
-              toolCalls: result.toolCalls,
-              finishReason: result.finishReason,
-            };
-          } catch (error) {
-            const errorMessage =
-              error instanceof Error ? error.message : "Unknown error";
-            return { error: errorMessage };
-          }
+    .mutateMethod(
+      "completeAssistantMessage",
+      (fn) => fn.withParams({
+          scopeId,
+          sessionId: string(),
+          content: string(),
+          model: string().optional(),
+          toolCalls: string().optional(),
+          toolResults: string().optional(),
+          usage: string().optional(),
+        }).handle(
+      ONLY_SERVER &&
+        (async (ctx, params) => {
+          const assistantMsgId = messageId.generate();
+          await ctx.assistantMessageCompleted.emit({
+            messageId: assistantMsgId,
+            scopeId: params.scopeId,
+            sessionId: params.sessionId,
+            content: params.content,
+            model: params.model,
+            toolCalls: params.toolCalls,
+            toolResults: params.toolResults,
+            usage: params.usage,
+          });
+          return { messageId: assistantMsgId };
         }),
-    )
+    ))
 
     .clientQuery(
-      "getByConversation",
-      async (ctx, params: { conversationId: string }) =>
-        ctx.$query.find({ where: { conversationId: params.conversationId } }),
+      "getByScope",
+      (fn) => fn
+        .withParams({ scopeId: string() })
+        .handle(async (ctx, params) =>
+          ctx.$query.find({ where: { scopeId: params.scopeId } }),
+        ),
     )
 
-    .protectBy(userToken, (p) => ({ accountId: p.accountId }))
-;
+    .protectBy(userToken, (p) => ({ accountId: p.accountId }));
 };
 
 export type MessageAggregate = ReturnType<typeof createMessageAggregate>;

package/src/chat-builder.ts

@@ -1,75 +1,99 @@
-import {
-  context,
-  type ArcAggregateElement,
-  type ArcContextElement,
-} from "@arcote.tech/arc";
+import { context, type ArcContextElement, type ArcId } from "@arcote.tech/arc";
 import type { AccountId, Token } from "@arcote.tech/arc-auth";
-import type { AIBuilder } from "@arcote.tech/arc-ai";
-import { createConversationId, createConversationAggregate } from "./aggregates/conversation";
+import type { AIConfig } from "@arcote.tech/arc-ai";
+import type { ArcToolAny, ToolContext } from "@arcote.tech/arc-ai";
 import { createMessageId, createMessageAggregate } from "./aggregates/message";
+import { createAiGenerationListener } from "./listeners/ai-generation-listener";
+import { createChatStreamRoute } from "./routes/chat-stream-route";
+import { createToolResultsRoute } from "./routes/tool-results-route";
 
-export class ChatBuilder<
-  ConvId,
-  MsgId,
-  Conversation extends ArcAggregateElement,
-  Message extends ArcAggregateElement,
-  Elements extends ArcContextElement<any>[],
-> {
-  constructor(
-    private readonly _name: string,
-    readonly conversationId: ConvId,
-    readonly messageId: MsgId,
-    readonly Conversation: Conversation,
-    readonly Message: Message,
-    readonly elements: Elements,
-  ) {}
+// ─── Prepare Callback ───────────────────────────────────────────
 
-  build() {
-    return {
-      context: context(this.elements),
-      conversationId: this.conversationId,
-      messageId: this.messageId,
-      Conversation: this.Conversation,
-      Message: this.Message,
-    };
-  }
+export interface PrepareContext {
+  query: (element: ArcContextElement<any>) => any;
+  mutate: (element: ArcContextElement<any>) => any;
+}
+
+export interface PrepareParams {
+  content: string;
+  identifyBy: string;
+  model: string;
 }
 
-export function chat<const Name extends string>(config: {
-  name: Name;
+export interface PrepareResult {
+  instructions: string;
+  tools?: ArcToolAny[];
+  clientTools?: ArcToolAny[];
+}
+
+// ─── Chat Factory ───────────────────────────────────────────────
+
+export function chat(config: {
+  name: string;
+  identifyBy: ArcId<any>;
   accountId: AccountId;
   userToken: Token;
-  ai: ReturnType<AIBuilder<any, any, any, any, any, any>["build"]>;
+  ai: AIConfig;
+  tools?: ArcToolAny[];
+  clientTools?: ArcToolAny[];
+  prepare?: ((ctx: PrepareContext, params: PrepareParams) => Promise<PrepareResult>) | false;
+  maxExecutionCount?: number;
 }) {
-  const conversationId = createConversationId({ name: config.name });
   const messageId = createMessageId({ name: config.name });
 
-  const Conversation = createConversationAggregate({
+  const Message = createMessageAggregate({
     name: config.name,
-    conversationId,
+    messageId,
+    scopeId: config.identifyBy,
     accountId: config.accountId,
     userToken: config.userToken,
   });
-  const conversationElement = Conversation;
 
-  const Message = createMessageAggregate({
+  // Collect all mutation elements from server tools for listener registration
+  const allTools = config.tools ?? [];
+  const allMutationElements: ArcContextElement<any>[] = [];
+  for (const tool of allTools) {
+    for (const el of tool.mutationElements) {
+      if (!allMutationElements.includes(el)) {
+        allMutationElements.push(el);
+      }
+    }
+  }
+
+  const aiListener = createAiGenerationListener({
     name: config.name,
-    messageId,
-    conversationId,
-    accountId: config.accountId,
-    userToken: config.userToken,
+    messageElement: Message,
     resolveProvider: config.ai.resolveProvider,
+    prepare: config.prepare || undefined,
+    tools: allTools,
+    clientTools: config.clientTools ?? [],
+    toolMutationElements: allMutationElements,
+    maxExecutionCount: config.maxExecutionCount ?? 10,
   });
-  const messageElement = Message;
 
-  const elements = [conversationElement, messageElement];
+  const streamRoute = createChatStreamRoute({
+    name: config.name,
+    userToken: config.userToken,
+  });
 
-  return new ChatBuilder(
-    config.name,
-    conversationId,
-    messageId,
-    Conversation,
+  const toolResultsRoute = createToolResultsRoute({
+    name: config.name,
+    userToken: config.userToken,
+  });
+
+  const elements: ArcContextElement<any>[] = [
     Message,
+    aiListener,
+    streamRoute,
+    toolResultsRoute,
+  ];
+
+  return {
+    context: context(elements),
     elements,
-  );
+    messageId,
+    Message,
+  };
 }
+
+export type ChatConfig = ReturnType<typeof chat>;

package/src/index.ts

@@ -1,19 +1,35 @@
 // --- Builder API ---
-export { chat, ChatBuilder } from "./chat-builder";
+export { chat } from "./chat-builder";
+export type { ChatConfig, PrepareContext, PrepareParams, PrepareResult } from "./chat-builder";
 
 // --- Aggregate factories & types ---
-export { createConversationAggregate, createConversationId } from "./aggregates/conversation";
-export type { ConversationAggregate, ConversationId } from "./aggregates/conversation";
 export { createMessageAggregate, createMessageId } from "./aggregates/message";
 export type { MessageAggregate, MessageId } from "./aggregates/message";
 
-// --- React components ---
+// --- Streaming ---
+export {
+  createStreamSession,
+  getStreamSession,
+  deleteStreamSession,
+} from "./streaming/stream-registry";
+export type { StreamSession } from "./streaming/stream-registry";
+
+// --- Listener ---
+export { createAiGenerationListener } from "./listeners/ai-generation-listener";
+export type { AiGenerationListenerConfig } from "./listeners/ai-generation-listener";
+
+// --- Routes ---
+export { createChatStreamRoute } from "./routes/chat-stream-route";
+export { createToolResultsRoute } from "./routes/tool-results-route";
+
+// --- React components & hooks ---
 export {
   Chat,
   ChatMessage,
   ChatInput,
   QuestionTabs,
   ToolUseBlock,
+  useChat,
 } from "./react";
 export type {
   ChatMessageData,
@@ -22,4 +38,6 @@ export type {
   ToolUse,
   Question,
   QuestionAnswers,
+  UseChatConfig,
+  UseChatReturn,
 } from "./react";