@agentikos/omega-os 0.2.0 → 0.19.5

package/omega/Agentik_Engine/tests/test_skill_routing.py

@@ -0,0 +1,189 @@
+"""Tests for omega_engine.skill_routing — role → skills resolution + the
+system-prompt skill block.
+
+The routing module is pure (no I/O for the role map, single Read for the
+description extraction) so these tests stay fast: ~30 ms total.
+"""
+from __future__ import annotations
+
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine import skill_routing as SR  # noqa: E402
+from omega_engine import worker as W          # noqa: E402
+
+
+class TestRoleDefaults(unittest.TestCase):
+    def test_worker_includes_pursue_and_audits(self):
+        recs = SR.recommend("worker")
+        self.assertIn("pursue", recs)
+        self.assertIn("codeaudit", recs)
+        self.assertIn("debugaudit", recs)
+
+    def test_oracle_includes_dispatch(self):
+        self.assertIn("dispatch", SR.recommend("oracle"))
+
+    def test_classifier_is_empty(self):
+        self.assertEqual(SR.recommend("classifier"), [])
+
+    def test_unknown_role_returns_empty_list(self):
+        self.assertEqual(SR.recommend("does-not-exist"), [])
+
+    def test_recommend_returns_copy(self):
+        # Mutating the return value must not pollute the global map.
+        a = SR.recommend("worker")
+        a.append("garbage")
+        self.assertNotIn("garbage", SR.recommend("worker"))
+
+    def test_power_skills_listed(self):
+        # The constant exists, includes the obvious ones, has stable ordering.
+        self.assertIn("dispatch", SR.POWER_SKILLS)
+        self.assertIn("pursue", SR.POWER_SKILLS)
+        self.assertIn("codeaudit", SR.POWER_SKILLS)
+
+
+class TestResolution(unittest.TestCase):
+    def test_explicit_wins(self):
+        out = SR.skills_for("worker", explicit=["only-this"])
+        self.assertEqual(out, ["only-this"])
+
+    def test_topology_wins_over_role_default(self):
+        out = SR.skills_for("worker", topology_skills=["mission-skill"])
+        self.assertEqual(out, ["mission-skill"])
+
+    def test_explicit_wins_over_topology(self):
+        out = SR.skills_for("worker", explicit=["a"], topology_skills=["b"])
+        self.assertEqual(out, ["a"])
+
+    def test_falls_back_to_role_default(self):
+        out = SR.skills_for("oracle")
+        self.assertIn("dispatch", out)
+
+
+class TestCatalog(unittest.TestCase):
+    def test_empty_home_returns_empty(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            self.assertEqual(SR.catalog_for_home(tmp), [])
+
+    def test_lists_skill_dirs_and_files(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "Agentik_SSOT" / "skills"
+            (root / "pursue").mkdir(parents=True)
+            (root / "pursue" / "SKILL.md").write_text("---\nname: pursue\n---")
+            (root / "codeaudit").mkdir()
+            (root / "codeaudit" / "SKILL.md").write_text("---\nname: codeaudit\n---")
+            (root / "no-skillmd").mkdir()  # not a real skill, must be skipped
+            (root / "rag-route.md").write_text("---\nname: rag-route\n---")
+            out = SR.catalog_for_home(tmp)
+            self.assertIn("pursue", out)
+            self.assertIn("codeaudit", out)
+            self.assertIn("rag-route", out)
+            self.assertNotIn("no-skillmd", out)
+
+
+class TestSkillBlock(unittest.TestCase):
+    def test_empty_returns_empty(self):
+        self.assertEqual(SR.format_skill_block([]), "")
+
+    def test_block_lists_skill_ids_and_header(self):
+        block = SR.format_skill_block(["pursue", "codeaudit"])
+        self.assertIn("## Skills available", block)
+        self.assertIn("/pursue", block)
+        self.assertIn("/codeaudit", block)
+        self.assertIn("invoke them as slash", block)
+
+    def test_block_includes_descriptions_when_skillmd_present(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "Agentik_SSOT" / "skills"
+            (root / "pursue").mkdir(parents=True)
+            (root / "pursue" / "SKILL.md").write_text(
+                "---\nname: pursue\n"
+                "description: Goal-driven loop until verify exits 0.\n"
+                "---\n# pursue\n"
+            )
+            block = SR.format_skill_block(["pursue"], home=tmp)
+            self.assertIn("Goal-driven loop", block)
+
+    def test_description_too_long_is_truncated(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "Agentik_SSOT" / "skills"
+            (root / "huge").mkdir(parents=True)
+            long_desc = "x" * 200
+            (root / "huge" / "SKILL.md").write_text(
+                f"---\nname: huge\ndescription: {long_desc}\n---"
+            )
+            block = SR.format_skill_block(["huge"], home=tmp)
+            self.assertIn("...", block)
+
+
+class TestWorkerBriefSkills(unittest.TestCase):
+    def test_default_role_resolves_to_role_skills(self):
+        b = W.WorkerBrief(task_id="t1", role="worker", intent="x")
+        skills = b.resolved_skills()
+        self.assertIn("pursue", skills)
+
+    def test_explicit_skills_override(self):
+        b = W.WorkerBrief(task_id="t1", role="worker", intent="x",
+                          skills=["only-this"])
+        self.assertEqual(b.resolved_skills(), ["only-this"])
+
+    def test_classifier_role_empty_by_default(self):
+        b = W.WorkerBrief(task_id="t1", role="classifier", intent="x")
+        self.assertEqual(b.resolved_skills(), [])
+
+    def test_json_round_trip_preserves_skills(self):
+        import json
+        b = W.WorkerBrief(task_id="t1", role="worker", intent="x",
+                          skills=["pursue", "codeaudit"])
+        loaded = W.WorkerBrief.from_dict(json.loads(b.to_json()))
+        self.assertEqual(loaded.skills, ["pursue", "codeaudit"])
+
+
+class TestRunBriefEmbedsSkillBlock(unittest.TestCase):
+    """When the brief carries skills, the system_prompt sent to claude
+    contains the skill block."""
+
+    def test_system_prompt_includes_skill_section(self):
+        import json as _json
+        from unittest import mock
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            brief = W.WorkerBrief(
+                task_id="t-sk", role="worker", intent="x",
+                skills=["pursue", "codeaudit"],
+            )
+            W.write_brief(home, brief)
+            captured = {}
+
+            def fake_run(cmd, **kw):
+                captured["cmd"] = cmd
+                import subprocess
+                return subprocess.CompletedProcess(
+                    args=cmd, returncode=0,
+                    stdout=_json.dumps({
+                        "result": "ok", "session_id": "s",
+                        "usage": {}, "total_cost_usd": 0.0,
+                    }),
+                    stderr="",
+                )
+
+            with mock.patch.object(W.subprocess, "run", side_effect=fake_run):
+                W.run_brief(home, "t-sk")
+            cmd = captured["cmd"]
+            # --append-system-prompt is present
+            self.assertIn("--append-system-prompt", cmd)
+            idx = cmd.index("--append-system-prompt")
+            block = cmd[idx + 1]
+            self.assertIn("## Skills available", block)
+            self.assertIn("/pursue", block)
+            self.assertIn("/codeaudit", block)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/omega/Agentik_Engine/tests/test_telegram_history.py

@@ -0,0 +1,209 @@
+"""Tests for the per-topic conversation-history layer.
+
+The Telegram daemon used to forget everything between turns. This module
+adds a SQLite-backed history. The tests verify the round-trip, the
+chronological ordering, the context-prompt builder, and the DM refusal
+path in the daemon router.
+"""
+from __future__ import annotations
+
+import sys
+import tempfile
+import time
+import unittest
+from pathlib import Path
+from unittest import mock
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine.telegram_history import (  # noqa: E402
+    Message,
+    build_context_prompt,
+    prune,
+    record_inbound,
+    record_outbound,
+    recent_messages,
+    topic_stats,
+)
+
+
+class TestRecordAndRecent(unittest.TestCase):
+    def test_round_trip(self):
+        with tempfile.TemporaryDirectory() as td:
+            record_inbound(td, topic_id=42, text="hi", message_id=1)
+            record_outbound(td, topic_id=42, text="hello", message_id=2)
+            history = recent_messages(td, topic_id=42)
+            self.assertEqual(len(history), 2)
+            self.assertEqual(history[0].role, "user")
+            self.assertEqual(history[0].text, "hi")
+            self.assertEqual(history[1].role, "bot")
+            self.assertEqual(history[1].text, "hello")
+
+    def test_recent_is_chronological(self):
+        with tempfile.TemporaryDirectory() as td:
+            for i in range(5):
+                record_inbound(td, topic_id=7, text=f"msg{i}")
+                time.sleep(0.01)
+            history = recent_messages(td, topic_id=7)
+            self.assertEqual(
+                [m.text for m in history],
+                ["msg0", "msg1", "msg2", "msg3", "msg4"],
+            )
+
+    def test_recent_respects_limit(self):
+        with tempfile.TemporaryDirectory() as td:
+            for i in range(20):
+                record_inbound(td, topic_id=8, text=f"m{i}")
+            history = recent_messages(td, topic_id=8, limit=5)
+            self.assertEqual(len(history), 5)
+            # The 5 most recent, in chronological order.
+            self.assertEqual(
+                [m.text for m in history],
+                ["m15", "m16", "m17", "m18", "m19"],
+            )
+
+    def test_topics_are_isolated(self):
+        with tempfile.TemporaryDirectory() as td:
+            record_inbound(td, topic_id=1, text="topic1-a")
+            record_inbound(td, topic_id=2, text="topic2-a")
+            t1 = recent_messages(td, topic_id=1)
+            t2 = recent_messages(td, topic_id=2)
+            self.assertEqual([m.text for m in t1], ["topic1-a"])
+            self.assertEqual([m.text for m in t2], ["topic2-a"])
+
+    def test_record_rejects_unknown_role(self):
+        with tempfile.TemporaryDirectory() as td:
+            from omega_engine.telegram_history import _record
+            with self.assertRaises(ValueError):
+                _record(td, topic_id=1, role="alien", text="x", message_id=None)
+
+
+class TestContextPrompt(unittest.TestCase):
+    def test_cold_topic_returns_intent_unchanged(self):
+        with tempfile.TemporaryDirectory() as td:
+            out = build_context_prompt(td, topic_id=99, new_intent="hello")
+            self.assertEqual(out, "hello")
+
+    def test_warm_topic_prepends_history(self):
+        with tempfile.TemporaryDirectory() as td:
+            record_inbound(td, topic_id=1, text="please fix the login bug")
+            record_outbound(td, topic_id=1, text="ok, I'm starting now")
+            out = build_context_prompt(td, topic_id=1,
+                                        new_intent="any progress?")
+            self.assertIn("Conversation history in topic 1", out)
+            self.assertIn("please fix the login bug", out)
+            self.assertIn("ok, I'm starting now", out)
+            self.assertIn("any progress?", out)
+            self.assertIn("user (just now)", out)
+
+    def test_context_format_carries_roles_and_age(self):
+        with tempfile.TemporaryDirectory() as td:
+            record_inbound(td, topic_id=2, text="how do I configure age?")
+            out = build_context_prompt(td, topic_id=2,
+                                        new_intent="also tell me about vault")
+            # role markers present
+            self.assertIn("user (", out)
+            # short human-time present (we just wrote it; should be "0s ago" or similar)
+            self.assertTrue("ago" in out)
+
+
+class TestPrune(unittest.TestCase):
+    def test_prune_drops_old_rows(self):
+        with tempfile.TemporaryDirectory() as td:
+            from omega_engine.telegram_history import _connect
+            # Inject an artificially old row.
+            conn = _connect(td)
+            conn.execute(
+                "INSERT INTO messages (topic_id, role, text, message_id, timestamp) "
+                "VALUES (?, ?, ?, ?, ?)",
+                (1, "user", "ancient", None, 0),  # epoch 0 — very old
+            )
+            conn.commit()
+            conn.close()
+            record_inbound(td, topic_id=1, text="recent")
+            removed = prune(td, older_than_days=30)
+            self.assertEqual(removed, 1)
+            history = recent_messages(td, topic_id=1)
+            self.assertEqual([m.text for m in history], ["recent"])
+
+
+class TestTopicStats(unittest.TestCase):
+    def test_stats_groups_per_topic(self):
+        with tempfile.TemporaryDirectory() as td:
+            record_inbound(td, topic_id=1, text="a")
+            record_inbound(td, topic_id=1, text="b")
+            record_outbound(td, topic_id=1, text="c")
+            record_inbound(td, topic_id=2, text="x")
+            stats = topic_stats(td)
+            by_topic = {s["topic_id"]: s for s in stats}
+            self.assertEqual(by_topic[1]["messages"], 3)
+            self.assertEqual(by_topic[2]["messages"], 1)
+
+
+class TestDaemonDMRefusal(unittest.TestCase):
+    """The daemon must refuse to start a mission from a DM."""
+    def test_dm_message_is_refused(self):
+        from omega_engine.daemons.telegram import _route_one
+
+        class _FakeBridge:
+            def __init__(self):
+                self.calls: list[dict] = []
+            def _call(self, method, fields, **_kw):
+                self.calls.append({"method": method, "fields": fields})
+                return {"message_id": 1}
+
+        class _FakeSupervisor:
+            def on_channel_message(self, topic_id, text):
+                return []
+
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            bridge = _FakeBridge()
+            tag = _route_one(
+                topic_id=None, text="hi from DM",
+                message_id=5, chat_id=12345,
+                supervisor=_FakeSupervisor(),
+                project_map={},
+                home=home,
+                telegram_bridge=bridge,
+            )
+            self.assertEqual(tag, "dm:refused")
+            # We replied to the user with the redirect message.
+            self.assertEqual(len(bridge.calls), 1)
+            self.assertEqual(bridge.calls[0]["method"], "sendMessage")
+            self.assertEqual(
+                str(bridge.calls[0]["fields"]["chat_id"]), "12345",
+            )
+            self.assertIn("project topic", bridge.calls[0]["fields"]["text"])
+
+    def test_topic_message_records_history(self):
+        from omega_engine.daemons.telegram import _route_one
+
+        class _FakeBridge: pass
+        class _FakeSupervisor:
+            def on_channel_message(self, topic_id, text):
+                return []
+
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            # No project mapped → topic:unknown path. But the inbound
+            # message should still be recorded.
+            tag = _route_one(
+                topic_id=99, text="curious question",
+                message_id=11, chat_id=12345,
+                supervisor=_FakeSupervisor(),
+                project_map={},
+                home=home,
+                telegram_bridge=_FakeBridge(),
+            )
+            self.assertEqual(tag, "topic:unknown")
+            history = recent_messages(home, topic_id=99)
+            self.assertEqual(len(history), 1)
+            self.assertEqual(history[0].text, "curious question")
+            self.assertEqual(history[0].role, "user")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/omega/Agentik_Engine/tests/test_tmux_and_aisb_chat.py

@@ -0,0 +1,223 @@
+"""Tests for the tmux orchestrator + AISB chat-loop fallback."""
+from __future__ import annotations
+
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine import tmux  # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Categorisation
+# ---------------------------------------------------------------------------
+
+
+class TestCategorize(unittest.TestCase):
+    def test_aisb(self):
+        for n in ("AISB-master", "AISB-ORACLE", "aisb-chat"):
+            self.assertEqual(tmux.categorize(n), "aisb")
+
+    def test_oracle(self):
+        for n in ("Kommu-oracle", "DentistryGPT-oracle-2",
+                  "AgentikOS-oracle"):
+            self.assertEqual(tmux.categorize(n), "oracle")
+
+    def test_worker(self):
+        for n in ("Kommu-worker-1-audit-codeaudit",
+                  "DentistryGPT-worker-2-fix-login",
+                  "Project-oracle-2-worker-1-task"):
+            self.assertEqual(tmux.categorize(n), "worker")
+
+    def test_dev(self):
+        for n in ("Causio-dev-feat", "Causio-fix-CAU-42", "K-work-x"):
+            self.assertEqual(tmux.categorize(n), "dev")
+
+    def test_linear(self):
+        self.assertEqual(tmux.categorize("Kommu-linear"), "linear")
+
+    def test_home(self):
+        for n in ("Home", "Home-2", "Home-3"):
+            self.assertEqual(tmux.categorize(n), "home")
+
+    def test_other(self):
+        for n in ("misc", "ssh-tunnel", "random-session-name"):
+            self.assertEqual(tmux.categorize(n), "other")
+
+    def test_project_extraction(self):
+        self.assertEqual(tmux.project_from("Kommu-oracle"), "Kommu")
+        self.assertEqual(tmux.project_from("DentistryGPT-worker-1-x"),
+                         "DentistryGPT")
+        self.assertEqual(tmux.project_from("Causio-fix-CAU-42"), "Causio")
+        self.assertIsNone(tmux.project_from("Home"))
+
+
+# ---------------------------------------------------------------------------
+# Subprocess wrapper (mocked)
+# ---------------------------------------------------------------------------
+
+
+def _fake_proc(stdout: str, returncode: int = 0):
+    import subprocess
+    return subprocess.CompletedProcess(args=[], returncode=returncode,
+                                       stdout=stdout, stderr="")
+
+
+class TestListSessions(unittest.TestCase):
+    def test_list_empty_when_tmux_missing(self):
+        with mock.patch("shutil.which", return_value=None):
+            sessions = tmux.list_sessions()
+            self.assertEqual(sessions, [])
+
+    def test_list_parses_format(self):
+        # Two sessions: Kommu-oracle (detached, 2 windows), Home (attached)
+        canned = (
+            "Kommu-oracle\t0\t2\t1700000000\n"
+            "Home\t1\t1\t1700000100\n"
+        )
+        with mock.patch("shutil.which", return_value="/usr/bin/tmux"), \
+             mock.patch("subprocess.run", return_value=_fake_proc(canned, 0)):
+            sessions = tmux.list_sessions()
+        self.assertEqual(len(sessions), 2)
+        self.assertEqual(sessions[0].name, "Kommu-oracle")
+        self.assertEqual(sessions[0].category, "oracle")
+        self.assertEqual(sessions[0].project, "Kommu")
+        self.assertFalse(sessions[0].attached)
+        self.assertEqual(sessions[0].windows, 2)
+        self.assertTrue(sessions[1].attached)
+        self.assertEqual(sessions[1].category, "home")
+
+
+class TestSpawn(unittest.TestCase):
+    def test_refuses_existing_session(self):
+        with mock.patch("shutil.which", return_value="/usr/bin/tmux"), \
+             mock.patch("subprocess.run", return_value=_fake_proc("", 0)):
+            # is_alive returns True (rc=0) so spawn refuses.
+            self.assertFalse(tmux.spawn("Kommu-oracle"))
+
+    def test_spawn_oracle_naming(self):
+        captured: list = []
+
+        def fake_run(cmd, **kw):
+            captured.append(cmd)
+            # First call (has-session) returns 1 (not alive).
+            # Second call (new-session) returns 0.
+            rc = 1 if "has-session" in cmd else 0
+            return _fake_proc("", rc)
+
+        with mock.patch("shutil.which", return_value="/usr/bin/tmux"), \
+             mock.patch("subprocess.run", side_effect=fake_run):
+            name = tmux.spawn_oracle("Kommu")
+        self.assertEqual(name, "Kommu-oracle")
+        # The new-session command carries the right session name
+        new_session_cmd = next(c for c in captured if "new-session" in c)
+        self.assertIn("Kommu-oracle", new_session_cmd)
+
+    def test_spawn_worker_with_oracle_id(self):
+        with mock.patch("shutil.which", return_value="/usr/bin/tmux"), \
+             mock.patch("subprocess.run", return_value=_fake_proc("", 1)):
+            n1 = tmux.spawn_worker("Kommu", "audit-codeaudit",
+                                    worker_id=1, oracle_id=1)
+            n2 = tmux.spawn_worker("Kommu", "audit-secaudit",
+                                    worker_id=1, oracle_id=2)
+        self.assertEqual(n1, "Kommu-worker-1-audit-codeaudit")
+        self.assertEqual(n2, "Kommu-oracle-2-worker-1-audit-secaudit")
+
+
+class TestHealth(unittest.TestCase):
+    def test_health_without_tmux(self):
+        with mock.patch("shutil.which", return_value=None):
+            r = tmux.health_report()
+            self.assertFalse(r["tmux_installed"])
+
+    def test_health_groups_categories(self):
+        canned = (
+            "AISB-master\t0\t1\t1700000000\n"
+            "Kommu-oracle\t0\t1\t1700000000\n"
+            "Kommu-worker-1-codeaudit\t0\t1\t1700000000\n"
+        )
+        with mock.patch("shutil.which", return_value="/usr/bin/tmux"), \
+             mock.patch("subprocess.run", return_value=_fake_proc(canned, 0)):
+            r = tmux.health_report()
+        self.assertEqual(r["sessions"], 3)
+        self.assertIn("oracle", r["by_category"])
+        self.assertIn("worker", r["by_category"])
+        self.assertIn("aisb", r["by_category"])
+
+
+class TestCleanupStale(unittest.TestCase):
+    def test_dry_run_lists_but_no_kill(self):
+        # Worker created at epoch 0 → very old.
+        canned = "Kommu-worker-1-stuck\t0\t1\t0\n"
+        with mock.patch("shutil.which", return_value="/usr/bin/tmux"), \
+             mock.patch("subprocess.run", return_value=_fake_proc(canned, 0)):
+            r = tmux.cleanup_stale(older_than_hours=1, dry_run=True)
+        self.assertEqual(r["candidates"], ["Kommu-worker-1-stuck"])
+        self.assertEqual(r["killed"], [])
+
+
+# ---------------------------------------------------------------------------
+# Default config writes a file with the prefix+Z popup
+# ---------------------------------------------------------------------------
+
+
+class TestDefaultConfig(unittest.TestCase):
+    def test_writes_file_with_prefix_z_binding(self):
+        with tempfile.TemporaryDirectory() as td:
+            path = tmux.write_default_config(Path(td) / "tmux.conf")
+            self.assertTrue(path.exists())
+            text = path.read_text()
+            self.assertIn("bind-key Z", text)
+            self.assertIn("omega tmux menu", text)
+
+
+# ---------------------------------------------------------------------------
+# AISB chat-loop wiring
+# ---------------------------------------------------------------------------
+
+
+class TestAisbChat(unittest.TestCase):
+    def test_chat_records_inbound_and_outbound(self):
+        from omega_engine import aisb_chat
+        from omega_engine.telegram_history import recent_messages
+
+        # Mock input(): one user line then /quit.
+        responses = iter(["fix the login bug", "/quit"])
+
+        def fake_input(prompt=""):
+            return next(responses)
+
+        # Mock the provider so we don't actually call Claude.
+        class _FakeResult:
+            text = "ok, will look into it"
+        class _FakeProvider:
+            id = "fake"
+            def run(self, req): return _FakeResult()
+        class _FakeRouter:
+            def resolve(self, role): return _FakeProvider()
+
+        with tempfile.TemporaryDirectory() as td, \
+             mock.patch("builtins.input", side_effect=fake_input), \
+             mock.patch("omega_engine.router.ModelRouter.auto",
+                        return_value=_FakeRouter()), \
+             mock.patch.dict("os.environ", {"OMEGA_HOME": td}):
+            rc = aisb_chat.run_chat_loop()
+            self.assertEqual(rc, 0)
+            # Assertions MUST be inside the with block — temp dir is
+            # deleted on context exit.
+            history = recent_messages(td, topic_id=aisb_chat.CHAT_TOPIC)
+            self.assertEqual(len(history), 2)
+            self.assertEqual(history[0].role, "user")
+            self.assertEqual(history[0].text, "fix the login bug")
+            self.assertEqual(history[1].role, "bot")
+            self.assertEqual(history[1].text, "ok, will look into it")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)