conductor_ruby 0.1.0

data/lib/conductor/workflow/dsl/workflow_definition.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Workflow
+    module Dsl
+      # WorkflowDefinition wraps a WorkflowBuilder and provides methods
+      # for registering and executing workflows.
+      #
+      # @example
+      #   workflow = Conductor.workflow :my_workflow do
+      #     simple :task1
+      #   end
+      #
+      #   workflow.register(overwrite: true)
+      #   result = workflow.execute(input: { foo: 'bar' })
+      #
+      class WorkflowDefinition
+        attr_reader :builder
+
+        # @param builder [WorkflowBuilder] The workflow builder
+        # @param executor [WorkflowExecutor, nil] Optional workflow executor
+        def initialize(builder, executor: nil)
+          @builder = builder
+          @executor = executor
+        end
+
+        # Get the workflow name
+        # @return [String] Workflow name
+        def name
+          @builder.name
+        end
+
+        # Get the workflow version
+        # @return [Integer, nil] Workflow version
+        def version
+          @builder.version
+        end
+
+        # Convert to WorkflowDef model
+        # @return [Conductor::Http::Models::WorkflowDef] Workflow definition
+        def to_workflow_def
+          @builder.to_workflow_def
+        end
+
+        # Register this workflow with Conductor
+        # @param overwrite [Boolean] Overwrite existing workflow definition (default: false)
+        # @return [Object] API response
+        # @raise [RuntimeError] If no executor is configured
+        #
+        # @example
+        #   workflow.register(overwrite: true)
+        def register(overwrite: false)
+          raise 'Executor required for registration. Pass executor: option to Conductor.workflow' unless @executor
+
+          @executor.register_workflow(self, overwrite: overwrite)
+        end
+
+        # Execute this workflow and wait for completion
+        # @param input [Hash] Workflow input parameters (default: {})
+        # @param wait_for_seconds [Integer] Maximum time to wait for completion (default: 30)
+        # @param correlation_id [String, nil] Correlation ID for tracking
+        # @param domain [String, nil] Task domain for all tasks
+        # @param wait_until_task_ref [String, nil] Wait until specific task completes
+        # @param request_id [String, nil] Unique request ID for idempotency
+        # @return [WorkflowRun] Workflow execution result
+        # @raise [RuntimeError] If no executor is configured
+        #
+        # @example
+        #   result = workflow.execute(input: { user_id: 123 })
+        #   puts result.status
+        def execute(input: {}, wait_for_seconds: 30, correlation_id: nil, domain: nil,
+                    wait_until_task_ref: nil, request_id: nil)
+          raise 'Executor required for execution. Pass executor: option to Conductor.workflow' unless @executor
+
+          @executor.execute(
+            @builder.name,
+            input: input,
+            version: @builder.version,
+            wait_for_seconds: wait_for_seconds,
+            correlation_id: correlation_id,
+            domain: domain,
+            wait_until_task_ref: wait_until_task_ref,
+            request_id: request_id
+          )
+        end
+
+        # Execute this workflow (alias for execute)
+        # @param input [Hash] Workflow input parameters
+        # @return [WorkflowRun] Workflow execution result
+        #
+        # @example
+        #   result = workflow.call(user_id: 123, email: 'user@example.com')
+        def call(**input)
+          execute(input: input)
+        end
+
+        # Start this workflow asynchronously (returns immediately with workflow ID)
+        # @param input [Hash] Workflow input parameters (default: {})
+        # @param correlation_id [String, nil] Correlation ID for tracking
+        # @param domain [String, nil] Task domain for all tasks
+        # @return [String] Workflow ID
+        # @raise [RuntimeError] If no executor is configured
+        #
+        # @example
+        #   workflow_id = workflow.start(input: { user_id: 123 })
+        def start(input: {}, correlation_id: nil, domain: nil)
+          raise 'Executor required for starting workflow. Pass executor: option to Conductor.workflow' unless @executor
+
+          request = Conductor::Http::Models::StartWorkflowRequest.new(
+            name: @builder.name,
+            version: @builder.version,
+            input: input,
+            correlation_id: correlation_id
+          )
+          request.task_to_domain = { '*' => domain } if domain
+
+          @executor.start_workflow(request)
+        end
+
+        # Get the workflow status
+        # @param workflow_id [String] The workflow execution ID
+        # @param include_tasks [Boolean] Include task details (default: true)
+        # @return [Workflow] Workflow execution details
+        # @raise [RuntimeError] If no executor is configured
+        #
+        # @example
+        #   workflow_id = workflow.start(input: { user_id: 123 })
+        #   status = workflow.status(workflow_id)
+        def status(workflow_id, include_tasks: true)
+          raise 'Executor required for checking status. Pass executor: option to Conductor.workflow' unless @executor
+
+          @executor.get_workflow(workflow_id, include_tasks: include_tasks)
+        end
+
+        # Inspect the workflow definition
+        # @return [String] Human-readable representation
+        def inspect
+          "#<Conductor::Workflow::Dsl::WorkflowDefinition name=#{@builder.name.inspect} " \
+            "version=#{@builder.version.inspect} tasks=#{@builder.tasks.size}>"
+        end
+
+        # Convert to string
+        # @return [String] Workflow name and version
+        def to_s
+          "#{@builder.name}:#{@builder.version || 'latest'}"
+        end
+      end
+    end
+  end
+end

