File size: 9,806 Bytes
28fad98
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
import gradio as gr
import asyncio
import os
import logging
from dotenv import load_dotenv
from google.adk.sessions import DatabaseSessionService
from google.adk.runners import Runner
from google.genai import types
from huggingface_hub import HfApi, HfApiHTTPError

# Asumsi struktur proyek Anda dipertahankan
from src.logging import setup_logging
from src.db import DB_PATH, DB_URL, engine, initialize_db
from src.agents.agent import finova # Impor agen utama
from src.utils import display_state, process_agent_response

# --- Inisialisasi ---
load_dotenv()
setup_logging()
logger = logging.getLogger(__name__)

# Setup Langfuse (Opsional)
def setup_tracing():
    """Setup tracing for observability"""
    if os.getenv("LANGFUSE_PUBLIC_KEY") and os.getenv("LANGFUSE_SECRET_KEY"):
        try:
            from langfuse import get_client
            langfuse = get_client()
            if langfuse.auth_check():
                logger.info("Langfuse client authenticated. Observability ENABLED.")
                from openinference.instrumentation.google_adk import GoogleADKInstrumentor
                GoogleADKInstrumentor().instrument()
            else:
                logger.warning("Langfuse client authentication failed")
        except ImportError:
             logger.warning("Langfuse not installed. pip install langfuse openinference-instrumentation-google-adk")
        except Exception as e:
            logger.error(f"Error setting up Langfuse: {e}")
    else:
        logger.warning("Langfuse observability is DISABLED. Set LANGFUSE keys to enable.")

# Setup Database
def setup_database():
    """Periksa database dan inisialisasi jika tidak ditemukan"""
    if not os.path.exists(DB_PATH):
        logger.warning("Database not found. Initializing...")
        try:
            initialize_db(engine)
            logger.info(f"Database created successfully at: {DB_PATH}")
        except Exception as e:
            logger.critical(f"Error initializing database: {e}")
            raise
    else:
        logger.info("Database already exists. Skipping initialization.")

logger.info("==================== GRADIO APP START ====================")
setup_tracing() # Opsional
setup_database()

# Setup Session Service dan Runner
session_service = DatabaseSessionService(db_url=DB_URL)
APP_NAME = "FinovaGradio" # Nama aplikasi yang konsisten

# State Awal
initial_state = {
    "user:name": "User",
    "user:balance": 0,
    "user:language": "eng",
    "user:currency": "USD",
    "user:financial_goals": []
}

runner = Runner(
    app_name=APP_NAME,
    agent=finova,
    session_service=session_service,
)

# --- Logika Antarmuka Gradio ---

async def get_user_id(
    hf_token: gr.OAuthToken | None, 
    request: gr.Request
) -> str:
    """
    Mendapatkan user_id yang unik.
    Prioritas: Login HF > Session Hash Anonim.
    """
    user_id = None
    if hf_token:
        try:
            # Gunakan token untuk mendapatkan info pengguna
            user_info = await asyncio.to_thread(
                HfApi().whoami, token=hf_token.token
            )
            user_id = user_info['name'] # 'name' adalah username HF
            logger.info(f"Using Hugging Face user ID: {user_id}")
        except HfApiHTTPError as e:
            logger.warning(f"Failed to get HF user info with token: {e}. Using session hash.")
            user_id = request.session_hash # Fallback
        except Exception as e:
            logger.error(f"Error during HF whoami check: {e}. Using session hash.")
            user_id = request.session_hash # Fallback
    else:
        # Pengguna tidak login
        logger.info("No HF token. Using Gradio session hash for anonymous user.")
        user_id = request.session_hash
        
    return user_id

async def get_or_create_adk_session(
    user_id: str, 
    adk_session_state: str | None
) -> str:
    """
    Mendapatkan atau membuat sesi ADK untuk user_id yang diberikan.
    """
    adk_session_id = adk_session_state
    
    if adk_session_id is None:
        logger.info(f"No existing ADK session state. Checking DB for user: {user_id}")
        
        # Periksa apakah sesi SUDAH ADA untuk user_id ini di DB
        # (Berguna untuk pengguna HF yang login me-refresh browser)
        existing_sessions = []
        try:
            session_list = await session_service.list_sessions(
                app_name=APP_NAME, user_id=user_id
            )
            existing_sessions = session_list.sessions
        except Exception as e:
            logger.warning(f"Could not list existing sessions for user {user_id}: {e}")

        if existing_sessions:
            # Gunakan kembali sesi terbaru
            adk_session_id = existing_sessions[-1].id
            logger.info(f"Reusing existing ADK session {adk_session_id} from DB for user {user_id}")
        else:
            # Buat sesi yang benar-benar baru
            logger.info(f"Creating new ADK session for user: {user_id}")
            new_session = await session_service.create_session(
                app_name=APP_NAME,
                user_id=user_id,
                state=initial_state, 
            )
            adk_session_id = new_session.id
            logger.info(f"Created new ADK session: {adk_session_id} for user: {user_id}")
    else:
        logger.info(f"Using existing ADK session from state: {adk_session_id} for user: {user_id}")
        
    return adk_session_id

