semantic-kernel 1.8.3__zip

semantic_kernel-1.8.3/semantic_kernel/agents/group_chat/agent_group_chat.py

@@ -0,0 +1,135 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from collections.abc import AsyncIterable
+from typing import Any
+
+from pydantic import Field
+
+from semantic_kernel.agents import Agent, AgentChat
+from semantic_kernel.agents.strategies import (
+    DefaultTerminationStrategy,
+    SequentialSelectionStrategy,
+)
+from semantic_kernel.agents.strategies.selection.selection_strategy import SelectionStrategy
+from semantic_kernel.agents.strategies.termination.termination_strategy import TerminationStrategy
+from semantic_kernel.contents.chat_message_content import ChatMessageContent
+from semantic_kernel.contents.utils.author_role import AuthorRole
+from semantic_kernel.exceptions.agent_exceptions import AgentChatException
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class AgentGroupChat(AgentChat):
+    """An agent chat that supports multi-turn interactions."""
+
+    agent_ids: set[str]
+    agents: list[Agent] = Field(default_factory=list)
+
+    is_complete: bool = False
+    termination_strategy: TerminationStrategy = Field(default_factory=DefaultTerminationStrategy)
+    selection_strategy: SelectionStrategy = Field(default_factory=SequentialSelectionStrategy)
+
+    def __init__(
+        self,
+        agents: list[Agent] | None = None,
+        termination_strategy: TerminationStrategy | None = None,
+        selection_strategy: SelectionStrategy | None = None,
+    ) -> None:
+        """Initialize a new instance of AgentGroupChat.
+
+        Args:
+            agents: The agents to add to the group chat.
+            termination_strategy: The termination strategy to use.
+            selection_strategy: The selection strategy
+        """
+        agent_ids = {agent.id for agent in agents} if agents else set()
+
+        if agents is None:
+            agents = []
+
+        args: dict[str, Any] = {
+            "agents": agents,
+            "agent_ids": agent_ids,
+        }
+
+        if termination_strategy is not None:
+            args["termination_strategy"] = termination_strategy
+        if selection_strategy is not None:
+            args["selection_strategy"] = selection_strategy
+
+        super().__init__(**args)
+
+    def add_agent(self, agent: Agent) -> None:
+        """Add an agent to the group chat.
+
+        Args:
+            agent: The agent to add.
+        """
+        if agent.id not in self.agent_ids:
+            self.agent_ids.add(agent.id)
+            self.agents.append(agent)
+
+    async def invoke_single_turn(self, agent: Agent) -> AsyncIterable[ChatMessageContent]:
+        """Invoke the agent chat for a single turn.
+
+        Args:
+            agent: The agent to invoke.
+
+        Yields:
+            The chat message.
+        """
+        async for message in self.invoke(agent, is_joining=True):
+            if message.role == AuthorRole.ASSISTANT:
+                task = self.termination_strategy.should_terminate(agent, self.history.messages)
+                self.is_complete = await task
+            yield message
+
+    async def invoke(self, agent: Agent | None = None, is_joining: bool = True) -> AsyncIterable[ChatMessageContent]:
+        """Invoke the agent chat asynchronously.
+
+        Handles both group interactions and single agent interactions based on the provided arguments.
+
+        Args:
+            agent: The agent to invoke. If not provided, the method processes all agents in the chat.
+            is_joining: Controls whether the agent joins the chat. Defaults to True.
+
+        Yields:
+            The chat message.
+        """
+        if agent is not None:
+            if is_joining:
+                self.add_agent(agent)
+
+            async for message in super().invoke_agent(agent):
+                if message.role == AuthorRole.ASSISTANT:
+                    task = self.termination_strategy.should_terminate(agent, self.history.messages)
+                    self.is_complete = await task
+                yield message
+
+            return
+
+        if self.agents is None:
+            raise AgentChatException("No agents are available")
+
+        if self.is_complete:
+            if not self.termination_strategy.automatic_reset:
+                raise AgentChatException("Chat is already complete")
+
+            self.is_complete = False
+
+        for _ in range(self.termination_strategy.maximum_iterations):
+            try:
+                selected_agent = await self.selection_strategy.next(self.agents, self.history.messages)
+            except Exception as ex:
+                logger.error(f"Failed to select agent: {ex}")
+                raise AgentChatException("Failed to select agent") from ex
+
+            async for message in super().invoke_agent(selected_agent):
+                if message.role == AuthorRole.ASSISTANT:
+                    task = self.termination_strategy.should_terminate(selected_agent, self.history.messages)
+                    self.is_complete = await task
+                yield message
+
+            if self.is_complete:
+                break

