Fix further getnewthread and deserializethread instances

Author: westey-m

agent-framework/integrations/ag-ui/getting-started.md

@@ -178,7 +178,7 @@ AIAgent agent = chatClient.AsAIAgent(
     name: "agui-client",
     description: "AG-UI Client Agent");
 
-AgentThread thread = agent.GetNewThread();
+AgentThread thread = await agent.GetNewThreadAsync();
 List<ChatMessage> messages =
 [
     new(ChatRole.System, "You are a helpful assistant.")

agent-framework/migration-guide/from-semantic-kernel/index.md

@@ -103,7 +103,7 @@ The agent is responsible for creating the thread.
 
 ```csharp
 // New.
-AgentThread thread = agent.GetNewThread();
+AgentThread thread = await agent.GetNewThreadAsync();
 ```
 
 ## 4. Hosted Agent Thread Cleanup

agent-framework/tutorials/agents/function-tools-approvals.md

@@ -66,7 +66,7 @@ Since you now have a function that requires approval, the agent might respond wi
 You can check the response content for any `FunctionApprovalRequestContent` instances, which indicates that the agent requires user approval for a function.
 
 ```csharp
-AgentThread thread = agent.GetNewThread();
+AgentThread thread = await agent.GetNewThreadAsync();
 AgentResponse response = await agent.RunAsync("What is the weather like in Amsterdam?", thread);
 
 var functionApprovalRequests = response.Messages

agent-framework/tutorials/agents/memory.md

@@ -146,6 +146,8 @@ To use the custom `AIContextProvider`, you need to provide an `AIContextProvider
 
 When creating a `ChatClientAgent` it is possible to provide a `ChatClientAgentOptions` object that allows providing the `AIContextProviderFactory` in addition to all other agent options.
 
+The factory is an async function that receives a context object and a cancellation token.
+
 ```csharp
 using System;
 using Azure.AI.OpenAI;
@@ -161,19 +163,20 @@ ChatClient chatClient = new AzureOpenAIClient(
 AIAgent agent = chatClient.AsAIAgent(new ChatClientAgentOptions()
 {
     ChatOptions = new() { Instructions = "You are a friendly assistant. Always address the user by their name." },
-    AIContextProviderFactory = ctx => new UserInfoMemory(
-        chatClient.AsIChatClient(),
-        ctx.SerializedState,
-        ctx.JsonSerializerOptions)
+    AIContextProviderFactory = (ctx, ct) => new ValueTask<AIContextProvider>(
+        new UserInfoMemory(
+            chatClient.AsIChatClient(),
+            ctx.SerializedState,
+            ctx.JsonSerializerOptions))
 });
 ```
 
-When creating a new thread, the `AIContextProvider` will be created by `GetNewThread`
+When creating a new thread, the `AIContextProvider` will be created by `GetNewThreadAsync`
 and attached to the thread. Once memories are extracted it is therefore possible to access the memory component via the thread's `GetService` method and inspect the memories.
 
 ```csharp
 // Create a new thread for the conversation.
-AgentThread thread = agent.GetNewThread();
+AgentThread thread = await agent.GetNewThreadAsync();
 
 Console.WriteLine(await agent.RunAsync("Hello, what is the square root of 9?", thread));
 Console.WriteLine(await agent.RunAsync("My name is Ruaidhrí", thread));

agent-framework/tutorials/agents/multi-turn-conversation.md

@@ -27,10 +27,10 @@ For prerequisites and creating the agent, see the [Create and run a simple agent
 Agents are stateless and do not maintain any state internally between calls.
 To have a multi-turn conversation with an agent, you need to create an object to hold the conversation state and pass this object to the agent when running it.
 
-To create the conversation state object, call the `GetNewThread` method on the agent instance.
+To create the conversation state object, call the `GetNewThreadAsync` method on the agent instance.
 
 ```csharp
-AgentThread thread = agent.GetNewThread();
+AgentThread thread = await agent.GetNewThreadAsync();
 ```
 
 You can then pass this thread object to the `RunAsync` and `RunStreamingAsync` methods on the agent instance, along with the user input.
@@ -52,8 +52,8 @@ These threads can then be used to maintain separate conversation states for each
 The conversations will be fully independent of each other, since the agent does not maintain any state internally.
 
 ```csharp
-AgentThread thread1 = agent.GetNewThread();
-AgentThread thread2 = agent.GetNewThread();
+AgentThread thread1 = await agent.GetNewThreadAsync();
+AgentThread thread2 = await agent.GetNewThreadAsync();
 Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate.", thread1));
 Console.WriteLine(await agent.RunAsync("Tell me a joke about a robot.", thread2));
 Console.WriteLine(await agent.RunAsync("Now add some emojis to the joke and tell it in the voice of a pirate's parrot.", thread1));

agent-framework/tutorials/agents/persisted-conversation.md

@@ -38,7 +38,7 @@ AIAgent agent = new AzureOpenAIClient(
      .GetChatClient("gpt-4o-mini")
      .AsAIAgent(instructions: "You are a helpful assistant.", name: "Assistant");
 
-AgentThread thread = agent.GetNewThread();
+AgentThread thread = await agent.GetNewThreadAsync();
 ```
 
 Run the agent, passing in the thread, so that the `AgentThread` includes this exchange.
@@ -75,7 +75,7 @@ string loadedJson = await File.ReadAllTextAsync(filePath);
 JsonElement reloaded = JsonSerializer.Deserialize<JsonElement>(loadedJson, JsonSerializerOptions.Web);
 
 // Deserialize the thread into an AgentThread tied to the same agent type
-AgentThread resumedThread = agent.DeserializeThread(reloaded, JsonSerializerOptions.Web);
+AgentThread resumedThread = await agent.DeserializeThreadAsync(reloaded, JsonSerializerOptions.Web);
 ```
 
 Use the resumed thread to continue the conversation.

agent-framework/user-guide/agents/agent-background-responses.md

@@ -66,7 +66,7 @@ AgentRunOptions options = new()
     AllowBackgroundResponses = true
 };
 
-AgentThread thread = agent.GetNewThread();
+AgentThread thread = await agent.GetNewThreadAsync();
 
 // Get initial response - may return with or without a continuation token
 AgentResponse response = await agent.RunAsync("Write a very long novel about otters in space.", thread, options);
@@ -108,7 +108,7 @@ AgentRunOptions options = new()
     AllowBackgroundResponses = true
 };
 
