openai key

.gitignore

@@ -11,12 +11,12 @@ env/
 
 # Distribution / packaging
 build/
-dist/
+dist/``
 *.egg-info/
 .eggs/
 
 # Installer logs
-pip-log.txt
+pip-log.txt``
 pip-delete-this-directory.txt
 
 # Unit test / coverage

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

Gradio_UI.py

@@ -141,9 +141,10 @@ def stream_to_gradio(
 
     for step_log in agent.run(task, stream=True, reset=reset_agent_memory, additional_args=additional_args):
         # Track tokens if model provides them
-        if hasattr(agent.model, "last_input_token_count"):
+        if hasattr(agent.model, "last_input_token_count") and agent.model.last_input_token_count is not None:
             total_input_tokens += agent.model.last_input_token_count
-            total_output_tokens += agent.model.last_output_token_count
+            if agent.model.last_output_token_count is not None:
+                total_output_tokens += agent.model.last_output_token_count
             if isinstance(step_log, ActionStep):
                 step_log.input_token_count = agent.model.last_input_token_count
                 step_log.output_token_count = agent.model.last_output_token_count

README_LOCAL.md

@@ -0,0 +1,57 @@
+First Agent Template — Local Run Guide
+
+This file explains how to run the prototype locally (macOS, zsh).
+
+Assumptions
+- Project root: /Users/gautam.kumar/Desktop/agents/First_agent_template
+- You will use the included virtualenv `.venv` or create one.
+
+1) Create & activate a venv (if needed)
+
+```bash
+cd /Users/gautam.kumar/Desktop/agents/First_agent_template
+python3 -m venv .venv
+source .venv/bin/activate
+```
+
+2) Install dependencies
+
+```bash
+pip install --upgrade pip
+pip install -r requirements.txt
+# optional: install gradio UI extras
+pip install "smolagents[gradio]"
+```
+
+3) Smoke tests
+
+```bash
+PYTHONPATH=$(pwd) python tests/run_nlu_test.py
+```
+
+4) Demo run
+
+```bash
+PYTHONPATH=$(pwd) python tests/run_dialog_demo.py
+```
+
+5) Interactive CLI
+
+```bash
+PYTHONPATH=$(pwd) python tools/interactive_cli.py
+```
+
+Interactive CLI tips
+- Type natural sentences like: "I can pay ¥30000 by next Friday"
+- If assistant asks for missing info ("Can I confirm your full name?"), reply with the requested info.
+- To request a human operator: "I want to talk to an operator tomorrow morning" — the assistant will propose JST slots.
+- Type `exit` or `quit` to leave.
+
+Data & files
+- `data/requests.json` — saved handoff requests (JSON).
+- `data/operator_notifications.log` — operator notification stub logs.
+
+If you want, I can:
+- Add this file into the main `README.md` (merge), or keep it separate.
+- Add unit tests and CI configs.
+- Improve the CLI to track dialogue state across multiple turns more robustly.

app.py

@@ -1,4 +1,4 @@
-from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
+from smolagents import CodeAgent, DuckDuckGoSearchTool, OpenAIServerModel, load_tool, tool
 import datetime
 import requests
 import pytz
@@ -98,14 +98,22 @@ def get_current_time_in_timezone(timezone: str) -> str:
 
 final_answer = FinalAnswerTool()
 
-# If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
-# model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 
 