data/lib/conductor/workflow/llm/chat_message.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Workflow
+    module Llm
+      # Role constants for ChatMessage
+      module Role
+        USER = 'user'
+        ASSISTANT = 'assistant'
+        SYSTEM = 'system'
+        TOOL_CALL = 'tool_call'
+        TOOL = 'tool'
+      end
+
+      # ChatMessage represents a single message in an LLM chat conversation
+      class ChatMessage
+        attr_accessor :role, :message, :media, :mime_type, :tool_calls
+
+        # @param role [String] The role (use Role constants)
+        # @param message [String] The message content
+        # @param media [Array<String>, nil] Optional media URLs
+        # @param mime_type [String, nil] Optional MIME type for media
+        # @param tool_calls [Array<ToolCall>, nil] Optional tool calls
+        def initialize(role:, message:, media: nil, mime_type: nil, tool_calls: nil)
+          @role = role
+          @message = message
+          @media = media
+          @mime_type = mime_type
+          @tool_calls = tool_calls
+        end
+
+        # Convert to hash for serialization
+        # @return [Hash] The message as a hash with camelCase keys
+        def to_h
+          result = {
+            'role' => @role,
+            'message' => @message
+          }
+          result['media'] = @media if @media && !@media.empty?
+          result['mimeType'] = @mime_type if @mime_type
+          result['toolCalls'] = @tool_calls.map(&:to_h) if @tool_calls && !@tool_calls.empty?
+          result
+        end
+      end
+    end
+  end
+end

data/lib/conductor/workflow/llm/embedding_model.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Workflow
+    module Llm
+      # EmbeddingModel encapsulates the provider and model name for embeddings
+      class EmbeddingModel
+        attr_reader :provider, :model
+
+        # @param provider [String] The embedding provider name (e.g. 'openai')
+        # @param model [String] The model name (e.g. 'text-embedding-ada-002')
+        def initialize(provider:, model:)
+          @provider = provider
+          @model = model
+        end
+      end
+    end
+  end
+end

