fix: code review bugs + bump both packages to 1.6.0

Bug fixes (critical):
- callbacks.py: add ABC to UiPathDynamicHeadersCallback so @AbstractMethod
  is enforced — previously the class could be instantiated without implementing
  get_headers(), silently deferring the error to runtime
- clients/anthropic/chat_models.py: make vendor_type a required field (no default)
  and seed api_config with VendorType.VERTEXAI as placeholder; the old default of
  VendorType.ANTHROPIC caused the model validator to immediately raise ValueError,
  making the class impossible to construct directly; also removed dead
  VendorType.ANTHROPIC / VendorType.AZURE branches from _anthropic_client and
  _async_anthropic_client that could never be reached, and unused imports
- clients/bedrock/utils.py: fix json.loads(kwargs.get('body', {})) — passing a
  dict as default caused TypeError since json.loads requires str/bytes; changed
  default to '{}' string; also corrected converse() and converse_stream()
  system parameter type annotation from str|None to list[dict[str,Any]]|None to
  match the list[dict] value langchain-aws actually passes
- clients/normalized/chat_models.py: add 'stream': True to request body in
  _uipath_stream and _uipath_astream — without it the server returns a regular
  non-streaming JSON response instead of SSE; fix fragile SSE prefix stripping
  from chunk.split('data:')[1] (splits on all occurrences) to
  chunk[len('data:'):].strip(); fix _generate_chunk to set text=content or ''
  instead of text=original_message (raw JSON wire data)
- factory.py: replace bare model_info['vendor'] key access in get_embedding_model
  with model_info.get('vendor') + explicit ValueError, matching the safe pattern
  already used in get_chat_model

Bug fixes (minor):
- base_client.py: correct return type annotations on _astream, _uipath_astream,
  and uipath_astream from AsyncIterator to AsyncGenerator (these are async
  generator functions that contain yield, not plain iterables)
- demo.py: replace unsafe eval(expression) with an AST-based arithmetic-only
  evaluator to prevent arbitrary code execution via LLM-generated input

Version bumps:
- packages/uipath_langchain_client: 1.5.10 -> 1.6.0
- src/uipath/llm_client:             1.5.10 -> 1.6.0

Author: cosminacho

packages/uipath_langchain_client/demo.py

@@ -136,8 +136,20 @@ def calculate(expression: str) -> str:
         Args:
             expression: A mathematical expression to evaluate (e.g., "2 + 2").
         """
+        import ast
         try:
-            result = eval(expression)
+            # Restrict to a safe subset: only literals and basic arithmetic operators.
+            # This prevents arbitrary code execution via eval().
+            tree = ast.parse(expression, mode="eval")
+            allowed_node_types = (
+                ast.Expression, ast.BinOp, ast.UnaryOp, ast.Constant,
+                ast.Add, ast.Sub, ast.Mult, ast.Div, ast.FloorDiv,
+                ast.Mod, ast.Pow, ast.USub, ast.UAdd,
+            )
+            for node in ast.walk(tree):
+                if not isinstance(node, allowed_node_types):
+                    return f"Error: unsupported operation in expression"
+            result = eval(compile(tree, "<string>", "eval"), {"__builtins__": {}})
             return str(result)
         except Exception as e:
             return f"Error: {e}"

packages/uipath_langchain_client/src/uipath_langchain_client/__version__.py

@@ -1,3 +1,3 @@
 __title__ = "UiPath LangChain Client"
 __description__ = "A Python client for interacting with UiPath's LLM services via LangChain."
-__version__ = "1.5.10"
+__version__ = "1.6.0"

packages/uipath_langchain_client/src/uipath_langchain_client/base_client.py

@@ -25,7 +25,7 @@
 
 import logging
 from abc import ABC
-from collections.abc import AsyncIterator, Iterator, Mapping, Sequence
+from collections.abc import AsyncGenerator, AsyncIterator, Iterator, Mapping, Sequence
 from functools import cached_property
 from typing import Any, Literal
 
@@ -282,7 +282,7 @@ async def uipath_astream(
         stream_type: Literal["text", "bytes", "lines", "raw"] = "lines",
         raise_status_error: bool = False,
         **kwargs: Any,
-    ) -> AsyncIterator[str | bytes]:
+    ) -> AsyncGenerator[str | bytes, None]:
         """Make an asynchronous streaming HTTP request to the UiPath API.
 
         Args:
@@ -423,7 +423,7 @@ async def _astream(
         stop: list[str] | None = None,
         run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
-    ) -> AsyncIterator[ChatGenerationChunk]:
+    ) -> AsyncGenerator[ChatGenerationChunk, None]:
         set_captured_response_headers({})
         try:
             first = True
@@ -443,7 +443,7 @@ async def _uipath_astream(
         stop: list[str] | None = None,
         run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
-    ) -> AsyncIterator[ChatGenerationChunk]:
+    ) -> AsyncGenerator[ChatGenerationChunk, None]:
         """Override in subclasses to provide the core (non-wrapped) async stream logic."""
         async for chunk in super()._astream(messages, stop=stop, run_manager=run_manager, **kwargs):
             yield chunk

