ساخت ربات مترجم تلگرام با AI SDK

git clone https://github.com/liara-cloud/ai-sdk-examples.git
cd ai-sdk-examples/Telegram-Bot

npm install

import TelegramBot from 'node-telegram-bot-api';
import dotenv from 'dotenv';
import { translateWithFeedback } from './translator';

dotenv.config();

const bot = new TelegramBot(process.env.TELEGRAM_BOT_TOKEN!, { polling: true });

type UserState = {
  step: 'idle' | 'awaitingText' | 'awaitingTargetLanguage';
  sourceText?: string;
};

const userStates = new Map<number, UserState>();

bot.onText(/\/start/, (msg) => {
  const chatId = msg.chat.id;
  bot.sendMessage(
    chatId,
    `سلام ${msg.from?.first_name || ''} 👋\nبه ربات مترجم خوش اومدی!\nاز منو یکی از دستورات رو انتخاب کن.`,
    {
      reply_markup: {
        keyboard: [
          [{ text: '/translate' }, { text: '/help' }],
        ],
        resize_keyboard: true,
      },
    }
  );
  userStates.set(chatId, { step: 'idle' });
});

bot.onText(/\/translate/, (msg) => {
  const chatId = msg.chat.id;
  bot.sendMessage(chatId, '📝 لطفاً متنی که می‌خوای ترجمه بشه رو وارد کن');
  userStates.set(chatId, { step: 'awaitingText' });
});

bot.onText(/\/help/, (msg) => {
  const chatId = msg.chat.id;

  const helpMessage = `
🤖 راهنمای ربات:

✅ /start - شروع و نمایش منوی اصلی
🌐 /translate - ترجمه متن به زبان دلخواه
ℹ️ /help - نمایش این راهنما
  `.trim();

  bot.sendMessage(chatId, helpMessage);
});

bot.on('message', async (msg) => {
  const chatId = msg.chat.id;
  const text = msg.text?.trim();

  if (!text || text.startsWith('/')) return;

  const state = userStates.get(chatId) || { step: 'idle' };

  if (state.step === 'awaitingText') {
    userStates.set(chatId, { step: 'awaitingTargetLanguage', sourceText: text });
    bot.sendMessage(chatId, '🌐 حالا زبان مقصد رو وارد کن (مثلاً: فارسی، انگلیسی و...)');
    return;
  }

  if (state.step === 'awaitingTargetLanguage' && state.sourceText) {
    bot.sendMessage(chatId, '⏳ در حال ترجمه...');

    try {
      const result = await translateWithFeedback(state.sourceText, text);
      const t = result.currentObjectTranslation.translation;

      const message = `
✅ ترجمه نهایی:

📝 ${t.accurate_translated_text}

------------------------
🌐 زبان متن اصلی: ${t.text_language}
🔁 زبان مقصد: ${t.target_language}
🔤 متن اصلی:
${t.text_to_translate}

💡 توضیحات (به زبان مقصد):
${t.explanations_related_to_translation_in_target_language}
      `.trim();

      bot.sendMessage(chatId, message);
    } catch (err) {
      bot.sendMessage(chatId, '❌ خطایی در ترجمه رخ داد.');
      console.error(err);
    }

    userStates.set(chatId, { step: 'idle' });
  }
});

import { generateText, generateObject } from 'ai';
import { createOpenAI } from '@ai-sdk/openai';
import { z } from 'zod';
import dotenv from 'dotenv';

dotenv.config();

const my_model = createOpenAI({
  baseURL: process.env.BASE_URL!,
  apiKey: process.env.LIARA_API_KEY!,
});

const translationSchema = z.object({
  translation: z.object({
    text_language: z.string(),
    text_to_translate: z.string(),
    target_language: z.string(),
    accurate_translated_text: z.string(),
    explanations_related_to_translation_in_target_language: z.string(),
  }),
});

export async function translateWithFeedback(text: string, targetLanguage: string) {
  let currentTranslation = '';
  let currentObjectTranslation = { translation: {
    text_language: '',
    text_to_translate: text,
    target_language: targetLanguage,
    accurate_translated_text: '',
    explanations_related_to_translation_in_target_language: '',
  }};
  let iterations = 0;
  const MAX_ITERATIONS = 3;

  const { object: firstTranslation } = await generateObject({
    model: my_model('openai/gpt-4o-mini'),
    system: `You are an expert literary translator.
    You Do not censor any content in the translation and provide the correct and accurate text.`,
      prompt: `Translate this text to ${targetLanguage}, preserving tone and cultural nuances:\n\n${text}`,
    schema: translationSchema,
  });

  currentTranslation = firstTranslation.translation.accurate_translated_text;
  currentObjectTranslation = firstTranslation as {
    translation: {
      text_language: string;
      text_to_translate: string;
      target_language: string;
      accurate_translated_text: string;
      explanations_related_to_translation_in_target_language: string;
    };
  };

  while (iterations < MAX_ITERATIONS) {
    const { object: evaluation } = await generateObject({
      model: my_model('openai/gpt-4.1-mini'),
      schema: z.object({
        qualityScore: z.number().min(1).max(10),
        preservesTone: z.boolean(),
        preservesNuance: z.boolean(),
        culturallyAccurate: z.boolean(),
        specificIssues: z.array(z.string()),
        improvementSuggestions: z.array(z.string()),
      }),
      system: 'You are an expert in evaluating literary translations.',
      prompt: `Evaluate this translation:\n\nOriginal: ${text}\nTranslation: ${currentTranslation}\n\nConsider:\n1. Overall quality\n2. Preservation of tone\n3. Preservation of nuance\n4. Cultural accuracy`,
    });

    if (
      evaluation.qualityScore >= 8 &&
      evaluation.preservesTone &&
      evaluation.preservesNuance &&
      evaluation.culturallyAccurate
    ) {
      break;
    }

    const { object: improvedTranslation } = await generateObject({
      model: my_model('openai/gpt-4.1'),
      system: 'You are an expert literary translator.',
      prompt: `Improve this translation based on the following feedback:\n\n${evaluation.specificIssues.join('\n')}\n\n${evaluation.improvementSuggestions.join('\n')}\n\nOriginal: ${text}\nCurrent Translation: ${currentTranslation}`,
      schema: translationSchema,
    });

    currentTranslation = improvedTranslation.translation.accurate_translated_text;
    currentObjectTranslation = improvedTranslation as {
      translation: {
        text_language: string;
        text_to_translate: string;
        target_language: string;
        accurate_translated_text: string;
        explanations_related_to_translation_in_target_language: string;
      };
    };
    iterations++;
  }

  return {
    currentObjectTranslation,
    iterations,
  };
}