Remove public Codable (Decodable and/or Encodable) conformance (google-gemini#142)

Author: andrewheard

Sources/GoogleAI/CountTokensRequest.swift

@@ -21,13 +21,6 @@ struct CountTokensRequest {
   let options: RequestOptions
 }
 
-@available(iOS 15.0, macOS 11.0, macCatalyst 15.0, *)
-extension CountTokensRequest: Encodable {
-  enum CodingKeys: CodingKey {
-    case contents
-  }
-}
-
 @available(iOS 15.0, macOS 11.0, macCatalyst 15.0, *)
 extension CountTokensRequest: GenerativeAIRequest {
   typealias Response = CountTokensResponse
@@ -39,7 +32,19 @@ extension CountTokensRequest: GenerativeAIRequest {
 
 /// The model's response to a count tokens request.
 @available(iOS 15.0, macOS 11.0, macCatalyst 15.0, *)
-public struct CountTokensResponse: Decodable {
+public struct CountTokensResponse {
   /// The total number of tokens in the input given to the model as a prompt.
   public let totalTokens: Int
 }
+
+// MARK: - Codable Conformances
+
+@available(iOS 15.0, macOS 11.0, macCatalyst 15.0, *)
+extension CountTokensRequest: Encodable {
+  enum CodingKeys: CodingKey {
+    case contents
+  }
+}
+
+@available(iOS 15.0, macOS 11.0, macCatalyst 15.0, *)
+extension CountTokensResponse: Decodable {}

Sources/GoogleAI/FunctionCalling.swift

@@ -15,93 +15,233 @@
 import Foundation
 
 /// A predicted function call returned from the model.
-///
-/// REST Docs: https://ai.google.dev/api/rest/v1beta/Content#functioncall
-public struct FunctionCall: Equatable, Encodable {
+public struct FunctionCall: Equatable {
   /// The name of the function to call.
   public let name: String
 
   /// The function parameters and values.
   public let args: JSONObject
 }
 
-// REST Docs: https://ai.google.dev/api/rest/v1beta/Tool#schema
-public class Schema: Encodable {
+/// A `Schema` object allows the definition of input and output data types.
+///
+/// These types can be objects, but also primitives and arrays. Represents a select subset of an
+/// [OpenAPI 3.0 schema object](https://spec.openapis.org/oas/v3.0.3#schema).
+public class Schema {
+  /// The data type.
   let type: DataType
 
+  /// The format of the data.
   let format: String?
 
+  /// A brief description of the parameter.
   let description: String?
 
+  /// Indicates if the value may be null.
   let nullable: Bool?
 
+  /// Possible values of the element of type ``DataType/string`` with "enum" format.
   let enumValues: [String]?
 
+  /// Schema of the elements of type ``DataType/array``.
   let items: Schema?
 
+  /// Properties of type ``DataType/object``.
   let properties: [String: Schema]?
 
-  let required: [String]?
+  /// Required properties of type ``DataType/object``.
+  let requiredProperties: [String]?
+
+  enum CodingKeys: String, CodingKey {
+    case type
+    case format
+    case description
+    case nullable
+    case enumValues = "enum"
+    case items
+    case properties
+    case requiredProperties = "required"
+  }
 
+  /// Constructs a new `Schema`.
+  ///
+  /// - Parameters:
+  ///   - type: The data type.
+  ///   - format: The format of the data; used only for primitive datatypes.
+  ///     Supported formats:
+  ///     - ``DataType/integer``: int32, int64
+  ///     - ``DataType/number``: float, double
+  ///     - ``DataType/string``: enum
+  ///   - description: A brief description of the parameter; may be formatted as Markdown.
+  ///   - nullable: Indicates if the value may be null.
+  ///   - enumValues: Possible values of the element of type ``DataType/string`` with "enum" format.
+  ///     For example, an enum `Direction` may be defined as `["EAST", NORTH", "SOUTH", "WEST"]`.
+  ///   - items: Schema of the elements of type ``DataType/array``.
+  ///   - properties: Properties of type ``DataType/object``.
+  ///   - requiredProperties: Required properties of type ``DataType/object``.
   public init(type: DataType, format: String? = nil, description: String? = nil,
               nullable: Bool? = nil,
               enumValues: [String]? = nil, items: Schema? = nil,
               properties: [String: Schema]? = nil,
-              required: [String]? = nil) {
+              requiredProperties: [String]? = nil) {
     self.type = type
     self.format = format
     self.description = description
     self.nullable = nullable
     self.enumValues = enumValues
     self.items = items
     self.properties = properties
-    self.required = required
+    self.requiredProperties = requiredProperties
   }
 }
 
-// REST Docs: https://ai.google.dev/api/rest/v1beta/Tool#Type
-public enum DataType: String, Encodable {
+/// A data type.
+///
+/// Contains the set of OpenAPI [data types](https://spec.openapis.org/oas/v3.0.3#data-types).
+public enum DataType: String {
+  /// A `String` type.
   case string = "STRING"
+
+  /// A floating-point number type.
   case number = "NUMBER"
+
+  /// An integer type.
   case integer = "INTEGER"
+
+  /// A boolean type.
   case boolean = "BOOLEAN"
+
+  /// An array type.
   case array = "ARRAY"
+
+  /// An object type.
   case object = "OBJECT"
 }
 
-// REST Docs: https://ai.google.dev/api/rest/v1beta/Tool#FunctionDeclaration
+/// Structured representation of a function declaration.
+///
+/// This `FunctionDeclaration` is a representation of a block of code that can be used as a ``Tool``
+/// by the model and executed by the client.
 public struct FunctionDeclaration {
+  /// The name of the function.
   let name: String
 
+  /// A brief description of the function.
   let description: String
 
-  let parameters: Schema
+  /// Describes the parameters to this function; must be of type ``DataType/object``.
+  let parameters: Schema?
 
-  let function: ((JSONObject) async throws -> JSONObject)?
-
-  public init(name: String, description: String, parameters: Schema,
-              function: ((JSONObject) async throws -> JSONObject)?) {
+  /// Constructs a new `FunctionDeclaration`.
+  ///
+  /// - Parameters:
+  ///   - name: The name of the function; must be a-z, A-Z, 0-9, or contain underscores and dashes,
+  ///   with a maximum length of 63.
+  ///   - description: A brief description of the function.
+  ///   - parameters: Describes the parameters to this function; the keys are parameter names and
+  ///   the values are ``Schema`` objects describing them.
+  ///   - requiredParameters: A list of required parameters by name.
+  public init(name: String, description: String, parameters: [String: Schema]?,
+              requiredParameters: [String]?) {
     self.name = name
     self.description = description
-    self.parameters = parameters
-    self.function = function
+    self.parameters = Schema(
+      type: .object,
+      properties: parameters,
+      requiredProperties: requiredParameters
+    )
   }
 }
 
-// REST Docs: https://ai.google.dev/api/rest/v1beta/Tool
-public struct Tool: Encodable {
+/// Helper tools that the model may use to generate response.
+///
+/// A `Tool` is a piece of code that enables the system to interact with external systems to
+/// perform an action, or set of actions, outside of knowledge and scope of the model.
+public struct Tool {
+  /// A list of `FunctionDeclarations` available to the model.
   let functionDeclarations: [FunctionDeclaration]?
 
+  /// Constructs a new `Tool`.
+  ///
+  /// - Parameters:
+  ///   - functionDeclarations: A list of `FunctionDeclarations` available to the model that can be
+  ///   used for function calling.
+  ///   The model or system does not execute the function. Instead the defined function may be
+  ///   returned as a ``FunctionCall`` in ``ModelContent/Part/functionCall(_:)`` with arguments to
+  ///   the client side for execution. The model may decide to call a subset of these functions by
+  ///   populating ``FunctionCall`` in the response. The next conversation turn may contain a
+  ///   ``FunctionResponse`` in ``ModelContent/Part/functionResponse(_:)`` with the
+  ///   ``ModelContent/role`` "function", providing generation context for the next model turn.
   public init(functionDeclarations: [FunctionDeclaration]?) {
     self.functionDeclarations = functionDeclarations
   }
 }
 
-// REST Docs: https://ai.google.dev/api/rest/v1beta/Content#functionresponse
-public struct FunctionResponse: Equatable, Encodable {
+/// Configuration for specifying function calling behavior.
+public struct FunctionCallingConfig {
+  /// Defines the execution behavior for function calling by defining the
+  /// execution mode.
+  public enum Mode: String {
+    /// The default behavior for function calling. The model calls functions to answer queries at
+    /// its discretion.
+    case auto = "AUTO"
+
+    /// The model always predicts a provided function call to answer every query.
+    case any = "ANY"
+
+    /// The model will never predict a function call to answer a query. This can also be achieved by
+    /// not passing any tools to the model.
+    case none = "NONE"
+  }
+
+  /// Specifies the mode in which function calling should execute. If
+  /// unspecified, the default value will be set to AUTO.
+  let mode: Mode?
+
+  /// A set of function names that, when provided, limits the functions the model
+  /// will call.
+  ///
+  /// This should only be set when the Mode is ANY. Function names
+  /// should match [FunctionDeclaration.name]. With mode set to ANY, model will
+  /// predict a function call from the set of function names provided.
+  let allowedFunctionNames: [String]?
+
+  public init(mode: FunctionCallingConfig.Mode? = nil, allowedFunctionNames: [String]? = nil) {
+    self.mode = mode
+    self.allowedFunctionNames = allowedFunctionNames
+  }
+}
+
+/// Tool configuration for any `Tool` specified in the request.
+public struct ToolConfig {
+  let functionCallingConfig: FunctionCallingConfig?
+
+  public init(functionCallingConfig: FunctionCallingConfig? = nil) {
+    self.functionCallingConfig = functionCallingConfig
+  }
+}
+
+/// Result output from a ``FunctionCall``.
+///
+/// Contains a string representing the `FunctionDeclaration.name` and a structured JSON object
+/// containing any output from the function is used as context to the model. This should contain the
+/// result of a ``FunctionCall`` made based on model prediction.
+public struct FunctionResponse: Equatable {
+  /// The name of the function that was called.
   let name: String
 
+  /// The function's response.
   let response: JSONObject
+
+  /// Constructs a new `FunctionResponse`.
+  ///
+  /// - Parameters:
+  ///   - name: The name of the function that was called.
+  ///   - response: The function's response.
+  public init(name: String, response: JSONObject) {
+    self.name = name
+    self.response = response
+  }
 }
 
 // MARK: - Codable Conformance
@@ -123,6 +263,8 @@ extension FunctionCall: Decodable {
   }
 }
 
+extension FunctionCall: Encodable {}
+
 extension FunctionDeclaration: Encodable {
   enum CodingKeys: String, CodingKey {
     case name
@@ -137,3 +279,17 @@ extension FunctionDeclaration: Encodable {
     try container.encode(parameters, forKey: .parameters)
   }
 }
+
+extension Schema: Encodable {}
+
+extension DataType: Encodable {}
+
+extension Tool: Encodable {}
+
+extension FunctionCallingConfig: Encodable {}
+
+extension FunctionCallingConfig.Mode: Encodable {}
+
+extension ToolConfig: Encodable {}
+
+extension FunctionResponse: Encodable {}