unique_toolkit 0.8.16__tar.gz → 0.8.18__tar.gz

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.18] - 2025-08-22
+- moved class variables into instance variables
+
+## [0.8.17] - 2025-08-22
+- fixed circular dependencies in tools
+
 ## [0.8.16] - 2025-08-19
 - moved Hallucination evaluator into toolkit
 

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 0.8.16
+Version: 0.8.18
 Summary: 
 License: Proprietary
 Author: Martin Fadler
@@ -114,6 +114,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.18] - 2025-08-22
+- moved class variables into instance variables
+
+## [0.8.17] - 2025-08-22
+- fixed circular dependencies in tools
+
 ## [0.8.16] - 2025-08-19
 - moved Hallucination evaluator into toolkit
 

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unique_toolkit"
-version = "0.8.16"
+version = "0.8.18"
 description = ""
 authors = [
     "Martin Fadler <martin.fadler@unique.ch>",

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/unique_toolkit/_common/token/token_counting.py

@@ -5,15 +5,14 @@ import json
 from typing import Any, Callable
 
 from pydantic import BaseModel
+from unique_toolkit._common.token.image_token_counting import calculate_image_tokens_from_base64
 from unique_toolkit.language_model import (
     LanguageModelMessage,
     LanguageModelMessages,
     LanguageModelName,
 )
 
-from _common.utils.token.image_token_counting import (
-    calculate_image_tokens_from_base64,
-)
+
 
 
 class SpecialToolCallingTokens(BaseModel):

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/unique_toolkit/_common/validators.py

@@ -28,6 +28,13 @@ LMI = Annotated[
     ),
 ]
 
+def get_LMI_default_field(llm_name: LanguageModelName, **kwargs) -> Any:
+    return Field(
+        default=LanguageModelInfo.from_name(llm_name),
+        json_schema_extra={"default": llm_name},
+        **kwargs,
+    )
+
 
 def serialize_lmi(model: LanguageModelInfo) -> str | LanguageModelInfo:
     if model.provider == LanguageModelProvider.CUSTOM:

unique_toolkit-0.8.18/unique_toolkit/debug_info_manager/debug_info_manager.py

@@ -0,0 +1,19 @@
+from unique_toolkit.content.schemas import ContentChunk, ContentReference
+from unique_toolkit.tools.schemas import ToolCallResponse
+
+
+class DebugInfoManager:
+    def __init__(self):
+        self.debug_info = {"tools": []}
+
+    def extract_tool_debug_info(self, tool_call_responses: list[ToolCallResponse]):
+        for tool_call_response in tool_call_responses:
+            self.debug_info["tools"].append(
+                {"name": tool_call_response.name, "data": tool_call_response.debug_info}
+            )
+
+    def add(self, key, value):
+        self.debug_info = self.debug_info | {key: value}
+
+    def get(self):
+        return self.debug_info

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/unique_toolkit/evals/evaluation_manager.py

