Jev で経費分類：銀行明細の自動仕訳と信頼度ゲート

import json
import os
import time

import requests

# ベースライン: まずキーワードルール、一致しないものを生成系 LLM へ。
# 2 つのシステム、2 つの失敗モード。
KEYWORD_RULES = {
    "software_saas": ["AWS", "NOTION", "ZOOM.US", "ADOBE"],
    "travel": ["DELTA AIR", "UBER", "LYFT", "MARRIOTT"],
    "meals": ["RESTAURANT", "COFFEE", "SUSHI", "CAFE"],
    "office_supplies": ["OFFICE DEPOT", "STAPLES", "AMZN MKTP"],
}
CATEGORIES = set(KEYWORD_RULES) | {"professional_services", "other"}

def rule_category(line: str) -> str | None:
    upper = line.upper()
    for category, keywords in KEYWORD_RULES.items():
        if any(keyword in upper for keyword in keywords):
            return category
    return None  # 「SQ *BLUE BOTTLE」「MERCH PAYMENT 8842 LLC」はどのルールにも一致しない

def generative_category(line: str) -> dict:
    # 1 行 1.5〜3 秒、試行ごとに出力トークンを課金。json.loads は
    # 幻覚カテゴリも本物と同じく通してしまう。
    for attempt in range(3):
        resp = requests.post(
            "https://api.openai.com/v1/chat/completions",
            headers={"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}"},
            json={
                "model": "gpt-4o-mini",
                "response_format": {"type": "json_object"},
                "messages": [{
                    "role": "user",
                    "content": f'この経費行を {", ".join(sorted(CATEGORIES))} の 1 つに分類し、'
                               f'JSON で返答: {{"category": "..."}}\n明細行: {line}',
                }],
            },
            timeout=30,
        )
        try:
            category = json.loads(
                resp.json()["choices"][0]["message"]["content"]
            )["category"]
            if category in CATEGORIES:  # json_mode が提供しない値チェック
                return {"category": category, "confidence": None}
        except (KeyError, json.JSONDecodeError):
            time.sleep(2 ** attempt)  # リトライのたびに生成全体を再請求
    return {"category": "other", "confidence": None}  # サイレントな失敗

def categorize_line(line: str) -> dict:
    category = rule_category(line)
    if category is not None:
        return {"category": category, "confidence": None}  # ルールに信頼度はない
    return generative_category(line)

import requests

JEV_ENDPOINT = "https://api.typesafe.ai/v1/jev/evaluate"
AUTO_POST_CONFIDENCE = 0.85   # 0.85 以上 → 自動計上
REVIEW_MIN_CONFIDENCE = 0.60  # 0.60〜0.85 → レビューキュー、未満 → 人手

QUESTIONS = {
    "category": {
        "type": "choice",
        "instructions": "各行の経費をちょうど 1 つのカテゴリに分類する",
        "criteria": {
            "software_saas": "SaaS 契約、クラウドホスティング、デジタルツール",
            "travel": "航空券、ホテル、地上交通",
            "meals": "レストラン、コーヒー、顧客接待",
            "office_supplies": "事務用品、備品、倉庫用品の購入",
            "professional_services": "法務、会計、コンサルティング、外注",
            "other": "上記のいずれも確信を持って当てはまらない",
        },
    },
    "deductibility": {
        "type": "score",
        "instructions": "各行を経費としてどの程度計上できるかを評価、1（個人支出）から 4（全額控除）",
    },
    "needs_review": {
        "type": "noul",
        "instructions": "各行について、経理担当者の確認なしに計上するには曖昧すぎますか？",
    },
}

def categorize_statement(lines: list[dict]) -> list[dict]:
    # 明細全体が 1 つの state として乗る——3 つの型付き質問が
    # 単一の約 70-100ms フォワードパスで行ごとに答えを返す。
    resp = requests.post(
        JEV_ENDPOINT,
        json={"state": {"lines": lines}, "questions": QUESTIONS},
        timeout=5,
    )
    resp.raise_for_status()
    data = resp.json()

    results = []
    for i, line in enumerate(lines):
        category = data["category"][i]
        flagged = data["needs_review"][i]["answer"]
        if flagged or category["answer"] == "other":
            lane = "human_review"
        elif category["confidence"] >= AUTO_POST_CONFIDENCE:
            lane = "auto_post"
        elif category["confidence"] >= REVIEW_MIN_CONFIDENCE:
            lane = "review"
        else:
            lane = "human_review"
        results.append({
            "line_index": line["line_index"],
            "category": category["answer"],
            "confidence": category["confidence"],
            "deductibility": data["deductibility"][i]["answer"],
            "lane": lane,
        })
    return results

def sweep_statements(statements: list[list[dict]]) -> dict:
    # 入力のみ課金 $0.042/M: 30 行の明細は約 1,500 トークン ≈ $0.00007。
    # 月 1 万件でも 1 ドル未満です。
    lanes: dict[str, int] = {"auto_post": 0, "review": 0, "human_review": 0}
    for lines in statements:
        for row in categorize_statement(lines):
            lanes[row["lane"]] += 1
    return lanes

