1st Commit

.env.sample

@@ -0,0 +1,8 @@
+# .env.sample
+# Feature toggles
+AZURE_ENABLED=false
+SENTIMENT_ENABLED=false
+DB_URL=memory://
+# Azure (optional)
+AZURE_TEXT_ANALYTICS_ENDPOINT=
+AZURE_TEXT_ANALYTICS_KEY=

Makefile

@@ -0,0 +1,11 @@
+.PHONY: dev test run seed check
+dev:
+	pip install -r requirements.txt
+test:
+	pytest -q
+run:
+	export PYTHONPATH=. && python -c "from storefront_chatbot.app.app import build; build().launch(server_name='0.0.0.0', server_port=7860)"
+seed:
+	python storefront_chatbot/scripts/seed_data.py
+check:
+	python storefront_chatbot/scripts/check_compliance.py

README.md

@@ -1,2 +1,43 @@
+<!-- README.md -->
 # Agentic-Chat-bot-
-Agentic Chat-bot with RAG, Memory, and Privacy Considerations 
+Agentic Chat-bot with RAG, Memory, and Privacy Considerations. 
+
+# Storefront Chatbot
+
+This repo follows a modular layout with a Gradio UI, NLU pipeline, anonymous and logged-in flows,
+guardrails, and optional Azure sentiment.
+
+## Quickstart
+```bash
+make dev
+make run
+# open http://localhost:7860
+```
+
+## Agentic Integration
+- Core bot: `agenticcore/chatbot/services.py`
+- Providers: `agenticcore/providers_unified.py`
+- CLI: `python -m agenticcore.cli agentic "hello"` (loads .env)
+- FastAPI demo: `uvicorn integrations.web.fastapi.web_agentic:app --reload`
+
+## Added Samples & Tests
+- chat.html → `app/assets/html/chat.html`
+- echo_bot.py → `integrations/botframework/bots/echo_bot.py`
+- ChatbotIntegration.ipynb → `notebooks/ChatbotIntegration.ipynb`
+- SimpleTraditionalChatbot.ipynb → `notebooks/SimpleTraditionalChatbot.ipynb`
+- smoke_test.py → `tests/smoke_test.py`
+- test_routes.py → `tests/test_routes.py`
+- quick_sanity.py → `tools/quick_sanity.py`
+- example.py → `examples/example.py`
+- service.py → `samples/service.py`
+- DEV_DOC.md → `docs/DEV_DOC.md`
+
+Run `pytest -q` for tests; open HTML in `app/assets/html/` to try local UIs.
+
+
+---
+This is the **unified** storefront-chatbot bundle.
+Duplicates from earlier skeletons were removed; priority order was:
+1) storefront_chatbot_final_bundle
+2) storefront_chatbot_merged_with_agentic
+3) storefront_chatbot_skeleton

agenticcore/__init__.py

@@ -0,0 +1 @@
+# package

agenticcore/chatbot/__init__.py

@@ -0,0 +1 @@
+# package

agenticcore/chatbot/services.py

@@ -0,0 +1,103 @@
+# /agenticcore/chatbot/services.py
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from typing import Dict
+
+# Delegate sentiment to the unified provider layer
+# If you put providers_unified.py under agenticcore/chatbot/, change the import to:
+#   from agenticcore.chatbot.providers_unified import analyze_sentiment
+from agenticcore.providers_unified import analyze_sentiment
+from ..providers_unified import analyze_sentiment
+
+
+def _trim(s: str, max_len: int = 2000) -> str:
+    s = (s or "").strip()
+    return s if len(s) <= max_len else s[: max_len - 1] + "…"
+
+
+@dataclass(frozen=True)
+class SentimentResult:
+    label: str          # "positive" | "neutral" | "negative" | "mixed" | "unknown"
+    confidence: float   # 0.0 .. 1.0
+
+
+class ChatBot:
+    """
+    Minimal chatbot that uses provider-agnostic sentiment via providers_unified.
+    Public API:
+      - reply(text: str) -> Dict[str, object]
+      - capabilities() -> Dict[str, object]
+    """
+
+    def __init__(self, system_prompt: str = "You are a concise helper.") -> None:
+        self._system_prompt = _trim(system_prompt, 800)
+        # Expose which provider is intended/active (for diagnostics)
+        self._mode = os.getenv("AI_PROVIDER") or "auto"
+
+    def capabilities(self) -> Dict[str, object]:
+        """List what this bot can do."""
+        return {
+            "system": "chatbot",
+            "mode": self._mode,  # "auto" or a pinned provider (hf/azure/openai/cohere/deepai/offline)
+            "features": ["text-input", "sentiment-analysis", "help"],
+            "commands": {"help": "Describe capabilities and usage."},
+        }
+
+    def reply(self, text: str) -> Dict[str, object]:
+        """Produce a reply and sentiment for one user message."""
+        user = _trim(text)
+        if not user:
+            return self._make_response(
+                "I didn't catch that. Please provide some text.",
+                SentimentResult("unknown", 0.0),
+            )
+
+        if user.lower() in {"help", "/help"}:
+            return {"reply": self._format_help(), "capabilities": self.capabilities()}
+
+        s = analyze_sentiment(user)  # -> {"provider", "label", "score", ...}
+        sr = SentimentResult(label=str(s.get("label", "neutral")), confidence=float(s.get("score", 0.5)))
+        return self._make_response(self._compose(sr), sr)
+
+    # ---- internals ----
+
+    def _format_help(self) -> str:
+        caps = self.capabilities()
+        feats = ", ".join(caps["features"])
+        return f"I can analyze sentiment and respond concisely. Features: {feats}. Send any text or type 'help'."
+
+    @staticmethod
+    def _make_response(reply: str, s: SentimentResult) -> Dict[str, object]:
+        return {"reply": reply, "sentiment": s.label, "confidence": round(float(s.confidence), 2)}
+
+    @staticmethod
+    def _compose(s: SentimentResult) -> str:
+        if s.label == "positive":
+            return "Thanks for sharing. I detected a positive sentiment."
+        if s.label == "negative":
+            return "I hear your concern. I detected a negative sentiment."
+        if s.label == "neutral":
+            return "Noted. The sentiment appears neutral."
+        if s.label == "mixed":
+            return "Your message has mixed signals. Can you clarify?"
+        return "I could not determine the sentiment. Please rephrase."
+
+
+# Optional: local REPL for quick manual testing
+def _interactive_loop() -> None:
+    bot = ChatBot()
+    try:
+        while True:
+            msg = input("> ").strip()
+            if msg.lower() in {"exit", "quit"}:
+                break
+            print(json.dumps(bot.reply(msg), ensure_ascii=False))
+    except (EOFError, KeyboardInterrupt):
+        pass
+
+
+if __name__ == "__main__":
+    _interactive_loop()

agenticcore/cli.py

@@ -0,0 +1,187 @@
+# /agenticcore/cli.py
+"""
+agenticcore.cli
+Console entrypoints:
+  - agentic: send a message to ChatBot and print reply JSON
+  - repo-tree: print a filtered tree view (uses tree.txt if present)
+  - repo-flatten: flatten code listing to stdout (uses FLATTENED_CODE.txt if present)
+"""
+import argparse, json, sys, traceback
+from pathlib import Path
+from dotenv import load_dotenv
+import os
+
+# Load .env variables into os.environ (project root .env by default)
+load_dotenv()
+
+
+def cmd_agentic(argv=None):
+    # Lazy import so other commands don't require ChatBot to be importable
+    from agenticcore.chatbot.services import ChatBot
+    # We call analyze_sentiment only for 'status' to reveal the actual chosen provider
+    try:
+        from agenticcore.providers_unified import analyze_sentiment
+    except Exception:
+        analyze_sentiment = None  # still fine; we'll show mode only
+
+    p = argparse.ArgumentParser(prog="agentic", description="Chat with AgenticCore ChatBot")
+    p.add_argument("message", nargs="*", help="Message to send")
+    p.add_argument("--debug", action="store_true", help="Print debug info")
+    args = p.parse_args(argv)
+    msg = " ".join(args.message).strip() or "hello"
+
+    if args.debug:
+        print(f"DEBUG argv={sys.argv}", flush=True)
+        print(f"DEBUG raw message='{msg}'", flush=True)
+
+    bot = ChatBot()
+
+    # Special commands for testing / assignments
+        # Special commands for testing / assignments
+    if msg.lower() == "status":
+        import requests  # local import to avoid hard dep for other commands
+
+        # Try a lightweight provider probe via analyze_sentiment
+        provider = None
+        if analyze_sentiment is not None:
+            try:
+                probe = analyze_sentiment("status ping")
+                provider = (probe or {}).get("provider")
+            except Exception:
+                if args.debug:
+                    traceback.print_exc()
+
+        # Hugging Face whoami auth probe
+        tok = os.getenv("HF_API_KEY", "")
+        who = None
+        auth_ok = False
+        err = None
+        try:
+            if tok:
+                r = requests.get(
+                    "https://huggingface.co/api/whoami-v2",
+                    headers={"Authorization": f"Bearer {tok}"},
+                    timeout=15,
+                )
+                auth_ok = (r.status_code == 200)
+                who = r.json() if auth_ok else None
+                if not auth_ok:
+                    err = r.text  # e.g., {"error":"Invalid credentials in Authorization header"}
+            else:
+                err = "HF_API_KEY not set (load .env or export it)"
+        except Exception as e:
+            err = str(e)
+
+        # Extract fine-grained scopes for visibility
+        fg = (((who or {}).get("auth") or {}).get("accessToken") or {}).get("fineGrained") or {}
+        scoped = fg.get("scoped") or []
+        global_scopes = fg.get("global") or []
+
+        # ---- tiny inference ping (proves 'Make calls to Inference Providers') ----
+        infer_ok, infer_err = False, None
+        try:
+            if tok:
+                model = os.getenv(
+                    "HF_MODEL_SENTIMENT",
+                    "distilbert-base-uncased-finetuned-sst-2-english"
+                )
+                r2 = requests.post(
+                    f"https://api-inference.huggingface.co/models/{model}",
+                    headers={"Authorization": f"Bearer {tok}", "x-wait-for-model": "true"},
+                    json={"inputs": "ping"},
+                    timeout=int(os.getenv("HTTP_TIMEOUT", "60")),
+                )
+                infer_ok = (r2.status_code == 200)
+                if not infer_ok:
+                    infer_err = f"HTTP {r2.status_code}: {r2.text}"
+        except Exception as e:
+            infer_err = str(e)
+        # -------------------------------------------------------------------------
+
+        # Mask + length to verify what .env provided
+        mask = (tok[:3] + "..." + tok[-4:]) if tok else None
+        out = {
+            "provider": provider or "unknown",
+            "mode": getattr(bot, "_mode", "auto"),
+            "auth_ok": auth_ok,
+            "whoami": who,
+            "token_scopes": {            # <--- added
+                "global": global_scopes,
+                "scoped": scoped,
+            },
+            "inference_ok": infer_ok,
+            "inference_error": infer_err,
+            "env": {
+                "HF_API_KEY_len": len(tok) if tok else 0,
+                "HF_API_KEY_mask": mask,
+                "HF_MODEL_SENTIMENT": os.getenv("HF_MODEL_SENTIMENT"),
+                "HTTP_TIMEOUT": os.getenv("HTTP_TIMEOUT"),
+            },
+            "capabilities": bot.capabilities(),
+            "error": err,
+        }
+
+    elif msg.lower() == "help":
+        out = {"capabilities": bot.capabilities()}
+
+    else:
+        try:
+            out = bot.reply(msg)
+        except Exception as e:
+            if args.debug:
+                traceback.print_exc()
+            out = {"error": str(e), "message": msg}
+
+    if args.debug:
+        print(f"DEBUG out={out}", flush=True)
+
+    print(json.dumps(out, indent=2), flush=True)
+
+
+def cmd_repo_tree(argv=None):
+    p = argparse.ArgumentParser(prog="repo-tree", description="Print repo tree (from tree.txt if available)")
+    p.add_argument("--path", default="tree.txt", help="Path to precomputed tree file")
+    args = p.parse_args(argv)
+    path = Path(args.path)
+    if path.exists():
+        print(path.read_text(encoding="utf-8"), flush=True)
+    else:
+        print("(no tree.txt found)", flush=True)
+
+
+def cmd_repo_flatten(argv=None):
+    p = argparse.ArgumentParser(prog="repo-flatten", description="Print flattened code listing")
+    p.add_argument("--path", default="FLATTENED_CODE.txt", help="Path to pre-flattened code file")
+    args = p.parse_args(argv)
+    path = Path(args.path)
+    if path.exists():
+        print(path.read_text(encoding="utf-8"), flush=True)
+    else:
+        print("(no FLATTENED_CODE.txt found)", flush=True)
+
+
+def _dispatch():
+    # Allow: python -m agenticcore.cli <subcommand> [args...]
+    if len(sys.argv) <= 1:
+        print("Usage: python -m agenticcore.cli <agentic|repo-tree|repo-flatten> [args]", file=sys.stderr)
+        sys.exit(2)
+    cmd, argv = sys.argv[1], sys.argv[2:]
+    try:
+        if cmd == "agentic":
+            cmd_agentic(argv)
+        elif cmd == "repo-tree":
+            cmd_repo_tree(argv)
+        elif cmd == "repo-flatten":
+            cmd_repo_flatten(argv)
+        else:
+            print(f"Unknown subcommand: {cmd}", file=sys.stderr)
+            sys.exit(2)
+    except SystemExit:
+        raise
+    except Exception:
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    _dispatch()