@@ -74,8 +74,7 @@ class EvaluationManager:
     The EvaluationManager serves as the central hub for managing and executing evaluations.
     """
     # a hashmap to hold evaluations by their names
-    _evaluations: dict[EvaluationMetricName, Evaluation] = {}
-    _evaluation_passed: bool = True
+
 
     def __init__(
         self,
@@ -86,6 +85,8 @@ class EvaluationManager:
         self._logger = logger
         self._chat_service = chat_service
         self._assistant_message_id = assistant_message_id
+        self._evaluations: dict[EvaluationMetricName, Evaluation] = {}
+        self._evaluation_passed: bool = True
 
     def add_evaluation(self, evaluation: Evaluation):
         self._evaluations[evaluation.get_name()] = evaluation

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/unique_toolkit/evals/hallucination/hallucination_evaluation.py

@@ -1,24 +1,23 @@
 from typing import Any
 
-from unique_toolkit.unique_toolkit.app.schemas import ChatEvent
-from unique_toolkit.unique_toolkit.chat.schemas import (
+from unique_toolkit.app.schemas import ChatEvent
+from unique_toolkit.chat.schemas import (
     ChatMessageAssessmentLabel,
     ChatMessageAssessmentStatus,
     ChatMessageAssessmentType,
 )
-from unique_toolkit.unique_toolkit.evals.config import EvaluationMetricConfig
-from unique_toolkit.unique_toolkit.evals.evaluation_manager import Evaluation
-from unique_toolkit.unique_toolkit.evals.hallucination.utils import check_hallucination
-from unique_toolkit.unique_toolkit.evals.schemas import (
+from unique_toolkit.evals.evaluation_manager import Evaluation
+from unique_toolkit.evals.hallucination.utils import check_hallucination
+from unique_toolkit.evals.schemas import (
     EvaluationAssessmentMessage,
     EvaluationMetricInput,
     EvaluationMetricName,
     EvaluationMetricResult,
 )
-from unique_toolkit.unique_toolkit.evals.hallucination.constants import (
+from unique_toolkit.evals.hallucination.constants import (
     HallucinationConfig,
 )
-from unique_toolkit.unique_toolkit.reference_manager.reference_manager import (
+from unique_toolkit.reference_manager.reference_manager import (
     ReferenceManager,
 )
 

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/unique_toolkit/history_manager/history_construction_with_contents.py

@@ -9,10 +9,10 @@ import tiktoken
 
 from pydantic import RootModel
 
-from _common.token.token_counting import num_tokens_per_language_model_message
-from chat.service import ChatService
-from content.service import ContentService
-from language_model.schemas import LanguageModelMessages
+from unique_toolkit._common.token.token_counting import num_tokens_per_language_model_message
+from unique_toolkit.chat.service import ChatService
+from unique_toolkit.content.service import ContentService
+from unique_toolkit.language_model.schemas import LanguageModelMessages
 from unique_toolkit.app import ChatEventUserMessage
 from unique_toolkit.chat.schemas import ChatMessage
 from unique_toolkit.chat.schemas import ChatMessageRole as ChatRole

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/unique_toolkit/history_manager/history_manager.py

@@ -1,92 +1,84 @@
-from datetime import datetime
 from logging import Logger
 from typing import Annotated, Awaitable, Callable
 
 from pydantic import BaseModel, Field
 
-import tiktoken
 from unique_toolkit.app.schemas import ChatEvent
 
 
-from unique_toolkit.chat.schemas import ChatMessage
-from unique_toolkit.chat.service import ChatService
-from unique_toolkit.content.schemas import Content
-from unique_toolkit.content.service import ContentService
-from unique_toolkit.language_model.builder import MessagesBuilder
+
 from unique_toolkit.language_model.schemas import (
     LanguageModelAssistantMessage,
     LanguageModelFunction,
-    LanguageModelMessage,
-    LanguageModelMessageRole,
+    LanguageModelMessage,   
     LanguageModelMessages,
-    LanguageModelSystemMessage,
-    LanguageModelToolMessage,
-    LanguageModelUserMessage,
+    LanguageModelToolMessage
 )
 
 from unique_toolkit.tools.schemas import ToolCallResponse
 from unique_toolkit.history_manager.utils import transform_chunks_to_string
 
-from _common.validators import LMI
-from history_manager.loop_token_reducer import LoopTokenReducer
-from reference_manager.reference_manager import ReferenceManager
-from tools.config import get_configuration_dict
+from unique_toolkit._common.validators import LMI
+from unique_toolkit.history_manager.loop_token_reducer import LoopTokenReducer
+from unique_toolkit.language_model.infos import LanguageModelInfo, LanguageModelName
+from unique_toolkit.reference_manager.reference_manager import ReferenceManager
+from unique_toolkit.tools.config import get_configuration_dict
 
 DeactivatedNone = Annotated[
     None,
     Field(title="Deactivated", description="None"),
 ]
 
-class HistoryManagerConfig(BaseModel):
+class UploadedContentConfig(BaseModel):
+    model_config = get_configuration_dict()
 
-    class InputTokenDistributionConfig(BaseModel):
-        model_config = get_configuration_dict(frozen=True)
+    user_context_window_limit_warning: str = Field(
+        default="The uploaded content is too large to fit into the ai model. "
+        "Unique AI will search for relevant sections in the material and if needed combine the data with knowledge base content",
+        description="Message to show when using the Internal Search instead of upload and chat tool due to context window limit. Jinja template.",
+    )
+    percent_for_uploaded_content: float = Field(
+        default=0.6,
+        ge=0.0,
+        lt=1.0,
+        description="The fraction of the max input tokens that will be reserved for the uploaded content.",
+    )
 
-        percent_for_history: float = Field(
-            default=0.6,
-            ge=0.0,
-            lt=1.0,
-            description="The fraction of the max input tokens that will be reserved for the history.",
-        )
+class ExperimentalFeatures(BaseModel):
 
-        def max_history_tokens(self, max_input_token: int) -> int:
-            return int(self.percent_for_history * max_input_token)
-    
-    class UploadedContentConfig(BaseModel):
-        model_config = get_configuration_dict()
+    full_sources_serialize_dump: bool = Field(
+        default=False,
+        description="If True, the sources will be serialized in full, otherwise only the content will be serialized.",
+    )
 
-        user_context_window_limit_warning: str = Field(
-            default="The uploaded content is too large to fit into the ai model. "
-            "Unique AI will search for relevant sections in the material and if needed combine the data with knowledge base content",
-            description="Message to show when using the Internal Search instead of upload and chat tool due to context window limit. Jinja template.",
-        )
-        percent_for_uploaded_content: float = Field(
-            default=0.6,
-            ge=0.0,
-            lt=1.0,
-            description="The fraction of the max input tokens that will be reserved for the uploaded content.",
-        )
 
-    class ExperimentalFeatures(BaseModel):
-        def __init__(self, full_sources_serialize_dump: bool = False):
-            self.full_sources_serialize_dump = full_sources_serialize_dump
+class HistoryManagerConfig(BaseModel):
 
-        full_sources_serialize_dump: bool = Field(
-            default=False,
-            description="If True, the sources will be serialized in full, otherwise only the content will be serialized.",
-        )
 
     experimental_features: ExperimentalFeatures = Field(
         default=ExperimentalFeatures(),
         description="Experimental features for the history manager.",
     )
 
-    max_history_tokens: int = Field(
-        default=8000,
-        ge=0,
-        description="The maximum number of tokens to keep in the history.",
+
+    percent_of_max_tokens_for_history: float = Field(
+        default=0.2,
+        ge=0.0,
+        lt=1.0,
+        description="The fraction of the max input tokens that will be reserved for the history.",
+    )
+
+    language_model: LMI = LanguageModelInfo.from_name(
+        LanguageModelName.AZURE_GPT_4o_2024_1120
     )
 
+    @property
+    def max_history_tokens(self) -> int:
+        return int(
+            self.language_model.token_limits.token_limit_input
+            * self.percent_of_max_tokens_for_history,
+        )
+
     uploaded_content_config: (
         Annotated[
             UploadedContentConfig,
@@ -96,11 +88,6 @@ class HistoryManagerConfig(BaseModel):
     ) = UploadedContentConfig()
 
 
-    input_token_distribution: InputTokenDistributionConfig = Field(
-        default=InputTokenDistributionConfig(),
-        description="Configuration for the input token distribution.",
-    )
-
 
 class HistoryManager:
     """
