azure-ai-agentserver-langgraph 1.0.0b2__tar.gz

azure_ai_agentserver_langgraph-1.0.0b2/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Release History
+
+
+## 1.0.0b2 (2025-11-10)
+
+### Bugs Fixed
+
+- Fixed Id generator format.
+
+- Improved stream mode error messsage.
+
+- Updated application insights related configuration environment variables.
+
+
+## 1.0.0b1 (2025-11-07)
+
+### Features Added
+
+First version

azure_ai_agentserver_langgraph-1.0.0b2/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_langgraph-1.0.0b2/MANIFEST.in

@@ -0,0 +1,9 @@
+include *.md
+include LICENSE
+recursive-include tests *.py
+recursive-include samples *.py *.md
+recursive-include doc *.rst *.md
+include azure/__init__.py
+include azure/ai/__init__.py
+include azure/ai/agentserver/__init__.py
+include azure/ai/agentserver/langgraph/py.typed

azure_ai_agentserver_langgraph-1.0.0b2/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: azure-ai-agentserver-langgraph
+Version: 1.0.0b2
+Summary: LangGraph adapter for Azure AI Agent Server
+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: langchain>0.3.5
+Requires-Dist: langchain-openai>0.3.10
+Requires-Dist: langchain-azure-ai[opentelemetry]>=0.1.4
+Requires-Dist: langgraph>0.5.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http
+Dynamic: license-file
+
+# Azure AI Agent Server Adapter for LangGraph Python
+
+
+## Getting started
+
+```bash
+pip install azure-ai-agentserver-langgraph
+```
+
+
+## Key concepts
+
+Azure AI Agent Server wraps your LangGraph agent, and host it on the cloud.
+
+
+## Examples
+
+```python
+# your existing agent
+from my_langgraph_agent import my_awesome_agent
+
+# langgraph utils
+from azure.ai.agentserver.langgraph import from_langgraph
+
+if __name__ == "__main__":
+    # with this simple line, your agent will be hosted on http://localhost:8088
+    from_langgraph(my_awesome_agent).run()
+
+```
+
+**Note**
+If your langgraph agent was not using langgraph's builtin [MessageState](https://langchain-ai.github.io/langgraph/concepts/low_level/?h=messagesstate#messagesstate), you should implement your own `LanggraphStateConverter` and provide to `from_langgraph`.
+
+Reference this [example](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/agentserver/azure-ai-agentserver-langgraph/samples/custom_state/main.py) for more details.
+
+
+## Troubleshooting
+
+First run your agent with azure-ai-agentserver-langgraph 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-langgraph/samples) folder. There are several samples for you to build your agent with azure-ai-agentserver-* packages
+
+
+## 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_langgraph-1.0.0b2/README.md

@@ -0,0 +1,64 @@
+# Azure AI Agent Server Adapter for LangGraph Python
+
+
+## Getting started
+
+```bash
+pip install azure-ai-agentserver-langgraph
+```
+
+
+## Key concepts
+
+Azure AI Agent Server wraps your LangGraph agent, and host it on the cloud.
+
+
+## Examples
+
+```python
+# your existing agent
+from my_langgraph_agent import my_awesome_agent
+
+# langgraph utils
+from azure.ai.agentserver.langgraph import from_langgraph
+
+if __name__ == "__main__":
+    # with this simple line, your agent will be hosted on http://localhost:8088
+    from_langgraph(my_awesome_agent).run()
+
+```
+
+**Note**
+If your langgraph agent was not using langgraph's builtin [MessageState](https://langchain-ai.github.io/langgraph/concepts/low_level/?h=messagesstate#messagesstate), you should implement your own `LanggraphStateConverter` and provide to `from_langgraph`.
+
+Reference this [example](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/agentserver/azure-ai-agentserver-langgraph/samples/custom_state/main.py) for more details.
+
+
+## Troubleshooting
+
+First run your agent with azure-ai-agentserver-langgraph 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-langgraph/samples) folder. There are several samples for you to build your agent with azure-ai-agentserver-* packages
+
+
+## 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_langgraph-1.0.0b2/azure/__init__.py

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

azure_ai_agentserver_langgraph-1.0.0b2/azure/ai/__init__.py

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

azure_ai_agentserver_langgraph-1.0.0b2/azure/ai/agentserver/__init__.py

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

azure_ai_agentserver_langgraph-1.0.0b2/azure/ai/agentserver/langgraph/__init__.py

