AI Agent의 퍼미션 시스템: 도구 실행 전에 일어나는 일곱 단계의 판단

Phase 1: 사전 필터 (Pre-model)           Phase 2: 사후 판단 (Post-model)

최대 54개 도구                             모델이 선택한 도구 호출
      │                                         │
  퍼미션 모드 필터링                          모드 게이트
      │                                         │
  deny 규칙 적용                             deny 규칙 검사
      │                                         │
  MCP 도구 통합                              allow 규칙 검사
      │                                         │
  중복 제거                                  ML 분류기 (auto 모드)
      │                                         │
  모델에게 전달 ─────────►                   사용자 프롬프트 (필요시)
  (축소된 도구 목록)        모델 호출              │
                                             실행 또는 거부 라우팅

from enum import Enum


class PermissionMode(Enum):
    PLAN = "plan"
    DEFAULT = "default"
    ACCEPT_EDITS = "acceptEdits"
    DONT_ASK = "dontAsk"
    BYPASS = "bypassPermissions"
    AUTO = "auto"
    BUBBLE = "bubble"


READ_ONLY_TOOLS = {"Read", "Grep", "Glob", "LSP"}


def should_prompt(mode: PermissionMode, tool_name: str,
                  classifier=None, context=None) -> bool:
    """이 도구 호출에 사용자 승인이 필요한지 판단합니다."""
    if mode == PermissionMode.PLAN:
        return tool_name not in READ_ONLY_TOOLS  # True = 차단
    if mode == PermissionMode.BYPASS:
        return False
    if mode == PermissionMode.BUBBLE:
        raise EscalateToParent(tool_name)  # 부모 에이전트로 위임
    if tool_name in READ_ONLY_TOOLS:
        return False
    if mode == PermissionMode.ACCEPT_EDITS:
        return tool_name not in {"Edit", "Write"}
    if mode == PermissionMode.DONT_ASK:
        return is_high_risk(tool_name, context)
    if mode == PermissionMode.AUTO:
        return classifier(tool_name, context).is_risky
    return True  # default: 쓰기 도구는 항상 물어봄

from dataclasses import dataclass
import re


@dataclass
class PermissionResult:
    allowed: bool
    reason: str
    stage: int


def evaluate_permission(
    tool_call: dict,
    mode: PermissionMode,
    deny_rules: list[str],
    allow_rules: list[str],
) -> PermissionResult:
    """deny-first 순서로 퍼미션을 평가합니다."""
    tool_name = tool_call["name"]
    tool_args = tool_call.get("arguments", {})
    call_repr = f"{tool_name}({tool_args})"

    # Stage 1: Mode Gate
    if mode == PermissionMode.PLAN and tool_name not in READ_ONLY_TOOLS:
        return PermissionResult(False, "plan 모드: 쓰기 차단", 1)
    if mode == PermissionMode.BYPASS:
        return PermissionResult(True, "bypass 모드: 전부 허용", 1)

    # Stage 2: Deny Rules (먼저 검사)
    for pattern in deny_rules:
        if re.search(pattern, call_repr):
            return PermissionResult(False, f"deny 규칙 매칭: {pattern}", 2)

    # Stage 3: Allow Rules (deny 통과 후 검사)
    for pattern in allow_rules:
        if re.search(pattern, call_repr):
            return PermissionResult(True, f"allow 규칙 매칭: {pattern}", 3)

    # Stage 4-5로 넘어감 (이 함수는 규칙 평가만 담당)
    return PermissionResult(False, "규칙 미매칭: 분류기/사용자 판단 필요", 4)

from dataclasses import dataclass


@dataclass
class ClassifierResult:
    is_risky: bool
    confidence: float
    reason: str


SAFE_TOOLS = {"Read", "Grep", "Glob", "LSP"}
RISKY_PATTERNS = [
    r"--force", r"-rf\b", r"--hard",
    r"/(etc|usr|sys)/", r"rm\s+.*\*",
    r"\b(curl|wget|ssh)\b", r"-delete\b",
]
SAFE_PATTERNS = [
    r"\b(ls|cat|grep|find|head|tail)\b",
    r"\b(npm|yarn|pip)\s+(test|lint|check)\b",
    r"\bgit\s+(status|log|diff|branch)\b",
]