semantic_kernel-1.8.3/semantic_kernel/agents/group_chat/broadcast_queue.py

@@ -0,0 +1,127 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+import asyncio
+from collections import deque
+from dataclasses import dataclass, field
+
+from pydantic import Field, SkipValidation, ValidationError, model_validator
+
+from semantic_kernel.agents.channels.agent_channel import AgentChannel
+from semantic_kernel.contents.chat_message_content import ChatMessageContent
+from semantic_kernel.kernel_pydantic import KernelBaseModel
+from semantic_kernel.utils.experimental_decorator import experimental_class
+
+
+@experimental_class
+class QueueReference(KernelBaseModel):
+    """Utility class to associate a queue with its specific lock."""
+
+    queue: deque = Field(default_factory=deque)
+    queue_lock: SkipValidation[asyncio.Lock] = Field(default_factory=asyncio.Lock, exclude=True)
+    receive_task: SkipValidation[asyncio.Task | None] = None
+    receive_failure: Exception | None = None
+
+    @property
+    def is_empty(self):
+        """Check if the queue is empty."""
+        return len(self.queue) == 0
+
+    @model_validator(mode="before")
+    def validate_receive_task(cls, values):
+        """Validate the receive task."""
+        receive_task = values.get("receive_task")
+        if receive_task is not None and not isinstance(receive_task, asyncio.Task):
+            raise ValidationError("receive_task must be an instance of asyncio.Task or None")
+        return values
+
+
+@experimental_class
+@dataclass
+class ChannelReference:
+    """Tracks a channel along with its hashed key."""
+
+    hash: str
+    channel: AgentChannel = field(default_factory=AgentChannel)
+
+
+@experimental_class
+class BroadcastQueue(KernelBaseModel):
+    """A queue for broadcasting messages to listeners."""
+
+    queues: dict[str, QueueReference] = Field(default_factory=dict)
+    block_duration: float = 0.1
+
+    async def enqueue(self, channel_refs: list[ChannelReference], messages: list[ChatMessageContent]) -> None:
+        """Enqueue a set of messages for a given channel.
+
+        Args:
+            channel_refs: The channel references.
+            messages: The messages to broadcast.
+        """
+        for channel_ref in channel_refs:
+            if channel_ref.hash not in self.queues:
+                self.queues[channel_ref.hash] = QueueReference()
+
+            queue_ref = self.queues[channel_ref.hash]
+
+            async with queue_ref.queue_lock:
+                queue_ref.queue.append(messages)
+
+                if not queue_ref.receive_task or queue_ref.receive_task.done():
+                    queue_ref.receive_task = asyncio.create_task(self.receive(channel_ref, queue_ref))
+
+    async def ensure_synchronized(self, channel_ref: ChannelReference) -> None:
+        """Blocks until a channel-queue is not in a receive state to ensure that channel history is complete.
+
+        Args:
+            channel_ref: The channel reference.
+        """
+        if channel_ref.hash not in self.queues:
+            return
+
+        queue_ref = self.queues[channel_ref.hash]
+
+        while True:
+            async with queue_ref.queue_lock:
+                is_empty = queue_ref.is_empty
+
+                if queue_ref.receive_failure is not None:
+                    failure = queue_ref.receive_failure
+                    queue_ref.receive_failure = None
+                    raise Exception(
+                        f"Unexpected failure broadcasting to channel: {type(channel_ref.channel)}, failure: {failure}"
+                    ) from failure
+
+                if not is_empty and (not queue_ref.receive_task or queue_ref.receive_task.done()):
+                    queue_ref.receive_task = asyncio.create_task(self.receive(channel_ref, queue_ref))
+
+            if is_empty:
+                break
+
+            await asyncio.sleep(self.block_duration)
+
+    async def receive(self, channel_ref: ChannelReference, queue_ref: QueueReference) -> None:
+        """Processes the specified queue with the provided channel, until the queue is empty.
+
+        Args:
+            channel_ref: The channel reference.
+            queue_ref: The queue reference.
+        """
+        while True:
+            async with queue_ref.queue_lock:
+                if queue_ref.is_empty:
+                    break
+
+                messages = queue_ref.queue[0]
+            try:
+                await channel_ref.channel.receive(messages)
+            except Exception as e:
+                queue_ref.receive_failure = e
+
+            async with queue_ref.queue_lock:
+                if not queue_ref.is_empty:
+                    queue_ref.queue.popleft()
+
+                if queue_ref.receive_failure is not None or queue_ref.is_empty:
+                    break