agenticcore/providers_unified.py

@@ -0,0 +1,274 @@
+# /agenticcore/providers_unified.py
+"""
+providers_unified.py
+Unified, switchable providers for sentiment + (optional) text generation.
+Selection order unless AI_PROVIDER is set:
+  HF -> AZURE -> OPENAI -> COHERE -> DEEPAI -> OFFLINE
+Env vars:
+  HF_API_KEY
+  MICROSOFT_AI_SERVICE_ENDPOINT, MICROSOFT_AI_API_KEY
+  OPENAI_API_KEY,  OPENAI_MODEL=gpt-3.5-turbo
+  COHERE_API_KEY,  COHERE_MODEL=command
+  DEEPAI_API_KEY
+  AI_PROVIDER = hf|azure|openai|cohere|deepai|offline
+  HTTP_TIMEOUT = 20
+"""
+from __future__ import annotations
+import os, json
+from typing import Dict, Any, Optional
+import requests
+
+TIMEOUT = float(os.getenv("HTTP_TIMEOUT", "20"))
+
+def _env(name: str, default: Optional[str] = None) -> Optional[str]:
+    v = os.getenv(name)
+    return v if (v is not None and str(v).strip() != "") else default
+
+def _pick_provider() -> str:
+    forced = _env("AI_PROVIDER")
+    if forced in {"hf", "azure", "openai", "cohere", "deepai", "offline"}:
+        return forced
+    if _env("HF_API_KEY"): return "hf"
+    if _env("MICROSOFT_AI_API_KEY") and _env("MICROSOFT_AI_SERVICE_ENDPOINT"): return "azure"
+    if _env("OPENAI_API_KEY"): return "openai"
+    if _env("COHERE_API_KEY"): return "cohere"
+    if _env("DEEPAI_API_KEY"): return "deepai"
+    return "offline"
+
+# ---------------------------
+# Sentiment
+# ---------------------------
+
+def analyze_sentiment(text: str) -> Dict[str, Any]:
+    provider = _pick_provider()
+    try:
+        if provider == "hf":     return _sentiment_hf(text)
+        if provider == "azure":  return _sentiment_azure(text)
+        if provider == "openai": return _sentiment_openai_prompt(text)
+        if provider == "cohere": return _sentiment_cohere_prompt(text)
+        if provider == "deepai": return _sentiment_deepai(text)
+        return _sentiment_offline(text)
+    except Exception as e:
+        return {"provider": provider, "label": "neutral", "score": 0.5, "error": str(e)}
+
+def _sentiment_offline(text: str) -> Dict[str, Any]:
+    t = (text or "").lower()
+    pos = any(w in t for w in ["love","great","good","awesome","fantastic","thank","excellent","amazing"])
+    neg = any(w in t for w in ["hate","bad","terrible","awful","worst","angry","horrible"])
+    label = "positive" if pos and not neg else "negative" if neg and not pos else "neutral"
+    score = 0.9 if label != "neutral" else 0.5
+    return {"provider": "offline", "label": label, "score": score}
+
+def _sentiment_hf(text: str) -> Dict[str, Any]:
+    """
+    Hugging Face Inference API for sentiment.
+    Uses canonical repo id and handles 404/401 and various payload shapes.
+    """
+    key = _env("HF_API_KEY")
+    if not key:
+        return _sentiment_offline(text)
+
+    # canonical repo id to avoid 404
+    model = _env("HF_MODEL_SENTIMENT", "distilbert/distilbert-base-uncased-finetuned-sst-2-english")
+    timeout = int(_env("HTTP_TIMEOUT", "30"))
+
+    headers = {
+        "Authorization": f"Bearer {key}",
+        "x-wait-for-model": "true",
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+
+    r = requests.post(
+        f"https://api-inference.huggingface.co/models/{model}",
+        headers=headers,
+        json={"inputs": text},
+        timeout=timeout,
+    )
+
+    if r.status_code != 200:
+        return {"provider": "hf", "label": "neutral", "score": 0.5, "error": f"HTTP {r.status_code}: {r.text[:500]}"}
+
+    try:
+        data = r.json()
+    except Exception as e:
+        return {"provider": "hf", "label": "neutral", "score": 0.5, "error": str(e)}
+
+    if isinstance(data, dict) and "error" in data:
+        return {"provider": "hf", "label": "neutral", "score": 0.5, "error": data["error"]}
+
+    # normalize list shape
+    arr = data[0] if isinstance(data, list) and data and isinstance(data[0], list) else (data if isinstance(data, list) else [])
+    if not (isinstance(arr, list) and arr):
+        return {"provider": "hf", "label": "neutral", "score": 0.5, "error": f"Unexpected payload: {data}"}
+
+    top = max(arr, key=lambda x: x.get("score", 0.0) if isinstance(x, dict) else 0.0)
+    raw = str(top.get("label", "")).upper()
+    score = float(top.get("score", 0.5))
+
+    mapping = {
+        "LABEL_0": "negative", "LABEL_1": "neutral", "LABEL_2": "positive",
+        "NEGATIVE": "negative", "NEUTRAL": "neutral", "POSITIVE": "positive",
+    }
+    label = mapping.get(raw, (raw.lower() or "neutral"))
+
+    neutral_floor = float(os.getenv("SENTIMENT_NEUTRAL_THRESHOLD", "0.65"))
+    if label in {"positive", "negative"} and score < neutral_floor:
+        label = "neutral"
+
+    return {"provider": "hf", "label": label, "score": score}
+
+def _sentiment_azure(text: str) -> Dict[str, Any]:
+    try:
+        from azure.core.credentials import AzureKeyCredential  # type: ignore
+        from azure.ai.textanalytics import TextAnalyticsClient  # type: ignore
+    except Exception:
+        return _sentiment_offline(text)
+    endpoint = _env("MICROSOFT_AI_SERVICE_ENDPOINT")
+    key = _env("MICROSOFT_AI_API_KEY")
+    if not (endpoint and key): return _sentiment_offline(text)
+    client = TextAnalyticsClient(endpoint=endpoint.strip(), credential=AzureKeyCredential(key.strip()))
+    resp = client.analyze_sentiment(documents=[text], show_opinion_mining=False)[0]
+    scores = {
+        "positive": float(getattr(resp.confidence_scores, "positive", 0.0) or 0.0),
+        "neutral":  float(getattr(resp.confidence_scores, "neutral",  0.0) or 0.0),
+        "negative": float(getattr(resp.confidence_scores, "negative", 0.0) or 0.0),
+    }
+    label = max(scores, key=scores.get)
+    return {"provider": "azure", "label": label, "score": scores[label]}
+
+def _sentiment_openai_prompt(text: str) -> Dict[str, Any]:
+    key = _env("OPENAI_API_KEY")
+    model = _env("OPENAI_MODEL", "gpt-3.5-turbo")
+    if not key: return _sentiment_offline(text)
+    url = "https://api.openai.com/v1/chat/completions"
+    prompt = f"Classify the sentiment of this text as positive, negative, or neutral. Reply JSON with keys label and score (0..1). Text: {text!r}"
+    r = requests.post(
+        url,
+        headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
+        json={"model": model, "messages": [{"role": "user", "content": prompt}], "temperature": 0},
+        timeout=TIMEOUT,
+    )
+    r.raise_for_status()
+    content = r.json()["choices"][0]["message"]["content"]
+    try:
+        obj = json.loads(content)
+        label = str(obj.get("label", "neutral")).lower()
+        score = float(obj.get("score", 0.5))
+        return {"provider": "openai", "label": label, "score": score}
+    except Exception:
+        l = "positive" if "positive" in content.lower() else "negative" if "negative" in content.lower() else "neutral"
+        return {"provider": "openai", "label": l, "score": 0.5}
+
+def _sentiment_cohere_prompt(text: str) -> Dict[str, Any]:
+    key = _env("COHERE_API_KEY")
+    model = _env("COHERE_MODEL", "command")
+    if not key: return _sentiment_offline(text)
+    url = "https://api.cohere.ai/v1/generate"
+    prompt = f"Classify the sentiment (positive, negative, neutral) and return JSON with keys label and score (0..1). Text: {text!r}"
+    r = requests.post(
+        url,
+        headers={
+            "Authorization": f"Bearer {key}",
+            "Content-Type": "application/json",
+            "Cohere-Version": "2022-12-06",
+        },
+        json={"model": model, "prompt": prompt, "max_tokens": 30, "temperature": 0},
+        timeout=TIMEOUT,
+    )
+    r.raise_for_status()
+    gen = (r.json().get("generations") or [{}])[0].get("text", "")
+    try:
+        obj = json.loads(gen)
+        label = str(obj.get("label", "neutral")).lower()
+        score = float(obj.get("score", 0.5))
+        return {"provider": "cohere", "label": label, "score": score}
+    except Exception:
+        l = "positive" if "positive" in gen.lower() else "negative" if "negative" in gen.lower() else "neutral"
+        return {"provider": "cohere", "label": l, "score": 0.5}
+
+def _sentiment_deepai(text: str) -> Dict[str, Any]:
+    key = _env("DEEPAI_API_KEY")
+    if not key: return _sentiment_offline(text)
+    url = "https://api.deepai.org/api/sentiment-analysis"
+    r = requests.post(url, headers={"api-key": key}, data={"text": text}, timeout=TIMEOUT)
+    r.raise_for_status()
+    data = r.json()
+    label = (data.get("output") or ["neutral"])[0].lower()
+    return {"provider": "deepai", "label": label, "score": 0.5 if label == "neutral" else 0.9}
+
+# ---------------------------
+# Text generation (optional)
+# ---------------------------
+
+def generate_text(prompt: str, max_tokens: int = 128) -> Dict[str, Any]:
+    provider = _pick_provider()
+    try:
+        if provider == "hf":     return _gen_hf(prompt, max_tokens)
+        if provider == "openai": return _gen_openai(prompt, max_tokens)
+        if provider == "cohere": return _gen_cohere(prompt, max_tokens)
+        if provider == "deepai": return _gen_deepai(prompt, max_tokens)
+        return {"provider": "offline", "text": f"(offline) {prompt[:160]}"}
+    except Exception as e:
+        return {"provider": provider, "text": f"(error) {str(e)}"}
+
+def _gen_hf(prompt: str, max_tokens: int) -> Dict[str, Any]:
+    key = _env("HF_API_KEY")
+    if not key: return {"provider": "offline", "text": f"(offline) {prompt[:160]}"}
+    model = _env("HF_MODEL_GENERATION", "tiiuae/falcon-7b-instruct")
+    r = requests.post(
+        f"https://api-inference.huggingface.co/models/{model}",
+        headers={"Authorization": f"Bearer {key}"},
+        json={"inputs": prompt, "parameters": {"max_new_tokens": max_tokens}},
+        timeout=TIMEOUT,
+    )
+    r.raise_for_status()
+    data = r.json()
+    if isinstance(data, list) and data and "generated_text" in data[0]:
+        return {"provider": "hf", "text": data[0]["generated_text"]}
+    return {"provider": "hf", "text": str(data)}
+
+def _gen_openai(prompt: str, max_tokens: int) -> Dict[str, Any]:
+    key = _env("OPENAI_API_KEY")
+    model = _env("OPENAI_MODEL", "gpt-3.5-turbo")
+    if not key: return {"provider": "offline", "text": f"(offline) {prompt[:160]}"}
+    url = "https://api.openai.com/v1/chat/completions"
+    r = requests.post(
+        url,
+        headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
+        json={"model": model, "messages": [{"role": "user", "content": prompt}], "max_tokens": max_tokens},
+        timeout=TIMEOUT,
+    )
+    r.raise_for_status()
+    data = r.json()
+    text = data["choices"][0]["message"]["content"]
+    return {"provider": "openai", "text": text}
+
+def _gen_cohere(prompt: str, max_tokens: int) -> Dict[str, Any]:
+    key = _env("COHERE_API_KEY")
+    model = _env("COHERE_MODEL", "command")
+    if not key: return {"provider": "offline", "text": f"(offline) {prompt[:160]}"}
+    url = "https://api.cohere.ai/v1/generate"
+    r = requests.post(
+        url,
+        headers={
+            "Authorization": f"Bearer {key}",
+            "Content-Type": "application/json",
+            "Cohere-Version": "2022-12-06",
+        },
+        json={"model": model, "prompt": prompt, "max_tokens": max_tokens},
+        timeout=TIMEOUT,
+    )
+    r.raise_for_status()
+    data = r.json()
+    text = data.get("generations", [{}])[0].get("text", "")
+    return {"provider": "cohere", "text": text}
+
+def _gen_deepai(prompt: str, max_tokens: int) -> Dict[str, Any]:
+    key = _env("DEEPAI_API_KEY")
+    if not key: return {"provider": "offline", "text": f"(offline) {prompt[:160]}"}
+    url = "https://api.deepai.org/api/text-generator"
+    r = requests.post(url, headers={"api-key": key}, data={"text": prompt}, timeout=TIMEOUT)
+    r.raise_for_status()
+    data = r.json()
+    return {"provider": "deepai", "text": data.get("output", "")}

anon_bot/handler.py

@@ -0,0 +1,3 @@
+# /anon_bot/handler.py
+
+def handle_turn(m,h,u): return (h or [])+[[m,'hi']]

anon_bot/rules.py

@@ -0,0 +1 @@
+# /anon_bot/rules.py

app/app.py

@@ -0,0 +1,139 @@
+# /app/app.py
+#!/usr/bin/env python3
+# app.py — aiohttp + Bot Framework Echo bot
+
+import os
+import sys
+import json
+from logic import handle_text
+from aiohttp import web
+from botbuilder.core import BotFrameworkAdapter, BotFrameworkAdapterSettings, TurnContext
+from botbuilder.schema import Activity
+import aiohttp_cors
+from pathlib import Path
+
+
+# -------------------------------------------------------------------
+# Your bot implementation
+# -------------------------------------------------------------------
+# Make sure this exists at packages/bots/echo_bot.py
+# from bots.echo_bot import EchoBot
+# Minimal inline fallback if you want to test quickly:
+class EchoBot:
+    async def on_turn(self, turn_context: TurnContext):
+        if turn_context.activity.type == "message":
+            text = (turn_context.activity.text or "").strip()
+            if not text:
+                await turn_context.send_activity("Input was empty. Type 'help' for usage.")
+                return
+
+            lower = text.lower()
+            if lower == "help":
+                await turn_context.send_activity("Try: echo <msg> | reverse: <msg> | capabilities")
+            elif lower == "capabilities":
+                await turn_context.send_activity("- echo\n- reverse\n- help\n- capabilities")
+            elif lower.startswith("reverse:"):
+                payload = text.split(":", 1)[1].strip()
+                await turn_context.send_activity(payload[::-1])
+            elif lower.startswith("echo "):
+                await turn_context.send_activity(text[5:])
+            else:
+                await turn_context.send_activity("Unsupported command. Type 'help' for examples.")
+        else:
+            await turn_context.send_activity(f"[{turn_context.activity.type}] event received.")
+
+# -------------------------------------------------------------------
+# Adapter / bot setup
+# -------------------------------------------------------------------
+APP_ID = os.environ.get("MicrosoftAppId") or None
+APP_PASSWORD = os.environ.get("MicrosoftAppPassword") or None
+
+adapter_settings = BotFrameworkAdapterSettings(APP_ID, APP_PASSWORD)
+adapter = BotFrameworkAdapter(adapter_settings)
+
+async def on_error(context: TurnContext, error: Exception):
+    print(f"[on_turn_error] {error}", file=sys.stderr, flush=True)
+    try:
+        await context.send_activity("Oops. Something went wrong!")
+    except Exception as send_err:
+        print(f"[on_turn_error][send_activity_failed] {send_err}", file=sys.stderr, flush=True)
+
+adapter.on_turn_error = on_error
+bot = EchoBot()
+
+# -------------------------------------------------------------------
+# HTTP handlers
+# -------------------------------------------------------------------
+async def messages(req: web.Request) -> web.Response:
+    # Content-Type can include charset; do a contains check
+    ctype = (req.headers.get("Content-Type") or "").lower()
+    if "application/json" not in ctype:
+        return web.Response(status=415, text="Unsupported Media Type: expected application/json")
+
+    try:
+        body = await req.json()
+    except json.JSONDecodeError:
+        return web.Response(status=400, text="Invalid JSON body")
+
+    activity = Activity().deserialize(body)
+    auth_header = req.headers.get("Authorization")
+
+    invoke_response = await adapter.process_activity(activity, auth_header, bot.on_turn)
+    if invoke_response:
+        # For invoke activities, adapter returns explicit status/body
+        return web.json_response(data=invoke_response.body, status=invoke_response.status)
+    # Acknowledge standard message activities
+    return web.Response(status=202, text="Accepted")
+
+async def home(_req: web.Request) -> web.Response:
+    return web.Response(
+        text="Bot is running. POST Bot Framework activities to /api/messages.",
+        content_type="text/plain"
+    )
+
+async def messages_get(_req: web.Request) -> web.Response:
+    return web.Response(
+        text="This endpoint only accepts POST (Bot Framework activities).",
+        content_type="text/plain",
+        status=405
+    )
+
+async def healthz(_req: web.Request) -> web.Response:
+    return web.json_response({"status": "ok"})
+
+async def plain_chat(req: web.Request) -> web.Response:
+    try:
+        payload = await req.json()
+    except Exception:
+        return web.json_response({"error": "Invalid JSON"}, status=400)
+    user_text = payload.get("text", "")
+    reply = handle_text(user_text)
+    return web.json_response({"reply": reply})
+
+# -------------------------------------------------------------------
+# App factory and entrypoint
+# -------------------------------------------------------------------
+from pathlib import Path
+
+def create_app() -> web.Application:
+    app = web.Application()
+    app.router.add_get("/", home)
+    app.router.add_get("/healthz", healthz)
+    app.router.add_get("/api/messages", messages_get)
+    app.router.add_post("/api/messages", messages)
+    app.router.add_post("/plain-chat", plain_chat)
+
+    static_dir = Path(__file__).parent / "static"
+    if static_dir.exists():
+        app.router.add_static("/static/", path=static_dir, show_index=True)
+    else:
+        print(f"[warn] static directory not found: {static_dir}", flush=True)
+
+    return app
+
+app = create_app()
+
+if __name__ == "__main__":
+    host = os.environ.get("HOST", "127.0.0.1")  # use 0.0.0.0 in containers
+    port = int(os.environ.get("PORT", 3978))
+    web.run_app(app, host=host, port=port)

app/assets/html/agenticcore_frontend.html

@@ -0,0 +1,200 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>AgenticCore Chatbot Frontend</title>
+  <style>
+    :root {
+      --bg: #0b0d12;
+      --panel: #0f172a;
+      --panel-2: #111827;
+      --text: #e5e7eb;
+      --muted: #9ca3af;
+      --accent: #60a5fa;
+      --border: #1f2940;
+      --danger: #ef4444;
+      --success: #22c55e;
+    }
+    * { box-sizing: border-box; }
+    body { margin: 0; font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Arial, sans-serif; background: var(--bg); color: var(--text); }
+    .wrap { max-width: 920px; margin: 32px auto; padding: 0 16px; }
+    header { display: flex; align-items: center; justify-content: space-between; margin-bottom: 16px; gap: 16px; }
+    header h1 { font-size: 18px; margin: 0; letter-spacing: .3px; }
+    header .badge { font-size: 12px; opacity: .85; padding: 4px 8px; border:1px solid var(--border); border-radius: 999px; background: rgba(255,255,255,0.03); }
+    .card { background: var(--panel); border: 1px solid var(--border); border-radius: 16px; padding: 16px; }
+    .row { display: flex; gap: 10px; align-items: center; }
+    .stack { display: grid; gap: 12px; }
+    label { font-size: 12px; color: var(--muted); }
+    input[type=text] { flex: 1; padding: 12px 14px; border-radius: 12px; border: 1px solid var(--border); background: var(--panel-2); color: var(--text); outline: none; }
+    input[type=text]::placeholder { color: #6b7280; }
+    button { padding: 10px 14px; border-radius: 12px; border: 1px solid var(--border); background: #1f2937; color: var(--text); cursor: pointer; transition: transform .02s ease, background .2s; }
+    button:hover { background: #273449; }
+    button:active { transform: translateY(1px); }
+    .btn-primary { background: #1f2937; border-color: #31405a; }
+    .btn-ghost { background: transparent; border-color: var(--border); }
+    .grid { display: grid; gap: 12px; }
+    .grid-2 { grid-template-columns: 1fr 1fr; }
+    .log { margin-top: 16px; display: grid; gap: 10px; }
+    .bubble { max-width: 80%; padding: 12px 14px; border-radius: 14px; line-height: 1.35; }
+    .user { background: #1e293b; border:1px solid #2b3b55; margin-left: auto; border-bottom-right-radius: 4px; }
+    .bot  { background: #0d1b2a; border:1px solid #223049; margin-right: auto; border-bottom-left-radius: 4px; }
+    .meta { font-size: 12px; color: var(--muted); margin-top: 4px; }
+    pre { margin: 0; white-space: pre-wrap; word-break: break-word; }
+    .status { display:flex; align-items:center; gap:8px; font-size: 12px; color: var(--muted); }
+    .dot { width:8px; height:8px; border-radius:999px; background: #64748b; display:inline-block; }
+    .dot.ok { background: var(--success); }
+    .dot.bad { background: var(--danger); }
+    footer { margin: 24px 0; text-align:center; color: var(--muted); font-size: 12px; }
+    .small { font-size: 12px; }
+    @media (max-width: 700px) { .grid-2 { grid-template-columns: 1fr; } }
+  </style>
+</head>
+<body>
+  <div class="wrap">
+    <header>
+      <h1>AgenticCore Chatbot Frontend</h1>
+      <div class="badge">Frontend → FastAPI → providers_unified</div>
+    </header>
+
+    <section class="card stack">
+      <div class="grid grid-2">
+        <div class="stack">
+          <label for="backend">Backend URL</label>
+          <div class="row">
+            <input id="backend" type="text" placeholder="http://127.0.0.1:8000" />
+            <button id="save" class="btn-ghost">Save</button>
+          </div>
+          <div class="status" id="status"><span class="dot"></span><span>Not checked</span></div>
+        </div>
+        <div class="stack">
+          <label for="message">Message</label>
+          <div class="row">
+            <input id="message" type="text" placeholder="Type a message…" />
+            <button id="send" class="btn-primary">Send</button>
+          </div>
+          <div class="row">
+            <button id="cap" class="btn-ghost small">Capabilities</button>
+            <button id="health" class="btn-ghost small">Health</button>
+            <button id="clear" class="btn-ghost small">Clear</button>
+          </div>
+        </div>
+      </div>
+      <div class="log" id="log"></div>
+    </section>
+
+    <footer>
+      Use with your FastAPI backend at <code>/chatbot/message</code>. Configure CORS if you serve this file from a different origin.
+    </footer>
+  </div>
+
+  <script>
+    const $ = (sel) => document.querySelector(sel);
+    const backendInput = $('#backend');
+    const sendBtn = $('#send');
+    const saveBtn = $('#save');
+    const msgInput = $('#message');
+    const capBtn = $('#cap');
+    const healthBtn = $('#health');
+    const clearBtn = $('#clear');
+    const log = $('#log');
+    const status = $('#status');
+    const dot = status.querySelector('.dot');
+    const statusText = status.querySelector('span:last-child');
+
+    function getBackendUrl() {
+      return localStorage.getItem('BACKEND_URL') || 'http://127.0.0.1:8000';
+    }
+    function setBackendUrl(v) {
+      localStorage.setItem('BACKEND_URL', v);
+    }
+    function cardUser(text) {
+      const div = document.createElement('div');
+      div.className = 'bubble user';
+      div.textContent = text;
+      log.appendChild(div);
+      log.scrollTop = log.scrollHeight;
+    }
+    function cardBot(obj) {
+      const wrap = document.createElement('div');
+      wrap.className = 'bubble bot';
+      const pre = document.createElement('pre');
+      pre.textContent = typeof obj === 'string' ? obj : JSON.stringify(obj, null, 2);
+      wrap.appendChild(pre);
+      log.appendChild(wrap);
+      log.scrollTop = log.scrollHeight;
+    }
+    function setStatus(ok, text) {
+      dot.classList.toggle('ok', !!ok);
+      dot.classList.toggle('bad', ok === false);
+      statusText.textContent = text || (ok ? 'OK' : 'Error');
+    }
+    async function api(path, init) {
+      const base = backendInput.value.trim().replace(/\/$/, '');
+      const url = base + path;
+      const resp = await fetch(url, init);
+      if (!resp.ok) {
+        let t = await resp.text().catch(() => '');
+        throw new Error(`HTTP ${resp.status} ${resp.statusText} — ${t}`);
+      }
+      const contentType = resp.headers.get('content-type') || '';
+      if (contentType.includes('application/json')) return resp.json();
+      return resp.text();
+    }
+
+    async function checkHealth() {
+      try {
+        const h = await api('/health', { method: 'GET' });
+        setStatus(true, 'Healthy');
+        cardBot({ health: h });
+      } catch (e) {
+        setStatus(false, String(e.message || e));
+        cardBot({ error: String(e.message || e) });
+      }
+    }
+
+    async function sendMessage() {
+      const text = msgInput.value.trim();
+      if (!text) return;
+      cardUser(text);
+      msgInput.value = '';
+      try {
+        const data = await api('/chatbot/message', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ message: text })
+        });
+        cardBot(data);
+      } catch (e) {
+        cardBot({ error: String(e.message || e) });
+      }
+    }
+
+    async function showCapabilities() {
+      try {
+        // Prefer API if available; if 404, fall back to library-like prompt.
+        const data = await api('/chatbot/message', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ message: 'help' })
+        });
+        cardBot(data);
+      } catch (e) {
+        cardBot({ capabilities: ['text-input','sentiment-analysis','help'], note: 'API help failed, showing defaults', error: String(e.message || e) });
+      }
+    }
+
+    // Wire up
+    backendInput.value = getBackendUrl();
+    saveBtn.onclick = () => { setBackendUrl(backendInput.value.trim()); setStatus(null, 'Saved'); };
+    sendBtn.onclick = sendMessage;
+    msgInput.addEventListener('keydown', (ev) => { if (ev.key === 'Enter') sendMessage(); });
+    capBtn.onclick = showCapabilities;
+    healthBtn.onclick = checkHealth;
+    clearBtn.onclick = () => { log.innerHTML = ''; setStatus(null, 'Idle'); };
+
+    // Initial health ping
+    checkHealth();
+  </script>
+</body>
+</html>

app/assets/html/chat.html

@@ -0,0 +1,56 @@
+<!doctype html>
+<html><head><meta charset="utf-8"/><title>Simple Chat</title>
+<meta name="viewport" content="width=device-width,initial-scale=1"/>
+<style>
+:root { --bg:#f6f7f9; --card:#fff; --me:#dff1ff; --bot:#ffffff; --text:#23262b; --muted:#8a9099; }
+body { margin:0; font-family:system-ui,-apple-system,Segoe UI,Roboto,Arial,sans-serif; background:var(--bg); color:var(--text); }
+.app { max-width:840px; margin:24px auto; padding:0 16px; }
+.card { background:var(--card); border:1px solid #e3e6ea; border-radius:14px; box-shadow:0 1px 2px rgba(0,0,0,.04); overflow:hidden; }
+.header { padding:14px 16px; border-bottom:1px solid #e9edf2; font-weight:600; }
+.chat { height:480px; overflow:auto; padding:16px; display:flex; flex-direction:column; gap:12px; }
+.row { display:flex; }
+.row.me { justify-content:flex-end; }
+.bubble { max-width:70%; padding:10px 12px; border-radius:12px; line-height:1.35; white-space:pre-wrap; }
+.me .bubble { background:var(--me); border:1px solid #c3e5ff; }
+.bot .bubble { background:var(--bot); border:1px solid #e5e8ec; }
+.footer { display:flex; gap:8px; padding:12px; border-top:1px solid #e9edf2; }
+input[type=text] { flex:1; padding:10px 12px; border-radius:10px; border:1px solid #d5dbe3; font-size:15px; }
+button { padding:10px 14px; border-radius:10px; border:1px solid #2b6cb0; background:#2b6cb0; color:#fff; font-weight:600; cursor:pointer; }
+button:disabled { opacity:.6; cursor:not-allowed; }
+.hint { color:var(--muted); font-size:12px; padding:0 16px 12px; }
+</style></head>
+<body>
+<div class="app"><div class="card">
+  <div class="header">Traditional Chatbot (Local)</div>
+  <div id="chat" class="chat"></div>
+  <div class="hint">Try: <code>reverse: hello world</code>, <code>help</code>, <code>capabilities</code></div>
+  <div class="footer">
+    <input id="msg" type="text" placeholder="Type a message..." autofocus />
+    <button id="send">Send</button>
+  </div>
+</div></div>
+<script>
+const API = "http://127.0.0.1:3978/plain-chat";
+const chat = document.getElementById("chat");
+const input = document.getElementById("msg");
+const sendBtn = document.getElementById("send");
+function addBubble(text, who) {
+  const row = document.createElement("div"); row.className = "row " + who;
+  const wrap = document.createElement("div"); wrap.className = who === "me" ? "me" : "bot";
+  const b = document.createElement("div"); b.className = "bubble"; b.textContent = text;
+  wrap.appendChild(b); row.appendChild(wrap); chat.appendChild(row); chat.scrollTop = chat.scrollHeight;
+}
+async function send() {
+  const text = input.value.trim(); if (!text) return; input.value = ""; addBubble(text, "me"); sendBtn.disabled = true;
+  try {
+    const res = await fetch(API, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ text }) });
+    if (!res.ok) throw new Error("HTTP " + res.status);
+    const data = await res.json(); addBubble(data.reply ?? "(no reply)", "bot");
+  } catch (err) { addBubble("Error: " + err.message, "bot"); }
+  finally { sendBtn.disabled = false; input.focus(); }
+}
+sendBtn.addEventListener("click", send);
+input.addEventListener("keydown", (e)=>{ if (e.key === "Enter") send(); });
+addBubble("Connected to local bot at /plain-chat", "bot");
+</script>
+</body></html>

app/assets/html/chat_console.html

@@ -0,0 +1,77 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>Console Chat Tester</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <style>
+    body{ font-family: ui-sans-serif, system-ui, Arial; margin:20px; }
+    .row{ display:flex; gap:8px; align-items:center; margin:6px 0; }
+    input[type=text]{ flex:1; padding:8px; }
+    button{ padding:8px 10px; }
+    pre{ background:#0b1020; color:#d6e7ff; padding:10px; height:320px; overflow:auto; }
+    .chip{ display:inline-block; padding:3px 8px; background:#eef; border-radius:12px; margin-left:8px; }
+  </style>
+</head>
+<body>
+<h2>AgenticCore Console</h2>
+
+<div class="row">
+  <label>Backend</label>
+  <input id="base" type="text" value="http://127.0.0.1:8000" />
+  <button id="btnHealth">Health</button>
+  <button id="btnRoutes">Routes</button>
+</div>
+
+<div class="row">
+  <input id="msg" type="text" placeholder="Say something…" />
+  <button id="btnSend">POST /chatbot/message</button>
+</div>
+
+<div>
+  <span>Mode:</span>
+  <span id="mode" class="chip">API</span>
+</div>
+
+<pre id="out"></pre>
+
+<script>
+const $ = id => document.getElementById(id);
+const out = $("out");
+function print(o){ out.textContent += (typeof o==="string" ? o : JSON.stringify(o,null,2)) + "\n"; out.scrollTop = out.scrollHeight; }
+function join(b, p){ return b.replace(/\/+$/,"") + p; }
+
+async function health(){
+  try{
+    const r = await fetch(join($("base").value, "/health"));
+    print(await r.json());
+  }catch(e){ print("health error: " + e); }
+}
+async function routes(){
+  try{
+    const r = await fetch(join($("base").value, "/openapi.json"));
+    const j = await r.json();
+    print({ routes: Object.keys(j.paths) });
+  }catch(e){ print("routes error: " + e); }
+}
+async function send(){
+  const text = $("msg").value.trim();
+  if(!text){ print("enter a message first"); return; }
+  try{
+    const r = await fetch(join($("base").value, "/chatbot/message"), {
+      method:"POST",
+      headers:{ "Content-Type":"application/json" },
+      body: JSON.stringify({ message: text })
+    });
+    print(await r.json());
+  }catch(e){ print("send error: " + e); }
+}
+$("btnHealth").onclick = health;
+$("btnRoutes").onclick = routes;
+$("btnSend").onclick = send;
+
+// boot
+health();
+</script>
+</body>
+</html>

app/assets/html/chat_minimal.html

@@ -0,0 +1,89 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>Minimal Chat Tester</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <style>
+    body { font-family: system-ui, Arial, sans-serif; margin: 24px; }
+    .row { display:flex; gap:8px; align-items:center; margin-bottom:8px; }
+    input[type=text]{ width:420px; padding:8px; }
+    textarea{ width:100%; height:240px; padding:8px; }
+    button{ padding:8px 12px; }
+    .ok{ color:#1a7f37; }
+    .warn{ color:#b54708; }
+    .err{ color:#b42318; }
+  </style>
+</head>
+<body>
+<h2>Minimal Chat Tester → FastAPI /chatbot/message</h2>
+
+<div class="row">
+  <label>Backend URL:</label>
+  <input id="base" type="text" value="http://127.0.0.1:8000" />
+  <button id="btnHealth">Health</button>
+  <button id="btnCaps">Capabilities</button>
+</div>
+
+<div class="row">
+  <input id="msg" type="text" placeholder="Type a message…" />
+  <button id="btnSend">Send</button>
+</div>
+
+<p id="status"></p>
+<textarea id="log" readonly></textarea>
+
+<script>
+const $ = id => document.getElementById(id);
+const log = (o, cls="") => {
+  const line = (typeof o === "string") ? o : JSON.stringify(o, null, 2);
+  $("log").value += line + "\n";
+  $("log").scrollTop = $("log").scrollHeight;
+  if(cls) { $("status").className = cls; $("status").textContent = line; }
+};
+
+function urlJoin(base, path) {
+  return base.replace(/\/+$/,"") + path;
+}
+
+async function health() {
+  try {
+    const r = await fetch(urlJoin($("base").value, "/health"));
+    const j = await r.json();
+    log(j, "ok");
+  } catch (e) { log("Health error: " + e, "err"); }
+}
+
+async function caps() {
+  try {
+    // Prefer library-like caps endpoint if you expose one; otherwise call /openapi.json for visibility
+    const r = await fetch(urlJoin($("base").value, "/openapi.json"));
+    const j = await r.json();
+    log({paths: Object.keys(j.paths).slice(0,20)}, "ok");
+  } catch (e) { log("Caps error: " + e, "err"); }
+}
+
+async function sendMsg() {
+  const text = $("msg").value.trim();
+  if(!text) { log("Please type a message.", "warn"); return; }
+  try {
+    const r = await fetch(urlJoin($("base").value, "/chatbot/message"), {
+      method:"POST",
+      headers:{ "Content-Type":"application/json" },
+      body: JSON.stringify({ message: text })
+    });
+    if(!r.ok) throw new Error(`${r.status} ${r.statusText}`);
+    const j = await r.json();
+    log(j, "ok");
+  } catch (e) { log("Send error: " + e, "err"); }
+}
+
+$("btnHealth").onclick = health;
+$("btnCaps").onclick = caps;
+$("btnSend").onclick = sendMsg;
+
+// Warmup
+health();
+</script>
+</body>
+</html>

app/routes.py

@@ -0,0 +1 @@
+# /app/routes.py

core/config.py

@@ -0,0 +1,4 @@
+# /core/config.py
+
+class Settings: pass
+settings = Settings()

core/logging.py

@@ -0,0 +1 @@
+# /core/logging.py

core/types.py

@@ -0,0 +1 @@
+# /core/types.py

docs/DEV_DOC.md

@@ -0,0 +1,97 @@
+## 3. Functional Requirements
+
+This section describes the functional requirements for connecting a chatbot to an AI-as-a-Service (AIaaS) platform. It defines the expected system behavior, outlines constraints, and sets measurable acceptance criteria. Requirements are grouped into system context, core functions, supporting functions, and non-functional aspects.
+
+---
+
+### 3.1 System Context
+
+The chatbot acts as the client application. It receives user input, processes it, and communicates with an external AIaaS endpoint (e.g., Azure AI Language Service). The AI service provides natural language processing (NLP) features such as sentiment analysis. The chatbot then interprets the service output and responds back to the user.
+
+Key components include:
+- **User Interface (UI):** Chat interface for entering text.
+- **Chatbot Core:** Handles request routing and conversation logic.
+- **AI Service Connector:** Manages authentication and API calls to the AI service.
+- **AIaaS Platform:** External cloud service providing NLP functions.
+
+---
+
+### 3.2 Functional Requirements
+
+#### FR-1: User Input Handling
+- The chatbot shall accept text input from users.
+- The chatbot shall sanitize input to remove unsafe characters.
+- The chatbot shall log all interactions for debugging and testing.
+
+#### FR-2: API Connection
+- The system shall authenticate with the AI service using API keys stored securely in environment variables.
+- The chatbot shall send user text to the AIaaS endpoint in the required format.
+- The chatbot shall handle and parse responses from the AIaaS.
+
+#### FR-3: Sentiment Analysis Integration
+- The chatbot shall use the AIaaS to determine the sentiment (e.g., positive, neutral, negative) of user input.
+- The chatbot shall present sentiment results as part of its response or use them to adjust tone.
+
+#### FR-4: Error and Exception Handling
+- The system shall detect failed API calls and return a fallback message to the user.
+- The chatbot shall notify the user if the AI service is unavailable.
+- The chatbot shall log errors with timestamp and cause.
+
+#### FR-5: Reporting and Documentation
+- The chatbot shall provide a list of supported commands or features when prompted.
+- The chatbot shall record system status and output for inclusion in the project report.
+- The development process shall be documented with screenshots and configuration notes.
+
+---
+
+### 3.3 Non-Functional Requirements
+
+#### NFR-1: Security
+- API keys shall not be hard-coded in source files.
+- Sensitive data shall be retrieved from environment variables or secure vaults.
+
+#### NFR-2: Performance
+- The chatbot shall return responses within 2 seconds under normal network conditions.
+- The system shall process at least 20 concurrent user sessions without performance degradation.
+
+#### NFR-3: Reliability
+- The chatbot shall achieve at least 95% uptime during testing.
+- The chatbot shall gracefully degrade to local responses if the AI service is unavailable.
+
+#### NFR-4: Usability
+- The chatbot shall provide clear, user-friendly error messages.
+- The chatbot shall handle malformed input without crashing.
+
+---
+
+### 3.4 Acceptance Criteria
+
+1. **Input Handling**
+   - Given valid text input, the chatbot processes it without errors.
+   - Given invalid or malformed input, the chatbot responds with a clarification request.
+
+2. **API Connection**
+   - Given a valid API key and endpoint, the chatbot connects and retrieves sentiment analysis.
+   - Given an invalid API key, the chatbot logs an error and informs the user.
+
+3. **Sentiment Analysis**
+   - Given a positive statement, the chatbot labels it correctly with at least 90% accuracy.
+   - Given a negative statement, the chatbot labels it correctly with at least 90% accuracy.
+
+4. **Error Handling**
+   - When the AI service is unavailable, the chatbot informs the user and continues functioning with local responses.
+   - All failures are recorded in a log file.
+
+5. **Usability**
+   - The chatbot returns responses in less than 2 seconds for 95% of requests.
+   - The chatbot displays a list of features when the user requests “help.”
+
+---
+
+### Glossary
+
+- **AIaaS (AI-as-a-Service):** Cloud-based artificial intelligence services accessible via APIs.
+- **API (Application Programming Interface):** A set of rules for software applications to communicate with each other.
+- **NLP (Natural Language Processing):** A field of AI focused on enabling computers to understand human language.
+- **Sentiment Analysis:** An NLP technique that determines the emotional tone behind a text.
+

docs/architecture.md

@@ -0,0 +1,2 @@
+# /docs/slides/architecture.md
+# Architecture\n\nShort explainer tied to the flowchart.\n

docs/design.md

@@ -0,0 +1,2 @@
+# /docs/slides/design.md
+# Design notes\n\nAPI notes, security, tradeoffs.\n

docs/results.md

@@ -0,0 +1,2 @@
+# /docs/slides/design.md
+# Results\n\nChallenges, metrics, screenshots.\n

examples/example.py

@@ -0,0 +1,9 @@
+# /example/example.py
+"""Simple CLI example that sends a message to the ChatBot and prints the JSON reply."""
+import json
+from agenticcore.chatbot.services import ChatBot
+
+if __name__ == "__main__":
+    bot = ChatBot()
+    result = bot.reply("hello world")
+    print(json.dumps(result, indent=2))

guardrails/pii_redaction.py

@@ -0,0 +1,3 @@
+# /guardrails/pii_redaction.py
+
+def redact(t): return t

guardrails/safety.py

@@ -0,0 +1 @@
+# /guardrails/safety.py

integrations/azure/bot_framework.py

@@ -0,0 +1,2 @@
+# /intergrations/azure/bot_framework.py
+# Azure Bot Framework (placeholder)

integrations/botframework/app.py

@@ -0,0 +1,138 @@
+# /intergrations/botframework/app.py — aiohttp + Bot Framework Echo bot
+#!/usr/bin/env python3
+
+import os
+import sys
+import json
+from logic import handle_text
+from aiohttp import web
+from botbuilder.core import BotFrameworkAdapter, BotFrameworkAdapterSettings, TurnContext
+from botbuilder.schema import Activity
+import aiohttp_cors
+from pathlib import Path
+
+
+# -------------------------------------------------------------------
+# Your bot implementation
+# -------------------------------------------------------------------
+# Make sure this exists at packages/bots/echo_bot.py
+# from bots.echo_bot import EchoBot
+# Minimal inline fallback if you want to test quickly:
+class EchoBot:
+    async def on_turn(self, turn_context: TurnContext):
+        if turn_context.activity.type == "message":
+            text = (turn_context.activity.text or "").strip()
+            if not text:
+                await turn_context.send_activity("Input was empty. Type 'help' for usage.")
+                return
+
+            lower = text.lower()
+            if lower == "help":
+                await turn_context.send_activity("Try: echo <msg> | reverse: <msg> | capabilities")
+            elif lower == "capabilities":
+                await turn_context.send_activity("- echo\n- reverse\n- help\n- capabilities")
+            elif lower.startswith("reverse:"):
+                payload = text.split(":", 1)[1].strip()
+                await turn_context.send_activity(payload[::-1])
+            elif lower.startswith("echo "):
+                await turn_context.send_activity(text[5:])
+            else:
+                await turn_context.send_activity("Unsupported command. Type 'help' for examples.")
+        else:
+            await turn_context.send_activity(f"[{turn_context.activity.type}] event received.")
+
+# -------------------------------------------------------------------
+# Adapter / bot setup
+# -------------------------------------------------------------------
+APP_ID = os.environ.get("MicrosoftAppId") or None
+APP_PASSWORD = os.environ.get("MicrosoftAppPassword") or None
+
+adapter_settings = BotFrameworkAdapterSettings(APP_ID, APP_PASSWORD)
+adapter = BotFrameworkAdapter(adapter_settings)
+
+async def on_error(context: TurnContext, error: Exception):
+    print(f"[on_turn_error] {error}", file=sys.stderr, flush=True)
+    try:
+        await context.send_activity("Oops. Something went wrong!")
+    except Exception as send_err:
+        print(f"[on_turn_error][send_activity_failed] {send_err}", file=sys.stderr, flush=True)
+
+adapter.on_turn_error = on_error
+bot = EchoBot()
+
+# -------------------------------------------------------------------
+# HTTP handlers
+# -------------------------------------------------------------------
+async def messages(req: web.Request) -> web.Response:
+    # Content-Type can include charset; do a contains check
+    ctype = (req.headers.get("Content-Type") or "").lower()
+    if "application/json" not in ctype:
+        return web.Response(status=415, text="Unsupported Media Type: expected application/json")
+
+    try:
+        body = await req.json()
+    except json.JSONDecodeError:
+        return web.Response(status=400, text="Invalid JSON body")
+
+    activity = Activity().deserialize(body)
+    auth_header = req.headers.get("Authorization")
+
+    invoke_response = await adapter.process_activity(activity, auth_header, bot.on_turn)
+    if invoke_response:
+        # For invoke activities, adapter returns explicit status/body
+        return web.json_response(data=invoke_response.body, status=invoke_response.status)
+    # Acknowledge standard message activities
+    return web.Response(status=202, text="Accepted")
+
+async def home(_req: web.Request) -> web.Response:
+    return web.Response(
+        text="Bot is running. POST Bot Framework activities to /api/messages.",
+        content_type="text/plain"
+    )
+
+async def messages_get(_req: web.Request) -> web.Response:
+    return web.Response(
+        text="This endpoint only accepts POST (Bot Framework activities).",
+        content_type="text/plain",
+        status=405
+    )
+
+async def healthz(_req: web.Request) -> web.Response:
+    return web.json_response({"status": "ok"})
+
+async def plain_chat(req: web.Request) -> web.Response:
+    try:
+        payload = await req.json()
+    except Exception:
+        return web.json_response({"error": "Invalid JSON"}, status=400)
+    user_text = payload.get("text", "")
+    reply = handle_text(user_text)
+    return web.json_response({"reply": reply})
+
+# -------------------------------------------------------------------
+# App factory and entrypoint
+# -------------------------------------------------------------------
+from pathlib import Path
+
+def create_app() -> web.Application:
+    app = web.Application()
+    app.router.add_get("/", home)
+    app.router.add_get("/healthz", healthz)
+    app.router.add_get("/api/messages", messages_get)
+    app.router.add_post("/api/messages", messages)
+    app.router.add_post("/plain-chat", plain_chat)
+
+    static_dir = Path(__file__).parent / "static"
+    if static_dir.exists():
+        app.router.add_static("/static/", path=static_dir, show_index=True)
+    else:
+        print(f"[warn] static directory not found: {static_dir}", flush=True)
+
+    return app
+
+app = create_app()
+
+if __name__ == "__main__":
+    host = os.environ.get("HOST", "127.0.0.1")  # use 0.0.0.0 in containers
+    port = int(os.environ.get("PORT", 3978))
+    web.run_app(app, host=host, port=port)

integrations/botframework/bot.py

@@ -0,0 +1,86 @@
+# /intergrations/botframework/bot.py
+"""
+Simple MBF bot:
+- 'help' / 'capabilities' shows features
+- 'reverse <text>' returns reversed text
+- otherwise delegates to AgenticCore ChatBot (sentiment) if available
+"""
+
+from typing import List, Optional, Dict, Any
+from botbuilder.core import ActivityHandler, TurnContext
+from botbuilder.schema import ChannelAccount, ActivityTypes
+
+from skills import normalize, reverse_text, capabilities, is_empty
+
+# Try to import AgenticCore; if unavailable, provide a tiny fallback.
+try:
+    from agenticcore.chatbot.services import ChatBot  # real provider-backed bot
+except Exception:
+    class ChatBot:  # fallback shim for offline/dev
+        def reply(self, message: str) -> Dict[str, Any]:
+            return {
+                "reply": "Noted. (local fallback reply)",
+                "sentiment": "neutral",
+                "confidence": 0.5,
+            }
+
+def _format_sentiment(res: Dict[str, Any]) -> str:
+    """Compose a user-facing string from ChatBot reply payload."""
+    reply = (res.get("reply") or "").strip()
+    label: Optional[str] = res.get("sentiment")
+    conf = res.get("confidence")
+    if label is not None and conf is not None:
+        return f"{reply} (sentiment: {label}, confidence: {float(conf):.2f})"
+    return reply or "I'm not sure what to say."
+
+def _help_text() -> str:
+    """Single source of truth for the help/capability text."""
+    feats = "\n".join(f"- {c}" for c in capabilities())
+    return (
+        "I can reverse text and provide concise replies with sentiment.\n"
+        "Commands:\n"
+        "- help | capabilities\n"
+        "- reverse <text>\n"
+        "General text will be handled by the ChatBot service.\n\n"
+        f"My capabilities:\n{feats}"
+    )
+
+class SimpleBot(ActivityHandler):
+    """Minimal ActivityHandler with local commands + ChatBot fallback."""
+
+    def __init__(self, chatbot: Optional[ChatBot] = None):
+        self._chatbot = chatbot or ChatBot()
+
+    async def on_members_added_activity(
+        self, members_added: List[ChannelAccount], turn_context: TurnContext
+    ):
+        for member in members_added:
+            if member.id != turn_context.activity.recipient.id:
+                await turn_context.send_activity("Hello! Type 'help' to see what I can do.")
+
+    async def on_message_activity(self, turn_context: TurnContext):
+        if turn_context.activity.type != ActivityTypes.message:
+            return
+
+        text = (turn_context.activity.text or "").strip()
+        if is_empty(text):
+            await turn_context.send_activity("Please enter a message (try 'help').")
+            return
+
+        cmd = normalize(text)
+
+        if cmd in {"help", "capabilities"}:
+            await turn_context.send_activity(_help_text())
+            return
+
+        if cmd.startswith("reverse "):
+            original = text.split(" ", 1)[1] if " " in text else ""
+            await turn_context.send_activity(reverse_text(original))
+            return
+
+        # ChatBot fallback (provider-agnostic sentiment/reply)
+        try:
+            result = self._chatbot.reply(text)
+            await turn_context.send_activity(_format_sentiment(result))
+        except Exception:
+            await turn_context.send_activity(f"You said: {text}")

integrations/botframework/bots/echo_bot.py

@@ -0,0 +1,57 @@
+# bots/echo_bot.py
+from botbuilder.core import ActivityHandler, TurnContext
+from botbuilder.schema import ChannelAccount
+
+def simple_sentiment(text: str):
+    """
+    Tiny, no-cost heuristic so you can demo behavior without extra services.
+    You can swap this later for HF/OpenAI/Azure easily.
+    """
+    t = (text or "").lower()
+    pos = any(w in t for w in ["love","great","good","awesome","fantastic","excellent","amazing"])
+    neg = any(w in t for w in ["hate","bad","terrible","awful","worst","horrible","angry"])
+    if pos and not neg:  return "positive", 0.9
+    if neg and not pos:  return "negative", 0.9
+    return "neutral", 0.5
+
+CAPS = [
+    "Echo what you say (baseline).",
+    "Show my capabilities with 'help' or 'capabilities'.",
+    "Handle malformed/empty input politely.",
+    "Classify simple sentiment (positive/negative/neutral).",
+]
+
+class EchoBot(ActivityHandler):
+    async def on_members_added_activity(
+        self, members_added: [ChannelAccount], turn_context: TurnContext
+    ):
+        for member in members_added:
+            if member.id != turn_context.activity.recipient.id:
+                await turn_context.send_activity(
+                    "Hi! I’m your sample bot.\n"
+                    "- Try typing: **help**\n"
+                    "- Or any sentence and I’ll echo it + sentiment."
+                )
+
+    async def on_message_activity(self, turn_context: TurnContext):
+        text = (turn_context.activity.text or "").strip()
+
+        # Handle empty/malformed
+        if not text:
+            await turn_context.send_activity(
+                "I didn’t catch anything. Please type a message (or 'help')."
+            )
+            return
+
+        # Capabilities
+        if text.lower() in {"help","capabilities","what can you do"}:
+            caps = "\n".join(f"• {c}" for c in CAPS)
+            await turn_context.send_activity(
+                "Here’s what I can do:\n" + caps
+            )
+            return
+
+        # Normal message → echo + sentiment
+        label, score = simple_sentiment(text)
+        reply = f"You said: **{text}**\nSentiment: **{label}** (conf {score:.2f})"
+        await turn_context.send_activity(reply)

integrations/email/ticket_stub.py

@@ -0,0 +1,2 @@
+# /intergrations/email/ticket_stub.py
+# Email ticket stub (placeholder)

integrations/web/fastapi/web_agentic.py

@@ -0,0 +1,22 @@
+# /integrations/web/fastapi/web_agentic.py
+from fastapi import FastAPI, Query
+from fastapi.responses import HTMLResponse
+from agenticcore.chatbot.services import ChatBot
+
+app = FastAPI(title="AgenticCore Web UI")
+
+# 1. Simple HTML form at /
+@app.get("/", response_class=HTMLResponse)
+def index():
+    return """
+    <form action="/agentic" method="get">
+        <input type="text" name="msg" placeholder="Type a message" style="width:300px">
+        <input type="submit" value="Send">
+    </form>
+    """
+
+# 2. Agentic endpoint
+@app.get("/agentic")
+def run_agentic(msg: str = Query(..., description="Message to send to ChatBot")):
+    bot = ChatBot()
+    return bot.reply(msg)

logged_in_bot/handler.py

@@ -0,0 +1,20 @@
+# /logged_in_bot/handler.py
+
+from agenticcore.chatbot.services import ChatBot
+
+_bot = ChatBot()
+
+def handle_turn(message, history, user):
+    history = history or []
+    try:
+        res = _bot.reply(message)
+        reply = res.get("reply") or "Noted."
+        label = res.get("sentiment")
+        conf = res.get("confidence")
+        if label is not None and conf is not None:
+            reply = f"{reply} (sentiment: {label}, confidence: {float(conf):.2f})"
+    except Exception as e:
+        reply = f"Sorry—error in ChatBot: {type(e).__name__}. Using fallback."
+    history = history + [[message, reply]]
+    return history
+

logged_in_bot/sentiment_azure.py

@@ -0,0 +1 @@
+# /logged_in_bot/sentiment_azure.py

logged_in_bot/tools.py

@@ -0,0 +1 @@
+# /logged_in_bot/tools.py

memory/rag/indexer.py

@@ -0,0 +1 @@
+# /memory/rag/data/indexer.py

memory/rag/retriever.py

@@ -0,0 +1 @@
+# /memory/rag/data/retriever.py

memory/sessions.py

@@ -0,0 +1 @@
+# /memory/sessions.py

memory/store.py

@@ -0,0 +1,3 @@
+# /memory/sessions.py
+
+DB={}

nlu/pipeline.py

@@ -0,0 +1,3 @@
+# /nlu/pipeline.py
+
+def analyze(t): return {'intent':'general'}

nlu/prompts.py

@@ -0,0 +1 @@
+# /nlu/prompts.py

nlu/router.py

@@ -0,0 +1 @@
+# /nlu/router.py

notebooks/ChatbotIntegration.ipynb

@@ -0,0 +1,559 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3c5453da-9714-4410-af12-2727730020bc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'reply': 'Noted. The sentiment appears neutral.', 'sentiment': 'neutral', 'confidence': 0.5}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from agenticcore.chatbot.services import ChatBot\n",
+    "bot = ChatBot()\n",
+    "print(bot.reply(\"Testing from notebook\"))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d467914-f9b5-43bb-b66e-fc7f1db12b21",
+   "metadata": {},
+   "source": [
+    "# 2) Config: choose backend URL and provider (HF/Azure/etc.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "240d2787-aacd-49ec-bfe9-709108e49df0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'http://127.0.0.1:8000'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
+    "# Point to your FastAPI server (change if needed)\n",
+    "import os\n",
+    "\n",
+    "# Default backend URL (can be overridden later via the widget)\n",
+    "BACKEND_URL = os.environ.get(\"BACKEND_URL\", \"http://127.0.0.1:8000\")\n",
+    "\n",
+    "# Provider hint (optional; providers_unified auto-detects if keys exist)\n",
+    "# Examples:\n",
+    "# os.environ[\"AI_PROVIDER\"] = \"hf\"\n",
+    "# os.environ[\"HF_API_KEY\"] = \"hf_XXXXXXXX...\"   # if using Hugging Face\n",
+    "# os.environ[\"MICROSOFT_AI_SERVICE_ENDPOINT\"] = \"https://<name>.cognitiveservices.azure.com/\"\n",
+    "# os.environ[\"MICROSOFT_AI_API_KEY\"] = \"<your-azure-key>\"\n",
+    "\n",
+    "BACKEND_URL\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bde64f5a-dd29-414e-9116-498ee972e759",
+   "metadata": {},
+   "source": [
+    "# 3) Helper functions (API + Library paths)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8d50f328-567b-454f-8090-87c045674338",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import json\n",
+    "import requests\n",
+    "from typing import Dict, Any\n",
+    "\n",
+    "# Default backend URL\n",
+    "BACKEND_URL = os.environ.get(\"BACKEND_URL\", \"http://127.0.0.1:8000\")\n",
+    "\n",
+    "def send_via_api(message: str, url: str = BACKEND_URL) -> Dict[str, Any]:\n",
+    "    \"\"\"POST to FastAPI /chatbot/message. Returns dict with reply/sentiment/confidence.\"\"\"\n",
+    "    u = url.rstrip(\"/\") + \"/chatbot/message\"\n",
+    "    r = requests.post(u, json={\"message\": message}, timeout=20)\n",
+    "    r.raise_for_status()\n",
+    "    return r.json()\n",
+    "\n",
+    "def send_via_library(message: str) -> Dict[str, Any]:\n",
+    "    \"\"\"Call ChatBot() directly inside this kernel.\"\"\"\n",
+    "    from agenticcore.chatbot.services import ChatBot\n",
+    "    return ChatBot().reply(message)\n",
+    "\n",
+    "def health(url: str = BACKEND_URL) -> Dict[str, Any]:\n",
+    "    r = requests.get(url.rstrip(\"/\") + \"/health\", timeout=10)\n",
+    "    r.raise_for_status()\n",
+    "    return r.json()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f247c509-abd4-44de-9b49-20402d54a296",
+   "metadata": {},
+   "source": [
+    "# 4) Minimal UI (ipywidgets)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3f1258d0-5616-4c5a-b19e-e4ffa040e9cb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d5e531363757461cbb9225d4afdd5ea9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(ToggleButtons(description='Route:', options=(('API', 'api'), ('Library', 'lib')), value='api'),…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b7e695b92e094e3094099e4f54c5852d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(Text(value='', description='You:', layout=Layout(width='60%'), placeholder='Type a message…'), …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4d1b73dbb842416bb085ba3237e6c69c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "<div style=\"margin-top:8px;opacity:.8\">\n",
+       "  Tip: API path requires your FastAPI server running at /chatbot/message.\n",
+       "  Switch to <b>Library</b> mode for offline tests.\n",
+       "</div>\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import ipywidgets as W\n",
+    "from IPython.display import display, HTML, clear_output\n",
+    "\n",
+    "mode = W.ToggleButtons(\n",
+    "    options=[(\"API\", \"api\"), (\"Library\", \"lib\")],\n",
+    "    value=\"api\",\n",
+    "    description=\"Route:\",\n",
+    ")\n",
+    "backend = W.Text(value=BACKEND_URL, placeholder=\"http://127.0.0.1:8000\", description=\"Backend:\", layout=W.Layout(width=\"60%\"))\n",
+    "save_btn = W.Button(description=\"Save\", button_style=\"info\")\n",
+    "msg = W.Text(placeholder=\"Type a message…\", description=\"You:\", layout=W.Layout(width=\"60%\"))\n",
+    "send_btn = W.Button(description=\"Send\", button_style=\"primary\")\n",
+    "cap_btn = W.Button(description=\"Capabilities\", tooltip=\"Show ChatBot capabilities\")\n",
+    "out = W.Output()\n",
+    "\n",
+    "def on_save(_):\n",
+    "    os.environ[\"BACKEND_URL\"] = backend.value.strip()\n",
+    "    with out:\n",
+    "        print(f\"[config] BACKEND_URL = {os.environ['BACKEND_URL']}\")\n",
+    "\n",
+    "def on_send(_):\n",
+    "    text = msg.value.strip()\n",
+    "    if not text:\n",
+    "        with out:\n",
+    "            print(\"[warn] Please enter some text.\")\n",
+    "        return\n",
+    "    try:\n",
+    "        if mode.value == \"api\":\n",
+    "            data = send_via_api(text, backend.value.strip())\n",
+    "        else:\n",
+    "            data = send_via_library(text)\n",
+    "        with out:\n",
+    "            print(json.dumps(data, indent=2, ensure_ascii=False))\n",
+    "    except Exception as e:\n",
+    "        with out:\n",
+    "            print(f\"[error] {e}\")\n",
+    "\n",
+    "def on_caps(_):\n",
+    "    try:\n",
+    "        # Prefer library capabilities; keeps working even if API is down\n",
+    "        from agenticcore.chatbot.services import ChatBot\n",
+    "        data = ChatBot().capabilities()\n",
+    "        with out:\n",
+    "            print(json.dumps({\"capabilities\": data}, indent=2))\n",
+    "    except Exception as e:\n",
+    "        with out:\n",
+    "            print(f\"[error capabilities] {e}\")\n",
+    "\n",
+    "save_btn.on_click(on_save)\n",
+    "send_btn.on_click(on_send)\n",
+    "cap_btn.on_click(on_caps)\n",
+    "\n",
+    "display(W.HBox([mode, backend, save_btn]))\n",
+    "display(W.HBox([msg, send_btn, cap_btn]))\n",
+    "display(out)\n",
+    "\n",
+    "# Optional visual hint\n",
+    "display(HTML(\"\"\"\n",
+    "<div style=\"margin-top:8px;opacity:.8\">\n",
+    "  Tip: API path requires your FastAPI server running at /chatbot/message.\n",
+    "  Switch to <b>Library</b> mode for offline tests.\n",
+    "</div>\n",
+    "\"\"\"))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7aaf5b2a-2a30-42a5-ae77-d851c62feccb",
+   "metadata": {},
+   "source": [
+    "# 5) Batch test cell (multi-prompt, tabular)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f1d5da55-08ff-4433-aea9-a3ccde34de5c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>message</th>\n",
+       "      <th>reply</th>\n",
+       "      <th>sentiment</th>\n",
+       "      <th>confidence</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>I absolutely love this project!</td>\n",
+       "      <td>(error) 404 Client Error: Not Found for url: h...</td>\n",
+       "      <td>None</td>\n",
+       "      <td>None</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>This is awful and broken.</td>\n",
+       "      <td>(error) 404 Client Error: Not Found for url: h...</td>\n",
+       "      <td>None</td>\n",
+       "      <td>None</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Can you list your capabilities?</td>\n",
+       "      <td>(error) 404 Client Error: Not Found for url: h...</td>\n",
+       "      <td>None</td>\n",
+       "      <td>None</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td></td>\n",
+       "      <td>(error) 404 Client Error: Not Found for url: h...</td>\n",
+       "      <td>None</td>\n",
+       "      <td>None</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                           message  \\\n",
+       "0  I absolutely love this project!   \n",
+       "1        This is awful and broken.   \n",
+       "2  Can you list your capabilities?   \n",
+       "3                                    \n",
+       "\n",
+       "                                               reply sentiment confidence  \n",
+       "0  (error) 404 Client Error: Not Found for url: h...      None       None  \n",
+       "1  (error) 404 Client Error: Not Found for url: h...      None       None  \n",
+       "2  (error) 404 Client Error: Not Found for url: h...      None       None  \n",
+       "3  (error) 404 Client Error: Not Found for url: h...      None       None  "
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "tests = [\n",
+    "    \"I absolutely love this project!\",\n",
+    "    \"This is awful and broken.\",\n",
+    "    \"Can you list your capabilities?\",\n",
+    "    \"\",  # malformed/empty\n",
+    "]\n",
+    "\n",
+    "rows = []\n",
+    "for t in tests:\n",
+    "    try:\n",
+    "        data = send_via_api(t, backend.value.strip()) if mode.value == \"api\" else send_via_library(t)\n",
+    "        rows.append({\"message\": t, **data})\n",
+    "    except Exception as e:\n",
+    "        rows.append({\"message\": t, \"reply\": f\"(error) {e}\", \"sentiment\": None, \"confidence\": None})\n",
+    "\n",
+    "df = pd.DataFrame(rows)\n",
+    "df\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bc6096a4-ea15-4908-9edf-e80d2c89c4a6",
+   "metadata": {},
+   "source": [
+    "# 6) Health check + quick assertions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "a3b9632b-a7eb-4c4b-94ed-add3bd5a88c6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Health: {'ok': True, 'version': '0.3.0', 'time': 1757798428}\n",
+      "Library OK: {'reply': 'Noted. The sentiment appears neutral.', 'sentiment': 'neutral', 'confidence': 0.5}\n",
+      "API OK: {'reply': 'Noted. The sentiment appears neutral.', 'sentiment': 'neutral', 'confidence': 0.5, 'thread': None}\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    print(\"Health:\", health(backend.value.strip()))\n",
+    "except Exception as e:\n",
+    "    print(\"Health check failed:\", e)\n",
+    "\n",
+    "# Simple acceptance checks\n",
+    "sample = send_via_library(\"hello\")\n",
+    "assert all(k in sample for k in (\"reply\", \"sentiment\", \"confidence\"))\n",
+    "print(\"Library OK:\", sample)\n",
+    "\n",
+    "sample_api = send_via_api(\"hello from api\", backend.value.strip())\n",
+    "assert all(k in sample_api for k in (\"reply\", \"sentiment\", \"confidence\"))\n",
+    "print(\"API OK:\", sample_api)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21b5e668-3b60-4d3d-bef2-fae238ebf91a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "1fd68863-30cd-4790-a77d-e637acfb9fd0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[\n",
+      "  \"/health\",\n",
+      "  \"/status\",\n",
+      "  \"/chatbot/message\",\n",
+      "  \"/ui\"\n",
+      "]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests, os, json\n",
+    "BACKEND_URL = os.environ.get(\"BACKEND_URL\", \"http://127.0.0.1:8000\")\n",
+    "routes = requests.get(BACKEND_URL.rstrip(\"/\") + \"/openapi.json\", timeout=10).json()[\"paths\"]\n",
+    "print(json.dumps(list(routes.keys())[:20], indent=2))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "0595d521-f8da-46ed-aafa-bc84fd519c08",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'reply': 'Noted. The sentiment appears neutral.',\n",
+       " 'sentiment': 'neutral',\n",
+       " 'confidence': 0.5,\n",
+       " 'thread': None}"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "send_via_api(\"hello from api\", BACKEND_URL.strip())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "7e44f300-e314-466b-9a9e-b2817f6b3aaa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Health: {'ok': True, 'version': '0.3.0', 'time': 1757798440}\n",
+      "Library OK: {'reply': 'Noted. The sentiment appears neutral.', 'sentiment': 'neutral', 'confidence': 0.5}\n",
+      "API OK: {'reply': 'Noted. The sentiment appears neutral.', 'sentiment': 'neutral', 'confidence': 0.5, 'thread': None}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Health:\", health(BACKEND_URL))\n",
+    "sample = send_via_library(\"hello\")\n",
+    "print(\"Library OK:\", sample)\n",
+    "\n",
+    "sample_api = send_via_api(\"hello from api\", BACKEND_URL)\n",
+    "print(\"API OK:\", sample_api)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "190a5e9b-a0b6-47a9-8201-51788715ac12",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "invalid syntax (3247471142.py, line 2)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;36m  Cell \u001b[1;32mIn[16], line 2\u001b[1;36m\u001b[0m\n\u001b[1;33m    uvicorn backend.app.main:app --reload --port 8077 --app-dir .\u001b[0m\n\u001b[1;37m            ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Pick a clean port to avoid collisions (e.g., 8077)\n",
+    "uvicorn backend.app.main:app --reload --port 8077 --app-dir .\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "efef3da8-8f93-483c-a623-ea8e48c604c8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99187776-e8c6-4c4c-80d6-6d87c299c96b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c32a0f8c-a533-4bd0-abd3-88b5fd993305",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2e8a5292-7458-474f-b599-6b2192c23b37",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (stock_ai)",
+   "language": "python",
+   "name": "stock_ai"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.20"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/SimpleTraditionalChatbot.ipynb

@@ -0,0 +1,522 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0c68164d-7eea-473c-9722-8bc92564fa6f",
+   "metadata": {},
+   "source": [
+    "# **Jupyter notebook front-end (drop-in cells)**\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "298d485d-5391-47f5-9844-b5f5945324fd",
+   "metadata": {},
+   "source": [
+    "**Smoke tests (copy/paste)**\n",
+    "\n",
+    "**Run these whenever something feels off.**\n",
+    "\n",
+    "**A. Confirm the router is mounted**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "bd2a2e6d-8b6e-4630-9aeb-d6c0cbd1b78d",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[ui] serving SPA from: C:\\Users\\User\\PortaeOS-skeleton\\packages\\shell\\dist\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[('/openapi.json', {'GET', 'HEAD'}),\n",
+       " ('/docs', {'GET', 'HEAD'}),\n",
+       " ('/docs/oauth2-redirect', {'GET', 'HEAD'}),\n",
+       " ('/redoc', {'GET', 'HEAD'}),\n",
+       " ('/health', {'GET'}),\n",
+       " ('/status', {'GET'}),\n",
+       " ('/services', {'GET'}),\n",
+       " ('/services/{name}/start', {'POST'}),\n",
+       " ('/services/{name}/stop', {'POST'}),\n",
+       " ('/services/{name}/restart', {'POST'}),\n",
+       " ('/logs/{service}/tail', {'GET'}),\n",
+       " ('/logs/bundle.zip', {'GET'}),\n",
+       " ('/favorites', {'GET'}),\n",
+       " ('/macros/open', {'POST'}),\n",
+       " ('/license/validate', {'POST'}),\n",
+       " ('/agents/run', {'POST'}),\n",
+       " ('/terminals', None),\n",
+       " ('/storefront/postman-collection', {'GET'}),\n",
+       " ('/office/status', {'GET'}),\n",
+       " ('/office/run-macro', {'POST'}),\n",
+       " ('/ui', None),\n",
+       " ('/', {'GET'}),\n",
+       " ('/ui/{_:path}', {'GET'}),\n",
+       " ('/ai/ping', {'GET'}),\n",
+       " ('/ai/health', {'GET'}),\n",
+       " ('/ai/agents/dispatch', {'POST'}),\n",
+       " ('/ai/ingest', {'POST'}),\n",
+       " ('/ai/search', {'GET'}),\n",
+       " ('/ai/chat', {'POST'}),\n",
+       " ('/recode/health', {'GET'}),\n",
+       " ('/terminals/{tid}', None),\n",
+       " ('/terminals/spawn/{tid}', {'GET'}),\n",
+       " ('/terminals/kill/{tid}', {'GET'}),\n",
+       " ('/terminals/{tid}/resize', {'POST'})]"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "os.chdir(r\"C:\\Users\\User\\PortaeOS-skeleton\\packages\\agenticcore\")  # <-- adjust to your repo root\n",
+    "\n",
+    "# Python one-liner in the same env where the server runs\n",
+    "import sys; sys.path.insert(0,'.')\n",
+    "import backend.app.main as m\n",
+    "[(getattr(r,'path',None), getattr(r,'methods',None)) for r in m.app.routes]\n",
+    "\n",
+    "# Expect to see ('/chatbot/message', {'POST'}) in the list\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2705c51f-c966-4183-a2c6-a54534e035ae",
+   "metadata": {},
+   "source": [
+    "(You already did a version of this and saw /chatbot/message appear — perfect.)\n",
+    "\n",
+    "**B. Health → Chat via API**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0e622f18-d769-4003-a915-41511c5240e1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Health: {'ok': True, 'version': '0.3.0', 'time': 1757812216}\n",
+      "Reply: 200 {'reply': 'Noted. The sentiment appears neutral.', 'sentiment': 'neutral', 'confidence': 0.5, 'thread': None}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests, json, os\n",
+    "BASE = os.environ.get(\"BACKEND_URL\",\"http://127.0.0.1:8000\").rstrip(\"/\")\n",
+    "print(\"Health:\", requests.get(BASE+\"/health\").json())\n",
+    "r = requests.post(BASE+\"/chatbot/message\", json={\"message\":\"hello via api\"})\n",
+    "print(\"Reply:\", r.status_code, r.json())\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "02aeef6d-dd70-476d-83a2-48e7732eba78",
+   "metadata": {},
+   "source": [
+    "**C. Library path (no server required)**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "11a88e5d-9ae6-4d44-a1b4-3c89716dba28",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'reply': 'Noted. The sentiment appears neutral.', 'sentiment': 'neutral', 'confidence': 0.5}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from agenticcore.chatbot.services import ChatBot\n",
+    "print(ChatBot().reply(\"hello via library\"))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89fd0fdf-c799-4e4d-8c63-c430f9d8f3b3",
+   "metadata": {},
+   "source": [
+    "# **Minimal notebook “front-end” cells (drop into top of your .ipynb)**\n",
+    "\n",
+    "These mirror your working UI and give you pass/fail signals inside the notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "65acc3b5-ec39-4b53-9c1e-be6eee9928ac",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "BACKEND_URL = http://127.0.0.1:8000\n",
+      "Health: {'ok': True, 'version': '0.3.0', 'time': 1757812221}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Cell 1: config + helpers\n",
+    "import os, json, requests\n",
+    "BACKEND_URL = os.environ.get(\"BACKEND_URL\", \"http://127.0.0.1:8000\").rstrip(\"/\")\n",
+    "\n",
+    "def health(url: str = BACKEND_URL): \n",
+    "    r = requests.get(url + \"/health\", timeout=10); r.raise_for_status(); return r.json()\n",
+    "\n",
+    "def send_via_api(message: str, url: str = BACKEND_URL):\n",
+    "    r = requests.post(url + \"/chatbot/message\", json={\"message\": message}, timeout=20)\n",
+    "    r.raise_for_status(); return r.json()\n",
+    "\n",
+    "def send_via_library(message: str):\n",
+    "    from agenticcore.chatbot.services import ChatBot\n",
+    "    return ChatBot().reply(message)\n",
+    "\n",
+    "print(\"BACKEND_URL =\", BACKEND_URL)\n",
+    "print(\"Health:\", health())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "b00f82ca-faea-43b3-b35a-03fdc0d1c2b3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Library OK: {'reply': 'Noted. The sentiment appears neutral.', 'sentiment': 'neutral', 'confidence': 0.5}\n",
+      "API OK: {'reply': 'Noted. The sentiment appears neutral.', 'sentiment': 'neutral', 'confidence': 0.5, 'thread': None}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Cell 2: quick acceptance checks\n",
+    "lib = send_via_library(\"hello\")\n",
+    "assert all(k in lib for k in (\"reply\",\"sentiment\",\"confidence\"))\n",
+    "print(\"Library OK:\", lib)\n",
+    "\n",
+    "api = send_via_api(\"hello from api\")\n",
+    "assert all(k in api for k in (\"reply\",\"sentiment\",\"confidence\"))\n",
+    "print(\"API OK:\", api)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b4dcea8-0a06-4734-8780-f4180b4ceec8",
+   "metadata": {},
+   "source": [
+    "**Cell 1 — Config & helpers**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "93d23e33-c19f-423f-9e89-b98295637075",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "BACKEND_URL = http://127.0.0.1:8000\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Notebook Config\n",
+    "import os, json, requests\n",
+    "from typing import Dict, Any\n",
+    "\n",
+    "BACKEND_URL = os.environ.get(\"BACKEND_URL\", \"http://127.0.0.1:8000\").rstrip(\"/\")\n",
+    "\n",
+    "def health(url: str = BACKEND_URL) -> Dict[str, Any]:\n",
+    "    \"\"\"GET /health to verify server is up.\"\"\"\n",
+    "    r = requests.get(url + \"/health\", timeout=10)\n",
+    "    r.raise_for_status()\n",
+    "    return r.json()\n",
+    "\n",
+    "def send_via_api(message: str, url: str = BACKEND_URL) -> Dict[str, Any]:\n",
+    "    \"\"\"POST to FastAPI /chatbot/message. Returns reply/sentiment/confidence.\"\"\"\n",
+    "    r = requests.post(url + \"/chatbot/message\", json={\"message\": message}, timeout=20)\n",
+    "    r.raise_for_status()\n",
+    "    return r.json()\n",
+    "\n",
+    "def send_via_library(message: str) -> Dict[str, Any]:\n",
+    "    \"\"\"Call ChatBot() directly (no server needed).\"\"\"\n",
+    "    from agenticcore.chatbot.services import ChatBot\n",
+    "    return ChatBot().reply(message)\n",
+    "\n",
+    "print(\"BACKEND_URL =\", BACKEND_URL)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3239843e-75b6-4bb7-8e6c-e20eb160e0a6",
+   "metadata": {},
+   "source": [
+    "**Cell 2 — Widget UI (switch API / Library)**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "f688b856-cb39-45ae-b5d3-ff20564893c0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "160ab5a3d8a54eccbaf75eec203babae",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(ToggleButtons(description='Route:', options=(('API', 'api'), ('Library', 'lib')), value='api'),…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "70a92ad1d523445781c212d302c44556",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(Text(value='', description='You:', layout=Layout(width='60%'), placeholder='Type a message…'), …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bc59056493eb4380a6559c0d88f373cb",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div style=\"margin-top:8px;opacity:.8\">Tip: ensure FastAPI exposes <code>/chatbot/message</code>. Switch to Library for offline tests.</div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import ipywidgets as W\n",
+    "from IPython.display import display, HTML\n",
+    "\n",
+    "mode = W.ToggleButtons(options=[(\"API\", \"api\"), (\"Library\", \"lib\")], value=\"api\", description=\"Route:\")\n",
+    "backend = W.Text(value=BACKEND_URL, description=\"Backend:\", layout=W.Layout(width=\"60%\"))\n",
+    "save_btn = W.Button(description=\"Save\", button_style=\"info\")\n",
+    "msg = W.Text(placeholder=\"Type a message…\", description=\"You:\", layout=W.Layout(width=\"60%\"))\n",
+    "send_btn = W.Button(description=\"Send\", button_style=\"primary\")\n",
+    "cap_btn = W.Button(description=\"Capabilities\")\n",
+    "out = W.Output()\n",
+    "\n",
+    "def on_save(_):\n",
+    "    os.environ[\"BACKEND_URL\"] = backend.value.strip().rstrip(\"/\")\n",
+    "    with out: print(\"[config] BACKEND_URL =\", os.environ[\"BACKEND_URL\"])\n",
+    "\n",
+    "def on_send(_):\n",
+    "    text = msg.value.strip()\n",
+    "    if not text:\n",
+    "        with out: print(\"[warn] Please enter some text.\")\n",
+    "        return\n",
+    "    try:\n",
+    "        data = send_via_api(text, backend.value.strip()) if mode.value == \"api\" else send_via_library(text)\n",
+    "        with out: print(json.dumps(data, indent=2, ensure_ascii=False))\n",
+    "    except Exception as e:\n",
+    "        with out: print(f\"[error] {e}\")\n",
+    "\n",
+    "def on_caps(_):\n",
+    "    try:\n",
+    "        from agenticcore.chatbot.services import ChatBot\n",
+    "        with out: print(json.dumps({\"capabilities\": ChatBot().capabilities()}, indent=2))\n",
+    "    except Exception as e:\n",
+    "        with out: print(f\"[error capabilities] {e}\")\n",
+    "\n",
+    "save_btn.on_click(on_save); send_btn.on_click(on_send); cap_btn.on_click(on_caps)\n",
+    "\n",
+    "display(W.HBox([mode, backend, save_btn]))\n",
+    "display(W.HBox([msg, send_btn, cap_btn]))\n",
+    "display(out)\n",
+    "display(HTML('<div style=\"margin-top:8px;opacity:.8\">Tip: ensure FastAPI exposes <code>/chatbot/message</code>. Switch to Library for offline tests.</div>'))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "85999cc1-26e2-497d-95c1-ffb8c9210240",
+   "metadata": {},
+   "source": [
+    "**Cell 3 — Smoke checks (acceptance)**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "3fc28db0-5aa6-4813-9663-f19d6937e39b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Health: {'ok': True, 'version': '0.3.0', 'time': 1757812228}\n",
+      "Library OK: {'reply': 'Noted. The sentiment appears neutral.', 'sentiment': 'neutral', 'confidence': 0.5}\n",
+      "API OK: {'reply': 'Noted. The sentiment appears neutral.', 'sentiment': 'neutral', 'confidence': 0.5, 'thread': None}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Backend health (if running)\n",
+    "try:\n",
+    "    print(\"Health:\", health(backend.value.strip()))\n",
+    "except Exception as e:\n",
+    "    print(\"Health check failed:\", e)\n",
+    "\n",
+    "# Library path always available\n",
+    "sample = send_via_library(\"hello\")\n",
+    "assert all(k in sample for k in (\"reply\", \"sentiment\", \"confidence\"))\n",
+    "print(\"Library OK:\", sample)\n",
+    "\n",
+    "# API path (requires uvicorn backend running)\n",
+    "try:\n",
+    "    sample_api = send_via_api(\"hello from api\", backend.value.strip())\n",
+    "    assert all(k in sample_api for k in (\"reply\", \"sentiment\", \"confidence\"))\n",
+    "    print(\"API OK:\", sample_api)\n",
+    "except Exception as e:\n",
+    "    print(\"API test failed (start uvicorn?):\", e)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "caeb5108-f0fb-4d5e-ad2a-56011904e397",
+   "metadata": {},
+   "source": [
+    "**Cell 4 — Minimal report cell (optional screenshots prompt)**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "8a3d85fc-6c2d-4c99-a286-4e9af2085d64",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "\n",
+       "### What to capture for the report\n",
+       "- Screenshot of **/health** and a successful **/chatbot/message** call.\n",
+       "- Notebook output using **API** mode and **Library** mode.\n",
+       "- Short note: environment variables used (e.g., `MICROSOFT_AI_*`, `AI_PROVIDER`, `HF_API_KEY`).\n",
+       "- Brief discussion of any errors and fixes (e.g., route mounting, ports).\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Markdown\n",
+    "Markdown(\"\"\"\n",
+    "### What to capture for the report\n",
+    "- Screenshot of **/health** and a successful **/chatbot/message** call.\n",
+    "- Notebook output using **API** mode and **Library** mode.\n",
+    "- Short note: environment variables used (e.g., `MICROSOFT_AI_*`, `AI_PROVIDER`, `HF_API_KEY`).\n",
+    "- Brief discussion of any errors and fixes (e.g., route mounting, ports).\n",
+    "\"\"\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0fcc4e15-82c2-49e8-86c5-86b80a5b691a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3e950a2-af8a-4a69-802b-7b2f81b9245c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ccb42ea3-2d61-4451-9ee8-f8e0755ff89c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (stock_ai)",
+   "language": "python",
+   "name": "stock_ai"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.20"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

pyproject.toml

@@ -0,0 +1,10 @@
+# pyproject.toml
+[tool.black]
+line-length = 100
+target-version = ["py310"]
+
+[tool.isort]
+profile = "black"
+
+[tool.pytest.ini_options]
+addopts = "-q"

requirements.txt

@@ -0,0 +1,15 @@
+gradio>=4.0
+transformers>=4.41.0
+torch>=2.2.0
+scikit-learn>=1.3.0
+pandas>=2.1.0
+numpy>=1.26.0
+pytest>=7.4.0
+# Optional Azure
+azure-ai-textanalytics>=5.3.0
+python-dotenv>=1.0
+fastapi>=0.115.0
+uvicorn[standard]>=0.30.0
+# Optional for Bot Framework sample:
+# aiohttp>=3.9
+# botbuilder-core>=4.14

samples/service.py

@@ -0,0 +1,58 @@
+# /samples/services.py
+import os
+from typing import Dict, Any
+
+# Use the unified provider layer (HF, Azure, OpenAI, Cohere, DeepAI, or offline)
+from packages.agenticcore.agenticcore.providers_unified import analyze_sentiment, generate_text
+
+
+class ChatBot:
+    """
+    Thin façade over provider-agnostic functions.
+    - Provider selection is automatic unless AI_PROVIDER is set (hf|azure|openai|cohere|deepai|offline).
+    - Reply shape: {"reply": str, "sentiment": str, "confidence": float}
+    """
+
+    def __init__(self) -> None:
+        # Optional: pin a provider via env; otherwise providers_unified auto-detects.
+        self.provider = os.getenv("AI_PROVIDER") or "auto"
+
+    def reply(self, message: str) -> Dict[str, Any]:
+        msg = (message or "").strip()
+        if not msg:
+            return {"reply": "Please enter some text.", "sentiment": "unknown", "confidence": 0.0}
+
+        if msg.lower() in {"help", "/help"}:
+            return {
+                "reply": self._help_text(),
+                "capabilities": {
+                    "system": "chatbot",
+                    "mode": self.provider,
+                    "features": ["text-input", "sentiment-analysis", "help"],
+                    "commands": {"help": "Describe capabilities and usage."},
+                },
+            }
+
+        s = analyze_sentiment(msg)  # -> {"provider","label","score",...}
+        label = str(s.get("label", "neutral"))
+        score = float(s.get("score", 0.5))
+
+        # Keep the same phrasing used elsewhere so surfaces are consistent.
+        reply = self._compose(label)
+        return {"reply": reply, "sentiment": label, "confidence": round(score, 2)}
+
+    @staticmethod
+    def _compose(label: str) -> str:
+        if label == "positive":
+            return "Thanks for sharing. I detected a positive sentiment."
+        if label == "negative":
+            return "I hear your concern. I detected a negative sentiment."
+        if label == "neutral":
+            return "Noted. The sentiment appears neutral."
+        if label == "mixed":
+            return "Your message has mixed signals. Can you clarify?"
+        return "I could not determine the sentiment. Please rephrase."
+
+    @staticmethod
+    def _help_text() -> str:
+        return "I analyze sentiment and respond concisely. Send any text or type 'help'."

scripts/check_compliance.py

@@ -0,0 +1,3 @@
+# /scripts/check_compliance.py
+
+# Fails if disallowed deps appear (placeholder)

scripts/run_local.sh

@@ -0,0 +1,5 @@
+# /scripts/run_local.sh
+#!/usr/bin/env bash
+set -euo pipefail
+export PYTHONPATH=.
+python -c "from storefront_chatbot.app.app import build; build().launch(server_name='0.0.0.0', server_port=7860)"