version: "3.1"

nlu:

  # Intent: check_order_status
  # Covers: tracking requests, delivery ETA questions, shipment location
  # Does NOT cover: problems with the order (separate intent below)
- intent: check_order_status
  examples: |
    - where is my order
    - track my order [ORD-12345](order_id)
    - what's the status of [ORD-7621](order_id)
    - has my package shipped yet
    - when will my order arrive
    - can you check order [9981](order_id) for me
    - I want to know where my package is
    - wheres my stuff
    - order [12345](order_id) tracking
    - any update on my delivery
    - is [ORD-4432](order_id) on its way
    - still waiting for my order
    - need delivery update for [ORD-0012](order_id)
    - check my shipment
    - how long until my order gets here

  # Intent: report_order_problem
  # Covers: damaged goods, wrong item, missing items from order
  # Key distinction from above: involves a problem, not just a status check
- intent: report_order_problem
  examples: |
    - my order arrived damaged
    - I got the wrong item
    - my package is missing items
    - order [ORD-5512](order_id) is wrong
    - what I received is not what I ordered
    - the product is broken
    - something is missing from my delivery
    - I need to report a problem with order [ORD-3310](order_id)
    - received wrong product
    - my parcel was damaged when it arrived
    - the item doesn't match what I ordered
    - there's a problem with my recent delivery
    - wrong size in my order
    - item is defective
    - delivery issue with [ORD-7788](order_id)

version: "3.1"

stories:

  # Happy path: user provides order ID in their first message
- story: order status check with ID provided upfront
  steps:
  - intent: check_order_status
    entities:
    - order_id: "ORD-12345"
  - action: action_check_order_status

  # Slot-filling path: user does not provide the order ID
  # The bot asks, the user responds, then the action runs
- story: order status check requiring order ID collection
  steps:
  - intent: check_order_status
  - action: utter_ask_order_id
  - intent: inform
    entities:
    - order_id: "ORD-12345"
  - action: action_check_order_status

  # Escalation path: bot cannot resolve the issue
- story: unresolved issue escalation to human agent
  steps:
  - intent: report_order_problem
  - action: action_check_order_status
  - action: utter_offer_human_handoff
  - intent: affirm
  - action: action_create_support_ticket

  # Context switch: user changes topic mid-conversation
- story: user asks about order then asks about cancellation
  steps:
  - intent: check_order_status
    entities:
    - order_id: "ORD-12345"
  - action: action_check_order_status
  - intent: cancel_order
  - action: utter_confirm_cancellation_request

version: "3.1"

intents:
  - greet
  - goodbye
  - check_order_status
  - cancel_order
  - report_order_problem
  - ask_product_info
  - affirm
  - deny
  - inform
  - out_of_scope

entities:
  - order_id
  - product_name

slots:
  order_id:
    type: text
    influence_conversation: true
    mappings:
      - type: from_entity
        entity: order_id
  
  pending_issue_type:
    type: categorical
    values:
      - delivery_problem
      - wrong_item
      - billing
    influence_conversation: true
    mappings:
      - type: custom

responses:
  utter_greet:
    - text: "Hello. I can help with order status, cancellations, and product questions. What do you need?"
    - text: "Hi there. What can I help you with today?"

  utter_ask_order_id:
    - text: "What is your order number? You will find it in your confirmation email, formatted like ORD-12345."

  utter_offer_human_handoff:
    - text: "I want to connect you with a support agent who can resolve this properly. Would that help?"

  utter_out_of_scope:
    - text: "That is outside what I can help with directly. I can connect you with our support team for that. Would you like me to do that?"

  utter_goodbye:
    - text: "Thanks for getting in touch. Hope that sorted things out."

actions:
  - action_check_order_status
  - action_cancel_order
  - action_create_support_ticket
  - action_get_product_info

from typing import Any, Text, Dict, List
from rasa_sdk import Action, Tracker
from rasa_sdk.executor import CollectingDispatcher
from rasa_sdk.events import SlotSet
import requests
import logging

logger = logging.getLogger(__name__)