packages/uipath_langchain_client/src/uipath_langchain_client/callbacks.py

@@ -1,14 +1,14 @@
 """LangChain callbacks for dynamic per-request header injection."""
 
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from typing import Any
 
 from langchain_core.callbacks import BaseCallbackHandler
 
 from uipath.llm_client.utils.headers import set_dynamic_request_headers
 
 
-class UiPathDynamicHeadersCallback(BaseCallbackHandler):
+class UiPathDynamicHeadersCallback(BaseCallbackHandler, ABC):
     """Base callback for injecting dynamic headers into each LLM gateway request.
 
     Extend this class and implement ``get_headers()`` to return the headers to

packages/uipath_langchain_client/src/uipath_langchain_client/clients/anthropic/chat_models.py

@@ -15,13 +15,9 @@
 
 try:
     from anthropic import (
-        Anthropic,
         AnthropicBedrock,
-        AnthropicFoundry,
         AnthropicVertex,
-        AsyncAnthropic,
         AsyncAnthropicBedrock,
-        AsyncAnthropicFoundry,
         AsyncAnthropicVertex,
     )
     from langchain_anthropic.chat_models import ChatAnthropic
@@ -33,13 +29,18 @@
 
 
 class UiPathChatAnthropic(UiPathBaseChatModel, ChatAnthropic):
+    # api_config.vendor_type is a placeholder here; the model_validator below
+    # always overwrites it (and api_flavor / api_version) from self.vendor_type.
+    # VendorType.VERTEXAI is used as the seed so UiPathAPIConfig's own validator
+    # (which requires vendor_type when routing_mode=PASSTHROUGH) is satisfied.
     api_config: UiPathAPIConfig = UiPathAPIConfig(
         api_type=ApiType.COMPLETIONS,
         routing_mode=RoutingMode.PASSTHROUGH,
-        vendor_type=VendorType.ANTHROPIC,
+        vendor_type=VendorType.VERTEXAI,
         freeze_base_url=True,
     )
-    vendor_type: VendorType = VendorType.ANTHROPIC
+    # Required — caller must supply VendorType.VERTEXAI or VendorType.AWSBEDROCK.
+    vendor_type: VendorType
 
     @model_validator(mode="after")
     def setup_api_flavor_and_version(self) -> Self:
@@ -52,7 +53,8 @@ def setup_api_flavor_and_version(self) -> Self:
                 self.api_config.api_flavor = ApiFlavor.INVOKE
             case _:
                 raise ValueError(
-                    "anthropic and azure vendors are currently not supported by UiPath"
+                    f"vendor_type '{self.vendor_type}' is not supported by UiPathChatAnthropic. "
+                    "Use VendorType.VERTEXAI or VendorType.AWSBEDROCK."
                 )
         return self
 
@@ -64,24 +66,8 @@ def setup_api_flavor_and_version(self) -> Self:
     @cached_property
     def _anthropic_client(
         self,
-    ) -> Anthropic | AnthropicVertex | AnthropicBedrock | AnthropicFoundry:
+    ) -> AnthropicVertex | AnthropicBedrock:
         match self.vendor_type:
-            case VendorType.ANTHROPIC:
-                return Anthropic(
-                    api_key="PLACEHOLDER",
-                    base_url=str(self.uipath_sync_client.base_url),
-                    default_headers=dict(self.uipath_sync_client.headers),
-                    max_retries=0,  # handled by the UiPathBaseChatModel
-                    http_client=self.uipath_sync_client,
-                )
-            case VendorType.AZURE:
-                return AnthropicFoundry(
-                    api_key="PLACEHOLDER",
-                    base_url=str(self.uipath_sync_client.base_url),
-                    default_headers=dict(self.uipath_sync_client.headers),
-                    max_retries=0,  # handled by the UiPathBaseChatModel
-                    http_client=self.uipath_sync_client,
-                )
             case VendorType.VERTEXAI:
                 return AnthropicVertex(
                     region="PLACEHOLDER",
@@ -103,29 +89,15 @@ def _anthropic_client(
                     http_client=self.uipath_sync_client,
                 )
             case _:
-                raise ValueError("Anthropic models are currently not hosted on any other provider")
+                raise ValueError(
+                    f"vendor_type '{self.vendor_type}' is not supported by UiPathChatAnthropic."
+                )
 
     @cached_property
     def _async_anthropic_client(
         self,
-    ) -> AsyncAnthropic | AsyncAnthropicVertex | AsyncAnthropicBedrock | AsyncAnthropicFoundry:
+    ) -> AsyncAnthropicVertex | AsyncAnthropicBedrock:
         match self.vendor_type:
-            case VendorType.ANTHROPIC:
-                return AsyncAnthropic(
-                    api_key="PLACEHOLDER",
-                    base_url=str(self.uipath_async_client.base_url),
-                    default_headers=dict(self.uipath_async_client.headers),
-                    max_retries=0,  # handled by the UiPathBaseChatModel
-                    http_client=self.uipath_async_client,
-                )
-            case VendorType.AZURE:
-                return AsyncAnthropicFoundry(
-                    api_key="PLACEHOLDER",
-                    base_url=str(self.uipath_async_client.base_url),
-                    default_headers=dict(self.uipath_async_client.headers),
-                    max_retries=0,  # handled by the UiPathBaseChatModel
-                    http_client=self.uipath_async_client,
-                )
             case VendorType.VERTEXAI:
                 return AsyncAnthropicVertex(
                     region="PLACEHOLDER",
@@ -147,7 +119,9 @@ def _async_anthropic_client(
                     http_client=self.uipath_async_client,
                 )
             case _:
-                raise ValueError("Anthropic models are currently not hosted on any other provider")
+                raise ValueError(
+                    f"vendor_type '{self.vendor_type}' is not supported by UiPathChatAnthropic."
+                )
 
     @override
     def _create(self, payload: dict) -> Any:

packages/uipath_langchain_client/src/uipath_langchain_client/clients/bedrock/utils.py

@@ -71,15 +71,19 @@ def invoke_model(self, **kwargs: Any) -> Any:
         return {
             "body": self.httpx_client.post(
                 "/",
-                json=json.loads(kwargs.get("body", {})),
+                json=json.loads(kwargs.get("body", "{}")),
             )
         }
 
     def invoke_model_with_response_stream(self, **kwargs: Any) -> Any:
-        return {"body": self._stream_generator(json.loads(kwargs.get("body", {})))}
+        return {"body": self._stream_generator(json.loads(kwargs.get("body", "{}")))}
 
     def converse(
-        self, *, messages: list[dict[str, Any]], system: str | None = None, **params: Any
+        self,
+        *,
+        messages: list[dict[str, Any]],
+        system: list[dict[str, Any]] | None = None,
+        **params: Any,
     ) -> Any:
         if self.httpx_client is None:
             raise ValueError("httpx_client is not set")
@@ -95,7 +99,11 @@ def converse(
         ).json()
 
     def converse_stream(
-        self, *, messages: list[dict[str, Any]], system: str | None = None, **params: Any
+        self,
+        *,
+        messages: list[dict[str, Any]],
+        system: list[dict[str, Any]] | None = None,
+        **params: Any,
     ) -> Any:
         return {
             "stream": self._stream_generator(

packages/uipath_langchain_client/src/uipath_langchain_client/clients/normalized/chat_models.py

@@ -24,7 +24,7 @@
 """
 
 import json
