hatchet-sdk 0.5.0 → 0.7.0

data/lib/hatchet/task.rb

@@ -68,6 +68,9 @@ module Hatchet
     # @return [Hatchet::EvictionPolicy, nil] Eviction policy for durable tasks
     attr_reader :eviction_policy
 
+    # @return [Hatchet::BatchTaskConfig, nil] Batch configuration, if this is a batch task
+    attr_reader :batch
+
     # @return [Proc, nil] The task execution block
     attr_reader :fn
 
@@ -112,6 +115,7 @@ module Hatchet
       skip_if: [],
       durable: false,
       eviction_policy: nil,
+      batch: nil,
       workflow: nil,
       client: nil,
       deps: nil,
@@ -131,6 +135,7 @@ module Hatchet
       @skip_if = skip_if
       @durable = durable
       @eviction_policy = eviction_policy
+      @batch = batch
       @workflow = workflow
       @client = client
       @deps = deps
@@ -191,6 +196,14 @@ module Hatchet
 
       opts[:is_durable] = @durable
 
+      # Batch tasks buffer many concurrent runs into a single execution; per-item retry
+      # semantics don't apply, so retries is always forced to 0, regardless of any retries
+      # the caller may have supplied.
+      if @batch
+        opts[:batch] = @batch.to_proto
+        opts[:retries] = 0
+      end
+
       ::V1::CreateTaskOpts.new(**opts)
     end
 

data/lib/hatchet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hatchet
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

data/lib/hatchet/worker/runner.rb

@@ -226,6 +226,11 @@ module Hatchet
       end
 
       def execute_task(action)
+        if batch_action?(action)
+          execute_batch_task(action)
+          return
+        end
+
         action_key = nil
         prepare_action_execution(action)
 
@@ -329,6 +334,114 @@ module Hatchet
         send_result(action, result)
       end
 