async def yolo_classifier(
    tool_name: str,
    tool_args: dict,
    context: list[dict],
    llm_call,
) -> ClassifierResult:
    """2단계 위험도 분류기."""
    # 읽기 전용 도구: 분류 불필요
    if tool_name in SAFE_TOOLS:
        return ClassifierResult(False, 1.0, "읽기 전용 도구")

    call_repr = f"{tool_name}({tool_args})"

    # Stage 1: 패턴 기반 빠른 분류
    for pattern in RISKY_PATTERNS:
        if re.search(pattern, call_repr):
            return ClassifierResult(True, 0.9, f"위험 패턴: {pattern}")
    for pattern in SAFE_PATTERNS:
        if re.search(pattern, call_repr):
            return ClassifierResult(False, 0.9, f"안전 패턴: {pattern}")

    # Stage 2: LLM 기반 심층 분류 (경계 사례, chain-of-thought)
    assessment = await llm_call(
        f"이 도구 호출의 위험도를 단계별로 분석하세요: {call_repr}",
        max_tokens=256,
    )
    is_risky = "risky" in assessment.lower()
    return ClassifierResult(is_risky, 0.7, f"LLM 판단: {assessment}")

denied_result = {
    "role": "tool",
    "tool_use_id": tool_call.id,
    "content": "Permission denied by user. "
               "The user chose not to execute this tool call. "
               "Consider an alternative approach.",
}

from dataclasses import dataclass, field


@dataclass
class PermissionPipeline:
    mode: PermissionMode
    deny_rules: list[str] = field(default_factory=list)
    allow_rules: list[str] = field(default_factory=list)
    classifier: object = None  # yolo_classifier

    async def evaluate(self, tool_call: dict,
                       context: list[dict],
                       llm_call=None) -> PermissionResult:
        """7단계 deny-first 파이프라인."""
        tool_name = tool_call["name"]
        call_repr = f"{tool_name}({tool_call.get('arguments', {})})"

        # Stage 1: Mode Gate
        if self.mode == PermissionMode.PLAN:
            if tool_name not in READ_ONLY_TOOLS:
                return PermissionResult(False, "plan 모드", 1)
        if self.mode == PermissionMode.BYPASS:
            return PermissionResult(True, "bypass 모드", 1)

        # Stage 2: Deny Rules
        for pattern in self.deny_rules:
            if re.search(pattern, call_repr):
                return PermissionResult(False, f"deny: {pattern}", 2)

        # Stage 3: Allow Rules
        for pattern in self.allow_rules:
            if re.search(pattern, call_repr):
                return PermissionResult(True, f"allow: {pattern}", 3)

        # Stage 4: ML Classifier (auto 모드)
        if self.mode == PermissionMode.AUTO and self.classifier:
            result = await self.classifier(
                tool_name, tool_call.get("arguments", {}),
                context, llm_call,
            )
            if not result.is_risky:
                return PermissionResult(True, "분류기: safe", 4)

        # Stage 5: 모드별 자동 승인 판단
        if tool_name in READ_ONLY_TOOLS:
            return PermissionResult(True, "읽기 전용", 5)
        if self.mode == PermissionMode.DONT_ASK:
            if not is_high_risk(tool_name, tool_call.get("arguments", {})):
                return PermissionResult(True, "dontAsk 모드", 5)
        if self.mode == PermissionMode.ACCEPT_EDITS:
            if tool_name in {"Edit", "Write"}:
                return PermissionResult(True, "acceptEdits 모드", 5)

        # Stage 5 (continued): 사용자 프롬프트 필요
        return PermissionResult(False, "사용자 승인 필요", 5)


async def guarded_loop(
    task: str, tools: dict, llm_call,
    pipeline: PermissionPipeline,
    max_turns: int = 100,
):
    """퍼미션 파이프라인을 갖춘 에이전트 루프."""
    messages = [{"role": "user", "content": task}]

    for turn in range(max_turns):
        response = await llm_call(messages, tools=list(tools.keys()))

        if not response.tool_calls:
            return response.text

        for call in response.tool_calls:
            result = await pipeline.evaluate(
                call, messages, llm_call,
            )
            if result.allowed:
                output = await tools[call.name](**call.args)
                messages.append(tool_result(call.id, str(output)))
            else:
                # Stage 6-7: 거부 라우팅
                # 프로덕션에서는 여기서 사용자 프롬프트 UI를 호출합니다
                messages.append({
                    "role": "tool",
                    "tool_use_id": call.id,
                    "content": f"Permission denied: {result.reason}",
                })

    return "최대 턴 수 도달"