Updated FunctionRequest and ApiAgent classes to include a new property for sending API responses to AI, and modified related methods and UI elements accordingly.

Author: Jefferson Pires

OpenAI_API/Functions/FunctionRequest.cs

@@ -49,7 +49,7 @@ public class Function
         /// Setting strict to true will ensure function calls reliably adhere to the function schema, instead of being best effort. We recommend always enabling strict mode.
         /// </summary>
         [JsonProperty("strict")]
-        public bool Strict => true;
+        public bool Strict => false;
     }
 
     /// <summary>

README.md

@@ -198,6 +198,7 @@ Follow these steps to make the most of this feature:
    - **Identification**: Enter a unique name to identify the API.
    - **Base URL**: Enter the base URL of the API.
    - **Key/Values**: Define key-value pairs to be included in API requests, or to replace the key/values defined by the AI. Ideal for inserting authentication/authorization key/values, or to ensure that all calls have a certain key/value.
+   - **Send Responses to AI**: If checked, all API responses will be forwarded to the AI so it can process and retain them in its context. Otherwise, the AI will only receive the HTTP status, and the responses will be displayed directly in the chat. This option is ideal if you want to protect data and save tokens.
    - **Definition**: Enter the API's definition (e.g., OpenAPI, Swagger, SOAP) here. This allows the AI to understand the API's structure and capabilities for making requests.
 
 2. **Access the 'API' icon in Turbo Chat**  
@@ -215,6 +216,10 @@ Follow these steps to make the most of this feature:
 
    ![image]()
 
+   Or if you prefer that the AI only receives the status code from the APIs, without the actual responses (after disabled the "Send Responses to AI" parameter):
+
+   ![image]()
+
 5. **Important considerations**  
    - The AI ​​never has knowledge of the keys/values ​​configured through the options, so they are ideal for authentication tokens.
    - The AI ​​never has knowledge of the Base URL.

Resources/api.png

@@ -226,6 +226,7 @@
     <Resource Include="Resources\diffView.png" />
     <Resource Include="Resources\DB.png" />
     <Resource Include="Resources\cloud.png" />
+    <Resource Include="Resources\api.png" />
     <Content Include="Resources\Icon.png">
       <IncludeInVSIX>true</IncludeInVSIX>
     </Content>

VisualChatGPTStudio.csproj

@@ -181,6 +181,9 @@
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       <IncludeInVSIX>true</IncludeInVSIX>
     </Content>
+    <Resource Include="..\Resources\api.png">
+      <Link>Resources\api.png</Link>
+    </Resource>
     <Content Include="..\Resources\cancelCommand.png">
       <Link>Resources\cancelCommand.png</Link>
     </Content>

VisualChatGPTStudio2019/VisualChatGPTStudio2019.csproj

@@ -2,12 +2,17 @@
 using OpenAI_API.Functions;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using System.Net;
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
+using System.Xml;
+using System.Xml.Linq;
 using VisualChatGPTStudioShared.Utils.Http;
 using VisualChatGPTStudioShared.Utils.Repositories;
+using Parameter = OpenAI_API.Functions.Parameter;
 
 namespace VisualChatGPTStudioShared.Agents.ApiAgent
 {
@@ -92,12 +97,12 @@ public static List<FunctionRequest> GetApiFunctions()
         }
 
         /// <summary>
-        /// Executes the function based on the arguments provided by the AI.
+        /// Executes an asynchronous function call to an API, handling both SOAP and REST requests based on the provided function parameters.
         /// </summary>
