Interact with AI in IM and make voice calls

{
    "appid": "1",
    "event": "send_msg",
    "nonce": "350176",
    "signature": "signature",
    "timestamp": 1679553625,
    "from_user_id": "user_id_1",
    "conv_type": 0,
    "conv_id": "@RBT#AIAgentExample1",
    "msg_type": 1,
    "msg_body": "msg_body",
    "msg_id": "857639062792568832",
    "payload": "payload",
    "msg_time": 1679554146000,
    "send_result": 0,
    "sub_msg_type": 0,
    "user_list":[
    ]
}

async function generateLLMResponse(messages: MessageItem[]): Promise<string> {
    try {
        console.log('Preparing to generate LLM response, message context:', messages); 
        // Get LLM configuration from environment variables
        const apiKey = process.env.LLM_API_KEY;
        const baseURL = process.env.LLM_BASE_URL;
        const model = process.env.LLM_MODEL || 'deepseek-v3-250324';
        if (!apiKey || !baseURL) {
            console.error('Missing LLM configuration, please check environment variables');
            return "Sorry, I'm temporarily unable to reply to your message. Please try again later.";
        }

        // Convert message format
        const formattedMessages = messages.map(msg => ({
            role: msg.role as "user" | "assistant" | "system",
            content: msg.content
        }));

        // Add system prompt
        formattedMessages.unshift({
            role: "system",
            content: "You are a helpful assistant. Please answer user questions concisely and clearly."
        });

        // Use fetch API to call LLM service. Note: using non-streaming response.
        const response = await fetch(baseURL, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${apiKey}`
            },
            body: JSON.stringify({
                messages: formattedMessages,
                model: model
            })
        });

        if (!response.ok) {
            throw new Error(`LLM API request failed: ${response.status} ${response.statusText}`);
        }

        const data = await response.json();

        // Get reply content
        const reply = data.choices?.[0]?.message?.content || "Sorry, I cannot generate a reply.";
        return reply;
    } catch (error) {
        console.error('Error generating LLM response:', error);
        return "Sorry, there was an issue processing your request. Please try again later.";
    }
}

async function sendReplyMessage(fromUserId: string, toUserId: string, message: string) {
    try {
        // Build message body
        const messageBody = {
            Message: message, // LLM reply content
            ExtendedData: ''
        };

        // Send message
        // ZegoZIM.getInstance().sendPeerMessage is a demo wrapper method. For complete implementation, refer to: https://github.com/ZEGOCLOUD/ai_agent_quick_start_server/blob/im_and_voice/src/lib/zego/zim.ts#L162
        // Please refer to detailed send peer message API documentation: https://www.zegocloud.com/docs/zim-server/messaging/send-a-one-to-one-message
        const result = await ZegoZIM.getInstance().sendPeerMessage(
            fromUserId,                  // Sender ID, i.e., UserInfo.UserId from bot registration (Bot ID)
            [toUserId],                  // Receiver ID array (Real user ID)
            ZegoMessageType.Text,        // Message type: Text
            messageBody,                 // Message content
            ZegoMessagePriority.Medium   // Message priority: Medium
        );

        console.log('Send reply message result:', result);
        return result;
    } catch (error) {
        console.error('Error sending reply message:', error);
        throw error;
    }
}

ZIMMessageQueryConfig queryConfig = new ZIMMessageQueryConfig();
queryConfig.count = 100;     // Query count
queryConfig.reverse = true;  // Query the latest count messages

String conversationId ; // Conversation ID for querying historical messages. i.e., bot `UserId` (i.e., RobotId)
ZIM.getInstance().queryHistoryMessage(conversationId, ZIMConversationType.PEER, queryConfig,new ZIMMessageQueriedCallback() {
    @Override
    public void onMessageQueried(String conversationID, ZIMConversationType conversationType,ArrayList<ZIMMessage> messageList, ZIMError errorInfo) {
        if (errorInfo.code == ZIMErrorCode.SUCCESS) {
            //  Success
        } else {
           // Failure
        }
    }
});

const conversationID = ""; // Conversation ID for querying historical messages. i.e., bot `UserId` (i.e., RobotId)
const conversationType = 0; // Query peer conversation
const config = {
    count: 100, // Number of messages to query
    reverse: true, // Whether to query in reverse order
};
zim.queryHistoryMessage(conversationID, conversationType, config)
    .then(({ messageList }) => {
        // Process messages and update UI
        console.log("Query historical messages success:", messageList);
    })
    .catch((error) => {
        console.error("Query historical messages failed:", error);
    });

@interface ZegoAIAgentIMChatViewController () <ZIMEventHandler>

// zim object
@property (nonatomic, strong) ZIM *zim;

@end

@implementation ZegoAIAgentIMChatViewController

- (void)fetchHistoryMessagesIfNeeded {
    if (!self.zim) {
        return;
    }

    ZIMMessageQueryConfig *config = [[ZIMMessageQueryConfig alloc] init];
    config.count = 50; // Fetch 50 messages
    config.nextMessage = nil; // Start from latest message
    config.reverse = YES; // Fetch from last page

    [self.zim queryHistoryMessageByConversationID:@"your robot id"
                                 conversationType:ZIMConversationTypePeer
                                           config:config
                                         callback:^(NSString * _Nonnull conversationID, ZIMConversationType conversationType, NSArray<ZIMMessage *> * _Nonnull messageList, ZIMError * _Nonnull errorInfo) {
        if (errorInfo.code == 0) {
            dispatch_async(dispatch_get_main_queue(), ^{
             // Update data
             // Sort all messages by orderKey
             // Refresh interface
            });
        } else {
            NSLog(@"Failed to fetch historical messages: %@", errorInfo.message);
        }
    }];
}

@end

String text ; // Chat text
String conversationId ; // Conversation ID for sending messages. i.e., bot `UserId` (i.e., RobotId)
ZIMTextMessage zimMessage = new ZIMTextMessage();
zimMessage.message = text;
// In peer chat scenario, set ZIMConversationType to PEER
ZIM.getInstance().sendMessage(zimMessage, conversationId, ZIMConversationType.PEER, new ZIMMessageSendConfig(),
    new ZIMMessageSentFullCallback() {
        @Override
        public void onMessageAttached(ZIMMessage message) {
            // Insert message to list when sending starts
        }

        @Override
        public void onMessageSent(ZIMMessage message, ZIMError errorInfo) {
            // Send success
        }

        @Override
        public void onMediaUploadingProgress(ZIMMediaMessage message, long currentFileSize,
            long totalFileSize) {

        }

        @Override
        public void onMultipleMediaUploadingProgress(ZIMMultipleMessage message, long currentFileSize,
            long totalFileSize, int messageInfoIndex, long currentIndexFileSize, long totalIndexFileSize) {

        }
    });

const toConversationID = ''; // Peer userID. i.e., bot `UserId` (i.e., RobotId)
const conversationType = 0; // Send peer message
const config = { 
    priority: 3, // Set message priority: Low: 1 (default), Medium: 2, High: 3
};

const messageTextObj = { type: 1, message: 'xxxx' };

zim.sendMessage(messageTextObj, toConversationID, conversationType, config)
    .then(function ({ message }) {
        // Send success
    })
    .catch(function (err) {
        // Send failure
    });

@interface ZegoAIAgentIMChatViewController () <ZIMEventHandler>

// zim object
@property (nonatomic, strong) ZIM *zim;

@end

@implementation ZegoAIAgentIMChatViewController

- (void)sendMessage {
    if (!self.zim) {
      return;
    }

    // Create text message
    ZIMTextMessage *zimMessage = [[ZIMTextMessage alloc] init];
    zimMessage.message = @"your message text";

    // Message send configuration
    ZIMMessageSendConfig *config = [[ZIMMessageSendConfig alloc] init];
    config.priority = ZIMMessagePriorityMedium;

    // Message send notification
    ZIMMessageSendNotification *notification = [[ZIMMessageSendNotification alloc] init];
    notification.onMessageAttached = ^(ZIMMessage * _Nonnull message) {
        // Callback before sending, can show UI in advance here
        dispatch_async(dispatch_get_main_queue(), ^{
            // Update data, refresh interface
        });
    };


    // Send message
    [self.zim sendMessage:zimMessage
        toConversationID:@"your robot id"
        conversationType:ZIMConversationTypePeer
                  config:config
            notification:notification
               callback:^(ZIMMessage * _Nonnull message, ZIMError * _Nonnull errorInfo) {
        if (errorInfo.code == 0) {
            NSLog(@"Message sent successfully");
        } else {
            NSLog(@"Message sending failed: %@", errorInfo.message);
        }
    }];
}

@end

ZIM.getInstance().setEventHandler(new ZIMEventHandler() {
    @Override
    public void onPeerMessageReceived(ZIM zim, ArrayList<ZIMMessage> messageList, ZIMMessageReceivedInfo info,String fromUserID) {
        // Only add messages from this conversation to this page
        List<ZIMMessage> collect = messageList.stream()
            .filter(zimMessage -> Objects.equals(Constant.agent_zim_robotid, zimMessage.getConversationID()))
            .collect(Collectors.toList());
    }
});

zim.on("peerMessageReceived", (zim, { messageList }) => {
    console.log("Received new messages:", messageList);
    // Process messages and update UI
});

// Implement ZIMEventHandler
@interface ZegoAIAgentIMChatViewController () <ZIMEventHandler>

@end

@implementation ZegoAIAgentIMChatViewController

#pragma mark - ZIMEventHandler

- (void)zim:(ZIM *)zim peerMessageReceived:(NSArray<ZIMMessage *> *)messageList info:(ZIMMessageReceivedInfo *)info fromUserID:(NSString *)fromUserID {
    NSLog(@"Received peer messages - Sender ID: %@, Message count: %lu, Message details:", fromUserID, (unsigned long)messageList.count);
    for (ZIMMessage *message in messageList) {
        if ([message isKindOfClass:[ZIMTextMessage class]]) {
            ZIMTextMessage *textMessage = (ZIMTextMessage *)message;
            NSLog(@"Message ID: %lld, Send time: %llu, Message content: %@", textMessage.messageID, textMessage.timestamp, textMessage.message);
        }
    }

    dispatch_async(dispatch_get_main_queue(), ^{
         // Update data

        // Sort all messages by orderKey

        // Refresh interface
    });
}

@end