fix: Upgrade azure-ai-projects and agent-framework

infra/vscode_web/codeSample.py

@@ -1,25 +1,32 @@
 from azure.ai.projects import AIProjectClient
 from azure.identity import DefaultAzureCredential
+from azure.ai.agents.models import ListSortOrder
 
 project_client = AIProjectClient.from_connection_string(
     credential=DefaultAzureCredential(),
     conn_str="<%= connectionString %>")
 
 agent = project_client.agents.get_agent("<%= agentId %>")
 
-thread = project_client.agents.create_thread()
+thread = project_client.agents.threads.create()
 print(f"Created thread, ID: {thread.id}")
 
-message = project_client.agents.create_message(
+message = project_client.agents.messages.create(
     thread_id=thread.id,
     role="user",
     content="<%= userMessage %>"
 )
 
-run = project_client.agents.create_and_process_run(
+run = project_client.agents.runs.create_and_process(
     thread_id=thread.id,
     agent_id=agent.id)
-messages = project_client.agents.list_messages(thread_id=thread.id)
 
-for text_message in messages.text_messages:
-    print(text_message.as_dict())
+if run.status == "failed":
+    print(f"Run failed: {run.last_error}")
+else:
+    messages = project_client.agents.messages.list(
+        thread_id=thread.id, order=ListSortOrder.ASCENDING)
+
+    for message in messages:
+        if message.text_messages:
+            print(f"{message.role}: {message.text_messages[-1].text.value}")

infra/vscode_web/requirements.txt

@@ -1,3 +1,3 @@
-azure-ai-projects==1.0.0b12
+azure-ai-projects==2.1.0
 azure-identity==1.20.0
 ansible-core~=2.17.0

src/ContentProcessor/pyproject.toml

@@ -5,7 +5,7 @@ description = "Content Process Gold Standard Solution Accelerator - Content Proc
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
-    "agent-framework==1.0.0b260127",
+    "agent-framework==1.1.1",
     "azure-ai-inference==1.0.0b9",
     "azure-appconfiguration==1.8.0",
     "azure-identity==1.26.0b1",

src/ContentProcessor/src/libs/agent_framework/agent_builder.py

@@ -12,13 +12,14 @@
 from typing import Any, Literal
 
 from agent_framework import (
-    ChatAgent,
-    ChatClientProtocol,
-    ChatMessageStoreProtocol,
+    Agent,
+    AgentMiddleware,
+    ChatMiddleware,
+    ChatOptions,
     ContextProvider,
-    Middleware,
+    HistoryProvider,
+    SupportsChatGetResponse,
     ToolMode,
-    ToolProtocol,
 )
 from pydantic import BaseModel
 
@@ -64,7 +65,7 @@ class AgentBuilder:
             )
     """
 
-    def __init__(self, chat_client: ChatClientProtocol):
+    def __init__(self, chat_client: SupportsChatGetResponse):
         """Initialize the builder with a chat client.
 
         Args:
@@ -75,12 +76,15 @@ def __init__(self, chat_client: ChatClientProtocol):
         self._id: str | None = None
         self._name: str | None = None
         self._description: str | None = None
-        self._chat_message_store_factory: (
-            Callable[[], ChatMessageStoreProtocol] | None
-        ) = None
+        self._chat_message_store_factory: Callable[[], HistoryProvider] | None = None
         self._conversation_id: str | None = None
         self._context_providers: ContextProvider | list[ContextProvider] | None = None
-        self._middleware: Middleware | list[Middleware] | None = None
+        self._middleware: (
+            AgentMiddleware
+            | ChatMiddleware
+            | list[AgentMiddleware | ChatMiddleware]
+            | None
+        ) = None
         self._frequency_penalty: float | None = None
         self._logit_bias: dict[str | int, float] | None = None
         self._max_tokens: int | None = None
@@ -96,10 +100,10 @@ def __init__(self, chat_client: ChatClientProtocol):
             ToolMode | Literal["auto", "required", "none"] | dict[str, Any] | None
         ) = "auto"
         self._tools: (
-            ToolProtocol
+            Any
             | Callable[..., Any]
             | MutableMapping[str, Any]
-            | Sequence[ToolProtocol | Callable[..., Any] | MutableMapping[str, Any]]
+            | Sequence[Any | Callable[..., Any] | MutableMapping[str, Any]]
             | None
         ) = None
         self._top_p: float | None = None
