ragbits-core 1.4.0.dev202509220622__tar.gz → 1.4.0.dev202511290233__tar.gz

{ragbits_core-1.4.0.dev202509220622 → ragbits_core-1.4.0.dev202511290233}/CHANGELOG.md

@@ -1,6 +1,9 @@
 # CHANGELOG
 
 ## Unreleased
+- Add Support for Thinking in agents (#837)
+
+- Add name parameter and slightly refactor HuggingFace dataloder (#829)
 
 ## 1.3.0 (2025-09-11)
 

{ragbits_core-1.4.0.dev202509220622 → ragbits_core-1.4.0.dev202511290233}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragbits-core
-Version: 1.4.0.dev202509220622
+Version: 1.4.0.dev202511290233
 Summary: Building blocks for rapid development of GenAI applications
 Project-URL: Homepage, https://github.com/deepsense-ai/ragbits
 Project-URL: Bug Reports, https://github.com/deepsense-ai/ragbits/issues
@@ -89,6 +89,8 @@ pip install ragbits-core
 ## Quick Start
 
 ```python
+import asyncio
+
 from pydantic import BaseModel
 from ragbits.core.prompt import Prompt
 from ragbits.core.llms.litellm import LiteLLM

{ragbits_core-1.4.0.dev202509220622 → ragbits_core-1.4.0.dev202511290233}/README.md

@@ -11,6 +11,8 @@ pip install ragbits-core
 ## Quick Start
 
 ```python
+import asyncio
+
 from pydantic import BaseModel
 from ragbits.core.prompt import Prompt
 from ragbits.core.llms.litellm import LiteLLM

{ragbits_core-1.4.0.dev202509220622 → ragbits_core-1.4.0.dev202511290233}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ragbits-core"
-version = "1.4.0.dev202509220622"
+version = "1.4.0.dev202511290233"
 description = "Building blocks for rapid development of GenAI applications"
 readme = "README.md"
 requires-python = ">=3.10"

{ragbits_core-1.4.0.dev202509220622 → ragbits_core-1.4.0.dev202511290233}/src/ragbits/core/llms/litellm.py

@@ -315,8 +315,13 @@ class LiteLLM(LLM[LiteLLMOptions], LazyLiteLLM):
             stream=True,
             stream_options={"include_usage": True},
         )
-        if not response.completion_stream and not response.choices:  # type: ignore
-            raise LLMEmptyResponseError()
+
+        try:
+            if (not response.completion_stream and not response.choices) and not response.reasoning:  # type: ignore
+                raise LLMEmptyResponseError()
+        except AttributeError:
+            # some providers might not include some parameters (i.e. Gemini -> choices)
+            pass
 
         async def response_to_async_generator(response: "CustomStreamWrapper") -> AsyncGenerator[dict, None]:
             nonlocal input_tokens, provider_calculated_usage
@@ -431,9 +436,12 @@ class LiteLLM(LLM[LiteLLMOptions], LazyLiteLLM):
     ) -> "ModelResponse | CustomStreamWrapper":
         entrypoint = self.router or self._create_router_from_self_and_options(options)
 