-        /// <param name="function">The <see cref="FunctionResult"/> object with the function arguments.</param>
-        /// <param name="logRequestAndResponse">Indicate whether the request and response should be logged.</param>
-        /// <returns>The response returned by the API or exception details in case of an error.</returns>
-        public static async Task<string> ExecuteFunctionAsync(FunctionResult function, bool logRequestAndResponse)
+        /// <param name="function">The function result containing the API call details.</param>
+        /// <param name="logRequestAndResponse">A boolean indicating whether to log the request and response.</param>
+        /// <returns>A tuple where the first value refers to the response to be sent to the AI, and the second value refers to the API response to be displayed in the chat, when applicable.</returns>
+        public static async Task<(string, string)> ExecuteFunctionAsync(FunctionResult function, bool logRequestAndResponse)
         {
             try
             {
@@ -109,7 +114,7 @@ public static async Task<string> ExecuteFunctionAsync(FunctionResult function, b
 
                 if (apiDefinition == null)
                 {
-                    return $"API with name {apiName} was not found.";
+                    return ($"API with name {apiName} was not found.", null);
                 }
 
                 string endPoint = arguments[nameof(endPoint)]?.Value<string>();
@@ -129,41 +134,59 @@ public static async Task<string> ExecuteFunctionAsync(FunctionResult function, b
                     }
                 }
 
+                HttpStatusCode responseStatusCode;
+                string responseContent;
+
                 if (function.Function.Name == nameof(CallSoapApiAsync))
                 {
                     string soapAction = arguments["soapAction"]?.Value<string>();
                     string soapEnvelope = arguments["soapEnvelope"]?.Value<string>();
 
-                    return await CallSoapApiAsync(apiDefinition, endPoint, soapAction, headers, soapEnvelope, logRequestAndResponse);
-                }
+                    HttpResponseMessage response = await CallSoapApiAsync(apiDefinition, endPoint, soapAction, headers, soapEnvelope, logRequestAndResponse);
 
-                string method = arguments[nameof(method)]?.Value<string>();
+                    responseStatusCode = response.StatusCode;
+                    responseContent = FormatXml(await response.Content.ReadAsStringAsync());
+                }
+                else
+                {
+                    string method = arguments[nameof(method)]?.Value<string>();
 
-                // Optional query parameters
-                Dictionary<string, string> queryParams = arguments[nameof(queryParams)]?.ToObject<Dictionary<string, string>>() ?? [];
+                    // Optional query parameters
+                    Dictionary<string, string> queryParams = arguments[nameof(queryParams)]?.ToObject<Dictionary<string, string>>() ?? [];
 
-                // Request body (for POST, PUT, PATCH, etc.)
-                string body = arguments[nameof(body)]?.Value<string>();
+                    // Request body (for POST, PUT, PATCH, etc.)
+                    string body = arguments[nameof(body)]?.Value<string>();
 
-                foreach (ApiTagItem tag in apiDefinition.Tags.Where(t => t.Type == ApiTagType.QueryString))
-                {
-                    if (queryParams.ContainsKey(tag.Key))
+                    foreach (ApiTagItem tag in apiDefinition.Tags.Where(t => t.Type == ApiTagType.QueryString))
                     {
-                        queryParams[tag.Key] = tag.Value;
-                    }
-                    else
-                    {
-                        queryParams.Add(tag.Key, tag.Value);
+                        if (queryParams.ContainsKey(tag.Key))
+                        {
+                            queryParams[tag.Key] = tag.Value;
+                        }
+                        else
+                        {
+                            queryParams.Add(tag.Key, tag.Value);
+                        }
                     }
+
+                    HttpResponseMessage response = await CallRestApiAsync(apiDefinition, endPoint, method, headers, queryParams, body, logRequestAndResponse);
+
+                    responseStatusCode = response.StatusCode;
+                    responseContent = FormatJson(await response.Content.ReadAsStringAsync());
+                }
+
+                if (apiDefinition.SendResponsesToAI)
+                {
+                    return ($"Response Status Code: {responseStatusCode}{Environment.NewLine}{responseContent}", null);
                 }
 
-                return await CallRestApiAsync(apiDefinition, endPoint, method, headers, queryParams, body, logRequestAndResponse);
+                return ($"Response Status Code: {responseStatusCode}", responseContent);
             }
             catch (Exception ex)
             {
                 Logger.Log(ex);
 
-                return ex.Message;
+                return (ex.Message, null);
             }
         }
 
