naming

Author: oxyplay

flexus_simple_bots/integration_tester/integration_tester_bot.py

@@ -1,23 +1,20 @@
 import asyncio
 import json
 import logging
-import sys
 from pathlib import Path
 from typing import Any, Dict, List, Callable, Awaitable
 
-_repo_root = Path(__file__).parents[2]
-if str(_repo_root) not in sys.path:
-    sys.path.insert(0, str(_repo_root))
-
 from flexus_client_kit import ckit_bot_exec, ckit_client, ckit_shutdown
 from flexus_client_kit import ckit_bot_version
-from flexus_client_kit import ckit_cloudtool, ckit_integrations_db
+from flexus_client_kit import ckit_cloudtool, ckit_integrations_db, ckit_skills
+from flexus_client_kit.integrations import fi_resend
 
-logger = logging.getLogger("integration_tester")
+logger = logging.getLogger("bot_integration_tester")
 
 INTEGRATION_TESTER_ROOTDIR = Path(__file__).parent
+INTEGRATION_TESTER_SKILLS: list[str] = ckit_skills.static_skills_find(INTEGRATION_TESTER_ROOTDIR, shared_skills_allowlist="", integration_skills_allowlist="")
 
-PLAN_BATCHES_TOOL = ckit_cloudtool.CloudTool(
+INTEGRATION_TESTER_PLAN_BATCHES_TOOL = ckit_cloudtool.CloudTool(
     strict=True,
     name="integration_plan_batches",
     description="Plan integration tests one by one and return task specs for kanban fan-out.",
@@ -47,12 +44,14 @@
         "airtable",
         "hubspot",
         "twilio",
+        "resend",
+        "newsapi",
         "skills",
     ],
-    builtin_skills=[],
+    builtin_skills=INTEGRATION_TESTER_SKILLS,
 )
 
-TOOLS = [PLAN_BATCHES_TOOL] + [t for rec in INTEGRATION_TESTER_INTEGRATIONS for t in rec.integr_tools]
+TOOLS = [INTEGRATION_TESTER_PLAN_BATCHES_TOOL] + [t for rec in INTEGRATION_TESTER_INTEGRATIONS for t in rec.integr_tools]
 
 
 def _requested_names(raw: str) -> List[str]:
@@ -145,15 +144,14 @@ async def wrapper(toolcall: ckit_cloudtool.FCloudtoolCall, model_produced_args:
 
 
 BOT_NAME = ckit_bot_version.bot_name_from_file(__file__)
-BOT_VERSION = (Path(__file__).parents[1] / "VERSION").read_text().strip()
-SETUP_SCHEMA = json.loads((Path(__file__).parent / "setup_schema.json").read_text())
+INTEGRATION_TESTER_SETUP_SCHEMA = json.loads((Path(__file__).parent / "setup_schema.json").read_text()) + fi_resend.RESEND_SETUP_SCHEMA
 
 
 async def integration_tester_main_loop(
     fclient: ckit_client.FlexusClient,
     rcx: ckit_bot_exec.RobotContext,
 ) -> None:
-    setup = ckit_bot_exec.official_setup_mixing_procedure(SETUP_SCHEMA, rcx.persona.persona_setup)
+    setup = ckit_bot_exec.official_setup_mixing_procedure(INTEGRATION_TESTER_SETUP_SCHEMA, rcx.persona.persona_setup)
 
     integr_objects = await ckit_integrations_db.main_loop_integrations_init(INTEGRATION_TESTER_INTEGRATIONS, rcx, setup)
     supported_integrations = sorted({r.integr_name for r in INTEGRATION_TESTER_INTEGRATIONS})
@@ -170,7 +168,7 @@ async def integration_tester_main_loop(
                     )
                 )
 
-    @rcx.on_tool_call(PLAN_BATCHES_TOOL.name)
+    @rcx.on_tool_call(INTEGRATION_TESTER_PLAN_BATCHES_TOOL.name)
     async def toolcall_plan_batches(toolcall, model_produced_args):
         args = model_produced_args or {}
         req = _requested_names(str(args.get("requested", "all")))
