var request = try Kagi.Endpoint.summarize.authorizedRequest

        var body: [String: Any] = query.reduce(first: { ["url": $0.absoluteString] }, second: { ["text": $0] })

        var body: [String: Any] = query.reduce(success: { ["url": $0.absoluteString] }, failure: { ["text": $0] })

        var request = try Kagi.Endpoint.summarize.authorizedRequest

// Copyright © 2024 Ryan Booker. All rights reserved.
import ArgumentParser
import Foundation
extension Kagi {
    struct Search: AsyncParsableCommand {
        static let configuration = CommandConfiguration(
            commandName: "search",
            abstract: "Search for something (Beta, requires Kagi Business (Team) plan).",
            usage: "kg search \"Do androids dream of electric sheep?\""
        )
        @Argument(help: "Something to search for") var query: String
        @Option(help: "The maximum number of search results") var limit: Int?
        mutating func run() async throws {
            do {
                let response = try await process(query, limit: limit)
                print(response)
            } catch {
                throw ValidationError(error.localizedDescription)
            }
        }
    }
}
// MARK: - Processing
extension Kagi.Search {
    func process(_ query: String, limit: Int?) async throws -> Kagi.Response<[Either<SearchResult, RelatedResults>]> {
        var queryItems: [URLQueryItem] = [.init(name: "q", value: query)]
        if let limit {
            queryItems.append(.init(name: "limit", value: "\(limit)"))
        }
        var request = try Kagi.Endpoint.search.authorizedRequest
        request.url?.append(queryItems: queryItems)
        let (data, response) = try await URLSession.shared.data(for: request)
        do {
            return try JSONDecoder().decode(Kagi.Response.self, from: data)
        } catch {
            #if DEBUG
            print(response)
            print(error)
            print("-----")
            #endif
            throw error
        }
    }
}
// MARK: - Response
extension Kagi.Search {
    struct SearchResult: CustomStringConvertible, Decodable {
        struct Thumbnail: Decodable {
            var url: URL
            var height: Int
            var width: Int
        }
        var rank: Int
        var url: URL
        var title: String
        var snippet: String?
        var published: Date?
        var thumbnail: Thumbnail?
        var description: String {
            [
                """
                \(rank): \(title)
                \(url)
                -----
                """,
                snippet.map {
                    """
                    \($0)
                    -----
                    """
                },
                published.map {
                    """
                    \($0.formatted(date: .long, time: .shortened))
                    -----
                    """
                }
            ]
            .compactMap { $0 }
            .joined(separator: "\n")
        }
    }
    struct RelatedResults: CustomStringConvertible, Decodable {
        var list: [String]
        var description: String {
            """
            Possibly related searches:
            \(list.map { "- \($0)" })
            """
        }
    }
}
extension Array where Element == Either<Kagi.Search.SearchResult, Kagi.Search.RelatedResults> {
    var description: String {
        """
        Results:
        \(map(\.description).joined(separator: "\n\n"))
        """
    }
}

        subcommands: [FastGPT.self, Summarize.self]

        subcommands: [FastGPT.self, Search.self, Summarize.self]

        case search

        var httpMethod: String {
            switch self {
            case .search:
                return "GET"
            case .fastGPT, .summarize:
                return "POST"
            }
        }

        }
        var request: URLRequest {
            var request = URLRequest(url: url)
            request.httpMethod = httpMethod
            if httpMethod == "POST" {
                request.setValue("application/json", forHTTPHeaderField: "Content-Type")
            }
            return request

                var request = URLRequest(url: url)
                request.setValue("application/json", forHTTPHeaderField: "Content-Type")

                var request = self.request

                request.httpMethod = "POST"

        success firstResult: (First) -> T,
        failure secondResult: (Second) -> T

        first firstResult: (First) -> T,
        second secondResult: (Second) -> T

    }
}
extension Either: CustomStringConvertible
where First: CustomStringConvertible, Second: CustomStringConvertible {
    var description: String {
        reduce(first: \.description, second: \.description)
    }
}
extension Either: Decodable
where First: Decodable, Second: Decodable {
    init(from decoder: Decoder) throws {
        self = try tryBoth(decoder, first: First.init, second: Second.init)

        }
    }
}
func tryBoth<A, First, Second>(
    _ value: A,
    first: (A) throws -> First,
    second: (A) throws -> Second
) throws -> Either<First, Second> {
    do {
        return try .first(first(value))
    } catch let firstError {
        do {
            return try .second(second(value))
        } catch let secondError {
            throw [firstError, secondError]

extension Array: Error where Element: Error {}

        .macOS(.v12),

        .macOS(.v13),

            argument = "summarize https://hypercritical.co/2024/01/11/i-made-this --summary-type takeaway"

            argument = "fastgpt "What is the answer to life, the universe, and everything?""
            isEnabled = "NO">
         </CommandLineArgument>
         <CommandLineArgument
            argument = "help fastgpt"
            isEnabled = "NO">
         </CommandLineArgument>
         <CommandLineArgument
            argument = "search &quot;Do androids dream of electric sheep?&quot;"

            argument = "help summarize"

            argument = "help search"

            argument = "fastgpt "What is the answer to life, the universe, and everything?""

            argument = "summarize https://hypercritical.co/2024/01/11/i-made-this --summary-type takeaway"

            argument = "help fastgpt"

            argument = "help summarize"