agent-messenger 2.12.0 → 2.12.1

package/src/platforms/telegrambot/types.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  TelegramBotConfigSchema,
+  TelegramBotCredentialsSchema,
+  TelegramBotEntrySchema,
+  TelegramBotError,
+  TelegramBotUserSchema,
+  TelegramChatSchema,
+  TelegramMessageSchema,
+} from './types'
+
+describe('TelegramBotError', () => {
+  it('creates error with message and code', () => {
+    const err = new TelegramBotError('Test error', 'TEST_CODE')
+    expect(err.message).toBe('Test error')
+    expect(err.code).toBe('TEST_CODE')
+    expect(err.name).toBe('TelegramBotError')
+    expect(err).toBeInstanceOf(Error)
+  })
+})
+
+describe('TelegramBotEntrySchema', () => {
+  it('validates correct bot entry', () => {
+    const result = TelegramBotEntrySchema.safeParse({
+      bot_id: 'mybot',
+      bot_name: 'My Bot',
+      token: '123456789:ABC-DEF',
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects missing bot_id', () => {
+    const result = TelegramBotEntrySchema.safeParse({ bot_name: 'My Bot', token: 'tok' })
+    expect(result.success).toBe(false)
+  })
+})
+
+describe('TelegramBotConfigSchema', () => {
+  it('accepts empty config', () => {
+    const result = TelegramBotConfigSchema.safeParse({ current: null, bots: {} })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts config with bots and current', () => {
+    const result = TelegramBotConfigSchema.safeParse({
+      current: { bot_id: 'mybot' },
+      bots: {
+        mybot: { bot_id: 'mybot', bot_name: 'My Bot', token: '123:abc' },
+      },
+    })
+    expect(result.success).toBe(true)
+  })
+})
+
+describe('TelegramBotCredentialsSchema', () => {
+  it('validates credentials', () => {
+    const result = TelegramBotCredentialsSchema.safeParse({
+      token: '123:abc',
+      bot_id: 'mybot',
+      bot_name: 'My Bot',
+    })
+    expect(result.success).toBe(true)
+  })
+})
+
+describe('TelegramBotUserSchema', () => {
+  it('validates a bot user', () => {
+    const result = TelegramBotUserSchema.safeParse({
+      id: 123456789,
+      is_bot: true,
+      first_name: 'My Bot',
+      username: 'mybot',
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects missing id', () => {
+    const result = TelegramBotUserSchema.safeParse({ is_bot: true, first_name: 'X' })
+    expect(result.success).toBe(false)
+  })
+})
+
+describe('TelegramChatSchema', () => {
+  it('validates private chat', () => {
+    const result = TelegramChatSchema.safeParse({ id: 1, type: 'private', first_name: 'Alice' })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates supergroup', () => {
+    const result = TelegramChatSchema.safeParse({ id: -1001234567890, type: 'supergroup', title: 'Eng' })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects invalid type', () => {
+    const result = TelegramChatSchema.safeParse({ id: 1, type: 'invalid' })
+    expect(result.success).toBe(false)
+  })
+})
+
+describe('TelegramMessageSchema', () => {
+  it('validates a text message', () => {
+    const result = TelegramMessageSchema.safeParse({
+      message_id: 42,
+      date: 1735689600,
+      chat: { id: -1001234567890, type: 'supergroup', title: 'Eng' },
+      from: { id: 1, is_bot: false, first_name: 'Alice' },
+      text: 'Hello',
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('validates message with reply', () => {
+    const result = TelegramMessageSchema.safeParse({
+      message_id: 43,
+      date: 1735689700,
+      chat: { id: -1001234567890, type: 'supergroup', title: 'Eng' },
+      text: 'Reply',
+      reply_to_message: {
+        message_id: 42,
+        date: 1735689600,
+        chat: { id: -1001234567890, type: 'supergroup', title: 'Eng' },
+        text: 'Original',
+      },
+    })
+    expect(result.success).toBe(true)
+  })
+})

package/src/platforms/telegrambot/types.ts

@@ -0,0 +1,282 @@
+import { z } from 'zod'
+
+export interface TelegramBotEntry {
+  bot_id: string
+  bot_name: string
+  token: string
+}
+
+export interface TelegramBotConfig {
+  current: { bot_id: string } | null
+  bots: Record<string, TelegramBotEntry>
+}
+
+export interface TelegramBotCredentials {
+  token: string
+  bot_id: string
+  bot_name: string
+}
+
+export class TelegramBotError extends Error {
+  code: string
+
+  constructor(message: string, code: string) {
+    super(message)
+    this.name = 'TelegramBotError'
+    this.code = code
+  }
+}
+
+export interface TelegramBotUser {
+  id: number
+  is_bot: boolean
+  first_name: string
+  last_name?: string
+  username?: string
+  language_code?: string
+  is_premium?: boolean
+  can_join_groups?: boolean
+  can_read_all_group_messages?: boolean
+  supports_inline_queries?: boolean
+}
+
+export interface TelegramChat {
+  id: number
+  type: 'private' | 'group' | 'supergroup' | 'channel'
+  title?: string
+  username?: string
+  first_name?: string
+  last_name?: string
+  is_forum?: boolean
+}
+
+export interface TelegramChatFullInfo extends TelegramChat {
+  bio?: string
+  description?: string
+  invite_link?: string
+  pinned_message?: TelegramMessage
+  permissions?: Record<string, boolean>
+  member_count?: number
+}
+
+export interface TelegramChatMember {
+  user: TelegramBotUser
+  status: 'creator' | 'administrator' | 'member' | 'restricted' | 'left' | 'kicked'
+  is_anonymous?: boolean
+  custom_title?: string
+  until_date?: number
+}
+
+export interface TelegramMessageEntity {
+  type: string
+  offset: number
+  length: number
+  url?: string
+  user?: TelegramBotUser
+  language?: string
+  custom_emoji_id?: string
+}
+
+export interface TelegramPhotoSize {
+  file_id: string
+  file_unique_id: string
+  width: number
+  height: number
+  file_size?: number
+}
+
+export interface TelegramDocument {
+  file_id: string
+  file_unique_id: string
+  thumbnail?: TelegramPhotoSize
+  file_name?: string
+  mime_type?: string
+  file_size?: number
+}
+
+export interface TelegramMessage {
+  message_id: number
+  message_thread_id?: number
+  date: number
+  chat: TelegramChat
+  from?: TelegramBotUser
+  sender_chat?: TelegramChat
+  text?: string
+  caption?: string
+  entities?: TelegramMessageEntity[]
+  caption_entities?: TelegramMessageEntity[]
+  reply_to_message?: TelegramMessage
+  edit_date?: number
+  photo?: TelegramPhotoSize[]
+  document?: TelegramDocument
+  is_topic_message?: boolean
+}
+
+export interface TelegramReactionType {
+  type: 'emoji' | 'custom_emoji' | 'paid'
+  emoji?: string
+  custom_emoji_id?: string
+}
+
+export interface TelegramCallbackQuery {
+  id: string
+  from: TelegramBotUser
+  message?: TelegramMessage
+  inline_message_id?: string
+  chat_instance: string
+  data?: string
+  game_short_name?: string
+}
+
+export interface TelegramInlineQuery {
+  id: string
+  from: TelegramBotUser
+  query: string
+  offset: string
+  chat_type?: string
+}
+
+export interface TelegramChatMemberUpdated {
+  chat: TelegramChat
+  from: TelegramBotUser
+  date: number
+  old_chat_member: TelegramChatMember
+  new_chat_member: TelegramChatMember
+}
+
+export interface TelegramUpdate {
+  update_id: number
+  message?: TelegramMessage
+  edited_message?: TelegramMessage
+  channel_post?: TelegramMessage
+  edited_channel_post?: TelegramMessage
+  inline_query?: TelegramInlineQuery
+  chosen_inline_result?: Record<string, unknown>
+  callback_query?: TelegramCallbackQuery
+  shipping_query?: Record<string, unknown>
+  pre_checkout_query?: Record<string, unknown>
+  poll?: Record<string, unknown>
+  poll_answer?: Record<string, unknown>
+  my_chat_member?: TelegramChatMemberUpdated
+  chat_member?: TelegramChatMemberUpdated
+  chat_join_request?: Record<string, unknown>
+  message_reaction?: Record<string, unknown>
+  message_reaction_count?: Record<string, unknown>
+}
+
+export const TelegramBotEntrySchema = z.object({
+  bot_id: z.string(),
+  bot_name: z.string(),
+  token: z.string(),
+})
+
+export const TelegramBotConfigSchema = z.object({
+  current: z
+    .object({
+      bot_id: z.string(),
+    })
+    .nullable(),
+  bots: z.record(z.string(), TelegramBotEntrySchema),
+})
+
+export const TelegramBotCredentialsSchema = z.object({
+  token: z.string(),
+  bot_id: z.string(),
+  bot_name: z.string(),
+})
+
+export const TelegramBotUserSchema = z
+  .object({
+    id: z.number(),
+    is_bot: z.boolean(),
+    first_name: z.string(),
+    last_name: z.string().optional(),
+    username: z.string().optional(),
+    language_code: z.string().optional(),
+    is_premium: z.boolean().optional(),
+    can_join_groups: z.boolean().optional(),
+    can_read_all_group_messages: z.boolean().optional(),
+    supports_inline_queries: z.boolean().optional(),
+  })
+  .passthrough()
+
+export const TelegramChatSchema = z
+  .object({
+    id: z.number(),
+    type: z.enum(['private', 'group', 'supergroup', 'channel']),
+    title: z.string().optional(),
+    username: z.string().optional(),
+    first_name: z.string().optional(),
+    last_name: z.string().optional(),
+    is_forum: z.boolean().optional(),
+  })
+  .passthrough()
+
+export const TelegramMessageEntitySchema = z.object({
+  type: z.string(),
+  offset: z.number(),
+  length: z.number(),
+  url: z.string().optional(),
+  user: TelegramBotUserSchema.optional(),
+  language: z.string().optional(),
+  custom_emoji_id: z.string().optional(),
+})
+
+export const TelegramPhotoSizeSchema = z.object({
+  file_id: z.string(),
+  file_unique_id: z.string(),
+  width: z.number(),
+  height: z.number(),
+  file_size: z.number().optional(),
+})
+
+export const TelegramDocumentSchema = z.object({
+  file_id: z.string(),
+  file_unique_id: z.string(),
+  thumbnail: TelegramPhotoSizeSchema.optional(),
+  file_name: z.string().optional(),
+  mime_type: z.string().optional(),
+  file_size: z.number().optional(),
+})
+
+export const TelegramMessageSchema = z
+  .object({
+    message_id: z.number(),
+    message_thread_id: z.number().optional(),
+    date: z.number(),
+    chat: TelegramChatSchema,
+    from: TelegramBotUserSchema.optional(),
+    sender_chat: TelegramChatSchema.optional(),
+    text: z.string().optional(),
+    caption: z.string().optional(),
+    entities: z.array(TelegramMessageEntitySchema).optional(),
+    caption_entities: z.array(TelegramMessageEntitySchema).optional(),
+    reply_to_message: z.lazy(() => TelegramMessageSchema).optional(),
+    edit_date: z.number().optional(),
+    photo: z.array(TelegramPhotoSizeSchema).optional(),
+    document: TelegramDocumentSchema.optional(),
+    is_topic_message: z.boolean().optional(),
+  })
+  .passthrough() as z.ZodType<TelegramMessage>
+
+export interface TelegramBotListenerOptions {
+  timeoutSeconds?: number
+  limit?: number
+  allowedUpdates?: string[]
+  dropPendingUpdates?: boolean
+}
+
+export interface TelegramBotListenerEventMap {
+  message: [event: TelegramMessage]
+  edited_message: [event: TelegramMessage]
+  channel_post: [event: TelegramMessage]
+  edited_channel_post: [event: TelegramMessage]
+  callback_query: [event: TelegramCallbackQuery]
+  inline_query: [event: TelegramInlineQuery]
+  my_chat_member: [event: TelegramChatMemberUpdated]
+  chat_member: [event: TelegramChatMemberUpdated]
+  telegram_update: [event: TelegramUpdate]
+  connected: [info: { user: TelegramBotUser }]
+  disconnected: []
+  error: [error: Error]
+}