azure-ai-agentserver-agentframework 1.0.0b2__py3-none-any.whl

azure/ai/agentserver/__init__.py

@@ -0,0 +1 @@
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)  # type: ignore

azure/ai/agentserver/agentframework/__init__.py

@@ -0,0 +1,16 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)
+
+from ._version import VERSION
+
+
+def from_agent_framework(agent):
+    from .agent_framework import AgentFrameworkCBAgent
+
+    return AgentFrameworkCBAgent(agent)
+
+
+__all__ = ["from_agent_framework"]
+__version__ = VERSION

azure/ai/agentserver/agentframework/_version.py

@@ -0,0 +1,9 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+VERSION = "1.0.0b2"

azure/ai/agentserver/agentframework/agent_framework.py

@@ -0,0 +1,153 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+# pylint: disable=logging-fstring-interpolation,no-name-in-module
+from __future__ import annotations
+
+import asyncio  # pylint: disable=do-not-import-asyncio
+import os
+from typing import Any, AsyncGenerator, Union
+
+from agent_framework import AgentProtocol
+from agent_framework.azure import AzureAIAgentClient  # pylint: disable=no-name-in-module
+from opentelemetry import trace
+
+from azure.ai.agentserver.core import AgentRunContext, FoundryCBAgent
+from azure.ai.agentserver.core.constants import Constants as AdapterConstants
+from azure.ai.agentserver.core.logger import APPINSIGHT_CONNSTR_ENV_NAME, get_logger
+from azure.ai.agentserver.core.models import (
+    CreateResponse,
+    Response as OpenAIResponse,
+    ResponseStreamEvent,
+)
+from azure.ai.projects import AIProjectClient
+from azure.identity import DefaultAzureCredential
+
+from .models.agent_framework_input_converters import AgentFrameworkInputConverter
+from .models.agent_framework_output_non_streaming_converter import (
+    AgentFrameworkOutputNonStreamingConverter,
+)
+from .models.agent_framework_output_streaming_converter import AgentFrameworkOutputStreamingConverter
+from .models.constants import Constants
+
+logger = get_logger()
+
+
+class AgentFrameworkCBAgent(FoundryCBAgent):
+    """
+    Adapter class for integrating Agent Framework agents with the FoundryCB agent interface.
+
+    This class wraps an Agent Framework `AgentProtocol` instance and provides a unified interface
+    for running agents in both streaming and non-streaming modes. It handles input and output
+    conversion between the Agent Framework and the expected formats for FoundryCB agents.
+
+    Parameters:
+        agent (AgentProtocol): An instance of an Agent Framework agent to be adapted.
+
+    Usage:
+        - Instantiate with an Agent Framework agent.
+        - Call `agent_run` with a `CreateResponse` request body to execute the agent.
+        - Supports both streaming and non-streaming responses based on the `stream` flag.
+    """
+
+    def __init__(self, agent: AgentProtocol):
+        super().__init__()
+        self.agent = agent
+        logger.info(f"Initialized AgentFrameworkCBAgent with agent: {type(agent).__name__}")
+
+    def _resolve_stream_timeout(self, request_body: CreateResponse) -> float:
+        """Resolve idle timeout for streaming updates.
+
+        Order of precedence:
+        1) request_body.stream_timeout_s (if provided)
+        2) env var Constants.AGENTS_ADAPTER_STREAM_TIMEOUT_S
+        3) Constants.DEFAULT_STREAM_TIMEOUT_S
+
+        :param request_body: The CreateResponse request body.
+        :type request_body: CreateResponse
+
+        :return: The resolved stream timeout in seconds.
+        :rtype: float
+        """
+        override = request_body.get("stream_timeout_s", None)
+        if override is not None:
+            return float(override)
+        env_val = os.getenv(Constants.AGENTS_ADAPTER_STREAM_TIMEOUT_S)
+        return float(env_val) if env_val is not None else float(Constants.DEFAULT_STREAM_TIMEOUT_S)
+
+    def init_tracing(self):
+        exporter = os.environ.get(AdapterConstants.OTEL_EXPORTER_ENDPOINT)
+        app_insights_conn_str = os.environ.get(APPINSIGHT_CONNSTR_ENV_NAME)
+        project_endpoint = os.environ.get(AdapterConstants.AZURE_AI_PROJECT_ENDPOINT)
+
+        if project_endpoint:
+            project_client = AIProjectClient(endpoint=project_endpoint, credential=DefaultAzureCredential())
+            agent_client = AzureAIAgentClient(project_client=project_client)
+            agent_client.setup_azure_ai_observability()
+        elif exporter or app_insights_conn_str:
+            os.environ["WORKFLOW_ENABLE_OTEL"] = "true"
+            from agent_framework.observability import setup_observability
+
+            setup_observability(
+                enable_sensitive_data=True,
+                otlp_endpoint=exporter,
+                applicationinsights_connection_string=app_insights_conn_str,
+            )
+        self.tracer = trace.get_tracer(__name__)
+
+    async def agent_run(
+        self, context: AgentRunContext
+    ) -> Union[
+        OpenAIResponse,
+        AsyncGenerator[ResponseStreamEvent, Any],
+    ]:
+        logger.info(f"Starting agent_run with stream={context.stream}")
+        request_input = context.request.get("input")
+
+        input_converter = AgentFrameworkInputConverter()
+        message = input_converter.transform_input(request_input)
+        logger.debug(f"Transformed input message type: {type(message)}")
+
+        # Use split converters
+        if context.stream:
+            logger.info("Running agent in streaming mode")
+            streaming_converter = AgentFrameworkOutputStreamingConverter(context)
+
+            async def stream_updates():
+                update_count = 0
+                timeout_s = self._resolve_stream_timeout(context.request)
+                logger.info("Starting streaming with idle-timeout=%.2fs", timeout_s)
+                for ev in streaming_converter.initial_events():
+                    yield ev
+
+                # Iterate with per-update timeout; terminate if idle too long
+                aiter = self.agent.run_stream(message).__aiter__()
+                while True:
+                    try:
+                        update = await asyncio.wait_for(aiter.__anext__(), timeout=timeout_s)
+                    except StopAsyncIteration:
+                        logger.debug("Agent streaming iterator finished (StopAsyncIteration)")
+                        break
+                    except asyncio.TimeoutError:
+                        logger.warning("Streaming idle timeout reached (%.1fs); terminating stream.", timeout_s)
+                        for ev in streaming_converter.completion_events():
+                            yield ev
+                        return
+                    update_count += 1
+                    transformed = streaming_converter.transform_output_for_streaming(update)
+                    for event in transformed:
+                        yield event
+                for ev in streaming_converter.completion_events():
+                    yield ev
+                logger.info("Streaming completed with %d updates", update_count)
+
+            return stream_updates()
+
+        # Non-streaming path
+        logger.info("Running agent in non-streaming mode")
+        non_streaming_converter = AgentFrameworkOutputNonStreamingConverter(context)
+        result = await self.agent.run(message)
+        logger.debug(f"Agent run completed, result type: {type(result)}")
+        transformed_result = non_streaming_converter.transform_output_for_response(result)
+        logger.info("Agent run and transformation completed successfully")
+        return transformed_result

