flowent 0.0.4 → 0.0.5

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

@@ -12,6 +12,7 @@ from flowent.settings import (
     build_model_context_window_tokens,
     build_model_input_image,
     build_model_output_image,
+    build_model_structured_output,
     build_provider_headers,
     build_provider_retry_429_delay_seconds,
     serialize_provider_model_catalog_entry,
@@ -27,6 +28,7 @@ class ProviderModelCatalogPayload(Protocol):
     context_window_tokens: int | None
     input_image: bool | None
     output_image: bool | None
+    structured_output: bool | None
 
 
 def validate_provider_base_url_input(
@@ -72,6 +74,10 @@ def build_provider_model_catalog_entry(
             payload.output_image,
             field_name=f"{field_name_prefix}.output_image",
         ),
+        structured_output=build_model_structured_output(
+            payload.structured_output,
+            field_name=f"{field_name_prefix}.structured_output",
+        ),
     )
 
 
@@ -178,5 +184,6 @@ def serialize_discovered_model_catalog_entry(model: ModelInfo) -> dict[str, obje
             context_window_tokens=model.context_window_tokens,
             input_image=model.capabilities.input_image,
             output_image=model.capabilities.output_image,
+            structured_output=model.capabilities.structured_output,
         )
     )

package/backend/src/flowent/role_management.py

@@ -67,6 +67,11 @@ def resolve_role_tool_config(
     included_tools: list[str] | None,
     excluded_tools: list[str] | None,
 ) -> tuple[list[str], list[str]]:
+    from flowent.tools import (
+        is_assistant_only_mcp_tool_name,
+        is_assistant_only_tool_name,
+    )
+
     next_included = normalize_tool_names(
         included_tools
         if included_tools is not None
@@ -74,6 +79,13 @@ def resolve_role_tool_config(
         if current
         else []
     )
+    if included_tools is not None:
+        next_included = [
+            tool_name
+            for tool_name in next_included
+            if not is_assistant_only_tool_name(tool_name)
+            and not is_assistant_only_mcp_tool_name(tool_name)
+        ]
     next_excluded = normalize_tool_names(
         excluded_tools
         if excluded_tools is not None

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

@@ -10,7 +10,6 @@ from flowent.routes.prompts import router as prompts_router
 from flowent.routes.providers_route import router as providers_router
 from flowent.routes.roles import router as roles_router
 from flowent.routes.settings import router as settings_router
-from flowent.routes.stats import router as stats_router
 from flowent.routes.tabs import router as tabs_router
 from flowent.routes.ws import router as ws_router
 
@@ -24,7 +23,6 @@ router.include_router(roles_router)
 router.include_router(providers_router)
 router.include_router(prompts_router)
 router.include_router(settings_router)
-router.include_router(stats_router)
 router.include_router(tabs_router)
 router.include_router(meta_router)
 router.include_router(ws_router)

package/backend/src/flowent/routes/assistant.py

@@ -7,8 +7,8 @@ from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 
 from flowent.assistant_commands import (
-    AssistantCommandError,
-    execute_assistant_command_input,
+    ConversationCommandError,
+    execute_conversation_command_input,
 )
 from flowent.image_assets import require_image_asset
 from flowent.models import (
@@ -110,11 +110,11 @@ async def send_assistant_message(req: AssistantMessageRequest) -> dict:
 
     try:
         executed_command = (
-            execute_assistant_command_input(assistant, command_input)
+            execute_conversation_command_input(assistant, command_input)
             if isinstance(command_input, str)
             else None
         )
-    except AssistantCommandError as exc:
+    except ConversationCommandError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
     except (RuntimeError, TimeoutError, LLMProviderError) as exc:
         raise HTTPException(status_code=409, detail=str(exc)) from exc

package/backend/src/flowent/routes/nodes.py

@@ -5,7 +5,17 @@ from typing import Literal
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 
-from flowent.graph_service import is_tab_leader, list_node_connection_ids
+from flowent.assistant_commands import (
+    ConversationCommandError,
+    execute_conversation_command_input,
+)
+from flowent.graph_service import (
+    is_tab_leader,
+    list_node_connection_ids,
+    resolve_effective_permissions_for_agent,
+    resolve_effective_permissions_for_node_record,
+)
+from flowent.providers.errors import LLMProviderError
 from flowent.registry import registry
 from flowent.settings import (
     find_provider,
@@ -196,11 +206,15 @@ async def get_node(node_id: str) -> dict:
         record_id = node.uuid
         record_state = node.state
         target_config = node.config
+        allow_network, write_dirs = resolve_effective_permissions_for_agent(node)
     else:
         assert record is not None
         record_id = record.id
         record_state = record.state
         target_config = record.config
+        allow_network, write_dirs = resolve_effective_permissions_for_node_record(
+            record
+        )
     history = (
         node.get_history_snapshot()
         if node is not None
@@ -219,7 +233,7 @@ async def get_node(node_id: str) -> dict:
         "role_name": target_config.role_name,
         "is_leader": is_tab_leader(node_id=record_id, tab_id=target_config.tab_id),
         "state": record_state.value,
-        "contacts": node.get_contact_ids_snapshot() if node is not None else [],
+        "contacts": node.get_contacts_info() if node is not None else [],
         "connections": (
             list_node_connection_ids(
                 tab_id=target_config.tab_id,
@@ -232,8 +246,12 @@ async def get_node(node_id: str) -> dict:
         "todos": [t.serialize() for t in todos],
         "capabilities": _serialize_model_capabilities(target_config.role_name),
         "tools": sorted(set(target_config.tools) | set(MINIMUM_TOOLS)),
-        "write_dirs": list(target_config.write_dirs),
-        "allow_network": target_config.allow_network,
+        "write_dirs": list(write_dirs),
+        "allow_network": allow_network,
+        "workflow_permissions": {
+            "allow_network": allow_network,
+            "write_dirs": list(write_dirs),
+        },
         "position": record.position.serialize()
         if record is not None and record.position is not None
         else None,
@@ -304,8 +322,14 @@ async def clear_node_chat(node_id: str) -> dict:
     node = registry.get(node_id)
     if node is None:
         raise HTTPException(status_code=404, detail="Node not found")
-    if node.config.node_type != NodeType.ASSISTANT:
-        raise HTTPException(status_code=400, detail="Can only clear assistant chat")
+    if node.config.node_type != NodeType.ASSISTANT and not is_tab_leader(
+        node_id=node.uuid,
+        tab_id=node.config.tab_id,
+    ):
+        raise HTTPException(
+            status_code=400,
+            detail="Can only clear Assistant or workflow chats",
+        )
 
     try:
         node.clear_chat_history()
@@ -321,6 +345,7 @@ async def clear_node_chat(node_id: str) -> dict:
 async def dispatch_node_message(node_id: str, req: DispatchNodeMessageRequest) -> dict:
     from flowent.graph_service import dispatch_node_message
     from flowent.models import NodeType, content_parts_to_text, has_image_parts
+    from flowent.models import TextPart as ModelTextPart
 
     node = registry.get(node_id)
     if node is None:
@@ -354,6 +379,29 @@ async def dispatch_node_message(node_id: str, req: DispatchNodeMessageRequest) -
             detail="Current model does not support `input_image`.",
         )
 
+    command_input = (
+        parts[0].text
+        if len(parts) == 1 and isinstance(parts[0], ModelTextPart)
+        else None
+    )
+
+    try:
+        executed_command = (
+            execute_conversation_command_input(node, command_input)
+            if isinstance(command_input, str)
+            else None
+        )
+    except ConversationCommandError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except (RuntimeError, TimeoutError, LLMProviderError) as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+    if executed_command is not None:
+        return {
+            "status": "command_executed",
+            "command_name": executed_command.command_name,
+        }
+
     error, message_id = dispatch_node_message(
         node_id=node_id,
         content=content_parts_to_text(parts),

package/backend/src/flowent/routes/providers_route.py

@@ -39,6 +39,7 @@ class ProviderModelRequest(BaseModel):
     context_window_tokens: int | None = None
     input_image: bool | None = None
     output_image: bool | None = None
+    structured_output: bool | None = None
 
 
 class CreateProviderRequest(BaseModel):

package/backend/src/flowent/routes/roles.py

@@ -70,7 +70,7 @@ async def get_roles_bootstrap() -> dict[str, object]:
     return {
         "roles": [serialize_role(role) for role in settings.roles],
         "providers": [serialize_provider(provider) for provider in settings.providers],
-        "tools": list_agent_visible_tool_descriptors(),
+        "tools": list_agent_visible_tool_descriptors(include_assistant_only=False),
     }
 
 

package/backend/src/flowent/routes/settings.py

@@ -138,6 +138,7 @@ async def update_settings(req: UpdateSettingsRequest) -> dict[str, object]:
     context_window_tokens: object = MISSING
     input_image: object = MISSING
     output_image: object = MISSING
+    structured_output: object = MISSING
     timeout_ms: object = MISSING
     retry_policy: object = MISSING
     max_retries: object = MISSING
@@ -159,6 +160,8 @@ async def update_settings(req: UpdateSettingsRequest) -> dict[str, object]:
             input_image = req.model.get("input_image")
         if "output_image" in req.model:
             output_image = req.model.get("output_image")
+        if "structured_output" in req.model:
+            structured_output = req.model.get("structured_output")
         if "timeout_ms" in req.model:
             timeout_ms = req.model.get("timeout_ms")
         if "retry_policy" in req.model:
@@ -189,6 +192,7 @@ async def update_settings(req: UpdateSettingsRequest) -> dict[str, object]:
             context_window_tokens=context_window_tokens,
             input_image=input_image,
             output_image=output_image,
+            structured_output=structured_output,
             max_retries=max_retries,
             retry_policy=retry_policy,
             timeout_ms=timeout_ms,

package/backend/src/flowent/routes/tabs.py

@@ -4,10 +4,12 @@ from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel, ConfigDict
 
 from flowent.graph_service import (
+    activate_tab,
     create_agent_node,
     create_edge,
     create_graph_node,
     create_tab,
+    deactivate_tab,
     delete_agent_node,
     delete_edge,
     delete_tab,
@@ -18,7 +20,7 @@ from flowent.graph_service import (
     serialize_tab_summary,
     update_tab_definition,
 )
-from flowent.models import AgentState, EdgeKind, WorkflowNodeKind
+from flowent.models import AgentState, WorkflowNodeKind
 from flowent.registry import registry
 from flowent.workspace_store import workspace_store
 
@@ -39,8 +41,6 @@ class CreateTabNodeRequest(BaseModel):
     name: str | None = None
     config: dict[str, object] = {}
     tools: list[str] = []
-    write_dirs: list[str] = []
-    allow_network: bool = False
 
 
 class CreateTabEdgeRequest(BaseModel):
@@ -49,7 +49,7 @@ class CreateTabEdgeRequest(BaseModel):
     from_port_key: str = "out"
     to_node_id: str
     to_port_key: str = "in"
-    kind: str = EdgeKind.CONTROL.value
+    kind: str | None = None
 
 
 class UpdateTabDefinitionRequest(BaseModel):
@@ -136,6 +136,30 @@ async def duplicate_workflow_route(tab_id: str) -> dict[str, object]:
     return serialize_tab_summary(duplicated)
 
 
+@router.post("/api/workflows/{tab_id}/activate")
+async def activate_workflow_route(tab_id: str) -> dict[str, object]:
+    updated, errors, error = activate_tab(tab_id=tab_id, actor_id=tab_id)
+    if errors:
+        raise HTTPException(status_code=400, detail={"errors": errors})
+    if error is not None or updated is None:
+        raise HTTPException(
+            status_code=404 if error and error.endswith("not found") else 400,
+            detail=error or "Failed to activate workflow",
+        )
+    return serialize_tab_summary(updated)
+
+
+@router.post("/api/workflows/{tab_id}/deactivate")
+async def deactivate_workflow_route(tab_id: str) -> dict[str, object]:
+    updated, error = deactivate_tab(tab_id=tab_id, actor_id=tab_id)
+    if error is not None or updated is None:
+        raise HTTPException(
+            status_code=404 if error and error.endswith("not found") else 400,
+            detail=error or "Failed to deactivate workflow",
+        )
+    return serialize_tab_summary(updated)
+
+
 @router.get("/api/workflows/{tab_id}")
 async def get_workflow(tab_id: str) -> dict[str, object]:
     tab = workspace_store.get_tab(tab_id)
@@ -201,8 +225,6 @@ async def create_workflow_node(
             tab_id=tab_id,
             name=req.name,
             tools=req.tools,
-            write_dirs=req.write_dirs,
-            allow_network=req.allow_network,
         )
         if error is not None or record is None:
             raise HTTPException(
@@ -236,17 +258,13 @@ async def create_workflow_edge(
     tab = workspace_store.get_tab(tab_id)
     if tab is None:
         raise HTTPException(status_code=404, detail="Workflow not found")
-    try:
-        edge_kind = EdgeKind(req.kind.strip())
-    except ValueError as exc:
-        raise HTTPException(status_code=400, detail="Invalid edge kind") from exc
     edge, error = create_edge(
         tab_id=tab_id,
         from_node_id=req.from_node_id,
         from_port_key=req.from_port_key,
         to_node_id=req.to_node_id,
         to_port_key=req.to_port_key,
-        kind=edge_kind,
+        kind=req.kind or "",
     )
     if error is not None or edge is None:
         raise HTTPException(status_code=400, detail=error or "Failed to create edge")

package/backend/src/flowent/runtime.py

@@ -48,9 +48,10 @@ def bootstrap_runtime() -> None:
     from flowent.graph_service import (
         build_assistant_tools,
         ensure_tab_leaders,
+        resolve_effective_permissions_for_node_record,
     )
     from flowent.mcp_service import mcp_service
-    from flowent.models import AgentState, NodeConfig, NodeType, StateEntry
+    from flowent.models import AgentState, NodeConfig, NodeType
     from flowent.settings import (
         ensure_builtin_roles,
         get_settings,
@@ -94,20 +95,6 @@ def bootstrap_runtime() -> None:
             summary=assistant_record.execution_context_summary,
             history_cutoff=assistant_record.execution_context_history_cutoff,
         )
-        if not any(isinstance(entry, StateEntry) for entry in assistant.history):
-            assistant.history.insert(
-                0,
-                StateEntry(state=assistant_record.state.value, reason="restored"),
-            )
-        if assistant_record.state in {
-            AgentState.INITIALIZING,
-            AgentState.IDLE,
-            AgentState.RUNNING,
-            AgentState.SLEEPING,
-        }:
-            assistant.history.append(
-                StateEntry(state=AgentState.IDLE.value, reason="restored")
-            )
         assistant.todos = list(assistant_record.todos)
         assistant.prime_runtime_state(
             AgentState.ERROR
@@ -126,6 +113,9 @@ def bootstrap_runtime() -> None:
             continue
         if record.state == AgentState.TERMINATED:
             continue
+        allow_network, write_dirs = resolve_effective_permissions_for_node_record(
+            record
+        )
         node = Agent(
             NodeConfig(
                 node_type=record.config.node_type,
@@ -133,8 +123,8 @@ def bootstrap_runtime() -> None:
                 tab_id=record.config.tab_id,
                 name=record.config.name,
                 tools=list(record.config.tools),
-                write_dirs=list(record.config.write_dirs),
-                allow_network=record.config.allow_network,
+                write_dirs=write_dirs,
+                allow_network=allow_network,
             ),
             uuid=record.id,
         )
@@ -143,19 +133,6 @@ def bootstrap_runtime() -> None:
             summary=record.execution_context_summary,
             history_cutoff=record.execution_context_history_cutoff,
         )
-        if not any(isinstance(entry, StateEntry) for entry in node.history):
-            node.history.insert(
-                0,
-                StateEntry(state=record.state.value, reason="restored"),
-            )
-        if record.state in {
-            AgentState.INITIALIZING,
-            AgentState.RUNNING,
-            AgentState.SLEEPING,
-        }:
-            node.history.append(
-                StateEntry(state=AgentState.IDLE.value, reason="restored")
-            )
         node.todos = list(record.todos)
         node.prime_runtime_state(
             AgentState.ERROR if record.state == AgentState.ERROR else AgentState.IDLE

package/backend/src/flowent/security.py

@@ -9,6 +9,18 @@ if TYPE_CHECKING:
 
 
 def authorize(tool_name: str, agent: Agent, args: dict[str, Any]) -> str | None:
+    from flowent.graph_service import resolve_effective_permissions_for_agent
+    from flowent.models import NodeType
+    from flowent.tools import (
+        is_assistant_only_mcp_tool_name,
+        is_assistant_only_tool_name,
+    )
+
+    if agent.node_type != NodeType.ASSISTANT and is_assistant_only_tool_name(tool_name):
+        return "Ask the Assistant to manage workflows or settings"
+
+    allow_network, write_dirs = resolve_effective_permissions_for_agent(agent)
+
     if tool_name.startswith("mcp__"):
         from flowent.mcp_service import mcp_service
         from flowent.settings import find_mcp_server, get_settings
@@ -16,27 +28,30 @@ def authorize(tool_name: str, agent: Agent, args: dict[str, Any]) -> str | None:
         descriptor = mcp_service.get_dynamic_tool_descriptor(tool_name)
         if descriptor is None:
             return f"MCP tool not found: {tool_name}"
+        if agent.node_type != NodeType.ASSISTANT and is_assistant_only_mcp_tool_name(
+            descriptor.tool_name
+        ):
+            return "Ask the Assistant to manage workflows or settings"
         server = find_mcp_server(get_settings(), descriptor.server_name)
         if (
             server is not None
             and server.transport == "streamable_http"
-            and not agent.config.allow_network
+            and not allow_network
         ):
-            return "Network access is disabled for this agent"
-        if descriptor.open_world_hint and not agent.config.allow_network:
-            return "Network access is disabled for this agent"
+            return "Network access is disabled for this workflow"
+        if descriptor.open_world_hint and not allow_network:
+            return "Network access is disabled for this workflow"
         return None
 
     if tool_name == "edit":
-        write_dirs = agent.config.write_dirs
         if not write_dirs:
-            return "Write access is disabled for this agent"
+            return "Write access is disabled for this workflow"
         path = args.get("path")
         if isinstance(path, str) and not is_path_writable(path, write_dirs):
             return f"Path not in write_dirs: {path}"
         return None
 
-    if tool_name == "fetch" and not agent.config.allow_network:
-        return "Network access is disabled for this agent"
+    if tool_name == "fetch" and not allow_network:
+        return "Network access is disabled for this workflow"
 
     return None