data/lib/conductor/workflow/llm/tool_call.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Workflow
+    module Llm
+      # ToolCall represents a tool invocation in an LLM conversation
+      class ToolCall
+        attr_accessor :name, :task_reference_name, :integration_names, :type,
+                      :input_parameters, :output
+
+        # @param name [String] Tool name
+        # @param task_reference_name [String, nil] Task reference name
+        # @param integration_names [Hash<String,String>, nil] Integration name mappings
+        # @param type [String] Tool type (default: 'SIMPLE')
+        # @param input_parameters [Hash, nil] Input parameters for the tool
+        # @param output [Hash, nil] Expected output
+        def initialize(name:, task_reference_name: nil, integration_names: nil,
+                       type: 'SIMPLE', input_parameters: nil, output: nil)
+          @name = name
+          @task_reference_name = task_reference_name
+          @integration_names = integration_names
+          @type = type
+          @input_parameters = input_parameters
+          @output = output
+        end
+
+        # Convert to hash for serialization
+        # @return [Hash] The tool call as a hash with camelCase keys
+        def to_h
+          result = {
+            'name' => @name,
+            'type' => @type
+          }
+          result['taskReferenceName'] = @task_reference_name if @task_reference_name
+          result['integrationNames'] = @integration_names if @integration_names
+          result['inputParameters'] = @input_parameters if @input_parameters
+          result['output'] = @output if @output
+          result
+        end
+      end
+    end
+  end
+end

data/lib/conductor/workflow/llm/tool_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Workflow
+    module Llm
+      # ToolSpec defines a tool specification for LLM function calling
+      class ToolSpec
+        attr_accessor :name, :type, :description, :config_params,
+                      :integration_names, :input_schema, :output_schema
+
+        # @param name [String] Tool name
+        # @param type [String] Tool type (default: 'SIMPLE')
+        # @param description [String, nil] Tool description
+        # @param config_params [Hash, nil] Configuration parameters
+        # @param integration_names [Hash<String,String>, nil] Integration name mappings
+        # @param input_schema [Hash, nil] JSON schema for inputs
+        # @param output_schema [Hash, nil] JSON schema for outputs
+        def initialize(name:, type: 'SIMPLE', description: nil, config_params: nil,
+                       integration_names: nil, input_schema: nil, output_schema: nil)
+          @name = name
+          @type = type
+          @description = description
+          @config_params = config_params
+          @integration_names = integration_names
+          @input_schema = input_schema
+          @output_schema = output_schema
+        end
+
+        # Convert to hash for serialization
+        # @return [Hash] The tool spec as a hash with camelCase keys
+        def to_h
+          result = {
+            'name' => @name,
+            'type' => @type
+          }
+          result['description'] = @description if @description
+          result['configParams'] = @config_params if @config_params
+          result['integrationNames'] = @integration_names if @integration_names
+          result['inputSchema'] = @input_schema if @input_schema
+          result['outputSchema'] = @output_schema if @output_schema
+          result
+        end
+      end
+    end
+  end
+end

