ckit_bot_exec

@rcx.on_tool_call("my_tool")
async def handle_my_tool(toolcall: FCloudtoolCall, args: dict) -> str:
    """
    Args:
        toolcall: Contains fcall_id, fcall_ft_id (thread), confirmed_by_human, etc.
        args: The arguments the LLM provided (already parsed from JSON)

    Returns:
        str: Result text that LLM will see
        OR List[dict]: Multi-modal response [{m_type: "image/png", m_content: "base64..."}]

    Raises:
        WaitForSubchats: To spawn subchats
        NeedsConfirmation: To request human approval
    """
    result = do_work(args["input"])
    return f"Result: {result}"

@rcx.on_updated_message
async def on_message(msg: FThreadMessageOutput):
    """
    Fields:
        msg.ftm_id: Message ID
        msg.ftm_ft_id: Thread ID
        msg.ftm_role: "user", "assistant", "tool", "cd_instruction"
        msg.ftm_content: Message content (may be None for tool calls)
        msg.ftm_tool_calls: List of tool calls (for assistant messages)
        msg.ftm_provenance: Metadata (model, timing, kernel logs)
    """
    if msg.ftm_role == "user":
        print(f"User said: {msg.ftm_content}")

@rcx.on_updated_thread
async def on_thread(thread: FThreadOutput):
    """
    Fields:
        thread.ft_id: Thread ID
        thread.ft_title: Thread title
        thread.ft_need_assistant: >0 if waiting for LLM
        thread.ft_need_tool_calls: >0 if waiting for tools
        thread.ft_need_user: >0 if waiting for user
        thread.ft_error: Error message if any
        thread.ft_coins: Coins spent
        thread.ft_budget: Budget limit
    """
    if thread.ft_error:
        print(f"Thread error: {thread.ft_error}")

@rcx.on_updated_task
async def on_task(task: FPersonaKanbanTaskOutput):
    """
    Fields:
        task.ktask_id: Task ID
        task.ktask_column: "inbox", "todo", "inprogress", "done"
        task.ktask_title: Task title
        task.ktask_description: Task description
        task.ktask_payload_json: Additional data
    """
    if task.ktask_column == "done":
        print(f"Task completed: {task.ktask_title}")

@rcx.on_erp_change("crm_contact")
async def on_contact_change(action: str, new_record, old_record):
    """
    Args:
        action: "INSERT", "UPDATE", "DELETE", or "ARCHIVE"
        new_record: The new row data (typed dataclass from erp_schema)
        old_record: The old row data (for UPDATE/DELETE/ARCHIVE)

    Note: ARCHIVE means soft delete (archived_ts: 0 -> >0)
    """
    if action == "INSERT":
        print(f"New contact: {new_record.contact_first_name}")

asyncio.run(ckit_bot_exec.run_bots_in_this_group(
    fclient,
    ...,
    subscribe_to_erp_tables=["crm_contact", "crm_deal"],
))

while not ckit_shutdown.shutdown_event.is_set():
    await rcx.unpark_collected_events(sleep_if_no_work=10.0)

while True:
    # Do periodic work
    await some_periodic_task()

    # Sleep with shutdown check
    if await ckit_shutdown.wait(120):  # 120 seconds
        break

setup = ckit_bot_exec.official_setup_mixing_procedure(
    mybot_install.mybot_setup_schema,  # Default values
    rcx.persona.persona_setup          # User overrides
)

# Now use setup["some_key"]
api_key = setup["API_KEY"]

scenario_fn = ckit_bot_exec.parse_bot_args()

asyncio.run(ckit_bot_exec.run_bots_in_this_group(
    fclient,
    marketable_name="mybot",
    marketable_version_str="1.0.0",
    bot_main_loop=mybot_main_loop,
    inprocess_tools=TOOLS,
    scenario_fn=scenario_fn,
    install_func=mybot_install.install,
    subscribe_to_erp_tables=["crm_contact"],  # Optional
))

import asyncio
from flexus_client_kit import ckit_client, ckit_bot_exec, ckit_cloudtool, ckit_shutdown
from flexus_client_kit import ckit_mongo
from pymongo import AsyncMongoClient
from mybot import mybot_install

BOT_NAME = "mybot"
BOT_VERSION = "1.0.0"

MY_TOOL = ckit_cloudtool.CloudTool(
    strict=True, name="my_tool",
    description="Does something",
    parameters={
        "type": "object",
        "properties": {"input": {"type": "string"}},
        "required": ["input"],
        "additionalProperties": False
    }
)

TOOLS = [MY_TOOL]


async def main_loop(fclient, rcx):
    setup = ckit_bot_exec.official_setup_mixing_procedure(
        mybot_install.mybot_setup_schema, rcx.persona.persona_setup)

    # MongoDB setup
    mongo_conn = await ckit_mongo.mongo_fetch_creds(fclient, rcx.persona.persona_id)
    mongo = AsyncMongoClient(mongo_conn)
    db = mongo[rcx.persona.persona_id + "_db"]

    @rcx.on_tool_call(MY_TOOL.name)
    async def handle(toolcall, args):
        await db.logs.insert_one({"input": args["input"]})
        return f"Processed: {args['input']}"

    @rcx.on_updated_task
    async def on_task(task):
        if task.ktask_column == "inprogress":
            print(f"Working on: {task.ktask_title}")

    try:
        while not ckit_shutdown.shutdown_event.is_set():
            await rcx.unpark_collected_events(sleep_if_no_work=10.0)
    finally:
        mongo.close()


def main():
    scenario_fn = ckit_bot_exec.parse_bot_args()
    fclient = ckit_client.FlexusClient(
        ckit_client.bot_service_name(BOT_NAME, BOT_VERSION),
        endpoint="/v1/jailed-bot")

    asyncio.run(ckit_bot_exec.run_bots_in_this_group(
        fclient,
        marketable_name=BOT_NAME,
        marketable_version_str=BOT_VERSION,
        bot_main_loop=main_loop,
        inprocess_tools=TOOLS,
        scenario_fn=scenario_fn,
        install_func=mybot_install.install,
    ))


if __name__ == "__main__":
    main()