initial commit

.gitignore

@@ -0,0 +1,66 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+.eggs/
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage
+.pytest_cache/
+.coverage
+coverage.xml
+
+# IDEs and editors
+.vscode/
+.idea/
+*.sublime-workspace
+*.sublime-project
+
+# Mac
+.DS_Store
+
+# Logs and local data
+logs/
+*.log
+/data/
+
+# Requests store and operator notifications (sensitive/ephemeral)
+data/requests.json
+data/operator_notifications.log
+
+# Python virtualenvs
+.python-version
+
+# Jupyter
+.ipynb_checkpoints/
+
+# Misc
+*.sqlite3
+*.env
+.env
+
+# Ignore compiled C extensions
+*.so
+
+# Node
+node_modules/
+
+# Terraform
+.terraform/
+
+# Local system files
+Thumbs.db

app.py

@@ -3,7 +3,10 @@ import datetime
 import requests
 import pytz
 import yaml
+import os
 from tools.final_answer import FinalAnswerTool
+from tools import nlu_tool, scheduler, requests_store
+from smolagents import tool as tool_decorator
 
 from Gradio_UI import GradioUI
 
@@ -18,6 +21,65 @@ def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return
     """
     return "What magic will you build ?"
 
+
+@tool_decorator
+def nlu(text: str) -> dict:
+    """Run NLU (intent + slots) on user text.
+
+    Args:
+        text: The user's message to analyze.
+    """
+    return nlu_tool.extract_intent_and_slots(text)
+
+
+@tool_decorator
+def propose_slots(preferred_windows: dict = None) -> list:
+    """Return up to 3 candidate operator slots based on preferred windows.
+
+    Args:
+        preferred_windows: Optional list of dicts with 'start' and 'end' strings
+            (natural language or ISO). Example: [{'start': 'tomorrow 09:00', 'end': 'tomorrow 12:00'}].
+    """
+    cust_windows = []
+    if preferred_windows:
+        for w in preferred_windows:
+            try:
+                # use dateparser to flexibly parse the start/end and normalize to Asia/Tokyo
+                import dateparser
+                settings = {'TIMEZONE': 'Asia/Tokyo', 'RETURN_AS_TIMEZONE_AWARE': True}
+                s = dateparser.parse(w['start'], settings=settings)
+                e = dateparser.parse(w['end'], settings=settings)
+                if s and e:
+                    cust_windows.append({'start': s, 'end': e})
+            except Exception:
+                continue
+    slots = scheduler.find_common_slots(cust_windows)
+    return slots
+
+
+@tool_decorator
+def create_request(payload: dict) -> dict:
+    """Persist a handoff request and return stored record.
+
+    Args:
+        payload: dict containing the handoff data (customer, account, amount, date_by_when, etc.)
+    """
+    return requests_store.create_request(payload)
+
+
+@tool_decorator
+def notify_operator(message: str) -> str:
+    """Stub: notify operator (logs the message into data/operator_notifications.log)
+
+    Args:
+        message: The notification content to send to operator.
+    """
+    os.makedirs('data', exist_ok=True)
+    path = 'data/operator_notifications.log'
+    with open(path, 'a') as f:
+        f.write(message + "\n---\n")
+    return "ok"
+
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
     """A tool that fetches the current local time in a specified timezone.