import { z } from "zod";
import OpenAI from "openai";

// ベースライン: まずキーワードルール、残りを structured outputs LLM へ。
const KEYWORD_RULES: Record<string, string[]> = {
  software_saas: ["AWS", "NOTION", "ZOOM.US", "ADOBE"],
  travel: ["DELTA AIR", "UBER", "LYFT", "MARRIOTT"],
  meals: ["RESTAURANT", "COFFEE", "SUSHI", "CAFE"],
  office_supplies: ["OFFICE DEPOT", "STAPLES", "AMZN MKTP"],
};

const CATEGORIES = [
  "software_saas",
  "travel",
  "meals",
  "office_supplies",
  "professional_services",
  "other",
] as const;

const Decision = z.object({ category: z.enum(CATEGORIES) });
const client = new OpenAI();

function ruleCategory(line: string): string | null {
  const upper = line.toUpperCase();
  for (const [category, keywords] of Object.entries(KEYWORD_RULES)) {
    if (keywords.some((k) => upper.includes(k))) return category;
  }
  return null; // 「MERCH PAYMENT 8842 LLC」はどのルールにも一致しない
}

export async function categorizeLine(line: string) {
  const category = ruleCategory(line);
  if (category) return { category, confidence: null }; // ルールに信頼度はない

  for (let attempt = 0; attempt < 3; attempt++) {
    try {
      const resp = await client.chat.completions.create({
        model: "gpt-4o-mini",
        response_format: { type: "json_object" },
        messages: [
          {
            role: "user",
            content: `この経費行を ${CATEGORIES.join(", ")} の 1 つに分類し、JSON で返答: {"category": "..."}\n明細行: ${line}`,
          },
        ],
      });
      // 形状は保証される。値が正しいかは保証されない——
      // しかも自動化をゲートする信頼度の数値が存在しない。
      return {
        category: Decision.parse(
          JSON.parse(resp.choices[0].message.content!),
        ).category,
        confidence: null,
      };
    } catch {
      await new Promise((r) => setTimeout(r, 2 ** attempt * 1000));
    }
  }
  return { category: "other" as const, confidence: null };
}

const JEV_ENDPOINT = "https://api.typesafe.ai/v1/jev/evaluate";

// ポリシーはアプリケーションコードに置く。モデルは事実を報告するだけ。
const AUTO_POST_CONFIDENCE = 0.85; // 0.85 以上 → 自動計上
const REVIEW_MIN_CONFIDENCE = 0.6; // 0.60〜0.85 → レビューキュー

type StatementLine = {
  line_index: number;
  merchant: string;
  amount: number;
  date: string;
  memo?: string;
};

const QUESTIONS = {
  category: {
    type: "choice",
    instructions: "各行の経費をちょうど 1 つのカテゴリに分類する",
    criteria: {
      software_saas: "SaaS 契約、クラウドホスティング、デジタルツール",
      travel: "航空券、ホテル、地上交通",
      meals: "レストラン、コーヒー、顧客接待",
      office_supplies: "事務用品、備品、倉庫用品の購入",
      professional_services: "法務、会計、コンサルティング、外注",
      other: "上記のいずれも確信を持って当てはまらない",
    },
  },
  deductibility: {
    type: "score",
    instructions: "各行を経費としてどの程度計上できるかを評価、1（個人支出）から 4（全額控除）",
  },
  needs_review: {
    type: "noul",
    instructions: "各行について、経理担当者の確認なしに計上するには曖昧すぎますか？",
  },
} as const;

export type ExpenseLane = "auto_post" | "review" | "human_review";

export async function categorizeStatement(lines: StatementLine[]) {
  const response = await fetch(JEV_ENDPOINT, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ state: { lines }, questions: QUESTIONS }),
  });
  if (!response.ok) throw new Error("Jev evaluate failed");
  const data = await response.json();

  // 答えは行ごとに、state.lines の順序と揃って返ります。
  return lines.map((line, i) => {
    const category = data.category[i] as {
      answer: string;
      confidence: number;
    };
    const flagged = data.needs_review[i].answer as boolean;
    const lane: ExpenseLane =
      flagged || category.answer === "other"
        ? "human_review"
        : category.confidence >= AUTO_POST_CONFIDENCE
          ? "auto_post"
          : category.confidence >= REVIEW_MIN_CONFIDENCE
            ? "review"
            : "human_review";
    return {
      ...line,
      category: category.answer,
      confidence: category.confidence,
      deductibility: data.deductibility[i].answer as number,
      lane,
    };
  });
}

// 金額・税・カテゴリ別集計はコード側に置く。モデルは算術をしない。
// 30 行の明細 ≈ 1,500 入力トークン、処理時間は約 70-100ms、
// 出力トークン $0。