data/lib/conductor/workflow/task_type.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Workflow
+    # Task type constants for Conductor workflow tasks
+    # These match the server-side task types
+    module TaskType
+      SIMPLE = 'SIMPLE'
+      DYNAMIC = 'DYNAMIC'
+      FORK_JOIN = 'FORK_JOIN'
+      FORK_JOIN_DYNAMIC = 'FORK_JOIN_DYNAMIC'
+      DECISION = 'DECISION'
+      SWITCH = 'SWITCH'
+      JOIN = 'JOIN'
+      DO_WHILE = 'DO_WHILE'
+      SUB_WORKFLOW = 'SUB_WORKFLOW'
+      START_WORKFLOW = 'START_WORKFLOW'
+      EVENT = 'EVENT'
+      WAIT = 'WAIT'
+      WAIT_FOR_WEBHOOK = 'WAIT_FOR_WEBHOOK'
+      HUMAN = 'HUMAN'
+      USER_DEFINED = 'USER_DEFINED'
+      HTTP = 'HTTP'
+      HTTP_POLL = 'HTTP_POLL'
+      LAMBDA = 'LAMBDA'
+      INLINE = 'INLINE'
+      EXCLUSIVE_JOIN = 'EXCLUSIVE_JOIN'
+      TERMINATE = 'TERMINATE'
+      KAFKA_PUBLISH = 'KAFKA_PUBLISH'
+      JSON_JQ_TRANSFORM = 'JSON_JQ_TRANSFORM'
+      SET_VARIABLE = 'SET_VARIABLE'
+      GET_DOCUMENT = 'GET_DOCUMENT'
+
+      # LLM Task Types
+      LLM_GENERATE_EMBEDDINGS = 'LLM_GENERATE_EMBEDDINGS'
+      LLM_GET_EMBEDDINGS = 'LLM_GET_EMBEDDINGS'
+      LLM_TEXT_COMPLETE = 'LLM_TEXT_COMPLETE'
+      LLM_CHAT_COMPLETE = 'LLM_CHAT_COMPLETE'
+      LLM_INDEX_TEXT = 'LLM_INDEX_TEXT'
+      LLM_SEARCH_INDEX = 'LLM_SEARCH_INDEX'
+      GENERATE_IMAGE = 'GENERATE_IMAGE'
+      GENERATE_AUDIO = 'GENERATE_AUDIO'
+      LLM_STORE_EMBEDDINGS = 'LLM_STORE_EMBEDDINGS'
+      LLM_SEARCH_EMBEDDINGS = 'LLM_SEARCH_EMBEDDINGS'
+      LIST_MCP_TOOLS = 'LIST_MCP_TOOLS'
+      CALL_MCP_TOOL = 'CALL_MCP_TOOL'
+
+      # All valid task types
+      ALL_TYPES = [
+        SIMPLE, DYNAMIC, FORK_JOIN, FORK_JOIN_DYNAMIC, DECISION, SWITCH, JOIN,
+        DO_WHILE, SUB_WORKFLOW, START_WORKFLOW, EVENT, WAIT, WAIT_FOR_WEBHOOK,
+        HUMAN, USER_DEFINED, HTTP, HTTP_POLL, LAMBDA, INLINE, EXCLUSIVE_JOIN,
+        TERMINATE, KAFKA_PUBLISH, JSON_JQ_TRANSFORM, SET_VARIABLE, GET_DOCUMENT,
+        LLM_GENERATE_EMBEDDINGS, LLM_GET_EMBEDDINGS, LLM_TEXT_COMPLETE,
+        LLM_CHAT_COMPLETE, LLM_INDEX_TEXT, LLM_SEARCH_INDEX, GENERATE_IMAGE,
+        GENERATE_AUDIO, LLM_STORE_EMBEDDINGS, LLM_SEARCH_EMBEDDINGS,
+        LIST_MCP_TOOLS, CALL_MCP_TOOL
+      ].freeze
+
+      # Check if a task type is valid
+      # @param type [String] The task type to check
+      # @return [Boolean] true if valid
+      def self.valid?(type)
+        ALL_TYPES.include?(type)
+      end
+    end
+  end
+end

data/lib/conductor/workflow/timeout_policy.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Workflow
+    # Timeout policy for workflows and tasks
+    module TimeoutPolicy
+      # Workflow times out and is marked as TIMED_OUT
+      TIME_OUT_WORKFLOW = 'TIME_OUT_WF'
+
+      # Only send an alert, workflow continues
+      ALERT_ONLY = 'ALERT_ONLY'
+
+      # All valid timeout policies
+      ALL_POLICIES = [TIME_OUT_WORKFLOW, ALERT_ONLY].freeze
+
+      # Check if a timeout policy is valid
+      # @param policy [String] The policy to check
+      # @return [Boolean] true if valid
+      def self.valid?(policy)
+        ALL_POLICIES.include?(policy)
+      end
+    end
+
+    # Evaluator types for switch tasks and expressions
+    module EvaluatorType
+      JAVASCRIPT = 'javascript'
+      ECMASCRIPT = 'graaljs'
+      VALUE_PARAM = 'value-param'
+    end
+  end
+end