unique_toolkit 0.7.7__py3-none-any.whl → 1.23.0__py3-none-any.whl

unique_toolkit/chat/rendering.py

@@ -0,0 +1,34 @@
+from urllib.parse import quote
+
+
+def create_prompt_button_string(
+    *,
+    button_text: str,
+    next_user_message: str,
+) -> str:
+    """
+    Create a prompt button string.
+
+    Args:
+        button_text: The text of the button.
+        next_user_message: The message to send when the button is clicked.
+
+    Returns:
+        A string that can be used to create a prompt button.
+        A prompt button includes the `next_user_message` to the user prompt windown.
+    """
+    next_user_message = quote(next_user_message)
+    return f"[{button_text}](https://prompt={next_user_message})"
+
+
+def create_latex_formula_string(latex_expression: str) -> str:
+    """
+    Create a LaTeX string.
+
+    Args:
+        latex_expression: The LaTeX expression to create.
+
+    Returns:
+        A string that can be used to create a LaTeX string.
+    """
+    return f"\\[{latex_expression}\\]"

unique_toolkit/chat/responses_api.py

@@ -0,0 +1,461 @@
+import logging
+from typing import Any, NamedTuple, Sequence
+
+import unique_sdk
+from openai.types.responses import (
+    ResponseIncludable,
+    ResponseInputItemParam,
+    ResponseInputParam,
+    ResponseOutputItem,
+    ResponseTextConfigParam,
+    ToolParam,
+    response_create_params,
+)
+from openai.types.shared_params import Metadata, Reasoning
+from pydantic import BaseModel, TypeAdapter, ValidationError
+
+from unique_toolkit.agentic.tools.utils.execution.execution import (
+    failsafe,
+)
+from unique_toolkit.content.schemas import ContentChunk
+from unique_toolkit.language_model.constants import (
+    DEFAULT_COMPLETE_TEMPERATURE,
+)
+from unique_toolkit.language_model.functions import (
+    SearchContext,
+    _clamp_temperature,
+    _to_search_context,
+)
+from unique_toolkit.language_model.infos import (
+    LanguageModelInfo,
+    LanguageModelName,
+)
+from unique_toolkit.language_model.schemas import (
+    LanguageModelAssistantMessage,
+    LanguageModelMessage,
+    LanguageModelMessageOptions,
+    LanguageModelMessageRole,
+    LanguageModelMessages,
+    LanguageModelSystemMessage,
+    LanguageModelToolDescription,
+    LanguageModelToolMessage,
+    LanguageModelUserMessage,
+    ResponsesLanguageModelStreamResponse,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _convert_tools_to_openai(
+    tools: Sequence[LanguageModelToolDescription | ToolParam],
+) -> list[ToolParam]:
+    openai_tools = []
+    for tool in tools:
+        if isinstance(tool, LanguageModelToolDescription):
+            openai_tools.append(tool.to_openai(mode="responses"))
+        else:
+            openai_tools.append(tool)
+    return openai_tools
+
+
+def _convert_message_to_openai(
+    message: LanguageModelMessageOptions,
+) -> ResponseInputParam:
+    res = []
+    match message:
+        case LanguageModelAssistantMessage():
+            return message.to_openai(mode="responses")  # type: ignore
+        case (
+            LanguageModelUserMessage()
+            | LanguageModelSystemMessage()
+            | LanguageModelToolMessage()
+        ):
+            return [message.to_openai(mode="responses")]
+        case _:
+            return _convert_message_to_openai(_convert_to_specific_message(message))
+    return res
+
+
+def _convert_to_specific_message(
+    message: LanguageModelMessage,
+) -> "LanguageModelSystemMessage | LanguageModelUserMessage | LanguageModelAssistantMessage":
+    match message.role:
+        case LanguageModelMessageRole.SYSTEM:
+            return LanguageModelSystemMessage(content=message.content)
+        case LanguageModelMessageRole.USER:
+            return LanguageModelUserMessage(content=message.content)
+        case LanguageModelMessageRole.ASSISTANT:
+            return LanguageModelAssistantMessage(content=message.content)
+        case LanguageModelMessageRole.TOOL:
+            raise ValueError(
+                "Cannot convert message with role `tool`. Please use `LanguageModelToolMessage` instead."
+            )
+
+
+def _convert_messages_to_openai(
+    messages: Sequence[
+        ResponseInputItemParam | LanguageModelMessageOptions | ResponseOutputItem
+    ],
+) -> ResponseInputParam:
+    res = []
+    for message in messages:
+        if isinstance(message, LanguageModelMessageOptions):
+            res.extend(_convert_message_to_openai(message))
+        elif isinstance(
+            message, dict
+        ):  # Openai uses dicts for their input and BaseModel as output
+            res.append(message)
+        else:
+            assert isinstance(message, BaseModel)
+            res.append(message.model_dump(exclude_defaults=True))
+
+    return res
+
+
+class _ResponsesParams(NamedTuple):
+    temperature: float
+    model_name: str
+    search_context: SearchContext | None
+    messages: str | ResponseInputParam
+    tools: list[ToolParam] | None
+    reasoning: Reasoning | None
+    text: ResponseTextConfigParam | None
+
+
+def _prepare_responses_params_util(
+    model_name: LanguageModelName | str,
+    content_chunks: list[ContentChunk] | None,
+    temperature: float,
+    tools: Sequence[LanguageModelToolDescription | ToolParam] | None,
+    messages: str
+    | LanguageModelMessages
+    | Sequence[
+        ResponseInputItemParam | LanguageModelMessageOptions | ResponseOutputItem
+    ],
+    reasoning: Reasoning | None,
+    text: ResponseTextConfigParam | None,
+    other_options: dict | None = None,
+) -> _ResponsesParams:
+    search_context = (
+        _to_search_context(content_chunks) if content_chunks is not None else None
+    )
+
+    model = model_name.name if isinstance(model_name, LanguageModelName) else model_name
+
+    tools_res = _convert_tools_to_openai(tools) if tools is not None else None
+
+    if other_options is not None:
+        # Key word argument takes precedence
+        reasoning = reasoning or _attempt_extract_reasoning_from_options(other_options)
+        text = text or _attempt_extract_verbosity_from_options(other_options)
+
+    if isinstance(model_name, LanguageModelName):
+        model_info = LanguageModelInfo.from_name(model_name)
+
+        if model_info.temperature_bounds is not None and temperature is not None:
+            temperature = _clamp_temperature(temperature, model_info.temperature_bounds)
+
+        if (
+            reasoning is None
+            and model_info.default_options is not None
+            and "reasoning_effort" in model_info.default_options
+        ):
+            reasoning = Reasoning(effort=model_info.default_options["reasoning_effort"])
+
+        if (
+            reasoning is not None
+            and tools_res is not None
+            and any(tool["type"] == "code_interpreter" for tool in tools_res)
+            and "effort" in reasoning
+            and reasoning["effort"] == "minimal"
+        ):
+            logger.warning(
+                "Code interpreter cannot be used with `minimal` effort. Switching to `low`."
+            )
+            reasoning["effort"] = (
+                "low"  # Code interpreter cannot be used with minimal effort
+            )
+
+    messages_res = None
+    if isinstance(messages, LanguageModelMessages):
+        messages_res = _convert_messages_to_openai(messages.root)
+    elif isinstance(messages, list):
+        messages_res = _convert_messages_to_openai(messages)
+    else:
+        assert isinstance(messages, str)
+        messages_res = messages
+
+    return _ResponsesParams(
+        temperature, model, search_context, messages_res, tools_res, reasoning, text
+    )
+
+
+@failsafe(
+    failure_return_value=None,
+    exceptions=(ValidationError,),
+    log_exc_info=False,
+    logger=logger,
+)
+def _attempt_extract_reasoning_from_options(options: dict) -> Reasoning | None:
+    reasoning = None
+
+    # Responses API
+    if "reasoning" in options:
+        reasoning = options["reasoning"]
+
+    # Completions API
+    elif "reasoning_effort" in options:
+        reasoning = {"effort": options["reasoning_effort"]}
+    if "reasoningEffort" in options:
+        reasoning = {"effort": options["reasoningEffort"]}
+
+    if reasoning is not None:
+        return TypeAdapter(Reasoning).validate_python(reasoning)
+
+    return None
+
+
+@failsafe(
+    failure_return_value=None,
+    exceptions=(ValidationError,),
+    log_exc_info=False,
+    logger=logger,
+)
+def _attempt_extract_verbosity_from_options(
+    options: dict,
+) -> ResponseTextConfigParam | None:
+    reasoning = None
+
+    # Responses API
+    if "text" in options:
+        reasoning = options["text"]
+
+    # Completions API
+    elif "verbosity" in options:
+        reasoning = {"verbosity": options["verbosity"]}
+
+    if reasoning is not None:
+        return TypeAdapter(ResponseTextConfigParam).validate_python(reasoning)
+
+    return None
+
+
+def _prepare_responses_args(
+    company_id: str,
+    user_id: str,
+    assistant_message_id: str,
+    user_message_id: str,
+    chat_id: str,
+    assistant_id: str,
+    params: _ResponsesParams,
+    debug_info: dict | None,
+    start_text: str | None,
+    include: list[ResponseIncludable] | None,
+    instructions: str | None,
+    max_output_tokens: int | None,
+    metadata: Metadata | None,
+    parallel_tool_calls: bool | None,
+    tool_choice: response_create_params.ToolChoice | None,
+    top_p: float | None,
+    other_options: dict | None = None,
+) -> dict[str, Any]:
+    options = {}
+
+    options["company_id"] = company_id
+    options["user_id"] = user_id
+
+    options["model"] = params.model_name
+
+    if params.search_context is not None:
+        options["searchContext"] = params.search_context
+
+    options["chatId"] = chat_id
+    options["assistantId"] = assistant_id
+    options["assistantMessageId"] = assistant_message_id
+    options["userMessageId"] = user_message_id
+
+    if debug_info is not None:
+        options["debugInfo"] = debug_info
+    if start_text is not None:
+        options["startText"] = start_text
+
+    options["input"] = params.messages
+
+    openai_options: unique_sdk.Integrated.CreateStreamResponsesOpenaiParams = {}
+
+    if params.temperature is not None:
+        openai_options["temperature"] = params.temperature
+
+    if params.reasoning is not None:
+        openai_options["reasoning"] = params.reasoning
+
+    if params.text is not None:
+        openai_options["text"] = params.text
+
+    if include is not None:
+        openai_options["include"] = include
+
+    if instructions is not None:
+        openai_options["instructions"] = instructions
+
+    if max_output_tokens is not None:
+        openai_options["max_output_tokens"] = max_output_tokens
+
+    if metadata is not None:
+        openai_options["metadata"] = metadata
+
+    if parallel_tool_calls is not None:
+        openai_options["parallel_tool_calls"] = parallel_tool_calls
+
+    if tool_choice is not None:
+        openai_options["tool_choice"] = tool_choice
+
+    if params.tools is not None:
+        openai_options["tools"] = params.tools
+
+    if top_p is not None:
+        openai_options["top_p"] = top_p
+
+    # allow any other openai.resources.responses.Response.create options
+    if other_options is not None:
+        openai_options.update(other_options)  # type: ignore
+
+    options["options"] = openai_options
+
+    return options
+
+
+def stream_responses_with_references(
+    *,
+    company_id: str,
+    user_id: str,
+    assistant_message_id: str,
+    user_message_id: str,
+    chat_id: str,
+    assistant_id: str,
+    model_name: LanguageModelName | str,
+    messages: str
+    | LanguageModelMessages
+    | Sequence[
+        ResponseInputItemParam | LanguageModelMessageOptions | ResponseOutputItem
+    ],
+    content_chunks: list[ContentChunk] | None = None,
+    tools: Sequence[LanguageModelToolDescription | ToolParam] | None = None,
+    temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+    debug_info: dict | None = None,
+    start_text: str | None = None,
+    include: list[ResponseIncludable] | None = None,
+    instructions: str | None = None,
+    max_output_tokens: int | None = None,
+    metadata: Metadata | None = None,
+    parallel_tool_calls: bool | None = None,
+    text: ResponseTextConfigParam | None = None,
+    tool_choice: response_create_params.ToolChoice | None = None,
+    top_p: float | None = None,
+    reasoning: Reasoning | None = None,
+    other_options: dict | None = None,
+) -> ResponsesLanguageModelStreamResponse:
+    responses_params = _prepare_responses_params_util(
+        model_name=model_name,
+        content_chunks=content_chunks,
+        temperature=temperature,
+        tools=tools,
+        messages=messages,
+        reasoning=reasoning,
+        text=text,
+        other_options=other_options,
+    )
+
+    responses_args = _prepare_responses_args(
+        company_id=company_id,
+        user_id=user_id,
+        assistant_message_id=assistant_message_id,
+        user_message_id=user_message_id,
+        chat_id=chat_id,
+        assistant_id=assistant_id,
+        params=responses_params,
+        debug_info=debug_info,
+        start_text=start_text,
+        include=include,
+        instructions=instructions,
+        max_output_tokens=max_output_tokens,
+        metadata=metadata,
+        parallel_tool_calls=parallel_tool_calls,
+        tool_choice=tool_choice,
+        top_p=top_p,
+        other_options=other_options,
+    )
+
+    return ResponsesLanguageModelStreamResponse.model_validate(
+        unique_sdk.Integrated.responses_stream(
+            **responses_args,
+        )
+    )
+
+
+async def stream_responses_with_references_async(
+    *,
+    company_id: str,
+    user_id: str,
+    assistant_message_id: str,
+    user_message_id: str,
+    chat_id: str,
+    assistant_id: str,
+    model_name: LanguageModelName | str,
+    messages: str
+    | LanguageModelMessages
+    | Sequence[
+        ResponseInputItemParam | LanguageModelMessageOptions | ResponseOutputItem
+    ],
+    content_chunks: list[ContentChunk] | None = None,
+    tools: Sequence[LanguageModelToolDescription | ToolParam] | None = None,
+    temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+    debug_info: dict | None = None,
+    start_text: str | None = None,
+    include: list[ResponseIncludable] | None = None,
+    instructions: str | None = None,
+    max_output_tokens: int | None = None,
+    metadata: Metadata | None = None,
+    parallel_tool_calls: bool | None = None,
+    text: ResponseTextConfigParam | None = None,
+    tool_choice: response_create_params.ToolChoice | None = None,
+    top_p: float | None = None,
+    reasoning: Reasoning | None = None,
+    other_options: dict | None = None,
+) -> ResponsesLanguageModelStreamResponse:
+    responses_params = _prepare_responses_params_util(
+        model_name=model_name,
+        content_chunks=content_chunks,
+        temperature=temperature,
+        tools=tools,
+        messages=messages,
+        reasoning=reasoning,
+        text=text,
+        other_options=other_options,
+    )
+
+    responses_args = _prepare_responses_args(
+        company_id=company_id,
+        user_id=user_id,
+        assistant_message_id=assistant_message_id,
+        user_message_id=user_message_id,
+        chat_id=chat_id,
+        assistant_id=assistant_id,
+        params=responses_params,
+        debug_info=debug_info,
+        start_text=start_text,
+        include=include,
+        instructions=instructions,
+        max_output_tokens=max_output_tokens,
+        metadata=metadata,
+        parallel_tool_calls=parallel_tool_calls,
+        tool_choice=tool_choice,
+        top_p=top_p,
+        other_options=other_options,
+    )
+
+    return ResponsesLanguageModelStreamResponse.model_validate(
+        await unique_sdk.Integrated.responses_stream_async(
+            **responses_args,
+        )
+    )

unique_toolkit/chat/schemas.py

@@ -1,7 +1,19 @@
 from datetime import datetime
 from enum import StrEnum
+from typing import Literal
 
 from humps import camelize
+from openai.types.chat import (
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionMessageParam,
+    ChatCompletionUserMessageParam,
+)
+from openai.types.chat.chat_completion_message_function_tool_call_param import (
+    ChatCompletionMessageFunctionToolCallParam,
+)
+from openai.types.chat.chat_completion_message_function_tool_call_param import (
+    Function as OpenAIFunction,
+)
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -10,16 +22,19 @@ from pydantic import (
     model_validator,
 )
 
+from unique_toolkit.content.schemas import ContentReference
+
 # set config to convert camelCase to snake_case
 model_config = ConfigDict(
-    alias_generator=camelize, populate_by_name=True, arbitrary_types_allowed=True
+    alias_generator=camelize,
+    populate_by_name=True,
 )
 
 
 class ChatMessageRole(StrEnum):
     USER = "user"
     ASSISTANT = "assistant"
-    TOOL = "tool"
+    TOOL = "tool"  # TODO: Unused according @unique-fabian. To be removed in separate PR
 
 
 class Function(BaseModel):
@@ -28,6 +43,12 @@ class Function(BaseModel):
     name: str
     arguments: str
 
+    def to_openai(self) -> OpenAIFunction:
+        return OpenAIFunction(
+            arguments=self.arguments,
+            name=self.name,
+        )
+
 
 class ToolCall(BaseModel):
     model_config = model_config
@@ -36,8 +57,16 @@ class ToolCall(BaseModel):
     type: str
     function: Function
 
+    def to_openai_param(self) -> ChatCompletionMessageFunctionToolCallParam:
+        return ChatCompletionMessageFunctionToolCallParam(
+            id=self.id,
+            function=self.function.to_openai(),
+            type="function",
+        )
+
 
 class ChatMessage(BaseModel):
+    # TODO: The below seems not to be True anymore @irina-unique. To be checked in separate PR
     # This model should strictly meets https://github.com/Unique-AG/monorepo/blob/master/node/apps/node-chat/src/public-api/2023-12-06/dtos/message/public-message.dto.ts
     model_config = model_config
 
@@ -54,6 +83,7 @@ class ChatMessage(BaseModel):
     created_at: datetime | None = None
     completed_at: datetime | None = None
     updated_at: datetime | None = None
+    references: list[ContentReference] | None = None
 
     # TODO make sdk return role consistently in lowercase
     # Currently needed as sdk returns role in uppercase
@@ -68,6 +98,38 @@ class ChatMessage(BaseModel):
             raise ValueError("tool_call_ids is required when role is 'tool'")
         return self
 
+    def to_openai_param(self) -> ChatCompletionMessageParam:
+        match self.role:
+            case ChatMessageRole.USER:
+                return ChatCompletionUserMessageParam(
+                    role="user",
+                    content=self.content or "",
+                )
+
+            case ChatMessageRole.ASSISTANT:
+                if self.tool_calls:
+                    assistant_message = ChatCompletionAssistantMessageParam(
+                        role="assistant",
+                        audio=None,
+                        content=self.content or "",
+                        function_call=None,
+                        refusal=None,
+                        tool_calls=[t.to_openai_param() for t in self.tool_calls],
+                    )
+                else:
+                    assistant_message = ChatCompletionAssistantMessageParam(
+                        role="assistant",
+                        audio=None,
+                        content=self.content or "",
+                        function_call=None,
+                        refusal=None,
+                    )
+
+                return assistant_message
+
+            case ChatMessageRole.TOOL:
+                raise NotImplementedError
+
 
 class ChatMessageAssessmentStatus(StrEnum):
     PENDING = "PENDING"
@@ -100,3 +162,72 @@ class ChatMessageAssessment(BaseModel):
     is_visible: bool
     created_at: datetime | None = None
     updated_at: datetime | None = None
+
+
+class MessageLogStatus(StrEnum):
+    RUNNING = "RUNNING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+
+
+class MessageExecutionStatus(StrEnum):
+    PENDING = "PENDING"
+    RUNNING = "RUNNING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+
+
+class MessageExecutionType(StrEnum):
+    DEEP_RESEARCH = "DEEP_RESEARCH"
+
+
+class MessageExecutionUpdateStatus(StrEnum):
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+
+
+class MessageLogUncitedReferences(BaseModel):
+    model_config = model_config
+    data: list[ContentReference]
+
+
+class MessageLogEvent(BaseModel):
+    model_config = model_config
+    type: Literal["WebSearch", "InternalSearch"]
+    text: str
+
+
+class MessageLogDetails(BaseModel):
+    model_config = model_config
+    data: list[MessageLogEvent] | None = None
+    status: str | None = Field(
+        default=None, description="Overarching status of the current message log"
+    )
+
+
+class MessageLog(BaseModel):
+    model_config = model_config
+
+    message_log_id: str | None = Field(default=None, validation_alias="id")
+    message_id: str | None = None
+    status: MessageLogStatus
+    text: str | None = None
+    details: MessageLogDetails | None = None
+    uncited_references: MessageLogUncitedReferences | None = None
+    order: int
+    references: list[ContentReference] | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+
+class MessageExecution(BaseModel):
+    model_config = model_config
+
+    message_execution_id: str | None = None
+    message_id: str | None = None
+    status: MessageExecutionStatus
+    type: MessageExecutionType = MessageExecutionType.DEEP_RESEARCH
+    seconds_remaining: int | None = None
+    percentage_completed: int | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None