azure/ai/agentserver/agentframework/models/__init__.py

@@ -0,0 +1,5 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

azure/ai/agentserver/agentframework/models/agent_framework_input_converters.py

@@ -0,0 +1,120 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+# pylint: disable=too-many-nested-blocks,too-many-return-statements,too-many-branches
+# mypy: disable-error-code="no-redef"
+from __future__ import annotations
+
+from typing import Dict, List
+
+from agent_framework import ChatMessage, Role as ChatRole
+from agent_framework._types import TextContent
+
+from azure.ai.agentserver.core.logger import get_logger
+
+logger = get_logger()
+
+
+class AgentFrameworkInputConverter:
+    """Normalize inputs for agent.run.
+
+    Accepts: str | List | None
+    Returns: None | str | ChatMessage | list[str] | list[ChatMessage]
+    """
+
+    def transform_input(
+        self,
+        input: str | List[Dict] | None,
+    ) -> str | ChatMessage | list[str] | list[ChatMessage] | None:
+        logger.debug("Transforming input of type: %s", type(input))
+
+        if input is None:
+            return None
+
+        if isinstance(input, str):
+            return input
+
+        try:
+            if isinstance(input, list):
+                messages: list[str | ChatMessage] = []
+
+                for item in input:
+                    # Case 1: ImplicitUserMessage with content as str or list of ItemContentInputText
+                    if self._is_implicit_user_message(item):
+                        content = item.get("content", None)
+                        if isinstance(content, str):
+                            messages.append(content)
+                        elif isinstance(content, list):
+                            text_parts: list[str] = []
+                            for content_item in content:
+                                text_content = self._extract_input_text(content_item)
+                                if text_content:
+                                    text_parts.append(text_content)
+                            if text_parts:
+                                messages.append(" ".join(text_parts))
+
+                    # Case 2: Explicit message params (user/assistant/system)
+                    elif (
+                        item.get("type") == "message"
+                        and item.get("role") is not None
+                        and item.get("content") is not None
+                    ):
+                        role_map = {
+                            "user": ChatRole.USER,
+                            "assistant": ChatRole.ASSISTANT,
+                            "system": ChatRole.SYSTEM,
+                        }
+                        role = role_map.get(item.get("role", "user"), ChatRole.USER)
+
+                        content_text = ""
+                        item_content = item.get("content", None)
+                        if item_content and isinstance(item_content, list):
+                            text_parts: list[str] = []
+                            for content_item in item_content:
+                                item_text = self._extract_input_text(content_item)
+                                if item_text:
+                                    text_parts.append(item_text)
+                            content_text = " ".join(text_parts) if text_parts else ""
+                        elif item_content and isinstance(item_content, str):
+                            content_text = str(item_content)
+
+                        if content_text:
+                            messages.append(ChatMessage(role=role, text=content_text))
+
+                # Determine the most natural return type
+                if not messages:
+                    return None
+                if len(messages) == 1:
+                    return messages[0]
+                if all(isinstance(m, str) for m in messages):
+                    return [m for m in messages if isinstance(m, str)]
+                if all(isinstance(m, ChatMessage) for m in messages):
+                    return [m for m in messages if isinstance(m, ChatMessage)]
+
+                # Mixed content: coerce ChatMessage to str by extracting TextContent parts
+                result: list[str] = []
+                for msg in messages:
+                    if isinstance(msg, ChatMessage):
+                        text_parts: list[str] = []
+                        for c in getattr(msg, "contents", []) or []:
+                            if isinstance(c, TextContent):
+                                text_parts.append(c.text)
+                        result.append(" ".join(text_parts) if text_parts else str(msg))
+                    else:
+                        result.append(str(msg))
+                return result
+
+            raise TypeError(f"Unsupported input type: {type(input)}")
+        except Exception as e:
+            logger.error("Error processing messages: %s", e, exc_info=True)
+            raise Exception(f"Error processing messages: {e}") from e  # pylint: disable=broad-exception-raised
+
+    def _is_implicit_user_message(self, item: Dict) -> bool:
+        return "content" in item and "role" not in item and "type" not in item
+
+    def _extract_input_text(self, content_item: Dict) -> str:
+        if content_item.get("type") == "input_text" and "text" in content_item:
+            text_content = content_item.get("text")
+            if isinstance(text_content, str):
+                return text_content
+        return None  # type: ignore

azure/ai/agentserver/agentframework/models/agent_framework_output_non_streaming_converter.py

