flowent 0.0.1 → 0.0.5

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

@@ -0,0 +1,468 @@
+from __future__ import annotations
+
+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 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_anthropic_content
+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_value(usage: dict[str, Any], key: str) -> int | None:
+    value = usage.get(key)
+    if isinstance(value, bool) or not isinstance(value, int):
+        return None
+    return value
+
+
+class AnthropicProvider(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",
+                "x-api-key": self._api_key,
+                "anthropic-version": "2023-06-01",
+            },
+            self._header_overrides,
+        )
+
+    def _convert_messages(
+        self,
+        messages: list[dict[str, Any]],
+    ) -> tuple[str | None, list[dict[str, Any]]]:
+        system_text: list[str] = []
+        converted: list[dict[str, Any]] = []
+        pending_tool_results: list[dict[str, Any]] = []
+
+        def flush_tool_results() -> None:
+            if not pending_tool_results:
+                return
+            converted.append(
+                {
+                    "role": "user",
+                    "content": list(pending_tool_results),
+                }
+            )
+            pending_tool_results.clear()
+
+        for msg in messages:
+            role = msg.get("role")
+
+            if role == "system":
+                content = msg.get("content")
+                if content is not None:
+                    system_text.append(
+                        content if isinstance(content, str) else json.dumps(content),
+                    )
+                continue
+
+            if role == "tool":
+                content = msg.get("content")
+                if content is None:
+                    tool_content = ""
+                elif isinstance(content, str):
+                    tool_content = content
+                else:
+                    tool_content = json.dumps(content)
+
+                pending_tool_results.append(
+                    {
+                        "type": "tool_result",
+                        "tool_use_id": msg.get("tool_call_id", ""),
+                        "content": tool_content,
+                    }
+                )
+                continue
+
+            flush_tool_results()
+
+            if role == "assistant" and msg.get("tool_calls"):
+                content_blocks: list[dict[str, Any]] = []
+                content = msg.get("content")
+                assistant_text = collapse_parts_to_text(content)
+                if assistant_text:
+                    content_blocks.append({"type": "text", "text": assistant_text})
+
+                for tool_call in msg.get("tool_calls", []):
+                    fn = tool_call.get("function", {})
+                    raw_arguments = fn.get("arguments", "{}")
+
+                    if isinstance(raw_arguments, str):
+                        try:
+                            parsed_arguments = (
+                                json.loads(raw_arguments) if raw_arguments else {}
+                            )
+                        except json.JSONDecodeError:
+                            parsed_arguments = {}
+                    elif isinstance(raw_arguments, dict):
+                        parsed_arguments = raw_arguments
+                    else:
+                        parsed_arguments = {}
+
+                    if not isinstance(parsed_arguments, dict):
+                        parsed_arguments = {}
+
+                    content_blocks.append(
+                        {
+                            "type": "tool_use",
+                            "id": tool_call.get("id", ""),
+                            "name": fn.get("name", ""),
+                            "input": parsed_arguments,
+                        }
+                    )
+
+                converted.append({"role": "assistant", "content": content_blocks})
+                continue
+
+            if role == "user":
+                converted.append(
+                    {
+                        "role": "user",
+                        "content": to_anthropic_content(
+                            msg.get("content"),
+                            allow_images=True,
+                        ),
+                    }
+                )
+                continue
+
+            converted.append(
+                {"role": role, "content": collapse_parts_to_text(msg.get("content"))}
+            )
+
+        flush_tool_results()
+
+        system = "\n\n".join(system_text) if system_text else None
+        return system, converted
+
+    def _convert_tools(self, tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        result = []
+        for tool in tools:
+            fn = tool.get("function", {})
+            result.append(
+                {
+                    "name": fn.get("name", ""),
+                    "description": fn.get("description", ""),
+                    "input_schema": fn.get("parameters", {}),
+                },
+            )
+        return result
+
+    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}/messages"
+        system, converted_messages = self._convert_messages(messages)
+
+        payload: dict[str, Any] = {
+            "model": self._model,
+            "messages": converted_messages,
+            "max_tokens": (
+                model_params.max_output_tokens
+                if model_params is not None
+                and model_params.max_output_tokens is not None
+                else 8192
+            ),
+            "stream": True,
+        }
+        if model_params is not None:
+            if model_params.temperature is not None:
+                payload["temperature"] = model_params.temperature
+            if model_params.top_p is not None:
+                payload["top_p"] = model_params.top_p
+        if system:
+            payload["system"] = system
+        if tools:
+            payload["tools"] = self._convert_tools(tools)
+
+        logger.debug(
+            "[{}] Anthropic chat request: model={}, messages={}, tools={}",
+            self._provider_name,
+            self._model,
+            len(converted_messages),
+            len(tools) if tools else 0,
+        )
+
+        t0 = time.perf_counter()
+
+        content_parts: list[str] = []
+        thinking_parts: list[str] = []
+        tool_calls_accum: dict[int, dict[str, Any]] = {}
+        current_block_idx = -1
+        event_count = 0
+        input_tokens: int | None = None
+        output_tokens: int | None = None
+        cached_input_tokens: int | None = None
+        cache_read_tokens: int | None = None
+        cache_write_tokens: int | None = None
+        usage_details: dict[str, int] = {}
+        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="anthropic",
+                        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=anthropic]: {} - {} ({:.2f}s)",
+                        self._provider_name,
+                        self._model,
+                        response.status_code,
+                        body[:500],
+                        elapsed,
+                    )
+                    raise build_status_error(
+                        provider_name=self._provider_name,
+                        provider_type="anthropic",
+                        model=self._model,
+                        base_url=self._api_base_url,
+                        status_code=response.status_code,
+                        body=body,
+                    )
+
+                for event in iter_sse_json(response):
+                    event_count += 1
+                    event_type = event.get("type", "")
+
+                    if event_type == "message_start":
+                        message = event.get("message", {})
+                        usage = message.get("usage", {})
+                        if isinstance(usage, dict):
+                            raw_usage = dict(usage)
+                            input_tokens = _extract_usage_value(usage, "input_tokens")
+                            cache_read_tokens = _extract_usage_value(
+                                usage, "cache_read_input_tokens"
+                            )
+                            cache_write_tokens = _extract_usage_value(
+                                usage, "cache_creation_input_tokens"
+                            )
+                            cached_input_tokens = cache_read_tokens
+                            if cached_input_tokens is None:
+                                cached_input_tokens = cache_write_tokens
+                            for key in (
+                                "cache_creation_input_tokens",
+                                "cache_read_input_tokens",
+                            ):
+                                value = _extract_usage_value(usage, key)
+                                if value is not None:
+                                    usage_details[key] = value
+                        continue
+
+                    if event_type == "content_block_start":
+                        current_block_idx += 1
+                        block = event.get("content_block", {})
+                        if block.get("type") == "tool_use":
+                            tool_calls_accum[current_block_idx] = {
+                                "id": block.get("id", str(uuid.uuid4())),
+                                "name": block.get("name", ""),
+                                "arguments": "",
+                            }
+
+                    elif event_type == "content_block_delta":
+                        delta = event.get("delta", {})
+                        delta_type = delta.get("type", "")
+
+                        if delta_type == "text_delta":
+                            text = delta.get("text", "")
+                            if text:
+                                content_parts.append(text)
+                                if on_chunk:
+                                    on_chunk("content", text)
+
+                        elif delta_type == "thinking_delta":
+                            thinking = delta.get("thinking", "")
+                            if thinking:
+                                thinking_parts.append(thinking)
+                                if on_chunk:
+                                    on_chunk("thinking", thinking)
+
+                        elif delta_type == "input_json_delta":
+                            partial = delta.get("partial_json", "")
+                            if current_block_idx in tool_calls_accum:
+                                tool_calls_accum[current_block_idx]["arguments"] += (
+                                    partial
+                                )
+
+                    elif event_type == "message_delta":
+                        usage = event.get("usage", {})
+                        if isinstance(usage, dict):
+                            next_output_tokens = _extract_usage_value(
+                                usage, "output_tokens"
+                            )
+                            if next_output_tokens is not None:
+                                output_tokens = next_output_tokens
+
+                    elif event_type == "message_stop":
+                        break
+        except RequestException as exc:
+            elapsed = time.perf_counter() - t0
+            logger.warning(
+                "LLM API transport error [provider={}, model={}, type=anthropic]: {} ({:.2f}s)",
+                self._provider_name,
+                self._model,
+                exc,
+                elapsed,
+            )
+            raise build_network_error(
+                provider_name=self._provider_name,
+                provider_type="anthropic",
+                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
+        thinking = "".join(thinking_parts) or None
+        usage = None
+        if input_tokens is not None or output_tokens is not None:
+            usage = LLMUsage(
+                total_tokens=(input_tokens or 0) + (output_tokens or 0),
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                cached_input_tokens=cached_input_tokens,
+                cache_read_tokens=cache_read_tokens,
+                cache_write_tokens=cache_write_tokens,
+                details=usage_details,
+            )
+
+        logger.debug(
+            "[{}] Anthropic chat done: {:.2f}s, events={}, content_len={}, thinking_len={}, tool_calls={}",
+            self._provider_name,
+            elapsed,
+            event_count,
+            len(content) if content else 0,
+            len(thinking) if thinking else 0,
+            len(tool_calls_accum),
+        )
+
+        if tool_calls_accum:
+            tool_calls = []
+            for _, acc in sorted(tool_calls_accum.items()):
+                args_str = acc["arguments"]
+                try:
+                    arguments = json.loads(args_str) if args_str else {}
+                except json.JSONDecodeError:
+                    arguments = {}
+                tool_calls.append(
+                    ToolCall(id=acc["id"], name=acc["name"], arguments=arguments),
+                )
+            return LLMResponse(
+                content=content,
+                tool_calls=tool_calls,
+                thinking=thinking,
+                usage=usage,
+                raw_usage=raw_usage,
+            )
+
+        return LLMResponse(
+            content=content or "",
+            thinking=thinking,
+            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}/models"
+        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("data", [])
+            return [
+                build_model_info(
+                    provider_type="anthropic",
+                    model_id=m["id"],
+                )
+                for m in models
+            ]
+        except Exception as e:
+            logger.error(
+                "Failed to list models [provider={}, type=anthropic]: {}",
+                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/base_url.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Final
+
+PROVIDER_VERSION_SUFFIXES: Final[dict[str, str]] = {
+    "openai_compatible": "/v1",
+    "openai_responses": "/v1",
+    "anthropic": "/v1",
+    "gemini": "/v1beta",
+}
+
+PROVIDER_REQUEST_PATHS: Final[dict[str, str]] = {
+    "openai_compatible": "/chat/completions",
+    "openai_responses": "/responses",
+    "anthropic": "/messages",
+    "gemini": "/models/{model}:streamGenerateContent",
+}
+
+_KNOWN_SUFFIXES: Final[tuple[str, ...]] = tuple(
+    sorted(set(PROVIDER_VERSION_SUFFIXES.values()), key=len, reverse=True)
+)
+
+
+def _normalize_raw_base_url(base_url: str) -> str:
+    normalized = base_url.strip().rstrip("/")
+    if not normalized:
+        raise ValueError("Provider base_url is required")
+    return normalized
+
+
+def _normalize_provider_type(provider_type: str) -> str:
+    normalized = provider_type.strip().lower()
+    if normalized not in PROVIDER_VERSION_SUFFIXES:
+        raise ValueError(f"Unknown provider type: {provider_type}")
+    return normalized
+
+
+def resolve_provider_base_url(provider_type: str, base_url: str) -> str:
+    normalized_type = _normalize_provider_type(provider_type)
+    normalized_base_url = _normalize_raw_base_url(base_url)
+    expected_suffix = PROVIDER_VERSION_SUFFIXES[normalized_type]
+    lower_base_url = normalized_base_url.lower()
+
+    for suffix in _KNOWN_SUFFIXES:
+        if not lower_base_url.endswith(suffix):
+            continue
+        if suffix != expected_suffix:
+            raise ValueError(
+                f"Provider base_url suffix '{suffix}' does not match type "
+                f"'{normalized_type}' (expected '{expected_suffix}')"
+            )
+        return normalized_base_url
+
+    return f"{normalized_base_url}{expected_suffix}"
+
+
+def build_provider_request_preview(provider_type: str, base_url: str) -> str:
+    normalized_type = _normalize_provider_type(provider_type)
+    resolved_base_url = resolve_provider_base_url(normalized_type, base_url)
+    return f"{resolved_base_url}{PROVIDER_REQUEST_PATHS[normalized_type]}"