+      def batch_action?(action)
+        action.respond_to?(:action_type) && action.action_type == :START_BATCH
+      end
+
+      # Handles a START_BATCH action: invokes the registered batch task block once with
+      # every buffered item, then reports completion/failure back per-member (or, for
+      # broadcast batch tasks, the same result for every member) via send_batch_action_event.
+      def execute_batch_task(action)
+        task_key = action.action_id.downcase
+        task = @task_map[task_key]
+
+        unless task
+          @logger.error("No task found for action: #{task_key}")
+          return
+        end
+
+        batch_items = parse_batch_items(action)
+        send_batch_started(action, batch_items.keys)
+
+        ctx = build_context(action, task)
+
+        begin
+          result = task.call(batch_items, ctx)
+
+          # If the handler cancelled the batch (ctx.cancel), a CANCELLED batch event
+          # covering every member was already sent from within cancel itself. Don't also
+          # send a COMPLETED event for the same members afterward.
+          send_batch_result(action, task, batch_items, result) unless ctx.cancelled?
+        rescue StandardError => e
+          @logger.error("Error in batch task #{action.action_id}: #{e.message}")
+          send_batch_failure_for_all(action, batch_items.keys, e)
+        end
+      ensure
+        ContextVars.clear
+      end
+
+      def send_batch_started(action, member_ids)
+        items = member_ids.map { |id| { task_run_external_id: id } }
+        @dispatcher_client.send_batch_action_event(action: action, event_type: :STEP_EVENT_TYPE_STARTED, items: items)
+      rescue StandardError => e
+        @logger.warn("Failed to send batch STARTED event: #{e.message}")
+      end
+
+      def send_batch_result(action, task, batch_items, result)
+        if task.batch.broadcast_output
+          payload = JSON.generate(result.nil? ? {} : result)
+          items = batch_items.keys.map { |id| { task_run_external_id: id, event_payload: payload } }
+          @dispatcher_client.send_batch_action_event(action: action, event_type: :STEP_EVENT_TYPE_COMPLETED, items: items)
+          return
+        end
+
+        unless result.is_a?(Hash)
+          send_batch_failure_for_all(
+            action, batch_items.keys,
+            StandardError.new("batch task handler must return a Hash keyed by batch member id"),
+          )
+          return
+        end
+
+        missing = batch_items.keys - result.keys
+        extra = result.keys - batch_items.keys
+
+        if !missing.empty? || !extra.empty?
+          send_batch_failure_for_all(
+            action, batch_items.keys,
+            StandardError.new("batch task handler result keys do not match batch member ids (missing=#{missing}, extra=#{extra})"),
+          )
+          return
+        end
+
+        completed_items = []
+        failed_items = []
+
+        result.each do |id, value|
+          completed_items << { task_run_external_id: id, event_payload: JSON.generate(value) }
+        rescue StandardError => e
+          failed_items << { task_run_external_id: id, event_payload: JSON.generate({ "error" => e.message }) }
+        end
+
+        unless completed_items.empty?
+          @dispatcher_client.send_batch_action_event(action: action, event_type: :STEP_EVENT_TYPE_COMPLETED, items: completed_items)
+        end
+
+        return if failed_items.empty?
+
+        @dispatcher_client.send_batch_action_event(action: action, event_type: :STEP_EVENT_TYPE_FAILED, items: failed_items)
+      end
+
+      def send_batch_failure_for_all(action, member_ids, error)
+        payload = JSON.generate({ "error" => error.message })
+        items = member_ids.map { |id| { task_run_external_id: id, event_payload: payload, should_not_retry: true } }
+        @dispatcher_client.send_batch_action_event(action: action, event_type: :STEP_EVENT_TYPE_FAILED, items: items)
+      end
+
+      def parse_batch_items(action)
+        raw = action.respond_to?(:action_payload) ? action.action_payload : nil
+        return {} if raw.nil? || raw.to_s.empty?
+
+        parsed = JSON.parse(raw)
+        return {} unless parsed.is_a?(Hash)
+
+        parsed.each_with_object({}) do |(id, item), acc|
+          acc[id] = item.is_a?(Hash) && item["payload"].is_a?(Hash) ? (item["payload"]["input"] || {}) : {}
+        end
+      rescue JSON::ParserError
+        {}
+      end
+
       def action_key_for(action)
         "#{action.task_run_external_id}/#{action.retry_count}"
       end

data/lib/hatchet/workflow.rb

@@ -98,10 +98,23 @@ module Hatchet
       @id ||= resolve_workflow_id
     end
 
-    # Define a task within this workflow
+    # Define a task within this workflow. The block receives the workflow input
+    # and a {Context} object, and its return value (a Hash) becomes the task
+    # output.
     #
-    # @param name [Symbol, String] Task name
-    # @param opts [Hash] Task options (parents:, execution_timeout:, retries:, etc.)
+    # @param name [Symbol, String] The name of the task
+    # @option opts [Array<Task, Symbol>] :parents ([]) A list of tasks that are parents of the task. Note: parents must be defined before their children
+    # @option opts [Integer, String, nil] :execution_timeout (nil) The maximum time to wait for the task to complete, in seconds or as a duration string (e.g. "60s")
+    # @option opts [Integer, String, nil] :schedule_timeout (nil) The maximum time to wait for the task to be scheduled
+    # @option opts [Integer, nil] :retries (nil) The number of times to retry the task before failing
+    # @option opts [Float, nil] :backoff_factor (nil) The backoff factor for controlling exponential backoff in retries
+    # @option opts [Integer, nil] :backoff_max_seconds (nil) The maximum number of seconds to allow retries with exponential backoff to continue
+    # @option opts [Array<RateLimit>] :rate_limits ([]) A list of rate limit configurations for the task
+    # @option opts [ConcurrencyExpression, Array<ConcurrencyExpression>, nil] :concurrency (nil) A concurrency expression (or list of them) controlling the concurrency settings for this task
+    # @option opts [Hash, nil] :desired_worker_labels (nil) A hash of desired worker labels that determine to which worker the task should be assigned
+    # @option opts [Array] :wait_for ([]) A list of conditions that must be met before the task can run
+    # @option opts [Array] :skip_if ([]) A list of conditions that, if met, will cause the task to be skipped
+    # @option opts [Hash, nil] :deps (nil) Dependency providers to inject into the task's context
     # @yield [input, ctx] The task execution block
     # @return [Task] The created task
     def task(name, **opts, &)
