handinger 0.0.2

data/rbi/handinger/models/worker.rbi

@@ -0,0 +1,546 @@
+# typed: strong
+
+module Handinger
+  module Models
+    class Worker < Handinger::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Handinger::Worker, Handinger::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :created_at
+
+      sig { returns(NilClass) }
+      attr_accessor :error
+
+      sig { returns(T::Array[Handinger::Worker::File]) }
+      attr_accessor :files
+
+      sig { returns(NilClass) }
+      attr_accessor :incomplete_details
+
+      sig { returns(T::Array[T.anything]) }
+      attr_accessor :messages
+
+      sig { returns(T::Hash[Symbol, T.anything]) }
+      attr_accessor :metadata
+
+      sig { returns(Handinger::Worker::Object::TaggedSymbol) }
+      attr_accessor :object
+
+      sig { returns(T::Array[Handinger::Worker::Output]) }
+      attr_accessor :output
+
+      sig { returns(String) }
+      attr_accessor :output_text
+
+      sig { returns(T::Boolean) }
+      attr_accessor :running
+
+      sig { returns(T::Array[Handinger::Worker::Source]) }
+      attr_accessor :sources
+
+      sig { returns(Handinger::Worker::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      sig { returns(T.nilable(Handinger::Worker::Costs)) }
+      attr_reader :costs
+
+      sig { params(costs: T.nilable(Handinger::Worker::Costs::OrHash)).void }
+      attr_writer :costs
+
+      sig { returns(T.nilable(Handinger::Worker::Usage)) }
+      attr_reader :usage
+
+      sig { params(usage: Handinger::Worker::Usage::OrHash).void }
+      attr_writer :usage
+
+      sig do
+        params(
+          id: String,
+          created_at: T.nilable(Integer),
+          error: NilClass,
+          files: T::Array[Handinger::Worker::File::OrHash],
+          incomplete_details: NilClass,
+          messages: T::Array[T.anything],
+          metadata: T::Hash[Symbol, T.anything],
+          object: Handinger::Worker::Object::OrSymbol,
+          output: T::Array[Handinger::Worker::Output::OrHash],
+          output_text: String,
+          running: T::Boolean,
+          sources: T::Array[Handinger::Worker::Source::OrHash],
+          status: Handinger::Worker::Status::OrSymbol,
+          costs: T.nilable(Handinger::Worker::Costs::OrHash),
+          usage: Handinger::Worker::Usage::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        created_at:,
+        error:,
+        files:,
+        incomplete_details:,
+        messages:,
+        metadata:,
+        object:,
+        output:,
+        output_text:,
+        running:,
+        sources:,
+        status:,
+        costs: nil,
+        usage: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            created_at: T.nilable(Integer),
+            error: NilClass,
+            files: T::Array[Handinger::Worker::File],
+            incomplete_details: NilClass,
+            messages: T::Array[T.anything],
+            metadata: T::Hash[Symbol, T.anything],
+            object: Handinger::Worker::Object::TaggedSymbol,
+            output: T::Array[Handinger::Worker::Output],
+            output_text: String,
+            running: T::Boolean,
+            sources: T::Array[Handinger::Worker::Source],
+            status: Handinger::Worker::Status::TaggedSymbol,
+            costs: T.nilable(Handinger::Worker::Costs),
+            usage: Handinger::Worker::Usage
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class File < Handinger::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Handinger::Worker::File, Handinger::Internal::AnyHash)
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :filename
+
+        sig { returns(String) }
+        attr_accessor :media_type
+
+        sig { returns(String) }
+        attr_accessor :url
+
+        sig do
+          params(
+            filename: T.nilable(String),
+            media_type: String,
+            url: String
+          ).returns(T.attached_class)
+        end
+        def self.new(filename:, media_type:, url:)
+        end
+
+        sig do
+          override.returns(
+            { filename: T.nilable(String), media_type: String, url: String }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      module Object
+        extend Handinger::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Handinger::Worker::Object) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        WORKER = T.let(:worker, Handinger::Worker::Object::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Handinger::Worker::Object::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+
+      class Output < Handinger::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Handinger::Worker::Output, Handinger::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T::Array[Handinger::Worker::Output::Content]) }
+        attr_accessor :content
+
+        sig { returns(Handinger::Worker::Output::Role::TaggedSymbol) }
+        attr_accessor :role
+
+        sig { returns(Handinger::Worker::Output::Status::TaggedSymbol) }
+        attr_accessor :status
+
+        sig { returns(Handinger::Worker::Output::Type::TaggedSymbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            id: String,
+            content: T::Array[Handinger::Worker::Output::Content::OrHash],
+            role: Handinger::Worker::Output::Role::OrSymbol,
+            status: Handinger::Worker::Output::Status::OrSymbol,
+            type: Handinger::Worker::Output::Type::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(id:, content:, role:, status:, type:)
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              content: T::Array[Handinger::Worker::Output::Content],
+              role: Handinger::Worker::Output::Role::TaggedSymbol,
+              status: Handinger::Worker::Output::Status::TaggedSymbol,
+              type: Handinger::Worker::Output::Type::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Content < Handinger::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Handinger::Worker::Output::Content,
+                Handinger::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :text
+
+          sig do
+            returns(Handinger::Worker::Output::Content::Type::TaggedSymbol)
+          end
+          attr_accessor :type
+
+          sig do
+            params(
+              text: String,
+              type: Handinger::Worker::Output::Content::Type::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(text:, type:)
+          end
+
+          sig do
+            override.returns(
+              {
+                text: String,
+                type: Handinger::Worker::Output::Content::Type::TaggedSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Type
+            extend Handinger::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, Handinger::Worker::Output::Content::Type)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            OUTPUT_TEXT =
+              T.let(
+                :output_text,
+                Handinger::Worker::Output::Content::Type::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[Handinger::Worker::Output::Content::Type::TaggedSymbol]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        module Role
+          extend Handinger::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Handinger::Worker::Output::Role) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ASSISTANT =
+            T.let(:assistant, Handinger::Worker::Output::Role::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Handinger::Worker::Output::Role::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+
+        module Status
+          extend Handinger::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Handinger::Worker::Output::Status) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          COMPLETED =
+            T.let(:completed, Handinger::Worker::Output::Status::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Handinger::Worker::Output::Status::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+
+        module Type
+          extend Handinger::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Handinger::Worker::Output::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          MESSAGE =
+            T.let(:message, Handinger::Worker::Output::Type::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Handinger::Worker::Output::Type::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      class Source < Handinger::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Handinger::Worker::Source, Handinger::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :title
+
+        sig { returns(Handinger::Worker::Source::Type::TaggedSymbol) }
+        attr_accessor :type
+
+        sig { returns(String) }
+        attr_accessor :url
+
+        sig do
+          params(
+            id: String,
+            title: T.nilable(String),
+            type: Handinger::Worker::Source::Type::OrSymbol,
+            url: String
+          ).returns(T.attached_class)
+        end
+        def self.new(id:, title:, type:, url:)
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              title: T.nilable(String),
+              type: Handinger::Worker::Source::Type::TaggedSymbol,
+              url: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Type
+          extend Handinger::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Handinger::Worker::Source::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          URL = T.let(:url, Handinger::Worker::Source::Type::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Handinger::Worker::Source::Type::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      module Status
+        extend Handinger::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Handinger::Worker::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        RUNNING = T.let(:running, Handinger::Worker::Status::TaggedSymbol)
+        COMPLETED = T.let(:completed, Handinger::Worker::Status::TaggedSymbol)
+        PENDING = T.let(:pending, Handinger::Worker::Status::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Handinger::Worker::Status::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+
+      class Costs < Handinger::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Handinger::Worker::Costs, Handinger::Internal::AnyHash)
+          end
+
+        sig { returns(Float) }
+        attr_accessor :internal_cost_usd
+
+        sig { returns(Float) }
+        attr_accessor :model_cost_usd
+
+        sig { returns(Float) }
+        attr_accessor :sandbox_cost_usd
+
+        sig { returns(Float) }
+        attr_accessor :tool_cost_usd
+
+        sig do
+          params(
+            internal_cost_usd: Float,
+            model_cost_usd: Float,
+            sandbox_cost_usd: Float,
+            tool_cost_usd: Float
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          internal_cost_usd:,
+          model_cost_usd:,
+          sandbox_cost_usd:,
+          tool_cost_usd:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              internal_cost_usd: Float,
+              model_cost_usd: Float,
+              sandbox_cost_usd: Float,
+              tool_cost_usd: Float
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Usage < Handinger::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Handinger::Worker::Usage, Handinger::Internal::AnyHash)
+          end
+
+        sig { returns(Integer) }
+        attr_accessor :cache_read_tokens
+
+        sig { returns(Integer) }
+        attr_accessor :cache_write_tokens
+
+        sig { returns(Float) }
+        attr_accessor :cost_usd
+
+        sig { returns(Integer) }
+        attr_accessor :input_tokens
+
+        sig { returns(Integer) }
+        attr_accessor :output_tokens
+
+        sig { returns(Integer) }
+        attr_accessor :reasoning_tokens
+
+        sig { returns(Integer) }
+        attr_accessor :steps
+
+        sig { returns(Integer) }
+        attr_accessor :total_tokens
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :credits
+
+        sig { params(credits: Integer).void }
+        attr_writer :credits
+
+        sig do
+          params(
+            cache_read_tokens: Integer,
+            cache_write_tokens: Integer,
+            cost_usd: Float,
+            input_tokens: Integer,
+            output_tokens: Integer,
+            reasoning_tokens: Integer,
+            steps: Integer,
+            total_tokens: Integer,
+            credits: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          cache_read_tokens:,
+          cache_write_tokens:,
+          cost_usd:,
+          input_tokens:,
+          output_tokens:,
+          reasoning_tokens:,
+          steps:,
+          total_tokens:,
+          credits: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              cache_read_tokens: Integer,
+              cache_write_tokens: Integer,
+              cost_usd: Float,
+              input_tokens: Integer,
+              output_tokens: Integer,
+              reasoning_tokens: Integer,
+              steps: Integer,
+              total_tokens: Integer,
+              credits: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/handinger/models/worker_continue_params.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Handinger
+  module Models
+    class WorkerContinueParams < Handinger::Models::CreateWorker
+      extend Handinger::Internal::Type::RequestParameters::Converter
+      include Handinger::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Handinger::WorkerContinueParams, Handinger::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :worker_id
+
+      sig do
+        params(
+          worker_id: String,
+          request_options: Handinger::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(worker_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { worker_id: String, request_options: Handinger::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/handinger/models/worker_create_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Handinger
+  module Models
+    class WorkerCreateParams < Handinger::Models::CreateWorker
+      extend Handinger::Internal::Type::RequestParameters::Converter
+      include Handinger::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Handinger::WorkerCreateParams, Handinger::Internal::AnyHash)
+        end
+
+      sig do
+        params(request_options: Handinger::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: Handinger::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/handinger/models/worker_retrieve_email_params.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Handinger
+  module Models
+    class WorkerRetrieveEmailParams < Handinger::Internal::Type::BaseModel
+      extend Handinger::Internal::Type::RequestParameters::Converter
+      include Handinger::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Handinger::WorkerRetrieveEmailParams,
+            Handinger::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :worker_id
+
+      sig do
+        params(
+          worker_id: String,
+          request_options: Handinger::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(worker_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { worker_id: String, request_options: Handinger::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/handinger/models/worker_retrieve_email_response.rbi

@@ -0,0 +1,7 @@
+# typed: strong
+
+module Handinger
+  module Models
+    WorkerRetrieveEmailResponse = String
+  end
+end

data/rbi/handinger/models/worker_retrieve_file_params.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Handinger
+  module Models
+    class WorkerRetrieveFileParams < Handinger::Internal::Type::BaseModel
+      extend Handinger::Internal::Type::RequestParameters::Converter
+      include Handinger::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Handinger::WorkerRetrieveFileParams,
+            Handinger::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :worker_id
+
+      sig { returns(String) }
+      attr_accessor :file_path
+
+      sig do
+        params(
+          worker_id: String,
+          file_path: String,
+          request_options: Handinger::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(worker_id:, file_path:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          {
+            worker_id: String,
+            file_path: String,
+            request_options: Handinger::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end