class ActionCheckOrderStatus(Action):
    """
    Retrieves live order status from the internal orders API.
    
    Called when: intent is check_order_status and order_id slot is filled.
    Returns:     Dispatcher message with status, carrier, and ETA.
                 Graceful error messages when the API is unavailable.
    """

    def name(self) -> Text:
        return "action_check_order_status"

    def run(
        self,
        dispatcher: CollectingDispatcher,
        tracker: Tracker,
        domain: Dict[Text, Any]
    ) -> List[Dict[Text, Any]]:

        order_id = tracker.get_slot("order_id")

        # Guard: should not be called without an order ID, but defend anyway
        if not order_id:
            dispatcher.utter_message(
                text="I need your order number to look that up. "
                     "It should be in your confirmation email."
            )
            return []

        try:
            response = requests.get(
                f"http://localhost:5000/api/orders/{order_id}",
                timeout=5  # Never omit this. A missing timeout stalls the action server.
            )
            response.raise_for_status()
            data = response.json()

            status = data.get("status")
            carrier = data.get("carrier")
            eta = data.get("estimated_delivery")

            if status == "delivered":
                dispatcher.utter_message(
                    text=f"Order {order_id} was delivered on {eta}. "
                         "If you did not receive it, let me know and I will open an investigation."
                )
            elif status == "in_transit":
                dispatcher.utter_message(
                    text=f"Order {order_id} is with {carrier} and is on its way. "
                         f"Estimated delivery: {eta}."
                )
            elif status == "processing":
                dispatcher.utter_message(
                    text=f"Order {order_id} is still being prepared. "
                         "It has not shipped yet. I will note this if you are concerned about a delay."
                )
            else:
                dispatcher.utter_message(
                    text=f"Order {order_id} has a status of '{status}'. "
                         "Would you like me to connect you with a support agent for more details?"
                )

        except requests.exceptions.Timeout:
            # Backend is slow. Tell the user honestly, not with a generic error.
            logger.warning(f"Order API timeout for order_id={order_id}")
            dispatcher.utter_message(
                text="Our order system is responding slowly right now. "
                     "Try again in a minute or check your confirmation email for tracking details."
            )

        except requests.exceptions.HTTPError as err:
            if err.response.status_code == 404:
                dispatcher.utter_message(
                    text=f"I could not find order {order_id}. "
                         "Can you double-check the number? It should start with ORD-"
                )
            else:
                logger.error(f"Order API HTTP error: {err}")
                dispatcher.utter_message(
                    text="Something went wrong on our end. I have flagged this for the team. "
                         "Would you like me to connect you with a support agent instead?"
                )

        except Exception as err:
            # Catch-all: never let an unhandled exception return nothing to the user
            logger.error(f"Unexpected error in ActionCheckOrderStatus: {err}")
            dispatcher.utter_message(
                text="I ran into an unexpected problem. Let me connect you with a support agent."
            )

        return []  # Return empty list unless you need to set/unset slots


class ActionCancelOrder(Action):
    """
    Cancels an order if it is within the cancellation window.
    Always confirms intent before executing. Irreversible actions need confirmation.
    """

    def name(self) -> Text:
        return "action_cancel_order"

    def run(
        self,
        dispatcher: CollectingDispatcher,
        tracker: Tracker,
        domain: Dict[Text, Any]
    ) -> List[Dict[Text, Any]]:

        order_id = tracker.get_slot("order_id")

        try:
            response = requests.post(
                "http://localhost:5000/api/orders/cancel",
                json={"order_id": order_id},
                timeout=5
            )
            result = response.json()

            if result.get("success"):
                dispatcher.utter_message(
                    text=f"Done. Order {order_id} has been cancelled. "
                         "Your refund will appear within 3 to 5 business days."
                )
                return [SlotSet("order_id", None)]
            else:
                reason = result.get("reason", "the cancellation window has passed")
                dispatcher.utter_message(
                    text=f"I was not able to cancel order {order_id} because {reason}. "
                         "Would you like me to open a support ticket instead?"
                )

        except Exception as err:
            logger.error(f"Cancellation error for {order_id}: {err}")
            dispatcher.utter_message(
                text="The cancellation did not go through due to a system issue. "
                     "A support agent can handle this manually. Should I connect you?"
            )

        return []

from flask import Flask, request, jsonify
from flask_cors import CORS
import os

app = Flask(__name__)
CORS(app, origins=["http://localhost:5005"])  # Restrict CORS in production

# In a real deployment, replace this with actual database queries.
# The structure stays identical. Your query replaces the dict lookup.
ORDERS_DB = {
    "ORD-12345": {
        "status": "in_transit",
        "carrier": "FedEx",
        "estimated_delivery": "May 10, 2025",
        "cancellable": False,
        "placed_at": "2025-05-06T09:00:00"
    },
    "ORD-67890": {
        "status": "processing",
        "carrier": None,
        "estimated_delivery": "May 14, 2025",
        "cancellable": True,
        "placed_at": "2025-05-06T15:30:00"
    },
}

