ИИ в вашем приложении за счёт пользователя

import express from 'express';
import session from 'express-session';
import { randomBytes, createHash } from 'crypto';
import OpenAI from 'openai';

const app = express();
app.use(express.json());
// в проде — хранилище сессий в базе, не в памяти
app.use(session({ secret: process.env.SESSION_SECRET, resave: false, saveUninitialized: false }));

const CALLBACK = 'https://mysite.ru/auth/polza/callback';

// 1–2. Кнопка «Войти через Polza» ведёт сюда
app.get('/auth/polza', (req, res) => {
  const verifier = randomBytes(32).toString('base64url');
  const challenge = createHash('sha256').update(verifier).digest('base64url');
  const state = randomBytes(16).toString('hex');
  req.session.pkce = { verifier, state };
  const params = new URLSearchParams({
    response_type: 'code', callback_url: CALLBACK,
    code_challenge: challenge, code_challenge_method: 'S256',
    state, app_name: 'Мой сайт',
  });
  res.redirect(`https://polza.ai/api/auth/authorize?${params}`);
});

// 3–4. Polza возвращает пользователя с кодом, меняем код на ключ
app.get('/auth/polza/callback', async (req, res) => {
  const { code, state, error } = req.query;
  if (error || state !== req.session.pkce?.state) return res.redirect('/');
  const r = await fetch('https://polza.ai/api/auth/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      grant_type: 'authorization_code', code,
      code_verifier: req.session.pkce.verifier, callback_url: CALLBACK,
    }),
  });
  if (!r.ok) return res.redirect('/');
  const { key } = await r.json();
  req.session.polzaKey = key; // ключ остаётся на сервере
  res.redirect('/chat');
});

// 5. Чат на сайте шлёт сообщения сюда, сервер идёт в модель с ключом пользователя
app.post('/api/chat', async (req, res) => {
  if (!req.session.polzaKey) return res.status(401).end();
  const ai = new OpenAI({ baseURL: 'https://polza.ai/api/v1', apiKey: req.session.polzaKey });
  try {
    const r = await ai.chat.completions.create({ model: 'openai/gpt-5.4-mini', messages: req.body.messages });
    res.json(r.choices[0].message);
  } catch (e) {
    if (e.status === 402) return res.status(402).json({ error: 'Не хватает лимита расходов или баланса' });
    res.status(500).json({ error: 'Модель не ответила' });
  }
});

app.listen(3000);

# aiogram 3 + FastAPI в одном процессе
import asyncio, base64, hashlib, os, secrets
from urllib.parse import urlencode

import httpx, uvicorn
from aiogram import Bot, Dispatcher, F
from aiogram.filters import CommandStart
from aiogram.types import Message
from fastapi import FastAPI
from fastapi.responses import PlainTextResponse
from openai import AsyncOpenAI, APIStatusError

CALLBACK = "https://mybot.ru/callback"
bot, dp, api = Bot(os.environ["BOT_TOKEN"]), Dispatcher(), FastAPI()
pending, keys = {}, {}  # в проде — база данных


@dp.message(CommandStart())
async def start(m: Message):
    verifier = secrets.token_urlsafe(32)
    digest = hashlib.sha256(verifier.encode()).digest()
    challenge = base64.urlsafe_b64encode(digest).rstrip(b"=").decode()
    state = secrets.token_urlsafe(16)
    pending[state] = (m.from_user.id, verifier)
    url = "https://polza.ai/api/auth/authorize?" + urlencode({
        "response_type": "code", "callback_url": CALLBACK,
        "code_challenge": challenge, "code_challenge_method": "S256",
        "state": state, "app_name": "Мой бот",
    })
    await m.answer(f"Войдите через Polza, и бот будет отвечать за счёт вашего баланса:\n{url}")


@api.get("/callback", response_class=PlainTextResponse)
async def callback(code: str = "", state: str = "", error: str = ""):
    user_id, verifier = pending.pop(state, (None, None))
    if error or user_id is None:
        return "Вход отменён"
    async with httpx.AsyncClient() as c:
        r = await c.post("https://polza.ai/api/auth/token", json={
            "grant_type": "authorization_code", "code": code,
            "code_verifier": verifier, "callback_url": CALLBACK,
        })
    if not r.is_success:
        return "Вход не удался, нажмите /start ещё раз"
    keys[user_id] = r.json()["key"]
    await bot.send_message(user_id, "Готово. Задайте вопрос.")
    return "Готово, вернитесь в Telegram"


@dp.message(F.text)
async def ask(m: Message):
    key = keys.get(m.from_user.id)
    if not key:
        return await m.answer("Сначала нажмите /start")
    ai = AsyncOpenAI(base_url="https://polza.ai/api/v1", api_key=key)
    try:
        r = await ai.chat.completions.create(
            model="openai/gpt-5.4-mini",
            messages=[{"role": "user", "content": m.text}],
        )
        await m.answer(r.choices[0].message.content)
    except APIStatusError as e:
        await m.answer("Не хватает лимита расходов или баланса" if e.status_code == 402 else "Модель не ответила")


async def main():
    server = uvicorn.Server(uvicorn.Config(api, host="0.0.0.0", port=8000))
    await asyncio.gather(server.serve(), dp.start_polling(bot))

asyncio.run(main())

import http.server, urllib.parse, webbrowser

# authorize_url собран как в шаге 2, с callback_url=http://localhost:8765/callback

class Callback(http.server.BaseHTTPRequestHandler):
    def do_GET(self):
        u = urllib.parse.urlparse(self.path)
        if u.path != "/callback":  # favicon и прочие запросы браузера
            self.send_response(404)
            self.end_headers()
            return
        q = urllib.parse.parse_qs(u.query)
        self.server.code = q.get("code", [None])[0]
        self.server.state = q.get("state", [None])[0]
        self.server.done = True
        self.send_response(200)
        self.end_headers()
        done = "Вход выполнен" if self.server.code else "Вход отменён"
        self.wfile.write(f"{done}, вкладку можно закрыть".encode())

srv = http.server.HTTPServer(("127.0.0.1", 8765), Callback)
webbrowser.open(authorize_url)
srv.done = False
while not srv.done:  # ждём запрос на /callback
    srv.handle_request()
if srv.state != state:  # state из шага 2
    raise SystemExit("state не совпал, вход прерван")
if srv.code is None:
    raise SystemExit("Пользователь отклонил доступ")
# обменяйте srv.code на ключ, как в шаге 4