consolidating code

Author: aahill

articles/ai-foundry/agents/how-to/tools/function-calling.md

@@ -54,17 +54,12 @@ def fetch_weather(location: str) -> str:
 user_functions = {fetch_weather}
 ```
 
-## Create a client and agent
-
-<!--
-In the sample below we create a client and define a `toolset` which will be used to process the functions defined in `user_functions`.
-
-`toolset`: When using the toolset parameter, you provide not only the function definitions and descriptions but also their implementations. The SDK will execute these functions within `create_and_run_process` or streaming. These functions will be invoked based on their definitions.
--->
+## Example agent code
 
 > [!NOTE]
 > You can find a streaming example on [GitHub](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/ai/azure-ai-agents/samples/agents_streaming/sample_agents_stream_eventhandler_with_functions.py).
 
+Use the following code sample to create an agent and call the function.
 
 ```python
 import os, time
@@ -74,7 +69,7 @@ from azure.ai.agents.models import FunctionTool
 
 # Retrieve the project endpoint from environment variables
 project_endpoint = os.environ["PROJECT_ENDPOINT"]
-
+model_name = os.environ["MODEL_DEPLOYMENT_NAME"]
 # Initialize the AIProjectClient
 project_client = AIProjectClient(
     endpoint=project_endpoint,
@@ -87,15 +82,13 @@ functions = FunctionTool(functions=user_functions)
 with project_client:
     # Create an agent with custom functions
     agent = project_client.agents.create_agent(
-        model=os.environ["MODEL_DEPLOYMENT_NAME"],
+        model=model_name,
         name="my-agent",
         instructions="You are a helpful agent",
         tools=functions.definitions,
     )
     print(f"Created agent, ID: {agent.id}")
-```
-## Create a thread
-```python
+
 # Create a thread for communication
 thread = project_client.agents.threads.create()
 print(f"Created thread, ID: {thread.id}")
@@ -107,9 +100,7 @@ message = project_client.agents.messages.create(
     content="Hello, send an email with the datetime and weather information in New York?",
 )
 print(f"Created message, ID: {message['id']}")
-```
-## Create a run and check the output
-```python
+
 # Create and process a run for the agent to handle the message
 run = project_client.agents.runs.create(thread_id=thread.id, agent_id=agent.id)
 print(f"Created run, ID: {run.id}")
@@ -123,7 +114,7 @@ while run.status in ["queued", "in_progress", "requires_action"]:
         tool_calls = run.required_action.submit_tool_outputs.tool_calls
         tool_outputs = []
         for tool_call in tool_calls:
-            if tool_call.name == "fetch_weather":
+            if tool_call.function.name == "fetch_weather":
                 output = fetch_weather("New York")
                 tool_outputs.append({"tool_call_id": tool_call.id, "output": output})
         project_client.agents.runs.submit_tool_outputs(thread_id=thread.id, run_id=run.id, tool_outputs=tool_outputs)
@@ -147,9 +138,7 @@ print("Deleted agent")
 > [!NOTE]
 > You can find a streaming example on [GitHub](https://github.com/Azure/azure-sdk-for-net/blob/main/sdk/ai/Azure.AI.Agents.Persistent/samples/Sample8_PersistentAgents_FunctionsWithStreaming.md).
 
-## Configure client and define functions
-
-First, set up the configuration using `appsettings.json` and create a `PersistentAgentsClient`. 
+## Configure the client and define functions
 
 ```csharp
 using Azure;
@@ -158,7 +147,8 @@ using Azure.Identity;
 using Microsoft.Extensions.Configuration;
 using System.Text.Json;
 
-// Load configuration from appsettings.json file
+//First, set up the configuration using `appsettings.json`, load it, and create a `PersistentAgentsClient`. 
+
 IConfigurationRoot configuration = new ConfigurationBuilder()
     .SetBasePath(AppContext.BaseDirectory)
     .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
@@ -169,13 +159,10 @@ var projectEndpoint = configuration["ProjectEndpoint"];
 var modelDeploymentName = configuration["ModelDeploymentName"];
 // Initialize the client to interact with the Azure AI Agents Persistent Client using default credentials
 PersistentAgentsClient client = new(projectEndpoint, new DefaultAzureCredential());
-```
 
-## Define functions
-Define the local C# functions that your agent can call, along with their `FunctionToolDefinition` to describe their purpose and parameters to the agent.
+//Define the local C# functions that your agent can call, 
+//along with their `FunctionToolDefinition` to describe their purpose and parameters to the agent.
 
-```csharp
-// Function to get the user's favorite city (hardcoded for example)
 string GetUserFavoriteCity() => "Seattle, WA";
 // Definition for the GetUserFavoriteCity function, describing its purpose to the agent
 FunctionToolDefinition getUserFavoriteCityTool = new("getUserFavoriteCity", "Gets the user's favorite city.");
@@ -240,14 +227,14 @@ FunctionToolDefinition getCurrentWeatherAtLocationTool = new(
             Required = new[] { "location" },
         },
         new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }));
-```
 
-## Implement function execution logic
+//Implement function execution logic
 
-Create a helper function, `GetResolvedToolOutput`, to process `RequiredToolCall` objects from the agent. This function will invoke the appropriate C# local function and return its output to the agent.
+/*
+Create a helper function, `GetResolvedToolOutput`, to process `RequiredToolCall` objects from the agent. 
+This function will invoke the appropriate C# local function and return its output to the agent.
+*/
 
-```csharp
-// Helper function to execute the correct local C# function based on the tool call request from the agent
 ToolOutput GetResolvedToolOutput(RequiredToolCall toolCall)
 {
     // Check if the required call is a function call
@@ -285,13 +272,15 @@ ToolOutput GetResolvedToolOutput(RequiredToolCall toolCall)
     // Return null if the tool call type isn't handled
     return null;
 }
-```
 
-## Create agent and conversation thread
+//Create agent and conversation thread
 
-Now, create the `PersistentAgent`, providing the model deployment name, a descriptive name, instructions for its behavior, and the list of `FunctionToolDefinitions` it can use. Then, create a `PersistentAgentThread` and add an initial user message to start the conversation.
+/*
+Create the `PersistentAgent`, providing the model deployment name, a descriptive name, 
+instructions for its behavior, and the list of `FunctionToolDefinitions` it can use. 
+Then, create a `PersistentAgentThread` and add an initial user message to start the conversation.
+*/
 
-```csharp
 // Create the agent instance
 PersistentAgent agent = client.Administration.CreateAgent(
     model: modelDeploymentName, 
@@ -309,14 +298,17 @@ client.Messages.CreateMessage(
     thread.Id,
     MessageRole.User,
     "What's the weather like in my favorite city?");
-```
 
-## Process run and handle function calls
+//Process run and handle function calls
 
-Create a `ThreadRun` for the agent on the thread. Poll for the run's completion status. If the run status is `RequiresAction`, it means the agent needs to call one of your local functions. Use the `GetResolvedToolOutput` helper to get the function's result and submit it back to the run.
+/*
+Create a `ThreadRun` for the agent on the thread. Poll for the run's completion status. 
+If the run status is `RequiresAction`, it means the agent needs to call one of your local functions. 
+Use the `GetResolvedToolOutput` helper to get the function's result and submit it back to the run.
+
+Start a run for the agent to process the messages in the thread
+*/
 
-```csharp
-// Start a run for the agent to process the messages in the thread
 ThreadRun run = client.Runs.CreateRun(thread.Id, agent.Id);
 
 // Loop to check the run status and handle required actions
@@ -340,20 +332,21 @@ do
             toolOutputs.Add(GetResolvedToolOutput(toolCall));
         }
         // Submit the collected tool outputs back to the run
-        run = client.Runs.SubmitToolOutputsToRun(run, toolOutputs);
+        run = client.Runs.SubmitToolOutputsToRun(run, toolOutputs, null);
     }
 }
 // Continue looping while the run is in progress or requires action
 while (run.Status == RunStatus.Queued
     || run.Status == RunStatus.InProgress
     || run.Status == RunStatus.RequiresAction);
-```
 
-## Retrieve and display results
+// Retrieve and display results
 
-After the run completes, retrieve all messages from the thread to see the full conversation, including the agent's final response.
+/*
+After the run completes, retrieve all messages from the thread to see the full conversation, 
+including the agent's final response.
+*/
 
-```csharp
 // Retrieve all messages from the completed thread, oldest first
 Pageable<PersistentThreadMessage> messages = client.Messages.GetMessages(
     threadId: thread.Id,
@@ -378,28 +371,39 @@ foreach (PersistentThreadMessage threadMessage in messages)
         }
     }
 }
-```
 
-## Clean up resources
+// Clean up resources
 
+/*
 Finally, clean up the created resources by deleting the thread and the agent.
+*/
 
-```csharp
 // Delete the conversation thread
 client.Threads.DeleteThread(threadId: thread.Id);
 // Delete the agent definition
 client.Administration.DeleteAgent(agentId: agent.Id);
-```
 
 ::: zone-end
 
 ::: zone pivot="javascript"
 
-## Define a function for your agent to call
-
-Start by defining a function for your agent to call. When you create a function for an agent to call, you describe its structure of it with any required parameters in a docstring. 
+## Example code
 
 ```javascript
+
+// Define a function for your agent to call
+
+/*
+Start by defining a function for your agent to call. When you create a function for an agent to call, 
+you describe its structure of it with any required parameters in a docstring. 
+*/
+
+const { AgentsClient, ToolUtility, isOutputOfType } = require("@azure/ai-agents");
+const { delay } = require("@azure/core-util");
+const { DefaultAzureCredential } = require("@azure/identity");
+
+require("dotenv/config");
+
 class FunctionToolExecutor {
     functionTools;
 
@@ -488,17 +492,8 @@ class FunctionToolExecutor {
       });
     }
   }
-```
-
-## Create a client and agent
 
-
-```javascript
-const { AgentsClient, ToolUtility, isOutputOfType } = require("@azure/ai-agents");
-const { delay } = require("@azure/core-util");
-const { DefaultAzureCredential } = require("@azure/identity");
-
-require("dotenv/config");
+// Create a client and agent
 
 const projectEndpoint = process.env["PROJECT_ENDPOINT"];
 
@@ -512,12 +507,8 @@ const functionToolExecutor = new FunctionToolExecutor();
     tools: functionTools,
   });
   console.log(`Created agent, agent ID: ${agent.id}`);
-```
-
-## Create a thread
 
-```javascript
-// Create thread
+// Create a thread
 const thread = await client.threads.create();
 console.log(`Created Thread, thread ID:  ${thread.id}`);
 
@@ -528,12 +519,9 @@ const message = await client.messages.create(
   "What's the weather like in my favorite city?",
 );
 console.log(`Created message, message ID ${message.id}`);
-```
 
-## Create a run and check the output
+// Create a run and check the output
 
-```javascript
-// Create run
 let run = await client.runs.create(thread.id, agent.id);
 console.log(`Created Run, Run ID:  ${run.id}`);
 
@@ -579,7 +567,7 @@ for await (const threadMessage of messages) {
     }
   });
 }
-// Delete agent
+// Delete agent - comment this out if you want to keep your agent
 await client.deleteAgent(agent.id);
 console.log(`Deleted agent, agent ID: ${agent.id}`);