@@ -130,6 +143,25 @@ module Hatchet
       task(name, durable: true, eviction_policy: eviction_policy, **opts, &)
     end
 
+    # Define a batch task within this workflow.
+    #
+    # Batch tasks buffer concurrent runs until Hatchet flushes the batch (size reached or
+    # flush interval), then invoke the block once with all buffered inputs keyed by each
+    # run's task-run external id. The block must return a Hash mapping each id to its
+    # output, or use +broadcast_output+ on the batch config to return the same result to
+    # all callers. retries is always forced to 0 for batch tasks.
+    #
+    # Preview: batch tasks are in beta and may change in future releases.
+    #
+    # @param name [Symbol, String] Task name
+    # @param batch [Hatchet::BatchTaskConfig] Batch configuration
+    # @param opts [Hash] Other Task options forwarded to {#task}.
+    # @yield [inputs, ctx] The batch execution block, receiving a Hash of task-run external id => input
+    # @return [Task] The created batch task
+    def batch_task(name, batch:, **opts, &)
+      task(name, batch: batch, **opts, &)
+    end
+
     # Define an on_failure task for this workflow
     #
     # @param opts [Hash] Task options
@@ -219,55 +251,65 @@ module Hatchet
       ::V1::CreateWorkflowVersionRequest.new(**args)
     end
 
-    # Run this workflow synchronously
+    # Run this workflow synchronously and wait for it to complete.
     #
-    # @param input [Hash] Workflow input
-    # @param options [TriggerWorkflowOptions, nil] Trigger options
-    # @return [Hash] The workflow run output
+    # @param input [Hash] The input data for the workflow
+    # @param options [TriggerWorkflowOptions, nil] Additional options for workflow execution, such as +additional_metadata:+ and +priority:+
+    # @return [Hash] The workflow run output, keyed by task name (e.g. `{"step1" => {...}, "step2" => {...}}`)
+    # @raise [Hatchet::Error] If no client is associated with the workflow
+    # @raise [Hatchet::FailedRunError] If the workflow run failed
     def run(input = {}, options: nil)
       raise Error, "No client associated with workflow #{@name}" unless @client
 
       @client.admin.trigger_workflow(self, input, options: options)
     end
 
-    # Run this workflow without waiting for the result
+    # Trigger a workflow run without waiting for it to complete. Useful for
+    # starting a run and immediately returning a reference to it without
+    # blocking while the workflow runs.
     #
-    # @param input [Hash] Workflow input
-    # @param options [TriggerWorkflowOptions, nil] Trigger options
-    # @return [WorkflowRunRef]
+    # @param input [Hash] The input data for the workflow
+    # @param options [TriggerWorkflowOptions, nil] Additional options for workflow execution
+    # @return [WorkflowRunRef] A reference to the workflow run, whose +result+ method blocks until the run completes
+    # @raise [Hatchet::Error] If no client is associated with the workflow
     def run_no_wait(input = {}, options: nil)
       raise Error, "No client associated with workflow #{@name}" unless @client
 
       @client.admin.trigger_workflow_no_wait(self, input, options: options)
     end
 
-    # Run many instances of this workflow in bulk
+    # Run this workflow in bulk and wait for all runs to complete. Runs are
+    # triggered via bulk gRPC triggering (batched by 1000) and results are
+    # collected concurrently.
     #
