flowent 0.0.7 → 0.0.11

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

@@ -1,447 +0,0 @@
-from __future__ import annotations
-
-import base64
-import json
-import time
-import uuid
-from collections.abc import Callable
-from typing import Any
-
-from loguru import logger
-
-from flowent.model_metadata import build_model_info
-from flowent.models import (
-    LLMOutputImagePart,
-    LLMOutputTextPart,
-    LLMResponse,
-    LLMUsage,
-    ModelInfo,
-)
-from flowent.models import ToolCallResult as ToolCall
-from flowent.network import (
-    RequestException,
-    create_http_session,
-    read_response_text,
-    response_looks_like_html,
-    truncate_text,
-)
-from flowent.providers import LLMProvider
-from flowent.providers.content import collapse_parts_to_text, to_gemini_parts
-from flowent.providers.errors import (
-    build_access_blocked_error,
-    build_network_error,
-    build_status_error,
-)
-from flowent.providers.headers import merge_headers
-from flowent.providers.sse import iter_sse_json
-from flowent.settings import ModelParams
-
-
-def _extract_usage_metadata_value(
-    usage_metadata: dict[str, Any],
-    key: str,
-) -> int | None:
-    value = usage_metadata.get(key)
-    if isinstance(value, bool) or not isinstance(value, int):
-        return None
-    return value
-
-
-class GeminiProvider(LLMProvider):
-    def __init__(
-        self,
-        provider_name: str,
-        api_base_url: str,
-        api_key: str = "",
-        headers: dict[str, str] | None = None,
-        model: str = "",
-        request_timeout_seconds: float = 120.0,
-    ) -> None:
-        self._provider_name = provider_name
-        self._api_base_url = api_base_url.rstrip("/")
-        self._api_key = api_key
-        self._header_overrides = dict(headers or {})
-        self._model = model
-        self._request_timeout_seconds = request_timeout_seconds
-        self._client = create_http_session(timeout=self._request_timeout_seconds)
-
-    def _headers(self) -> dict[str, str]:
-        return merge_headers(
-            {"Content-Type": "application/json"},
-            self._header_overrides,
-        )
-
-    def _convert_messages(
-        self,
-        messages: list[dict[str, Any]],
-    ) -> tuple[dict[str, Any] | None, list[dict[str, Any]]]:
-        system_parts: list[str] = []
-        contents: list[dict[str, Any]] = []
-        tool_call_names: dict[str, str] = {}
-
-        for msg in messages:
-            role = msg.get("role", "")
-            content = msg.get("content")
-
-            if role == "system":
-                system_text = collapse_parts_to_text(content)
-                if system_text:
-                    system_parts.append(system_text)
-                continue
-
-            if role == "user":
-                contents.append(
-                    {
-                        "role": "user",
-                        "parts": to_gemini_parts(content, allow_images=True),
-                    },
-                )
-                continue
-
-            if role == "assistant":
-                parts: list[dict[str, Any]] = []
-
-                assistant_text = collapse_parts_to_text(content)
-                if assistant_text:
-                    parts.append({"text": assistant_text})
-
-                for tc in msg.get("tool_calls", []) or []:
-                    fn = tc.get("function", {})
-                    name = fn.get("name", "")
-                    call_id = tc.get("id", "")
-                    if call_id and name:
-                        tool_call_names[call_id] = name
-
-                    raw_args = fn.get("arguments", {})
-                    if isinstance(raw_args, str):
-                        try:
-                            args = json.loads(raw_args) if raw_args else {}
-                        except json.JSONDecodeError:
-                            args = {}
-                    elif isinstance(raw_args, dict):
-                        args = raw_args
-                    else:
-                        args = {}
-
-                    if not isinstance(args, dict):
-                        args = {}
-
-                    parts.append(
-                        {
-                            "functionCall": {
-                                "name": name,
-                                "args": args,
-                            }
-                        },
-                    )
-
-                if parts:
-                    contents.append(
-                        {
-                            "role": "model",
-                            "parts": parts,
-                        },
-                    )
-                continue
-
-            if role == "tool":
-                tool_call_id = msg.get("tool_call_id", "")
-                name = tool_call_names.get(tool_call_id, msg.get("name", ""))
-                contents.append(
-                    {
-                        "role": "user",
-                        "parts": [
-                            {
-                                "functionResponse": {
-                                    "name": name,
-                                    "response": {"content": content or ""},
-                                }
-                            }
-                        ],
-                    },
-                )
-
-        system_instruction = None
-        if system_parts:
-            system_instruction = {"parts": [{"text": "\n\n".join(system_parts)}]}
-
-        return system_instruction, contents
-
-    def _convert_tools(self, tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
-        declarations = []
-        for tool in tools:
-            fn = tool.get("function", {})
-            decl: dict[str, Any] = {
-                "name": fn.get("name", ""),
-                "description": fn.get("description", ""),
-            }
-            params = fn.get("parameters")
-            if params:
-                decl["parameters"] = params
-            declarations.append(decl)
-        return [{"function_declarations": declarations}]
-
-    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:
-        url = (
-            f"{self._api_base_url}/v1beta/models/{self._model}"
-            f":streamGenerateContent?alt=sse&key={self._api_key}"
-        )
-
-        system_instruction, contents = self._convert_messages(messages)
-
-        payload: dict[str, Any] = {"contents": contents}
-        if model_params is not None:
-            generation_config: dict[str, Any] = {}
-            if model_params.max_output_tokens is not None:
-                generation_config["maxOutputTokens"] = model_params.max_output_tokens
-            if model_params.temperature is not None:
-                generation_config["temperature"] = model_params.temperature
-            if model_params.top_p is not None:
-                generation_config["topP"] = model_params.top_p
-            if generation_config:
-                payload["generationConfig"] = generation_config
-        if system_instruction:
-            payload["system_instruction"] = system_instruction
-        if tools:
-            payload["tools"] = self._convert_tools(tools)
-
-        logger.debug(
-            "[{}] Gemini chat request: model={}, messages={}, tools={}",
-            self._provider_name,
-            self._model,
-            len(contents),
-            len(tools) if tools else 0,
-        )
-
-        t0 = time.perf_counter()
-
-        content_parts: list[str] = []
-        output_parts: list[LLMOutputTextPart | LLMOutputImagePart] = []
-        tool_calls_list: list[ToolCall] = []
-        chunk_count = 0
-        usage: LLMUsage | None = None
-        raw_usage: dict[str, Any] | None = None
-        client = self._client
-        if register_interrupt is not None:
-            register_interrupt(client.close)
-
-        try:
-            with client.stream(
-                "POST",
-                url,
-                headers=self._headers(),
-                json=payload,
-            ) as response:
-                if register_interrupt is not None:
-                    register_interrupt(response.close)
-                if response_looks_like_html(response):
-                    raise build_access_blocked_error(
-                        provider_name=self._provider_name,
-                        provider_type="gemini",
-                        model=self._model,
-                        base_url=self._api_base_url,
-                        status_code=response.status_code,
-                        detail=truncate_text(read_response_text(response)),
-                    )
-                if response.status_code != 200:
-                    body = truncate_text(read_response_text(response))
-                    elapsed = time.perf_counter() - t0
-                    logger.error(
-                        "LLM API error [provider={}, model={}, type=gemini]: {} - {} ({:.2f}s)",
-                        self._provider_name,
-                        self._model,
-                        response.status_code,
-                        body[:500],
-                        elapsed,
-                    )
-                    raise build_status_error(
-                        provider_name=self._provider_name,
-                        provider_type="gemini",
-                        model=self._model,
-                        base_url=self._api_base_url,
-                        status_code=response.status_code,
-                        body=body,
-                    )
-
-                for chunk in iter_sse_json(response):
-                    chunk_count += 1
-                    usage_metadata = chunk.get("usageMetadata", {})
-                    if isinstance(usage_metadata, dict):
-                        raw_usage = dict(usage_metadata)
-                        input_tokens = _extract_usage_metadata_value(
-                            usage_metadata, "promptTokenCount"
-                        )
-                        output_tokens = _extract_usage_metadata_value(
-                            usage_metadata, "candidatesTokenCount"
-                        )
-                        total_tokens = _extract_usage_metadata_value(
-                            usage_metadata, "totalTokenCount"
-                        )
-                        cached_input_tokens = _extract_usage_metadata_value(
-                            usage_metadata, "cachedContentTokenCount"
-                        )
-                        details = {
-                            key: value
-                            for key in (
-                                "toolUsePromptTokenCount",
-                                "thoughtsTokenCount",
-                            )
-                            if (
-                                value := _extract_usage_metadata_value(
-                                    usage_metadata, key
-                                )
-                            )
-                            is not None
-                        }
-                        if total_tokens is not None:
-                            usage = LLMUsage(
-                                total_tokens=total_tokens,
-                                input_tokens=input_tokens,
-                                output_tokens=output_tokens,
-                                cached_input_tokens=cached_input_tokens,
-                                cache_read_tokens=cached_input_tokens,
-                                details=details,
-                            )
-                    candidates = chunk.get("candidates", [])
-                    if not candidates:
-                        continue
-
-                    parts = candidates[0].get("content", {}).get("parts", [])
-                    for part in parts:
-                        if "text" in part:
-                            text = part["text"]
-                            content_parts.append(text)
-                            output_parts.append(LLMOutputTextPart(text=text))
-                            if on_chunk:
-                                on_chunk("content", text)
-                        elif "inlineData" in part:
-                            inline_data = part["inlineData"]
-                            mime_type = inline_data.get("mimeType")
-                            encoded_data = inline_data.get("data")
-                            if (
-                                isinstance(mime_type, str)
-                                and mime_type.startswith("image/")
-                                and isinstance(encoded_data, str)
-                            ):
-                                try:
-                                    image_data = base64.b64decode(encoded_data)
-                                except ValueError:
-                                    continue
-                                output_parts.append(
-                                    LLMOutputImagePart(
-                                        data=image_data,
-                                        mime_type=mime_type,
-                                    )
-                                )
-                        elif "functionCall" in part:
-                            fc = part["functionCall"]
-                            tool_calls_list.append(
-                                ToolCall(
-                                    id=str(uuid.uuid4()),
-                                    name=fc.get("name", ""),
-                                    arguments=fc.get("args", {}),
-                                ),
-                            )
-        except RequestException as exc:
-            elapsed = time.perf_counter() - t0
-            logger.warning(
-                "LLM API transport error [provider={}, model={}, type=gemini]: {} ({:.2f}s)",
-                self._provider_name,
-                self._model,
-                exc,
-                elapsed,
-            )
-            raise build_network_error(
-                provider_name=self._provider_name,
-                provider_type="gemini",
-                model=self._model,
-                base_url=self._api_base_url,
-                error=exc,
-            ) from exc
-        finally:
-            close_client = getattr(client, "close", None)
-            if callable(close_client):
-                close_client()
-                self._client = create_http_session(
-                    timeout=self._request_timeout_seconds
-                )
-
-        elapsed = time.perf_counter() - t0
-        content = "".join(content_parts) or None
-
-        logger.debug(
-            "[{}] Gemini chat done: {:.2f}s, chunks={}, content_len={}, tool_calls={}",
-            self._provider_name,
-            elapsed,
-            chunk_count,
-            len(content) if content else 0,
-            len(tool_calls_list),
-        )
-
-        if tool_calls_list:
-            return LLMResponse(
-                content=content,
-                parts=output_parts or None,
-                tool_calls=tool_calls_list,
-                usage=usage,
-                raw_usage=raw_usage,
-            )
-
-        return LLMResponse(
-            content=content or "",
-            parts=output_parts or None,
-            usage=usage,
-            raw_usage=raw_usage,
-        )
-
-    def list_models(
-        self,
-        register_interrupt: Callable[[Callable[[], None] | None], None] | None = None,
-    ) -> list[ModelInfo]:
-        url = f"{self._api_base_url}/v1beta/models?key={self._api_key}"
-        client = self._client
-        close_client = getattr(client, "close", None)
-        if register_interrupt is not None and callable(close_client):
-            register_interrupt(close_client)
-        try:
-            resp = client.get(url, headers=self._headers())
-            resp.raise_for_status()
-            data = resp.json()
-            models = data.get("models", [])
-            result = []
-            for m in models:
-                methods = m.get("supportedGenerationMethods", [])
-                if "generateContent" in methods:
-                    model_id = m.get("name", "").removeprefix("models/")
-                    result.append(
-                        build_model_info(
-                            provider_type="gemini",
-                            model_id=model_id,
-                            context_window_tokens=(
-                                m.get("inputTokenLimit")
-                                if isinstance(m.get("inputTokenLimit"), int)
-                                else None
-                            ),
-                        )
-                    )
-            return result
-        except Exception as e:
-            logger.error(
-                "Failed to list models [provider={}, type=gemini]: {}",
-                self._provider_name,
-                e,
-            )
-            return []
-        finally:
-            if callable(close_client):
-                close_client()
-                self._client = create_http_session(
-                    timeout=self._request_timeout_seconds
-                )

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

@@ -1,20 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping
-
-
-def merge_headers(
-    builtins: Mapping[str, str],
-    overrides: Mapping[str, str],
-) -> dict[str, str]:
-    headers = dict(builtins)
-    names = {name.lower(): name for name in headers}
-
-    for name, value in overrides.items():
-        existing = names.get(name.lower())
-        if existing is not None:
-            headers.pop(existing, None)
-        headers[name] = value
-        names[name.lower()] = name
-
-    return headers

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

@@ -1,96 +0,0 @@
-from __future__ import annotations
-
-import uuid
-
-from flowent.providers.configuration import (
-    apply_provider_update,
-    build_provider_config,
-    serialize_provider,
-)
-from flowent.settings import (
-    ProviderConfig,
-    ProviderModelCatalogEntry,
-    Settings,
-    clear_provider_references,
-    find_provider,
-)
-
-
-class ProviderNotFoundError(LookupError):
-    def __init__(self, provider_id: str) -> None:
-        super().__init__(provider_id)
-        self.provider_id = provider_id
-
-
-def list_provider_payloads(
-    settings: Settings,
-    *,
-    include_api_key: bool = True,
-) -> list[dict[str, object]]:
-    return [
-        serialize_provider(provider, include_api_key=include_api_key)
-        for provider in settings.providers
-    ]
-
-
-def create_provider_entry(
-    settings: Settings,
-    *,
-    name: str,
-    provider_type: str,
-    base_url: str,
-    api_key: str = "",
-    raw_headers: object = None,
-    raw_retry_429_delay_seconds: object = 0,
-    models: list[ProviderModelCatalogEntry] | None = None,
-    base_url_required_message: str = "base_url is required",
-) -> ProviderConfig:
-    provider = build_provider_config(
-        provider_id=str(uuid.uuid4()),
-        name=name,
-        provider_type=provider_type,
-        base_url=base_url,
-        api_key=api_key,
-        raw_headers=raw_headers,
-        raw_retry_429_delay_seconds=raw_retry_429_delay_seconds,
-        models=models,
-        base_url_required_message=base_url_required_message,
-    )
-    settings.providers.append(provider)
-    return provider
-
-
-def update_provider_entry(
-    settings: Settings,
-    provider_id: str,
-    *,
-    name: str | None = None,
-    provider_type: str | None = None,
-    base_url: str | None = None,
-    api_key: str | None = None,
-    raw_headers: object | None = None,
-    raw_retry_429_delay_seconds: object | None = None,
-    models: list[ProviderModelCatalogEntry] | None = None,
-) -> ProviderConfig:
-    provider = find_provider(settings, provider_id)
-    if provider is None:
-        raise ProviderNotFoundError(provider_id)
-    apply_provider_update(
-        provider,
-        name=name,
-        provider_type=provider_type,
-        base_url=base_url,
-        api_key=api_key,
-        raw_headers=raw_headers,
-        raw_retry_429_delay_seconds=raw_retry_429_delay_seconds,
-        models=models,
-    )
-    return provider
-
-
-def delete_provider_entry(settings: Settings, provider_id: str) -> None:
-    provider = find_provider(settings, provider_id)
-    if provider is None:
-        raise ProviderNotFoundError(provider_id)
-    settings.providers = [item for item in settings.providers if item.id != provider_id]
-    clear_provider_references(settings, provider_id)