@@ -122,9 +109,7 @@ class HistoryManager:
 
     The HistoryManager serves as the backbone for managing and retrieving conversation history in a structured and efficient manner.
     """
-    _tool_call_result_history: list[ToolCallResponse] = []
-    _loop_history: list[LanguageModelMessage] = []
-    _source_enumerator = 0
+
 
     def __init__(
         self,
@@ -140,10 +125,14 @@ class HistoryManager:
         self._token_reducer = LoopTokenReducer(
             logger=self._logger,
             event=event,
-            config=self._config,
+            max_history_tokens=self._config.max_history_tokens,
+            has_uploaded_content_config=bool(self._config.uploaded_content_config),
             language_model=self._language_model,
             reference_manager=reference_manager,
         )
+        self._tool_call_result_history: list[ToolCallResponse] = []
+        self._loop_history: list[LanguageModelMessage] = []
+        self._source_enumerator = 0
 
 
     def has_no_loop_messages(self) -> bool:
@@ -220,6 +209,8 @@ class HistoryManager:
         rendered_system_message_string: str,
         remove_from_text: Callable[[str], Awaitable[str]]
     ) -> LanguageModelMessages:
+        self._logger.info("Getting history for model call -> ")
+
         messages = await self._token_reducer.get_history_for_model_call(
             original_user_message=original_user_message,
             rendered_user_message_string=rendered_user_message_string,

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/unique_toolkit/history_manager/loop_token_reducer.py

@@ -5,16 +5,15 @@ from typing import Awaitable, Callable
 
 from pydantic import BaseModel
 import tiktoken
-from _common.token.token_counting import num_token_for_language_model_messages
-from _common.validators import LMI
-from app.schemas import ChatEvent
-from chat.service import ChatService
-from content.schemas import ContentChunk
-from content.service import ContentService
-from history_manager.history_construction_with_contents import FileContentSerialization, get_full_history_with_contents
-from history_manager.history_manager import HistoryManagerConfig
-from language_model.schemas import LanguageModelAssistantMessage, LanguageModelMessage, LanguageModelMessageRole, LanguageModelMessages, LanguageModelSystemMessage, LanguageModelToolMessage, LanguageModelUserMessage
-from reference_manager.reference_manager import ReferenceManager
+from unique_toolkit._common.token.token_counting import num_token_for_language_model_messages
+from unique_toolkit._common.validators import LMI
+from unique_toolkit.app.schemas import ChatEvent
+from unique_toolkit.chat.service import ChatService
+from unique_toolkit.content.schemas import ContentChunk
+from unique_toolkit.content.service import ContentService
+from unique_toolkit.history_manager.history_construction_with_contents import FileContentSerialization, get_full_history_with_contents
+from unique_toolkit.language_model.schemas import LanguageModelAssistantMessage, LanguageModelMessage, LanguageModelMessageRole, LanguageModelMessages, LanguageModelSystemMessage, LanguageModelToolMessage, LanguageModelUserMessage
+from unique_toolkit.reference_manager.reference_manager import ReferenceManager
 
 
 class SourceReductionResult(BaseModel):
@@ -33,11 +32,14 @@ class LoopTokenReducer():
         self,
         logger: Logger,
         event: ChatEvent,
-        config: HistoryManagerConfig,
+        max_history_tokens:int,
+        has_uploaded_content_config: bool,
         reference_manager: ReferenceManager,
         language_model: LMI
     ):
-        self._config = config
+        
+        self._max_history_tokens = max_history_tokens
+        self._has_uploaded_content_config = has_uploaded_content_config
         self._logger = logger
         self._reference_manager = reference_manager
         self._language_model = language_model
@@ -49,7 +51,7 @@ class LoopTokenReducer():
     
 
     def _get_encoder(self, language_model: LMI) -> tiktoken.Encoding:
-        name = language_model.name or "cl100k_base"
+        name = language_model.encoder_name or "cl100k_base"
         return tiktoken.get_encoding(name)
 
     async def get_history_for_model_call( self,
@@ -203,7 +205,7 @@ class LoopTokenReducer():
                 content_service=self._content_service,
                 file_content_serialization_type=(
                     FileContentSerialization.NONE
-                    if self._config.uploaded_content_config
+                    if self._has_uploaded_content_config
                     else FileContentSerialization.FILE_NAME
                 ),
             )
@@ -212,9 +214,7 @@ class LoopTokenReducer():
         
         limited_history_messages = self._limit_to_token_window(
             full_history.root,
-            self._config.input_token_distribution.max_history_tokens(
-                self._language_model.token_limits.token_limit_input,
-            )
+            self._max_history_tokens
         )
         
         

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/unique_toolkit/postprocessor/postprocessor_manager.py

@@ -4,10 +4,9 @@ from logging import Logger
 
 from unique_toolkit.chat.service import ChatService
 from unique_toolkit.language_model.schemas import (
-    LanguageModelMessage,
     LanguageModelStreamResponse,
 )
-from unique_toolkit.tools.utils.execution.execution import Result, SafeTaskExecutor
+from unique_toolkit.tools.utils.execution.execution import SafeTaskExecutor
 
 
 class Postprocessor(ABC):
@@ -53,7 +52,7 @@ class PostprocessorManager:
     The PostprocessorManager serves as a centralized system for managing and applying postprocessing logic to enhance response quality and consistency.
     """
 
