Refactor to remove the reference to OpenAI_Api package and added his source on the project as project. Continuation of the implementation of SqlServerAgent

Author: Jefferson Pires

Copilot/InlinePredictionManager.cs

@@ -75,8 +75,8 @@ public async Task OnEnterPressed(OptionPageGridGeneral options)
                 }
 
                 string prediction = options.UseCompletion && options.Service == OpenAIService.OpenAI
-                    ? await ChatGPT.GetCompletionResponseAsync(options, systemMessage, code, null, cancellationTokenSource.Token)
-                    : await ChatGPT.GetResponseAsync(options, systemMessage, code, null, cancellationTokenSource.Token);
+                    ? await ApiHandler.GetCompletionResponseAsync(options, systemMessage, code, null, cancellationTokenSource.Token)
+                    : await ApiHandler.GetResponseAsync(options, systemMessage, code, null, cancellationTokenSource.Token);
 
                 if (cancellationTokenSource.Token.IsCancellationRequested || string.IsNullOrWhiteSpace(prediction))
                 {

OpenAI_API/APIAuthentication.cs

@@ -0,0 +1,205 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace OpenAI_API
+{
+	/// <summary>
+	/// Represents authentication to the OpenAPI API endpoint
+	/// </summary>
+	public class APIAuthentication
+	{
+		/// <summary>
+		/// The API key, required to access the API endpoint.
+		/// </summary>
+		public string ApiKey { get; set; }
+		/// <summary>
+		/// The Organization ID to count API requests against.  This can be found at https://beta.openai.com/account/org-settings.
+		/// </summary>
+		public string OpenAIOrganization { get; set; }
+
+		/// <summary>
+		/// Allows implicit casting from a string, so that a simple string API key can be provided in place of an instance of <see cref="APIAuthentication"/>
+		/// </summary>
+		/// <param name="key">The API key to convert into a <see cref="APIAuthentication"/>.</param>
+		public static implicit operator APIAuthentication(string key)
+		{
+			return new APIAuthentication(key);
+		}
+
+		/// <summary>
+		/// Instantiates a new Authentication object with the given <paramref name="apiKey"/>, which may be <see langword="null"/>.
+		/// </summary>
+		/// <param name="apiKey">The API key, required to access the API endpoint.</param>
+		public APIAuthentication(string apiKey)
+		{
+			this.ApiKey = apiKey;
+		}
+
+
+		/// <summary>
+		/// Instantiates a new Authentication object with the given <paramref name="apiKey"/>, which may be <see langword="null"/>.  For users who belong to multiple organizations, you can specify which organization is used. Usage from these API requests will count against the specified organization's subscription quota.
+		/// </summary>
+		/// <param name="apiKey">The API key, required to access the API endpoint.</param>
+		/// <param name="openAIOrganization">The Organization ID to count API requests against.  This can be found at https://beta.openai.com/account/org-settings.</param>
+		public APIAuthentication(string apiKey, string openAIOrganization)
+		{
+			this.ApiKey = apiKey;
+			this.OpenAIOrganization = openAIOrganization;
+		}
+
+		private static APIAuthentication cachedDefault = null;
+
+		/// <summary>
+		/// The default authentication to use when no other auth is specified.  This can be set manually, or automatically loaded via environment variables or a config file.  <seealso cref="LoadFromEnv"/><seealso cref="LoadFromPath(string, string, bool)"/>
+		/// </summary>
+		public static APIAuthentication Default
+		{
+			get
+			{
+				if (cachedDefault != null)
+					return cachedDefault;
+
+				APIAuthentication auth = LoadFromEnv();
+				if (auth == null)
+					auth = LoadFromPath();
+				if (auth == null)
+					auth = LoadFromPath(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile));
+
+				cachedDefault = auth;
+				return auth;
+			}
+			set
+			{
+				cachedDefault = value;
+			}
+		}
+
+		/// <summary>
+		/// Attempts to load api key from environment variables, as "OPENAI_KEY" or "OPENAI_API_KEY".  Also loads org if from "OPENAI_ORGANIZATION" if present.
+		/// </summary>
+		/// <returns>Returns the loaded <see cref="APIAuthentication"/> any api keys were found, or <see langword="null"/> if there were no matching environment vars.</returns>
+		public static APIAuthentication LoadFromEnv()
+		{
+			string key = Environment.GetEnvironmentVariable("OPENAI_KEY");
+
+			if (string.IsNullOrEmpty(key))
+			{
+				key = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
+
+				if (string.IsNullOrEmpty(key))
+					return null;
+			}
+
+			string org = Environment.GetEnvironmentVariable("OPENAI_ORGANIZATION");
+
+			return new APIAuthentication(key, org);
+		}
+
+		/// <summary>
+		/// Attempts to load api keys from a configuration file, by default ".openai" in the current directory, optionally traversing up the directory tree
+		/// </summary>
+		/// <param name="directory">The directory to look in, or <see langword="null"/> for the current directory</param>
+		/// <param name="filename">The filename of the config file</param>
+		/// <param name="searchUp">Whether to recursively traverse up the directory tree if the <paramref name="filename"/> is not found in the <paramref name="directory"/></param>
+		/// <returns>Returns the loaded <see cref="APIAuthentication"/> any api keys were found, or <see langword="null"/> if it was not successful in finding a config (or if the config file didn't contain correctly formatted API keys)</returns>
+		public static APIAuthentication LoadFromPath(string directory = null, string filename = ".openai", bool searchUp = true)
+		{
+			if (directory == null)
+				directory = Environment.CurrentDirectory;
+
+			string key = null;
+			string org = null;
+			var curDirectory = new DirectoryInfo(directory);
+
+			while (key == null && curDirectory.Parent != null)
+			{
+				if (File.Exists(Path.Combine(curDirectory.FullName, filename)))
+				{
+					var lines = File.ReadAllLines(Path.Combine(curDirectory.FullName, filename));
+					foreach (var l in lines)
+					{
+						var parts = l.Split('=', ':');
+						if (parts.Length == 2)
+						{
+							switch (parts[0].ToUpper())
+							{
+								case "OPENAI_KEY":
+									key = parts[1].Trim();
+									break;
+								case "OPENAI_API_KEY":
+									key = parts[1].Trim();
+									break;
+								case "OPENAI_ORGANIZATION":
+									org = parts[1].Trim();
+									break;
+								default:
+									break;
+							}
+						}
+					}
+				}
+
+				if (searchUp)
+				{
+					curDirectory = curDirectory.Parent;
+				}
+				else
+				{
+					break;
+				}
+			}
+
+			if (string.IsNullOrEmpty(key))
+				return null;
+
+			return new APIAuthentication(key, org);
+		}
+
+
+		/// <summary>
+		/// Tests the api key against the OpenAI API, to ensure it is valid.  This hits the models endpoint so should not be charged for usage.
+		/// </summary>
+		/// <returns><see langword="true"/> if the api key is valid, or <see langword="false"/> if empty or not accepted by the OpenAI API.</returns>
+		public async Task<bool> ValidateAPIKey()
+		{
+			if (string.IsNullOrEmpty(ApiKey))
+				return false;
+
+			var api = new OpenAIAPI(this);
+
+			List<Models.Model> results;
+
+			try
+			{
+				results = await api.Models.GetModelsAsync();
+			}
+			catch (Exception ex)
+			{
+				Debug.WriteLine(ex.ToString());
+				return false;
+			}
+
+			return (results.Count > 0);
+		}
+
+	}
+
+	internal static class AuthHelpers
+	{
+		/// <summary>
+		/// A helper method to swap out <see langword="null"/> <see cref="APIAuthentication"/> objects with the <see cref="APIAuthentication.Default"/> authentication, possibly loaded from ENV or a config file.
+		/// </summary>
+		/// <param name="auth">The specific authentication to use if not <see langword="null"/></param>
+		/// <returns>Either the provided <paramref name="auth"/> or the <see cref="APIAuthentication.Default"/></returns>
+		public static APIAuthentication ThisOrDefault(this APIAuthentication auth)
+		{
+			if (auth == null)
+				auth = APIAuthentication.Default;
+
+			return auth;
+		}
+	}
+}

