memind/direct-chat-service.test.mjs

import assert from 'node:assert/strict';
import test from 'node:test';
import {
  createDirectChatService,
  isDirectChatSessionId,
  sendDirectChatSessionEvents,
} from './direct-chat-service.mjs';

test('direct chat is disabled by default', () => {
  const service = createDirectChatService({
    userAuth: {},
    llmProviderService: {},
    sessionSnapshotService: {},
  });
  assert.equal(service.getStatus().enabled, false);
  assert.equal(service.canHandle({
    userMessage: { role: 'user', content: [{ type: 'text', text: 'hi' }] },
  }), false);
});

test('direct chat creates a direct session, saves snapshot, and bills returned usage', async () => {
  const registered = [];
  const saved = [];
  const billed = [];
  const llmMessages = [];
  const service = createDirectChatService({
    enabled: true,
    userAuth: {
      async registerAgentSession(userId, sessionId, target) {
        registered.push({ userId, sessionId, target });
      },
      async getBillingState() {
        return { lastInputTokens: 10, lastOutputTokens: 5 };
      },
      async billSessionUsage(userId, sessionId, tokenState, requestId) {
        billed.push({ userId, sessionId, tokenState, requestId });
        return { ok: true, costCents: 1 };
      },
    },
    llmProviderService: {
      async createChatCompletion({ messages }) {
        llmMessages.push(messages);
        return {
          ok: true,
          providerId: 'custom_deepseek',
          model: 'deepseek-chat',
          reply: '你好，已收到。',
          usage: { inputTokens: 3, outputTokens: 4 },
        };
      },
    },
    sessionSnapshotService: {
      async get() {
        return null;
      },
      async save(sessionId, userId, session, messages) {
        saved.push({ sessionId, userId, session, messages });
      },
    },
    memoryV2: {
      async resolve() {
        return { memories: [{ label: 'preference', text: '喜欢简洁回答' }] };
      },
    },
  });

  const result = await service.run({
    userId: 'user-1',
    requestId: 'req-1',
    userMessage: {
      id: 'msg-user-1',
      role: 'user',
      content: [{ type: 'text', text: '打个招呼' }],
      metadata: { userVisible: true },
    },
  });

  assert.equal(result.ok, true);
  assert.equal(isDirectChatSessionId(result.sessionId), true);
  assert.deepEqual(registered, [
    { userId: 'user-1', sessionId: result.sessionId, target: 'h5-direct' },
  ]);
  assert.equal(saved.length, 1);
  assert.equal(saved[0].messages.length, 2);
  assert.equal(saved[0].messages[1].content[0].text, '你好，已收到。');
  assert.match(llmMessages[0][0].content, /喜欢简洁回答/);
  assert.deepEqual(billed, [{
    userId: 'user-1',
    sessionId: result.sessionId,
    tokenState: {
      accumulatedInputTokens: 13,
      accumulatedOutputTokens: 9,
    },
    requestId: 'req-1',
  }]);
});

test('direct chat run can be replayed through finite session events', async () => {
  const snapshots = new Map();
  const service = createDirectChatService({
    enabled: true,
    userAuth: {
      async registerAgentSession() {},
      async getBillingState() {
        return null;
      },
      async billSessionUsage() {
        return null;
      },
    },
    llmProviderService: {
      async createChatCompletion() {
        return {
          ok: true,
          reply: '这是直连回复。',
          usage: null,
        };
      },
    },
    sessionSnapshotService: {
      async get(sessionId) {
        return snapshots.get(sessionId) ?? null;
      },
      async save(sessionId, userId, session, messages) {
        snapshots.set(sessionId, { session, messages, userId });
      },
    },
  });

  const result = await service.run({
    userId: 'user-1',
    requestId: 'req-e2e',
    userMessage: {
      id: 'user-e2e',
      role: 'user',
      content: [{ type: 'text', text: '讲个程序员笑话' }],
      metadata: { userVisible: true },
    },
  });
  const snapshot = snapshots.get(result.sessionId);
  const res = {
    statusCode: 200,
    headers: {},
    chunks: [],
    ended: false,
    writableEnded: false,
    status(code) {
      this.statusCode = code;
      return this;
    },
    setHeader(key, value) {
      this.headers[key] = value;
    },
    write(chunk) {
      this.chunks.push(chunk);
    },
    end() {
      this.ended = true;
      this.writableEnded = true;
    },
  };

  sendDirectChatSessionEvents({ once() {} }, res, snapshot);

  const stream = res.chunks.join('');
  assert.equal(res.ended, true);
  assert.equal(res.headers['Content-Type'], 'text/event-stream; charset=utf-8');
  assert.match(stream, /"type":"UpdateConversation"/);
  assert.match(stream, /"type":"Finish"/);
  assert.match(stream, /这是直连回复。/);
});

test('direct chat rejects non-text messages', () => {
  const service = createDirectChatService({
    enabled: true,
    userAuth: {},
    llmProviderService: {},
    sessionSnapshotService: {},
  });
  assert.equal(service.canHandle({
    userMessage: {
      role: 'user',
      content: [{ type: 'image_url', image_url: { url: 'x' } }],
    },
  }), false);
});