async def chat_interface(
    message: str, 
    history: list, 
    adk_session_state: str | None, # Dari additional_inputs
    request: gr.Request,          # Input implisit
    hf_token: gr.OAuthToken | None  # Input implisit dari login
):
    """
    Menangani interaksi chat dengan agen Finova melalui Gradio.
    Mengelola sesi pengguna berdasarkan login HF atau session hash.
    
    Args:
        message: Pesan input dari pengguna.
        history: Riwayat percakapan.
        adk_session_state: State dari Gradio, menyimpan ADK session_id.
        request: Objek Gradio Request untuk session hash (fallback).
        hf_token: Objek Gradio OAuthToken (jika pengguna login).
        
    Returns:
        Tuple: (respons_teks_final, adk_session_state_baru)
    """
    
    try:
        # 1. Dapatkan User ID (dari HF Login atau Session Hash)
        user_id = await get_user_id(hf_token, request)
        
        # 2. Dapatkan atau Buat Sesi ADK
        adk_session_id = await get_or_create_adk_session(user_id, adk_session_state)

        # 3. Jalankan agent
        logger.info(f"User query: {message}")
        content = types.Content(role="user", parts=[types.Part(text=message)])
        final_response_text = "Sorry, I couldn't process that." 

        async for event in runner.run_async(
            user_id=user_id, session_id=adk_session_id, new_message=content
        ):
            response = await process_agent_response(event) 
            if response:
                final_response_text = response
                logger.info(f"Agent response: {final_response_text}")

        # 4. Kembalikan respons dan state yang diperbarui
        return final_response_text, adk_session_id

    except Exception as e:
        logger.error(f"Error during chat interaction for user {user_id}: {e}", exc_info=True)
        # Jika terjadi error, laporkan error dan reset state ke None.
        return f"An error occurred: {e}", None

# --- Luncurkan Gradio ---
if __name__ == "__main__":
    
    with gr.Blocks(
        theme=gr.themes.Default(primary_hue="blue", secondary_hue="neutral")
    ) as demo:
        
        # State untuk menyimpan ID Sesi ADK di seluruh giliran
        adk_session_state = gr.State(None)
        
        with gr.Sidebar():
            gr.Markdown("## Login")
            gr.Markdown(
                "Login dengan akun Hugging Face Anda untuk menyimpan riwayat percakapan Anda."
            )
            gr.LoginButton() # Tombol Login OAuth
            gr.Markdown("---")
            gr.Markdown("### Tentang Finova")
            gr.Markdown(
                "Finova adalah asisten keuangan pribadi Anda, "
                "diberdayakan oleh Google ADK dan model Gemini."
            )

        with gr.Column():
            chatbot = gr.ChatInterface(
                fn=chat_interface,
                # 'fn' akan menerima argumen implisit 'request' dan 'hf_token'
                # 'adk_session_state' harus didefinisikan secara eksplisit
                additional_inputs=[adk_session_state],
                additional_outputs=[adk_session_state],
                title="Finova Chatbot",
                description="Your Agentic Financial Assistant. Interact using natural language.",
                examples=[
                    "Hello",
                    "I bought groceries for 50 dollars",
                    "I received my salary of 2000",
                    "What's my current balance?",
                    "Add a goal: Save for a vacation",
                    "What is a good way to start investing?"
                ],
                retry_btn=None,
                undo_btn="Delete Previous",
                clear_btn="Clear Chat",
            )
            
            # Saat "Clear Chat" diklik, kita juga harus me-reset state sesi ADK
            def clear_session_state():
                logger.info("Chat cleared by user. Resetting ADK session state.")
                return None # Kembalikan None untuk me-reset state
            
            chatbot.clear_btn.click(
                fn=clear_session_state, 
                inputs=[], 
                outputs=[adk_session_state],
                queue=False # Jalankan ini dengan cepat tanpa antrian
            )

    # Metode launch Gradio menangani event loop
    demo.launch() 

    logger.info("==================== GRADIO APP END ====================")