@@ -181,10 +185,10 @@ def with_max_tokens(self, max_tokens: int) -> "AgentBuilder":
 
     def with_tools(
         self,
-        tools: ToolProtocol
+        tools: Any
         | Callable[..., Any]
         | MutableMapping[str, Any]
-        | Sequence[ToolProtocol | Callable[..., Any] | MutableMapping[str, Any]],
+        | Sequence[Any | Callable[..., Any] | MutableMapping[str, Any]],
     ) -> "AgentBuilder":
         """Set the tools available to the agent.
 
@@ -213,7 +217,10 @@ def with_tool_choice(
         return self
 
     def with_middleware(
-        self, middleware: Middleware | list[Middleware]
+        self,
+        middleware: AgentMiddleware
+        | ChatMiddleware
+        | list[AgentMiddleware | ChatMiddleware],
     ) -> "AgentBuilder":
         """Set middleware for request/response processing.
 
@@ -385,7 +392,7 @@ def with_store(self, store: bool) -> "AgentBuilder":
         return self
 
     def with_message_store_factory(
-        self, factory: Callable[[], ChatMessageStoreProtocol]
+        self, factory: Callable[[], HistoryProvider]
     ) -> "AgentBuilder":
         """Set the message store factory.
 
@@ -422,7 +429,7 @@ def with_kwargs(self, **kwargs: Any) -> "AgentBuilder":
         self._kwargs.update(kwargs)
         return self
 
-    def build(self) -> ChatAgent:
+    def build(self) -> Agent:
         """Build and return the configured ChatAgent.
 
         Returns:
@@ -442,32 +449,52 @@ def build(self) -> ChatAgent:
                 async with agent:
                     response = await agent.run("Hello!")
         """
-        return ChatAgent(
-            chat_client=self._chat_client,
+        options: dict[str, Any] = {}
+        if self._frequency_penalty is not None:
+            options["frequency_penalty"] = self._frequency_penalty
+        if self._logit_bias is not None:
+            options["logit_bias"] = self._logit_bias
+        if self._max_tokens is not None:
+            options["max_tokens"] = self._max_tokens
+        if self._metadata is not None:
+            options["metadata"] = self._metadata
+        if self._model_id is not None:
+            options["model"] = self._model_id
+        if self._presence_penalty is not None:
+            options["presence_penalty"] = self._presence_penalty
+        if self._response_format is not None:
+            options["response_format"] = self._response_format
+        if self._seed is not None:
+            options["seed"] = self._seed
+        if self._stop is not None:
+            options["stop"] = self._stop
+        if self._store is not None:
+            options["store"] = self._store
+        if self._temperature is not None:
+            options["temperature"] = self._temperature
+        if self._tool_choice is not None:
+            options["tool_choice"] = self._tool_choice
+        if self._top_p is not None:
+            options["top_p"] = self._top_p
+        if self._user is not None:
+            options["user"] = self._user
+        if self._conversation_id is not None:
+            options["conversation_id"] = self._conversation_id
+        if self._additional_chat_options:
+            options.update(self._additional_chat_options)
+
+        default_options: ChatOptions | None = ChatOptions(**options) if options else None
+
+        return Agent(
+            client=self._chat_client,
             instructions=self._instructions,
             id=self._id,
             name=self._name,
             description=self._description,
-            chat_message_store_factory=self._chat_message_store_factory,
-            conversation_id=self._conversation_id,
+            tools=self._tools,
+            default_options=default_options,
             context_providers=self._context_providers,
             middleware=self._middleware,
-            frequency_penalty=self._frequency_penalty,
-            logit_bias=self._logit_bias,
-            max_tokens=self._max_tokens,
-            metadata=self._metadata,
-            model_id=self._model_id,
-            presence_penalty=self._presence_penalty,
-            response_format=self._response_format,
-            seed=self._seed,
-            stop=self._stop,
-            store=self._store,
-            temperature=self._temperature,
-            tool_choice=self._tool_choice,
-            tools=self._tools,
-            top_p=self._top_p,
-            user=self._user,
-            additional_chat_options=self._additional_chat_options,
             **self._kwargs,
         )
 
@@ -477,11 +504,12 @@ def create_agent_by_agentinfo(
         agent_info: AgentInfo,
         *,
         id: str | None = None,
-        chat_message_store_factory: Callable[[], ChatMessageStoreProtocol]
-        | None = None,
+        chat_message_store_factory: Callable[[], HistoryProvider] | None = None,
         conversation_id: str | None = None,
         context_providers: ContextProvider | list[ContextProvider] | None = None,
-        middleware: Middleware | list[Middleware] | None = None,
+        middleware: (
+            AgentMiddleware | ChatMiddleware | list[AgentMiddleware | ChatMiddleware] | None
+        ) = None,
         frequency_penalty: float | None = None,
         logit_bias: dict[str | int, float] | None = None,
         max_tokens: int | None = None,
@@ -497,16 +525,16 @@ def create_agent_by_agentinfo(
         | Literal["auto", "required", "none"]
         | dict[str, Any]
         | None = "auto",
-        tools: ToolProtocol
+        tools: Any
         | Callable[..., Any]
         | MutableMapping[str, Any]
-        | Sequence[ToolProtocol | Callable[..., Any] | MutableMapping[str, Any]]
+        | Sequence[Any | Callable[..., Any] | MutableMapping[str, Any]]
         | None = None,
         top_p: float | None = None,
         user: str | None = None,
         additional_chat_options: dict[str, Any] | None = None,
         **kwargs: Any,
-    ) -> ChatAgent:
+    ) -> Agent:
         """Create an agent using AgentInfo configuration with full parameter support.
 
         This method creates a chat client from the service configuration and then
