handinger 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 944762f22d72ab9b304851aa18a7d34221ad5aa7d785e50f423b7b55ba09eaed
-  data.tar.gz: 3b9a81528fce0edaedbbe54f0e155c00d91635f24e4275b7f5b40984873a9fc6
+  metadata.gz: 03e43a5f9df9dc47be5da0cb54df3bbd3a9caa7b0f32e35981f4375b443774e4
+  data.tar.gz: 105454fa3a99cc7b62cf7241dd8dfaf72190f01f5208f171da41265cd577f8e3
 SHA512:
-  metadata.gz: 0435c4ab79474558084bd58c91cc6731d56f46e53827d2d0944427c94a8015c310afbd47b1daed618f19f37b375191c338a54c91004c86c316454095a0dc0936
-  data.tar.gz: 8ea226be6e29c61cd4745a1a774319c951c01684386450bf3115ff0be3097022682c799533683140f96bf23eb3a1ed511b1e0a63bfa083b6b9f802ec43b03194
+  metadata.gz: 8ac4f97f05e1380cffc03eccbbd7343e6cbe10d6d5c23a491f5e36a4e76c58febb0db9dbed58d627cfba60062feda20df24214fe87883f9ae10f968ac5fc65c4
+  data.tar.gz: 8b9fa07b57feebd1066bac295f738ab3bf66a239c68b6a988e895212774c5dda056fbb4a1dde66ff94d01c182a02cfd4a2da73c983d29a73665b75c06e675143

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.6.0 (2026-05-11)
+
+Full Changelog: [v0.5.0...v0.6.0](https://github.com/Ramensoft/handinger-ruby/compare/v0.5.0...v0.6.0)
+
+### Features
+
+* **api:** api update ([7c72012](https://github.com/Ramensoft/handinger-ruby/commit/7c72012ce98e7d806881133cff1c1625a1bfcdac))
+
+## 0.5.0 (2026-05-11)
+
+Full Changelog: [v0.4.0...v0.5.0](https://github.com/Ramensoft/handinger-ruby/compare/v0.4.0...v0.5.0)
+
+### Features
+
+* Duplicate workers ([95c3bab](https://github.com/Ramensoft/handinger-ruby/commit/95c3babf3d9e97ad4d0b410f90c601e3613bdbee))
+
+
+### Chores
+
+* remove custom code ([e9cece7](https://github.com/Ramensoft/handinger-ruby/commit/e9cece7ce4e8a03e89b558253048b19f2872f27a))
+
 ## 0.4.0 (2026-05-11)
 
 Full Changelog: [v0.3.0...v0.4.0](https://github.com/Ramensoft/handinger-ruby/compare/v0.3.0...v0.4.0)

data/README.md

@@ -17,7 +17,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "handinger", "~> 0.4.0"
+gem "handinger", "~> 0.6.0"
 ```
 
 <!-- x-release-please-end -->
@@ -32,7 +32,7 @@ handinger = Handinger::Client.new(
   api_key: ENV["HANDINGER_API_KEY"] # This is the default and can be omitted
 )
 
-worker = handinger.tasks.create(worker_id: "wrk_vk81XUHKHG-qr4")
+worker = handinger.tasks.create(input: "What's the weather today in Barcelona?", worker_id: "wrk_vk81XUHKHG-qr4")
 
 puts(worker.id)
 ```
@@ -43,7 +43,7 @@ When the library is unable to connect to the API, or if the API returns a non-su
 
 ```ruby
 begin
-  task = handinger.tasks.create(worker_id: "wrk_vk81XUHKHG-qr4")
+  task = handinger.tasks.create(input: "What's the weather today in Barcelona?", worker_id: "wrk_vk81XUHKHG-qr4")
 rescue Handinger::Errors::APIConnectionError => e
   puts("The server could not be reached")
   puts(e.cause)  # an underlying Exception, likely raised within `net/http`
@@ -86,7 +86,11 @@ handinger = Handinger::Client.new(
 )
 
 # Or, configure per-request:
-handinger.tasks.create(worker_id: "wrk_vk81XUHKHG-qr4", request_options: {max_retries: 5})
+handinger.tasks.create(
+  input: "What's the weather today in Barcelona?",
+  worker_id: "wrk_vk81XUHKHG-qr4",
+  request_options: {max_retries: 5}
+)
 ```
 
 ### Timeouts
@@ -100,7 +104,11 @@ handinger = Handinger::Client.new(
 )
 
 # Or, configure per-request:
-handinger.tasks.create(worker_id: "wrk_vk81XUHKHG-qr4", request_options: {timeout: 5})
+handinger.tasks.create(
+  input: "What's the weather today in Barcelona?",
+  worker_id: "wrk_vk81XUHKHG-qr4",
+  request_options: {timeout: 5}
+)
 ```
 
 On timeout, `Handinger::Errors::APITimeoutError` is raised.
@@ -132,6 +140,7 @@ Note: the `extra_` parameters of the same name overrides the documented paramete
 ```ruby
 worker =
   handinger.tasks.create(
+    input: "What's the weather today in Barcelona?",
     worker_id: "wrk_vk81XUHKHG-qr4",
     request_options: {
       extra_query: {my_query_parameter: value},
@@ -178,17 +187,20 @@ This library provides comprehensive [RBI](https://sorbet.org/docs/rbi) definitio
 You can provide typesafe request parameters like so:
 
 ```ruby
-handinger.tasks.create(worker_id: "wrk_vk81XUHKHG-qr4")
+handinger.tasks.create(input: "What's the weather today in Barcelona?", worker_id: "wrk_vk81XUHKHG-qr4")
 ```
 
 Or, equivalently:
 
 ```ruby
 # Hashes work, but are not typesafe:
-handinger.tasks.create(worker_id: "wrk_vk81XUHKHG-qr4")
+handinger.tasks.create(input: "What's the weather today in Barcelona?", worker_id: "wrk_vk81XUHKHG-qr4")
 
 # You can also splat a full Params class:
-params = Handinger::TaskCreateParams.new(worker_id: "wrk_vk81XUHKHG-qr4")
+params = Handinger::TaskCreateParams.new(
+  input: "What's the weather today in Barcelona?",
+  worker_id: "wrk_vk81XUHKHG-qr4"
+)
 handinger.tasks.create(**params)
 ```
 

data/lib/handinger/client.rb

@@ -57,7 +57,7 @@ module Handinger
       initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
       max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY
     )
-      base_url ||= "https://v3.handinger.com"
+      base_url ||= "https://handinger.com"
 
       if api_key.nil?
         raise ArgumentError.new("api_key is required, and can be set via environ: \"HANDINGER_API_KEY\"")

data/lib/handinger/models/create_task.rb

@@ -2,12 +2,21 @@
 
 module Handinger
   module Models
-    class CreateTask < Handinger::Models::CreateWorker
-      # @!attribute worker_id
-      #   Worker id the task belongs to.
+    class CreateTask < Handinger::Internal::Type::BaseModel
+      # @!attribute input
       #
       #   @return [String]
-      required :worker_id, String, api_name: :workerId
+      required :input, String
+
+      # @!attribute budget
+      #
+      #   @return [Symbol, Handinger::Models::CreateTask::Budget, nil]
+      optional :budget, enum: -> { Handinger::CreateTask::Budget }
+
+      # @!attribute stream
+      #
+      #   @return [Boolean, nil]
+      optional :stream, Handinger::Internal::Type::Boolean
 
       # @!attribute task_id
       #   Optional client-provided task id. Reuse this id to add turns to an existing
@@ -16,13 +25,39 @@ module Handinger
       #   @return [String, nil]
       optional :task_id, String, api_name: :taskId
 
-      # @!method initialize(worker_id:, task_id: nil)
+      # @!attribute worker_id
+      #   Worker id the task belongs to. If omitted, a new worker is created on-the-fly
+      #   using the input as instructions.
+      #
+      #   @return [String, nil]
+      optional :worker_id, String, api_name: :workerId
+
+      # @!method initialize(input:, budget: nil, stream: nil, task_id: nil, worker_id: nil)
       #   Some parameter documentations has been truncated, see
       #   {Handinger::Models::CreateTask} for more details.
       #
-      #   @param worker_id [String] Worker id the task belongs to.
+      #   @param input [String]
+      #
+      #   @param budget [Symbol, Handinger::Models::CreateTask::Budget]
+      #
+      #   @param stream [Boolean]
       #
       #   @param task_id [String] Optional client-provided task id. Reuse this id to add turns to an existing task
+      #
+      #   @param worker_id [String] Worker id the task belongs to. If omitted, a new worker is created on-the-fly us
+
+      # @see Handinger::Models::CreateTask#budget
+      module Budget
+        extend Handinger::Internal::Type::Enum
+
+        LOW = :low
+        STANDARD = :standard
+        HIGH = :high
+        UNLIMITED = :unlimited
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
     end
   end
 end

data/lib/handinger/models/worker.rb

@@ -41,8 +41,8 @@ module Handinger
 
       # @!attribute object
       #
-      #   @return [Symbol, Handinger::Models::Worker::Object]
-      required :object, enum: -> { Handinger::Worker::Object }
+      #   @return [Symbol, :worker]
+      required :object, const: :worker
 
       # @!attribute output
       #
@@ -87,7 +87,7 @@ module Handinger
       #   @return [Handinger::Models::Worker::Usage, nil]
       optional :usage, -> { Handinger::Worker::Usage }
 
-      # @!method initialize(id:, created_at:, error:, files:, incomplete_details:, messages:, metadata:, object:, output:, output_text:, running:, sources:, status:, structured_output:, url:, usage: nil)
+      # @!method initialize(id:, created_at:, error:, files:, incomplete_details:, messages:, metadata:, output:, output_text:, running:, sources:, status:, structured_output:, url:, usage: nil, object: :worker)
       #   @param id [String]
       #
       #   @param created_at [Integer, nil]
@@ -102,8 +102,6 @@ module Handinger
       #
       #   @param metadata [Hash{Symbol=>Object}]
       #
-      #   @param object [Symbol, Handinger::Models::Worker::Object]
-      #
       #   @param output [Array<Handinger::Models::Worker::Output>]
       #
       #   @param output_text [String]
@@ -119,6 +117,8 @@ module Handinger
       #   @param url [String] Web URL of the worker in the Handinger dashboard.
       #
       #   @param usage [Handinger::Models::Worker::Usage]
+      #
+      #   @param object [Symbol, :worker]
 
       class File < Handinger::Internal::Type::BaseModel
         # @!attribute filename
@@ -142,16 +142,6 @@ module Handinger
         #   @param url [String]
       end
 
-      # @see Handinger::Models::Worker#object
-      module Object
-        extend Handinger::Internal::Type::Enum
-
-        WORKER = :worker
-
-        # @!method self.values
-        #   @return [Array<Symbol>]
-      end
-
       class Output < Handinger::Internal::Type::BaseModel
         # @!attribute id
         #
@@ -165,25 +155,25 @@ module Handinger
 
         # @!attribute role
         #
-        #   @return [Symbol, Handinger::Models::Worker::Output::Role]
-        required :role, enum: -> { Handinger::Worker::Output::Role }
+        #   @return [Symbol, :assistant]
+        required :role, const: :assistant
 
         # @!attribute status
         #
-        #   @return [Symbol, Handinger::Models::Worker::Output::Status]
-        required :status, enum: -> { Handinger::Worker::Output::Status }
+        #   @return [Symbol, :completed]
+        required :status, const: :completed
 
         # @!attribute type
         #
-        #   @return [Symbol, Handinger::Models::Worker::Output::Type]
-        required :type, enum: -> { Handinger::Worker::Output::Type }
+        #   @return [Symbol, :message]
+        required :type, const: :message
 
-        # @!method initialize(id:, content:, role:, status:, type:)
+        # @!method initialize(id:, content:, role: :assistant, status: :completed, type: :message)
         #   @param id [String]
         #   @param content [Array<Handinger::Models::Worker::Output::Content>]
-        #   @param role [Symbol, Handinger::Models::Worker::Output::Role]
-        #   @param status [Symbol, Handinger::Models::Worker::Output::Status]
-        #   @param type [Symbol, Handinger::Models::Worker::Output::Type]
+        #   @param role [Symbol, :assistant]
+        #   @param status [Symbol, :completed]
+        #   @param type [Symbol, :message]
 
         class Content < Handinger::Internal::Type::BaseModel
           # @!attribute text
@@ -193,52 +183,12 @@ module Handinger
 
           # @!attribute type
           #
-          #   @return [Symbol, Handinger::Models::Worker::Output::Content::Type]
-          required :type, enum: -> { Handinger::Worker::Output::Content::Type }
+          #   @return [Symbol, :output_text]
+          required :type, const: :output_text
 
-          # @!method initialize(text:, type:)
+          # @!method initialize(text:, type: :output_text)
           #   @param text [String]
-          #   @param type [Symbol, Handinger::Models::Worker::Output::Content::Type]
-
-          # @see Handinger::Models::Worker::Output::Content#type
-          module Type
-            extend Handinger::Internal::Type::Enum
-
-            OUTPUT_TEXT = :output_text
-
-            # @!method self.values
-            #   @return [Array<Symbol>]
-          end
-        end
-
-        # @see Handinger::Models::Worker::Output#role
-        module Role
-          extend Handinger::Internal::Type::Enum
-
-          ASSISTANT = :assistant
-
-          # @!method self.values
-          #   @return [Array<Symbol>]
-        end
-
-        # @see Handinger::Models::Worker::Output#status
-        module Status
-          extend Handinger::Internal::Type::Enum
-
-          COMPLETED = :completed
-
-          # @!method self.values
-          #   @return [Array<Symbol>]
-        end
-
-        # @see Handinger::Models::Worker::Output#type
-        module Type
-          extend Handinger::Internal::Type::Enum
-
-          MESSAGE = :message
-
-          # @!method self.values
-          #   @return [Array<Symbol>]
+          #   @param type [Symbol, :output_text]
         end
       end
 
@@ -255,29 +205,19 @@ module Handinger
 
         # @!attribute type
         #
-        #   @return [Symbol, Handinger::Models::Worker::Source::Type]
-        required :type, enum: -> { Handinger::Worker::Source::Type }
+        #   @return [Symbol, :url]
+        required :type, const: :url
 
         # @!attribute url
         #
         #   @return [String]
         required :url, String
 
-        # @!method initialize(id:, title:, type:, url:)
+        # @!method initialize(id:, title:, url:, type: :url)
         #   @param id [String]
         #   @param title [String, nil]
-        #   @param type [Symbol, Handinger::Models::Worker::Source::Type]
         #   @param url [String]
-
-        # @see Handinger::Models::Worker::Source#type
-        module Type
-          extend Handinger::Internal::Type::Enum
-
-          URL = :url
-
-          # @!method self.values
-          #   @return [Array<Symbol>]
-        end
+        #   @param type [Symbol, :url]
       end
 
       # @see Handinger::Models::Worker#status

data/lib/handinger/resources/tasks.rb

@@ -12,23 +12,17 @@ module Handinger
       # `multipart/form-data` to attach files; the bytes are bootstrapped into the
       # worker's workspace before the task starts.
       #
-      # @overload create(worker_id:, instructions: nil, output_schema: nil, prompt: nil, summary: nil, task_id: nil, title: nil, visibility: nil, request_options: {})
+      # @overload create(input:, budget: nil, stream: nil, task_id: nil, worker_id: nil, request_options: {})
       #
-      # @param worker_id [String] Worker id the task belongs to.
+      # @param input [String]
       #
-      # @param instructions [String] Persistent system prompt the worker uses for every task it runs.
+      # @param budget [Symbol, Handinger::Models::CreateTask::Budget]
       #
-      # @param output_schema [Hash{Symbol=>Object}] Optional JSON Schema (Draft-07) describing the structured object the worker must
-      #
-      # @param prompt [String] Natural-language description of the worker to use for AI-generated instructions
-      #
-      # @param summary [String] Short one-line description of the worker's purpose. Auto-generated when omitted
+      # @param stream [Boolean]
       #
       # @param task_id [String] Optional client-provided task id. Reuse this id to add turns to an existing task
       #
-      # @param title [String] Optional display name. When omitted, Handinger assigns a random dog-themed name.
-      #
-      # @param visibility [Symbol, Handinger::Models::CreateTask::Visibility] `public` (default) is visible to all org members. `private` is only visible to i
+      # @param worker_id [String] Worker id the task belongs to. If omitted, a new worker is created on-the-fly us
       #
       # @param request_options [Handinger::RequestOptions, Hash{Symbol=>Object}, nil]
       #

data/lib/handinger/resources/workers.rb

@@ -111,9 +111,9 @@ module Handinger
         )
       end
 
-      # Permanently delete a worker template along with its tasks, turns, files,
-      # schedules, and integrations. This action is not reversible. Only the worker
-      # creator can delete a worker.
+      # Soft-delete a worker template so it no longer appears in list or retrieve
+      # endpoints. Tasks, turns, files, schedules, and integrations remain in the
+      # database for analytics. Only the worker creator can delete a worker.
       #
       # @overload delete(worker_id, request_options: {})
       #

data/lib/handinger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Handinger
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/handinger.rb

@@ -52,8 +52,8 @@ require_relative "handinger/errors"
 require_relative "handinger/internal/transport/base_client"
 require_relative "handinger/internal/transport/pooled_net_requester"
 require_relative "handinger/client"
-require_relative "handinger/models/create_worker"
 require_relative "handinger/models/create_task"
+require_relative "handinger/models/create_worker"
 require_relative "handinger/models/update_worker"
 require_relative "handinger/models/delete_task_response"
 require_relative "handinger/models/delete_worker_response"

data/rbi/handinger/models/create_task.rbi

@@ -2,15 +2,26 @@
 
 module Handinger
   module Models
-    class CreateTask < Handinger::Models::CreateWorker
+    class CreateTask < Handinger::Internal::Type::BaseModel
       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
+      attr_accessor :input
+
+      sig { returns(T.nilable(Handinger::CreateTask::Budget::OrSymbol)) }
+      attr_reader :budget
+
+      sig { params(budget: Handinger::CreateTask::Budget::OrSymbol).void }
+      attr_writer :budget
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :stream
+
+      sig { params(stream: T::Boolean).void }
+      attr_writer :stream
 
       # Optional client-provided task id. Reuse this id to add turns to an existing
       # task.
@@ -20,21 +31,71 @@ module Handinger
       sig { params(task_id: String).void }
       attr_writer :task_id
 
+      # Worker id the task belongs to. If omitted, a new worker is created on-the-fly
+      # using the input as instructions.
+      sig { returns(T.nilable(String)) }
+      attr_reader :worker_id
+
+      sig { params(worker_id: String).void }
+      attr_writer :worker_id
+
       sig do
-        params(worker_id: String, task_id: String).returns(T.attached_class)
+        params(
+          input: String,
+          budget: Handinger::CreateTask::Budget::OrSymbol,
+          stream: T::Boolean,
+          task_id: String,
+          worker_id: String
+        ).returns(T.attached_class)
       end
       def self.new(
-        # Worker id the task belongs to.
-        worker_id:,
+        input:,
+        budget: nil,
+        stream: nil,
         # Optional client-provided task id. Reuse this id to add turns to an existing
         # task.
-        task_id: nil
+        task_id: nil,
+        # Worker id the task belongs to. If omitted, a new worker is created on-the-fly
+        # using the input as instructions.
+        worker_id: nil
       )
       end
 
-      sig { override.returns({ worker_id: String, task_id: String }) }
+      sig do
+        override.returns(
+          {
+            input: String,
+            budget: Handinger::CreateTask::Budget::OrSymbol,
+            stream: T::Boolean,
+            task_id: String,
+            worker_id: String
+          }
+        )
+      end
       def to_hash
       end
+
+      module Budget
+        extend Handinger::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Handinger::CreateTask::Budget) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        LOW = T.let(:low, Handinger::CreateTask::Budget::TaggedSymbol)
+        STANDARD = T.let(:standard, Handinger::CreateTask::Budget::TaggedSymbol)
+        HIGH = T.let(:high, Handinger::CreateTask::Budget::TaggedSymbol)
+        UNLIMITED =
+          T.let(:unlimited, Handinger::CreateTask::Budget::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Handinger::CreateTask::Budget::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
     end
   end
 end

data/rbi/handinger/models/worker.rbi

@@ -27,7 +27,7 @@ module Handinger
       sig { returns(T::Hash[Symbol, T.anything]) }
       attr_accessor :metadata
 
-      sig { returns(Handinger::Worker::Object::TaggedSymbol) }
+      sig { returns(Symbol) }
       attr_accessor :object
 
       sig { returns(T::Array[Handinger::Worker::Output]) }
@@ -67,7 +67,6 @@ module Handinger
           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,
@@ -75,7 +74,8 @@ module Handinger
           status: Handinger::Worker::Status::OrSymbol,
           structured_output: T.nilable(T::Hash[Symbol, T.anything]),
           url: String,
-          usage: Handinger::Worker::Usage::OrHash
+          usage: Handinger::Worker::Usage::OrHash,
+          object: Symbol
         ).returns(T.attached_class)
       end
       def self.new(
@@ -86,7 +86,6 @@ module Handinger
         incomplete_details:,
         messages:,
         metadata:,
-        object:,
         output:,
         output_text:,
         running:,
@@ -95,7 +94,8 @@ module Handinger
         structured_output:,
         # Web URL of the worker in the Handinger dashboard.
         url:,
-        usage: nil
+        usage: nil,
+        object: :worker
       )
       end
 
@@ -109,7 +109,7 @@ module Handinger
             incomplete_details: NilClass,
             messages: T::Array[T.anything],
             metadata: T::Hash[Symbol, T.anything],
-            object: Handinger::Worker::Object::TaggedSymbol,
+            object: Symbol,
             output: T::Array[Handinger::Worker::Output],
             output_text: String,
             running: T::Boolean,
@@ -158,21 +158,6 @@ module Handinger
         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
@@ -185,25 +170,31 @@ module Handinger
         sig { returns(T::Array[Handinger::Worker::Output::Content]) }
         attr_accessor :content
 
-        sig { returns(Handinger::Worker::Output::Role::TaggedSymbol) }
+        sig { returns(Symbol) }
         attr_accessor :role
 
-        sig { returns(Handinger::Worker::Output::Status::TaggedSymbol) }
+        sig { returns(Symbol) }
         attr_accessor :status
 
-        sig { returns(Handinger::Worker::Output::Type::TaggedSymbol) }
+        sig { returns(Symbol) }
         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
+            role: Symbol,
+            status: Symbol,
+            type: Symbol
           ).returns(T.attached_class)
         end
-        def self.new(id:, content:, role:, status:, type:)
+        def self.new(
+          id:,
+          content:,
+          role: :assistant,
+          status: :completed,
+          type: :message
+        )
         end
 
         sig do
@@ -211,9 +202,9 @@ module Handinger
             {
               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
+              role: Symbol,
+              status: Symbol,
+              type: Symbol
             }
           )
         end
@@ -232,111 +223,16 @@ module Handinger
           sig { returns(String) }
           attr_accessor :text
 
-          sig do
-            returns(Handinger::Worker::Output::Content::Type::TaggedSymbol)
-          end
+          sig { returns(Symbol) }
           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:)
+          sig { params(text: String, type: Symbol).returns(T.attached_class) }
+          def self.new(text:, type: :output_text)
           end
 
-          sig do
-            override.returns(
-              {
-                text: String,
-                type: Handinger::Worker::Output::Content::Type::TaggedSymbol
-              }
-            )
-          end
+          sig { override.returns({ text: String, type: Symbol }) }
           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
 
@@ -352,7 +248,7 @@ module Handinger
         sig { returns(T.nilable(String)) }
         attr_accessor :title
 
-        sig { returns(Handinger::Worker::Source::Type::TaggedSymbol) }
+        sig { returns(Symbol) }
         attr_accessor :type
 
         sig { returns(String) }
@@ -362,43 +258,20 @@ module Handinger
           params(
             id: String,
             title: T.nilable(String),
-            type: Handinger::Worker::Source::Type::OrSymbol,
-            url: String
+            url: String,
+            type: Symbol
           ).returns(T.attached_class)
         end
-        def self.new(id:, title:, type:, url:)
+        def self.new(id:, title:, url:, type: :url)
         end
 
         sig do
           override.returns(
-            {
-              id: String,
-              title: T.nilable(String),
-              type: Handinger::Worker::Source::Type::TaggedSymbol,
-              url: String
-            }
+            { id: String, title: T.nilable(String), type: Symbol, 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

data/rbi/handinger/resources/tasks.rbi

@@ -10,40 +10,24 @@ module Handinger
       # worker's workspace before the task starts.
       sig do
         params(
-          worker_id: String,
-          instructions: String,
-          output_schema: T::Hash[Symbol, T.anything],
-          prompt: String,
-          summary: String,
+          input: String,
+          budget: Handinger::CreateTask::Budget::OrSymbol,
+          stream: T::Boolean,
           task_id: String,
-          title: String,
-          visibility: Handinger::CreateTask::Visibility::OrSymbol,
+          worker_id: String,
           request_options: Handinger::RequestOptions::OrHash
         ).returns(Handinger::Worker)
       end
       def create(
-        # Worker id the task belongs to.
-        worker_id:,
-        # 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,
+        input:,
+        budget: nil,
+        stream: nil,
         # Optional client-provided task id. Reuse this id to add turns to an existing
         # task.
         task_id: 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,
+        # Worker id the task belongs to. If omitted, a new worker is created on-the-fly
+        # using the input as instructions.
+        worker_id: nil,
         request_options: {}
       )
       end

data/rbi/handinger/resources/workers.rbi

@@ -98,9 +98,9 @@ module Handinger
       )
       end
 
-      # Permanently delete a worker template along with its tasks, turns, files,
-      # schedules, and integrations. This action is not reversible. Only the worker
-      # creator can delete a worker.
+      # Soft-delete a worker template so it no longer appears in list or retrieve
+      # endpoints. Tasks, turns, files, schedules, and integrations remain in the
+      # database for analytics. Only the worker creator can delete a worker.
       sig do
         params(
           worker_id: String,

data/sig/handinger/models/create_task.rbs

@@ -1,19 +1,63 @@
 module Handinger
   module Models
-    type create_task = { worker_id: String, task_id: String }
+    type create_task =
+      {
+        input: String,
+        budget: Handinger::Models::CreateTask::budget,
+        stream: bool,
+        task_id: String,
+        worker_id: String
+      }
 
-    class CreateTask < Handinger::Models::CreateWorker
-      def worker_id: -> String
+    class CreateTask < Handinger::Internal::Type::BaseModel
+      attr_accessor input: String
 
-      def worker_id=: (String _) -> String
+      attr_reader budget: Handinger::Models::CreateTask::budget?
 
-      def task_id: -> String?
+      def budget=: (
+        Handinger::Models::CreateTask::budget
+      ) -> Handinger::Models::CreateTask::budget
 
-      def task_id=: (String _) -> String
+      attr_reader stream: bool?
 
-      def initialize: (worker_id: String, ?task_id: String) -> void
+      def stream=: (bool) -> bool
 
-      def to_hash: -> { worker_id: String, task_id: String }
+      attr_reader task_id: String?
+
+      def task_id=: (String) -> String
+
+      attr_reader worker_id: String?
+
+      def worker_id=: (String) -> String
+
+      def initialize: (
+        input: String,
+        ?budget: Handinger::Models::CreateTask::budget,
+        ?stream: bool,
+        ?task_id: String,
+        ?worker_id: String
+      ) -> void
+
+      def to_hash: -> {
+        input: String,
+        budget: Handinger::Models::CreateTask::budget,
+        stream: bool,
+        task_id: String,
+        worker_id: String
+      }
+
+      type budget = :low | :standard | :high | :unlimited
+
+      module Budget
+        extend Handinger::Internal::Type::Enum
+
+        LOW: :low
+        STANDARD: :standard
+        HIGH: :high
+        UNLIMITED: :unlimited
+
+        def self?.values: -> ::Array[Handinger::Models::CreateTask::budget]
+      end
     end
   end
 end

data/sig/handinger/models/worker.rbs

@@ -9,7 +9,7 @@ module Handinger
         incomplete_details: nil,
         messages: ::Array[top],
         metadata: ::Hash[Symbol, top],
-        object: Handinger::Models::Worker::object,
+        object: :worker,
         output: ::Array[Handinger::Worker::Output],
         output_text: String,
         running: bool,
@@ -35,7 +35,7 @@ module Handinger
 
       attr_accessor metadata: ::Hash[Symbol, top]
 
-      attr_accessor object: Handinger::Models::Worker::object
+      attr_accessor object: :worker
 
       attr_accessor output: ::Array[Handinger::Worker::Output]
 
@@ -63,7 +63,6 @@ module Handinger
         incomplete_details: nil,
         messages: ::Array[top],
         metadata: ::Hash[Symbol, top],
-        object: Handinger::Models::Worker::object,
         output: ::Array[Handinger::Worker::Output],
         output_text: String,
         running: bool,
@@ -71,7 +70,8 @@ module Handinger
         status: Handinger::Models::Worker::status,
         structured_output: ::Hash[Symbol, top]?,
         url: String,
-        ?usage: Handinger::Worker::Usage
+        ?usage: Handinger::Worker::Usage,
+        ?object: :worker
       ) -> void
 
       def to_hash: -> {
@@ -82,7 +82,7 @@ module Handinger
         incomplete_details: nil,
         messages: ::Array[top],
         metadata: ::Hash[Symbol, top],
-        object: Handinger::Models::Worker::object,
+        object: :worker,
         output: ::Array[Handinger::Worker::Output],
         output_text: String,
         running: bool,
@@ -111,23 +111,13 @@ module Handinger
         def to_hash: -> { filename: String?, media_type: String, url: String }
       end
 
-      type object = :worker
-
-      module Object
-        extend Handinger::Internal::Type::Enum
-
-        WORKER: :worker
-
-        def self?.values: -> ::Array[Handinger::Models::Worker::object]
-      end
-
       type output =
         {
           id: String,
           content: ::Array[Handinger::Worker::Output::Content],
-          role: Handinger::Models::Worker::Output::role,
-          status: Handinger::Models::Worker::Output::status,
-          type: Handinger::Models::Worker::Output::type_
+          role: :assistant,
+          status: :completed,
+          type: :message
         }
 
       class Output < Handinger::Internal::Type::BaseModel
@@ -135,131 +125,60 @@ module Handinger
 
         attr_accessor content: ::Array[Handinger::Worker::Output::Content]
 
-        attr_accessor role: Handinger::Models::Worker::Output::role
+        attr_accessor role: :assistant
 
-        attr_accessor status: Handinger::Models::Worker::Output::status
+        attr_accessor status: :completed
 
-        attr_accessor type: Handinger::Models::Worker::Output::type_
+        attr_accessor type: :message
 
         def initialize: (
           id: String,
           content: ::Array[Handinger::Worker::Output::Content],
-          role: Handinger::Models::Worker::Output::role,
-          status: Handinger::Models::Worker::Output::status,
-          type: Handinger::Models::Worker::Output::type_
+          ?role: :assistant,
+          ?status: :completed,
+          ?type: :message
         ) -> void
 
         def to_hash: -> {
           id: String,
           content: ::Array[Handinger::Worker::Output::Content],
-          role: Handinger::Models::Worker::Output::role,
-          status: Handinger::Models::Worker::Output::status,
-          type: Handinger::Models::Worker::Output::type_
+          role: :assistant,
+          status: :completed,
+          type: :message
         }
 
-        type content =
-          {
-            text: String,
-            type: Handinger::Models::Worker::Output::Content::type_
-          }
+        type content = { text: String, type: :output_text }
 
         class Content < Handinger::Internal::Type::BaseModel
           attr_accessor text: String
 
-          attr_accessor type: Handinger::Models::Worker::Output::Content::type_
+          attr_accessor type: :output_text
 
-          def initialize: (
-            text: String,
-            type: Handinger::Models::Worker::Output::Content::type_
-          ) -> void
+          def initialize: (text: String, ?type: :output_text) -> void
 
-          def to_hash: -> {
-            text: String,
-            type: Handinger::Models::Worker::Output::Content::type_
-          }
-
-          type type_ = :output_text
-
-          module Type
-            extend Handinger::Internal::Type::Enum
-
-            OUTPUT_TEXT: :output_text
-
-            def self?.values: -> ::Array[Handinger::Models::Worker::Output::Content::type_]
-          end
-        end
-
-        type role = :assistant
-
-        module Role
-          extend Handinger::Internal::Type::Enum
-
-          ASSISTANT: :assistant
-
-          def self?.values: -> ::Array[Handinger::Models::Worker::Output::role]
-        end
-
-        type status = :completed
-
-        module Status
-          extend Handinger::Internal::Type::Enum
-
-          COMPLETED: :completed
-
-          def self?.values: -> ::Array[Handinger::Models::Worker::Output::status]
-        end
-
-        type type_ = :message
-
-        module Type
-          extend Handinger::Internal::Type::Enum
-
-          MESSAGE: :message
-
-          def self?.values: -> ::Array[Handinger::Models::Worker::Output::type_]
+          def to_hash: -> { text: String, type: :output_text }
         end
       end
 
-      type source =
-        {
-          id: String,
-          title: String?,
-          type: Handinger::Models::Worker::Source::type_,
-          url: String
-        }
+      type source = { id: String, title: String?, type: :url, url: String }
 
       class Source < Handinger::Internal::Type::BaseModel
         attr_accessor id: String
 
         attr_accessor title: String?
 
-        attr_accessor type: Handinger::Models::Worker::Source::type_
+        attr_accessor type: :url
 
         attr_accessor url: String
 
         def initialize: (
           id: String,
           title: String?,
-          type: Handinger::Models::Worker::Source::type_,
-          url: String
+          url: String,
+          ?type: :url
         ) -> void
 
-        def to_hash: -> {
-          id: String,
-          title: String?,
-          type: Handinger::Models::Worker::Source::type_,
-          url: String
-        }
-
-        type type_ = :url
-
-        module Type
-          extend Handinger::Internal::Type::Enum
-
-          URL: :url
-
-          def self?.values: -> ::Array[Handinger::Models::Worker::Source::type_]
-        end
+        def to_hash: -> { id: String, title: String?, type: :url, url: String }
       end
 
       type status = :running | :completed | :pending

data/sig/handinger/resources/tasks.rbs

@@ -2,14 +2,11 @@ module Handinger
   module Resources
     class Tasks
       def create: (
-        worker_id: String,
-        ?instructions: String,
-        ?output_schema: ::Hash[Symbol, top],
-        ?prompt: String,
-        ?summary: String,
+        input: String,
+        ?budget: Handinger::Models::CreateTask::budget,
+        ?stream: bool,
         ?task_id: String,
-        ?title: String,
-        ?visibility: Handinger::Models::CreateTask::visibility,
+        ?worker_id: String,
         ?request_options: Handinger::request_opts
       ) -> Handinger::Worker
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: handinger
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Handinger