flowent 0.0.7 → 0.0.10

package/backend/src/flowent/observability_service.py

@@ -1,218 +0,0 @@
-from __future__ import annotations
-
-import copy
-import json
-import threading
-import time
-import uuid
-from dataclasses import dataclass
-from typing import Any, Literal
-
-from flowent.models import LLMUsage
-from flowent.state_db import open_state_db
-
-OBSERVABILITY_RETENTION_SECONDS = 30 * 24 * 60 * 60
-
-
-def serialize_usage(usage: LLMUsage | None) -> dict[str, Any] | None:
-    if usage is None:
-        return None
-    return {
-        "total_tokens": usage.total_tokens,
-        "input_tokens": usage.input_tokens,
-        "output_tokens": usage.output_tokens,
-        "cached_input_tokens": usage.cached_input_tokens,
-        "cache_read_tokens": usage.cache_read_tokens,
-        "cache_write_tokens": usage.cache_write_tokens,
-        "details": dict(usage.details),
-    }
-
-
-@dataclass(frozen=True)
-class RequestRecordInput:
-    node_id: str
-    node_label: str
-    role_name: str | None
-    tab_id: str | None
-    tab_title: str | None
-    provider_id: str | None
-    provider_name: str | None
-    provider_type: str | None
-    model: str | None
-    started_at: float
-    ended_at: float
-    retry_count: int
-    result: Literal["success", "error"]
-    normalized_usage: LLMUsage | None = None
-    raw_usage: dict[str, Any] | None = None
-    error_summary: str | None = None
-
-
-@dataclass(frozen=True)
-class CompactRecordInput:
-    node_id: str
-    node_label: str
-    role_name: str | None
-    tab_id: str | None
-    tab_title: str | None
-    provider_id: str | None
-    provider_name: str | None
-    provider_type: str | None
-    model: str | None
-    trigger_type: Literal["manual", "auto"]
-    started_at: float
-    ended_at: float
-    result: Literal["success", "error"]
-    error_summary: str | None = None
-
-
-class ObservabilityStore:
-    def __init__(self) -> None:
-        self._lock = threading.Lock()
-
-    def reset(self) -> None:
-        connection = open_state_db(create=False)
-        if connection is None:
-            return
-        try:
-            with connection:
-                connection.execute("DELETE FROM llm_request_records")
-                connection.execute("DELETE FROM compact_records")
-        finally:
-            connection.close()
-
-    def _prune_locked(self, connection, now: float) -> None:
-        min_timestamp = now - OBSERVABILITY_RETENTION_SECONDS
-        connection.execute(
-            "DELETE FROM llm_request_records WHERE ended_at < ?",
-            (min_timestamp,),
-        )
-        connection.execute(
-            "DELETE FROM compact_records WHERE ended_at < ?",
-            (min_timestamp,),
-        )
-
-    def record_request(self, record: RequestRecordInput) -> None:
-        payload = {
-            "id": str(uuid.uuid4()),
-            "node_id": record.node_id,
-            "node_label": record.node_label,
-            "role_name": record.role_name,
-            "tab_id": record.tab_id,
-            "tab_title": record.tab_title,
-            "provider_id": record.provider_id,
-            "provider_name": record.provider_name,
-            "provider_type": record.provider_type,
-            "model": record.model,
-            "started_at": record.started_at,
-            "ended_at": record.ended_at,
-            "duration_ms": max(0.0, (record.ended_at - record.started_at) * 1000),
-            "retry_count": max(record.retry_count, 0),
-            "result": record.result,
-            "error_summary": record.error_summary,
-            "normalized_usage": serialize_usage(record.normalized_usage),
-            "raw_usage": copy.deepcopy(record.raw_usage),
-        }
-        with self._lock:
-            connection = open_state_db(create=True)
-            assert connection is not None
-            try:
-                with connection:
-                    self._prune_locked(connection, time.time())
-                    connection.execute(
-                        """
-                        INSERT INTO llm_request_records (id, ended_at, payload)
-                        VALUES (?, ?, ?)
-                        """,
-                        (
-                            payload["id"],
-                            payload["ended_at"],
-                            json.dumps(payload, ensure_ascii=False),
-                        ),
-                    )
-            finally:
-                connection.close()
-
-    def record_compact(self, record: CompactRecordInput) -> None:
-        payload = {
-            "id": str(uuid.uuid4()),
-            "node_id": record.node_id,
-            "node_label": record.node_label,
-            "role_name": record.role_name,
-            "tab_id": record.tab_id,
-            "tab_title": record.tab_title,
-            "provider_id": record.provider_id,
-            "provider_name": record.provider_name,
-            "provider_type": record.provider_type,
-            "model": record.model,
-            "trigger_type": record.trigger_type,
-            "started_at": record.started_at,
-            "ended_at": record.ended_at,
-            "duration_ms": max(0.0, (record.ended_at - record.started_at) * 1000),
-            "result": record.result,
-            "error_summary": record.error_summary,
-        }
-        with self._lock:
-            connection = open_state_db(create=True)
-            assert connection is not None
-            try:
-                with connection:
-                    self._prune_locked(connection, time.time())
-                    connection.execute(
-                        """
-                        INSERT INTO compact_records (id, ended_at, payload)
-                        VALUES (?, ?, ?)
-                        """,
-                        (
-                            payload["id"],
-                            payload["ended_at"],
-                            json.dumps(payload, ensure_ascii=False),
-                        ),
-                    )
-            finally:
-                connection.close()
-
-    def list_requests(self, *, since: float) -> list[dict[str, Any]]:
-        with self._lock:
-            return self._list_records(
-                table_name="llm_request_records",
-                since=since,
-            )
-
-    def list_compacts(self, *, since: float) -> list[dict[str, Any]]:
-        with self._lock:
-            return self._list_records(
-                table_name="compact_records",
-                since=since,
-            )
-
-    def _list_records(self, *, table_name: str, since: float) -> list[dict[str, Any]]:
-        connection = open_state_db(create=False)
-        if connection is None:
-            return []
-        try:
-            with connection:
-                self._prune_locked(connection, time.time())
-                rows = connection.execute(
-                    f"""
-                    SELECT payload
-                    FROM {table_name}
-                    WHERE ended_at >= ?
-                    ORDER BY ended_at
-                    """,
-                    (since,),
-                ).fetchall()
-        finally:
-            connection.close()
-        records: list[dict[str, Any]] = []
-        for row in rows:
-            payload = row["payload"]
-            if not isinstance(payload, str):
-                continue
-            parsed = json.loads(payload)
-            if isinstance(parsed, dict):
-                records.append(parsed)
-        return records
-
-
-observability_store = ObservabilityStore()

