unique_toolkit 1.38.3__tar.gz → 1.39.0__tar.gz

{unique_toolkit-1.38.3 → unique_toolkit-1.39.0}/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).
 
+## [1.39.0] - 2025-12-17
+- Adding simpler shortterm message abilities to chat service
+
+## [1.38.4] - 2025-12-17
+- Improving handling of tool calls with Qwen models
+
 ## [1.38.3] - 2025-12-17
 - Move the failsafe exception to root folder of unique_toolkit from agentic tools
 

{unique_toolkit-1.38.3 → unique_toolkit-1.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 1.38.3
+Version: 1.39.0
 Summary: 
 License: Proprietary
 Author: Cedric Klinkert
@@ -41,9 +41,25 @@ The Toolkit is structured along the following domains:
 - `unique_toolkit.language_model`
 - `unique_toolkit.short_term_memory`
 
-Each domain comprises a set of functions (in `functions.py`) and a service class (in `service.py`) which encapsulates the basic functionalities to interact with the domain entities, the schemas (in `schemas.py`) used in the service and required for interacting with the service functions, utility functions (in `utils.py`) which give additional functionality to interact with the domain entities (all domains except embedding) and other domain specific functionalities which are explained in the respective domain documentation.
+Each domain comprises a set of schemas (in `schemas.py`) are used in functions (in `functions.py`) which encapsulates the basic functionalities to interact with the plattform. 
+The above domains represent the internal structure of the Unique platform.
 
-In addition, the `unique_toolkit.app` module provides functions to initialize apps that interact with the Unique platform. It also includes some utility functions to run async tasks in parallel (async webserver and app implementation required).
+For the `developers` we expose interfaces via `services` classes that correspond directly to an frontend or an entity the `user` interacts with. 
+
+The following services are currently available:
+
+| Service | Responsability |
+|--|--|
+| ChatService | All interactions with the chat interface | 
+| KnowledgeBaseService | All interaction with the knowledgebase |
+
+The services can be directly import as 
+
+```
+from unique_toolkit import ChatService, KnowledgeBaseService
+
+
+In addition, the `unique_toolkit.app` module provides functions to initialize apps and dev utilities to interact with the Unique platform. 
 
 ## Changelog
 
@@ -65,7 +81,6 @@ The `unique_toolkit.app` module encompasses functions for initializing and secur
 The `unique_toolkit.chat` module encompasses all chat related functionality.
 
 - `functions.py` comprises the functions to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
-- `service.py` comprises the ChatService and provides an interface to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message and stream complete.
 - `schemas.py` comprises all relevant schemas, e.g., ChatMessage, used in the ChatService.
 - `utils.py` comprises utility functions to use and convert ChatMessage objects in assistants, e.g., convert_chat_history_to_injectable_string converts the chat history to a string that can be injected into a prompt. 
 
@@ -74,11 +89,10 @@ The `unique_toolkit.chat` module encompasses all chat related functionality.
 The `unique_toolkit.content` module encompasses all content related functionality. Content can be any type of textual data that is stored in the Knowledgebase on the Unique platform. During the ingestion of the content, the content is parsed, split in chunks, indexed, and stored in the database.
 
 - `functions.py` comprises the functions to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
-- `service.py` comprises the ContentService and provides an interface to interact with the content, e.g., search content, search content chunks, upload and download content.
 - `schemas.py` comprises all relevant schemas, e.g., Content and ContentChunk, used in the ContentService.
 - `utils.py` comprise utility functions to manipulate Content and ContentChunk objects, e.g., sort_content_chunks and merge_content_chunks.
 
-## Embedding
+## Embedding (To be Deprecated)
 
 The `unique_toolkit.embedding` module encompasses all embedding related functionality. Embeddings are used to represent textual data in a high-dimensional space. The embeddings can be used to calculate the similarity between two texts, for instance.
 
@@ -86,34 +100,22 @@ The `unique_toolkit.embedding` module encompasses all embedding related function
 - `service.py` encompasses the EmbeddingService and provides an interface to interact with the embeddings, e.g., embed text and calculate the similarity between two texts.
 - `schemas.py` comprises all relevant schemas, e.g., Embeddings, used in the EmbeddingService.
 
-## Language Model
+## Language Model 
 
 The `unique_toolkit.language_model` module encompasses all language model related functionality and information on the different language models deployed through the 
 Unique platform.
 
 - `infos.py` comprises the information on all language models deployed through the Unique platform. We recommend to use the LanguageModel class, initialized with the LanguageModelName, e.g., LanguageModel(LanguageModelName.AZURE_GPT_4o_2024_1120) to get the information on the specific language model like the name, version, token limits or retirement date.
 - `functions.py` comprises the functions to complete and stream complete to chat.
-- `service.py` comprises the LanguageModelService and provides an interface to interact with the language models, e.g., complete. 
 - `schemas.py` comprises all relevant schemas, e.g., LanguageModelResponse, used in the LanguageModelService.
 - `utils.py` comprises utility functions to parse the output of the language model, e.g., convert_string_to_json finds and parses the last json object in a string.
 
-## Short Term Memory
+## Short Term Memory 
 
 The `unique_toolkit.short_term_memory` module encompasses all short term memory related functionality.
 
 - `functions.py` comprises the functions to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
-- `service.py` comprises the ShortTermMemoryService and provides an interface to interact with the short term memory, e.g., create memory.
 - `schemas.py` comprises all relevant schemas, e.g., ShortTermMemory, used in the ShortTermMemoryService.
-
-# Development instructions
-
-1. Install poetry on your system (through `brew` or `pipx`).
-
-2. Install `pyenv` and install python 3.11. `pyenv` is recommended as otherwise poetry uses the python version used to install itself and not the user preferred python version.
-
-3. If you then run `python --version` in your terminal, you should be able to see python version as specified in `.python-version`.
-
-4. Then finally run `poetry install` to install the package and all dependencies.
 # Changelog
 
 All notable changes to this project will be documented in this file.
@@ -121,6 +123,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).
 
+## [1.39.0] - 2025-12-17
+- Adding simpler shortterm message abilities to chat service
+
+## [1.38.4] - 2025-12-17
+- Improving handling of tool calls with Qwen models
+
 ## [1.38.3] - 2025-12-17
 - Move the failsafe exception to root folder of unique_toolkit from agentic tools
 

{unique_toolkit-1.38.3 → unique_toolkit-1.39.0}/README.md

@@ -9,9 +9,25 @@ The Toolkit is structured along the following domains:
 - `unique_toolkit.language_model`
 - `unique_toolkit.short_term_memory`
 
-Each domain comprises a set of functions (in `functions.py`) and a service class (in `service.py`) which encapsulates the basic functionalities to interact with the domain entities, the schemas (in `schemas.py`) used in the service and required for interacting with the service functions, utility functions (in `utils.py`) which give additional functionality to interact with the domain entities (all domains except embedding) and other domain specific functionalities which are explained in the respective domain documentation.
+Each domain comprises a set of schemas (in `schemas.py`) are used in functions (in `functions.py`) which encapsulates the basic functionalities to interact with the plattform. 
+The above domains represent the internal structure of the Unique platform.
 
-In addition, the `unique_toolkit.app` module provides functions to initialize apps that interact with the Unique platform. It also includes some utility functions to run async tasks in parallel (async webserver and app implementation required).
+For the `developers` we expose interfaces via `services` classes that correspond directly to an frontend or an entity the `user` interacts with. 
+
+The following services are currently available:
+
+| Service | Responsability |
+|--|--|
+| ChatService | All interactions with the chat interface | 
+| KnowledgeBaseService | All interaction with the knowledgebase |
+
+The services can be directly import as 
+
+```
+from unique_toolkit import ChatService, KnowledgeBaseService
+
+
+In addition, the `unique_toolkit.app` module provides functions to initialize apps and dev utilities to interact with the Unique platform. 
 
 ## Changelog
 
@@ -33,7 +49,6 @@ The `unique_toolkit.app` module encompasses functions for initializing and secur
 The `unique_toolkit.chat` module encompasses all chat related functionality.
 
 - `functions.py` comprises the functions to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
-- `service.py` comprises the ChatService and provides an interface to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message and stream complete.
 - `schemas.py` comprises all relevant schemas, e.g., ChatMessage, used in the ChatService.
 - `utils.py` comprises utility functions to use and convert ChatMessage objects in assistants, e.g., convert_chat_history_to_injectable_string converts the chat history to a string that can be injected into a prompt. 
 
@@ -42,11 +57,10 @@ The `unique_toolkit.chat` module encompasses all chat related functionality.
 The `unique_toolkit.content` module encompasses all content related functionality. Content can be any type of textual data that is stored in the Knowledgebase on the Unique platform. During the ingestion of the content, the content is parsed, split in chunks, indexed, and stored in the database.
 
 - `functions.py` comprises the functions to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
-- `service.py` comprises the ContentService and provides an interface to interact with the content, e.g., search content, search content chunks, upload and download content.
 - `schemas.py` comprises all relevant schemas, e.g., Content and ContentChunk, used in the ContentService.
 - `utils.py` comprise utility functions to manipulate Content and ContentChunk objects, e.g., sort_content_chunks and merge_content_chunks.
 
-## Embedding
+## Embedding (To be Deprecated)
 
 The `unique_toolkit.embedding` module encompasses all embedding related functionality. Embeddings are used to represent textual data in a high-dimensional space. The embeddings can be used to calculate the similarity between two texts, for instance.
 
@@ -54,31 +68,19 @@ The `unique_toolkit.embedding` module encompasses all embedding related function
 - `service.py` encompasses the EmbeddingService and provides an interface to interact with the embeddings, e.g., embed text and calculate the similarity between two texts.
 - `schemas.py` comprises all relevant schemas, e.g., Embeddings, used in the EmbeddingService.
 
-## Language Model
+## Language Model 
 
 The `unique_toolkit.language_model` module encompasses all language model related functionality and information on the different language models deployed through the 
 Unique platform.
 
 - `infos.py` comprises the information on all language models deployed through the Unique platform. We recommend to use the LanguageModel class, initialized with the LanguageModelName, e.g., LanguageModel(LanguageModelName.AZURE_GPT_4o_2024_1120) to get the information on the specific language model like the name, version, token limits or retirement date.
 - `functions.py` comprises the functions to complete and stream complete to chat.
-- `service.py` comprises the LanguageModelService and provides an interface to interact with the language models, e.g., complete. 
 - `schemas.py` comprises all relevant schemas, e.g., LanguageModelResponse, used in the LanguageModelService.
 - `utils.py` comprises utility functions to parse the output of the language model, e.g., convert_string_to_json finds and parses the last json object in a string.
 
-## Short Term Memory
+## Short Term Memory 
 
 The `unique_toolkit.short_term_memory` module encompasses all short term memory related functionality.
 
 - `functions.py` comprises the functions to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
-- `service.py` comprises the ShortTermMemoryService and provides an interface to interact with the short term memory, e.g., create memory.
-- `schemas.py` comprises all relevant schemas, e.g., ShortTermMemory, used in the ShortTermMemoryService.
-
-# Development instructions
-
-1. Install poetry on your system (through `brew` or `pipx`).
-
-2. Install `pyenv` and install python 3.11. `pyenv` is recommended as otherwise poetry uses the python version used to install itself and not the user preferred python version.
-
-3. If you then run `python --version` in your terminal, you should be able to see python version as specified in `.python-version`.
-
-4. Then finally run `poetry install` to install the package and all dependencies.
+- `schemas.py` comprises all relevant schemas, e.g., ShortTermMemory, used in the ShortTermMemoryService.

{unique_toolkit-1.38.3 → unique_toolkit-1.39.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unique_toolkit"
-version = "1.38.3"
+version = "1.39.0"
 description = ""
 authors = [
     "Cedric Klinkert <cedric.klinkert@unique.ch>",

{unique_toolkit-1.38.3 → unique_toolkit-1.39.0}/unique_toolkit/agentic/loop_runner/__init__.py

@@ -1,25 +1,35 @@
+from unique_toolkit.agentic.loop_runner._iteration_handler_utils import (
+    handle_forced_tools_iteration,
+    handle_last_iteration,
+    handle_normal_iteration,
+)
 from unique_toolkit.agentic.loop_runner.base import LoopIterationRunner
 from unique_toolkit.agentic.loop_runner.middleware import (
-    QWEN_FORCED_TOOL_CALL_PROMPT_INSTRUCTION,
     PlanningConfig,
     PlanningMiddleware,
     PlanningSchemaConfig,
-    QwenForcedToolCallMiddleware,
-    is_qwen_model,
 )
 from unique_toolkit.agentic.loop_runner.runners import (
+    QWEN_FORCED_TOOL_CALL_INSTRUCTION,
+    QWEN_LAST_ITERATION_INSTRUCTION,
     BasicLoopIterationRunner,
     BasicLoopIterationRunnerConfig,
+    QwenLoopIterationRunner,
+    is_qwen_model,
 )
 
 __all__ = [
     "LoopIterationRunner",
-    "QWEN_FORCED_TOOL_CALL_PROMPT_INSTRUCTION",
     "PlanningConfig",
     "PlanningMiddleware",
     "PlanningSchemaConfig",
-    "QwenForcedToolCallMiddleware",
+    "QwenLoopIterationRunner",
     "is_qwen_model",
     "BasicLoopIterationRunnerConfig",
     "BasicLoopIterationRunner",
+    "handle_forced_tools_iteration",
+    "handle_last_iteration",
+    "handle_normal_iteration",
+    "QWEN_FORCED_TOOL_CALL_INSTRUCTION",
+    "QWEN_LAST_ITERATION_INSTRUCTION",
 ]

unique_toolkit-1.39.0/unique_toolkit/agentic/loop_runner/_iteration_handler_utils.py

@@ -0,0 +1,95 @@
+import logging
+from typing import Protocol, Unpack, cast
+
+from unique_toolkit.agentic.loop_runner._stream_handler_utils import stream_response
+from unique_toolkit.agentic.loop_runner.base import (
+    _LoopIterationRunnerKwargs,
+)
+from unique_toolkit.chat.functions import LanguageModelStreamResponse
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class PrepareForcedToolIterationKwargs(Protocol):
+    def __call__(
+        self,
+        func_name: str | None,
+        per_choice_kwargs: _LoopIterationRunnerKwargs,
+    ) -> _LoopIterationRunnerKwargs: ...
+
+
+async def handle_last_iteration(
+    **kwargs: Unpack[_LoopIterationRunnerKwargs],
+) -> LanguageModelStreamResponse:
+    _LOGGER.info("Reached last iteration, removing tools and producing final response")
+
+    return await stream_response(
+        loop_runner_kwargs=kwargs,
+        tools=None,
+    )
+
+
+async def handle_normal_iteration(
+    **kwargs: Unpack[_LoopIterationRunnerKwargs],
+) -> LanguageModelStreamResponse:
+    _LOGGER.info("Running loop iteration %d", kwargs["iteration_index"])
+
+    return await stream_response(loop_runner_kwargs=kwargs)
+
+
+async def handle_forced_tools_iteration(
+    **kwargs: Unpack[_LoopIterationRunnerKwargs],
+) -> LanguageModelStreamResponse:
+    return await run_forced_tools_iteration(loop_runner_kwargs=kwargs)
+
+
+async def run_forced_tools_iteration(
+    *,
+    loop_runner_kwargs: _LoopIterationRunnerKwargs,
+    prepare_loop_runner_kwargs: PrepareForcedToolIterationKwargs | None = None,
+) -> LanguageModelStreamResponse:
+    """
+    Execute a "forced tools" iteration by running one stream_response per tool choice,
+    then merging tool calls and references into a single response.
+
+    Some models (e.g. Qwen) need per-tool-choice message rewriting; this can be done
+    via prepare_loop_runner_kwargs (called once per tool choice, on a copy of kwargs).
+    """
+    assert "tool_choices" in loop_runner_kwargs
+
+    tool_choices = loop_runner_kwargs["tool_choices"]
+    assert len(tool_choices) > 0, (
+        "run_forced_tools_iteration requires at least one tool choice"
+    )
+    _LOGGER.info("Forcing tools calls: %s", tool_choices)
+
+    responses: list[LanguageModelStreamResponse] = []
+
+    available_tools = {t.name: t for t in loop_runner_kwargs.get("tools") or []}
+
+    for opt in tool_choices:
+        func_name = opt.get("function", {}).get("name")
+
+        per_choice_kwargs = cast(_LoopIterationRunnerKwargs, dict(loop_runner_kwargs))
+        if prepare_loop_runner_kwargs:
+            per_choice_kwargs = prepare_loop_runner_kwargs(func_name, per_choice_kwargs)
+
+        limited_tool = available_tools.get(func_name) if func_name else None
+        stream_kwargs = {"loop_runner_kwargs": per_choice_kwargs, "tool_choice": opt}
+        if limited_tool:
+            stream_kwargs["tools"] = [limited_tool]
+        responses.append(await stream_response(**stream_kwargs))
+
+    # Merge responses and refs:
+    tool_calls = []
+    references = []
+    for r in responses:
+        if r.tool_calls:
+            tool_calls.extend(r.tool_calls)
+        references.extend(r.message.references)
+
+    response = responses[0]
+    response.tool_calls = tool_calls if len(tool_calls) > 0 else None
+    response.message.references = references
+
+    return response

unique_toolkit-1.39.0/unique_toolkit/agentic/loop_runner/middleware/__init__.py

@@ -0,0 +1,11 @@
+from unique_toolkit.agentic.loop_runner.middleware.planning import (
+    PlanningConfig,
+    PlanningMiddleware,
+    PlanningSchemaConfig,
+)
+
+__all__ = [
+    "PlanningConfig",
+    "PlanningMiddleware",
+    "PlanningSchemaConfig",
+]

unique_toolkit-1.39.0/unique_toolkit/agentic/loop_runner/runners/__init__.py

@@ -0,0 +1,19 @@
+from unique_toolkit.agentic.loop_runner.runners.basic import (
+    BasicLoopIterationRunner,
+    BasicLoopIterationRunnerConfig,
+)
+from unique_toolkit.agentic.loop_runner.runners.qwen import (
+    QWEN_FORCED_TOOL_CALL_INSTRUCTION,
+    QWEN_LAST_ITERATION_INSTRUCTION,
+    QwenLoopIterationRunner,
+    is_qwen_model,
+)
+
+__all__ = [
+    "BasicLoopIterationRunnerConfig",
+    "BasicLoopIterationRunner",
+    "QwenLoopIterationRunner",
+    "QWEN_FORCED_TOOL_CALL_INSTRUCTION",
+    "QWEN_LAST_ITERATION_INSTRUCTION",
+    "is_qwen_model",
+]

unique_toolkit-1.39.0/unique_toolkit/agentic/loop_runner/runners/basic.py

@@ -0,0 +1,46 @@
+import logging
+from typing import Unpack, override
+
+from pydantic import BaseModel
+
+from unique_toolkit._common.pydantic_helpers import get_configuration_dict
+from unique_toolkit.agentic.loop_runner._iteration_handler_utils import (
+    handle_forced_tools_iteration,
+    handle_last_iteration,
+    handle_normal_iteration,
+)
+from unique_toolkit.agentic.loop_runner.base import (
+    LoopIterationRunner,
+    _LoopIterationRunnerKwargs,
+)
+from unique_toolkit.chat.functions import LanguageModelStreamResponse
+from unique_toolkit.protocols.support import (
+    ResponsesLanguageModelStreamResponse,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class BasicLoopIterationRunnerConfig(BaseModel):
+    model_config = get_configuration_dict()
+    max_loop_iterations: int
+
+
+class BasicLoopIterationRunner(LoopIterationRunner):
+    def __init__(self, config: BasicLoopIterationRunnerConfig) -> None:
+        self._config = config
+
+    @override
+    async def __call__(
+        self,
+        **kwargs: Unpack[_LoopIterationRunnerKwargs],
+    ) -> LanguageModelStreamResponse | ResponsesLanguageModelStreamResponse:
+        tool_choices = kwargs.get("tool_choices", [])
+        iteration_index = kwargs["iteration_index"]
+
+        if len(tool_choices) > 0 and iteration_index == 0:
+            return await handle_forced_tools_iteration(**kwargs)
+        elif iteration_index == self._config.max_loop_iterations - 1:
+            return await handle_last_iteration(**kwargs)
+        else:
+            return await handle_normal_iteration(**kwargs)

unique_toolkit-1.39.0/unique_toolkit/agentic/loop_runner/runners/qwen/__init__.py

@@ -0,0 +1,15 @@
+from unique_toolkit.agentic.loop_runner.runners.qwen.helpers import (
+    is_qwen_model,
+)
+from unique_toolkit.agentic.loop_runner.runners.qwen.qwen_runner import (
+    QWEN_FORCED_TOOL_CALL_INSTRUCTION,
+    QWEN_LAST_ITERATION_INSTRUCTION,
+    QwenLoopIterationRunner,
+)
+
+__all__ = [
+    "QwenLoopIterationRunner",
+    "is_qwen_model",
+    "QWEN_FORCED_TOOL_CALL_INSTRUCTION",
+    "QWEN_LAST_ITERATION_INSTRUCTION",
+]

{unique_toolkit-1.38.3/unique_toolkit/agentic/loop_runner/middleware/qwen_forced_tool_call → unique_toolkit-1.39.0/unique_toolkit/agentic/loop_runner/runners/qwen}/helpers.py

@@ -1,5 +1,6 @@
 from unique_toolkit.language_model.infos import LanguageModelInfo
 from unique_toolkit.language_model.schemas import (
+    LanguageModelAssistantMessage,
     LanguageModelMessageRole,
     LanguageModelMessages,
 )
@@ -31,3 +32,17 @@ def append_qwen_forced_tool_call_instruction(
             )
             break
     return LanguageModelMessages(root=messages_list)
+
+
+def append_qwen_last_iteration_assistant_message(
+    *,
+    messages: LanguageModelMessages,
+    last_iteration_instruction: str,
+) -> LanguageModelMessages:
+    """Append an assistant message at the end to indicate no further tool calls are allowed."""
+    messages_list = list(messages)
+    assistant_message = LanguageModelAssistantMessage(
+        content=last_iteration_instruction,
+    )
+    messages_list.append(assistant_message)
+    return LanguageModelMessages(root=messages_list)

unique_toolkit-1.39.0/unique_toolkit/agentic/loop_runner/runners/qwen/qwen_runner.py

@@ -0,0 +1,118 @@
+import logging
+from typing import Unpack
+
+from unique_toolkit.agentic.loop_runner._iteration_handler_utils import (
+    handle_last_iteration,
+    handle_normal_iteration,
+    run_forced_tools_iteration,
+)
+from unique_toolkit.agentic.loop_runner.base import (
+    LoopIterationRunner,
+    _LoopIterationRunnerKwargs,
+)
+from unique_toolkit.agentic.loop_runner.runners.qwen.helpers import (
+    append_qwen_forced_tool_call_instruction,
+    append_qwen_last_iteration_assistant_message,
+)
+from unique_toolkit.chat.service import ChatService, LanguageModelStreamResponse
+
+_LOGGER = logging.getLogger(__name__)
+
+QWEN_FORCED_TOOL_CALL_INSTRUCTION = (
+    "**Tool Call Instruction:** \nYou MUST call the tool {TOOL_NAME}. "
+    "You must start the response with <tool_call>. "
+    "Do NOT provide natural language explanations, summaries, or any text outside the <tool_call> block."
+)
+
+QWEN_LAST_ITERATION_INSTRUCTION = "The maximum number of loop iteration have been reached. Not further tool calls are allowed. Based on the found information, an answer should be generated"
+
+
+class QwenLoopIterationRunner(LoopIterationRunner):
+    def __init__(
+        self,
+        *,
+        qwen_forced_tool_call_instruction: str,
+        qwen_last_iteration_instruction: str,
+        max_loop_iterations: int,
+        chat_service: ChatService,
+    ) -> None:
+        self._qwen_forced_tool_call_instruction = qwen_forced_tool_call_instruction
+        self._qwen_last_iteration_instruction = qwen_last_iteration_instruction
+        self._max_loop_iterations = max_loop_iterations
+        self._chat_service = chat_service
+
+    async def __call__(
+        self, **kwargs: Unpack[_LoopIterationRunnerKwargs]
+    ) -> LanguageModelStreamResponse:
+        tool_choices = kwargs.get("tool_choices") or []
+        iteration_index = kwargs["iteration_index"]
+
+        if len(tool_choices) > 0 and iteration_index == 0:
+            return await self._qwen_handle_forced_tools_iteration(**kwargs)
+        elif iteration_index == self._max_loop_iterations - 1:
+            return await self._qwen_handle_last_iteration(**kwargs)
+        else:
+            return await self._qwen_handle_normal_iteration(**kwargs)
+
+    async def _qwen_handle_forced_tools_iteration(
+        self, **kwargs: Unpack[_LoopIterationRunnerKwargs]
+    ) -> LanguageModelStreamResponse:
+        # For Qwen models, append tool call instruction to the last user message. These models ignore the parameter tool_choice.
+        # As the message has to be modified for each tool call instruction, the function from the basic runner cant be used.
+        original_messages = kwargs["messages"].model_copy(deep=True)
+
+        def _prepare(
+            func_name: str | None,
+            per_choice_kwargs: _LoopIterationRunnerKwargs,
+        ) -> _LoopIterationRunnerKwargs:
+            prompt_instruction = self._qwen_forced_tool_call_instruction.format(
+                TOOL_NAME=func_name or ""
+            )
+            per_choice_kwargs["messages"] = append_qwen_forced_tool_call_instruction(
+                messages=original_messages,
+                forced_tool_call_instruction=prompt_instruction,
+            )
+            return per_choice_kwargs
+
+        response = await run_forced_tools_iteration(
+            loop_runner_kwargs=kwargs,
+            prepare_loop_runner_kwargs=_prepare,
+        )
+        return self._process_response(response)
+
+    async def _qwen_handle_last_iteration(
+        self, **kwargs: Unpack[_LoopIterationRunnerKwargs]
+    ) -> LanguageModelStreamResponse:
+        # For Qwen models, append an assistant message with instructions to not call any tool in this iteration.
+        _LOGGER.info(
+            "Reached last iteration, removing tools. Appending assistant message with instructions to not call any tool in this iteration."
+        )
+        kwargs["messages"] = append_qwen_last_iteration_assistant_message(
+            messages=kwargs["messages"],
+            last_iteration_instruction=self._qwen_last_iteration_instruction,
+        )
+
+        response = await handle_last_iteration(
+            **kwargs,
+        )
+
+        return self._process_response(response)
+
+    async def _qwen_handle_normal_iteration(
+        self, **kwargs: Unpack[_LoopIterationRunnerKwargs]
+    ) -> LanguageModelStreamResponse:
+        response = await handle_normal_iteration(**kwargs)
+        return self._process_response(response)
+
+    def _process_response(
+        self, response: LanguageModelStreamResponse
+    ) -> LanguageModelStreamResponse:
+        # Check if content of response is </tool_call>
+        if "</tool_call>" == response.message.text.strip():
+            _LOGGER.warning(
+                "Response contains only <tool_call>. This is not allowed. Returning empty response."
+            )
+            self._chat_service.modify_assistant_message(content="")
+            response.message.text = ""
+
+        return response

{unique_toolkit-1.38.3 → unique_toolkit-1.39.0}/unique_toolkit/app/schemas.py

@@ -120,11 +120,15 @@ class McpServer(BaseModel):
 class ChatEventUserMessage(BaseModel):
     model_config = model_config
 
-    id: str
-    text: str
-    original_text: str
-    created_at: str
-    language: str
+    id: str = Field(
+        description="The id of the user message. On an event this corresponds to the user message that created the event."
+    )
+    text: str = Field(description="The text of the user message.")
+    original_text: str = Field(description="The original text of the user message.")
+    created_at: str = Field(
+        description="The creation date and time of the user message."
+    )
+    language: str = Field(description="The language of the user message.")
 
 
 @deprecated(
@@ -140,8 +144,12 @@ class EventUserMessage(ChatEventUserMessage):
 class ChatEventAssistantMessage(BaseModel):
     model_config = model_config
 
-    id: str
-    created_at: str
+    id: str = Field(
+        description="The id of the assistant message. On an event this corresponds to the assistant message that will be returned by the process handling the event."
+    )
+    created_at: str = Field(
+        description="The creation date and time of the assistant message."
+    )
 
 
 @deprecated(