flowent 0.1.5 → 0.2.0

package/backend/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowent"
-version = "0.1.5"
+version = "0.2.0"
 description = "A workflow orchestration platform for multi-agent collaboration."
 readme = "README.md"
 authors = [

package/backend/src/flowent/agent.py

@@ -146,56 +146,102 @@ async def run_agent_stream(
     while True:
         round_number += 1
         logger.debug("Agent round started id=%s round=%s", assistant_id, round_number)
+        logger.info(
+            "Agent model call started id=%s round=%s conversation_messages=%s",
+            assistant_id,
+            round_number,
+            len(conversation),
+        )
         yield AgentStreamEvent(event="output_start", data={"index": round_number})
         round_content = ""
         pending: dict[int, PendingToolCall] = {}
+        chunk_count = 0
+        content_delta_count = 0
+        reasoning_delta_count = 0
+        tool_delta_count = 0
 
-        async for chunk in stream_chat_chunks(
-            connection,
-            conversation,
-            completion=completion,
-            tools=[*tool_specs(), *list(extra_tool_specs or [])],
-        ):
-            reasoning = chunk_delta_reasoning(chunk)
-            if reasoning:
-                final_thinking += reasoning
-                logger.log(
-                    TRACE_LEVEL,
-                    "Agent stream reasoning id=%s content=%r",
-                    assistant_id,
-                    reasoning,
-                )
-                yield AgentStreamEvent(
-                    event="thinking_delta", data={"content": reasoning}
-                )
-            content = chunk_delta_content(chunk)
-            if content:
-                round_content += content
-                final_content += content
-                logger.log(
-                    TRACE_LEVEL,
-                    "Agent stream delta id=%s content=%r",
-                    assistant_id,
-                    content,
-                )
-                yield AgentStreamEvent(event="delta", data={"content": content})
-            for delta in chunk_delta_tool_calls(chunk):
-                pending.setdefault(delta.index, PendingToolCall()).apply_delta(delta)
+        try:
+            async for chunk in stream_chat_chunks(
+                connection,
+                conversation,
+                completion=completion,
+                tools=[*tool_specs(), *list(extra_tool_specs or [])],
+            ):
+                chunk_count += 1
+                reasoning = chunk_delta_reasoning(chunk)
+                if reasoning:
+                    reasoning_delta_count += 1
+                    final_thinking += reasoning
+                    logger.log(
+                        TRACE_LEVEL,
+                        "Agent stream reasoning id=%s round=%s content=%r",
+                        assistant_id,
+                        round_number,
+                        reasoning,
+                    )
+                    yield AgentStreamEvent(
+                        event="thinking_delta", data={"content": reasoning}
+                    )
+                content = chunk_delta_content(chunk)
+                if content:
+                    content_delta_count += 1
+                    round_content += content
+                    final_content += content
+                    logger.log(
+                        TRACE_LEVEL,
+                        "Agent stream delta id=%s round=%s content=%r",
+                        assistant_id,
+                        round_number,
+                        content,
+                    )
+                    yield AgentStreamEvent(event="delta", data={"content": content})
+                for delta in chunk_delta_tool_calls(chunk):
+                    tool_delta_count += 1
+                    pending.setdefault(delta.index, PendingToolCall()).apply_delta(
+                        delta
+                    )
+        except Exception:
+            logger.exception(
+                "Agent model call failed id=%s round=%s chunk_count=%s content_deltas=%s reasoning_deltas=%s tool_deltas=%s conversation_messages=%s",
+                assistant_id,
+                round_number,
+                chunk_count,
+                content_delta_count,
+                reasoning_delta_count,
+                tool_delta_count,
+                len(conversation),
+            )
+            raise
 
         tool_calls = [pending[index] for index in sorted(pending)]
+        logger.info(
+            "Agent model call completed id=%s round=%s chunk_count=%s content_deltas=%s reasoning_deltas=%s tool_deltas=%s tool_calls=%s content_length=%s decision=%s",
+            assistant_id,
+            round_number,
+            chunk_count,
+            content_delta_count,
+            reasoning_delta_count,
+            tool_delta_count,
+            len(tool_calls),
+            len(round_content),
+            "run_tools" if tool_calls else "final_response",
+        )
         logger.log(
             TRACE_LEVEL,
-            "Agent round tool calls id=%s tool_calls=%r",
+            "Agent round tool calls id=%s round=%s tool_calls=%r",
             assistant_id,
+            round_number,
             tool_calls,
         )
         if not tool_calls:
             if not final_content and not final_thinking:
                 raise RuntimeError(EMPTY_MODEL_RESPONSE_ERROR)
             logger.info(
-                "Agent response completed id=%s content_length=%s",
+                "Agent response completed id=%s rounds=%s content_length=%s thinking_length=%s decision=final_response",
                 assistant_id,
+                round_number,
                 len(final_content),
+                len(final_thinking),
             )
             logger.log(
                 TRACE_LEVEL,
@@ -301,9 +347,24 @@ async def run_agent_stream(
                 )
             conversation.append(tool_result_message(tool_call_id, result_content))
 
+        logger.info(
+            "Agent continuing after tools id=%s completed_round=%s tool_results=%s conversation_messages=%s decision=continue",
+            assistant_id,
+            round_number,
+            len(tool_calls),
+            len(conversation),
+        )
+
         if context_compactor is not None:
             compaction = await context_compactor(conversation)
             if compaction is not None:
+                logger.info(
+                    "Agent context optimized id=%s round=%s conversation_messages_before=%s conversation_messages_after=%s",
+                    assistant_id,
+                    round_number,
+                    len(conversation),
+                    len(compaction.conversation),
+                )
                 conversation = [dict(message) for message in compaction.conversation]
                 yield AgentStreamEvent(
                     event="context_optimized",

package/backend/src/flowent/llm.py

@@ -1,7 +1,9 @@
 import logging
+import re
 from collections.abc import AsyncIterator, Awaitable, Mapping, Sequence
 from enum import StrEnum
-from typing import Any, Literal, Protocol
+from typing import Any, Literal, Protocol, cast
+from urllib.parse import urlsplit, urlunsplit
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -66,12 +68,26 @@ class ModelListCallable(Protocol):
 logger = logging.getLogger("flowent.llm")
 
 
+class LLMStreamError(RuntimeError):
+    pass
+
+
 MODEL_PREFIXES: dict[ProviderFormat, str] = {
     ProviderFormat.OPENAI: "openai",
     ProviderFormat.OPENAI_RESPONSES: "openai",
     ProviderFormat.ANTHROPIC: "anthropic",
     ProviderFormat.GEMINI: "gemini",
 }
+_litellm_stream_error_patch_installed = False
+
+PROVIDER_API_VERSIONS: dict[ProviderFormat, str] = {
+    ProviderFormat.OPENAI: "v1",
+    ProviderFormat.OPENAI_RESPONSES: "v1",
+    ProviderFormat.ANTHROPIC: "v1",
+    ProviderFormat.GEMINI: "v1beta",
+}
+
+VERSION_PATH_SEGMENT = re.compile(r"^v\d+(?:[a-z]+)?$", re.IGNORECASE)
 
 
 def provider_model_name(connection: ProviderConnection) -> str:
@@ -82,6 +98,40 @@ def provider_litellm_name(provider: ProviderFormat) -> str:
     return MODEL_PREFIXES[provider]
 
 
+def normalize_provider_base_url(
+    provider: ProviderFormat, base_url: str | None
+) -> str | None:
+    if base_url is None:
+        return None
+    raw_base_url = base_url.strip()
+    if not raw_base_url:
+        return None
+    if raw_base_url.endswith("#"):
+        return raw_base_url[:-1].rstrip("/") or None
+
+    trimmed_base_url = raw_base_url.rstrip("/")
+    parsed_base_url = urlsplit(trimmed_base_url)
+    path_segments = [segment for segment in parsed_base_url.path.split("/") if segment]
+    if any(VERSION_PATH_SEGMENT.fullmatch(segment) for segment in path_segments):
+        return trimmed_base_url
+
+    version = PROVIDER_API_VERSIONS[provider]
+    if parsed_base_url.scheme and parsed_base_url.netloc:
+        path = parsed_base_url.path.rstrip("/")
+        normalized_path = f"{path}/{version}" if path else f"/{version}"
+        return urlunsplit(
+            (
+                parsed_base_url.scheme,
+                parsed_base_url.netloc,
+                normalized_path,
+                parsed_base_url.query,
+                parsed_base_url.fragment,
+            )
+        )
+
+    return f"{trimmed_base_url}/{version}"
+
+
 def normalize_provider_model_name(provider: ProviderFormat, model: str) -> str:
     prefix = f"{provider_litellm_name(provider)}/"
     if model.startswith(prefix):
@@ -89,6 +139,71 @@ def normalize_provider_model_name(provider: ProviderFormat, model: str) -> str:
     return model
 
 
+def stream_failure_message(chunk: Any) -> str:
+    if isinstance(chunk, BaseModel):
+        chunk = chunk.model_dump()
+    if not isinstance(chunk, Mapping):
+        return ""
+
+    event_type = getattr(chunk.get("type"), "value", chunk.get("type"))
+    event_type = str(event_type or "")
+    if event_type == "error":
+        error = chunk.get("error", {})
+    elif event_type == "response.failed":
+        response = chunk.get("response", {})
+        error = value_at(response, "error", {})
+    else:
+        return ""
+
+    message = value_at(error, "message", "")
+    if isinstance(message, str) and message:
+        return message
+    code = value_at(error, "code", "")
+    if isinstance(code, str) and code:
+        return code
+    return "Upstream request failed"
+
+
+def raise_for_stream_failure(chunk: Any) -> None:
+    message = stream_failure_message(chunk)
+    if message:
+        raise LLMStreamError(message)
+
+
+def configure_litellm_stream_error_handling() -> None:
+    global _litellm_stream_error_patch_installed
+
+    if _litellm_stream_error_patch_installed:
+        return
+    try:
+        from litellm.completion_extras.litellm_responses_transformation.transformation import (
+            OpenAiResponsesToChatCompletionStreamIterator,
+        )
+    except Exception:
+        return
+
+    if getattr(
+        OpenAiResponsesToChatCompletionStreamIterator,
+        "_flowent_stream_error_patch_installed",
+        False,
+    ):
+        _litellm_stream_error_patch_installed = True
+        return
+
+    transformer = cast(Any, OpenAiResponsesToChatCompletionStreamIterator)
+    original = transformer.translate_responses_chunk_to_openai_stream
+
+    def translate_responses_chunk_to_openai_stream(parsed_chunk: Any) -> Any:
+        raise_for_stream_failure(parsed_chunk)
+        return original(parsed_chunk)
+
+    transformer.translate_responses_chunk_to_openai_stream = staticmethod(
+        translate_responses_chunk_to_openai_stream
+    )
+    transformer._flowent_stream_error_patch_installed = True
+    _litellm_stream_error_patch_installed = True
+
+
 def unique_model_names(provider: ProviderFormat, models: Sequence[str]) -> list[str]:
     seen: set[str] = set()
     normalized_models: list[str] = []
@@ -115,7 +230,7 @@ def list_provider_models(
         model_lister = get_valid_models
 
     models = model_lister(
-        api_base=base_url,
+        api_base=normalize_provider_base_url(provider, base_url),
         api_key=secret_reference,
         check_provider_endpoint=True,
         custom_llm_provider=provider_litellm_name(provider),
@@ -161,8 +276,11 @@ def build_litellm_request(
         request["tools"] = list(tools)
     if stream:
         request["stream"] = True
-    if connection.base_url:
-        request["api_base"] = connection.base_url
+    normalized_base_url = normalize_provider_base_url(
+        connection.provider, connection.base_url
+    )
+    if normalized_base_url:
+        request["api_base"] = normalized_base_url
     if connection.reasoning_effort != ReasoningEffort.DEFAULT:
         request["reasoning_effort"] = connection.reasoning_effort.value
     logger.log(
@@ -170,7 +288,7 @@ def build_litellm_request(
         "Built LiteLLM request provider=%s model=%s base_url=%s stream=%s tools=%s reasoning_effort=%s messages=%r",
         connection.provider,
         connection.model,
-        connection.base_url or "",
+        normalized_base_url or "",
         stream,
         bool(tools),
         connection.reasoning_effort,
@@ -185,7 +303,7 @@ def record_litellm_request_diagnostic(
 ) -> None:
     write_llm_request_diagnostic(
         {
-            "base_url": connection.base_url,
+            "base_url": request.get("api_base"),
             "litellm_model": request["model"],
             "messages": request["messages"],
             "model": connection.model,
@@ -317,6 +435,7 @@ async def stream_chat_chunks(
         from litellm import acompletion
 
         configure_litellm_logging()
+        configure_litellm_stream_error_handling()
         completion = acompletion
 
     logger.debug(
@@ -328,6 +447,7 @@ async def stream_chat_chunks(
     record_litellm_request_diagnostic(connection, request)
     response = await completion(**request)
     async for chunk in response:
+        raise_for_stream_failure(chunk)
         logger.log(TRACE_LEVEL, "LLM stream chunk=%r", chunk)
         yield chunk