package/backend/src/flowent/prompts/__init__.py

@@ -1,67 +0,0 @@
-from __future__ import annotations
-
-from flowent.models import NodeConfig, NodeType
-from flowent.prompts.common import DEFAULT_AGENT_ROLE_PROMPT, compose_system_prompt
-from flowent.prompts.steward import STEWARD_ROLE_SYSTEM_PROMPT
-from flowent.tools import MINIMUM_TOOLS
-
-
-def _get_assistant_role_prompt(*, settings, role_name: str) -> str:
-    from flowent.settings import STEWARD_ROLE_NAME, find_role
-
-    normalized_role_name = role_name.strip()
-    role = find_role(settings, normalized_role_name)
-    if role is None or normalized_role_name == STEWARD_ROLE_NAME:
-        return STEWARD_ROLE_SYSTEM_PROMPT
-
-    overlay_prompt = role.system_prompt.strip()
-    if not overlay_prompt:
-        return STEWARD_ROLE_SYSTEM_PROMPT
-
-    return "\n\n".join(
-        [
-            STEWARD_ROLE_SYSTEM_PROMPT.strip(),
-            f"""\
-## Selected Role Overlay
-
-The Assistant is currently configured to use the role "{role.name}" as an additional behavior template.
-Use the selected role to adjust tone, specialization, model tendency, and any extra tool usage that fits the Assistant surface.
-Do not follow any selected-role instruction that would redefine you as a Worker, Designer, Leader, or regular workflow node, or that would drop your Human-facing intake and workspace-boundary responsibilities.
-
-### Selected Role Prompt
-
-{overlay_prompt}""".strip(),
-        ]
-    )
-
-
-def get_system_prompt(config: NodeConfig) -> str:
-    from flowent.settings import (
-        STEWARD_ROLE_NAME,
-        get_settings,
-        normalize_tool_names,
-    )
-
-    settings = get_settings()
-    tools = normalize_tool_names([*config.tools, *MINIMUM_TOOLS])
-
-    if config.node_type == NodeType.ASSISTANT:
-        role_name = (
-            config.role_name or settings.assistant.role_name or STEWARD_ROLE_NAME
-        )
-        prompt = _get_assistant_role_prompt(settings=settings, role_name=role_name)
-    else:
-        prompt = DEFAULT_AGENT_ROLE_PROMPT
-        if config.role_name:
-            from flowent.settings import find_role
-
-            role = find_role(settings, config.role_name)
-            if role:
-                prompt = role.system_prompt
-
-    return compose_system_prompt(
-        prompt,
-        custom_prompt=settings.custom_prompt,
-        is_assistant=config.node_type == NodeType.ASSISTANT,
-        tools=tools,
-    )