-    # @param items [Array<Hash>] Bulk run items
-    # @param return_exceptions [Boolean] Return exceptions instead of raising
-    # @return [Array] Results
+    # @param items [Array<Hash>] A list of bulk run items, as created by {#create_bulk_run_item}
+    # @param return_exceptions [Boolean] If +true+, exceptions are returned as part of the results instead of being raised
+    # @return [Array] A list of results for each workflow run
+    # @raise [Hatchet::Error] If no client is associated with the workflow
     def run_many(items, return_exceptions: false)
       raise Error, "No client associated with workflow #{@name}" unless @client
 
       @client.admin.trigger_workflow_many(self, items, return_exceptions: return_exceptions)
     end
 
-    # Run many instances without waiting for results
+    # Run this workflow in bulk without waiting for the runs to complete.
     #
-    # @param items [Array<Hash>] Bulk run items
-    # @return [Array<WorkflowRunRef>]
+    # @param items [Array<Hash>] A list of bulk run items, as created by {#create_bulk_run_item}
+    # @return [Array<WorkflowRunRef>] A list of references to the triggered workflow runs
+    # @raise [Hatchet::Error] If no client is associated with the workflow
     def run_many_no_wait(items)
       raise Error, "No client associated with workflow #{@name}" unless @client
 
       @client.admin.trigger_workflow_many_no_wait(self, items)
     end
 
-    # Create a bulk run item for use with run_many
+    # Create a bulk run item for this workflow, intended to be used with the
+    # {#run_many} methods.
     #
-    # @param input [Hash] Input data
-    # @param key [String, nil] Deduplication key
-    # @param options [TriggerWorkflowOptions, nil] Trigger options
-    # @return [Hash] Bulk run item
+    # @param input [Hash] The input data for the workflow
+    # @param key [String, nil] The key for the workflow run, used for identification and deduplication
+    # @param options [TriggerWorkflowOptions, nil] Additional options for the workflow run
+    # @return [Hash] A bulk run item that can be passed to the +run_many+ methods
     def create_bulk_run_item(input: {}, key: nil, options: nil)
       item = { input: input }
       item[:key] = key if key
@@ -275,24 +317,26 @@ module Hatchet
       item
     end
 
-    # Schedule this workflow for future execution
+    # Schedule this workflow to run at a specific time.
     #
-    # @param time [Time] When to execute
-    # @param input [Hash] Workflow input
-    # @param options [ScheduleTriggerWorkflowOptions, nil] Schedule options
-    # @return [Object] Schedule result
+    # @param time [Time] When to execute the workflow
+    # @param input [Hash] The input data for the workflow
+    # @param options [ScheduleTriggerWorkflowOptions, nil] Additional schedule options
+    # @return [Object] The schedule response from the Hatchet engine
+    # @raise [Hatchet::Error] If no client is associated with the workflow
     def schedule(time, input: {}, options: nil)
       raise Error, "No client associated with workflow #{@name}" unless @client
 
       @client.admin.schedule_workflow(self, time, input: input, options: options)
     end
 
-    # Create a cron trigger for this workflow
+    # Create a cron trigger for this workflow.
     #
-    # @param cron_name [String] Name for the cron
-    # @param expression [String] Cron expression
-    # @param input [Hash] Workflow input
-    # @return [Object] Cron result
+    # @param cron_name [String] The name of the cron job
+    # @param expression [String] The cron expression that defines the schedule
+    # @param input [Hash] The input data for the workflow
+    # @return [Object] The created cron workflow trigger
+    # @raise [Hatchet::Error] If no client is associated with the workflow
     def create_cron(cron_name, expression, input: {})
       raise Error, "No client associated with workflow #{@name}" unless @client
 

data/lib/hatchet-sdk.rb

@@ -31,6 +31,7 @@ module Hatchet
   require_relative "hatchet/conditions"
   require_relative "hatchet/condition_converter"
   require_relative "hatchet/rate_limit"
+  require_relative "hatchet/batch"
   require_relative "hatchet/labels"
   require_relative "hatchet/trigger_options"
   require_relative "hatchet/default_filter"
@@ -112,83 +113,103 @@ module Hatchet
       @rest_client ||= Hatchet::Clients.rest_client(@config)
     end
 
