Решения

{
  "id": "gen-dec-...",
  "model": "jev-1.13-20260917",
  "answers": {
    "is_bug": { "type": "noul", "noul": 0.96 },
    "team": {
      "type": "choice",
      "choice": "payments",
      "confidence": 0.67,
      "probabilities": { "payments": 0.78, "frontend": 0.22, "account": 0 }
    },
    "urgency": {
      "type": "score",
      "score": 1.99,
      "confidence": 0.99,
      "probabilities": { "0": 0, "1": 0, "2": 1 },
      "legend": {
        "0": "Подождёт до следующего релиза",
        "1": "Нужно исправить на этой неделе",
        "2": "Прямо сейчас теряем выручку"
      }
    }
  },
  "usage": {
    "input_tokens": 476,
    "output_tokens": 70,
    "cost_rub": 0.004,
    "balance": 950.5
  }
}

"refund": {
  "type": "noul",
  "instructions": "Клиент просит вернуть деньги?",
  "criteria": {
    "true": "Явно просит возврат, отмену списания или компенсацию",
    "false": "Возврат не упоминает или спрашивает об условиях"
  }
}
// ответ: { "type": "noul", "noul": 0.97 }

"sentiment": {
  "type": "choice",
  "instructions": "Как автор относится к продукту?",
  "criteria": {
    "negative": "Жалуется, критикует, отговаривает других",
    "neutral": "Задаёт вопрос, излагает факты, отношения не видно",
    "positive": "Хвалит, рекомендует, делится хорошим опытом"
  }
}
// ответ: { "type": "choice", "choice": "neutral", "confidence": 0.65,
//          "probabilities": { "negative": 0.05, "neutral": 0.62, "positive": 0.33 } }

"severity": {
  "type": "score",
  "instructions": "Насколько серьёзно нарушение правил сообщества?",
  "criteria": [
    "Нарушения нет",
    "Мелкое: оффтоп, капс",
    "Серьёзное: оскорбления, спам",
    "Критическое: угрозы, персональные данные"
  ]
}
// ответ: { "type": "score", "score": 2.1, "confidence": 0.81,
//          "probabilities": { "0": 0.02, "1": 0.08, "2": 0.68, "3": 0.22 },
//          "legend": { "0": "Нарушения нет", ... } }

{
  "model": "jev-1.13",
  "state": {
    "policy": "Брак — полный возврат без возврата товара. Вскрытый товар без брака не возвращается.",
    "ticket": {
      "customer_message": "Наушники (заказ A-5520) пришли с помятой коробкой, сами работают, но хочу вернуть деньги.",
      "orders": [{ "id": "A-5520", "total_rub": 8900, "refunded_rub": 0 }]
    },
    "refund": { "order_id": "A-5520", "amount_rub": 8900 }
  },
  "questions": {
    "policy_covers": {
      "type": "noul",
      "instructions": "Ситуация из `ticket.customer_message` даёт право на возврат `refund.amount_rub` по `policy`."
    }
  }
}

APPROVE_AT = 0.9
BLOCK_AT = 0.1

def route(p: float) -> str:
    if p >= APPROVE_AT:
        return "approve"   # явно «да» — действуем автоматически
    if p <= BLOCK_AT:
        return "block"     # явно «нет» — отказываем
    return "review"        # середина — человеку

# sample — 100–200 примеров, размеченных вручную: [{"text": ..., "tags": [...]}]
# results — ответы модели на те же примеры, в том же порядке

def precision_recall(sample, results, tag, threshold):
    tp = fp = fn = 0
    for item, res in zip(sample, results):
        predicted = res["raw"][tag] >= threshold
        actual = tag in item["tags"]
        tp += predicted and actual
        fp += predicted and not actual
        fn += actual and not predicted
    precision = tp / (tp + fp) if tp + fp else None
    recall = tp / (tp + fn) if tp + fn else None
    return precision, recall

for tag in TAGS:
    for t in (0.3, 0.5, 0.7, 0.8, 0.9):
        p, r = precision_recall(sample, results, tag, t)
        print(f"{tag:20} {t}: precision={p} recall={r}")

import time
from concurrent.futures import ThreadPoolExecutor

import requests

