handinger 0.1.0 → 0.3.0

data/rbi/handinger/models/task.rbi

@@ -0,0 +1,160 @@
+# typed: strong
+
+module Handinger
+  module Models
+    class Task < Handinger::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Handinger::Task, Handinger::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :completed_at
+
+      sig { returns(String) }
+      attr_accessor :created_at
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :created_by_user_id
+
+      sig { returns(String) }
+      attr_accessor :organization_id
+
+      sig { returns(Handinger::Task::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      sig { returns(String) }
+      attr_accessor :title
+
+      sig { returns(Handinger::Task::Totals) }
+      attr_reader :totals
+
+      sig { params(totals: Handinger::Task::Totals::OrHash).void }
+      attr_writer :totals
+
+      sig { returns(Handinger::Task::TriggeredBy::TaggedSymbol) }
+      attr_accessor :triggered_by
+
+      sig { returns(String) }
+      attr_accessor :worker_id
+
+      sig do
+        params(
+          id: String,
+          completed_at: T.nilable(String),
+          created_at: String,
+          created_by_user_id: T.nilable(String),
+          organization_id: String,
+          status: Handinger::Task::Status::OrSymbol,
+          title: String,
+          totals: Handinger::Task::Totals::OrHash,
+          triggered_by: Handinger::Task::TriggeredBy::OrSymbol,
+          worker_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        completed_at:,
+        created_at:,
+        created_by_user_id:,
+        organization_id:,
+        status:,
+        title:,
+        totals:,
+        triggered_by:,
+        worker_id:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            completed_at: T.nilable(String),
+            created_at: String,
+            created_by_user_id: T.nilable(String),
+            organization_id: String,
+            status: Handinger::Task::Status::TaggedSymbol,
+            title: String,
+            totals: Handinger::Task::Totals,
+            triggered_by: Handinger::Task::TriggeredBy::TaggedSymbol,
+            worker_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Status
+        extend Handinger::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Handinger::Task::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING = T.let(:pending, Handinger::Task::Status::TaggedSymbol)
+        RUNNING = T.let(:running, Handinger::Task::Status::TaggedSymbol)
+        COMPLETED = T.let(:completed, Handinger::Task::Status::TaggedSymbol)
+        ERROR = T.let(:error, Handinger::Task::Status::TaggedSymbol)
+        ABORTED = T.let(:aborted, Handinger::Task::Status::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Handinger::Task::Status::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+
+      class Totals < Handinger::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Handinger::Task::Totals, Handinger::Internal::AnyHash)
+          end
+
+        sig { returns(Float) }
+        attr_accessor :credits
+
+        sig { returns(Float) }
+        attr_accessor :duration_ms
+
+        sig { returns(Float) }
+        attr_accessor :turn_count
+
+        sig do
+          params(credits: Float, duration_ms: Float, turn_count: Float).returns(
+            T.attached_class
+          )
+        end
+        def self.new(credits:, duration_ms:, turn_count:)
+        end
+
+        sig do
+          override.returns(
+            { credits: Float, duration_ms: Float, turn_count: Float }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      module TriggeredBy
+        extend Handinger::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Handinger::Task::TriggeredBy) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        API = T.let(:api, Handinger::Task::TriggeredBy::TaggedSymbol)
+        EMAIL = T.let(:email, Handinger::Task::TriggeredBy::TaggedSymbol)
+        SCHEDULE = T.let(:schedule, Handinger::Task::TriggeredBy::TaggedSymbol)
+        UI = T.let(:ui, Handinger::Task::TriggeredBy::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Handinger::Task::TriggeredBy::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/handinger/models/task_create_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Handinger
+  module Models
+    class TaskCreateParams < Handinger::Models::CreateTask
+      extend Handinger::Internal::Type::RequestParameters::Converter
+      include Handinger::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Handinger::TaskCreateParams, 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/task_delete_params.rbi

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

data/rbi/handinger/models/task_retrieve_params.rbi

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

data/rbi/handinger/models/task_with_turns.rbi

@@ -0,0 +1,149 @@
+# typed: strong
+
+module Handinger
+  module Models
+    class TaskWithTurns < Handinger::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Handinger::TaskWithTurns, Handinger::Internal::AnyHash)
+        end
+
+      sig { returns(Handinger::Task) }
+      attr_reader :task
+
+      sig { params(task: Handinger::Task::OrHash).void }
+      attr_writer :task
+
+      sig { returns(T::Array[Handinger::TaskWithTurns::Turn]) }
+      attr_accessor :turns
+
+      sig do
+        params(
+          task: Handinger::Task::OrHash,
+          turns: T::Array[Handinger::TaskWithTurns::Turn::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(task:, turns:)
+      end
+
+      sig do
+        override.returns(
+          {
+            task: Handinger::Task,
+            turns: T::Array[Handinger::TaskWithTurns::Turn]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Turn < Handinger::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Handinger::TaskWithTurns::Turn, Handinger::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :completed_at
+
+        sig { returns(Float) }
+        attr_accessor :credits
+
+        sig { returns(Integer) }
+        attr_accessor :duration_ms
+
+        sig { returns(String) }
+        attr_accessor :input
+
+        sig { returns(Integer) }
+        attr_accessor :input_tokens
+
+        sig { returns(String) }
+        attr_accessor :output_text
+
+        sig { returns(Integer) }
+        attr_accessor :output_tokens
+
+        sig { returns(String) }
+        attr_accessor :role
+
+        sig { returns(Integer) }
+        attr_accessor :seq
+
+        sig { returns(String) }
+        attr_accessor :started_at
+
+        sig { returns(String) }
+        attr_accessor :status
+
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_accessor :structured_output
+
+        sig { returns(String) }
+        attr_accessor :task_id
+
+        sig do
+          params(
+            id: String,
+            completed_at: T.nilable(String),
+            credits: Float,
+            duration_ms: Integer,
+            input: String,
+            input_tokens: Integer,
+            output_text: String,
+            output_tokens: Integer,
+            role: String,
+            seq: Integer,
+            started_at: String,
+            status: String,
+            structured_output: T.nilable(T::Hash[Symbol, T.anything]),
+            task_id: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          completed_at:,
+          credits:,
+          duration_ms:,
+          input:,
+          input_tokens:,
+          output_text:,
+          output_tokens:,
+          role:,
+          seq:,
+          started_at:,
+          status:,
+          structured_output:,
+          task_id:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              completed_at: T.nilable(String),
+              credits: Float,
+              duration_ms: Integer,
+              input: String,
+              input_tokens: Integer,
+              output_text: String,
+              output_tokens: Integer,
+              role: String,
+              seq: Integer,
+              started_at: String,
+              status: String,
+              structured_output: T.nilable(T::Hash[Symbol, T.anything]),
+              task_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/handinger/models/update_worker.rbi

@@ -0,0 +1,112 @@
+# typed: strong
+
+module Handinger
+  module Models
+    class UpdateWorker < Handinger::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Handinger::UpdateWorker, Handinger::Internal::AnyHash)
+        end
+
+      # Replaces the persistent system prompt. Subsequent tasks pick up the new
+      # instructions immediately; in-flight tasks keep using the previous version.
+      sig { returns(T.nilable(String)) }
+      attr_reader :instructions
+
+      sig { params(instructions: String).void }
+      attr_writer :instructions
+
+      # Replace the worker's structured output schema. Pass `null` to clear it and
+      # return to free-form text responses.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :output_schema
+
+      # Replaces the worker's short one-line summary.
+      sig { returns(T.nilable(String)) }
+      attr_reader :summary
+
+      sig { params(summary: String).void }
+      attr_writer :summary
+
+      # New display name for the worker.
+      sig { returns(T.nilable(String)) }
+      attr_reader :title
+
+      sig { params(title: String).void }
+      attr_writer :title
+
+      # Change visibility between `public` (any org member can run tasks) and `private`
+      # (only invited members).
+      sig { returns(T.nilable(Handinger::UpdateWorker::Visibility::OrSymbol)) }
+      attr_reader :visibility
+
+      sig do
+        params(visibility: Handinger::UpdateWorker::Visibility::OrSymbol).void
+      end
+      attr_writer :visibility
+
+      sig do
+        params(
+          instructions: String,
+          output_schema: T.nilable(T::Hash[Symbol, T.anything]),
+          summary: String,
+          title: String,
+          visibility: Handinger::UpdateWorker::Visibility::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Replaces the persistent system prompt. Subsequent tasks pick up the new
+        # instructions immediately; in-flight tasks keep using the previous version.
+        instructions: nil,
+        # Replace the worker's structured output schema. Pass `null` to clear it and
+        # return to free-form text responses.
+        output_schema: nil,
+        # Replaces the worker's short one-line summary.
+        summary: nil,
+        # New display name for the worker.
+        title: nil,
+        # Change visibility between `public` (any org member can run tasks) and `private`
+        # (only invited members).
+        visibility: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            instructions: String,
+            output_schema: T.nilable(T::Hash[Symbol, T.anything]),
+            summary: String,
+            title: String,
+            visibility: Handinger::UpdateWorker::Visibility::OrSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Change visibility between `public` (any org member can run tasks) and `private`
+      # (only invited members).
+      module Visibility
+        extend Handinger::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Handinger::UpdateWorker::Visibility) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PUBLIC =
+          T.let(:public, Handinger::UpdateWorker::Visibility::TaggedSymbol)
+        PRIVATE =
+          T.let(:private, Handinger::UpdateWorker::Visibility::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Handinger::UpdateWorker::Visibility::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/handinger/models/worker.rbi

@@ -45,11 +45,8 @@ module Handinger
       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(T::Hash[Symbol, T.anything])) }
+      attr_accessor :structured_output
 
       sig { returns(T.nilable(Handinger::Worker::Usage)) }
       attr_reader :usage
@@ -72,7 +69,7 @@ module Handinger
           running: T::Boolean,
           sources: T::Array[Handinger::Worker::Source::OrHash],
           status: Handinger::Worker::Status::OrSymbol,
-          costs: T.nilable(Handinger::Worker::Costs::OrHash),
+          structured_output: T.nilable(T::Hash[Symbol, T.anything]),
           usage: Handinger::Worker::Usage::OrHash
         ).returns(T.attached_class)
       end
@@ -90,7 +87,7 @@ module Handinger
         running:,
         sources:,
         status:,
-        costs: nil,
+        structured_output:,
         usage: nil
       )
       end
@@ -111,7 +108,7 @@ module Handinger
             running: T::Boolean,
             sources: T::Array[Handinger::Worker::Source],
             status: Handinger::Worker::Status::TaggedSymbol,
-            costs: T.nilable(Handinger::Worker::Costs),
+            structured_output: T.nilable(T::Hash[Symbol, T.anything]),
             usage: Handinger::Worker::Usage
           }
         )
@@ -413,84 +410,12 @@ module Handinger
         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
 
@@ -504,49 +429,14 @@ module Handinger
         attr_writer :duration_ms
 
         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,
-            duration_ms: Integer
-          ).returns(T.attached_class)
+          params(credits: Integer, duration_ms: 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,
-          duration_ms: nil
-        )
+        def self.new(credits: nil, duration_ms: 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,
-              duration_ms: Integer
-            }
-          )
-        end
+        sig { override.returns({ credits: Integer, duration_ms: Integer }) }
         def to_hash
         end
       end