unique_toolkit 1.69.0__tar.gz → 1.69.2__tar.gz

{unique_toolkit-1.69.0 → unique_toolkit-1.69.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 1.69.0
+Version: 1.69.2
 Summary: 
 Author: Cedric Klinkert, Martin Fadler, Sadique Sheik, Fabian Schläpfer, Pascal Hauri, Ejiroghene Oki-Peter, Rami Azouz, Ricardo Visini, Sanzio Monti
 Author-email: Cedric Klinkert <cedric.klinkert@unique.ch>, Martin Fadler <martin.fadler@unique.ch>, Sadique Sheik <sadique@unique.ch>, Fabian Schläpfer <fabian@unique.ch>, Pascal Hauri <pascal@unique.ch>, Ejiroghene Oki-Peter <oki-peter.ejiroghene@unique.ai>, Rami Azouz <rami.ext@unique.ch>, Ricardo Visini <ricardo.visini@unique.ch>, Sanzio Monti <sanzio.monti@unique.ai>

{unique_toolkit-1.69.0 → unique_toolkit-1.69.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "1.69.0"
+version = "1.69.2"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"

{unique_toolkit-1.69.0 → unique_toolkit-1.69.2}/unique_toolkit/agentic/history_manager/history_construction_with_contents.py

@@ -6,7 +6,7 @@ import mimetypes
 from datetime import datetime
 from enum import StrEnum
 from itertools import groupby
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Iterator
 
 if TYPE_CHECKING:
     from unique_toolkit.content.schemas import ContentChunk
@@ -77,7 +77,7 @@ class ChatHistoryWithContent(RootModel):
 
         return cls(root=grouped_elements)
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[ChatMessageWithContents]:
         return iter(self.root)
 
     def __getitem__(self, item):
@@ -94,7 +94,7 @@ def get_chat_history_with_contents(
         id=user_message.id,
         chat_id=chat_id,
         text=user_message.text,
-        originalText=user_message.original_text,
+        original_text=user_message.original_text,
         role=ChatRole.USER,
         gpt_request=None,
         created_at=datetime.fromisoformat(user_message.created_at),
@@ -118,6 +118,41 @@ def get_chat_history_with_contents(
     )
 
 
+async def get_chat_history_with_contents_async(
+    *,
+    user_message: ChatEventUserMessage,
+    chat_id: str,
+    chat_history: list[ChatMessage],
+    content_service: ContentService,
+) -> ChatHistoryWithContent:
+    last_user_message = ChatMessage(
+        id=user_message.id,
+        chat_id=chat_id,
+        text=user_message.text,
+        original_text=user_message.original_text,
+        role=ChatRole.USER,
+        gpt_request=None,
+        created_at=datetime.fromisoformat(user_message.created_at),
+    )
+    if len(chat_history) > 0 and last_user_message.id == chat_history[-1].id:
+        pass
+    else:
+        chat_history.append(last_user_message)
+
+    chat_contents = await content_service.search_contents_async(
+        where={
+            "ownerId": {
+                "equals": chat_id,
+            },
+        },
+    )
+
+    return ChatHistoryWithContent.from_chat_history_and_contents(
+        chat_history,
+        chat_contents,
+    )
+
+
 def download_encoded_images(
     contents: list[Content],
     content_service: ContentService,
@@ -141,6 +176,30 @@ def download_encoded_images(
     return base64_encoded_images
 
 
+async def download_encoded_images_async(
+    *,
+    contents: list[Content],
+    content_service: ContentService,
+    chat_id: str,
+) -> list[str]:
+    base64_encoded_images = []
+    for im in contents:
+        if FileUtils.is_image_content(im.key):
+            try:
+                file_bytes = await content_service.download_content_to_bytes_async(
+                    content_id=im.id,
+                    chat_id=chat_id,
+                )
+
+                mime_type, _ = mimetypes.guess_type(im.key)
+                encoded_string = base64.b64encode(file_bytes).decode("utf-8")
+                image_string = f"data:{mime_type};base64," + encoded_string
+                base64_encoded_images.append(image_string)
+            except Exception as e:
+                _LOGGER.warning("Failed to download image %s: %s", im.key, e)
+    return base64_encoded_images
+
+
 class FileContentSerialization(StrEnum):
     NONE = "none"
     FILE_NAME = "file_name"
@@ -212,6 +271,49 @@ def _append_element_to_builder(
         )
 
 
+async def _append_element_to_builder_async(
+    builder: MessagesBuilder,
+    *,
+    c: ChatMessageWithContents,
+    text: str,
+    include_images: ImageContentInclusion,
+    file_content_serialization_type: FileContentSerialization,
+    content_service: ContentService,
+    chat_id: str,
+) -> None:
+    if len(c.contents) > 0:
+        file_contents = [co for co in c.contents if FileUtils.is_file_content(co.key)]
+        image_contents = [co for co in c.contents if FileUtils.is_image_content(co.key)]
+        content = (
+            text
+            + "\n\n"
+            + file_content_serialization(
+                file_contents,
+                file_content_serialization_type,
+            )
+        ).strip()
+        if include_images and len(image_contents) > 0:
+            builder.image_message_append(
+                content=content,
+                images=await download_encoded_images_async(
+                    contents=image_contents,
+                    content_service=content_service,
+                    chat_id=chat_id,
+                ),
+                role=map_chat_llm_message_role[c.role],
+            )
+        else:
+            builder.message_append(
+                role=map_chat_llm_message_role[c.role],
+                content=content,
+            )
+    else:
+        builder.message_append(
+            role=map_chat_llm_message_role[c.role],
+            content=text,
+        )
+
+
 def get_full_history_with_contents(
     user_message: ChatEventUserMessage,
     chat_id: str,
@@ -228,7 +330,7 @@ def get_full_history_with_contents(
     )
 
     builder = LanguageModelMessages([]).builder()
-    for c in grouped_elements:
+    for c in grouped_elements.root:
         # LanguageModelUserMessage has no field original_text
         text = c.original_text if c.original_text else c.content
         if text is None:
@@ -249,6 +351,43 @@ def get_full_history_with_contents(
     return builder.build()
 
 
+async def get_full_history_with_contents_async(
+    *,
+    user_message: ChatEventUserMessage,
+    chat_id: str,
+    chat_service: ChatService,
+    content_service: ContentService,
+    include_images: ImageContentInclusion = ImageContentInclusion.ALL,
+    file_content_serialization_type: FileContentSerialization = FileContentSerialization.FILE_NAME,
+) -> LanguageModelMessages:
+    grouped_elements = await get_chat_history_with_contents_async(
+        user_message=user_message,
+        chat_id=chat_id,
+        chat_history=await chat_service.get_full_history_async(),
+        content_service=content_service,
+    )
+
+    builder = LanguageModelMessages([]).builder()
+    for c in grouped_elements.root:
+        text = c.original_text if c.original_text else c.content
+        if text is None:
+            if c.role == ChatRole.USER:
+                raise ValueError(
+                    "Content or original_text of LanguageModelMessages should exist.",
+                )
+            text = ""
+        await _append_element_to_builder_async(
+            builder=builder,
+            c=c,
+            text=text,
+            include_images=include_images,
+            file_content_serialization_type=file_content_serialization_type,
+            content_service=content_service,
+            chat_id=chat_id,
+        )
+    return builder.build()
+
+
 def get_full_history_with_contents_and_tool_calls(
     *,
     user_message: ChatEventUserMessage,
@@ -307,7 +446,7 @@ def get_full_history_with_contents_and_tool_calls(
     )
 
     builder = LanguageModelMessages([]).builder()
-    for c in grouped_elements:
+    for c in grouped_elements.root:
         text = c.original_text if c.original_text else c.content
         if text is None:
             if c.role == ChatRole.USER:
@@ -391,6 +530,122 @@ def get_full_history_with_contents_and_tool_calls(
     return builder.build(), max_source_number, source_map
 
 
+async def get_full_history_with_contents_and_tool_calls_async(
+    *,
+    user_message: ChatEventUserMessage,
+    chat_id: str,
+    chat_service: ChatService,
+    content_service: ContentService,
+    include_images: ImageContentInclusion = ImageContentInclusion.ALL,
+    file_content_serialization_type: FileContentSerialization = FileContentSerialization.FILE_NAME,
+) -> tuple[LanguageModelMessages, int, dict[int, "ContentChunk"]]:
+    """Async version of get_full_history_with_contents_and_tool_calls."""
+    from unique_toolkit.agentic.history_manager.utils import (
+        build_source_map_from_tool_calls,
+        compute_max_source_number_from_tool_calls,
+    )
+    from unique_toolkit.content.schemas import (
+        ContentChunk as ContentChunk,  # noqa: F811
+    )
+
+    chat_history = await chat_service.get_full_history_async()
+
+    assistant_message_ids = [
+        msg.id for msg in chat_history if msg.role == ChatRole.ASSISTANT and msg.id
+    ]
+    all_tool_calls: list[ChatMessageTool] = []
+    tool_calls_by_message: dict[str, list[ChatMessageTool]] = {}
+    if assistant_message_ids:
+        try:
+            all_tool_calls = await chat_service.get_message_tools_async(
+                message_ids=assistant_message_ids,
+            )
+            for tc in all_tool_calls:
+                if tc.message_id:
+                    tool_calls_by_message.setdefault(tc.message_id, []).append(tc)
+        except Exception:
+            _LOGGER.warning(
+                "Failed to batch-load tool calls, falling back to empty", exc_info=True
+            )
+    max_source_number = compute_max_source_number_from_tool_calls(all_tool_calls)
+    source_map: dict[int, ContentChunk] = build_source_map_from_tool_calls(
+        all_tool_calls
+    )
+
+    grouped_elements = await get_chat_history_with_contents_async(
+        user_message=user_message,
+        chat_id=chat_id,
+        chat_history=chat_history,
+        content_service=content_service,
+    )
+
+    builder = LanguageModelMessages([]).builder()
+    for c in grouped_elements.root:
+        text = c.original_text if c.original_text else c.content
+        if text is None:
+            if c.role == ChatRole.USER:
+                raise ValueError(
+                    "Content or original_text of LanguageModelMessages should exist.",
+                )
+            text = ""
+
+        if c.role == ChatRole.ASSISTANT and c.id and c.id in tool_calls_by_message:
+            tc_records = sorted(
+                tool_calls_by_message[c.id],
+                key=lambda tc: (tc.round_index, tc.sequence_index),
+            )
+            if tc_records:
+                for _round, round_group in groupby(
+                    tc_records, key=lambda tc: tc.round_index
+                ):
+                    round_tcs = list(round_group)
+                    round_tcs_with_response = [
+                        tc
+                        for tc in round_tcs
+                        if tc.response and tc.response.content is not None
+                    ]
+                    if not round_tcs_with_response:
+                        continue
+                    fns = [
+                        LanguageModelFunction(
+                            id=tc.external_tool_call_id,
+                            name=tc.function_name,
+                            arguments=tc.arguments,
+                        )
+                        for tc in round_tcs_with_response
+                    ]
+                    builder.messages.append(
+                        LanguageModelAssistantMessage.from_functions(tool_calls=fns)
+                    )
+                    for fn, tc in zip(fns, round_tcs_with_response):
+                        builder.messages.append(
+                            LanguageModelToolMessage(
+                                tool_call_id=fn.id,
+                                content=tc.response.content,  # type: ignore[union-attr]
+                                name=tc.function_name,
+                            )
+                        )
+
+        had_tool_calls = (
+            c.role == ChatRole.ASSISTANT
+            and c.id is not None
+            and c.id in tool_calls_by_message
+        )
+        if had_tool_calls and not text:
+            continue
+
+        await _append_element_to_builder_async(
+            builder=builder,
+            c=c,
+            text=text,
+            include_images=include_images,
+            file_content_serialization_type=file_content_serialization_type,
+            content_service=content_service,
+            chat_id=chat_id,
+        )
+    return builder.build(), max_source_number, source_map
+
+
 def get_full_history_as_llm_messages(
     chat_service: ChatService,
 ) -> LanguageModelMessages:

{unique_toolkit-1.69.0 → unique_toolkit-1.69.2}/unique_toolkit/agentic/history_manager/loop_token_reducer.py

@@ -10,8 +10,8 @@ from unique_toolkit._common.token.token_counting import (
 from unique_toolkit._common.validators import LMI
 from unique_toolkit.agentic.history_manager.history_construction_with_contents import (
     FileContentSerialization,
-    get_full_history_with_contents,
-    get_full_history_with_contents_and_tool_calls,
+    get_full_history_with_contents_and_tool_calls_async,
+    get_full_history_with_contents_async,
 )
 from unique_toolkit.agentic.history_manager.utils import serialize_tool_content_json
 from unique_toolkit.agentic.reference_manager.reference_manager import ReferenceManager
@@ -312,19 +312,21 @@ class LoopTokenReducer:
             else FileContentSerialization.FILE_NAME
         )
         if self._enable_tool_call_persistence:
-            full_history, max_src, src_map = (
-                get_full_history_with_contents_and_tool_calls(
-                    user_message=self._user_message,
-                    chat_id=self._chat_id,
-                    chat_service=self._chat_service,
-                    content_service=self._content_service,
-                    file_content_serialization_type=file_content_serialization_type,
-                )
+            (
+                full_history,
+                max_src,
+                src_map,
+            ) = await get_full_history_with_contents_and_tool_calls_async(
+                user_message=self._user_message,
+                chat_id=self._chat_id,
+                chat_service=self._chat_service,
+                content_service=self._content_service,
+                file_content_serialization_type=file_content_serialization_type,
             )
             self._max_db_source_number = max_src
             self._db_source_map = src_map
         else:
-            full_history = get_full_history_with_contents(
+            full_history = await get_full_history_with_contents_async(
                 user_message=self._user_message,
                 chat_id=self._chat_id,
                 chat_service=self._chat_service,

{unique_toolkit-1.69.0 → unique_toolkit-1.69.2}/unique_toolkit/agentic/loop_runner/runners/qwen/qwen_runner.py

@@ -65,7 +65,7 @@ class QwenLoopIterationRunner(BasicLoopIterationRunner):
             loop_runner_kwargs=kwargs,
             prepare_loop_runner_kwargs=_prepare,
         )
-        return self._process_response(response)
+        return await self._process_response(response)
 
     async def _handle_last_iteration(
         self, **kwargs: Unpack[_LoopIterationRunnerKwargs]
@@ -78,22 +78,23 @@ class QwenLoopIterationRunner(BasicLoopIterationRunner):
             last_iteration_instruction=self._last_iteration_instruction,
         )
         response = await super()._handle_last_iteration(**kwargs)
-        return self._process_response(response)
+        return await self._process_response(response)
 
     async def _handle_normal_iteration(
         self, **kwargs: Unpack[_LoopIterationRunnerKwargs]
     ) -> LanguageModelStreamResponse:
         response = await super()._handle_normal_iteration(**kwargs)
-        return self._process_response(response)
+        return await self._process_response(response)
 
-    def _process_response(
+    async def _process_response(
         self, response: LanguageModelStreamResponse
     ) -> LanguageModelStreamResponse:
-        if "</tool_call>" == response.message.text.strip():
+        message_text = response.message.text or ""
+        if "</tool_call>" == message_text.strip():
             _LOGGER.warning(
                 "Response contains only <tool_call>. This is not allowed. Returning empty response."
             )
-            self._chat_service.modify_assistant_message(content="")
+            await self._chat_service.modify_assistant_message_async(content="")
             response.message.text = ""
 
         return response

{unique_toolkit-1.69.0 → unique_toolkit-1.69.2}/unique_toolkit/agentic/tools/mcp/tool_wrapper.py

@@ -377,7 +377,10 @@ class MCPToolWrapper(Tool[MCPToolConfig]):
     async def _call_mcp_tool_via_sdk(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
         """Call MCP tool via SDK to public API"""
         try:
-            result = unique_sdk.MCP.call_tool(
+            self.logger.info(
+                f"Calling MCP tool {self.name} with arguments: {arguments}"
+            )
+            result = await unique_sdk.MCP.call_tool_async(
                 user_id=self._event.user_id,
                 company_id=self._event.company_id,
                 name=self.name,
@@ -386,9 +389,6 @@ class MCPToolWrapper(Tool[MCPToolConfig]):
                 arguments=arguments,
             )
 
-            self.logger.info(
-                f"Calling MCP tool {self.name} with arguments: {arguments}"
-            )
             self.logger.debug(f"Result: {result}")
 
             return result

{unique_toolkit-1.69.0 → unique_toolkit-1.69.2}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/postprocessors/generated_files.py

@@ -1029,9 +1029,7 @@ def _collect_stdout(call: ResponseCodeInterpreterToolCall) -> str:
 
 def _get_next_fence_id(text: str) -> int:
     """Return the next available fence id by scanning existing fences in the text."""
-    existing = re.findall(
-        r"````(?:imgWithSource|fileWithSource|htmlWithSource)\(id='(\d+)'", text
-    )
+    existing = re.findall(r"````(?:imgWithSource|fileWithSource)\(id='(\d+)'", text)
     if not existing:
         return 1
     return max(int(fid) for fid in existing) + 1
@@ -1119,9 +1117,12 @@ def _build_file_fence(file: CodeInterpreterFile, code: str, fence_id: int) -> st
     content_id, a title derived from the filename, the type, and the
     escaped source code.
 
+    HTML is not emitted here in normal flow: it is rendered via ``HtmlRendering`` blocks
+    in message text and excluded from fence injection. If ``type="html"`` is passed (e.g.
+    orphan path), fall through to ``fileWithSource`` like other non-image artifacts.
+
     Format (4 backticks so inner code backticks never close the fence):
       ````imgWithSource(id='{n}', contentId='{id}', title="{title}", code="{escaped_code}")````
-      ````htmlWithSource(id='{n}', contentId='{id}', title="{title}", code="{escaped_code}")````
       ````fileWithSource(id='{n}', contentId='{id}', title="{title}", type="{type}", code="{escaped_code}")````
     """
     title = _file_title(file.filename)
@@ -1129,8 +1130,6 @@ def _build_file_fence(file: CodeInterpreterFile, code: str, fence_id: int) -> st
     outer = "````"
     if file.type == "image":
         tag = f"imgWithSource(id='{fence_id}', contentId='{file.content_id}', title=\"{title}\", code=\"{escaped}\")"
-    elif file.type == "html":
-        tag = f"htmlWithSource(id='{fence_id}', contentId='{file.content_id}', title=\"{title}\", code=\"{escaped}\")"
     else:
         ftype = _file_frontend_type(file.filename)
         tag = f'fileWithSource(id=\'{fence_id}\', contentId=\'{file.content_id}\', title="{title}", type="{ftype}", code="{escaped}")'
@@ -1154,7 +1153,7 @@ def _inline_ref_pattern(file: CodeInterpreterFile) -> re.Pattern[str]:
 
 
 _FENCE_BLOCK_START = re.compile(
-    r"^[^\n`]+?(````(?:imgWithSource|fileWithSource|htmlWithSource)\()",
+    r"^[^\n`]+?(````(?:imgWithSource|fileWithSource)\()",
     re.MULTILINE,
 )
 
@@ -1164,9 +1163,9 @@ _FENCE_BLOCK_START = re.compile(
 #   - cross-line: 1 or 2 newlines optionally surrounded by horizontal whitespace
 #     (list-item linebreak, or blank-line paragraph gap)
 _CONSECUTIVE_FENCES_RE = re.compile(
-    r"(````(?:imgWithSource|fileWithSource|htmlWithSource)\([^\n]*\)````)"
+    r"(````(?:imgWithSource|fileWithSource)\([^\n]*\)````)"
     r"(?:[^\n`]*|[ \t]*\n{1,2}[ \t]*)"
-    r"(?=````(?:imgWithSource|fileWithSource|htmlWithSource)\()"
+    r"(?=````(?:imgWithSource|fileWithSource)\()"
 )