@@ -0,0 +1,21 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)
+
+from typing import TYPE_CHECKING, Optional
+
+from ._version import VERSION
+
+if TYPE_CHECKING:  # pragma: no cover
+    from . import models
+
+
+def from_langgraph(agent, state_converter: Optional["models.LanggraphStateConverter"] = None):
+    from .langgraph import LangGraphAdapter
+
+    return LangGraphAdapter(agent, state_converter=state_converter)
+
+
+__all__ = ["from_langgraph"]
+__version__ = VERSION

azure_ai_agentserver_langgraph-1.0.0b2/azure/ai/agentserver/langgraph/_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_langgraph-1.0.0b2/azure/ai/agentserver/langgraph/langgraph.py

@@ -0,0 +1,165 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+# pylint: disable=logging-fstring-interpolation,broad-exception-caught
+# mypy: disable-error-code="assignment,arg-type"
+import os
+import re
+from typing import Optional
+
+from langchain_core.runnables import RunnableConfig
+from langgraph.graph.state import CompiledStateGraph
+
+from azure.ai.agentserver.core.constants import Constants
+from azure.ai.agentserver.core.logger import get_logger
+from azure.ai.agentserver.core.server.base import FoundryCBAgent
+from azure.ai.agentserver.core.server.common.agent_run_context import AgentRunContext
+
+from .models import (
+    LanggraphMessageStateConverter,
+    LanggraphStateConverter,
+)
+from .models.utils import is_state_schema_valid
+
+logger = get_logger()
+
+
+class LangGraphAdapter(FoundryCBAgent):
+    """
+    Adapter for LangGraph Agent.
+    """
+
+    def __init__(self, graph: CompiledStateGraph, state_converter: Optional[LanggraphStateConverter] = None):
+        """
+        Initialize the LangGraphAdapter with a CompiledStateGraph.
+
+        :param graph: The LangGraph StateGraph to adapt.
+        :type graph: CompiledStateGraph
+        :param state_converter: custom state converter. Required if graph state is not MessagesState.
+        :type state_converter: Optional[LanggraphStateConverter]
+        """
+        super().__init__()
+        self.graph = graph
+        self.azure_ai_tracer = None
+        if not state_converter:
+            if is_state_schema_valid(self.graph.builder.state_schema):
+                self.state_converter = LanggraphMessageStateConverter()
+            else:
+                raise ValueError("state_converter is required for non-MessagesState graph.")
+        else:
+            self.state_converter = state_converter
+
+    async def agent_run(self, context: AgentRunContext):
+        input_data = self.state_converter.request_to_state(context)
+        logger.debug(f"Converted input data: {input_data}")
+        if not context.stream:
+            response = await self.agent_run_non_stream(input_data, context)
+            return response
+        return self.agent_run_astream(input_data, context)
+
+    def init_tracing_internal(self, exporter_endpoint=None, app_insights_conn_str=None):
+        # set env vars for langsmith
+        os.environ["LANGSMITH_OTEL_ENABLED"] = "true"
+        os.environ["LANGSMITH_TRACING"] = "true"
+        os.environ["LANGSMITH_OTEL_ONLY"] = "true"
+        if app_insights_conn_str:
+            # setup azure ai telemetry callbacks
+            try:
+                from langchain_azure_ai.callbacks.tracers import AzureAIOpenTelemetryTracer
+
+                self.azure_ai_tracer = AzureAIOpenTelemetryTracer(
+                    connection_string=app_insights_conn_str,
+                    enable_content_recording=True,
+                    name=self.get_agent_identifier(),
+                )
+                logger.info("AzureAIOpenTelemetryTracer initialized successfully.")
+            except Exception as e:
+                logger.error(f"Failed to import AzureAIOpenTelemetryTracer, ignore: {e}")
+
+    def setup_otlp_exporter(self, endpoint, provider):
+        endpoint = self.format_otlp_endpoint(endpoint)
+        return super().setup_otlp_exporter(endpoint, provider)
+
+    def get_trace_attributes(self):
+        attrs = super().get_trace_attributes()
+        attrs["service.namespace"] = "azure.ai.agentserver.langgraph"
+        return attrs
+
+    async def agent_run_non_stream(self, input_data: dict, context: AgentRunContext):
+        """
+        Run the agent with non-streaming response.
+
+        :param input_data: The input data to run the agent with.
+        :type input_data: dict
+        :param context: The context for the agent run.
+        :type context: AgentRunContext
+
+        :return: The response of the agent run.
+        :rtype: dict
+        """
+
+        try:
+            config = self.create_runnable_config(context)
+            stream_mode = self.state_converter.get_stream_mode(context)
+            result = await self.graph.ainvoke(input_data, config=config, stream_mode=stream_mode)
+            output = self.state_converter.state_to_response(result, context)
+            return output
+        except Exception as e:
+            logger.error(f"Error during agent run: {e}")
+            raise e
+
+    async def agent_run_astream(self, input_data: dict, context: AgentRunContext):
+        """
+        Run the agent with streaming response.
+
+        :param input_data: The input data to run the agent with.
+        :type input_data: dict
+        :param context: The context for the agent run.
+        :type context: AgentRunContext
+
+        :return: An async generator yielding the response stream events.
+        :rtype: AsyncGenerator[dict]
+        """
+        try:
+            logger.info(f"Starting streaming agent run {context.response_id}")
+            config = self.create_runnable_config(context)
+            stream_mode = self.state_converter.get_stream_mode(context)
+            stream = self.graph.astream(input=input_data, config=config, stream_mode=stream_mode)
+            async for result in self.state_converter.state_to_response_stream(stream, context):
+                yield result
+        except Exception as e:
+            logger.error(f"Error during streaming agent run: {e}")
+            raise e
+
+    def create_runnable_config(self, context: AgentRunContext) -> RunnableConfig:
+        """
+        Create a RunnableConfig from the converted request data.
+
+        :param context: The context for the agent run.
+        :type context: AgentRunContext
+
+        :return: The RunnableConfig for the agent run.
+        :rtype: RunnableConfig
+        """
+        config = RunnableConfig(
+            configurable={
+                "thread_id": context.conversation_id,
+            },
+            callbacks=[self.azure_ai_tracer] if self.azure_ai_tracer else None,
+        )
+        return config
+
+    def format_otlp_endpoint(self, endpoint: str) -> str:
+        m = re.match(r"^(https?://[^/]+)", endpoint)
+        if m:
+            return f"{m.group(1)}/v1/traces"
+        return endpoint
+
+    def get_agent_identifier(self) -> str:
+        agent_name = os.getenv(Constants.AGENT_NAME)
+        if agent_name:
+            return agent_name
+        agent_id = os.getenv(Constants.AGENT_ID)
+        if agent_id:
+            return agent_id
+        return "HostedAgent-LangGraph"

