intent_api.py

import intent_utils as intent
import requests
import traceback
from log import log

def auth_token_handler(api_name, auth_config, session):
    token_info = session.get("auth_tokens", {}).get(api_name)
    if token_info and "token" in token_info:
        return token_info["token"], session

    auth_endpoint = auth_config.get("auth_endpoint")
    auth_body = auth_config.get("auth_body", {})
    token_path = auth_config.get("auth_token_path")

    resolved_body = {
        k: intent.resolve_placeholders(str(v), session, session.get("variables", {})) for k, v in auth_body.items()
    }

    response = requests.post(auth_endpoint, json=resolved_body, timeout=5)
    response.raise_for_status()
    json_resp = response.json()

    token_parts = token_path.split(".")
    token = json_resp
    for part in token_parts:
        token = token.get(part)
        if token is None:
            raise Exception(f"Token path çözülemedi: {token_path}")

    refresh_token = json_resp.get("refresh_token")
    session.setdefault("auth_tokens", {})[api_name] = {
        "token": token,
        "refresh_token": refresh_token
    }

    return token, session

def refresh_auth_token(api_name, auth_config, session):
    refresh_endpoint = auth_config.get("auth_refresh_endpoint")
    refresh_body = auth_config.get("refresh_body", {})
    token_path = auth_config.get("auth_token_path")

    refresh_token = session.get("auth_tokens", {}).get(api_name, {}).get("refresh_token")
    if not refresh_token:
        raise Exception("Mevcut refresh token bulunamadı")

    resolved_body = {
        k: intent.resolve_placeholders(str(v), session, session.get("variables", {})) for k, v in refresh_body.items()
    }

    response = requests.post(refresh_endpoint, json=resolved_body, timeout=5)
    response.raise_for_status()
    json_resp = response.json()

    token_parts = token_path.split(".")
    token = json_resp
    for part in token_parts:
        token = token.get(part)
        if token is None:
            raise Exception(f"Token path çözülemedi: {token_path}")

    new_refresh_token = json_resp.get("refresh_token", refresh_token)
    session.setdefault("auth_tokens", {})[api_name] = {
        "token": token,
        "refresh_token": new_refresh_token
    }

    log(f"🔁 Token başarıyla yenilendi: {api_name}")
    return token, session

def execute_intent(intent_name, user_input, session_dict, project_name, service_config):
    session = session_dict
    try:
        # intent config
        project_intents = service_config.get_project_llm_config(project_name)["intents"]
        intent_def = next((i for i in project_intents if i["name"] == intent_name), None)
        if not intent_def:
            raise Exception(f"'{intent_name}' için intent tanımı bulunamadı.")

        action_api_name = intent_def.get("action")
        api_def = service_config.get_api_config(action_api_name)
        if not api_def:
            raise Exception(f"API '{action_api_name}' tanımı bulunamadı.")

        # API setup
        variables = session.get("variables", {})
        headers = api_def.get("headers", [])
        body = api_def.get("body", {})
        method = api_def.get("method", "POST")
        url = api_def["url"]
        timeout = api_def.get("timeout", 5)
        retry_count = api_def.get("retry_count", 0)
        auth_config = api_def.get("auth")
        tls = api_def.get("tls", {})
        verify = tls.get("verify", True)
        verify_path = tls.get("ca_bundle") if verify and tls.get("ca_bundle") else verify

        if auth_config:
            token, session = auth_token_handler(action_api_name, auth_config, session)
        else:
            token = None

        resolved_headers = {
            h["key"]: intent.resolve_placeholders(h["value"], session, variables)
            for h in headers
        }
        resolved_body = {
            k: intent.resolve_placeholders(str(v), session, variables)
            for k, v in body.items()
        }

        # API call with retries
        for attempt in range(retry_count + 1):
            try:
                response = requests.request(
                    method=method,
                    url=url,
                    headers=resolved_headers,
                    json=resolved_body,
                    timeout=timeout,
                    verify=verify_path
                )
                if response.status_code == 401 and auth_config and attempt < retry_count:
                    log("🔁 Token expired. Yenileniyor...")
                    token, session = refresh_auth_token(action_api_name, auth_config, session)
                    continue
                response.raise_for_status()
                break
            except requests.Timeout:
                fallback = intent_def.get("fallback_timeout_message", "Bu işlem şu anda gerçekleştirilemiyor.")
                log(f"⚠️ Timeout → fallback mesajı: {fallback}")
                return {"fallback": fallback}
            except Exception as e:
                log(f"❌ API çağrısı hatası: {e}")
                fallback = intent_def.get("fallback_error_message", "Bir hata oluştu.")
                return {"fallback": fallback}

        # Success
        json_resp = response.json()
        log("✅ API çağrısı başarılı")
        return {
            "reply": json_resp
        }

    except Exception as e:
        log(f"❌ execute_intent() hatası: {e}")
        traceback.print_exc()
        return {
            "fallback": "Bir hata oluştu, işlem tamamlanamadı."
        }