kagi-api 0.0.0

data/lib/kagi/api/endpoints/container.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "containable"
+
+module Kagi
+  module API
+    module Endpoints
+      # Registers all endpoints.
+      module Container
+        extend Containable
+
+        namespace :enrich do
+          register(:news) { Enrich::News.new }
+          register(:web) { Enrich::Web.new }
+        end
+
+        register(:fast) { Fast.new }
+        register(:search) { Search.new }
+        register(:summarize) { Summarize.new }
+      end
+    end
+  end
+end

data/lib/kagi/api/endpoints/dependencies.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "infusible"
+
+module Kagi
+  module API
+    module Endpoints
+      Dependencies = Infusible[Container]
+    end
+  end
+end

data/lib/kagi/api/endpoints/enrich/news.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+require "pipeable"
+
+module Kagi
+  module API
+    module Endpoints
+      module Enrich
+        # Handles news requests.
+        class News
+          include Kagi::API::Dependencies[
+            :requester,
+            contract: "contracts.search",
+            error_contract: "contracts.error",
+            model: "models.search",
+            error_model: "models.error"
+          ]
+
+          include Dry::Monads[:result]
+          include Pipeable
+
+          def call(**params)
+            result = requester.get("enrich/news", **params)
+
+            case result
+              in Success then success result
+              in Failure(response) then failure response
+              else Failure "Unable to parse HTTP response."
+            end
+          end
+
+          private
+
+          def success result
+            pipe result,
+                 try(:parse, catch: JSON::ParserError),
+                 validate(contract, as: :to_h),
+                 to(model, :for)
+          end
+
+          def failure response
+            pipe(
+              response,
+              try(:parse, catch: JSON::ParserError),
+              validate(error_contract, as: :to_h),
+              to(error_model, :for),
+              bind { Failure it }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/endpoints/enrich/web.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+require "pipeable"
+
+module Kagi
+  module API
+    module Endpoints
+      module Enrich
+        # Handles web requests.
+        class Web
+          include Kagi::API::Dependencies[
+            :requester,
+            contract: "contracts.search",
+            error_contract: "contracts.error",
+            model: "models.search",
+            error_model: "models.error"
+          ]
+
+          include Dry::Monads[:result]
+          include Pipeable
+
+          def call(**params)
+            result = requester.get("enrich/web", **params)
+
+            case result
+              in Success then success result
+              in Failure(response) then failure response
+              else Failure "Unable to parse HTTP response."
+            end
+          end
+
+          private
+
+          def success result
+            pipe result,
+                 try(:parse, catch: JSON::ParserError),
+                 validate(contract, as: :to_h),
+                 to(model, :for)
+          end
+
+          def failure response
+            pipe(
+              response,
+              try(:parse, catch: JSON::ParserError),
+              validate(error_contract, as: :to_h),
+              to(error_model, :for),
+              bind { Failure it }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/endpoints/fast.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+require "pipeable"
+
+module Kagi
+  module API
+    module Endpoints
+      # Handles Fast GPT requests.
+      class Fast
+        include Kagi::API::Dependencies[
+          :requester,
+          contract: "contracts.fast",
+          error_contract: "contracts.error",
+          model: "models.fast",
+          error_model: "models.error"
+        ]
+
+        include Dry::Monads[:result]
+        include Pipeable
+
+        def call(**params)
+          result = requester.post("fastgpt", **params)
+
+          case result
+            in Success then success result
+            in Failure(response) then failure response
+            else Failure "Unable to parse HTTP response."
+          end
+        end
+
+        private
+
+        def success result
+          pipe result,
+               try(:parse, catch: JSON::ParserError),
+               validate(contract, as: :to_h),
+               to(model, :for)
+        end
+
+        def failure response
+          pipe(
+            response,
+            try(:parse, catch: JSON::ParserError),
+            validate(error_contract, as: :to_h),
+            to(error_model, :for),
+            bind { Failure it }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/endpoints/search.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+require "pipeable"
+
+module Kagi
+  module API
+    module Endpoints
+      # Handles search requests.
+      class Search
+        include Kagi::API::Dependencies[
+          :requester,
+          contract: "contracts.search",
+          error_contract: "contracts.error",
+          model: "models.search",
+          error_model: "models.error"
+        ]
+
+        include Dry::Monads[:result]
+        include Pipeable
+
+        def call(**params)
+          result = requester.get("search", **params)
+
+          case result
+            in Success then success result
+            in Failure(response) then failure response
+            else Failure "Unable to parse HTTP response."
+          end
+        end
+
+        private
+
+        def success result
+          pipe result,
+               try(:parse, catch: JSON::ParserError),
+               validate(contract, as: :to_h),
+               to(model, :for)
+        end
+
+        def failure response
+          pipe(
+            response,
+            try(:parse, catch: JSON::ParserError),
+            validate(error_contract, as: :to_h),
+            to(error_model, :for),
+            bind { Failure it }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/endpoints/summarize.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+require "pipeable"
+
+module Kagi
+  module API
+    module Endpoints
+      # Handles summarize requests.
+      class Summarize
+        include Kagi::API::Dependencies[
+          :requester,
+          contract: "contracts.summary",
+          error_contract: "contracts.error",
+          model: "models.summary",
+          error_model: "models.error"
+        ]
+
+        include Dry::Monads[:result]
+        include Pipeable
+
+        def call(**params)
+          result = requester.post("summarize", **params)
+
+          case result
+            in Success then success result
+            in Failure(response) then failure response
+            else Failure "Unable to parse HTTP response."
+          end
+        end
+
+        private
+
+        def success result
+          pipe result,
+               try(:parse, catch: JSON::ParserError),
+               validate(contract, as: :to_h),
+               to(model, :for)
+        end
+
+        def failure response
+          pipe(
+            response,
+            try(:parse, catch: JSON::ParserError),
+            validate(error_contract, as: :to_h),
+            to(error_model, :for),
+            bind { Failure it }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/models/content/error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    module Models
+      module Content
+        ERROR_MAP = {msg: :message, ref: :reference}.freeze
+
+        # Models error data.
+        Error = Data.define :code, :message, :reference do
+          def self.for(key_map: ERROR_MAP, **attributes)
+            new(**attributes.transform_keys(key_map))
+          end
+
+          def initialize(reference: nil, **)
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/models/content/fast.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    module Models
+      module Content
+        # Models fast data.
+        Fast = Data.define :output, :tokens, :references do
+          def self.for(**attributes)
+            new(**attributes, references: attributes[:references].map { Reference[**it] })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/models/content/meta.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    module Models
+      module Content
+        META_MAP = {ms: :duration, api_balance: :balance}.freeze
+
+        # Models meta data.
+        Meta = Data.define :id, :node, :duration, :balance do
+          def self.for(key_map: META_MAP, **attributes) = new(**attributes.transform_keys(key_map))
+
+          def initialize(balance: nil, **)
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/models/content/reference.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    module Models
+      module Content
+        # Models reference data.
+        Reference = Data.define :title, :snippet, :url
+      end
+    end
+  end
+end

data/lib/kagi/api/models/content/search.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    module Models
+      module Content
+        SEARCH_MAP = {t: :type, published: :published_at}.freeze
+
+        # Models search data.
+        Search = Data.define :type, :rank, :title, :url, :snippet, :published_at, :thumbnail do
+          def self.for(key_map: SEARCH_MAP, **attributes)
+            new(
+              **attributes.transform_keys(key_map),
+              thumbnail: (Thumbnail[**attributes[:thumbnail]] if attributes.key? :thumbnail)
+            )
+          end
+
+          # rubocop:todo Metrics/ParameterLists
+          def initialize(
+            rank: nil,
+            title: nil,
+            url: nil,
+            snippet: nil,
+            published_at: nil,
+            thumbnail: nil,
+            **attributes
+          )
+            super
+          end
+          # rubocop:enable Metrics/ParameterLists
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/models/content/summary.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    module Models
+      module Content
+        # Models summary data.
+        Summary = Data.define :output, :tokens
+      end
+    end
+  end
+end

data/lib/kagi/api/models/content/thumbnail.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    module Models
+      module Content
+        # Models thumbnail data.
+        Thumbnail = Data.define :url, :width, :height do
+          def initialize url:, width: nil, height: nil
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/models/error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    module Models
+      # Models the API error.
+      Error = Data.define :meta, :error do
+        def self.for(**attributes)
+          new(
+            **attributes.merge!(
+              meta: Content::Meta.for(**attributes[:meta]),
+              error: attributes[:error].map { Content::Error.for(**it) }
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/models/fast.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    module Models
+      # Models the fast payload.
+      Fast = Data.define :meta, :data do
+        def self.for(**attributes)
+          new(
+            **attributes.merge!(
+              meta: Content::Meta.for(**attributes[:meta]),
+              data: Content::Fast.for(**attributes[:data])
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/models/search.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    module Models
+      # Models the search payload.
+      Search = Data.define :meta, :data do
+        def self.for(**attributes)
+          new(
+            **attributes.merge!(
+              meta: Content::Meta.for(**attributes[:meta]),
+              data: attributes[:data].map { Content::Search.for(**it) }
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/models/summary.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    module Models
+      # Models the API payload.
+      Summary = Data.define :meta, :data do
+        def self.for(**attributes)
+          new(
+            **attributes.merge!(
+              meta: Content::Meta.for(**attributes[:meta]),
+              data: Content::Summary[**attributes[:data]]
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kagi/api/requester.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Kagi
+  module API
+    # The low-level object for making basic HTTP requests.
+    class Requester
+      include Dependencies[:settings, :http]
+      include Dry::Monads[:result]
+
+      def initialize(**)
+        super
+        yield settings if block_given?
+      end
+
+      def get(path, **params) = call(__method__, path, params:)
+
+      def post(path, **json) = call(__method__, path, json:)
+
+      private
+
+      attr_reader :settings
+
+      def call verb, path, **options
+        http.auth("Bot #{settings.token}")
+            .headers(settings.headers)
+            .public_send(verb, "#{settings.uri}/#{path}", options)
+            .then { |response| response.status.success? ? Success(response) : Failure(response) }
+      end
+    end
+  end
+end

data/lib/kagi/api.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "dry/schema"
+require "zeitwerk"
+
+Dry::Schema.load_extensions :monads
+
+Zeitwerk::Loader.new.then do |loader|
+  loader.inflector.inflect "api" => "API"
+  loader.tag = "kagi-api"
+  loader.push_dir "#{__dir__}/.."
+  loader.setup
+end
+
+module Kagi
+  # Main namespace.
+  module API
+    def self.loader registry = Zeitwerk::Registry
+      @loader ||= registry.loaders.find { |loader| loader.tag == "kagi-api" }
+    end
+
+    def self.new(&) = Client.new(&)
+  end
+end