API_URL = "https://api.aitunnel.ru/v1/decisions"
API_KEY = "sk-aitunnel-xxx"

# Взаимоисключающие категории — один choice. Добавьте "other",
# если категории покрывают не всё: choice всегда выбирает один из вариантов.
CATEGORY = {
    "type": "choice",
    "instructions": "К какой одной категории относится отзыв?",
    "criteria": {
        "delivery": "Доставка, сроки, курьер, упаковка",
        "quality": "Качество товара, брак, несоответствие описанию",
        "price": "Цена, скидки, акции",
        "service": "Поддержка, общение с магазином",
        "other": "Ничего из перечисленного",
    },
}

# Независимые метки — по одному noul на каждую.
TAGS = {
    "complaint": "Автор отзыва жалуется?",
    "wants_refund": "Автор просит вернуть деньги или заменить товар?",
    "mentions_competitor": "В отзыве упоминается другой магазин или бренд?",
}
QUESTIONS = {
    "category": CATEGORY,
    **{tag: {"type": "noul", "instructions": q} for tag, q in TAGS.items()},
}

# Пороги свои для каждой метки — подберите по размеченной выборке.
THRESHOLDS = {"complaint": 0.7, "wants_refund": 0.8, "mentions_competitor": 0.6}


def classify(review: str, attempts: int = 5) -> dict:
    for attempt in range(attempts):
        res = requests.post(
            API_URL,
            headers={"Authorization": f"Bearer {API_KEY}"},
            json={"model": "jev-1.13", "state": {"review": review}, "questions": QUESTIONS},
            timeout=60,
        )
        if res.status_code == 429 or res.status_code >= 500:
            retry_after = res.headers.get("Retry-After", "")
            time.sleep(int(retry_after) if retry_after.isdigit() else min(30, 2**attempt))
            continue
        res.raise_for_status()  # 400, 402, 403 — повтор не поможет
        data = res.json()
        a = data["answers"]
        raw = {tag: a[tag]["noul"] for tag in TAGS}
        return {
            "category": a["category"]["choice"],
            "confidence": a["category"].get("confidence", 0),
            "tags": [tag for tag, p in raw.items() if p >= THRESHOLDS[tag]],
            "raw": raw,  # сохраните — пороги можно перенастроить без новых запросов
            "cost_rub": data["usage"]["cost_rub"],
        }
    raise RuntimeError("Нет ответа после повторов")


reviews = [
    "Курьер опоздал на два дня, коробка мятая. В другом магазине привозят за сутки.",
    "Отличный чайник, кипятит быстро, пользуюсь каждый день.",
    "Пришёл с трещиной на корпусе. Верните деньги или пришлите замену.",
]

with ThreadPoolExecutor(max_workers=8) as pool:
    results = list(pool.map(classify, reviews))

for review, r in zip(reviews, results):
    print(r["category"], round(r["confidence"], 2), r["tags"], "—", review[:50])

total = sum(r["cost_rub"] for r in results)
print(f"{len(results)} отзывов: {total:.4f} ₽, {total / len(results) * 1000:.2f} ₽ за 1000")

import requests
from openai import OpenAI

API_KEY = "sk-aitunnel-xxx"
client = OpenAI(api_key=API_KEY, base_url="https://api.aitunnel.ru/v1")

DRAFT_MODEL = "gpt-5-mini"          # дешёвая модель пишет черновик
STRONG_MODEL = "claude-sonnet-5.5"  # сильная — только если черновик не прошёл
ACCEPT_CONFIDENCE = 0.8

SYSTEM = (
    "Ты ассистент поддержки. Отвечай только по выдержкам из справки. "
    "Если в них нет ответа — так и скажи и предложи связаться с поддержкой."
)


def draft(model: str, question: str, excerpts: list[str]) -> str:
    context = "\n".join(f"[{i + 1}] {text}" for i, text in enumerate(excerpts))
    r = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": f"Выдержки из справки:\n{context}\n\nВопрос клиента: {question}"},
        ],
    )
    return r.choices[0].message.content


