flowent 0.0.1 → 0.0.5

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

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

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

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