@@ -0,0 +1,232 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+from __future__ import annotations
+
+import datetime
+import json
+from typing import Any, List
+
+from agent_framework import AgentRunResponse, FunctionResultContent
+from agent_framework._types import FunctionCallContent, TextContent
+
+from azure.ai.agentserver.core import AgentRunContext
+from azure.ai.agentserver.core.logger import get_logger
+from azure.ai.agentserver.core.models import Response as OpenAIResponse
+from azure.ai.agentserver.core.models.projects import (
+    ItemContentOutputText,
+    ResponsesAssistantMessageItemResource,
+)
+
+from .agent_id_generator import AgentIdGenerator
+from .constants import Constants
+
+logger = get_logger()
+
+
+class AgentFrameworkOutputNonStreamingConverter:  # pylint: disable=name-too-long
+    """Non-streaming converter: AgentRunResponse -> OpenAIResponse."""
+
+    def __init__(self, context: AgentRunContext):
+        self._context = context
+        self._response_id = None
+        self._response_created_at = None
+
+    def _ensure_response_started(self) -> None:
+        if not self._response_id:
+            self._response_id = self._context.response_id  # type: ignore
+        if not self._response_created_at:
+            self._response_created_at = int(datetime.datetime.now(datetime.timezone.utc).timestamp())  # type: ignore
+
+    def _build_item_content_output_text(self, text: str) -> ItemContentOutputText:
+        return ItemContentOutputText(text=text, annotations=[])
+
+    def _new_assistant_message_item(self, message_text: str) -> ResponsesAssistantMessageItemResource:
+        item_content = self._build_item_content_output_text(message_text)
+        return ResponsesAssistantMessageItemResource(
+            id=self._context.id_generator.generate_message_id(), status="completed", content=[item_content]
+        )
+
+    def transform_output_for_response(self, response: AgentRunResponse) -> OpenAIResponse:
+        """Build an OpenAIResponse capturing all supported content types.
+
+        Previously this method only emitted text message items. We now also capture:
+          - FunctionCallContent  -> function_call output item
+          - FunctionResultContent -> function_call_output item
+
+        to stay aligned with the streaming converter so no output is lost.
+
+        :param response: The AgentRunResponse from the agent framework.
+        :type response: AgentRunResponse
+
+        :return: The constructed OpenAIResponse.
+        :rtype: OpenAIResponse
+        """
+        logger.debug("Transforming non-streaming response (messages=%d)", len(response.messages))
+        self._ensure_response_started()
+
+        completed_items: List[dict] = []
+
+        for i, message in enumerate(response.messages):
+            logger.debug("Non-streaming: processing message index=%d type=%s", i, type(message).__name__)
+            contents = getattr(message, "contents", None)
+            if not contents:
+                continue
+            for j, content in enumerate(contents):
+                logger.debug("  content index=%d in message=%d type=%s", j, i, type(content).__name__)
+                self._append_content_item(content, completed_items)
+
+        response_data = self._construct_response_data(completed_items)
+        openai_response = OpenAIResponse(response_data)
+        logger.info(
+            "OpenAIResponse built (id=%s, items=%d)",
+            self._response_id,
+            len(completed_items),
+        )
+        return openai_response
+
+    # ------------------------- helper append methods -------------------------
+
+    def _append_content_item(self, content: Any, sink: List[dict]) -> None:
+        """Dispatch a content object to the appropriate append helper.
+
+        Adding this indirection keeps the main transform method compact and makes it
+        simpler to extend with new content types later.
+
+        :param content: The content object to append.
+        :type content: Any
+        :param sink: The list to append the converted content dict to.
+        :type sink: List[dict]
+
+        :return: None
+        :rtype: None
+        """
+        if isinstance(content, TextContent):
+            self._append_text_content(content, sink)
+        elif isinstance(content, FunctionCallContent):
+            self._append_function_call_content(content, sink)
+        elif isinstance(content, FunctionResultContent):
+            self._append_function_result_content(content, sink)
+        else:
+            logger.debug("unsupported content type skipped: %s", type(content).__name__)
+
+    def _append_text_content(self, content: TextContent, sink: List[dict]) -> None:
+        text_value = getattr(content, "text", None)
+        if not text_value:
+            return
+        item_id = self._context.id_generator.generate_message_id()
+        sink.append(
+            {
+                "id": item_id,
+                "type": "message",
+                "status": "completed",
+                "role": "assistant",
+                "content": [
+                    {
+                        "type": "output_text",
+                        "text": text_value,
+                        "annotations": [],
+                        "logprobs": [],
+                    }
+                ],
+            }
+        )
+        logger.debug("    added message item id=%s text_len=%d", item_id, len(text_value))
+
+    def _append_function_call_content(self, content: FunctionCallContent, sink: List[dict]) -> None:
+        name = getattr(content, "name", "") or ""
+        arguments = getattr(content, "arguments", "")
+        if not isinstance(arguments, str):
+            try:
+                arguments = json.dumps(arguments)
+            except Exception:  # pragma: no cover - fallback # pylint: disable=broad-exception-caught
+                arguments = str(arguments)
+        call_id = getattr(content, "call_id", None) or self._context.id_generator.generate_function_call_id()
+        func_item_id = self._context.id_generator.generate_function_call_id()
+        sink.append(
+            {
+                "id": func_item_id,
+                "type": "function_call",
+                "status": "completed",
+                "call_id": call_id,
+                "name": name,
+                "arguments": arguments or "",
+            }
+        )
+        logger.debug(
+            "    added function_call item id=%s call_id=%s name=%s args_len=%d",
+            func_item_id,
+            call_id,
+            name,
+            len(arguments or ""),
+        )
+
+    def _append_function_result_content(self, content: FunctionResultContent, sink: List[dict]) -> None:
+        # Coerce the function result into a simple display string.
+        result = []
+        raw = getattr(content, "result", None)
+        if isinstance(raw, str):
+            result = [raw]
+        elif isinstance(raw, list):
+            for item in raw:
+                result.append(self._coerce_result_text(item))  # type: ignore
+        call_id = getattr(content, "call_id", None) or ""
+        func_out_id = self._context.id_generator.generate_function_output_id()
+        sink.append(
+            {
+                "id": func_out_id,
+                "type": "function_call_output",
+                "status": "completed",
+                "call_id": call_id,
+                "output": json.dumps(result) if len(result) > 0 else "",
+            }
+        )
+        logger.debug(
+            "added function_call_output item id=%s call_id=%s output_len=%d",
+            func_out_id,
+            call_id,
+            len(result),
+        )
+
+    # ------------- simple normalization helper -------------------------
+    def _coerce_result_text(self, value: Any) -> str | dict:
+        """
+        Return a string if value is already str or a TextContent-like object; else str(value).
+
+        :param value: The value to coerce.
+        :type value: Any
+
+        :return: The coerced string or dict.
+        :rtype: str | dict
+        """
+        if value is None:
+            return ""
+        if isinstance(value, str):
+            return value
+        # Direct TextContent instance
+        if isinstance(value, TextContent):
+            content_payload = {"type": "text", "text": getattr(value, "text", "")}
+            return content_payload
+
+        return ""
+
+    def _construct_response_data(self, output_items: List[dict]) -> dict:
+        agent_id = AgentIdGenerator.generate(self._context)
+
+        response_data = {
+            "object": "response",
+            "metadata": {},
+            "agent": agent_id,
+            "conversation": self._context.get_conversation_object(),
+            "type": "message",
+            "role": "assistant",
+            "temperature": Constants.DEFAULT_TEMPERATURE,
+            "top_p": Constants.DEFAULT_TOP_P,
+            "user": "",
+            "id": self._context.response_id,
+            "created_at": self._response_created_at,
+            "output": output_items,
+            "parallel_tool_calls": True,
+            "status": "completed",
+        }
+        return response_data