-AgentThread thread = agent.GetNewThread();
+AgentThread thread = await agent.GetNewThreadAsync();
 
 AgentResponseUpdate? latestReceivedUpdate = null;
 

agent-framework/user-guide/agents/agent-rag.md

@@ -21,14 +21,17 @@ The `TextSearchProvider` class is an out-of-the-box implementation of a RAG cont
 
 It can easily be attached to a `ChatClientAgent` using the `AIContextProviderFactory` option to provide RAG capabilities to the agent.
 
+The factory is an async function that receives a context object and a cancellation token.
+
 ```csharp
 // Create the AI agent with the TextSearchProvider as the AI context provider.
 AIAgent agent = azureOpenAIClient
     .GetChatClient(deploymentName)
     .AsAIAgent(new ChatClientAgentOptions
     {
         ChatOptions = new() { Instructions = "You are a helpful support specialist for Contoso Outdoors. Answer questions using the provided context and cite the source document when available." },
-        AIContextProviderFactory = ctx => new TextSearchProvider(SearchAdapter, ctx.SerializedState, ctx.JsonSerializerOptions, textSearchOptions)
+        AIContextProviderFactory = (ctx, ct) => new ValueTask<AIContextProvider>(
+            new TextSearchProvider(SearchAdapter, ctx.SerializedState, ctx.JsonSerializerOptions, textSearchOptions))
     });
 ```
 

agent-framework/user-guide/agents/agent-types/custom-agent.md

@@ -68,10 +68,11 @@ Agents can therefore attach any additional state or behaviors needed to the thre
 Two methods are required to be implemented:
 
 ```csharp
-    public override AgentThread GetNewThread() => new CustomAgentThread();
+    public override Task<AgentThread> GetNewThreadAsync(CancellationToken cancellationToken = default) 
+        => Task.FromResult<AgentThread>(new CustomAgentThread());
 
-    public override AgentThread DeserializeThread(JsonElement serializedThread, JsonSerializerOptions? jsonSerializerOptions = null)
-        => new CustomAgentThread(serializedThread, jsonSerializerOptions);
+    public override Task<AgentThread> DeserializeThreadAsync(JsonElement serializedThread, JsonSerializerOptions? jsonSerializerOptions = null, CancellationToken cancellationToken = default)
+        => Task.FromResult<AgentThread>(new CustomAgentThread(serializedThread, jsonSerializerOptions));
 ```
 
 ### Core agent logic
@@ -110,7 +111,7 @@ If you don't do this, the user won't be able to have a multi-turn conversation w
 ```csharp
     public override async Task<AgentResponse> RunAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
     {
-        thread ??= this.GetNewThread();
+        thread ??= await this.GetNewThreadAsync(cancellationToken);
         List<ChatMessage> responseMessages = CloneAndToUpperCase(messages, this.DisplayName).ToList();
         await NotifyThreadOfNewMessagesAsync(thread, messages.Concat(responseMessages), cancellationToken);
         return new AgentResponse
@@ -123,7 +124,7 @@ If you don't do this, the user won't be able to have a multi-turn conversation w
 
     public override async IAsyncEnumerable<AgentResponseUpdate> RunStreamingAsync(IEnumerable<ChatMessage> messages, AgentThread? thread = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
-        thread ??= this.GetNewThread();
+        thread ??= await this.GetNewThreadAsync(cancellationToken);
         List<ChatMessage> responseMessages = CloneAndToUpperCase(messages, this.DisplayName).ToList();
         await NotifyThreadOfNewMessagesAsync(thread, messages.Concat(responseMessages), cancellationToken);
         foreach (var message in responseMessages)

agent-framework/user-guide/agents/agent-types/durable-agent/features.md

@@ -42,7 +42,7 @@ public static async Task<string> SpamDetectionOrchestration(
 
     // Check if the email is spam
     DurableAIAgent spamDetectionAgent = context.GetAgent("SpamDetectionAgent");
-    AgentThread spamThread = spamDetectionAgent.GetNewThread();
+    AgentThread spamThread = await spamDetectionAgent.GetNewThreadAsync();
 
     AgentResponse<DetectionResult> spamDetectionResponse = await spamDetectionAgent.RunAsync<DetectionResult>(
         message: $"Analyze this email for spam: {email.EmailContent}",
@@ -56,7 +56,7 @@ public static async Task<string> SpamDetectionOrchestration(
 
     // Generate response for legitimate email
     DurableAIAgent emailAssistantAgent = context.GetAgent("EmailAssistantAgent");
-    AgentThread emailThread = emailAssistantAgent.GetNewThread();
+    AgentThread emailThread = await emailAssistantAgent.GetNewThreadAsync();
 
     AgentResponse<EmailResponse> emailAssistantResponse = await emailAssistantAgent.RunAsync<EmailResponse>(
         message: $"Draft a professional response to: {email.EmailContent}",