-    # Feature Client for interacting with Hatchet events
+    # The events client, which you can use to push events to Hatchet to trigger
+    # event-driven workflows.
     # @return [Hatchet::Features::Events]
     def events
       @events ||= Hatchet::Features::Events.new(rest_client, event_grpc, @config)
     end
 
-    # Feature Client for interacting with Hatchet workflow runs
+    # The runs client is a client for interacting with task and workflow runs
+    # within Hatchet.
     # @return [Hatchet::Features::Runs]
     def runs
       @runs ||= Hatchet::Features::Runs.new(rest_client, @config, client: self)
     end
 
-    # Feature Client for interacting with the current tenant
+    # The tenant client is a client for reading information about the tenant
+    # you're operating in.
     # @return [Hatchet::Features::Tenant]
     def tenant
       @tenant ||= Hatchet::Features::Tenant.new(rest_client, @config)
     end
 
-    # Feature Client for interacting with Hatchet logs
+    # The logs client is a client for interacting with Hatchet's logs API.
     # @return [Hatchet::Features::Logs]
     def logs
       @logs ||= Hatchet::Features::Logs.new(rest_client, @config)
     end
 
-    # Feature Client for managing workers
+    # The workers client is a client for managing workers programmatically
+    # within Hatchet.
     # @return [Hatchet::Features::Workers]
     def workers
       @workers ||= Hatchet::Features::Workers.new(rest_client, @config)
     end
 
-    # Feature Client for debugging CEL expressions
+    # The CEL client is a client for debugging CEL expressions within Hatchet.
     # @return [Hatchet::Features::CEL]
     def cel
       @cel ||= Hatchet::Features::CEL.new(rest_client, @config)
     end
 
-    # Feature Client for managing workflow definitions
+    # The workflows client is a client for managing workflow declarations
+    # programmatically within Hatchet. Note that workflows are the declaration,
+    # _not_ the individual runs; if you're looking for runs, use the runs
+    # client instead.
     # @return [Hatchet::Features::Workflows]
     def workflows
       @workflows ||= Hatchet::Features::Workflows.new(rest_client, @config)
     end
 
-    # Feature Client for managing filters
+    # The filters client is a client for managing filters within Hatchet, which
+    # scope event triggers to workflows using CEL expressions.
     # @return [Hatchet::Features::Filters]
     def filters
       @filters ||= Hatchet::Features::Filters.new(rest_client, @config)
     end
 
-    # Feature Client for reading metrics
+    # The metrics client is a client for reading metrics out of Hatchet's
+    # metrics API.
     # @return [Hatchet::Features::Metrics]
     def metrics
       @metrics ||= Hatchet::Features::Metrics.new(rest_client, @config)
     end
 
-    # Feature Client for managing rate limits
+    # The rate limits client is a wrapper for Hatchet's gRPC API that makes it
+    # easier to work with rate limits in Hatchet.
     # @return [Hatchet::Features::RateLimits]
     def rate_limits
       @rate_limits ||= Hatchet::Features::RateLimits.new(admin_grpc, @config)
     end
 
-    # Feature Client for managing cron workflows
+    # The cron client is a client for managing cron workflow triggers within
+    # Hatchet.
     # @return [Hatchet::Features::Cron]
     def cron
       @cron ||= Hatchet::Features::Cron.new(rest_client, @config)
     end
 
-    # Feature Client for managing scheduled workflows
+    # The scheduled client is a client for managing scheduled workflow runs
+    # within Hatchet.
     # @return [Hatchet::Features::Scheduled]
     def scheduled
       @scheduled ||= Hatchet::Features::Scheduled.new(rest_client, @config)
     end
 
-    # Create a new workflow definition
+    # Define a Hatchet workflow, which can then declare tasks and be run,
+    # scheduled, and so on.
     #