azure/ai/agentserver/agentframework/models/agent_framework_output_streaming_converter.py

@@ -0,0 +1,596 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+# pylint: disable=attribute-defined-outside-init,protected-access
+# mypy: disable-error-code="call-overload,assignment,arg-type"
+from __future__ import annotations
+
+import datetime
+import json
+import uuid
+from typing import Any, List, Optional, cast
+
+from agent_framework import AgentRunResponseUpdate, FunctionApprovalRequestContent, FunctionResultContent
+from agent_framework._types import (
+    ErrorContent,
+    FunctionCallContent,
+    TextContent,
+)
+
+from azure.ai.agentserver.core import AgentRunContext
+from azure.ai.agentserver.core.logger import get_logger
+from azure.ai.agentserver.core.models import (
+    Response as OpenAIResponse,
+    ResponseStreamEvent,
+)
+from azure.ai.agentserver.core.models.projects import (
+    FunctionToolCallItemResource,
+    FunctionToolCallOutputItemResource,
+    ItemContentOutputText,
+    ResponseCompletedEvent,
+    ResponseContentPartAddedEvent,
+    ResponseContentPartDoneEvent,
+    ResponseCreatedEvent,
+    ResponseErrorEvent,
+    ResponseFunctionCallArgumentsDeltaEvent,
+    ResponseFunctionCallArgumentsDoneEvent,
+    ResponseInProgressEvent,
+    ResponseOutputItemAddedEvent,
+    ResponseOutputItemDoneEvent,
+    ResponsesAssistantMessageItemResource,
+    ResponseTextDeltaEvent,
+    ResponseTextDoneEvent,
+)
+
+from .agent_id_generator import AgentIdGenerator
+
+logger = get_logger()
+
+
+class _BaseStreamingState:
+    """Base interface for streaming state handlers."""
+
+    def prework(self, ctx: Any) -> List[ResponseStreamEvent]:  # pylint: disable=unused-argument
+        return []
+
+    def convert_content(self, ctx: Any, content) -> List[ResponseStreamEvent]:  # pylint: disable=unused-argument
+        raise NotImplementedError
+
+    def afterwork(self, ctx: Any) -> List[ResponseStreamEvent]:  # pylint: disable=unused-argument
+        return []
+
+
+class _TextContentStreamingState(_BaseStreamingState):
+    """State handler for text and reasoning-text content during streaming."""
+
+    def __init__(self, context: AgentRunContext) -> None:
+        self.context = context
+        self.item_id = None
+        self.output_index = None
+        self.text_buffer = ""
+        self.text_part_started = False
+
+    def prework(self, ctx: Any) -> List[ResponseStreamEvent]:
+        events: List[ResponseStreamEvent] = []
+        if self.item_id is not None:
+            return events
+
+        # Start a new assistant message item (in_progress)
+        self.item_id = self.context.id_generator.generate_message_id()
+        self.output_index = ctx._next_output_index  # pylint: disable=protected-access
+        ctx._next_output_index += 1
+
+        message_item = ResponsesAssistantMessageItemResource(
+            id=self.item_id,
+            status="in_progress",
+            content=[],
+        )
+
+        events.append(
+            ResponseOutputItemAddedEvent(
+                sequence_number=ctx.next_sequence(),
+                output_index=self.output_index,
+                item=message_item,
+            )
+        )
+
+        if not self.text_part_started:
+            empty_part = ItemContentOutputText(text="", annotations=[], logprobs=[])
+            events.append(
+                ResponseContentPartAddedEvent(
+                    sequence_number=ctx.next_sequence(),
+                    item_id=self.item_id,
+                    output_index=self.output_index,
+                    content_index=0,
+                    part=empty_part,
+                )
+            )
+            self.text_part_started = True
+        return events
+
+    def convert_content(self, ctx: Any, content: TextContent) -> List[ResponseStreamEvent]:
+        events: List[ResponseStreamEvent] = []
+        if isinstance(content, TextContent):
+            delta = content.text or ""
+        else:
+            delta = getattr(content, "text", None) or getattr(content, "reasoning", "") or ""
+
+        # buffer accumulated text
+        self.text_buffer += delta
+
+        # emit delta event for text
+        assert self.item_id is not None, "Text state not initialized: missing item_id"
+        assert self.output_index is not None, "Text state not initialized: missing output_index"
+        events.append(
+            ResponseTextDeltaEvent(
+                sequence_number=ctx.next_sequence(),
+                item_id=self.item_id,
+                output_index=self.output_index,
+                content_index=0,
+                delta=delta,
+            )
+        )
+        return events
+
+    def afterwork(self, ctx: Any) -> List[ResponseStreamEvent]:
+        events: List[ResponseStreamEvent] = []
+        if not self.item_id:
+            return events
+
+        full_text = self.text_buffer
+        assert self.item_id is not None and self.output_index is not None
+        events.append(
+            ResponseTextDoneEvent(
+                sequence_number=ctx.next_sequence(),
+                item_id=self.item_id,
+                output_index=self.output_index,
+                content_index=0,
+                text=full_text,
+            )
+        )
+        final_part = ItemContentOutputText(text=full_text, annotations=[], logprobs=[])
+        events.append(
+            ResponseContentPartDoneEvent(
+                sequence_number=ctx.next_sequence(),
+                item_id=self.item_id,
+                output_index=self.output_index,
+                content_index=0,
+                part=final_part,
+            )
+        )
+        completed_item = ResponsesAssistantMessageItemResource(
+            id=self.item_id, status="completed", content=[final_part]
+        )
+        events.append(
+            ResponseOutputItemDoneEvent(
+                sequence_number=ctx.next_sequence(),
+                output_index=self.output_index,
+                item=completed_item,
+            )
+        )
+        ctx._last_completed_text = full_text  # pylint: disable=protected-access
+        # store for final response
+        ctx._completed_output_items.append(
+            {
+                "id": self.item_id,
+                "type": "message",
+                "status": "completed",
+                "content": [
+                    {
+                        "type": "output_text",
+                        "text": full_text,
+                        "annotations": [],
+                        "logprobs": [],
+                    }
+                ],
+                "role": "assistant",
+            }
+        )
+        # reset state
+        self.item_id = None
+        self.output_index = None
+        self.text_buffer = ""
+        self.text_part_started = False
+        return events
+
+
+class _FunctionCallStreamingState(_BaseStreamingState):
+    """State handler for function_call content during streaming."""
+
+    def __init__(self, context: AgentRunContext) -> None:
+        self.context = context
+        self.item_id = None
+        self.output_index = None
+        self.call_id = None
+        self.name = None
+        self.args_buffer = ""
+        self.requires_approval = False
+        self.approval_request_id: str | None = None
+
+    def prework(self, ctx: Any) -> List[ResponseStreamEvent]:
+        events: List[ResponseStreamEvent] = []
+        if self.item_id is not None:
+            return events
+        # initialize function-call item
+        self.item_id = self.context.id_generator.generate_function_call_id()
+        self.output_index = ctx._next_output_index
+        ctx._next_output_index += 1
+
+        self.call_id = self.call_id or str(uuid.uuid4())
+        function_item = FunctionToolCallItemResource(
+            id=self.item_id,
+            status="in_progress",
+            call_id=self.call_id,
+            name=self.name or "",
+            arguments="",
+        )
+        events.append(
+            ResponseOutputItemAddedEvent(
+                sequence_number=ctx.next_sequence(),
+                output_index=self.output_index,
+                item=function_item,
+            )
+        )
+        return events
+
+    def convert_content(self, ctx: Any, content: FunctionCallContent) -> List[ResponseStreamEvent]:
+        events: List[ResponseStreamEvent] = []
+        # record identifiers (once available)
+        self.name = getattr(content, "name", None) or self.name or ""
+        self.call_id = getattr(content, "call_id", None) or self.call_id or str(uuid.uuid4())
+
+        args_delta = content.arguments if isinstance(content.arguments, str) else json.dumps(content.arguments)
+        args_delta = args_delta or ""
+        self.args_buffer += args_delta
+        assert self.item_id is not None and self.output_index is not None
+        for ch in args_delta:
+            events.append(
+                ResponseFunctionCallArgumentsDeltaEvent(
+                    sequence_number=ctx.next_sequence(),
+                    item_id=self.item_id,
+                    output_index=self.output_index,
+                    delta=ch,
+                )
+            )
+
+        # finalize if arguments are detected to be complete
+        is_done = bool(
+            getattr(content, "is_final", False)
+            or getattr(content, "final", False)
+            or getattr(content, "done", False)
+            or getattr(content, "arguments_final", False)
+            or getattr(content, "arguments_done", False)
+            or getattr(content, "finish", False)
+        )
+        if not is_done and self.args_buffer:
+            try:
+                json.loads(self.args_buffer)
+                is_done = True
+            except Exception:  # pylint: disable=broad-exception-caught
+                pass
+
+        if is_done:
+            events.append(
+                ResponseFunctionCallArgumentsDoneEvent(
+                    sequence_number=ctx.next_sequence(),
+                    item_id=self.item_id,
+                    output_index=self.output_index,
+                    arguments=self.args_buffer,
+                )
+            )
+            events.extend(self.afterwork(ctx))
+        return events
+
+    def afterwork(self, ctx: Any) -> List[ResponseStreamEvent]:
+        events: List[ResponseStreamEvent] = []
+        if not self.item_id:
+            return events
+        assert self.call_id is not None
+        done_item = FunctionToolCallItemResource(
+            id=self.item_id,
+            status="completed",
+            call_id=self.call_id,
+            name=self.name or "",
+            arguments=self.args_buffer,
+        )
+        assert self.output_index is not None
+        events.append(
+            ResponseOutputItemDoneEvent(
+                sequence_number=ctx.next_sequence(),
+                output_index=self.output_index,
+                item=done_item,
+            )
+        )
+        # store for final response
+        ctx._completed_output_items.append(
+            {
+                "id": self.item_id,
+                "type": "function_call",
+                "call_id": self.call_id,
+                "name": self.name or "",
+                "arguments": self.args_buffer,
+                "status": "requires_approval" if self.requires_approval else "completed",
+                "requires_approval": self.requires_approval,
+                "approval_request_id": self.approval_request_id,
+            }
+        )
+        # reset
+        self.item_id = None
+        self.output_index = None
+        self.args_buffer = ""
+        self.call_id = None
+        self.name = None
+        self.requires_approval = False
+        self.approval_request_id = None
+        return events
+
+
+class _FunctionCallOutputStreamingState(_BaseStreamingState):
+    """Handles function_call_output items streaming (non-chunked simple output)."""
+
+    def __init__(
+        self,
+        context: AgentRunContext,
+        call_id: Optional[str] = None,
+        output: Optional[list[str]] = None,
+    ) -> None:
+        # Avoid mutable default argument (Ruff B006)
+        self.context = context
+        self.item_id = None
+        self.output_index = None
+        self.call_id = call_id
+        self.output = output if output is not None else []
+
+    def prework(self, ctx: Any) -> List[ResponseStreamEvent]:
+        events: List[ResponseStreamEvent] = []
+        if self.item_id is not None:
+            return events
+        self.item_id = self.context.id_generator.generate_function_output_id()
+        self.output_index = ctx._next_output_index
+        ctx._next_output_index += 1
+
+        self.call_id = self.call_id or str(uuid.uuid4())
+        item = FunctionToolCallOutputItemResource(
+            id=self.item_id,
+            status="in_progress",
+            call_id=self.call_id,
+            output="",
+        )
+        events.append(
+            ResponseOutputItemAddedEvent(
+                sequence_number=ctx.next_sequence(),
+                output_index=self.output_index,
+                item=item,
+            )
+        )
+        return events
+
+    def convert_content(self, ctx: Any, content: Any) -> List[ResponseStreamEvent]:  # no delta events for now
+        events: List[ResponseStreamEvent] = []
+        # treat entire output as final
+        result = []
+        raw = getattr(content, "result", None)
+        if isinstance(raw, str):
+            result = [raw or self.output]
+        elif isinstance(raw, list):
+            for item in raw:
+                result.append(self._coerce_result_text(item))
+        self.output = json.dumps(result) if len(result) > 0 else ""
+
+        events.extend(self.afterwork(ctx))
+        return events
+
+    def _coerce_result_text(self, value: Any) -> str | dict:
+        """
+        Return a string if value is already str or a TextContent-like object; else str(value).
+
+        :param value: The value to coerce.
+        :type value: Any
+
+        :return: The coerced string or dict.
+        :rtype: str | dict
+        """
+        if value is None:
+            return ""
+        if isinstance(value, str):
+            return value
+        # Direct TextContent instance
+        if isinstance(value, TextContent):
+            content_payload = {"type": "text", "text": getattr(value, "text", "")}
+            return content_payload
+
+        return ""
+
+    def afterwork(self, ctx: Any) -> List[ResponseStreamEvent]:
+        events: List[ResponseStreamEvent] = []
+        if not self.item_id:
+            return events
+        # Ensure types conform: call_id must be str (guarantee non-None) and output is a single string
+        str_call_id = self.call_id or ""
+        single_output: str = cast(str, self.output[0]) if self.output else ""
+        done_item = FunctionToolCallOutputItemResource(
+            id=self.item_id,
+            status="completed",
+            call_id=str_call_id,
+            output=single_output,
+        )
+        assert self.output_index is not None
+        events.append(
+            ResponseOutputItemDoneEvent(
+                sequence_number=ctx.next_sequence(),
+                output_index=self.output_index,
+                item=done_item,
+            )
+        )
+        ctx._completed_output_items.append(
+            {
+                "id": self.item_id,
+                "type": "function_call_output",
+                "status": "completed",
+                "call_id": self.call_id,
+                "output": self.output,
+            }
+        )
+        self.item_id = None
+        self.output_index = None
+        return events
+
+
+class AgentFrameworkOutputStreamingConverter:
+    """Streaming converter using content-type-specific state handlers."""
+
+    def __init__(self, context: AgentRunContext) -> None:
+        self._context = context
+        # sequence numbers must start at 0 for first emitted event
+        self._sequence = 0
+        self._response_id = None
+        self._response_created_at = None
+        self._next_output_index = 0
+        self._last_completed_text = ""
+        self._active_state: Optional[_BaseStreamingState] = None
+        self._active_kind = None  # "text" | "function_call" | "error"
+        # accumulate completed output items for final response
+        self._completed_output_items: List[dict] = []
+
+    def _ensure_response_started(self) -> None:
+        if not self._response_id:
+            self._response_id = self._context.response_id
+        if not self._response_created_at:
+            self._response_created_at = int(datetime.datetime.now(datetime.timezone.utc).timestamp())
+
+    def next_sequence(self) -> int:
+        self._sequence += 1
+        return self._sequence
+
+    def _switch_state(self, kind: str) -> List[ResponseStreamEvent]:
+        events: List[ResponseStreamEvent] = []
+        if self._active_state and self._active_kind != kind:
+            events.extend(self._active_state.afterwork(self))
+            self._active_state = None
+            self._active_kind = None
+
+        if self._active_state is None:
+            if kind == "text":
+                self._active_state = _TextContentStreamingState(self._context)
+            elif kind == "function_call":
+                self._active_state = _FunctionCallStreamingState(self._context)
+            elif kind == "function_call_output":
+                self._active_state = _FunctionCallOutputStreamingState(self._context)
+            else:
+                self._active_state = None
+            self._active_kind = kind
+            if self._active_state:
+                events.extend(self._active_state.prework(self))
+        return events
+
+    def transform_output_for_streaming(self, update: AgentRunResponseUpdate) -> List[ResponseStreamEvent]:
+        logger.debug(
+            "Transforming streaming update with %d contents",
+            len(update.contents) if getattr(update, "contents", None) else 0,
+        )
+        self._ensure_response_started()
+        events: List[ResponseStreamEvent] = []
+
+        if getattr(update, "contents", None):
+            for i, content in enumerate(update.contents):
+                logger.debug("Processing content %d: %s", i, type(content))
+                if isinstance(content, TextContent):
+                    events.extend(self._switch_state("text"))
+                    if isinstance(self._active_state, _TextContentStreamingState):
+                        events.extend(self._active_state.convert_content(self, content))
+                elif isinstance(content, FunctionCallContent):
+                    events.extend(self._switch_state("function_call"))
+                    if isinstance(self._active_state, _FunctionCallStreamingState):
+                        events.extend(self._active_state.convert_content(self, content))
+                elif isinstance(content, FunctionResultContent):
+                    events.extend(self._switch_state("function_call_output"))
+                    if isinstance(self._active_state, _FunctionCallOutputStreamingState):
+                        call_id = getattr(content, "call_id", None)
+                        if call_id:
+                            self._active_state.call_id = call_id
+                        events.extend(self._active_state.convert_content(self, content))
+                elif isinstance(content, FunctionApprovalRequestContent):
+                    events.extend(self._switch_state("function_call"))
+                    if isinstance(self._active_state, _FunctionCallStreamingState):
+                        self._active_state.requires_approval = True
+                        self._active_state.approval_request_id = getattr(content, "id", None)
+                        events.extend(self._active_state.convert_content(self, content.function_call))
+                elif isinstance(content, ErrorContent):
+                    # errors are stateless; flush current state and emit error
+                    events.extend(self._switch_state("error"))
+                    events.append(
+                        ResponseErrorEvent(
+                            sequence_number=self.next_sequence(),
+                            code=getattr(content, "error_code", None) or "server_error",
+                            message=getattr(content, "message", None) or "An error occurred",
+                            param="",
+                        )
+                    )
+        return events
+
+    def finalize_last_content(self) -> List[ResponseStreamEvent]:
+        events: List[ResponseStreamEvent] = []
+        if self._active_state:
+            events.extend(self._active_state.afterwork(self))
+            self._active_state = None
+            self._active_kind = None
+        return events
+
+    def build_response(self, status: str) -> OpenAIResponse:
+        self._ensure_response_started()
+        agent_id = AgentIdGenerator.generate(self._context)
+        response_data = {
+            "object": "response",
+            "agent_id": agent_id,
+            "id": self._response_id,
+            "status": status,
+            "created_at": self._response_created_at,
+            "conversation": self._context.get_conversation_object(),
+        }
+        if status == "completed" and self._completed_output_items:
+            response_data["output"] = self._completed_output_items
+        return OpenAIResponse(response_data)
+
+    # High-level helpers to emit lifecycle events for streaming
+    def initial_events(self) -> List[ResponseStreamEvent]:
+        """
+        Emit ResponseCreatedEvent and an initial ResponseInProgressEvent.
+
+        :return: List of initial response stream events.
+        :rtype: List[ResponseStreamEvent]
+        """
+        self._ensure_response_started()
+        events: List[ResponseStreamEvent] = []
+        created_response = self.build_response(status="in_progress")
+        events.append(
+            ResponseCreatedEvent(
+                sequence_number=self.next_sequence(),
+                response=created_response,
+            )
+        )
+        events.append(
+            ResponseInProgressEvent(
+                sequence_number=self.next_sequence(),
+                response=self.build_response(status="in_progress"),
+            )
+        )
+        return events
+
+    def completion_events(self) -> List[ResponseStreamEvent]:
+        """
+        Finalize any active content and emit a single ResponseCompletedEvent.
+
+        :return: List of completion response stream events.
+        :rtype: List[ResponseStreamEvent]
+        """
+        self._ensure_response_started()
+        events: List[ResponseStreamEvent] = []
+        events.extend(self.finalize_last_content())
+        completed_response = self.build_response(status="completed")
+        events.append(
+            ResponseCompletedEvent(
+                sequence_number=self.next_sequence(),
+                response=completed_response,
+            )
+        )
+        return events

