flowent 0.0.7 → 0.0.10

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

@@ -1,46 +0,0 @@
-from __future__ import annotations
-
-from fastapi import APIRouter
-from pydantic import AliasChoices, BaseModel, Field
-
-from flowent.settings import get_settings, save_settings
-
-router = APIRouter()
-
-
-class PromptSettingsResponse(BaseModel):
-    custom_prompt: str
-    custom_post_prompt: str
-
-
-class UpdatePromptSettingsRequest(BaseModel):
-    custom_prompt: str | None = None
-    custom_post_prompt: str | None = Field(
-        default=None,
-        validation_alias=AliasChoices("custom_post_prompt", "post_prompt"),
-    )
-
-
-@router.get("/api/prompts")
-async def get_prompts() -> PromptSettingsResponse:
-    settings = get_settings()
-    return PromptSettingsResponse(
-        custom_prompt=settings.custom_prompt,
-        custom_post_prompt=settings.custom_post_prompt,
-    )
-
-
-@router.put("/api/prompts")
-async def update_prompts(
-    req: UpdatePromptSettingsRequest,
-) -> PromptSettingsResponse:
-    settings = get_settings()
-    if req.custom_prompt is not None:
-        settings.custom_prompt = req.custom_prompt
-    if req.custom_post_prompt is not None:
-        settings.custom_post_prompt = req.custom_post_prompt
-    save_settings(settings)
-    return PromptSettingsResponse(
-        custom_prompt=settings.custom_prompt,
-        custom_post_prompt=settings.custom_post_prompt,
-    )

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

@@ -1,365 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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"}