-    # @param name [String] Workflow name
-    # @param opts [Hash] Workflow options (on_events:, concurrency:, idempotency:, etc.)
-    # @return [Hatchet::Workflow]
+    # @param name [String] The name of the workflow
+    # @option opts [Array<String>] :on_events ([]) A list of event triggers for the workflow - events which cause the workflow to be run
+    # @option opts [Array<String>] :on_crons ([]) A list of cron triggers for the workflow
+    # @option opts [ConcurrencyExpression, Array<ConcurrencyExpression>, nil] :concurrency (nil) A concurrency object (or list of them) controlling the concurrency settings for this workflow
+    # @option opts [Integer, nil] :default_priority (nil) The default priority of the workflow. Higher values will cause runs of this workflow to have priority in scheduling over other, lower priority ones
+    # @option opts [Hash, nil] :task_defaults (nil) Default task settings for this workflow
+    # @option opts [Array<DefaultFilter>] :default_filters ([]) A list of filters to create when the workflow is created
+    # @option opts [Symbol, nil] :sticky (nil) A sticky strategy for the workflow, either +:soft+ or +:hard+
+    # @option opts [TTLBasedIdempotencyConfig, StatusBasedIdempotencyConfig, nil] :idempotency (nil) An idempotency configuration for the workflow
+    # @return [Hatchet::Workflow] The created workflow object, which can be used to declare tasks, run the workflow, and so on
     #
     # @example
     #   wf = hatchet.workflow(name: "MyWorkflow")
@@ -197,12 +218,18 @@ module Hatchet
       Workflow.new(name: name, client: self, **opts)
     end
 
-    # Create a standalone task (auto-wraps in a single-task workflow)
+    # Create a standalone Hatchet task. The task is automatically wrapped in a
+    # single-task workflow, so it can be run, scheduled, and registered on a
+    # worker just like a workflow. The block receives the run's input and a
+    # {Context} object.
     #
-    # @param name [String] Task name
-    # @param opts [Hash] Task options (on_events:, idempotency:, retries:, etc.)
+    # @param name [String] The name of the task
+    # @option opts [Array<String>] :on_events ([]) A list of event triggers for the task - events which cause the task to be run
+    # @option opts [Array<DefaultFilter>] :default_filters ([]) A list of filters to create when the task is created
+    # @option opts [TTLBasedIdempotencyConfig, StatusBasedIdempotencyConfig, nil] :idempotency (nil) An idempotency configuration for the task
+    # @param opts [Hash] Any other keyword arguments (+retries:+, +execution_timeout:+, +concurrency:+, and so on) are forwarded to the task declaration - see {Workflow#task} for the full list
     # @yield [input, ctx] The task execution block
-    # @return [Hatchet::Task]
+    # @return [Hatchet::Task] The created task object, which can be run, scheduled, and registered on a worker
     #
     # @example
     #   my_task = hatchet.task(name: "my_task") { |input, ctx| { "result" => "done" } }
@@ -214,16 +241,42 @@ module Hatchet
       wf.task(name, **opts, &block)
     end
 
-    # Create a standalone durable task.
+    # Create a standalone batch task (auto-wraps in a single-task workflow).
     #
-    # @param name [String] Task name
+    # Batch tasks buffer concurrent runs until Hatchet flushes the batch (size reached or
+    # flush interval), then invoke the block once with all buffered inputs keyed by each
+    # run's task-run external id. The block must return a Hash mapping each id to its
+    # output, or use +broadcast_output+ on the batch config to return the same result to
+    # all callers. retries is always forced to 0 for batch tasks.
+    #
+    # Preview: batch tasks are in beta and may change in future releases.
+    #
+    # @param name [String] The name of the task
+    # @param batch [Hatchet::BatchTaskConfig] The batch configuration (+max_size+, flush interval, +broadcast_output+)
+    # @param opts [Hash] Any other keyword arguments (+on_events:+, +idempotency:+, and so on) are forwarded to {#task}
+    # @yield [inputs, ctx] The batch execution block, receiving a Hash of task-run external id => input
+    # @return [Hatchet::Task] The created batch task object
+    #
+    # @example
+    #   batch = hatchet.batch_task(name: "my_batch", batch: Hatchet::BatchTaskConfig.new(max_size: 3)) do |inputs, ctx|
+    #     inputs.transform_values { |input| { "result" => input["message"].upcase } }
+    #   end
+    def batch_task(name:, batch:, **opts, &block)
+      task(name: name, batch: batch, **opts, &block)
+    end
+
+    # Create a standalone _durable_ Hatchet task, which works using Hatchet's
+    # durable execution capabilities. Durable tasks receive a {DurableContext}
+    # with additional methods like +sleep_for+ and +wait_for+.
+    #
+    # @param name [String] The name of the task
     # @param eviction_policy [Hatchet::EvictionPolicy, nil] Eviction policy for this
     #   durable task. Defaults to {Hatchet::DEFAULT_DURABLE_TASK_EVICTION_POLICY}
     #   (15-minute TTL, capacity-eviction enabled). Pass ``nil`` to disable
     #   eviction entirely for this task.