@@ -180,17 +203,17 @@ public static async Task<string> ExecuteFunctionAsync(FunctionResult function, b
         /// <param name="headers">Optional headers.</param>
         /// <param name="soapEnvelope">SOAP envelope in XML format.</param>
         /// <param name="logRequestAndResponse">Indicate whether the request and response should be logged..</param>
-        /// <returns>Response content from the SOAP service as a string.</returns>
-        private static async Task<string> CallSoapApiAsync(ApiItem apiDefinition,
-                                                           string endPoint,
-                                                           string soapAction,
-                                                           Dictionary<string, string> headers,
-                                                           string soapEnvelope,
-                                                           bool logRequestAndResponse)
+        /// <returns>The API response.</returns>
+        private static async Task<HttpResponseMessage> CallSoapApiAsync(ApiItem apiDefinition,
+                                                                        string endPoint,
+                                                                        string soapAction,
+                                                                        Dictionary<string, string> headers,
+                                                                        string soapEnvelope,
+                                                                        bool logRequestAndResponse)
         {
             using (HttpClient client = new())
             {
-                HttpRequestMessage request = new(HttpMethod.Post, apiDefinition.BaseUrl + endPoint)
+                HttpRequestMessage request = new(HttpMethod.Post, apiDefinition.BaseUrl.TrimEnd('/') + endPoint)
                 {
                     Content = new StringContent(soapEnvelope, Encoding.UTF8, "text/xml")
                 };
@@ -222,7 +245,7 @@ private static async Task<string> CallSoapApiAsync(ApiItem apiDefinition,
                     await HttpLogs.LogResponseAsync(response);
                 }
 
-                return await response.Content.ReadAsStringAsync();
+                return response;
             }
         }
 
@@ -236,14 +259,14 @@ private static async Task<string> CallSoapApiAsync(ApiItem apiDefinition,
         /// <param name="queryParams">Optional query parameters.</param>
         /// <param name="body">Request body (when applicable).</param>
         /// <param name="logRequestAndResponse">Indicate whether the request and response should be logged..</param>
-        /// <returns>Response content from the API as a string.</returns>
-        private static async Task<string> CallRestApiAsync(ApiItem apiDefinition,
-                                                           string endPoint,
-                                                           string method,
-                                                           Dictionary<string, string> headers,
-                                                           Dictionary<string, string> queryParams,
-                                                           string body,
-                                                           bool logRequestAndResponse)
+        /// <returns>The API response.</returns>
+        private static async Task<HttpResponseMessage> CallRestApiAsync(ApiItem apiDefinition,
+                                                                        string endPoint,
+                                                                        string method,
+                                                                        Dictionary<string, string> headers,
+                                                                        Dictionary<string, string> queryParams,
+                                                                        string body,
+                                                                        bool logRequestAndResponse)
         {
             using (HttpClient client = new())
             {
@@ -255,7 +278,7 @@ private static async Task<string> CallRestApiAsync(ApiItem apiDefinition,
                     endPoint += (endPoint.Contains("?") ? "&" : "?") + queryString;
                 }
 
-                HttpRequestMessage request = new(new HttpMethod(method), apiDefinition.BaseUrl + endPoint);
+                HttpRequestMessage request = new(new HttpMethod(method), apiDefinition.BaseUrl.TrimEnd('/') + endPoint);
 
                 // Add headers, if provided
                 if (headers != null)
@@ -285,7 +308,67 @@ private static async Task<string> CallRestApiAsync(ApiItem apiDefinition,
                     await HttpLogs.LogResponseAsync(response);
                 }
 
-                return await response.Content.ReadAsStringAsync();
+                return response;
+            }
+        }
+
+        /// <summary>
+        /// Formats the provided XML string with indentation and wraps it in code block syntax for display.
+        /// </summary>
+        /// <param name="xml">The XML string to be formatted.</param>
+        /// <returns>A formatted XML string wrapped in code block syntax.</returns>
+        private static string FormatXml(string xml)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(xml))
+                {
+                    return null;
+                }
+
+                StringBuilder stringBuilder = new();
+
+                XDocument xmlDoc = XDocument.Parse(xml);
+
+                using (StringWriter stringWriter = new(stringBuilder))
+                {
+                    using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings { Indent = true }))
+                    {
+                        xmlDoc.WriteTo(xmlWriter);
+                    }
+                }
+
+                return string.Concat("```xml", Environment.NewLine, stringBuilder.ToString(), Environment.NewLine, "```");
+            }
+            catch (Exception)
+            {
+                return xml;
+            }
+        }
+
+        /// <summary>
+        /// Formats a JSON string by parsing it and returning a prettified version enclosed in markdown code block syntax for JSON.
+        /// </summary>
+        /// <param name="json">The JSON string to be formatted.</param>
+        /// <returns>
+        /// A string containing the formatted JSON wrapped in markdown code block syntax.
+        /// </returns>
+        private static string FormatJson(string json)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(json))
+                {
+                    return null;
+                }
+
+                JToken parsedJson = JToken.Parse(json);
+
+                return string.Concat("```json", Environment.NewLine, parsedJson.ToString(Newtonsoft.Json.Formatting.Indented), Environment.NewLine, "```");
+            }
+            catch (Exception)
+            {
+                return json;
             }
         }
 

