handinger 0.0.2 → 0.2.0

data/rbi/handinger/models/create_task.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Handinger
+  module Models
+    class CreateTask < Handinger::Models::CreateWorker
+      OrHash =
+        T.type_alias do
+          T.any(Handinger::CreateTask, Handinger::Internal::AnyHash)
+        end
+
+      # Worker id the task belongs to.
+      sig { returns(String) }
+      attr_accessor :worker_id
+
+      # Optional client-provided task id. Reuse this id to add turns to an existing
+      # task.
+      sig { returns(T.nilable(String)) }
+      attr_reader :task_id
+
+      sig { params(task_id: String).void }
+      attr_writer :task_id
+
+      sig do
+        params(worker_id: String, task_id: String).returns(T.attached_class)
+      end
+      def self.new(
+        # Worker id the task belongs to.
+        worker_id:,
+        # Optional client-provided task id. Reuse this id to add turns to an existing
+        # task.
+        task_id: nil
+      )
+      end
+
+      sig { override.returns({ worker_id: String, task_id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/handinger/models/create_worker.rbi

@@ -8,60 +8,118 @@ module Handinger
           T.any(Handinger::CreateWorker, Handinger::Internal::AnyHash)
         end
 
-      sig { returns(String) }
-      attr_accessor :input
+      # Persistent system prompt the worker uses for every task it runs.
+      sig { returns(T.nilable(String)) }
+      attr_reader :instructions
 
-      sig { returns(T.nilable(Handinger::CreateWorker::Budget::OrSymbol)) }
-      attr_reader :budget
+      sig { params(instructions: String).void }
+      attr_writer :instructions
 
-      sig { params(budget: Handinger::CreateWorker::Budget::OrSymbol).void }
-      attr_writer :budget
+      # Optional JSON Schema (Draft-07) describing the structured object the worker must
+      # produce. When set, every task response is validated against the schema and
+      # exposed as `structuredOutput`.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :output_schema
 
-      sig { returns(T.nilable(T::Boolean)) }
-      attr_reader :stream
+      sig { params(output_schema: T::Hash[Symbol, T.anything]).void }
+      attr_writer :output_schema
 
-      sig { params(stream: T::Boolean).void }
-      attr_writer :stream
+      # Natural-language description of the worker to use for AI-generated instructions
+      # when `instructions` is omitted.
+      sig { returns(T.nilable(String)) }
+      attr_reader :prompt
+
+      sig { params(prompt: String).void }
+      attr_writer :prompt
+
+      # Short one-line description of the worker's purpose. Auto-generated when omitted
+      # and a `prompt` is provided.
+      sig { returns(T.nilable(String)) }
+      attr_reader :summary
+
+      sig { params(summary: String).void }
+      attr_writer :summary
+
+      # Optional display name. When omitted, Handinger assigns a random dog-themed name.
+      sig { returns(T.nilable(String)) }
+      attr_reader :title
+
+      sig { params(title: String).void }
+      attr_writer :title
+
+      # `public` (default) is visible to all org members. `private` is only visible to
+      # invited members.
+      sig { returns(T.nilable(Handinger::CreateWorker::Visibility::OrSymbol)) }
+      attr_reader :visibility
+
+      sig do
+        params(visibility: Handinger::CreateWorker::Visibility::OrSymbol).void
+      end
+      attr_writer :visibility
 
       sig do
         params(
-          input: String,
-          budget: Handinger::CreateWorker::Budget::OrSymbol,
-          stream: T::Boolean
+          instructions: String,
+          output_schema: T::Hash[Symbol, T.anything],
+          prompt: String,
+          summary: String,
+          title: String,
+          visibility: Handinger::CreateWorker::Visibility::OrSymbol
         ).returns(T.attached_class)
       end
-      def self.new(input:, budget: nil, stream: nil)
+      def self.new(
+        # Persistent system prompt the worker uses for every task it runs.
+        instructions: nil,
+        # Optional JSON Schema (Draft-07) describing the structured object the worker must
+        # produce. When set, every task response is validated against the schema and
+        # exposed as `structuredOutput`.
+        output_schema: nil,
+        # Natural-language description of the worker to use for AI-generated instructions
+        # when `instructions` is omitted.
+        prompt: nil,
+        # Short one-line description of the worker's purpose. Auto-generated when omitted
+        # and a `prompt` is provided.
+        summary: nil,
+        # Optional display name. When omitted, Handinger assigns a random dog-themed name.
+        title: nil,
+        # `public` (default) is visible to all org members. `private` is only visible to
+        # invited members.
+        visibility: nil
+      )
       end
 
       sig do
         override.returns(
           {
-            input: String,
-            budget: Handinger::CreateWorker::Budget::OrSymbol,
-            stream: T::Boolean
+            instructions: String,
+            output_schema: T::Hash[Symbol, T.anything],
+            prompt: String,
+            summary: String,
+            title: String,
+            visibility: Handinger::CreateWorker::Visibility::OrSymbol
           }
         )
       end
       def to_hash
       end
 
-      module Budget
+      # `public` (default) is visible to all org members. `private` is only visible to
+      # invited members.
+      module Visibility
         extend Handinger::Internal::Type::Enum
 
         TaggedSymbol =
-          T.type_alias { T.all(Symbol, Handinger::CreateWorker::Budget) }
+          T.type_alias { T.all(Symbol, Handinger::CreateWorker::Visibility) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        LOW = T.let(:low, Handinger::CreateWorker::Budget::TaggedSymbol)
-        STANDARD =
-          T.let(:standard, Handinger::CreateWorker::Budget::TaggedSymbol)
-        HIGH = T.let(:high, Handinger::CreateWorker::Budget::TaggedSymbol)
-        UNLIMITED =
-          T.let(:unlimited, Handinger::CreateWorker::Budget::TaggedSymbol)
+        PUBLIC =
+          T.let(:public, Handinger::CreateWorker::Visibility::TaggedSymbol)
+        PRIVATE =
+          T.let(:private, Handinger::CreateWorker::Visibility::TaggedSymbol)
 
         sig do
           override.returns(
-            T::Array[Handinger::CreateWorker::Budget::TaggedSymbol]
+            T::Array[Handinger::CreateWorker::Visibility::TaggedSymbol]
           )
         end
         def self.values

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/{worker_continue_params.rbi → task_retrieve_params.rbi}

@@ -2,30 +2,30 @@
 
 module Handinger
   module Models
-    class WorkerContinueParams < Handinger::Models::CreateWorker
+    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::WorkerContinueParams, Handinger::Internal::AnyHash)
+          T.any(Handinger::TaskRetrieveParams, Handinger::Internal::AnyHash)
         end
 
       sig { returns(String) }
-      attr_accessor :worker_id
+      attr_accessor :task_id
 
       sig do
         params(
-          worker_id: String,
+          task_id: String,
           request_options: Handinger::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
-      def self.new(worker_id:, request_options: {})
+      def self.new(task_id:, request_options: {})
       end
 
       sig do
         override.returns(
-          { worker_id: String, request_options: Handinger::RequestOptions }
+          { task_id: String, request_options: Handinger::RequestOptions }
         )
       end
       def to_hash

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