OpenAI_API/ApiResultBase.cs

@@ -0,0 +1,59 @@
+using Newtonsoft.Json;
+using OpenAI_API.Models;
+using System;
+
+namespace OpenAI_API
+{
+	/// <summary>
+	/// Represents a result from calling the OpenAI API, with all the common metadata returned from every endpoint
+	/// </summary>
+	abstract public class ApiResultBase
+	{
+
+		/// The time when the result was generated
+		[JsonIgnore]
+		public DateTime? Created => CreatedUnixTime.HasValue ? (DateTime?)(DateTimeOffset.FromUnixTimeSeconds(CreatedUnixTime.Value).DateTime) : null;
+
+		/// <summary>
+		/// The time when the result was generated in unix epoch format
+		/// </summary>
+		[JsonProperty("created")]
+		public long? CreatedUnixTime { get; set; }
+
+		/// <summary>
+		/// Which model was used to generate this result.
+		/// </summary>
+		[JsonProperty("model")]
+		public Model Model { get; set; }
+
+		/// <summary>
+		/// Object type, ie: text_completion, file, fine-tune, list, etc
+		/// </summary>
+		[JsonProperty("object")]
+		public string Object { get; set; }
+
+		/// <summary>
+		/// The organization associated with the API request, as reported by the API.
+		/// </summary>
+		[JsonIgnore]
+		public string Organization { get; internal set; }
+
+		/// <summary>
+		/// The server-side processing time as reported by the API.  This can be useful for debugging where a delay occurs.
+		/// </summary>
+		[JsonIgnore]
+		public TimeSpan ProcessingTime { get; internal set; }
+
+		/// <summary>
+		/// The request id of this API call, as reported in the response headers.  This may be useful for troubleshooting or when contacting OpenAI support in reference to a specific request.
+		/// </summary>
+		[JsonIgnore]
+		public string RequestId { get; internal set; }
+
+		/// <summary>
+		/// The Openai-Version used to generate this response, as reported in the response headers.  This may be useful for troubleshooting or when contacting OpenAI support in reference to a specific request.
+		/// </summary>
+		[JsonIgnore]
+		public string OpenaiVersion { get; internal set; }
+	}
+}