@@ -55,7 +117,7 @@ with open("prompts.yaml", 'r') as stream:
     
 agent = CodeAgent(
     model=model,
-    tools=[final_answer, get_current_time_in_timezone], ## add your tools here (don't remove final answer)
+    tools=[final_answer, get_current_time_in_timezone, nlu, propose_slots, create_request, notify_operator], ## add your tools here (don't remove final answer)
     max_steps=6,
     verbosity_level=1,
     grammar=None,
@@ -66,4 +128,5 @@ agent = CodeAgent(
 )
 
 
-GradioUI(agent).launch()
+if __name__ == '__main__':
+    GradioUI(agent).launch()

prompts.yaml

@@ -319,3 +319,121 @@
   "report": |-
     Here is the final answer from your managed agent '{{name}}':
     {{final_answer}}
+  "collection_assistant": |-
+    description: "Conversation assistant helper for credit-card debt collection workflows. Use these intents and templates to detect customer intent, perform slot-filling, confirm commitments with the customer, and generate an operator handoff payload."
+    config:
+      default_confidence_threshold: 0.75
+      minimum_slot_confidence: 0.6
+
+    intents:
+      - name: detect_intent
+        description: "Classify utterances into one of: payment_commitment, request_human_operator, billing_question, update_contact, other"
+        sample_utterances:
+          - "I can pay X by DATE"
+          - "I need to talk to an operator"
+          - "My billing address changed"
+          - "I want to dispute a charge"
+
+      - name: payment_commitment
+        description: "Customer commits to a payment or partial payment by a certain date. The assistant should collect slots and confirm before handoff."
+        slots:
+          - id: customer_name
+            type: string
+            required: true
+            prompt: "Can I confirm your full name?"
+          - id: account_number
+            type: string
+            required: true
+            prompt: "Please provide the last 4 digits of your account number."
+          - id: amount
+            type: currency
+            currency: JPY
+            required: true
+            prompt: "How much do you plan to pay (approx) in Japanese yen (¥)?"
+          - id: date_by_when
+            type: date
+            required: true
+            prompt: "By which date can you make this payment?"
+          - id: contact_preference
+            type: enum
+            values: [sms, email, phone]
+            required: false
+            prompt: "How would you like us to contact you about this request? (sms/email/phone)"
+        confirmation_template: >-
+          Thank you {customer_name}. I have recorded that you'll pay {amount} (JPY) by {date_by_when} for account ending {account_number}.
+          I will send this to an operator for approval. You'll be notified when the status changes.
+        handoff_payload_template: |-
+          {
+            "type": "payment_commitment",
+            "customer_name": "{customer_name}",
+            "account_last4": "{account_number}",
+            "amount": "{amount}",
+            "date_by_when": "{date_by_when}",
+            "contact_preference": "{contact_preference}",
+            "nlu_confidence": {nlu_confidence}
+          }
+        operator_message_template: |-
+          New payment commitment needs approval.
+          Customer: {customer_name}
+          Account (last4): {account_number}
+          Amount: {amount}
+          Commit by: {date_by_when}
+          Contact pref: {contact_preference}
+          NLU confidence: {nlu_confidence}
+          Actions: [APPROVE, REJECT, REQUEST_CALL]
+
+      - name: request_human_operator
+        description: "Customer explicitly asks to speak with an operator. Assistant should check operator availability and propose common timeslots."
+        slots:
+          - id: customer_name
+            type: string
+            required: false
+            prompt: "May I have your name so I can connect you?"
+          - id: preferred_windows
+            type: string
+            required: false
+            prompt: "Do you have preferred times or days for a call?"
+        scheduling_instructions: |-
+          1) Query operator availability via calendar API (stub: tools.check_availability(customer_timezone, duration=15))
+          2) Find up to 3 candidate slots that overlap with customer's preferred windows (or next available slots if none provided).
+          3) Present candidate slots to customer for selection and confirm.
+          4) Once customer confirms, create handoff payload with proposed slot and notify operator.
+        propose_slots_template: >-
+          I can connect you with an operator. Here are some available times:
+          1) {slot1_local}
+          2) {slot2_local}
+          3) {slot3_local}
+          Which one works best for you?
+        operator_notification_template: |-
+          Customer requests a live operator call.
+          Customer: {customer_name}
+          Preferred windows: {preferred_windows}
+          Proposed slot: {confirmed_slot}
+          NLU confidence: {nlu_confidence}
+
+      - name: fallback
+        description: "Low-confidence or unrecognized requests. Ask clarifying question and avoid making commitments."
+        prompt: "I didn't fully understand that. Can you please rephrase or provide more details?"
+
+    behaviors:
+      - name: low_confidence_flow
+        when: "nlu_confidence < config.default_confidence_threshold"
+        actions:
+          - ask_clarifying_question: true
+          - avoid_handoff: true
+
+      - name: commit_then_handoff
+        when: "intent == payment_commitment and all required slots filled and nlu_confidence >= config.default_confidence_threshold"
+        actions:
+          - confirm_with_user: "confirmation_template"
+          - create_request_record: "handoff_payload_template"
+          - notify_user: "Your request has been created and an operator will review it. We'll notify you when the status changes."
+          - notify_operator: "operator_message_template"
+
+    examples: |
+      Example conversation - payment commitment:
+        Customer: "I can pay ¥30000 by next Friday"
+        Assistant: "Thanks — can I confirm your full name and last 4 of account?"
+        Customer: "Gautam Kumar, account 1234"
+        Assistant: "Great, I have recorded that you'll pay ¥30000 by 2025-10-10 for account ending 1234. I'll send this to an operator for approval and notify you when status changes."
+