def verify(question: str, excerpts: list[str], answer: str) -> dict:
    r = requests.post(
        "https://api.aitunnel.ru/v1/decisions",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "model": "jev-1.13",
            "state": {
                "help_center_excerpts": excerpts,
                "customer_question": question,
                "assistant_answer": answer,
            },
            "questions": {
                "support": {
                    "type": "choice",
                    "instructions": "Сравни `assistant_answer` с `help_center_excerpts`. Что его описывает?",
                    "criteria": {
                        "supported": "Ответ отвечает на `customer_question`, и каждый факт, число и правило в нём есть в выдержках.",
                        "unsupported": "В ответе есть факт, число или правило, которого нет в выдержках или которое им противоречит, либо ответ не на тот вопрос.",
                        "declined": "Ответ говорит, что в выдержках нет ответа, и не утверждает своих фактов.",
                    },
                }
            },
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["answers"]["support"]


def answer_with_cascade(question: str, excerpts: list[str]) -> dict:
    verdicts = []
    for model in (DRAFT_MODEL, STRONG_MODEL):
        answer = draft(model, question, excerpts)
        verdict = verify(question, excerpts, answer)
        verdicts.append(verdict)
        if verdict["choice"] == "supported" and verdict.get("confidence", 0) >= ACCEPT_CONFIDENCE:
            return {"route": "send", "model": model, "answer": answer, "verdicts": verdicts}
        if verdict["choice"] == "declined":
            # Ответа нет в справке — сильная модель его не найдёт, нужен человек.
            return {"route": "handoff", "model": model, "answer": answer, "verdicts": verdicts}
    return {"route": "handoff", "model": STRONG_MODEL, "answer": answer, "verdicts": verdicts}

import requests
from openai import OpenAI

API_KEY = "sk-aitunnel-xxx"
client = OpenAI(api_key=API_KEY, base_url="https://api.aitunnel.ru/v1")

# Уровни шкалы — от простого к сложному; индекс уровня выбирает модель.
TIERS = ["gpt-5-nano", "gpt-5-mini", "claude-sonnet-5.5"]


def pick_model(messages: list[dict]) -> str:
    r = requests.post(
        "https://api.aitunnel.ru/v1/decisions",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "model": "jev-1.13",
            "state": {"conversation": messages},
            "questions": {
                "difficulty": {
                    "type": "score",
                    "instructions": "Насколько сложно ответить на последнее сообщение пользователя в `conversation`?",
                    "criteria": [
                        "Простой вопрос, приветствие, короткая справка",
                        "Обычная задача: текст, перевод, несложный код",
                        "Сложная задача: многошаговые рассуждения, архитектура, большой код",
                    ],
                }
            },
        },
        timeout=15,
    )
    r.raise_for_status()
    score = r.json()["answers"]["difficulty"]["score"]  # дробный: 0.0 … 2.0
    return TIERS[min(len(TIERS) - 1, round(score))]


messages = [{"role": "user", "content": "Чем мьютекс отличается от семафора?"}]
model = pick_model(messages)
reply = client.chat.completions.create(model=model, messages=messages)
print(model, "→", reply.choices[0].message.content[:200])

import requests

API_URL = "https://api.aitunnel.ru/v1/decisions"
API_KEY = "sk-aitunnel-xxx"
TOPIC = "AITUNNEL — сервис доступа к API нейросетей с оплатой в рублях"

RELEVANT_AT, IRRELEVANT_AT, SENTIMENT_CONFIDENCE_AT = 0.8, 0.2, 0.7


def judge(comment: str) -> dict:
    r = requests.post(
        API_URL,
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "model": "jev-1.13",
            "state": {"topic": TOPIC, "comment": comment},
            "questions": {
                "relevant": {
                    "type": "noul",
                    "instructions": (
                        "`comment` обсуждает сам `topic`: продукт, цены, надёжность, функции или компанию. "
                        "Упоминание вскользь или другой продукт — не относится."
                    ),
                },
                "sentiment": {
                    "type": "choice",
                    "instructions": "Как автор `comment` относится к `topic`?",
                    "criteria": {
                        "negative": "Жалуется, критикует, отговаривает других",
                        "neutral": "Задаёт вопрос, излагает факты, отношения не видно",
                        "positive": "Хвалит, рекомендует, делится хорошим опытом",
                    },
                },
            },
        },
        timeout=30,
    )
    r.raise_for_status()
    data = r.json()
    a = data["answers"]
    return {
        "relevant": a["relevant"]["noul"],
        "sentiment": a["sentiment"]["choice"],
        "sentiment_confidence": a["sentiment"].get("confidence", 0),
        "cost_rub": data["usage"]["cost_rub"],
    }


