.gitignore
README.md
setup.py
mybot/
├── __init__.py              # Empty or minimal
├── mybot_bot.py             # Runtime: tools, handlers, main loop
├── mybot_prompts.py         # System prompts for each expert
├── mybot_install.py         # Marketplace registration
├── mybot-1024x1536.webp     # Big marketplace picture (exactly 1024x1536)
├── mybot-256x256.webp       # Avatar (exactly 256x256)
├── forms/                   # Optional: custom HTML forms
│   └── report.html          # Form for {"report": {"meta": {...}}} docs
├── lark/                    # Optional: Lark kernel files
│   └── subchat_kernel.lark  # Starlark script for subchat control
└── tools/                   # Optional: complex tool implementations
    └── my_tool.py           # Separate file for large tools

marketable_experts=[
    ("default", FMarketplaceExpertInput(
        fexp_system_prompt=prompts.main_prompt,
        fexp_python_kernel="",                    # Empty = no kernel
        fexp_app_capture_tools=json.dumps([t.openai_style_tool() for t in TOOLS]),
    )),
    ("worker", FMarketplaceExpertInput(
        fexp_system_prompt=prompts.worker_prompt,
        fexp_python_kernel=WORKER_LARK,           # Kernel controls subchat
        fexp_app_capture_tools=json.dumps([t.openai_style_tool() for t in WORKER_TOOLS]),
    )),
]

@rcx.on_tool_call("analyze_batch")
async def handle(toolcall, args):
    items = args["items"]
    subchats = await ckit_ask_model.bot_subchat_create_multiple(
        client=fclient,
        who_is_asking="mybot_analyze",
        persona_id=rcx.persona.persona_id,
        first_question=[f"Analyze: {item}" for item in items],
        first_calls=["null" for _ in items],
        title=[f"Analysis {i}" for i in range(len(items))],
        fcall_id=toolcall.fcall_id,
        fexp_name="worker",  # Use worker expert for subchats
    )
    raise ckit_cloudtool.WaitForSubchats(subchats)

# In lark/subchat_kernel.lark
for msg in messages[::-1]:
    if msg.get("role") == "assistant" and "DONE:" in str(msg.get("content", "")):
        subchat_result = msg["content"]
        break

# In mybot_install.py
marketable_preferred_model_default = "grok-4-1-fast-reasoning"  # For complex bots
# or
marketable_preferred_model_default = "grok-4-1-fast-non-reasoning"  # For simple bots

MYBOT_SETUP_SCHEMA = [
    {
        "bs_name": "SLACK_BOT_TOKEN",
        "bs_type": "string_long",       # Secret input field
        "bs_default": "",
        "bs_group": "Slack",            # UI tab/section
        "bs_importance": 0,
        "bs_description": "Bot User OAuth Token (starts with xoxb-)",
    },
    {
        "bs_name": "SLACK_APP_TOKEN",
        "bs_type": "string_long",
        "bs_default": "",
        "bs_group": "Slack",
        "bs_description": "App-Level Token for Socket Mode (starts with xapp-)",
    },
    {
        "bs_name": "slack_channels",
        "bs_type": "string_multiline",
        "bs_default": "",
        "bs_group": "Slack",
        "bs_description": "Channels to monitor (one per line)",
    },
]

from flexus_client_kit.integrations import fi_slack

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

    slack = None
    if setup.get("SLACK_BOT_TOKEN"):
        slack = fi_slack.IntegrationSlack(
            fclient=fclient,
            rcx=rcx,
            setup=setup,
        )
        await slack.start_reactive()  # Starts event loop

    try:
        while not ckit_shutdown.shutdown_event.is_set():
            await rcx.unpark_collected_events(sleep_if_no_work=10.0)
    finally:
        if slack:
            await slack.close()  # Always cleanup!

# Register the integration as a tool handler
@rcx.on_tool_call("slack")
async def toolcall_slack(toolcall, model_args):
    if not slack:
        return "ERROR: Slack not configured. Set SLACK_BOT_TOKEN in bot setup."
    return await slack.called_by_model(toolcall, model_args)

# In your tool handler, check integration status
@rcx.on_tool_call("slack")
async def toolcall_slack(toolcall, model_args):
    if not slack:
        return "ERROR: Slack not configured"
    if slack.problems_other:
        return f"WARNING: Slack has issues: {slack.problems_other}"
    return await slack.called_by_model(toolcall, model_args)

from setuptools import setup, find_packages
setup(
    name="mybot",
    version="0.1.0",
    packages=find_packages(),
    install_requires=["flexus-client-kit"],
    package_data={"": ["*.webp", "*.png", "*.html", "*.lark", "*.json"]},
)

python -m py_compile mybot/mybot_bot.py mybot/mybot_prompts.py mybot/mybot_install.py
python -c "import mybot.mybot_bot; import mybot.mybot_install; print('OK')"

# tests/test_mybot.py
import pytest
from unittest.mock import AsyncMock, patch

@pytest.mark.asyncio
async def test_my_tool_handler():
    with patch("mybot.mybot_bot.external_api") as mock_api:
        mock_api.fetch.return_value = {"status": "ok"}
        result = await handle_my_tool(mock_toolcall, {"param": "value"})
        assert "ok" in result

def test_prompt_formatting():
    from mybot import mybot_prompts
    assert "## Instructions" in mybot_prompts.main_prompt

python -m mybot.mybot_bot --scenario mybot/mybot__s1.yaml
cat scenario-dumps/mybot__s1-*-score.yaml

pip install -e /workspace
timeout 10 python -m mybot.mybot_bot 2>&1