OpenAI_API/Chat/ChatContent.cs

@@ -0,0 +1,92 @@
+using Newtonsoft.Json;
+using System;
+
+namespace OpenAI_API.Chat
+{
+    /// <summary>
+    /// Represents the base class for chat content, providing a common type identifier.
+    /// </summary>
+    public abstract class ChatContentBase
+    {
+        /// <summary>
+        /// Represents the type of the object, initialized with a default value.
+        /// </summary>
+        [JsonProperty("type")]
+        public string Type { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the ChatContentBase class with the specified type.
+        /// </summary>
+        /// <param name="type">The type of the chat content.</param>
+        public ChatContentBase(string type)
+        {
+            Type = type;
+        }
+    }
+
+    /// <summary>
+    /// Represents the content of a chat message in text format.
+    /// Inherits from the ChatContentBase class, specifying the content type as "text".
+    /// </summary>
+    public class ChatContentForText : ChatContentBase
+    {
+        /// <summary>
+        /// Represents a text property that is serialized to JSON with the key "text".
+        /// </summary>
+        [JsonProperty("text")]
+        public string Text { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the ChatContentForText class with the specified text.
+        /// </summary>
+        /// <param name="text">The text content to initialize the instance with.</param>
+        public ChatContentForText(string text) : base(text)
+        {
+            Text = text;
+        }
+    }
+
+    /// <summary>
+    /// Represents the content of a chat message that contains an image, 
+    /// initialized with the specified image data.
+    /// </summary>
+    public class ChatContentForImage : ChatContentBase
+    {
+        /// <summary>
+        /// Represents the URL of an image, initialized with a base64 encoded JPEG image data.
+        /// </summary>
+        [JsonProperty("image_url")]
+        public ImageUrl ImageUrl { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the ChatContentForImage class with the provided image data.
+        /// Converts the byte array to a Base64 string and constructs an image URL in the "data:image/jpeg;base64" format.
+        /// </summary>
+        /// <param name="imageData">The byte array representing the image data.</param>
+        public ChatContentForImage(byte[] imageData) : base("image_url")
+        {
+            ImageUrl = new ImageUrl("data:image/jpeg;base64," + Convert.ToBase64String(imageData));
+        }
+    }
+
+    /// <summary>
+    /// Represents an image URL with a specified URL string.
+    /// </summary>
+    public class ImageUrl
+    {
+        /// <summary>
+        /// Represents a URL property that can be serialized to and from JSON.
+        /// </summary>
+        [JsonProperty("url")]
+        public string Url { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the ImageUrl class with the specified URL.
+        /// </summary>
+        /// <param name="url">The URL of the image.</param>
+        public ImageUrl(string url)
+        {
+            Url = url;
+        }
+    }
+}