-    # @param opts [Hash] Task options
+    # @param opts [Hash] Any other keyword arguments (+retries:+, +execution_timeout:+, and so on) are forwarded to the task declaration - see {Workflow#task} for the full list
     # @yield [input, ctx] The task execution block
-    # @return [Hatchet::Task]
+    # @return [Hatchet::Task] The created durable task object
     def durable_task(name:, eviction_policy: Hatchet::DEFAULT_DURABLE_TASK_EVICTION_POLICY, **opts, &block)
       wf = Workflow.new(name: name, client: self,
                         on_events: opts.delete(:on_events) || [],
@@ -231,11 +284,16 @@ module Hatchet
       wf.durable_task(name, eviction_policy: eviction_policy, **opts, &block)
     end
 
-    # Create a new worker
+    # Create a Hatchet worker on which to run workflows.
     #
-    # @param name [String] Worker name
-    # @param opts [Hash] Worker options (workflows:, slots:, labels:)
-    # @return [Hatchet::Worker]
+    # @param name [String] The name of the worker
+    # @option opts [Array<Workflow, Task>] :workflows ([]) A list of workflows (or standalone tasks) to register on the worker
+    # @option opts [Integer] :slots (10) Slot count for standard tasks, i.e. the number of tasks the worker can run concurrently
+    # @option opts [Integer, nil] :durable_slots (nil) Slot count for durable tasks; defaults to +slots+ if not provided
+    # @option opts [Hash] :labels ({}) A hash of labels to assign to the worker, for use with worker affinity; merged with the client's +worker_preset_labels+
+    # @return [Hatchet::Worker] The created worker object, which exposes an instance
+    #   method +start+ which can be called to start the worker (blocking until
+    #   shutdown), and +stop+ to request a graceful shutdown
     #
     # @example
     #   worker = hatchet.worker("my-worker", workflows: [wf], slots: 10)

data/sig/hatchet/batch.rbs

@@ -0,0 +1,12 @@
+module Hatchet
+  class BatchTaskConfig
+    attr_reader max_size: Integer
+    attr_reader max_interval_ms: Integer?
+    attr_reader group_key: String?
+    attr_reader group_max_runs: Integer?
+    attr_reader broadcast_output: bool
+
+    def initialize: (max_size: Integer, ?max_interval_ms: Integer?, ?group_key: String?, ?group_max_runs: Integer?, ?broadcast_output: bool) -> void
+    def to_proto: () -> untyped
+  end
+end

data/sig/hatchet/task.rbs

@@ -14,6 +14,7 @@ module Hatchet
     attr_reader skip_if: Array[untyped]
     attr_reader durable: bool
     attr_reader eviction_policy: EvictionPolicy?
+    attr_reader batch: BatchTaskConfig?
     attr_reader fn: Proc?
     attr_reader workflow: Workflow?
     attr_reader client: Client?
@@ -34,6 +35,7 @@ module Hatchet
       ?skip_if: Array[untyped],
       ?durable: bool,
       ?eviction_policy: EvictionPolicy?,
+      ?batch: BatchTaskConfig?,
       ?workflow: Workflow?,
       ?client: Client?,
       ?deps: Hash[Symbol, Proc]?