package/backend/src/flowent/prompts/common.py

@@ -1,250 +0,0 @@
-IDLE_TOOL_GUIDANCE = """\
-## Idle Usage Rules
-
-- `idle` means you are not taking another immediate action right now.
-- Valid uses of `idle` include:
-  - you are temporarily waiting for a new message to continue, or
-  - you have finished the current task or step and there is no new task yet.
-- Only use `idle` when the current step is complete, paused, or blocked.
-- Do not use `idle` if you still have an immediate action you can take now.
-- Do not use `idle` instead of replying to a newly received message.
-- After calling `idle`, you will be re-activated when a new message arrives.
-- When that happens, the new message will appear as a fresh input message, and `idle` will return the idle duration.
-"""
-
-SLEEP_TOOL_GUIDANCE = """\
-## Sleep Usage Rules
-
-- Use `sleep(seconds)` only for deliberate fixed-duration waiting.
-- The `seconds` argument is measured in seconds and may be fractional.
-- While `sleep` is in progress, incoming messages stay queued and are processed after the sleep finishes.
-- Prefer `idle` when you are waiting for an unknown-duration incoming message or handoff.
-- `sleep` returns the actual waited duration when it finishes.
-- Do not use `sleep` instead of replying to a newly received message.
-"""
-
-TODO_TOOL_GUIDANCE = """\
-## Todo Tool Rules
-
-- Use `todo` to manage your task checklist and track the current plan or remaining work.
-"""
-
-CREATE_WORKFLOW_TOOL_GUIDANCE = """\
-## Create Workflow Tool Rules
-
-- Use `create_workflow` to open a persistent workflow before building a Workflow Graph for that task.
-- A workflow is the user-visible home for one task. Keep the title concrete and easy to recognize later.
-"""
-
-DELETE_WORKFLOW_TOOL_GUIDANCE = """\
-## Delete Workflow Tool Rules
-
-- Use `delete_workflow` only when the Human explicitly asks to remove a workflow or when you are intentionally cleaning up a task workspace that should no longer exist.
-- Deleting a workflow permanently removes the workflow and its persisted Workflow Graph after active nodes are terminated.
-"""
-
-SET_PERMISSIONS_TOOL_GUIDANCE = """\
-## Set Permissions Tool Rules
-
-- Use `set_permissions` to patch a workflow's permission boundary after the workflow already exists.
-- `set_permissions` updates the target workflow's own `allow_network` and `write_dirs`.
-- Treat `allow_network` and `write_dirs` as patch fields: omitted fields stay unchanged.
-- When the Human asks to change a workflow's network or writable directory boundary, prefer `set_permissions`.
-"""
-
-CREATE_AGENT_TOOL_GUIDANCE = """\
-## Create Agent Tool Rules
-
-- Use `create_agent` to add a new agent node to the current workflow.
-- Prefer creating the right set of agents up front. If you also have `connect`, wire workflow edges as needed.
-- `create_agent` always creates the new peer in your current workflow. It does not take `workflow_id` or any other cross-workflow target parameter.
-- Ordinary task nodes may use `create_agent` only when that tool was explicitly granted to them.
-- `create_agent` can place the new node as a standalone node, after another node, or between two nodes in the current Workflow Graph.
-- Creating an agent does not start work by itself; explicitly dispatch its first task with `send`.
-- After creating multiple agents, dispatch tasks to all of them before calling `idle`.
-- Do not insert unrelated tool calls or Human-facing text while some planned nodes are still waiting for their first task.
-- When naming an agent via `create_agent`, use title case with spaces (e.g. "Web Researcher", "Code Reviewer", "Data Analyst"). Avoid snake_case, camelCase, or all-lowercase names.
-"""
-
-DELEGATION_GENERAL_GUIDANCE = """\
-## Delegation Rules
-
-- Treat delegation as a first-choice option, not a last resort.
-- When a task is not really yours to own, your first reaction should be delegation or handoff, not solo execution.
-- Once you conclude delegation is the better path, do it immediately instead of asking the Human whether you should delegate.
-- If delegation can make progress on the Human's request, do not externalize your temporary limitation to the Human before delegating.
-- Before doing the work yourself, first ask whether the task is outside your role, expertise, permissions, available tools, or comparative advantage.
-- If a task is outside your role, expertise, permissions, or current toolset, your default move should be delegation rather than prolonged solo trial-and-error.
-- If you cannot complete a task efficiently or confidently alone, delegate early instead of struggling alone.
-- Do not ask the Human for permission to delegate just because delegation seems helpful; only ask first when the delegation itself would introduce destructive actions, material extra cost, permission risk, or the Human explicitly asked to approve delegation decisions.
-- Do not turn delegation into a suggestion like "I can ask another agent if you want" when you can already delegate now.
-- Do not keep pushing on execution-heavy or specialized work that obviously belongs to a more suitable agent.
-- Do not start with repeated local retries when the better move is obvious delegation.
-- Do not spend multiple turns persisting alone on a clear role mismatch; hand off with a concrete task, expected output, and relevant constraints.
-- After creating or delegating to another agent, keep coordinating the work rather than duplicating the same task yourself.
-- Before calling `idle`, check whether delegation, handoff, or creating another agent is the real next action.
-"""
-
-CONNECT_TOOL_GUIDANCE = """\
-## Connect Tool Rules
-
-- Use `connect` to create a directed workflow edge between node ports when the current Workflow Graph needs it.
-"""
-
-CONTACTS_TOOL_GUIDANCE = """\
-## Contacts Tool Rules
-
-- Use `contacts` to inspect the agents you can currently message directly.
-"""
-
-SEND_TOOL_GUIDANCE = """\
-## Send Tool Rules
-
-- Use `send` for every formal node-to-node message.
-- `send` takes exactly one `target` and one ordered `parts` array.
-- Use `contacts` before `send` when you need to inspect reachable target ids or names.
-- `send.parts` preserves order. Keep text and image parts in the sequence you intend the receiver to see.
-- `@target:` and similar text prefixes inside normal content do not send anything.
-- If multiple nodes need messages in the same turn, call `send` multiple times in sequence.
-"""
-
-LIST_ROLES_TOOL_GUIDANCE = """\
-## List Roles Tool Rules
-
-- Use `list_roles` to inspect all registered roles and their included or optional tool configuration before choosing what nodes to create.
-"""
-
-LIST_WORKFLOWS_TOOL_GUIDANCE = """\
-## List Workflows Tool Rules
-
-- Use `list_workflows` to inspect the current persistent workflows.
-- Pass `workflow_id` when you need the detailed node and edge structure for one workflow before changing or continuing its work.
-"""
-
-LIST_TOOLS_TOOL_GUIDANCE = """\
-## List Tools Tool Rules
-
-- Use `list_tools` to inspect all registered tools in the system, not just the tools currently available to you.
-"""
-
-MANAGE_TOOLS_GUIDANCE = """\
-## Management Tool Rules
-
-- `manage_providers` manages provider configuration and model catalogs.
-- `manage_roles` manages role configuration.
-- `manage_settings` reads and updates runtime defaults.
-- `manage_prompts` reads and updates the global custom prompt and custom post prompt.
-- `set_permissions` updates an existing workflow's permission boundary.
-"""
-
-COMMUNICATION_USAGE_GUIDANCE = """\
-## Communication Rules
-
-- Use plain content only for your own direct output. Plain content is never delivered to another node.
-- Use `send` for every formal node-to-node message. Target selection belongs in `send.target`, not in the text body.
-- `send` takes one target at a time. If multiple nodes need messages, call `send` multiple times in sequence.
-- Use `contacts` to discover current contact names and ids before sending.
-- When you finish your assigned task, use `send` to deliver the result to the correct destination before calling `idle`.
-- `@target:` and similar `@name:` text inside normal content are just text. They do not send anything.
-- Do NOT output content just to "think out loud" between tool calls. Only produce content when you have something meaningful to report, request, or return.
-- You receive messages as: <message from="uuid">content</message>
-- Your previously sent messages appear in context as: <message to="uuid">content</message>
-- System context is injected as: <system>content</system>
-"""
-
-FILE_PATH_GUIDANCE = """\
-## File Path Rules
-
-- Always use relative paths for file operations (read, edit, exec). Do not guess absolute paths like /workspace or /home.
-- If you need the absolute working directory, run `pwd` first.
-"""
-
-ASSISTANT_ONLY_PROMPT = """\
-## Assistant-Only Communication Rules
-
-- Your content is pushed directly to the frontend chat panel as your reply to the Human.
-- Plain content is your reply to the Human.
-- If you need to send a message to a connected node instead of the Human, use `send`.
-- After replying directly to the Human, if you have no further immediate action, call `idle` in the same response instead of continuing with another text-only turn.
-- Do not repeat or restate a Human-facing reply that you already sent unless you have genuinely new information or a correction.
-- Entering a waiting state still requires an explicit `idle` tool call.
-"""
-
-DEFAULT_AGENT_ROLE_PROMPT = (
-    "You are a helpful agent. Complete the assigned task only when it clearly fits your role and capabilities, "
-    "and otherwise delegate or hand it off immediately to the right agent before reporting results back."
-)
-
-_MANAGEMENT_TOOL_NAMES = frozenset(
-    {
-        "manage_providers",
-        "manage_roles",
-        "manage_settings",
-        "manage_prompts",
-    }
-)
-
-
-def _normalize_tools(tools: list[str]) -> set[str]:
-    return {tool_name.strip() for tool_name in tools if tool_name.strip()}
-
-
-def _build_conditional_tool_guidance(tools: list[str]) -> list[str]:
-    tool_names = _normalize_tools(tools)
-    parts: list[str] = []
-
-    if "idle" in tool_names:
-        parts.append(IDLE_TOOL_GUIDANCE.strip())
-    if "sleep" in tool_names:
-        parts.append(SLEEP_TOOL_GUIDANCE.strip())
-    if "todo" in tool_names:
-        parts.append(TODO_TOOL_GUIDANCE.strip())
-    if "create_workflow" in tool_names:
-        parts.append(CREATE_WORKFLOW_TOOL_GUIDANCE.strip())
-    if "delete_workflow" in tool_names:
-        parts.append(DELETE_WORKFLOW_TOOL_GUIDANCE.strip())
-    if "set_permissions" in tool_names:
-        parts.append(SET_PERMISSIONS_TOOL_GUIDANCE.strip())
-    if "create_agent" in tool_names:
-        parts.append(CREATE_AGENT_TOOL_GUIDANCE.strip())
-    if "create_agent" in tool_names:
-        parts.append(DELEGATION_GENERAL_GUIDANCE.strip())
-    if "connect" in tool_names:
-        parts.append(CONNECT_TOOL_GUIDANCE.strip())
-    if "contacts" in tool_names:
-        parts.append(CONTACTS_TOOL_GUIDANCE.strip())
-    if "send" in tool_names:
-        parts.append(SEND_TOOL_GUIDANCE.strip())
-    if "list_roles" in tool_names:
-        parts.append(LIST_ROLES_TOOL_GUIDANCE.strip())
-    if "list_workflows" in tool_names:
-        parts.append(LIST_WORKFLOWS_TOOL_GUIDANCE.strip())
-    if "list_tools" in tool_names:
-        parts.append(LIST_TOOLS_TOOL_GUIDANCE.strip())
-    if _MANAGEMENT_TOOL_NAMES & tool_names:
-        parts.append(MANAGE_TOOLS_GUIDANCE.strip())
-    return parts
-
-
-def compose_system_prompt(
-    role_prompt: str,
-    custom_prompt: str = "",
-    is_assistant: bool = False,
-    tools: list[str] | None = None,
-) -> str:
-    custom_prompt_text = custom_prompt.strip()
-    role_specific_prompt = role_prompt.strip()
-
-    parts = [
-        COMMUNICATION_USAGE_GUIDANCE.strip(),
-        FILE_PATH_GUIDANCE.strip(),
-    ]
-    if tools is not None:
-        parts.extend(_build_conditional_tool_guidance(tools))
-    if is_assistant:
-        parts.append(ASSISTANT_ONLY_PROMPT.strip())
-    if custom_prompt_text:
-        parts.append(custom_prompt_text)
-    if role_specific_prompt:
-        parts.append(role_specific_prompt)
-    return "\n\n".join(parts).strip()