requirements.txt

@@ -3,3 +3,4 @@ smolagents==1.13.0
 requests
 duckduckgo_search
 pandas
+dateparser

tests/run_nlu_test.py

@@ -0,0 +1,31 @@
+from tools.nlu_tool import extract_intent_and_slots
+from tools.scheduler import find_common_slots, get_operator_availability
+import datetime
+import pytz
+from app import propose_slots
+
+print('NLU test 1:')
+r1 = extract_intent_and_slots('I can pay ¥30000 by next Friday')
+print(r1)
+print('parsed date_by_when:', r1.get('slots', {}).get('date_by_when'))
+print('\nNLU test 2:')
+print(extract_intent_and_slots('I need to talk to an operator'))
+
+print('\nScheduler sample operator slots (first 3):')
+ops = get_operator_availability()
+for s in ops[:3]:
+    print(s.isoformat())
+
+# Example customer window for find_common_slots (timezone-aware Asia/Tokyo)
+TZ = pytz.timezone('Asia/Tokyo')
+now = datetime.datetime.now(TZ)
+start = TZ.localize(datetime.datetime(now.year, now.month, now.day, 9)) + datetime.timedelta(days=2)
+end = TZ.localize(datetime.datetime(now.year, now.month, now.day, 12)) + datetime.timedelta(days=2)
+slots = find_common_slots([{'start': start, 'end': end}])
+print('\nCommon slots:')
+for s in slots:
+    print(s)
+
+print('\nPropose slots using preferred window ("tomorrow 09:00" to "tomorrow 12:00")')
+prefs = [{'start': 'tomorrow 09:00', 'end': 'tomorrow 12:00'}]
+print(propose_slots(prefs))

tools/nlu_tool.py

@@ -0,0 +1,69 @@
+import re
+from typing import Dict, Any, Tuple
+import dateparser
+import pytz
+import datetime
+
+
+def parse_amount_and_currency(text: str) -> Tuple[str, float]:
+    """Simple parser: looks for yen amounts like "¥30000" or "30000 yen" or numbers.
+    Returns tuple (currency, amount)
+    """
+    # look for ¥ symbol
+    m = re.search(r"¥\s?([0-9,]+)", text)
+    if m:
+        amt = float(m.group(1).replace(',', ''))
+        return ("JPY", amt)
+    m = re.search(r"([0-9,]+)\s*(yen|JPY)\b", text, flags=re.I)
+    if m:
+        amt = float(m.group(1).replace(',', ''))
+        return ("JPY", amt)
+    # fallback: any number
+    m = re.search(r"([0-9,]+)", text)
+    if m:
+        return ("JPY", float(m.group(1).replace(',', '')))
+    return ("", 0.0)
+
+
+def extract_intent_and_slots(text: str) -> Dict[str, Any]:
+    text_l = text.lower()
+    result = {
+        'intent': 'other',
+        'nlu_confidence': 0.5,
+        'slots': {}
+    }
+
+    # detect request for human
+    if any(kw in text_l for kw in ['operator', 'human', 'representative', 'staff', 'talk to']):
+        result['intent'] = 'request_human_operator'
+        result['nlu_confidence'] = 0.9
+        return result
+
+    # detect payment commitment
+    if any(kw in text_l for kw in ['pay', 'payment', 'i will pay', 'i can pay']):
+        result['intent'] = 'payment_commitment'
+        result['nlu_confidence'] = 0.85
+        # amount
+        currency, amount = parse_amount_and_currency(text)
+        if amount > 0:
+            result['slots']['amount'] = f"{int(amount)}"
+        # date: use dateparser with Japan timezone
+        settings = {'TIMEZONE': 'Asia/Tokyo', 'RETURN_AS_TIMEZONE_AWARE': True}
+        # try to parse phrases like 'by next Friday' or 'by 2025-10-10'
+        m = re.search(r"by\s+(.+)$", text, flags=re.I)
+        parsed = None
+        if m:
+            parsed = dateparser.parse(m.group(1).strip(), settings=settings)
+        if not parsed:
+            # try to parse full sentence for a date
+            parsed = dateparser.parse(text, settings=settings)
+        if parsed:
+            # normalize to Asia/Tokyo and isoformat
+            tz = pytz.timezone('Asia/Tokyo')
+            if parsed.tzinfo is None:
+                parsed = tz.localize(parsed)
+            else:
+                parsed = parsed.astimezone(tz)
+            result['slots']['date_by_when'] = parsed.isoformat()
+
+    return result