def decide(j: dict) -> str:
    if j["relevant"] <= IRRELEVANT_AT:
        return "ignore"
    if j["relevant"] < RELEVANT_AT or j["sentiment_confidence"] < SENTIMENT_CONFIDENCE_AT:
        return "review"   # модель не уверена — пусть посмотрит человек
    return "record"


for comment in ["Перешли на AITUNNEL с зарубежной карты — оплата в рублях, всё работает.",
                "Спасибо за видео, очень познавательно!"]:
    j = judge(comment)
    print(decide(j), j)

// jev-permission-hook.ts — запускается Claude Code перед запросом разрешения
import { text } from "node:stream/consumers";

const API_KEY = "sk-aitunnel-xxx";
const APPROVE_AT = 0.9;

// Опасное — в коде, до модели. Совпадение = обычный запрос разрешения, без вызова API.
const RISKY = [
  /^(sudo|doas|su)\b/,
  /^(bash|sh|zsh|eval|xargs)\b/,
  /^(node|bun|python3?)\s+(-\S+\s+)*(-c|-e|--eval)\b/,
  /^rm\s+(-\S*[rRf]\S*\s+)+/,
  /^git\b.*\b(push|reset\s+--hard|clean\s+-\S*[fd]|branch\s+-D)\b/,
  /^(npm|pnpm|yarn|bun)\s+publish\b/,
  /^(wrangler|vercel|flyctl?)\s+deploy\b|^terraform\s+(apply|destroy)\b|^kubectl\s+(delete|apply)\b/,
  /\.env\b|\.ssh\b|\.aws\b|\.npmrc\b|credentials/i,
];

function neverAutoApprove(command: string): boolean {
  if (/\$\(|`|[<>]\(/.test(command)) return true; // подстановки прячут команду от проверки
  return command
    .split(/\s*(?:&&|\|\||;|\||&|\n)\s*/)
    .map((part) => part.trim().replace(/^(env|npx|bunx|nohup|time)\s+/, ""))
    .some((part) => RISKY.some((re) => re.test(part)));
}

async function jevApproves(command: string, project: string, task?: string): Promise<boolean> {
  const questions: Record<string, { type: "noul"; instructions: string }> = {
    reversible: {
      type: "noul",
      instructions:
        "Каждая команда из `commands` только читает или меняет файлы внутри `project` и отменяется через git " +
        "или повторным запуском. Она не пушит, не публикует, не деплоит, не удаляет файлы вне проекта " +
        "и не отправляет данные в сеть.",
    },
  };
  if (task) {
    questions.serves_task = { type: "noul", instructions: "Запуск `commands` — разумный следующий шаг к `task`." };
  }
  const res = await fetch("https://api.aitunnel.ru/v1/decisions", {
    method: "POST",
    headers: { Authorization: `Bearer ${API_KEY}`, "Content-Type": "application/json" },
    body: JSON.stringify({ model: "jev-1.13", state: { commands: [command], project, task }, questions }),
    signal: AbortSignal.timeout(8_000),
  }).catch(() => undefined);
  if (!res?.ok) return false; // сбой = обычный запрос разрешения, а не одобрение
  const body = await res.json().catch(() => undefined);
  return Object.keys(questions).every((k) => (body?.answers?.[k]?.noul ?? 0) >= APPROVE_AT);
}

const input = JSON.parse(await text(process.stdin));
const command = input.tool_input?.command;
const description = input.tool_input?.description;
if (input.tool_name === "Bash" && typeof command === "string" && !neverAutoApprove(command)) {
  const task = typeof description === "string" ? description : undefined;
  if (await jevApproves(command, input.cwd, task)) {
    console.log(JSON.stringify({
      hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "allow" } },
    }));
  }
}
// Пустой вывод и код 0 — Claude Code спросит разрешение как обычно.

{
  "hooks": {
    "PermissionRequest": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "bun ./jev-permission-hook.ts", "timeout": 15 }
        ]
      }
    ]
  }
}

curl https://api.aitunnel.ru/public/aitunnel/models/decisions