conductor_ruby 0.1.0

data/lib/conductor/http/models/prompt_template.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # PromptTemplate model - AI prompt template
+      class PromptTemplate < BaseModel
+        SWAGGER_TYPES = {
+          created_by: 'String',
+          create_time: 'Integer',
+          description: 'String',
+          integrations: 'Array<String>',
+          name: 'String',
+          owner_app: 'String',
+          tags: 'Array<TagObject>',
+          template: 'String',
+          updated_by: 'String',
+          update_time: 'Integer',
+          variables: 'Array<String>',
+          version: 'Integer'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          created_by: :createdBy,
+          create_time: :createTime,
+          description: :description,
+          integrations: :integrations,
+          name: :name,
+          owner_app: :ownerApp,
+          tags: :tags,
+          template: :template,
+          updated_by: :updatedBy,
+          update_time: :updateTime,
+          variables: :variables,
+          version: :version
+        }.freeze
+
+        attr_accessor :created_by, :create_time, :description, :integrations,
+                      :name, :owner_app, :tags, :template, :updated_by,
+                      :update_time, :variables, :version
+
+        def initialize(params = {})
+          @created_by = params[:created_by]
+          @create_time = params[:create_time]
+          @description = params[:description]
+          @integrations = params[:integrations]
+          @name = params[:name]
+          @owner_app = params[:owner_app]
+          @tags = params[:tags]
+          @template = params[:template]
+          @updated_by = params[:updated_by]
+          @update_time = params[:update_time]
+          @variables = params[:variables]
+          @version = params[:version] || 1
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/prompt_template_test_request.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # PromptTemplateTestRequest model - request to test a prompt template
+      class PromptTemplateTestRequest < BaseModel
+        SWAGGER_TYPES = {
+          llm_provider: 'String',
+          model: 'String',
+          prompt: 'String',
+          prompt_variables: 'Hash<String, Object>',
+          stop_words: 'Array<String>',
+          temperature: 'Float',
+          top_p: 'Float'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          llm_provider: :llmProvider,
+          model: :model,
+          prompt: :prompt,
+          prompt_variables: :promptVariables,
+          stop_words: :stopWords,
+          temperature: :temperature,
+          top_p: :topP
+        }.freeze
+
+        attr_accessor :llm_provider, :model, :prompt, :prompt_variables,
+                      :stop_words, :temperature, :top_p
+
+        def initialize(params = {})
+          @llm_provider = params[:llm_provider]
+          @model = params[:model]
+          @prompt = params[:prompt]
+          @prompt_variables = params[:prompt_variables]
+          @stop_words = params[:stop_words]
+          @temperature = params[:temperature]
+          @top_p = params[:top_p]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/rerun_workflow_request.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Request to rerun a workflow from a specific task
+      class RerunWorkflowRequest < BaseModel
+        SWAGGER_TYPES = {
+          re_run_from_workflow_id: 'String',
+          workflow_input: 'Hash<String, Object>',
+          re_run_from_task_id: 'String',
+          task_input: 'Hash<String, Object>',
+          correlation_id: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          re_run_from_workflow_id: :reRunFromWorkflowId,
+          workflow_input: :workflowInput,
+          re_run_from_task_id: :reRunFromTaskId,
+          task_input: :taskInput,
+          correlation_id: :correlationId
+        }.freeze
+
+        attr_accessor :re_run_from_workflow_id, :workflow_input, :re_run_from_task_id,
+                      :task_input, :correlation_id
+
+        def initialize(params = {})
+          @re_run_from_workflow_id = params[:re_run_from_workflow_id]
+          @workflow_input = params[:workflow_input]
+          @re_run_from_task_id = params[:re_run_from_task_id]
+          @task_input = params[:task_input]
+          @correlation_id = params[:correlation_id]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/role.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Role model - represents a role with permissions
+      class Role < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          permissions: 'Array<Permission>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          permissions: :permissions
+        }.freeze
+
+        attr_accessor :name, :permissions
+
+        def initialize(params = {})
+          @name = params[:name]
+          @permissions = params[:permissions]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/schema_def.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Schema type constants
+      module SchemaType
+        JSON = 'JSON'
+        AVRO = 'AVRO'
+        PROTOBUF = 'PROTOBUF'
+      end
+
+      # SchemaDef model - JSON/Avro/Protobuf schema definition
+      class SchemaDef < BaseModel
+        SWAGGER_TYPES = {
+          owner_app: 'String',
+          create_time: 'Integer',
+          update_time: 'Integer',
+          created_by: 'String',
+          updated_by: 'String',
+          name: 'String',
+          version: 'Integer',
+          type: 'String',
+          data: 'Hash<String, Object>',
+          external_ref: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          owner_app: :ownerApp,
+          create_time: :createTime,
+          update_time: :updateTime,
+          created_by: :createdBy,
+          updated_by: :updatedBy,
+          name: :name,
+          version: :version,
+          type: :type,
+          data: :data,
+          external_ref: :externalRef
+        }.freeze
+
+        attr_accessor :owner_app, :create_time, :update_time, :created_by,
+                      :updated_by, :name, :version, :type, :data, :external_ref
+
+        def initialize(params = {})
+          @owner_app = params[:owner_app]
+          @create_time = params[:create_time]
+          @update_time = params[:update_time]
+          @created_by = params[:created_by]
+          @updated_by = params[:updated_by]
+          @name = params[:name]
+          @version = params[:version] || 1
+          @type = params[:type]
+          @data = params[:data]
+          @external_ref = params[:external_ref]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/search_result.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Generic scrollable search result
+      class SearchResult < BaseModel
+        SWAGGER_TYPES = {
+          total_hits: 'Integer',
+          results: 'Array<Object>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          total_hits: :totalHits,
+          results: :results
+        }.freeze
+
+        attr_accessor :total_hits, :results
+
+        def initialize(params = {})
+          @total_hits = params[:total_hits] || 0
+          @results = params[:results] || []
+        end
+      end
+
+      # Workflow summary for search results
+      class WorkflowSummary < BaseModel
+        SWAGGER_TYPES = {
+          workflow_id: 'String',
+          correlation_id: 'String',
+          workflow_type: 'String',
+          version: 'Integer',
+          start_time: 'String',
+          update_time: 'String',
+          end_time: 'String',
+          status: 'String',
+          input: 'String',
+          output: 'String',
+          reason_for_incompletion: 'String',
+          execution_time: 'Integer',
+          event: 'String',
+          failed_reference_task_names: 'String',
+          external_input_payload_storage_path: 'String',
+          external_output_payload_storage_path: 'String',
+          priority: 'Integer',
+          input_size: 'Integer',
+          output_size: 'Integer',
+          failed_task_names: 'Array<String>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          workflow_id: :workflowId,
+          correlation_id: :correlationId,
+          workflow_type: :workflowType,
+          version: :version,
+          start_time: :startTime,
+          update_time: :updateTime,
+          end_time: :endTime,
+          status: :status,
+          input: :input,
+          output: :output,
+          reason_for_incompletion: :reasonForIncompletion,
+          execution_time: :executionTime,
+          event: :event,
+          failed_reference_task_names: :failedReferenceTaskNames,
+          external_input_payload_storage_path: :externalInputPayloadStoragePath,
+          external_output_payload_storage_path: :externalOutputPayloadStoragePath,
+          priority: :priority,
+          input_size: :inputSize,
+          output_size: :outputSize,
+          failed_task_names: :failedTaskNames
+        }.freeze
+
+        attr_accessor :workflow_id, :correlation_id, :workflow_type, :version,
+                      :start_time, :update_time, :end_time, :status, :input, :output,
+                      :reason_for_incompletion, :execution_time, :event,
+                      :failed_reference_task_names,
+                      :external_input_payload_storage_path,
+                      :external_output_payload_storage_path,
+                      :priority, :input_size, :output_size, :failed_task_names
+
+        def initialize(params = {})
+          @workflow_id = params[:workflow_id]
+          @correlation_id = params[:correlation_id]
+          @workflow_type = params[:workflow_type]
+          @version = params[:version]
+          @start_time = params[:start_time]
+          @update_time = params[:update_time]
+          @end_time = params[:end_time]
+          @status = params[:status]
+          @input = params[:input]
+          @output = params[:output]
+          @reason_for_incompletion = params[:reason_for_incompletion]
+          @execution_time = params[:execution_time]
+          @event = params[:event]
+          @failed_reference_task_names = params[:failed_reference_task_names]
+          @external_input_payload_storage_path = params[:external_input_payload_storage_path]
+          @external_output_payload_storage_path = params[:external_output_payload_storage_path]
+          @priority = params[:priority]
+          @input_size = params[:input_size]
+          @output_size = params[:output_size]
+          @failed_task_names = params[:failed_task_names] || []
+        end
+      end
+
+      # Task summary for search results
+      class TaskSummary < BaseModel
+        SWAGGER_TYPES = {
+          workflow_id: 'String',
+          workflow_type: 'String',
+          correlation_id: 'String',
+          scheduled_time: 'String',
+          start_time: 'String',
+          update_time: 'String',
+          end_time: 'String',
+          status: 'String',
+          reason_for_incompletion: 'String',
+          execution_time: 'Integer',
+          queue_wait_time: 'Integer',
+          task_def_name: 'String',
+          task_type: 'String',
+          input: 'String',
+          output: 'String',
+          task_id: 'String',
+          external_input_payload_storage_path: 'String',
+          external_output_payload_storage_path: 'String',
+          workflow_priority: 'Integer',
+          domain: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          workflow_id: :workflowId,
+          workflow_type: :workflowType,
+          correlation_id: :correlationId,
+          scheduled_time: :scheduledTime,
+          start_time: :startTime,
+          update_time: :updateTime,
+          end_time: :endTime,
+          status: :status,
+          reason_for_incompletion: :reasonForIncompletion,
+          execution_time: :executionTime,
+          queue_wait_time: :queueWaitTime,
+          task_def_name: :taskDefName,
+          task_type: :taskType,
+          input: :input,
+          output: :output,
+          task_id: :taskId,
+          external_input_payload_storage_path: :externalInputPayloadStoragePath,
+          external_output_payload_storage_path: :externalOutputPayloadStoragePath,
+          workflow_priority: :workflowPriority,
+          domain: :domain
+        }.freeze
+
+        attr_accessor :workflow_id, :workflow_type, :correlation_id, :scheduled_time,
+                      :start_time, :update_time, :end_time, :status,
+                      :reason_for_incompletion, :execution_time, :queue_wait_time,
+                      :task_def_name, :task_type, :input, :output, :task_id,
+                      :external_input_payload_storage_path,
+                      :external_output_payload_storage_path,
+                      :workflow_priority, :domain
+
+        def initialize(params = {})
+          @workflow_id = params[:workflow_id]
+          @workflow_type = params[:workflow_type]
+          @correlation_id = params[:correlation_id]
+          @scheduled_time = params[:scheduled_time]
+          @start_time = params[:start_time]
+          @update_time = params[:update_time]
+          @end_time = params[:end_time]
+          @status = params[:status]
+          @reason_for_incompletion = params[:reason_for_incompletion]
+          @execution_time = params[:execution_time]
+          @queue_wait_time = params[:queue_wait_time]
+          @task_def_name = params[:task_def_name]
+          @task_type = params[:task_type]
+          @input = params[:input]
+          @output = params[:output]
+          @task_id = params[:task_id]
+          @external_input_payload_storage_path = params[:external_input_payload_storage_path]
+          @external_output_payload_storage_path = params[:external_output_payload_storage_path]
+          @workflow_priority = params[:workflow_priority]
+          @domain = params[:domain]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/skip_task_request.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Request to skip a task in a running workflow
+      class SkipTaskRequest < BaseModel
+        SWAGGER_TYPES = {
+          task_input: 'Hash<String, Object>',
+          task_output: 'Hash<String, Object>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          task_input: :taskInput,
+          task_output: :taskOutput
+        }.freeze
+
+        attr_accessor :task_input, :task_output
+
+        def initialize(params = {})
+          @task_input = params[:task_input]
+          @task_output = params[:task_output]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/start_workflow_request.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'base_model'
+
+module Conductor
+  module Http
+    module Models
+      # StartWorkflowRequest model for starting a workflow execution
+      class StartWorkflowRequest < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          version: 'Integer',
+          correlation_id: 'String',
+          input: 'Hash<String, Object>',
+          task_to_domain: 'Hash<String, String>',
+          workflow_def: 'WorkflowDef',
+          external_input_payload_storage_path: 'String',
+          priority: 'Integer',
+          created_by: 'String',
+          idempotency_key: 'String',
+          idempotency_strategy: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          version: :version,
+          correlation_id: :correlationId,
+          input: :input,
+          task_to_domain: :taskToDomain,
+          workflow_def: :workflowDef,
+          external_input_payload_storage_path: :externalInputPayloadStoragePath,
+          priority: :priority,
+          created_by: :createdBy,
+          idempotency_key: :idempotencyKey,
+          idempotency_strategy: :idempotencyStrategy
+        }.freeze
+
+        # Idempotency strategies
+        module IdempotencyStrategy
+          FAIL = 'FAIL'
+          RETURN_EXISTING = 'RETURN_EXISTING'
+        end
+
+        attr_accessor :name, :version, :correlation_id, :input, :task_to_domain,
+                      :workflow_def, :external_input_payload_storage_path, :priority,
+                      :created_by, :idempotency_key, :idempotency_strategy
+
+        # Initialize a new StartWorkflowRequest
+        # @param [Hash] attributes Model attributes in the form of hash
+        def initialize(attributes = {})
+          return unless attributes.is_a?(Hash)
+
+          self.name = attributes[:name] if attributes.key?(:name)
+          self.version = attributes[:version] if attributes.key?(:version)
+          self.correlation_id = attributes[:correlation_id] if attributes.key?(:correlation_id)
+          self.input = attributes[:input] if attributes.key?(:input)
+          self.task_to_domain = attributes[:task_to_domain] if attributes.key?(:task_to_domain)
+          self.workflow_def = attributes[:workflow_def] if attributes.key?(:workflow_def)
+          self.external_input_payload_storage_path = attributes[:external_input_payload_storage_path] if attributes.key?(:external_input_payload_storage_path)
+          self.priority = attributes[:priority] if attributes.key?(:priority)
+          self.created_by = attributes[:created_by] if attributes.key?(:created_by)
+          self.idempotency_key = attributes[:idempotency_key] if attributes.key?(:idempotency_key)
+          self.idempotency_strategy = attributes[:idempotency_strategy] if attributes.key?(:idempotency_strategy)
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/subject_ref.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Subject type constants for authorization
+      module SubjectType
+        USER = 'USER'
+        ROLE = 'ROLE'
+        GROUP = 'GROUP'
+        TAG = 'TAG'
+      end
+
+      # SubjectRef model - identifies a user, role, or group for authorization
+      class SubjectRef < BaseModel
+        SWAGGER_TYPES = {
+          type: 'String',
+          id: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          type: :type,
+          id: :id
+        }.freeze
+
+        attr_accessor :type, :id
+
+        def initialize(params = {})
+          @type = params[:type]
+          @id = params[:id]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/tag_object.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Tag type constants
+      module TagType
+        METADATA = 'METADATA'
+        RATE_LIMIT = 'RATE_LIMIT'
+      end
+
+      # TagObject model - base tag model for metadata and rate limit tags
+      class TagObject < BaseModel
+        SWAGGER_TYPES = {
+          key: 'String',
+          type: 'String',
+          value: 'Object'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          key: :key,
+          type: :type,
+          value: :value
+        }.freeze
+
+        attr_accessor :key, :type, :value
+
+        def initialize(params = {})
+          @key = params[:key]
+          @type = params[:type]
+          @value = params[:value]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/target_ref.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Target type constants for authorization
+      module TargetType
+        WORKFLOW_DEF = 'WORKFLOW_DEF'
+        TASK_DEF = 'TASK_DEF'
+        APPLICATION = 'APPLICATION'
+        USER = 'USER'
+        SECRET = 'SECRET'
+        SECRET_NAME = 'SECRET_NAME'
+        TAG = 'TAG'
+        DOMAIN = 'DOMAIN'
+      end
+
+      # TargetRef model - identifies a resource target for authorization
+      class TargetRef < BaseModel
+        SWAGGER_TYPES = {
+          type: 'String',
+          id: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          type: :type,
+          id: :id
+        }.freeze
+
+        attr_accessor :type, :id
+
+        def initialize(params = {})
+          @type = params[:type]
+          @id = params[:id]
+        end
+      end
+    end
+  end
+end