VisualChatGPTStudioShared/Agents/ApiAgent/ApiAgent.cs

@@ -22,6 +22,11 @@ public class ApiItem
         /// </summary>
         public string BaseUrl { get; set; }
 
+        /// <summary>
+        /// If true, all responses will be send to AI, when false, only HTTP status will be send.
+        /// </summary>
+        public bool SendResponsesToAI { get; set; }
+
         /// <summary>
         /// Gets or sets the collection of API tag items.
         /// </summary>

VisualChatGPTStudioShared/Agents/ApiAgent/ApiItem.cs

@@ -62,6 +62,17 @@
             <TextBox x:Name="txtBaseUrl" Grid.Row="2" Grid.Column="2" FontSize="16" MaxLength="255"/>
             <Image Grid.Row="2" Grid.Column="4" VerticalAlignment="Center" ToolTip="Enter the base URL of the API." Source="pack://application:,,,/VisualChatGPTStudio;component/Resources/information.png" />
 
+            <!-- SEND RESPONSES TO AI -->
+            <Label Content="Send Responses to AI:" Grid.Row="4" Grid.Column="0" />
+            <StackPanel Grid.Row="4" Grid.Column="2" Orientation="Horizontal" HorizontalAlignment="Left">
+                <CheckBox Name="chkSendReponsesToAI" Margin="0,0,10,0">
+                    <CheckBox.LayoutTransform>
+                        <ScaleTransform ScaleX="1.5" ScaleY="1.5"/>
+                    </CheckBox.LayoutTransform>
+                </CheckBox>
+                <Image ToolTip="If checked, all API responses will be forwarded to the AI so it can process and retain them in its context. Otherwise, the AI will only receive the HTTP status, and the responses will be displayed directly in the chat. This option is ideal if you want to protect data and save tokens." Source="pack://application:,,,/VisualChatGPTStudio;component/Resources/information.png" />
+            </StackPanel>            
+            
             <!-- TAGs -->
             <Button x:Name="btnInsertTag" Content="Insert a Key/Value" Click="btnInsertTag_Click"  Grid.Row="4" Grid.Column="2" HorizontalAlignment="Right" Width="150" />
             <Label Content="Key/Values:" Grid.Row="6" Grid.Column="0" VerticalAlignment="Top" />

VisualChatGPTStudioShared/Options/ApiAgent/OptionApiAgentWindow.xaml

@@ -128,6 +128,7 @@ private void btnInsertApi_Click(object sender, RoutedEventArgs e)
                 Name = txtIdentification.Text.Trim(),
                 BaseUrl = txtBaseUrl.Text.Trim(),
                 Tags = Tags.ToList(),
+                SendResponsesToAI = chkSendReponsesToAI.IsChecked.Value,
                 Definition = txtDefinition.Text.Trim()
             };
 
@@ -139,6 +140,7 @@ private void btnInsertApi_Click(object sender, RoutedEventArgs e)
             txtIdentification.Clear();
             txtBaseUrl.Clear();
             txtDefinition.Clear();
+            chkSendReponsesToAI.IsChecked = false;
             Tags.Clear();
         }
 
@@ -153,6 +155,7 @@ private void btnEditApi_Click(object sender, MouseButtonEventArgs e)
                 apiIdOnEdit = selectedApi.Id;
                 txtIdentification.Text = selectedApi.Name;
                 txtBaseUrl.Text = selectedApi.BaseUrl;
+                chkSendReponsesToAI.IsChecked = selectedApi.SendResponsesToAI;
                 txtDefinition.Text = selectedApi.Definition;
                 Tags.Clear();
 

VisualChatGPTStudioShared/Options/ApiAgent/OptionApiAgentWindow.xaml.cs

@@ -30,6 +30,10 @@ public ChatListControlItem(AuthorEnum author, string message)
             {
                 ImageSource = "pack://application:,,,/VisualChatGPTStudio;component/Resources/chatGPT.png";
             }
+            else if (author == AuthorEnum.ApiResult)
+            {
+                ImageSource = "pack://application:,,,/VisualChatGPTStudio;component/Resources/api.png";
+            }
         }
     }
 
@@ -39,6 +43,7 @@ public enum AuthorEnum
         ChatGPT,
         ChatGPTCode,
         FunctionCall,
-        FunctionRequest
+        FunctionRequest,
+        ApiResult
     }
 }