-from collections.abc import AsyncIterator, Callable, Iterator, Sequence
+from collections.abc import AsyncGenerator, AsyncIterator, Callable, Iterator, Sequence
 from typing import Any
 
 from langchain_core.callbacks import (
@@ -377,10 +377,10 @@ def _generate_chunk(
                 )
 
         return ChatGenerationChunk(
-            text=original_message,
+            text=content or "",
             generation_info=generation_info,
             message=AIMessageChunk(
-                content=content,
+                content=content or "",
                 usage_metadata=usage_metadata,
                 tool_call_chunks=tool_call_chunks,
             ),
@@ -394,12 +394,13 @@ def _uipath_stream(
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
         request_body = self._preprocess_request(messages, stop=stop, **kwargs)
+        request_body["stream"] = True
         for chunk in self.uipath_stream(
             request_body=request_body, stream_type="lines", raise_status_error=True
         ):
             chunk = str(chunk)
             if chunk.startswith("data:"):
-                chunk = chunk.split("data:")[1].strip()
+                chunk = chunk[len("data:"):].strip()
             try:
                 json_data = json.loads(chunk)
             except json.JSONDecodeError:
@@ -414,14 +415,15 @@ async def _uipath_astream(
         stop: list[str] | None = None,
         run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
-    ) -> AsyncIterator[ChatGenerationChunk]:
+    ) -> AsyncGenerator[ChatGenerationChunk, None]:
         request_body = self._preprocess_request(messages, stop=stop, **kwargs)
+        request_body["stream"] = True
         async for chunk in self.uipath_astream(
             request_body=request_body, stream_type="lines", raise_status_error=True
         ):
             chunk = str(chunk)
             if chunk.startswith("data:"):
-                chunk = chunk.split("data:")[1].strip()
+                chunk = chunk[len("data:"):].strip()
             try:
                 json_data = json.loads(chunk)
             except json.JSONDecodeError:

packages/uipath_langchain_client/src/uipath_langchain_client/factory.py

@@ -298,7 +298,13 @@ def get_embedding_model(
             **model_kwargs,
         )
 
-    discovered_vendor_type = model_info["vendor"].lower()
+    discovered_vendor_type = model_info.get("vendor")
+    if discovered_vendor_type is None:
+        raise ValueError(
+            f"No vendor type found in model info for embedding model '{model_name}'. "
+            f"Model info returned: {model_info}"
+        )
+    discovered_vendor_type = discovered_vendor_type.lower()
     match discovered_vendor_type:
         case VendorType.OPENAI:
             if is_uipath_owned:

src/uipath/llm_client/__version__.py

@@ -1,3 +1,3 @@
 __title__ = "UiPath LLM Client"
 __description__ = "A Python client for interacting with UiPath's LLM services."
-__version__ = "1.5.10"
+__version__ = "1.6.0"