semantic_kernel-1.8.3/semantic_kernel/agents/open_ai/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.agents.open_ai.azure_assistant_agent import AzureAssistantAgent
+from semantic_kernel.agents.open_ai.open_ai_assistant_agent import OpenAIAssistantAgent
+
+__all__ = ["AzureAssistantAgent", "OpenAIAssistantAgent"]

semantic_kernel-1.8.3/semantic_kernel/agents/open_ai/assistant_content_generation.py

@@ -0,0 +1,198 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import TYPE_CHECKING, Any
+
+from openai import AsyncOpenAI
+from openai.types.beta.threads.image_file_content_block import ImageFileContentBlock
+from openai.types.beta.threads.text_content_block import TextContentBlock
+
+from semantic_kernel.contents.annotation_content import AnnotationContent
+from semantic_kernel.contents.chat_message_content import ChatMessageContent
+from semantic_kernel.contents.file_reference_content import FileReferenceContent
+from semantic_kernel.contents.function_call_content import FunctionCallContent
+from semantic_kernel.contents.function_result_content import FunctionResultContent
+from semantic_kernel.contents.image_content import ImageContent
+from semantic_kernel.contents.text_content import TextContent
+from semantic_kernel.contents.utils.author_role import AuthorRole
+from semantic_kernel.exceptions.agent_exceptions import AgentExecutionException
+
+if TYPE_CHECKING:
+    from openai.resources.beta.threads.messages import Message
+    from openai.resources.beta.threads.runs.runs import Run
+    from openai.types.beta.threads.annotation import Annotation
+    from openai.types.beta.threads.runs.tool_call import ToolCall
+
+
+###################################################################
+# The methods in this file are used with OpenAIAssistantAgent     #
+# related code. They are used to create chat messages, or         #
+# generate message content.                                       #
+###################################################################
+
+
+async def create_chat_message(
+    client: AsyncOpenAI,
+    thread_id: str,
+    message: "ChatMessageContent",
+    allowed_message_roles: list[str] = [AuthorRole.USER, AuthorRole.ASSISTANT],
+) -> "Message":
+    """Class method to add a chat message, callable from class or instance.
+
+    Args:
+        client: The client to use for creating the message.
+        thread_id: The thread id.
+        message: The chat message.
+        allowed_message_roles: The allowed message roles.
+
+    Returns:
+        Message: The message.
+    """
+    if message.role.value not in allowed_message_roles and message.role != AuthorRole.TOOL:
+        raise AgentExecutionException(
+            f"Invalid message role `{message.role.value}`. Allowed roles are {allowed_message_roles}."
+        )
+
+    message_contents: list[dict[str, Any]] = get_message_contents(message=message)
+
+    return await client.beta.threads.messages.create(
+        thread_id=thread_id,
+        role="assistant" if message.role == AuthorRole.TOOL else message.role.value,  # type: ignore
+        content=message_contents,  # type: ignore
+    )
+
+
+def get_message_contents(message: "ChatMessageContent") -> list[dict[str, Any]]:
+    """Get the message contents.
+
+    Args:
+        message: The message.
+    """
+    contents: list[dict[str, Any]] = []
+    for content in message.items:
+        if isinstance(content, TextContent):
+            contents.append({"type": "text", "text": content.text})
+        elif isinstance(content, ImageContent) and content.uri:
+            contents.append(content.to_dict())
+        elif isinstance(content, FileReferenceContent):
+            contents.append({
+                "type": "image_file",
+                "image_file": {"file_id": content.file_id},
+            })
+        elif isinstance(content, FunctionResultContent):
+            contents.append({"type": "text", "text": content.result})
+    return contents
+
+
+def generate_message_content(assistant_name: str, message: "Message") -> ChatMessageContent:
+    """Generate message content."""
+    role = AuthorRole(message.role)
+
+    content: ChatMessageContent = ChatMessageContent(role=role, name=assistant_name)  # type: ignore
+
+    for item_content in message.content:
+        if item_content.type == "text":
+            assert isinstance(item_content, TextContentBlock)  # nosec
+            content.items.append(
+                TextContent(
+                    text=item_content.text.value,
+                )
+            )
+            for annotation in item_content.text.annotations:
+                content.items.append(generate_annotation_content(annotation))
+        elif item_content.type == "image_file":
+            assert isinstance(item_content, ImageFileContentBlock)  # nosec
+            content.items.append(
+                FileReferenceContent(
+                    file_id=item_content.image_file.file_id,
+                )
+            )
+    return content
+
+
+def generate_function_call_content(agent_name: str, fccs: list[FunctionCallContent]) -> ChatMessageContent:
+    """Generate function call content.
+
+    Args:
+        agent_name: The agent name.
+        fccs: The function call contents.
+
+    Returns:
+        ChatMessageContent: The chat message content containing the function call content as the items.
+    """
+    return ChatMessageContent(role=AuthorRole.TOOL, name=agent_name, items=fccs)  # type: ignore
+
+
+def generate_function_result_content(
+    agent_name: str, function_step: FunctionCallContent, tool_call: "ToolCall"
+) -> ChatMessageContent:
+    """Generate function result content."""
+    function_call_content: ChatMessageContent = ChatMessageContent(role=AuthorRole.TOOL, name=agent_name)  # type: ignore
+    function_call_content.items.append(
+        FunctionResultContent(
+            function_name=function_step.function_name,
+            plugin_name=function_step.plugin_name,
+            id=function_step.id,
+            result=tool_call.function.output,  # type: ignore
+        )
+    )
+    return function_call_content
+
+
+def get_function_call_contents(run: "Run", function_steps: dict[str, FunctionCallContent]) -> list[FunctionCallContent]:
+    """Extract function call contents from the run.
+
+    Args:
+        run: The run.
+        function_steps: The function steps
+
+    Returns:
+        The list of function call contents.
+    """
+    function_call_contents: list[FunctionCallContent] = []
+    required_action = getattr(run, "required_action", None)
+    if not required_action or not getattr(required_action, "submit_tool_outputs", False):
+        return function_call_contents
+    for tool in required_action.submit_tool_outputs.tool_calls:
+        fcc = FunctionCallContent(
+            id=tool.id,
+            index=getattr(tool, "index", None),
+            name=tool.function.name,
+            arguments=tool.function.arguments,
+        )
+        function_call_contents.append(fcc)
+        function_steps[tool.id] = fcc
+    return function_call_contents
+
+
+def generate_code_interpreter_content(agent_name: str, code: str) -> "ChatMessageContent":
+    """Generate code interpreter content.
+
+    Args:
+        agent_name: The agent name.
+        code: The code.
+
+    Returns:
+        ChatMessageContent: The chat message content.
+    """
+    return ChatMessageContent(
+        role=AuthorRole.ASSISTANT,
+        content=code,
+        name=agent_name,
+        metadata={"code": True},
+    )
+
+
+def generate_annotation_content(annotation: "Annotation") -> AnnotationContent:
+    """Generate annotation content."""
+    file_id = None
+    if hasattr(annotation, "file_path"):
+        file_id = annotation.file_path.file_id
+    elif hasattr(annotation, "file_citation"):
+        file_id = annotation.file_citation.file_id
+
+    return AnnotationContent(
+        file_id=file_id,
+        quote=annotation.text,
+        start_index=annotation.start_index,
+        end_index=annotation.end_index,
+    )