-    _postprocessors: list[Postprocessor] = []
+    
 
     def __init__(
         self,
@@ -62,6 +61,7 @@ class PostprocessorManager:
     ):
         self._logger = logger
         self._chat_service = chat_service
+        self._postprocessors: list[Postprocessor] = []
 
     def add_postprocessor(self, postprocessor: Postprocessor):
         self._postprocessors.append(postprocessor)

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/unique_toolkit/tools/factory.py

@@ -1,13 +1,18 @@
 from typing import Callable
 
-from typing import TYPE_CHECKING
-from unique_toolkit.tools.schemas import BaseToolConfig
+
 from unique_toolkit.tools.tool import Tool
 
+from unique_toolkit.tools.schemas import BaseToolConfig
+
+
+from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from unique_toolkit.tools.config import ToolBuildConfig
 
 
+
+
 class ToolFactory:
     tool_map: dict[str, type[Tool]] = {}
     tool_config_map: dict[str, Callable] = {}

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/unique_toolkit/tools/tool.py

@@ -19,7 +19,6 @@ from unique_toolkit.language_model.service import LanguageModelService
 
 
 from unique_toolkit.evals.schemas import EvaluationMetricName
-from unique_toolkit.tools.agent_chunks_handler import AgentChunksHandler
 from unique_toolkit.tools.config import ToolBuildConfig, ToolSelectionPolicy
 from unique_toolkit.tools.schemas import BaseToolConfig, ToolCallResponse, ToolPrompts
 from unique_toolkit.tools.tool_progress_reporter import ToolProgressReporter