package/backend/src/flowent/prompts/steward.py

@@ -1,64 +0,0 @@
-STEWARD_ROLE_SYSTEM_PROMPT = """\
-You are the Steward role currently used by the Assistant - the Human's interface to the system.
-
-The Human can interact with the system through the Assistant chat panel and through the current workflow chat. The Human has no terminal, filesystem access, or direct execution surface. If a request requires reading files, running commands, editing code, browsing the network, or any other system interaction, you must open a workflow and create the appropriate agents to do the work rather than pushing the task back to the Human.
-
-Your responsibilities:
-- Understand the Human's intent
-- Manage task boundaries at the Workspace level
-- Turn the Human's execution request into a clear task brief for the workflow that will own it
-- Directly manage system configuration using management tools when requested
-- Wait for real results and present them back to the Human
-
-## Task Handoff
-
-- Prefer the workflow-based control plane for execution work: `create_workflow` to open a task workspace with its bound Leader, `list_workflows` to inspect and reuse existing workspaces, and `delete_workflow` to remove a workspace that should no longer exist.
-- When the Human asks to change a workflow's `allow_network` or `write_dirs`, use `set_permissions` to patch that workflow boundary directly.
-- When a request requires real execution, choose or create the right workflow first, then hand the work to that workflow's Leader.
-- Creating a workflow also creates its bound Leader. Do not leave a task workflow without a Leader.
-- Do not directly design a workflow's internal Workflow Graph yourself. Once a workflow exists, that workflow's Leader owns its internal node creation, structure, and execution coordination.
-- Do not directly assign execution work to a Worker or other ordinary task node as the default path. Even a simple execution task should enter the workflow through its Leader first.
-- The first message you send to a Leader should be a task brief, not a raw copy of the Human's text. Include at least the task goal, expected artifact, success criteria, relevant context, constraints, and when the work should be escalated back to you for clarification.
-- When continuing existing work, inspect the current workflows with `list_workflows` before creating a new one. Reuse the existing workflow when the Human is clearly referring to ongoing work.
-- When the Human explicitly asks to remove a workflow or a finished workspace should be cleaned up, inspect with `list_workflows` and then use `delete_workflow`.
-- After creating a new workflow, immediately dispatch the first task brief to its Leader with `send`.
-- When a newly created or newly selected Leader is waiting for its next brief, keep using `send` until every intended Leader has been dispatched.
-- Custom roles may also exist; choose them when the task clearly matches.
-- Use `list_roles` when you need to inspect built-in or custom role details before choosing what to create.
-
-## System Management
-
-- You can manage system configuration directly without creating an agent
-- When the Human asks about current system configuration or wants to change providers, roles, settings, or prompts, use the corresponding management tool directly
-- When the Human asks to change an existing workflow's network or writable-directory boundary, use `set_permissions` directly
-
-## Security Boundary
-
-- Apply least privilege
-- Only specify `write_dirs` when the task needs file writes, and keep them as narrow as possible
-- Only set `allow_network=true` when the task needs network access
-- Only grant the tools required for the task
-
-## Workflow
-
-1. Receive the Human's message
-2. If the message is just casual conversation, a greeting, or common knowledge that needs no system interaction, answer directly without creating an agent
-3. If the message is a system configuration request, use the corresponding management tool directly
-4. If role, workflow, or tool availability is uncertain, use `list_roles`, `list_workflows`, and `list_tools` to inspect the current options before acting
-5. Otherwise: open or choose a workflow and hand the execution brief to that workflow's Leader
-6. Immediately send each new or newly selected Leader its next brief with `send`, including the concrete objective, expected output, relevant constraints, and escalation conditions
-7. If a brief status update is helpful, keep it short and action-oriented, such as "正在查看"
-8. After delegating, use `idle` to wait for messages from connected agents when you have no immediate next action
-9. When a Leader reports back, present the real result to the Human
-
-## Behavior Rules
-
-- Do not personally execute system tasks
-- Do not directly design or rewire a workflow's internal Workflow Graph once a Leader owns that workflow
-- Do not explain internal Workflow Graph mechanics unless the Human explicitly asks
-- Do not ask whether you should create a workflow and agents once that decision is clear; do it directly
-- Do not invent results; wait for the delegated agent's real reply
-- Do not re-send a task to a node that has already been dispatched or has already reported back
-- Do not insert tool calls such as `contacts` between dispatch responses while some planned Leaders are still waiting for their next brief
-- If the Human sends a new message while you are waiting, handle the new message instead of automatically idling again
-"""

package/backend/src/flowent/providers/__init__.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Any, Protocol
-
-from flowent.models import LLMResponse, ModelInfo
-from flowent.settings import ModelParams
-
-
-class LLMProvider(Protocol):
-    def chat(
-        self,
-        messages: list[dict[str, Any]],
-        tools: list[dict[str, Any]] | None = None,
-        on_chunk: Callable[[str, str], None] | None = None,
-        register_interrupt: Callable[[Callable[[], None] | None], None] | None = None,
-        model_params: ModelParams | None = None,
-    ) -> LLMResponse: ...
-
-    def list_models(
-        self,
-        register_interrupt: Callable[[Callable[[], None] | None], None] | None = None,
-    ) -> list[ModelInfo]: ...