azure_ai_agentserver_langgraph-1.0.0b2/azure/ai/agentserver/langgraph/models/__init__.py

@@ -0,0 +1,15 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+from .langgraph_request_converter import LangGraphRequestConverter
+from .langgraph_response_converter import LangGraphResponseConverter
+from .langgraph_state_converter import LanggraphMessageStateConverter, LanggraphStateConverter
+from .langgraph_stream_response_converter import LangGraphStreamResponseConverter
+
+__all__ = [
+    "LangGraphRequestConverter",
+    "LangGraphResponseConverter",
+    "LangGraphStreamResponseConverter",
+    "LanggraphStateConverter",
+    "LanggraphMessageStateConverter",
+]

azure_ai_agentserver_langgraph-1.0.0b2/azure/ai/agentserver/langgraph/models/langgraph_request_converter.py

@@ -0,0 +1,155 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+# pylint: disable=logging-fstring-interpolation
+# mypy: ignore-errors
+import json
+from typing import Dict, List
+
+from langchain_core.messages import (
+    AIMessage,
+    AnyMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+from langchain_core.messages.tool import ToolCall
+
+from azure.ai.agentserver.core.logger import get_logger
+from azure.ai.agentserver.core.models import CreateResponse, openai as openai_models, projects as project_models
+
+logger = get_logger()
+
+role_mapping = {
+    project_models.ResponsesMessageRole.USER: HumanMessage,
+    project_models.ResponsesMessageRole.SYSTEM: SystemMessage,
+    project_models.ResponsesMessageRole.ASSISTANT: AIMessage,
+}
+
+item_content_type_mapping = {
+    project_models.ItemContentType.INPUT_TEXT: "text",
+    project_models.ItemContentType.INPUT_AUDIO: "audio",
+    project_models.ItemContentType.INPUT_IMAGE: "image",
+    project_models.ItemContentType.INPUT_FILE: "file",
+    project_models.ItemContentType.OUTPUT_TEXT: "text",
+    project_models.ItemContentType.OUTPUT_AUDIO: "audio",
+    # project_models.ItemContentType.REFUSAL: "refusal",
+}
+
+
+class LangGraphRequestConverter:
+    def __init__(self, data: CreateResponse):
+        self.data: CreateResponse = data
+
+    def convert(self) -> dict:
+        # Convert the CreateRunRequest input to a format suitable for LangGraph
+        langgraph_input = {"messages": []}
+
+        instructions = self.data.get("instructions")
+        if instructions and isinstance(instructions, str):
+            langgraph_input["messages"].append(SystemMessage(content=instructions))
+
+        input = self.data.get("input")
+        if isinstance(input, str):
+            langgraph_input["messages"].append(HumanMessage(content=input))
+        elif isinstance(input, List):
+            for inner in input:
+                message = self.convert_input(inner)
+                langgraph_input["messages"].append(message)
+        else:
+            raise ValueError(f"Unsupported input type: {type(input)}, {input}")
+        return langgraph_input
+
+    def convert_input(self, item: openai_models.ResponseInputItemParam) -> AnyMessage:
+        """
+        Convert ResponseInputItemParam to a LangGraph message
+
+        :param item: The ResponseInputItemParam to convert from request.
+        :type item: openai_models.ResponseInputItemParam
+
+        :return: The converted LangGraph message.
+        :rtype: AnyMessage
+        """
+        item_type = item.get("type", project_models.ItemType.MESSAGE)
+        if item_type == project_models.ItemType.MESSAGE:
+            # this is a message
+            return self.convert_message(item)
+        if item_type == project_models.ItemType.FUNCTION_CALL:
+            return self.convert_function_call(item)
+        if item_type == project_models.ItemType.FUNCTION_CALL_OUTPUT:
+            return self.convert_function_call_output(item)
+        raise ValueError(f"Unsupported OpenAIItemParam type: {item_type}, {item}")
+
+    def convert_message(self, message: dict) -> AnyMessage:
+        """
+        Convert a message dict to a LangGraph message
+
+        :param message: The message dict to convert.
+        :type message: dict
+
+        :return: The converted LangGraph message.
+        :rtype: AnyMessage
+        """
+        content = message.get("content")
+        role = message.get("role", project_models.ResponsesMessageRole.USER)
+        if not content:
+            raise ValueError(f"Message missing content: {message}")
+        if isinstance(content, str):
+            return role_mapping[role](content=content)
+        if isinstance(content, list):
+            return role_mapping[role](content=self.convert_OpenAIItemContentList(content))
+        raise ValueError(f"Unsupported ResponseMessagesItemParam content type: {type(content)}, {content}")
+
+    def convert_function_call(self, item: dict) -> AnyMessage:
+        try:
+            item = openai_models.ResponseFunctionToolCallParam(**item)
+            argument = item.get("arguments", None)
+            args = json.loads(argument) if argument else {}
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON in function call arguments: {item}") from e
+        except Exception as e:
+            raise ValueError(f"Invalid function call item: {item}") from e
+        return AIMessage(tool_calls=[ToolCall(id=item.get("call_id"), name=item.get("name"), args=args)], content="")
+
+    def convert_function_call_output(self, item: dict) -> ToolMessage:
+        try:
+            item = openai_models.response_input_item_param.FunctionCallOutput(**item)  # pylint: disable=no-member
+        except Exception as e:
+            raise ValueError(f"Invalid function call output item: {item}") from e
+
+        output = item.get("output", None)
+        if isinstance(output, str):
+            return ToolMessage(content=output, tool_call_id=item.get("call_id"))
+        if isinstance(output, list):
+            return ToolMessage(content=self.convert_OpenAIItemContentList(output), tool_call_id=item.get("call_id"))
+        raise ValueError(f"Unsupported function call output type: {type(output)}, {output}")
+
+    def convert_OpenAIItemContentList(self, content: List[Dict]) -> List[Dict]:
+        """
+        Convert ItemContent to a list format
+
+        :param content: The list of ItemContent to convert.
+        :type content: List[Dict]
+
+        :return: The converted list of ItemContent.
+        :rtype: List[Dict]
+        """
+        result = []
+        for item in content:
+            result.append(self.convert_OpenAIItemContent(item))
+        return result
+
+    def convert_OpenAIItemContent(self, content: Dict) -> Dict:
+        """
+        Convert ItemContent to a dict format
+
+        :param content: The ItemContent to convert.
+        :type content: Dict
+
+        :return: The converted ItemContent.
+        :rtype: Dict
+        """
+        res = content.copy()
+        content_type = content.get("type")
+        res["type"] = item_content_type_mapping.get(content_type, content_type)
+        return res