Add thinking status

src/apis/agentcoinfun.ts

@@ -7,6 +7,7 @@ import {
   AgentWallet,
   AgentWalletKind,
   AgentWalletSchema,
+  ChatStatusBody,
   CreateMessage,
   ErrorResponseSchema,
   HydratedMessage,
@@ -162,6 +163,19 @@ export class AgentcoinAPI {
     return hydratedMessage
   }
 
+  async sendStatus(newMessage: ChatStatusBody, options: { cookie: string }): Promise<void> {
+    const response = await fetch(`${AGENTCOIN_FUN_API_URL}/api/chat/status`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Cookie: options.cookie },
+      body: JSON.stringify(toJsonTree(newMessage))
+    })
+    if (response.status !== 200) {
+      const error = await response.json()
+      const parsed = ErrorResponseSchema.parse(error)
+      throw new Error(parsed.error)
+    }
+  }
+
   async getDefaultWallet(
     identity: Identity,
     kind: AgentWalletKind,

src/clients/agentcoin/agentcoinfun.ts

@@ -22,7 +22,7 @@ import {
   SentinelCommand,
   SentinelCommandSchema,
   ServiceKind,
-  UserDmEventSchema
+  MessageEventSchema
 } from '@/common/types'
 import * as fs from 'fs'
 
@@ -117,17 +117,30 @@ export class AgentcoinClient {
     this.socket.on(eventName, async (data: unknown) => {
       elizaLogger.info('Agentcoin client received event', data)
       try {
-        const event = UserDmEventSchema.parse(data)
+        const event = MessageEventSchema.parse(data)
         const channel = event.channel
 
+        if (channel.kind !== ChatChannelKind.DM) {
+          elizaLogger.info('Agentcoin client received msg for unknown channel', channel)
+          return
+        }
+
         // validate channel
         if (channel.firstIdentity !== identity && channel.secondIdentity !== identity) {
           elizaLogger.info('Agentcoin client received msg for unknown channel', channel)
           return
         }
 
-        // process message if allowed
-        await this.processMessage(channel, [event.message])
+        switch (event.kind) {
+          case 'message': {
+            // process message if allowed
+            await this.processMessage(channel, event.data)
+            break
+          }
+          case 'status':
+            console.log('received status', event)
+            break
+        }
       } catch (error) {
         console.error('Error processing message from agentcoin client', error)
         elizaLogger.error('Error processing message from agentcoin client', error)
@@ -267,6 +280,14 @@ export class AgentcoinClient {
       return
     }
 
+    const identity = await this.agentcoinService.getIdentity()
+
+    if (message.sender === identity) {
+      return
+    }
+
+    await this.agentcoinService.sendStatus(channel, 'thinking')
+
     // `message` event
     let shouldContinue = await this.runtime.handle('message', {
       text: message.text,
@@ -277,12 +298,7 @@ export class AgentcoinClient {
 
     if (!shouldContinue) {
       elizaLogger.info('AgentcoinClient received message event but it was suppressed')
-      return
-    }
-
-    const identity = await this.agentcoinService.getIdentity()
-
-    if (message.sender === identity) {
+      await this.agentcoinService.sendStatus(channel, 'idle')
       return
     }
 
@@ -322,9 +338,12 @@ export class AgentcoinClient {
 
     if (!shouldContinue) {
       elizaLogger.info('AgentcoinClient received prellm event but it was suppressed')
+      await this.agentcoinService.sendStatus(channel, 'idle')
       return
     }
 
+    await this.agentcoinService.sendStatus(channel, 'typing')
+
     const response = await generateMessageResponse({
       runtime: this.runtime,
       context,
@@ -341,10 +360,12 @@ export class AgentcoinClient {
 
     if (!shouldContinue) {
       elizaLogger.info('AgentcoinClient received postllm event but it was suppressed')
+      await this.agentcoinService.sendStatus(channel, 'idle')
       return
     }
 
     if (isNull(response.text) || response.text.trim().length === 0) {
+      await this.agentcoinService.sendStatus(channel, 'idle')
       return
     }
 
@@ -370,6 +391,8 @@ export class AgentcoinClient {
       return
     }
 
+    await this.agentcoinService.sendStatus(channel, 'thinking')
+
     // `preaction` event
     shouldContinue = await this.runtime.handle('preaction', {
       state,
@@ -379,6 +402,7 @@ export class AgentcoinClient {
 
     if (!shouldContinue) {
       elizaLogger.info('AgentcoinClient received preaction event but it was suppressed')
+      await this.agentcoinService.sendStatus(channel, 'idle')
       return
     }
 

src/common/types.ts

@@ -216,13 +216,6 @@ export const KnowledgeSchema = z.object({
 
 export type Knowledge = z.infer<typeof KnowledgeSchema>
 
-export const UserDmEventSchema = z.object({
-  channel: DMChannelSchema,
-  message: HydratedMessageSchema
-})
-
-export type UserEvent = z.infer<typeof UserDmEventSchema>
-
 // Character schema
 
 export const CharacterMessageSchema = z.object({
@@ -367,3 +360,39 @@ export enum ServiceKind {
   config = 'config-service',
   agent = 'agent-service'
 }
+
+export const MessageStatusEnumSchema = z.enum(['idle', 'thinking', 'typing'])
+export type MessageStatusEnum = z.infer<typeof MessageStatusEnumSchema>
+
+export const MessageStatusSchema = z.object({
+  status: MessageStatusEnumSchema,
+  user: UserSchema,
+  createdAt: z.preprocess((arg) => (isRequiredString(arg) ? new Date(arg) : arg), z.date())
+})
+
+export type MessageStatus = z.infer<typeof MessageStatusSchema>
+
+export const ChatStatusBodySchema = z.object({
+  channel: ChatChannelSchema,
+  status: MessageStatusEnumSchema
+})
+
+export type ChatStatusBody = z.infer<typeof ChatStatusBodySchema>
+
+export const MessageEventKindSchema = z.enum(['message', 'status'])
+export type MessageEventKind = z.infer<typeof MessageEventKindSchema>
+
+export const MessageEventSchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('message'),
+    data: HydratedMessageSchema.array(),
+    channel: DMChannelSchema
+  }),
+  z.object({
+    kind: z.literal('status'),
+    data: MessageStatusSchema,
+    channel: ChatChannelSchema
+  })
+])
+
+export type MessageEvent = z.infer<typeof MessageEventSchema>

src/services/agentcoinfun.ts

@@ -5,9 +5,11 @@ import {
   AgentProvisionResponse,
   AgentProvisionResponseSchema,
   AgentRegistrationSchema,
+  ChatChannel,
   CreateMessage,
   HydratedMessage,
   Identity,
+  MessageStatusEnum,
   ServiceKind,
   User
 } from '@/common/types'
@@ -48,6 +50,18 @@ export class AgentcoinService extends Service implements IAgentcoinService {
     return this.cachedIdentity
   }
 
+  async sendStatus(channel: ChatChannel, status: MessageStatusEnum): Promise<void> {
+    const cookie = await this.getCookie()
+
+    await this.api.sendStatus(
+      {
+        channel,
+        status
+      },
+      { cookie }
+    )
+  }
+
   async sendMessage(message: CreateMessage): Promise<HydratedMessage> {
     const cookie = await this.getCookie()