PRODUCTS_DB = {
    "pro-plan": {
        "name": "Pro Plan",
        "price": "$49 per month",
        "features": ["Unlimited API calls", "Priority support", "Advanced analytics"],
        "trial": "14 days free"
    },
}


@app.route("/api/orders/<order_id>", methods=["GET"])
def get_order(order_id):
    order = ORDERS_DB.get(order_id.upper())
    if not order:
        return jsonify({"error": "Order not found"}), 404
    return jsonify(order), 200


@app.route("/api/orders/cancel", methods=["POST"])
def cancel_order():
    data = request.get_json()
    order_id = data.get("order_id", "").upper()
    order = ORDERS_DB.get(order_id)

    if not order:
        return jsonify({"success": False, "reason": "order not found"}), 404

    if not order["cancellable"]:
        return jsonify({
            "success": False,
            "reason": "this order has already shipped and cannot be cancelled"
        }), 200

    order["status"] = "cancelled"
    order["cancellable"] = False
    return jsonify({"success": True, "order_id": order_id}), 200


@app.route("/api/products", methods=["GET"])
def get_product():
    name = request.args.get("name", "").lower().replace(" ", "-")
    product = PRODUCTS_DB.get(name)
    if not product:
        return jsonify({"error": "Product not found"}), 404
    return jsonify(product), 200


if __name__ == "__main__":
    app.run(
        host="0.0.0.0",
        port=5000,
        debug=os.getenv("FLASK_DEBUG", "false") == "true"
    )

from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferWindowMemory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.tools import tool
import requests, os
from dotenv import load_dotenv

load_dotenv()


# Tools are what give the LLM access to real data.
# The docstring is read by the model to understand when to call each tool.

@tool
def get_order_status(order_id: str) -> str:
    """
    Retrieves the current shipping status and delivery estimate for a customer order.
    Use this when a customer asks where their order is, when it will arrive, 
    or for any tracking-related question. Requires an order ID.
    """
    try:
        r = requests.get(f"http://localhost:5000/api/orders/{order_id}", timeout=5)
        if r.status_code == 404:
            return "Order not found. Customer may have the wrong number."
        d = r.json()
        return (f"Order {order_id}: status={d['status']}, "
                f"carrier={d.get('carrier','not assigned yet')}, "
                f"ETA={d.get('estimated_delivery','not available')}")
    except Exception as e:
        return f"Could not retrieve order status: {str(e)}"


@tool
def cancel_order(order_id: str) -> str:
    """
    Cancels a customer order. Only call this after the customer has explicitly
    confirmed they want to cancel. Do not call this speculatively.
    """
    try:
        r = requests.post(
            "http://localhost:5000/api/orders/cancel",
            json={"order_id": order_id},
            timeout=5
        )
        result = r.json()
        return (f"Cancellation successful: {result}"
                if result.get("success")
                else f"Cancellation failed: {result.get('reason')}")
    except Exception as e:
        return f"Error during cancellation: {str(e)}"


# The system prompt is your brand voice, your behavioral rules, and your escalation policy.
# Invest time in writing it precisely. Vague system prompts produce vague responses.
SYSTEM_PROMPT = """You are a customer service assistant for EmiTechLogic.

You help customers with order tracking, order cancellations, and product questions.

Rules:
- Always ask for an order ID before looking up any order information.
- Always confirm before cancelling an order. Say exactly what will happen and ask for a yes.
- If you cannot help with something, say so clearly and offer to escalate to a human agent.
- Keep responses direct and specific. Do not pad answers with unnecessary text.
- If an API call fails, tell the customer something went wrong and offer an alternative.

Escalation: If the customer's issue cannot be resolved through the available tools,
tell them you will connect them with a support agent and provide the ticket reference they should use.
"""

prompt = ChatPromptTemplate.from_messages([
    ("system", SYSTEM_PROMPT),
    MessagesPlaceholder("chat_history"),
    ("human", "{input}"),
    MessagesPlaceholder("agent_scratchpad"),
])

llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0.3,  # Low temperature: consistent, factual, predictable
    api_key=os.getenv("OPENAI_API_KEY")
)

tools = [get_order_status, cancel_order]

memory = ConversationBufferWindowMemory(
    memory_key="chat_history",
    k=12,           # Keep 12 turns. More than this inflates token costs without benefit.
    return_messages=True
)

agent = create_openai_tools_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory,
    max_iterations=5,             # Prevent runaway loops
    handle_parsing_errors=True  # Recover gracefully from malformed LLM output
)


def chat(user_message: str) -> str:
    result = agent_executor.invoke({"input": user_message})
    return result["output"]