@@ -226,29 +224,18 @@ async def toolcall_plan_batches(toolcall, model_produced_args):
 def main():
     from flexus_simple_bots.integration_tester import integration_tester_install
     scenario_fn = ckit_bot_exec.parse_bot_args()
+    bot_version = ckit_bot_version.read_version_file(__file__)
     fclient = ckit_client.FlexusClient(
-        ckit_client.bot_service_name(BOT_NAME, BOT_VERSION),
+        ckit_client.bot_service_name(BOT_NAME, bot_version),
         endpoint="/v1/jailed-bot",
     )
 
-    from dotenv import load_dotenv
-    load_dotenv()
-
-    async def _install_compat(client: ckit_client.FlexusClient) -> int:
-        await integration_tester_install.install(
-            client,
-            bot_name=BOT_NAME,
-            bot_version=BOT_VERSION,
-            tools=TOOLS,
-        )
-        return 0
-
     asyncio.run(ckit_bot_exec.run_bots_in_this_group(
         fclient,
         bot_main_loop=integration_tester_main_loop,
         inprocess_tools=TOOLS,
         scenario_fn=scenario_fn,
-        install_func=_install_compat,
+        install_func=integration_tester_install.install,
     ))
 
 

flexus_simple_bots/integration_tester/integration_tester_install.py

@@ -1,44 +1,34 @@
 import asyncio
-import json
 import logging
-from typing import List
 
 from flexus_client_kit import ckit_client, ckit_bot_install, ckit_cloudtool, ckit_integrations_db, ckit_skills
 from flexus_simple_bots import prompts_common
 from flexus_simple_bots.integration_tester import integration_tester_bot
 from flexus_simple_bots.integration_tester import integration_tester_prompts
 