tools/requests_store.py

@@ -0,0 +1,34 @@
+import json
+import os
+from typing import Dict, Any
+
+DATA_DIR = 'data'
+REQUESTS_FILE = os.path.join(DATA_DIR, 'requests.json')
+
+os.makedirs(DATA_DIR, exist_ok=True)
+
+
+def _load_all():
+    if not os.path.exists(REQUESTS_FILE):
+        return []
+    with open(REQUESTS_FILE, 'r') as f:
+        return json.load(f)
+
+
+def _save_all(items):
+    with open(REQUESTS_FILE, 'w') as f:
+        json.dump(items, f, indent=2, ensure_ascii=False)
+
+
+def create_request(payload: Dict[str, Any]) -> Dict[str, Any]:
+    items = _load_all()
+    request_id = len(items) + 1
+    payload['id'] = request_id
+    payload['status'] = 'pending'
+    items.append(payload)
+    _save_all(items)
+    return payload
+
+
+def list_requests():
+    return _load_all()

tools/scheduler.py

@@ -0,0 +1,40 @@
+import datetime
+from typing import List, Dict
+import pytz
+
+# Timezone-aware scheduler for Asia/Tokyo
+TZ = pytz.timezone('Asia/Tokyo')
+
+def _local_today():
+    return datetime.datetime.now(TZ)
+
+def get_operator_availability(duration_minutes: int = 15) -> List[datetime.datetime]:
+    now = _local_today()
+    slots = []
+    for d in range(1,6):
+        day = now + datetime.timedelta(days=d)
+        for hour_min in [(10,0),(11,0),(14,0),(15,30)]:
+            slot = TZ.localize(datetime.datetime(day.year, day.month, day.day, hour_min[0], hour_min[1]))
+            slots.append(slot)
+    return slots
+
+
+def find_common_slots(customer_windows: List[Dict], duration_minutes: int =15, max_candidates: int =3):
+    """Given customer's preferred windows (list of dicts with 'start' and 'end' datetimes),
+    return up to max_candidates slots that fit operator availability.
+    customer_windows example: [{'start': datetime, 'end': datetime}, ...]
+    Both operator slots and customer windows are assumed to be timezone-aware in Asia/Tokyo.
+    Returns list of ISO strings in Asia/Tokyo timezone.
+    """
+    operator_slots = get_operator_availability(duration_minutes)
+    candidates = []
+    for s in operator_slots:
+        for w in customer_windows:
+            if w['start'] <= s <= w['end']:
+                candidates.append(s)
+                break
+        if len(candidates) >= max_candidates:
+            break
+    if not candidates:
+        candidates = operator_slots[:max_candidates]
+    return [dt.isoformat() for dt in candidates]