azure/ai/agentserver/agentframework/models/agent_id_generator.py

@@ -0,0 +1,44 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+"""Helper utilities for constructing AgentId model instances.
+
+Centralizes logic for safely building a `models.AgentId` from a request agent
+object. We intentionally do not allow overriding the generated model's fixed
+`type` literal ("agent_id"). If the provided object lacks a name, `None` is
+returned so callers can decide how to handle absence.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from azure.ai.agentserver.core import AgentRunContext
+from azure.ai.agentserver.core.models import projects
+
+
+class AgentIdGenerator:
+    @staticmethod
+    def generate(context: AgentRunContext) -> Optional[projects.AgentId]:
+        """
+        Builds an AgentId model from the request agent object in the provided context.
+
+        :param context: The AgentRunContext containing the request.
+        :type context: AgentRunContext
+
+        :return: The constructed AgentId model, or None if the request lacks an agent name.
+        :rtype: Optional[projects.AgentId]
+        """
+        agent = context.request.get("agent")
+        if not agent:
+            return None
+
+        agent_id = projects.AgentId(
+            {
+                "type": agent.type,
+                "name": agent.name,
+                "version": agent.version,
+            }
+        )
+
+        return agent_id

azure/ai/agentserver/agentframework/models/constants.py

@@ -0,0 +1,13 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+class Constants:
+    # streaming configuration
+    # Environment variable name to control idle timeout for streaming updates (seconds)
+    AGENTS_ADAPTER_STREAM_TIMEOUT_S = "AGENTS_ADAPTER_STREAM_TIMEOUT_S"
+    # Default idle timeout (seconds) when env var or request override not provided
+    DEFAULT_STREAM_TIMEOUT_S = 300.0
+
+    # model defaults
+    DEFAULT_TEMPERATURE = 1.0
+    DEFAULT_TOP_P = 1.0

azure_ai_agentserver_agentframework-1.0.0b2.dist-info/METADATA

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: azure-ai-agentserver-agentframework
+Version: 1.0.0b2
+Summary: Agents server adapter for Azure AI
+Author-email: Microsoft Corporation <azpysdkhelp@microsoft.com>
+License-Expression: MIT
+Project-URL: repository, https://github.com/Azure/azure-sdk-for-python
+Keywords: azure,azure sdk
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: azure-ai-agentserver-core
+Requires-Dist: agent-framework-azure-ai==1.0.0b251007
+Requires-Dist: agent-framework-core==1.0.0b251007
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.36.0
+Dynamic: license-file
+
+# Azure AI Agent Server Adapter for Agent-framework Python
+
+
+
+## Getting started
+
+```bash
+pip install azure-ai-agentserver-agentframework
+```
+
+
+## Key concepts
+
+Azure AI Agent Server wraps your Agent-framework agent, and host it on the cloud.
+
+
+## Examples
+
+```python
+# your existing agent
+from my_framework_agent import my_awesome_agent
+
+# agent framework utils
+from azure.ai.agentserver.agentframework import from_agent_framework
+
+if __name__ == "__main__":
+    # with this simple line, your agent will be hosted on http://localhost:8088
+    from_agent_framework(my_awesome_agent).run()
+
+```
+
+## Troubleshooting
+
+First run your agent with azure-ai-agentserver-agentframework locally.
+
+If it works on local but failed on cloud. Check your logs in the application insight connected to your Azure AI Foundry Project.
+
+
+## Next steps
+
+Please visit [Samples](https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/agentserver/azure-ai-agentserver-agentframework/samples) folder. There are several samples for you to build your agent with azure-ai-agentserver
+
+
+## Contributing
+
+This project welcomes contributions and suggestions. Most contributions require
+you to agree to a Contributor License Agreement (CLA) declaring that you have
+the right to, and actually do, grant us the rights to use your contribution.
+For details, visit https://cla.microsoft.com.
+
+When you submit a pull request, a CLA-bot will automatically determine whether
+you need to provide a CLA and decorate the PR appropriately (e.g., label,
+comment). Simply follow the instructions provided by the bot. You will only
+need to do this once across all repos using our CLA.
+
+This project has adopted the
+[Microsoft Open Source Code of Conduct][code_of_conduct]. For more information,
+see the Code of Conduct FAQ or contact opencode@microsoft.com with any
+additional questions or comments.

azure_ai_agentserver_agentframework-1.0.0b2.dist-info/RECORD

@@ -0,0 +1,16 @@
+azure/ai/agentserver/__init__.py,sha256=bpT73UG7mZL_JjEqMwbYx6q69jA8J5Jcoul1LcDokhA,81
+azure/ai/agentserver/agentframework/__init__.py,sha256=nIvOiay25c9ehMWWPWt3d4XyROqbfoxj_inEmoxnbCI,466
+azure/ai/agentserver/agentframework/_version.py,sha256=g637Xd9Uf23mTrNOKxXc_oX7Wi-Zaz6tfo5NYxUwOr0,486
+azure/ai/agentserver/agentframework/agent_framework.py,sha256=6xsuw3yADc3bDIwdo4_GfHSWrydSlJf9Z98AxeslxAU,6858
+azure/ai/agentserver/agentframework/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+azure/ai/agentserver/agentframework/models/__init__.py,sha256=J_Cmr9IKDtiY7KQ4vjOy9-BwZ8AxVwUHKWesdhDCY_U,246
+azure/ai/agentserver/agentframework/models/agent_framework_input_converters.py,sha256=o88ONqSmOaPtJqph4_WWmRswn-hr0kgX0JRo_97O8Og,5368
+azure/ai/agentserver/agentframework/models/agent_framework_output_non_streaming_converter.py,sha256=XvqsFrNMfdCkbNOQhmMIheR_tK01aY05IafzrAzr_Fw,9145
+azure/ai/agentserver/agentframework/models/agent_framework_output_streaming_converter.py,sha256=T7WGfE8-yXdvgQwwsmqA2KaJw3v6pbTUWiUOSrlCZmM,22666
+azure/ai/agentserver/agentframework/models/agent_id_generator.py,sha256=tIT_729F4ykQwblo91Bhv6iILY35_N1P-zUPYfVlt1w,1485
+azure/ai/agentserver/agentframework/models/constants.py,sha256=sEJkC4UMRzpMNXm7TJCFw7GzIAOxuaSBoxKfCoqbSGI,583
+azure_ai_agentserver_agentframework-1.0.0b2.dist-info/licenses/LICENSE,sha256=_VMkgdgo4ToLE8y1mOAjOKNhd0BnWoYu5r3BVBto6T0,1073
+azure_ai_agentserver_agentframework-1.0.0b2.dist-info/METADATA,sha256=G_cHrbiO9wA5BBmQH2_J1u9VwR70NipGwt-RPqEzLNw,2836
+azure_ai_agentserver_agentframework-1.0.0b2.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+azure_ai_agentserver_agentframework-1.0.0b2.dist-info/top_level.txt,sha256=S7DhWV9m80TBzAhOFjxDUiNbKszzoThbnrSz5MpbHSQ,6
+azure_ai_agentserver_agentframework-1.0.0b2.dist-info/RECORD,,

azure_ai_agentserver_agentframework-1.0.0b2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (77.0.3)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

azure_ai_agentserver_agentframework-1.0.0b2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

azure_ai_agentserver_agentframework-1.0.0b2.dist-info/top_level.txt

@@ -0,0 +1 @@
+azure