-logger = logging.getLogger("integration_tester")
-
-INTEGRATION_TESTER_SKILLS = ckit_skills.static_skills_find(integration_tester_bot.INTEGRATION_TESTER_ROOTDIR, shared_skills_allowlist="", integration_skills_allowlist="")
-
-
-def _build_experts(tools):
-    builtin_skills = ckit_skills.read_name_description(integration_tester_bot.INTEGRATION_TESTER_ROOTDIR, INTEGRATION_TESTER_SKILLS)
-    tool_names = {t.name for rec in integration_tester_bot.INTEGRATION_TESTER_INTEGRATIONS for t in rec.integr_tools}
-    tool_names.add(integration_tester_bot.PLAN_BATCHES_TOOL.name)
-    allow_tools = ",".join(tool_names | ckit_cloudtool.KANBAN_ADVANCED | {"flexus_hand_over_task"})
-
-    return [
-        ("default", ckit_bot_install.FMarketplaceExpertInput(
-            fexp_system_prompt=integration_tester_prompts.DEFAULT_PROMPT,
-            fexp_python_kernel="",
-            fexp_allow_tools=allow_tools,
-            fexp_nature="NATURE_INTERACTIVE",
-            fexp_builtin_skills=builtin_skills,
-            fexp_description="Test API key integrations",
-        )),
-        ("autonomous", ckit_bot_install.FMarketplaceExpertInput(
-            fexp_system_prompt=integration_tester_prompts.AUTONOMOUS_PROMPT,
-            fexp_python_kernel="",
-            fexp_allow_tools=allow_tools,
-            fexp_nature="NATURE_AUTONOMOUS",
-            fexp_inactivity_timeout=600,
-            fexp_builtin_skills=builtin_skills,
-            fexp_description="Autonomous integration testing",
-        )),
-    ]
-
+logger = logging.getLogger("bot_integration_tester")
+
+TOOL_NAMESET = {t.name for t in integration_tester_bot.TOOLS}
+
+EXPERTS = [
+    ("default", ckit_bot_install.FMarketplaceExpertInput(
+        fexp_system_prompt=integration_tester_prompts.DEFAULT_PROMPT,
+        fexp_python_kernel="",
+        fexp_allow_tools=",".join(TOOL_NAMESET | ckit_cloudtool.KANBAN_ADVANCED | {"flexus_hand_over_task"}),
+        fexp_nature="NATURE_INTERACTIVE",
+        fexp_builtin_skills=ckit_skills.read_name_description(integration_tester_bot.INTEGRATION_TESTER_ROOTDIR, integration_tester_bot.INTEGRATION_TESTER_SKILLS),
+        fexp_description="Test API key integrations",
+    )),
+    ("autonomous", ckit_bot_install.FMarketplaceExpertInput(
+        fexp_system_prompt=integration_tester_prompts.AUTONOMOUS_PROMPT,
+        fexp_python_kernel="",
+        fexp_allow_tools=",".join(TOOL_NAMESET | ckit_cloudtool.KANBAN_ADVANCED | {"flexus_hand_over_task"}),
+        fexp_nature="NATURE_AUTONOMOUS",
+        fexp_inactivity_timeout=600,
+        fexp_builtin_skills=ckit_skills.read_name_description(integration_tester_bot.INTEGRATION_TESTER_ROOTDIR, integration_tester_bot.INTEGRATION_TESTER_SKILLS),
+        fexp_description="Autonomous integration testing",
+    )),
+]
 
 INTEGRATION_TESTER_DESC = """
 **Job description**
@@ -77,19 +67,9 @@ def _ensure_marketplace_images() -> None:
         pic_small_path.write_bytes(fallback_small_path.read_bytes())
 
 
-async def install(
-    client: ckit_client.FlexusClient,
-    bot_name: str,
-    bot_version: str,
-    tools: List[ckit_cloudtool.CloudTool],
-):
-    setup_schema_path = integration_tester_bot.INTEGRATION_TESTER_ROOTDIR / "setup_schema.json"
-    integration_tester_setup_default = json.loads(setup_schema_path.read_text())
-
+async def install(client: ckit_client.FlexusClient):
     _ensure_marketplace_images()
 
-    experts = _build_experts(tools)
-
     await ckit_bot_install.marketplace_upsert_dev_bot(
         client,
         ws_id=client.ws_id,
@@ -109,7 +89,7 @@ async def install(
             },
             prompts_common.SCHED_TODO_5M | {"sched_when": "EVERY:1m", "sched_fexp_name": "autonomous"},
         ],
-        marketable_setup_default=integration_tester_setup_default,
+        marketable_setup_default=integration_tester_bot.INTEGRATION_TESTER_SETUP_SCHEMA,
         marketable_featured_actions=[
             {"feat_question": "Test all integrations", "feat_expert": "default"},
             {"feat_question": "Test gmail", "feat_expert": "default"},
@@ -120,11 +100,13 @@ async def install(
             {"feat_question": "Test airtable", "feat_expert": "default"},
             {"feat_question": "Test hubspot", "feat_expert": "default"},
             {"feat_question": "Test twilio", "feat_expert": "default"},
+            {"feat_question": "Test resend", "feat_expert": "default"},
+            {"feat_question": "Test newsapi", "feat_expert": "default"},
         ],
         marketable_intro_message="Hi! I'm Integration Tester. I create deterministic kanban batch tasks and resolve them autonomously.",
         marketable_preferred_model_expensive="gpt-5.4-mini",
         marketable_preferred_model_cheap="gpt-5.4-mini",
-        marketable_experts=[(name, exp.filter_tools(tools)) for name, exp in experts],
+        marketable_experts=[(name, exp.filter_tools(integration_tester_bot.TOOLS)) for name, exp in EXPERTS],
         add_integrations_into_expert_system_prompt=integration_tester_bot.INTEGRATION_TESTER_INTEGRATIONS,
         marketable_tags=["testing", "integrations", "qa"],
         marketable_forms=ckit_bot_install.load_form_bundles(__file__),
@@ -140,6 +122,8 @@ async def install(
             "slack",
             "telegram",
             "twilio_manual",
+            "resend",
+            "newsapi",
         ],
         marketable_auth_scopes={
             "gmail": ckit_integrations_db.GOOGLE_OAUTH_BASE_SCOPES + [
@@ -171,8 +155,5 @@ async def install(
 
 
 if __name__ == "__main__":
-    from dotenv import load_dotenv
-    load_dotenv()
-
     client = ckit_client.FlexusClient("integration_tester_install")
-    asyncio.run(install(client, bot_name="integration_tester", bot_version="dev", tools=integration_tester_bot.TOOLS))
+    asyncio.run(install(client))