-model = HfApiModel(
-max_tokens=2096,
-temperature=0.5,
-model_id='Qwen/Qwen2.5-Coder-32B-Instruct',# it is possible that this model may be overloaded
-custom_role_conversions=None,
+# Get OpenAI API key from environment variable
+openai_api_key = os.getenv('OPENAI_API_KEY')
+if not openai_api_key:
+    raise ValueError("Please set the OPENAI_API_KEY environment variable")
+
+import urllib3
+# Disable SSL verification warnings
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+model = OpenAIServerModel(
+    api_key=openai_api_key,
+    model_id="gpt-5-mini-2025-08-07",  # Using GPT-4 Turbo, you can change to gpt-3.5-turbo for lower cost
+    max_tokens=2096,
+    # verify_ssl=False,  # Disable SSL verification
+    temperature=0.5,
 )
 
 

debug_test.py

@@ -0,0 +1,100 @@
+import os
+import pytz
+from tools.nlu_tool import extract_intent_and_slots
+from tools.scheduler import find_common_slots
+from datetime import datetime
+from smolagents import OpenAIServerModel
+
+def test_timezone_function():
+    """Test the timezone functionality"""
+    try:
+        tz = pytz.timezone('America/New_York')
+        local_time = datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+        print("Timezone test passed:", local_time)
+    except Exception as e:
+        print("Timezone test failed:", str(e))
+
+def test_nlu():
+    """Test the NLU functionality"""
+    try:
+        # Test with an amount in yen
+        test_text = "I need to transfer ¥30,000"
+        result = extract_intent_and_slots(test_text)
+        print("NLU test result (amount):", result)
+        
+        # Test with a date/time
+        test_text_2 = "Schedule for tomorrow at 2pm"
+        result_2 = extract_intent_and_slots(test_text_2)
+        print("NLU test result (schedule):", result_2)
+    except Exception as e:
+        print("NLU test failed:", str(e))
+
+def test_scheduler():
+    """Test the scheduler functionality"""
+    try:
+        # Create proper datetime objects in Asia/Tokyo timezone
+        import dateparser
+        from datetime import datetime, timedelta
+        tz = pytz.timezone('Asia/Tokyo')
+        settings = {'TIMEZONE': 'Asia/Tokyo', 'RETURN_AS_TIMEZONE_AWARE': True}
+        
+        tomorrow = datetime.now() + timedelta(days=1)
+        start_str = f"tomorrow 09:00"
+        end_str = f"tomorrow 12:00"
+        
+        start = dateparser.parse(start_str, settings=settings)
+        end = dateparser.parse(end_str, settings=settings)
+        
+        test_windows = [
+            {'start': start, 'end': end}
+        ]
+        result = find_common_slots(test_windows)
+        print("Scheduler test result:", result)
+    except Exception as e:
+        print("Scheduler test failed:", str(e))
+
+def test_openai_connection():
+    """Test the OpenAI API connection"""
+    try:
+        print("Testing OpenAI API connection...")
+        openai_api_key = os.getenv('OPENAI_API_KEY')
+        if not openai_api_key:
+            print("❌ Error: OPENAI_API_KEY environment variable is not set")
+            return
+
+        model = OpenAIServerModel(
+            api_key=openai_api_key,
+            model_id="gpt-5-mini-2025-08-07",
+            max_tokens=50,
+            temperature=0.5,
+        )
+
+        # Try a simple chat completion to test the connection
+        test_prompt = "Say 'Hello, the API is working!'"
+        try:
+            response = model.generate_text(test_prompt)
+            print("✅ OpenAI API Test Response:", response)
+        except Exception as e:
+            print("❌ API Call Error:", str(e))
+            print("Error details:", str(type(e).__name__))
+            
+    except Exception as e:
+        print("❌ OpenAI Setup Error:", str(e))
+
+def main():
+    print("Starting debug tests...")
+    
+    print("\n1. Testing OpenAI API connection:")
+    test_openai_connection()
+    
+    print("\n2. Testing timezone functionality:")
+    test_timezone_function()
+    
+    print("\n3. Testing NLU:")
+    test_nlu()
+    
+    print("\n4. Testing scheduler:")
+    test_scheduler()
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,6 +1,7 @@
 markdownify
-smolagents==1.13.0
+smolagents[gradio]
+# smolagents==1.13.0
 requests
 duckduckgo_search
 pandas
-dateparser
+dateparser

tests/run_dialog_demo.py

@@ -0,0 +1,14 @@
+from tools.dialog_handler import handle_message
+
+print('--- Payment commitment flow ---')
+msg = 'I can pay ¥25000 by 2025-10-10'
+out = handle_message(msg)
+print('User:', msg)
+print('Assistant:', out['response'])
+print('Created request:', out['request'])
+
+print('\n--- Request human operator flow ---')
+msg2 = 'I want to talk to an operator tomorrow morning'
+out2 = handle_message(msg2)
+print('User:', msg2)
+print('Assistant:', out2['response'])

tools/dialog_handler.py

@@ -0,0 +1,119 @@
+import typing
+from tools import nlu_tool, scheduler, requests_store
+from app import propose_slots, notify_operator
+import yaml
+import os
+
+PROMPTS_PATH = 'prompts.yaml'
+
+def _load_prompts():
+    with open(PROMPTS_PATH, 'r') as f:
+        txt = f.read()
+    # If file contains a fenced code block (```yaml ... ```), strip fences
+    stripped = txt
+    lines = txt.splitlines()
+    if lines and lines[0].strip().startswith("```") and lines[-1].strip().startswith("```"):
+        stripped = "\n".join(lines[1:-1])
+
+    data = yaml.safe_load(stripped)
+
+    # recursively search for collection_assistant
+    def find_collection(obj):
+        if isinstance(obj, dict):
+            if 'collection_assistant' in obj:
+                return obj['collection_assistant']
+            for v in obj.values():
+                found = find_collection(v)
+                if found is not None:
+                    return found
+        elif isinstance(obj, list):
+            for item in obj:
+                found = find_collection(item)
+                if found is not None:
+                    return found
+        return None
+
+    found = find_collection(data)
+    if found is not None:
+        # If the value is a YAML block string (from |-) parse it into a dict
+        if isinstance(found, str):
+            try:
+                inner = yaml.safe_load(found)
+                if isinstance(inner, dict):
+                    return inner
+            except Exception:
+                pass
+        return found
+    raise KeyError('collection_assistant')
+
+
+def handle_message(message: str, context: dict = None) -> dict:
+    """High-level handler that accepts a user message and performs:
+    - NLU (intent + slots)
+    - Minimal slot-filling for payment_commitment
+    - Confirmation and request creation
+    - Scheduling flow for human-operator requests
+
+    Returns a dict with response text and any created request record.
+    """
+    prompts = _load_prompts()
+    nlu = nlu_tool.extract_intent_and_slots(message)
+    intent = nlu.get('intent')
+    slots = nlu.get('slots', {})
+    response = ""
+    created = None
+
+    if intent == 'payment_commitment':
+        # find payment_commitment intent meta
+        slot_meta = next((x for x in prompts.get('intents', []) if x.get('name') == 'payment_commitment'), None)
+        # ensure required slots: customer_name, account_number, amount, date_by_when
+        missing = []
+        for s in ['customer_name', 'account_number', 'amount', 'date_by_when']:
+            if s not in slots or not slots[s]:
+                missing.append(s)
+
+        if missing:
+            # return prompt for the first missing slot (simple)
+            if slot_meta:
+                slot_prompt = next((x.get('prompt') for x in slot_meta.get('slots', []) if x.get('id') == missing[0]), None)
+                response = slot_prompt or f"Please provide {missing[0]}"
+            else:
+                response = f"Please provide {missing[0]}"
+            return {'response': response, 'request': None}
+
+        # All required slots present -> confirm and create request
+        tpl = slot_meta.get('confirmation_template') if slot_meta else "Thank you. I recorded your commitment."
+        response = tpl.format(customer_name=slots.get('customer_name', '[unknown]'), account_number=slots.get('account_number', '[unknown]'), amount=slots.get('amount'), date_by_when=slots.get('date_by_when'))
+
+        handoff_tpl = slot_meta.get('handoff_payload_template') if slot_meta else None
+        if handoff_tpl:
+            handoff_json = handoff_tpl.format(customer_name=slots.get('customer_name', ''), account_number=slots.get('account_number', ''), amount=slots.get('amount', ''), date_by_when=slots.get('date_by_when', ''), contact_preference=slots.get('contact_preference', ''), nlu_confidence=nlu.get('nlu_confidence', 0))
+        else:
+            handoff_json = str({'type': 'payment_commitment', 'slots': slots})
+
+        # persist
+        created = requests_store.create_request({'raw_payload': handoff_json})
+
+        # notify operator stub
+        notify_operator(f"HANDOFF: {handoff_json}")
+
+        return {'response': response, 'request': created}
+
+    if intent == 'request_human_operator':
+        # find intent meta
+        req_meta = next((x for x in prompts.get('intents', []) if x.get('name') == 'request_human_operator'), None)
+        preferred = []
+        if 'preferred_windows' in slots and slots['preferred_windows']:
+            preferred = [{'start': slots['preferred_windows'], 'end': slots['preferred_windows']}]
+        candidates = propose_slots(preferred)
+        if req_meta:
+            response = req_meta.get('propose_slots_template', '').format(slot1_local=candidates[0] if len(candidates) > 0 else '', slot2_local=candidates[1] if len(candidates) > 1 else '', slot3_local=candidates[2] if len(candidates) > 2 else '')
+        else:
+            response = f"I can connect you at: {', '.join(candidates)}"
+        return {'response': response, 'request': None}
+
+    # fallback
+    response = prompts.get('behaviors', {}).get('fallback', {}).get('prompt', "I didn't understand. Can you rephrase?")
+    if not response:
+        response = "I didn't understand. Can you rephrase?"
+    return {'response': response, 'request': None}

tools/interactive_cli.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+import os
+import sys
+from tools.dialog_handler import handle_message
+from tools import nlu_tool
+
+def prompt_loop():
+    print("Interactive CLI for collection assistant. Type 'exit' to quit.")
+    context = {}
+    while True:
+        msg = input('You: ').strip()
+        if msg.lower() in ('exit','quit'):
+            print('Goodbye')
+            break
+
+        # run NLU first to see what is missing
+        nlu = nlu_tool.extract_intent_and_slots(msg)
+        intent = nlu.get('intent')
+        print(f"(NLU -> intent={intent}, slots={nlu.get('slots')})")
+
+        # call handler - it will return either a prompt for missing slot or a confirmation
+        out = handle_message(msg, context=context)
+        print('Assistant:', out['response'])
+
+        # If handler requested a missing slot (no request created), accept next input as value and append to message
+        if out.get('request') is None and 'Please provide' in out['response'] or out['response'].endswith('?'):
+            # ask user to provide the requested info and re-run
+            follow = input('You (reply): ').strip()
+            # naive: append to previous message for NLU re-processing
+            combined = follow
+            out2 = handle_message(combined, context=context)
+            print('Assistant:', out2['response'])
+            if out2.get('request'):
+                print('Created request:', out2['request'])
+
+if __name__ == '__main__':
+    prompt_loop()