flowent 0.0.1 → 0.0.5

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

@@ -0,0 +1,365 @@
+from __future__ import annotations
+
+import time
+
+from fastapi import APIRouter, HTTPException
+from loguru import logger
+from pydantic import BaseModel, Field
+from starlette.concurrency import run_in_threadpool
+
+from flowent.models import ModelInfo
+from flowent.network import truncate_text
+from flowent.providers.configuration import (
+    build_provider_config,
+    coerce_provider_model_catalog,
+    serialize_discovered_model_catalog_entry,
+    serialize_provider,
+)
+from flowent.providers.management import (
+    ProviderNotFoundError,
+    create_provider_entry,
+    delete_provider_entry,
+    list_provider_payloads,
+    update_provider_entry,
+)
+from flowent.providers.registry import create_provider as create_llm_provider
+from flowent.settings import (
+    ProviderConfig,
+    find_provider,
+    get_settings,
+    save_settings,
+)
+
+router = APIRouter()
+
+
+class ProviderModelRequest(BaseModel):
+    model: str
+    source: str = "manual"
+    context_window_tokens: int | None = None
+    input_image: bool | None = None
+    output_image: bool | None = None
+    structured_output: bool | None = None
+
+
+class CreateProviderRequest(BaseModel):
+    name: str
+    type: str
+    base_url: str
+    api_key: str = ""
+    headers: dict[str, object] | None = None
+    retry_429_delay_seconds: int = 0
+    models: list[ProviderModelRequest] = Field(default_factory=list)
+
+
+class UpdateProviderRequest(BaseModel):
+    name: str | None = None
+    type: str | None = None
+    base_url: str | None = None
+    api_key: str | None = None
+    headers: dict[str, object] | None = None
+    retry_429_delay_seconds: int | None = None
+    models: list[ProviderModelRequest] | None = None
+
+
+class ProviderDraftRequest(BaseModel):
+    provider_id: str | None = None
+    name: str | None = None
+    type: str | None = None
+    base_url: str | None = None
+    api_key: str | None = None
+    headers: dict[str, object] | None = None
+
+
+class ListModelsRequest(ProviderDraftRequest):
+    pass
+
+
+class ProviderModelTestRequest(ProviderDraftRequest):
+    model: str
+
+
+def _has_draft_provider_fields(req: ProviderDraftRequest) -> bool:
+    return any(
+        value is not None
+        for value in (
+            req.name,
+            req.type,
+            req.base_url,
+            req.api_key,
+            req.headers,
+        )
+    )
+
+
+def _resolve_provider_from_request(req: ProviderDraftRequest) -> ProviderConfig:
+    settings = get_settings()
+    saved_provider = (
+        find_provider(settings, req.provider_id)
+        if req.provider_id is not None
+        else None
+    )
+    if (
+        req.provider_id is not None
+        and saved_provider is None
+        and not _has_draft_provider_fields(req)
+    ):
+        raise HTTPException(status_code=404, detail="Provider not found")
+
+    provider_type = (
+        req.type.strip()
+        if isinstance(req.type, str) and req.type.strip()
+        else saved_provider.type
+        if saved_provider is not None
+        else ""
+    )
+    if not provider_type:
+        raise HTTPException(status_code=400, detail="provider type is required")
+
+    base_url = (
+        req.base_url.strip()
+        if isinstance(req.base_url, str) and req.base_url.strip()
+        else saved_provider.base_url
+        if saved_provider is not None
+        else ""
+    )
+    if not base_url:
+        raise HTTPException(status_code=400, detail="provider base_url is required")
+
+    try:
+        return build_provider_config(
+            provider_id=(
+                saved_provider.id
+                if saved_provider is not None
+                else req.provider_id or ""
+            ),
+            name=(
+                req.name
+                if isinstance(req.name, str)
+                else saved_provider.name
+                if saved_provider is not None
+                else ""
+            ),
+            provider_type=provider_type,
+            base_url=base_url,
+            api_key=(
+                req.api_key
+                if isinstance(req.api_key, str)
+                else saved_provider.api_key
+                if saved_provider is not None
+                else ""
+            ),
+            raw_headers=(
+                req.headers
+                if req.headers is not None
+                else saved_provider.headers
+                if saved_provider is not None
+                else {}
+            ),
+            raw_retry_429_delay_seconds=(
+                saved_provider.retry_429_delay_seconds
+                if saved_provider is not None
+                else 0
+            ),
+            models=list(saved_provider.models) if saved_provider is not None else [],
+            base_url_required_message="provider base_url is required",
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
+def _list_models_with_provider(provider: ProviderConfig) -> list[ModelInfo]:
+    llm_provider = create_llm_provider(
+        provider_type=provider.type,
+        base_url=provider.base_url,
+        api_key=provider.api_key,
+        headers=provider.headers,
+        model="",
+        provider_name=provider.name,
+        request_timeout_seconds=120.0,
+    )
+    return llm_provider.list_models()
+
+
+def _summarize_provider_error(error: Exception) -> str:
+    detail = str(error).strip()
+    if not detail:
+        return "Provider test failed"
+
+    for line in detail.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("Detail:"):
+            normalized = stripped.removeprefix("Detail:").strip()
+            if normalized:
+                return truncate_text(normalized, limit=240)
+
+    first_line = next(
+        (line.strip() for line in detail.splitlines() if line.strip()), ""
+    )
+    if not first_line or first_line.lower().startswith("traceback"):
+        return "Provider returned an unexpected error response"
+    return truncate_text(first_line, limit=240)
+
+
+def _test_provider_model(provider: ProviderConfig, model: str) -> dict[str, object]:
+    settings = get_settings()
+    llm_provider = create_llm_provider(
+        provider_type=provider.type,
+        base_url=provider.base_url,
+        api_key=provider.api_key,
+        headers=provider.headers,
+        model=model,
+        provider_name=provider.name,
+        request_timeout_seconds=max(settings.model.timeout_ms / 1000, 1.0),
+    )
+    started_at = time.perf_counter()
+    llm_provider.chat(
+        [{"role": "user", "content": "Reply with OK."}],
+    )
+    ended_at = time.perf_counter()
+    return {
+        "ok": True,
+        "duration_ms": int((ended_at - started_at) * 1000),
+    }
+
+
+@router.get("/api/providers")
+async def list_providers() -> dict[str, object]:
+    settings = get_settings()
+    return {"providers": list_provider_payloads(settings)}
+
+
+@router.post("/api/providers")
+async def create_provider(req: CreateProviderRequest) -> dict[str, object]:
+    from flowent.providers.gateway import gateway
+
+    settings = get_settings()
+    try:
+        provider = create_provider_entry(
+            settings,
+            name=req.name,
+            provider_type=req.type,
+            base_url=req.base_url,
+            api_key=req.api_key,
+            raw_headers=req.headers,
+            raw_retry_429_delay_seconds=req.retry_429_delay_seconds,
+            models=coerce_provider_model_catalog(req.models),
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    save_settings(settings)
+    gateway.invalidate_cache()
+    return serialize_provider(provider)
+
+
+@router.put("/api/providers/{provider_id}")
+async def update_provider(
+    provider_id: str, req: UpdateProviderRequest
+) -> dict[str, object]:
+    from flowent.providers.gateway import gateway
+
+    settings = get_settings()
+    try:
+        provider = update_provider_entry(
+            settings,
+            provider_id,
+            name=req.name,
+            provider_type=req.type,
+            base_url=req.base_url,
+            api_key=req.api_key,
+            raw_headers=req.headers,
+            raw_retry_429_delay_seconds=req.retry_429_delay_seconds,
+            models=(
+                coerce_provider_model_catalog(req.models)
+                if req.models is not None
+                else None
+            ),
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except ProviderNotFoundError as exc:
+        raise HTTPException(status_code=404, detail="Provider not found") from exc
+    save_settings(settings)
+    gateway.invalidate_cache()
+    return serialize_provider(provider)
+
+
+@router.delete("/api/providers/{provider_id}")
+async def delete_provider(provider_id: str) -> dict[str, object]:
+    from flowent.providers.gateway import gateway
+
+    settings = get_settings()
+    try:
+        delete_provider_entry(settings, provider_id)
+    except ProviderNotFoundError as exc:
+        raise HTTPException(status_code=404, detail="Provider not found") from exc
+    save_settings(settings)
+    gateway.invalidate_cache()
+    return {"status": "deleted"}
+
+
+@router.post("/api/providers/models")
+async def list_provider_models(req: ListModelsRequest) -> dict[str, object]:
+    from flowent.providers.gateway import gateway
+
+    if req.provider_id is not None and not _has_draft_provider_fields(req):
+        try:
+            models = await run_in_threadpool(gateway.list_models_for, req.provider_id)
+            return {
+                "models": [
+                    serialize_discovered_model_catalog_entry(model) for model in models
+                ]
+            }
+        except Exception as exc:
+            logger.error(
+                "Failed to list models for provider '{}': {}",
+                req.provider_id,
+                exc,
+            )
+            raise HTTPException(
+                status_code=500,
+                detail=_summarize_provider_error(exc),
+            ) from exc
+
+    provider = _resolve_provider_from_request(req)
+
+    try:
+        models = await run_in_threadpool(_list_models_with_provider, provider)
+        return {
+            "models": [
+                serialize_discovered_model_catalog_entry(model) for model in models
+            ]
+        }
+    except Exception as exc:
+        logger.error(
+            "Failed to list models for provider '{}': {}",
+            provider.id or provider.name or provider.base_url,
+            exc,
+        )
+        raise HTTPException(
+            status_code=500, detail=_summarize_provider_error(exc)
+        ) from exc
+
+
+@router.post("/api/providers/models/test")
+async def run_provider_model_test_route(
+    req: ProviderModelTestRequest,
+) -> dict[str, object]:
+    model = req.model.strip()
+    if not model:
+        raise HTTPException(status_code=400, detail="model is required")
+
+    provider = _resolve_provider_from_request(req)
+    try:
+        return await run_in_threadpool(_test_provider_model, provider, model)
+    except Exception as exc:
+        logger.error(
+            "Failed to test model '{}' for provider '{}': {}",
+            model,
+            provider.id or provider.name or provider.base_url,
+            exc,
+        )
+        return {
+            "ok": False,
+            "error_summary": _summarize_provider_error(exc),
+        }

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

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from flowent.role_management import (
+    RoleConflictError,
+    apply_role_update,
+    build_role_config,
+    ensure_role_name_available,
+    find_role_by_name,
+    normalize_optional_role_description,
+    normalize_optional_role_name,
+    remove_role,
+    require_role_description,
+    require_role_name,
+    resolve_role_model,
+    resolve_role_model_params,
+    resolve_role_tool_config,
+    sync_running_system_roles,
+    validate_builtin_role_update,
+)
+from flowent.settings import (
+    get_settings,
+    is_builtin_role_name,
+    save_settings,
+    serialize_provider,
+    serialize_role,
+)
+
+router = APIRouter()
+
+
+class RoleModelRequest(BaseModel):
+    provider_id: str
+    model: str
+
+
+class CreateRoleRequest(BaseModel):
+    name: str
+    description: str
+    system_prompt: str
+    model: RoleModelRequest | None = None
+    model_params: dict[str, object] | None = None
+    included_tools: list[str] = Field(default_factory=list)
+    excluded_tools: list[str] = Field(default_factory=list)
+
+
+class UpdateRoleRequest(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    system_prompt: str | None = None
+    model: RoleModelRequest | None = None
+    model_params: dict[str, object] | None = None
+    included_tools: list[str] | None = None
+    excluded_tools: list[str] | None = None
+
+
+@router.get("/api/roles")
+async def list_roles() -> dict:
+    settings = get_settings()
+    return {"roles": [serialize_role(role) for role in settings.roles]}
+
+
+@router.get("/api/roles/bootstrap")
+async def get_roles_bootstrap() -> dict[str, object]:
+    from flowent.tools import list_agent_visible_tool_descriptors
+
+    settings = get_settings()
+    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(include_assistant_only=False),
+    }
+
+
+@router.post("/api/roles")
+async def create_role(req: CreateRoleRequest) -> dict:
+    from flowent.providers.gateway import gateway
+
+    settings = get_settings()
+    try:
+        name = require_role_name(req.name)
+        description = require_role_description(req.description)
+        ensure_role_name_available(settings.roles, name)
+        included_tools, excluded_tools = resolve_role_tool_config(
+            None,
+            req.included_tools,
+            req.excluded_tools,
+        )
+        role = build_role_config(
+            name=name,
+            description=description,
+            system_prompt=req.system_prompt,
+            model=resolve_role_model(
+                req.model,
+                settings=settings,
+                current=None,
+                provided="model" in req.model_fields_set,
+                invalid_type_error="Role model must be an object or null",
+                missing_provider_id_error="Role model provider_id is required",
+                missing_model_error="Role model is required",
+            ),
+            model_params=resolve_role_model_params(
+                req.model_params,
+                current=None,
+                provided="model_params" in req.model_fields_set,
+            ),
+            included_tools=included_tools,
+            excluded_tools=excluded_tools,
+        )
+    except RoleConflictError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    settings.roles.append(role)
+    save_settings(settings)
+    gateway.invalidate_cache()
+    return serialize_role(role)
+
+
+@router.put("/api/roles/{role_name:path}")
+async def update_role(role_name: str, req: UpdateRoleRequest) -> dict:
+    from flowent.providers.gateway import gateway
+
+    settings = get_settings()
+    role = find_role_by_name(settings.roles, role_name)
+    if role is None:
+        raise HTTPException(status_code=404, detail="Role not found")
+
+    try:
+        included_tools, excluded_tools = resolve_role_tool_config(
+            role,
+            req.included_tools,
+            req.excluded_tools,
+        )
+        next_name = normalize_optional_role_name(req.name)
+        next_description = normalize_optional_role_description(req.description)
+        if next_name is not None:
+            ensure_role_name_available(
+                settings.roles,
+                next_name,
+                current_name=role.name,
+            )
+        validate_builtin_role_update(
+            role,
+            next_name=next_name,
+            next_description=next_description,
+            next_system_prompt=req.system_prompt,
+            next_included_tools=included_tools,
+            next_excluded_tools=excluded_tools,
+        )
+        role = apply_role_update(
+            settings=settings,
+            role=role,
+            next_name=next_name,
+            next_description=next_description,
+            next_system_prompt=req.system_prompt,
+            next_model=resolve_role_model(
+                req.model,
+                settings=settings,
+                current=role.model,
+                provided="model" in req.model_fields_set,
+                invalid_type_error="Role model must be an object or null",
+                missing_provider_id_error="Role model provider_id is required",
+                missing_model_error="Role model is required",
+            ),
+            update_model="model" in req.model_fields_set,
+            next_model_params=resolve_role_model_params(
+                req.model_params,
+                current=role.model_params,
+                provided="model_params" in req.model_fields_set,
+            ),
+            update_model_params="model_params" in req.model_fields_set,
+            next_included_tools=included_tools,
+            next_excluded_tools=excluded_tools,
+        )
+    except RoleConflictError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    save_settings(settings)
+    sync_running_system_roles()
+    gateway.invalidate_cache()
+    return serialize_role(role)
+
+
+@router.delete("/api/roles/{role_name:path}")
+async def delete_role(role_name: str) -> dict:
+    from flowent.providers.gateway import gateway
+
+    if is_builtin_role_name(role_name):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Cannot delete built-in role '{role_name}'",
+        )
+
+    settings = get_settings()
+    role = find_role_by_name(settings.roles, role_name)
+    if role is None:
+        raise HTTPException(status_code=404, detail="Role not found")
+    remove_role(settings, role)
+    save_settings(settings)
+    sync_running_system_roles()
+    gateway.invalidate_cache()
+    return {"status": "deleted"}