4th commit Trimmed More

app/app/app.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+# app/app.py — aiohttp + Bot Framework bootstrap
+
+import os, sys
+from aiohttp import web
+from pathlib import Path
+from botbuilder.core import BotFrameworkAdapter, BotFrameworkAdapterSettings, TurnContext
+
+from app.routes import init_routes
+from bot import SimpleBot
+
+# Credentials
+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 instance
+bot = SimpleBot()
+
+def create_app() -> web.Application:
+    app = web.Application()
+    init_routes(app, adapter, bot)
+
+    # Optional CORS
+    try:
+        import aiohttp_cors
+        cors = aiohttp_cors.setup(app, defaults={
+            "*": aiohttp_cors.ResourceOptions(
+                allow_credentials=True,
+                expose_headers="*",
+                allow_headers="*",
+                allow_methods=["GET","POST","OPTIONS"],
+            )
+        })
+        for route in list(app.router.routes()):
+            cors.add(route)
+    except Exception:
+        pass
+
+    # Static folder if present
+    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/app/routes.py

@@ -0,0 +1,72 @@
+# app/routes.py — HTTP handlers
+import json
+from aiohttp import web
+from botbuilder.core import TurnContext
+from botbuilder.schema import Activity
+
+# Prefer project logic if available
+try:
+    from logic import handle_text as _handle_text
+except Exception:
+    from skills import normalize, reverse_text, is_empty
+    def _handle_text(user_text: str) -> str:
+        text = (user_text or "").strip()
+        if not text:
+            return "Please provide text."
+        cmd = normalize(text)
+        if cmd in {"help", "capabilities"}:
+            return "Try: reverse <text> | or just say anything"
+        if cmd.startswith("reverse "):
+            original = text.split(" ", 1)[1] if " " in text else ""
+            return reverse_text(original)
+        return f"You said: {text}"
+
+def init_routes(app: web.Application, adapter, bot) -> None:
+    async def messages(req: web.Request) -> web.Response:
+        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:
+            return web.json_response(data=invoke_response.body, status=invoke_response.status)
+        return web.Response(status=202, text="Accepted")
+
+    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 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 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})
+
+    # Wire routes
+    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)

app/mbf_bot/app.py

@@ -1,138 +0,0 @@
-#!/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)

full/.env.example

@@ -1,9 +0,0 @@
-# Optional provider pinning & keys
-# AI_PROVIDER=hf|azure|openai|cohere|deepai|offline
-# HF_API_KEY=
-# MICROSOFT_AI_SERVICE_ENDPOINT=
-# MICROSOFT_AI_API_KEY=
-# OPENAI_API_KEY=
-# COHERE_API_KEY=
-# DEEPAI_API_KEY=
-# HTTP_TIMEOUT=20

full/README.md

@@ -1,13 +0,0 @@
-# Storefront Chatbot (Unified)
-
-This merges your skeleton with AgenticCore + a simple FastAPI backend and frontends.
-
-## Run
-1) python -m venv .venv && source .venv/bin/activate
-2) pip install -r requirements.txt
-3) uvicorn backend.app.main:app --reload --port 8000
-4) Open http://127.0.0.1:8000/ui or open frontend/chat_minimal.html
-
-## Test
-- pytest -q
-- python tools/smoke_test.py

full/agenticcore/chatbot/services.py

@@ -1,102 +0,0 @@
-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()

full/agenticcore/providers_unified.py