@@ -608,17 +636,18 @@ def create_agent_by_agentinfo(
 
     @staticmethod
     def create_agent(
-        chat_client: ChatClientProtocol,
+        chat_client: SupportsChatGetResponse,
         instructions: str | None = None,
         *,
         id: str | None = None,
         name: str | None = None,
         description: str | None = None,
-        chat_message_store_factory: Callable[[], ChatMessageStoreProtocol]
-        | None = None,
+        chat_message_store_factory: Callable[[], HistoryProvider] | None = None,
         conversation_id: str | None = None,
         context_providers: ContextProvider | list[ContextProvider] | None = None,
-        middleware: Middleware | list[Middleware] | None = None,
+        middleware: (
+            AgentMiddleware | ChatMiddleware | list[AgentMiddleware | ChatMiddleware] | None
+        ) = None,
         frequency_penalty: float | None = None,
         logit_bias: dict[str | int, float] | None = None,
         max_tokens: int | None = None,
@@ -634,16 +663,16 @@ def create_agent(
         | Literal["auto", "required", "none"]
         | dict[str, Any]
         | None = "auto",
-        tools: ToolProtocol
+        tools: Any
         | Callable[..., Any]
         | MutableMapping[str, Any]
-        | Sequence[ToolProtocol | Callable[..., Any] | MutableMapping[str, Any]]
+        | Sequence[Any | Callable[..., Any] | MutableMapping[str, Any]]
         | None = None,
         top_p: float | None = None,
         user: str | None = None,
         additional_chat_options: dict[str, Any] | None = None,
         **kwargs: Any,
-    ) -> ChatAgent:
+    ) -> Agent:
         """Create a Chat Client Agent.
 
         Factory method that creates a ChatAgent instance with the specified configuration.
@@ -745,7 +774,7 @@ def create_agent(
                     temperature=0.7,
                     max_tokens=500,
                     additional_chat_options={
-                        "reasoning": {"effort": "high", "summary": "concise"}
+                        "reasoning_effort": "high"
                     },  # OpenAI-specific reasoning options
                 )
 
@@ -758,31 +787,51 @@ def create_agent(
             ``async with`` to ensure proper initialization and cleanup via the ChatAgent's
             async context manager protocol.
         """
-        return ChatAgent(
-            chat_client=chat_client,
+        options: dict[str, Any] = {}
+        if frequency_penalty is not None:
+            options["frequency_penalty"] = frequency_penalty
+        if logit_bias is not None:
+            options["logit_bias"] = logit_bias
+        if max_tokens is not None:
+            options["max_tokens"] = max_tokens
+        if metadata is not None:
+            options["metadata"] = metadata
+        if model_id is not None:
+            options["model"] = model_id
+        if presence_penalty is not None:
+            options["presence_penalty"] = presence_penalty
+        if response_format is not None:
+            options["response_format"] = response_format
+        if seed is not None:
+            options["seed"] = seed
+        if stop is not None:
+            options["stop"] = stop
+        if store is not None:
+            options["store"] = store
+        if temperature is not None:
+            options["temperature"] = temperature
+        if tool_choice is not None:
+            options["tool_choice"] = tool_choice
+        if top_p is not None:
+            options["top_p"] = top_p
+        if user is not None:
+            options["user"] = user
+        if conversation_id is not None:
+            options["conversation_id"] = conversation_id
+        if additional_chat_options:
+            options.update(additional_chat_options)
+
+        default_options: ChatOptions | None = ChatOptions(**options) if options else None
+
+        return Agent(
+            client=chat_client,
             instructions=instructions,
             id=id,
             name=name,
             description=description,
-            chat_message_store_factory=chat_message_store_factory,
-            conversation_id=conversation_id,
+            tools=tools,
+            default_options=default_options,
             context_providers=context_providers,
             middleware=middleware,
-            frequency_penalty=frequency_penalty,
-            logit_bias=logit_bias,
-            max_tokens=max_tokens,
-            metadata=metadata,
-            model_id=model_id,
-            presence_penalty=presence_penalty,
-            response_format=response_format,
-            seed=seed,
-            stop=stop,
-            store=store,
-            temperature=temperature,
-            tool_choice=tool_choice,
-            tools=tools,
-            top_p=top_p,
-            user=user,
-            additional_chat_options=additional_chat_options,
             **kwargs,
         )