ckit_ask_model

from flexus_client_kit import ckit_ask_model

result = await ckit_ask_model.bot_activate(
    client=fclient,
    who_is_asking="my_service",
    persona_id=rcx.persona.persona_id,
    first_question="Analyze this data: ...",
    title="Data Analysis",
    fexp_name="analyst",  # Optional: specific expert
)

print(f"Thread created: {result.ft_id}")

from flexus_client_kit import ckit_ask_model, ckit_cloudtool

@rcx.on_tool_call("analyze_multiple")
async def handle(toolcall, args):
    items = args["items"]  # ["item1", "item2", "item3"]

    subchats = await ckit_ask_model.bot_subchat_create_multiple(
        client=fclient,
        who_is_asking="multi_analyzer",
        persona_id=rcx.persona.persona_id,
        first_question=[f"Analyze: {item}" for item in items],
        first_calls=["null" for _ in items],  # No initial tool calls
        title=[f"Analysis: {item}" for item in items],
        fcall_id=toolcall.fcall_id,
        fexp_name="analyst",
    )

    # This pauses until all subchats complete
    raise ckit_cloudtool.WaitForSubchats(subchats)

# In install script, expert definition:
FMarketplaceExpertInput(
    fexp_system_prompt=ANALYST_PROMPT,
    fexp_python_kernel="""
# Check if analysis is complete
msg = messages[-1]
if msg["role"] == "assistant" and "ANALYSIS_COMPLETE" in str(msg.get("content", "")):
    subchat_result = msg["content"]
elif msg["role"] == "assistant" and not msg.get("tool_calls"):
    # No tool calls and no marker = ask to complete
    post_cd_instruction = "Finish your analysis and include ANALYSIS_COMPLETE at the end."
""",
    fexp_app_capture_tools=tools_json,
)

await ckit_ask_model.thread_messages_create_multiple(
    client=fclient,
    ft_id=thread_id,
    messages=[
        {"role": "user", "content": "Additional context"},
        {"role": "context_file", "content": "File contents here..."},
    ],
)

@dataclass
class FThreadOutput:
    ft_id: str              # Thread ID
    ft_title: str           # Thread title
    ft_need_assistant: int  # >0 if waiting for LLM
    ft_need_tool_calls: int # >0 if waiting for tools
    ft_need_user: int       # >0 if waiting for user
    ft_error: str           # Error message if any
    ft_coins: int           # Coins spent
    ft_budget: int          # Budget limit
    ft_fexp_id: str         # Expert ID
    ft_toolset: str         # JSON of allowed tools

@dataclass
class FThreadMessageOutput:
    ftm_id: str             # Message ID
    ftm_ft_id: str          # Thread ID
    ftm_role: str           # Message role
    ftm_content: str        # Message content
    ftm_tool_calls: List    # Tool calls (for assistant)
    ftm_call_id: str        # Tool call ID (for tool results)
    ftm_provenance: str     # JSON metadata
    ftm_created_ts: datetime

@rcx.on_tool_call("deep_research")
async def handle(toolcall, args):
    topic = args["topic"]

    # Create 3 parallel research threads
    subchats = await ckit_ask_model.bot_subchat_create_multiple(
        client=fclient,
        who_is_asking="deep_researcher",
        persona_id=rcx.persona.persona_id,
        first_question=[
            f"Research academic sources on: {topic}",
            f"Research industry reports on: {topic}",
            f"Research news and trends on: {topic}",
        ],
        first_calls=["null", "null", "null"],
        title=["Academic", "Industry", "News"],
        fcall_id=toolcall.fcall_id,
        fexp_name="researcher",
    )

    raise ckit_cloudtool.WaitForSubchats(subchats)

# External service activates a bot on schedule
async def daily_report_trigger():
    await ckit_ask_model.bot_activate(
        client=fclient,
        who_is_asking="daily_scheduler",
        persona_id=report_bot_persona_id,
        first_question="Generate daily sales report for yesterday",
        title=f"Daily Report {date.today()}",
    )

# First message starts the thread
result = await ckit_ask_model.bot_activate(
    client=fclient,
    who_is_asking="workflow",
    persona_id=rcx.persona.persona_id,
    first_question="Start processing",
    title="Workflow",
)

# Wait for response...

# Add more context
await ckit_ask_model.thread_messages_create_multiple(
    client=fclient,
    ft_id=result.ft_id,
    messages=[
        {"role": "context_file", "content": document_content},
        {"role": "user", "content": "Now analyze the document above"},
    ],
)

from flexus_client_kit import ckit_ask_model, ckit_cloudtool

COMPARE_TOOL = ckit_cloudtool.CloudTool(
    strict=True,
    name="compare_options",
    description="Compare multiple options in parallel",
    parameters={
        "type": "object",
        "properties": {
            "options": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Options to compare",
            },
            "criteria": {
                "type": "string",
                "description": "Comparison criteria",
            },
        },
        "required": ["options", "criteria"],
        "additionalProperties": False,
    },
)


async def main_loop(fclient, rcx):
    @rcx.on_tool_call(COMPARE_TOOL.name)
    async def handle_compare(toolcall, args):
        options = args["options"]
        criteria = args["criteria"]

        if len(options) < 2:
            return "Need at least 2 options to compare"

        if len(options) > 5:
            return "Maximum 5 options allowed"

        # Create parallel evaluation subchats
        subchats = await ckit_ask_model.bot_subchat_create_multiple(
            client=fclient,
            who_is_asking="option_comparator",
            persona_id=rcx.persona.persona_id,
            first_question=[
                f"Evaluate '{opt}' against criteria: {criteria}. "
                f"Score 1-10 and explain. End with EVALUATION_COMPLETE."
                for opt in options
            ],
            first_calls=["null" for _ in options],
            title=[f"Evaluate: {opt}" for opt in options],
            fcall_id=toolcall.fcall_id,
            fexp_name="evaluator",  # Must have kernel that sets subchat_result
        )

        raise ckit_cloudtool.WaitForSubchats(subchats)

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