@@ -1,273 +0,0 @@
-"""
-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", "")}

full/backend/app/main.py

@@ -1,69 +0,0 @@
-# backend/app/main.py
-from __future__ import annotations
-
-import os
-import time
-import traceback
-from pathlib import Path
-
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse
-from fastapi.staticfiles import StaticFiles
-
-
-def create_app() -> FastAPI:
-    app = FastAPI(title="AgenticCore Backend")
-
-    # --- CORS: allow local dev origins + file:// (appears as 'null') ---
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=[
-            "http://127.0.0.1:3000", "http://localhost:3000",
-            "http://127.0.0.1:5173", "http://localhost:5173",
-            "http://127.0.0.1:8080", "http://localhost:8080",
-            "http://127.0.0.1:8000", "http://localhost:8000",
-            "null",  # file:// pages in some browsers
-        ],
-        allow_credentials=False,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-
-    @app.get("/health")
-    def health():
-        return {"ok": True, "version": "0.3.0", "time": int(time.time())}
-
-    @app.get("/status")
-    def status():
-        provider = os.getenv("AI_PROVIDER") or "auto"
-        return {"provider": provider}
-
-    # --- Routers ---
-    try:
-        from backend.app.routers.chatbot import router as chatbot_router
-        app.include_router(chatbot_router)  # exposes POST /chatbot/message
-        print("✅ Chatbot router mounted at /chatbot")
-    except Exception as e:
-        print("❌ Failed to mount chatbot router:", e)
-        traceback.print_exc()
-
-    # --- Static frontends served by FastAPI (same-origin -> no CORS) ---
-    FRONTEND_DIR = Path(__file__).resolve().parents[2] / "frontend"
-    app.mount("/ui2", StaticFiles(directory=str(FRONTEND_DIR)), name="frontend")
-
-    # Keep your existing single-file UI at /ui (optional)
-    FRONTEND_FILE = FRONTEND_DIR / "agenticcore_frontend.html"
-
-    @app.get("/ui", response_class=HTMLResponse)
-    def ui():
-        try:
-            return FRONTEND_FILE.read_text(encoding="utf-8")
-        except Exception:
-            return HTMLResponse("<h1>UI not found</h1>", status_code=404)
-
-    return app
-
-
-# Uvicorn entrypoint
-app = create_app()

full/backend/app/routers/chatbot.py

@@ -1,27 +0,0 @@
-from fastapi import APIRouter
-from pydantic import BaseModel
-from typing import Optional, Dict, Any
-
-router = APIRouter(prefix="/chatbot", tags=["chatbot"])
-
-class ChatIn(BaseModel):
-    message: str
-    thread: Optional[str] = None
-
-class ChatOut(BaseModel):
-    reply: str
-    sentiment: Optional[str] = None
-    confidence: Optional[float] = None
-    thread: Optional[str] = None
-
-@router.post("/message", response_model=ChatOut)
-def post_message(body: ChatIn) -> Dict[str, Any]:
-    from agenticcore.chatbot.services import ChatBot
-    bot = ChatBot()
-    res = bot.reply(body.message)
-    return {
-        "reply": res.get("reply", ""),
-        "sentiment": res.get("sentiment"),
-        "confidence": res.get("confidence"),
-        "thread": body.thread or res.get("thread"),
-    }

full/frontend/agenticcore_frontend.html

@@ -1,200 +0,0 @@
-<!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>

full/frontend/chat_console.html

@@ -1,77 +0,0 @@
-<!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>

full/frontend/chat_minimal.html

@@ -1,89 +0,0 @@
-<!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>

full/requirements.txt

@@ -1,14 +0,0 @@
-# Web
-fastapi>=0.112
-uvicorn[standard]>=0.30
-pydantic>=2.7
-
-# HTTP
-requests>=2.32
-
-# Optional Bot Framework demo
-aiohttp>=3.9
-botbuilder-core>=4.15
-
-# Dev
-pytest>=8.0

full/tests/test_routes.py

@@ -1,6 +0,0 @@
-def test_routes_mount():
-    from backend.app.main import create_app
-    app = create_app()
-    paths = [getattr(r, "path", "") for r in app.routes]
-    assert "/chatbot/message" in paths
-    assert "/health" in paths

full/tools/quick_sanity.py

@@ -1,13 +0,0 @@
-# tools/quick_sanity.py
-"""
-Tiny sanity test for MBF helpers. Run from repo root or set PYTHONPATH.
-"""
-import sys, os
-# Add repo root so 'mbf_bot' is importable if running directly
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-
-from mbf_bot.skills import reverse_text, capabilities, normalize
-
-print("caps:", capabilities())
-print("reverse:", reverse_text("hello"))
-print("cmd:", normalize("  Help  "))

full/tools/smoke_test.py

@@ -1,11 +0,0 @@
-import os, json, requests
-from agenticcore.chatbot.services import ChatBot
-
-def p(title, data): print(f"\n== {title} ==\n{json.dumps(data, indent=2)}")
-
-bot = ChatBot()
-p("Lib/Direct", bot.reply("I really love this"))
-
-url = os.getenv("BACKEND_URL", "http://127.0.0.1:8000")
-r = requests.get(f"{url}/health"); p("API/Health", r.json())
-r = requests.post(f"{url}/chatbot/message", json={"message":"api path test"}); p("API/Chat", r.json())