+        # Preprocess messages for Claude with reasoning enabled
+        processed_conversation = self._preprocess_messages_for_claude(conversation, options)
+
         # Prepare kwargs for the completion call
         completion_kwargs = {
-            "messages": conversation,
+            "messages": processed_conversation,
             "model": self.model_name,
             "response_format": response_format,
             "tools": tools,
@@ -461,6 +469,101 @@ class LiteLLM(LLM[LiteLLMOptions], LazyLiteLLM):
             raise LLMResponseError() from exc
         return response
 
+    def _preprocess_messages_for_claude(self, conversation: ChatFormat, options: LiteLLMOptions) -> ChatFormat:
+        """
+        Preprocess messages for Claude when reasoning is enabled.
+
+        Claude + reasoning_effort + tool calls creates a conflict:
+        - LiteLLM validates messages against OpenAI format (rejects Claude native format)
+        - Claude requires thinking blocks when reasoning_effort is set (rejects OpenAI format)
+
+        Subject to removal after the following are resolved on LiteLLM's side:
+        Issue: https://github.com/BerriAI/litellm/issues/14194
+        Linked PR(s): https://github.com/BerriAI/litellm/pull/15220
+
+        Solution: Summarize tool call history and append to last user message.
+        This provides context to Claude without triggering validation errors.
+
+        Args:
+            conversation: The conversation in OpenAI format
+            options: LLM options including reasoning_effort
+
+        Returns:
+            Processed conversation with tool context included
+        """
+
+        def create_enhanced_user_message(
+            tool_summary_parts: list[str], original_user_msg: str | None
+        ) -> dict[str, Any]:
+            if tool_summary_parts and original_user_msg:
+                enhanced_message = original_user_msg
+                enhanced_message += "\n\n[Previous tool calls in this conversation:"
+
+                for summary in tool_summary_parts:
+                    enhanced_message += f"\n- {summary}"
+                enhanced_message += "\nUse this information to provide your final answer.]"
+                return {"role": "user", "content": enhanced_message}
+
+            return {"role": "user", "content": original_user_msg}
+
+        # Only process for Claude models with reasoning enabled
+        is_claude = "anthropic" in self.model_name.lower() or "claude" in self.model_name.lower()
+        has_reasoning = options.reasoning_effort is not NOT_GIVEN and options.reasoning_effort is not None
+
+        if not (is_claude and has_reasoning):
+            return conversation
+
+        # Check if conversation has tool calls
+        has_tool_calls = any(msg.get("role") == "assistant" and msg.get("tool_calls") for msg in conversation)
+
+        if not has_tool_calls:
+            # No tool calls, conversation is fine as-is
+            return conversation
+
+        # Build tool call summary from conversation history
+        tool_summary_parts = []
+        i = 0
+        while i < len(conversation):
+            msg = conversation[i]
+            if msg.get("role") == "assistant" and msg.get("tool_calls"):
+                # Found assistant message with tool calls
+                for tool_call in msg["tool_calls"]:
+                    tool_name = tool_call["function"]["name"]
+                    tool_args = tool_call["function"]["arguments"]
+                    tool_id = tool_call["id"]
+
+                    # Find corresponding tool result
+                    tool_result = None
+                    for j in range(i + 1, len(conversation)):
+                        if conversation[j].get("role") == "tool" and conversation[j].get("tool_call_id") == tool_id:
+                            tool_result = conversation[j].get("content")
+                            break
+
+                    if tool_result:
+                        tool_summary_parts.append(f"{tool_name}({tool_args}) returned: {tool_result}")
+            i += 1
+
+        # Build processed conversation
+        processed = []
+
+        # Keep system message if present
+        for msg in conversation:
+            if msg.get("role") == "system":
+                processed.append(msg)
+                break
+
+        # Get the original user message (first non-system)
+        original_user_msg = None
+        for msg in conversation:
+            if msg.get("role") == "user":
+                original_user_msg = msg.get("content", "")
+                break
+
+        # Create enhanced user message with tool context
+        processed.append(create_enhanced_user_message(tool_summary_parts, original_user_msg))
+
+        return processed
+
     def _get_response_format(
         self, output_schema: type[BaseModel] | dict | None, json_mode: bool
     ) -> type[BaseModel] | dict | None:

{ragbits_core-1.4.0.dev202509220622 → ragbits_core-1.4.0.dev202511290233}/src/ragbits/core/sources/hf.py

@@ -1,7 +1,7 @@
 import re
 from collections.abc import Iterable
 from pathlib import Path
-from typing import ClassVar
+from typing import TYPE_CHECKING, ClassVar, TypeAlias
 
 from typing_extensions import Self
 
@@ -10,6 +10,11 @@ from ragbits.core.sources.base import Source, get_local_storage_dir
 from ragbits.core.sources.exceptions import SourceConnectionError, SourceNotFoundError
 from ragbits.core.utils.decorators import requires_dependencies
 
+if TYPE_CHECKING:
+    from datasets import Dataset, DatasetDict, IterableDataset, IterableDatasetDict
+
+    HFDataset: TypeAlias = Dataset | DatasetDict | IterableDataset | IterableDatasetDict
+
 
 class HuggingFaceSource(Source):
     """
@@ -23,6 +28,7 @@ class HuggingFaceSource(Source):
 
     protocol: ClassVar[str] = "hf"
     path: str
+    name: str | None = None
     split: str = "train"
     row: int | None = None
 
@@ -33,6 +39,32 @@ class HuggingFaceSource(Source):
         """
         return f"hf:{self.path}/{self.split}{f'/{self.row}' if self.row is not None else ''}"
 
+    def _load_dataset(self, streaming: bool = False) -> "HFDataset":
+        """
+        Load the dataset from Hugging Face.
+
+        Args:
+            streaming: Whether to stream the dataset.
+
+        Returns:
+            The loaded dataset.
+
+        Raises:
+            SourceConnectionError: If the source connection fails.
+            SourceNotFoundError: If the source dataset is not found.
+        """
+        from datasets import load_dataset
+        from datasets.exceptions import DatasetNotFoundError
+
+        try:
+            if self.name is not None and str(self.name).strip():
+                return load_dataset(self.path, self.name, split=self.split, streaming=streaming)
+            return load_dataset(self.path, split=self.split, streaming=streaming)
+        except ConnectionError as exc:
+            raise SourceConnectionError() from exc
+        except DatasetNotFoundError as exc:
+            raise SourceNotFoundError(source_id=self.id) from exc
+
     @requires_dependencies(["datasets"], "hf")
     async def fetch(self) -> Path:
         """
@@ -45,17 +77,9 @@ class HuggingFaceSource(Source):
             SourceConnectionError: If the source connection fails.
             SourceNotFoundError: If the source document is not found.
         """
-        from datasets import load_dataset
-        from datasets.exceptions import DatasetNotFoundError
-
         with trace(path=self.path, split=self.split, row=self.row) as outputs:
             if self.row is not None:
-                try:
-                    dataset = load_dataset(self.path, split=self.split, streaming=True)
-                except ConnectionError as exc:
-                    raise SourceConnectionError() from exc
-                except DatasetNotFoundError as exc:
-                    raise SourceNotFoundError(source_id=self.id) from exc
+                dataset = self._load_dataset(streaming=True)
 
                 try:
                     data = next(iter(dataset.skip(self.row).take(1)))
@@ -78,13 +102,7 @@ class HuggingFaceSource(Source):
                 path = source_dir / f"{self.split}.json"
 
                 if not path.is_file():
-                    try:
-                        dataset = load_dataset(self.path, split=self.split)
-                    except ConnectionError as exc:
-                        raise SourceConnectionError() from exc
-                    except DatasetNotFoundError as exc:
-                        raise SourceNotFoundError(source_id=self.id) from exc
-
+                    dataset = self._load_dataset(streaming=False)
                     dataset.to_json(path)
                 outputs.path = path