@@ -81,7 +80,6 @@ class Tool(ABC, Generic[ConfigType]):
     def get_tool_call_result_for_loop_history(
         self,
         tool_response: ToolCallResponse,
-        agent_chunks_handler: AgentChunksHandler,
     ) -> LanguageModelMessage:
         raise NotImplementedError
 

{unique_toolkit-0.8.16 → unique_toolkit-0.8.18}/unique_toolkit/tools/tool_manager.py

@@ -35,9 +35,6 @@ class ToolManagerConfig(BaseModel):
         description="Maximum number of tool calls that can be executed in one iteration.",
     )
 
-    def __init__(self, tools: list[ToolBuildConfig], max_tool_calls: int = 10):
-        self.tools = tools
-        self.max_tool_calls = max_tool_calls
 
 
 class ToolManager:

unique_toolkit-0.8.16/unique_toolkit/tools/agent_chunks_handler.py

@@ -1,62 +0,0 @@
-from unique_toolkit.content.schemas import ContentChunk, ContentReference
-
-
-class AgentChunksHandler:
-    def __init__(self):
-        self._tool_chunks = {}
-        self._chunks: list[ContentChunk] = []
-        self._references: list[list[ContentReference]] = []
-
-    @property
-    def chunks(self) -> list[ContentChunk]:
-        return self._chunks
-
-    @property
-    def tool_chunks(self) -> dict:
-        return self._tool_chunks
-
-    def extend(self, chunks: list[ContentChunk]):
-        self._chunks.extend(chunks)
-
-    def replace(self, chunks: list[ContentChunk]):
-        self._chunks = chunks
-
-    def add_references(
-        self,
-        references: list[ContentReference],
-    ):
-        self._references.append(references)
-
-    @property
-    def all_references(
-        self,
-    ) -> list[list[ContentReference]]:
-        return self._references
-
-    @property
-    def latest_references(
-        self,
-    ) -> list[ContentReference]:
-        if not self._references:
-            return []
-        return self._references[-1]
-
-    @property
-    def latest_referenced_chunks(self) -> list[ContentChunk]:
-        if not self._references:
-            return []
-        return self._get_referenced_chunks_from_references(self._references[-1])
-
-    def _get_referenced_chunks_from_references(
-        self,
-        references: list[ContentReference],
-    ) -> list[ContentChunk]:
-        """
-        Get _referenced_chunks by matching sourceId from _references with merged id and chunk_id from _chunks.
-        """
-        referenced_chunks: list[ContentChunk] = []
-        for ref in references:
-            for chunk in self._chunks:
-                if ref.source_id == str(chunk.id) + "_" + str(chunk.chunk_id):
-                    referenced_chunks.append(chunk)
-        return referenced_chunks