Agent Nestjs Skills

```typescript
// Generated NestJS Service: TomiChatService
// Service for handling chat and payment interactions with Tomi's API

import { Injectable, Logger } from '@nestjs/common';
import { HttpService } from '@nestjs/axios';
import { ConfigService } from '@nestjs/config';
import { firstValueFrom } from 'rxjs';
import { CreateTomiChatDto } from './dto/create-tomi-chat.dto';
import { TomiChatResponse } from './interfaces/tomi-chat-response.interface';

@Injectable()
export class TomiChatService {
  private readonly logger = new Logger(TomiChatService.name);
  private readonly tomiApiUrl: string;

  constructor(
    private readonly httpService: HttpService,
    private readonly configService: ConfigService,
  ) {
    this.tomiApiUrl = this.configService.get<string>('TOMI_API_URL');
  }

  async createChatSession(createChatDto: CreateTomiChatDto): Promise<TomiChatResponse> {
    try {
      const response = await firstValueFrom(
        this.httpService.post(`${this.tomiApiUrl}/chats`, createChatDto, {
          headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${this.configService.get<string>('TOMI_API_KEY')}`,
          },
        }),
      );

      return {
        success: true,
        chatId: response.data.chatId,
        message: 'Chat session created successfully',
        timestamp: new Date().toISOString(),
      };
    } catch (error) {
      this.logger.error(`Failed to create chat session: ${error.message}`);
      throw new Error(`Tomi API error: ${error.response?.data?.message || error.message}`);
    }
  }

  async sendPayment(chatId: string, amount: number, currency: string): Promise<TomiChatResponse> {
    try {
      const response = await firstValueFrom(
        this.httpService.post(
          `${this.tomiApiUrl}/chats/${chatId}/pay`,
          { amount, currency },
          {
            headers: {
              'Content-Type': 'application/json',
              'Authorization': `Bearer ${this.configService.get<string>('TOMI_API_KEY')}`,
            },
          },
        ),
      );

      return {
        success: true,
        transactionId: response.data.transactionId,
        message: 'Payment processed successfully',
        timestamp: new Date().toISOString(),
      };
    } catch (error) {
      this.logger.error(`Failed to process payment: ${error.message}`);
      throw new Error(`Payment failed: ${error.response?.data?.message || error.message}`);
    }
  }
}
```

```typescript
// Generated DTO: create-tomi-chat.dto.ts
import { IsString, IsNumber, IsOptional, IsEnum } from 'class-validator';

export class CreateTomiChatDto {
  @IsString()
  userId: string;

  @IsString()
  recipientId: string;

  @IsOptional()
  @IsString()
  groupId?: string;

  @IsOptional()
  @IsString()
  message?: string;
}
```

```typescript
// Generated Unit Test: tomi-chat.service.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { TomiChatService } from './tomi-chat.service';
import { HttpService } from '@nestjs/axios';
import { ConfigService } from '@nestjs/config';
import { of, throwError } from 'rxjs';
import { CreateTomiChatDto } from './dto/create-tomi-chat.dto';

describe('TomiChatService', () => {
  let service: TomiChatService;
  let httpService: HttpService;
  let configService: ConfigService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        TomiChatService,
        {
          provide: HttpService,
          useValue: {
            post: jest.fn(),
          },
        },
        {
          provide: ConfigService,
          useValue: {
            get: jest.fn((key: string) => {
              const mockConfig = {
                TOMI_API_URL: 'https://api.tomi.com/v1',
                TOMI_API_KEY: 'mock-api-key',
              };
              return mockConfig[key];
            }),
          },
        },
      ],
    }).compile();

    service = module.get<TomiChatService>(TomiChatService);
    httpService = module.get<HttpService>(HttpService);
    configService = module.get<ConfigService>(ConfigService);
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  describe('createChatSession', () => {
    it('should create a chat session successfully', async () => {
      const mockResponse = {
        data: {
          chatId: 'chat_12345',
        },
      };
      jest.spyOn(httpService, 'post').mockReturnValue(of(mockResponse));

      const createChatDto: CreateTomiChatDto = {
        userId: 'user_1',
        recipientId: 'user_2',
        message: 'Hello, Tomi!',
      };

      const result = await service.createChatSession(createChatDto);

      expect(result.success).toBe(true);
      expect(result.chatId).toBe('chat_12345');
      expect(httpService.post).toHaveBeenCalledWith(
        'https://api.tomi.com/v1/chats',
        createChatDto,
        expect.any(Object),
      );
    });

    it('should throw an error when API fails', async () => {
      jest.spyOn(httpService, 'post').mockReturnValue(
        throwError(() => new Error('API Error')),
      );

      const createChatDto: CreateTomiChatDto = {
        userId: 'user_1',
        recipientId: 'user_2',
      };

      await expect(service.createChatSession(createChatDto)).rejects.toThrow(
        'Tomi API error: API Error',
      );
    });
  });

  describe('sendPayment', () => {
    it('should process a payment successfully', async () => {
      const mockResponse = {
        data: {
          transactionId: 'txn_67890',
        },
      };
      jest.spyOn(httpService, 'post').mockReturnValue(of(mockResponse));

      const result = await service.sendPayment('chat_12345', 10.5, 'USD');

      expect(result.success).toBe(true);
      expect(result.transactionId).toBe('txn_67890');
      expect(httpService.post).toHaveBeenCalledWith(
        'https://api.tomi.com/v1/chats/chat_12345/pay',
        { amount: 10.5, currency: 'USD' },
        expect.any(Object),
      );
    });
  });
});
```