durable_workflow 0.1.0

data/lib/durable_workflow/extensions/ai/executors/file_search.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module DurableWorkflow
+  module Extensions
+    module AI
+      module Executors
+        class FileSearch < Core::Executors::Base
+          def call(state)
+            query = resolve(state, config.query)
+            files = config.files
+            max_results = config.max_results
+
+            results = search_files(query, files, max_results)
+
+            state = store(state, config.output, results) if config.output
+            continue(state, output: results)
+          end
+
+          private
+
+          def search_files(query, files, max_results)
+            # Placeholder - returns dummy results
+            # In production, integrate with vector stores (OpenAI, Pinecone, etc.)
+            dummy_results = generate_dummy_results(query, files, max_results)
+
+            {
+              query:,
+              results: dummy_results,
+              total: dummy_results.size,
+              searched_files: files.size,
+              max_results:
+            }
+          end
+
+          def generate_dummy_results(query, files, max_results)
+            return [] if files.empty?
+
+            # Generate plausible dummy results based on query
+            files.take(max_results).map.with_index do |file, idx|
+              {
+                file: file,
+                score: (0.95 - (idx * 0.1)).round(2),
+                snippet: "...relevant content matching '#{query}' found in #{file}...",
+                line_number: rand(1..100)
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable_workflow/extensions/ai/executors/guardrail.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module DurableWorkflow
+  module Extensions
+    module AI
+      module Executors
+        class Guardrail < Core::Executors::Base
+          INJECTION_PATTERNS = [
+            /ignore\s+(all\s+)?previous\s+instructions/i,
+            /disregard\s+(all\s+)?previous/i,
+            /forget\s+(everything|all)/i,
+            /you\s+are\s+now\s+/i,
+            /new\s+instructions?:/i,
+            /system\s*:\s*/i,
+            /\[system\]/i,
+            /pretend\s+you\s+are/i,
+            /act\s+as\s+if/i,
+            /roleplay\s+as/i
+          ].freeze
+
+          PII_PATTERNS = [
+            /\b\d{3}-\d{2}-\d{4}\b/, # SSN
+            /\b\d{16}\b/, # Credit card (no spaces)
+            /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/, # Credit card (with spaces/dashes)
+            /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/, # Email
+            /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/ # Phone
+          ].freeze
+
+          def call(state)
+            content = resolve(state, config.content || config.input)
+            checks = parse_checks(config.checks)
+            on_fail = config.on_fail
+
+            results = checks.map { |check| run_check(check, content) }
+            failed = results.find { |r| !r.passed }
+
+            if failed
+              state = state.with_ctx(_guardrail_failure: {
+                                       check_type: failed.check_type,
+                                       reason: failed.reason
+                                     })
+              return on_fail ? continue(state, next_step: on_fail) : raise(ExecutionError, "Guardrail failed: #{failed.reason}")
+            end
+
+            continue(state)
+          end
+
+          private
+
+          def parse_checks(checks)
+            checks.map do |check|
+              case check
+              when Hash
+                GuardrailCheck.new(
+                  type: check[:type],
+                  pattern: check[:pattern],
+                  block_on_match: check.fetch(:block_on_match, true),
+                  max: check[:max],
+                  min: check[:min]
+                )
+              when GuardrailCheck
+                check
+              else
+                GuardrailCheck.new(type: check.to_s)
+              end
+            end
+          end
+
+          def run_check(check, content)
+            case check.type
+            when 'prompt_injection'
+              check_prompt_injection(content)
+            when 'pii'
+              check_pii(content)
+            when 'moderation'
+              check_moderation(content)
+            when 'regex'
+              check_regex(content, check.pattern, check.block_on_match)
+            when 'length'
+              check_length(content, check.max, check.min)
+            else
+              GuardrailResult.new(passed: true, check_type: check.type)
+            end
+          end
+
+          def check_prompt_injection(content)
+            detected = INJECTION_PATTERNS.any? { |pattern| content.to_s.match?(pattern) }
+            GuardrailResult.new(
+              passed: !detected,
+              check_type: 'prompt_injection',
+              reason: detected ? 'Potential prompt injection detected' : nil
+            )
+          end
+
+          def check_pii(content)
+            detected = PII_PATTERNS.any? { |pattern| content.to_s.match?(pattern) }
+            GuardrailResult.new(
+              passed: !detected,
+              check_type: 'pii',
+              reason: detected ? 'PII detected in content' : nil
+            )
+          end
+
+          def check_moderation(content)
+            result = RubyLLM.moderate(content)
+            GuardrailResult.new(
+              passed: !result.flagged,
+              check_type: 'moderation',
+              reason: result.flagged ? 'Content flagged by moderation' : nil
+            )
+          rescue StandardError
+            # If moderation fails (e.g., no API key), pass by default
+            GuardrailResult.new(passed: true, check_type: 'moderation')
+          end
+
+          def check_regex(content, pattern, block_on_match = true)
+            return GuardrailResult.new(passed: true, check_type: 'regex') unless pattern
+
+            matches = content.to_s.match?(Regexp.new(pattern))
+            passed = block_on_match ? !matches : matches
+
+            GuardrailResult.new(
+              passed:,
+              check_type: 'regex',
+              reason: if passed
+                        nil
+                      else
+                        "Content #{block_on_match ? 'matched' : 'did not match'} pattern"
+                      end
+            )
+          end
+
+          def check_length(content, max, min)
+            len = content.to_s.length
+            passed = true
+            reason = nil
+
+            if max && len > max
+              passed = false
+              reason = "Content exceeds max length (#{len} > #{max})"
+            elsif min && len < min
+              passed = false
+              reason = "Content below min length (#{len} < #{min})"
+            end
+
+            GuardrailResult.new(passed:, check_type: 'length', reason:)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable_workflow/extensions/ai/executors/handoff.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module DurableWorkflow
+  module Extensions
+    module AI
+      module Executors
+        class Handoff < Core::Executors::Base
+          def call(state)
+            target_agent = config.to || state.ctx[:_handoff_to]
+            raise ExecutionError, 'No handoff target specified' unless target_agent
+
+            workflow = DurableWorkflow.registry[state.workflow_id]
+            agents = Extension.agents(workflow)
+            raise ExecutionError, "Agent not found: #{target_agent}" unless agents.key?(target_agent)
+
+            new_ctx = state.ctx.except(:_handoff_to).merge(
+              _current_agent: target_agent,
+              _handoff_context: {
+                from: config.from,
+                to: target_agent,
+                reason: config.reason,
+                timestamp: Time.now.iso8601
+              }
+            )
+            state = state.with(ctx: new_ctx)
+
+            continue(state)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable_workflow/extensions/ai/executors/mcp.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module DurableWorkflow
+  module Extensions
+    module AI
+      module Executors
+        class MCP < Core::Executors::Base
+          def call(state)
+            server_config = resolve_server(state, config.server)
+            tool_name = config.tool
+            arguments = resolve(state, config.arguments)
+
+            result = AI::MCP::Client.call_tool(server_config, tool_name, arguments)
+
+            # Extract text content from MCP response
+            output = extract_output(result)
+
+            state = store(state, config.output, output) if config.output
+            continue(state, output: output)
+          end
+
+          private
+
+          def resolve_server(state, server_id)
+            servers = Extension.mcp_servers(workflow(state))
+            server_config = Utils.fetch(servers, server_id)
+            raise ExecutionError, "MCP server not found: #{server_id}" unless server_config
+
+            server_config
+          end
+
+          def workflow(state)
+            DurableWorkflow.registry[state.workflow_id]
+          end
+
+          def extract_output(result)
+            if result.respond_to?(:content)
+              result.content.map { |c| Utils.fetch(c, :text) }.compact.join("\n")
+            else
+              result.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable_workflow/extensions/ai/mcp/adapter.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DurableWorkflow
+  module Extensions
+    module AI
+      module MCP
+        class Adapter
+          class << self
+            # Convert RubyLLM::Tool instance to MCP::Tool
+            def to_mcp_tool(ruby_llm_tool)
+              tool_name = extract_name(ruby_llm_tool)
+              tool_description = ruby_llm_tool.description
+              tool_schema = ruby_llm_tool.class.respond_to?(:params_schema) ? ruby_llm_tool.class.params_schema : {}
+
+              captured_tool = ruby_llm_tool
+              adapter = self # Capture Adapter class for use in block
+
+              ::MCP::Tool.define(
+                name: tool_name,
+                description: tool_description,
+                input_schema: normalize_schema(tool_schema)
+              ) do |server_context:, **params|
+                adapter.execute_tool(captured_tool, params, server_context)
+              end
+            end
+
+            def execute_tool(tool, params, _server_context)
+              result = tool.call(**params.transform_keys(&:to_sym))
+              formatted = format_result(result)
+
+              ::MCP::Tool::Response.new([
+                                          { type: 'text', text: formatted }
+                                        ])
+            rescue StandardError => e
+              ::MCP::Tool::Response.new([
+                                          { type: 'text', text: "Error: #{e.message}" }
+                                        ], is_error: true)
+            end
+
+            private
+
+            def extract_name(tool)
+              if tool.class.respond_to?(:tool_def) && tool.class.tool_def
+                tool.class.tool_def.id
+              elsif tool.respond_to?(:name)
+                tool.name
+              else
+                tool.class.name&.split('::')&.last&.gsub(/([A-Z])/, '_\1')&.downcase&.sub(/^_/, '') || 'unknown'
+              end
+            end
+
+            def normalize_schema(schema)
+              return { properties: {}, required: [] } if schema.nil? || schema.empty?
+
+              {
+                properties: Utils.fetch(schema, :properties, {}),
+                required: Utils.fetch(schema, :required, [])
+              }
+            end
+
+            def format_result(result)
+              case result
+              when String then result
+              when Hash, Array then JSON.pretty_generate(result)
+              else result.to_s
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable_workflow/extensions/ai/mcp/client.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module DurableWorkflow
+  module Extensions
+    module AI
+      module MCP
+        class Client
+          @connections = {}
+
+          class << self
+            # Get or create client for server config
+            def for(server_config)
+              cache_key = server_config.url || server_config.command.to_s
+              @connections[cache_key] ||= build_client(server_config)
+            end
+
+            # List tools from server
+            def tools(server_config)
+              client = self.for(server_config)
+              client.tools
+            end
+
+            # Call tool on server
+            def call_tool(server_config, tool_name, arguments)
+              client = self.for(server_config)
+              tool = client.tools.find { |t| t.name == tool_name }
+              raise DurableWorkflow::ExecutionError, "MCP tool not found: #{tool_name}" unless tool
+
+              client.call_tool(tool: tool, arguments: arguments)
+            end
+
+            # Clear connection cache
+            def reset!
+              @connections = {}
+            end
+
+            private
+
+            def build_client(server_config)
+              transport = build_transport(server_config)
+              ::MCP::Client.new(transport: transport)
+            end
+
+            def build_transport(server_config)
+              case server_config.transport&.to_sym
+              when :stdio
+                build_stdio_transport(server_config)
+              else
+                build_http_transport(server_config)
+              end
+            end
+
+            def build_http_transport(config)
+              ::MCP::Client::HTTP.new(
+                url: config.url,
+                headers: interpolate_env(config.headers || {})
+              )
+            end
+
+            def build_stdio_transport(config)
+              # Stdio transport for command-line MCP servers
+              # This would require implementing or using a stdio transport
+              raise NotImplementedError, 'Stdio transport not yet implemented'
+            end
+
+            # Replace ${ENV_VAR} with actual values
+            def interpolate_env(headers)
+              headers.transform_values do |v|
+                v.to_s.gsub(/\$\{(\w+)\}/) { ENV.fetch(::Regexp.last_match(1), '') }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable_workflow/extensions/ai/mcp/rack_app.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rack'
+
+module DurableWorkflow
+  module Extensions
+    module AI
+      module MCP
+        class RackApp
+          def initialize(server)
+            @server = server
+          end
+
+          def call(env)
+            request = Rack::Request.new(env)
+
+            case request.request_method
+            when 'POST'
+              handle_post(request)
+            when 'GET'
+              handle_sse(request)
+            when 'DELETE'
+              handle_delete(request)
+            else
+              [405, { 'Content-Type' => 'text/plain' }, ['Method not allowed']]
+            end
+          end
+
+          private
+
+          def handle_post(request)
+            body = request.body.read
+            result = @server.handle_json(body)
+
+            [200, { 'Content-Type' => 'application/json' }, [result]]
+          rescue JSON::ParserError => e
+            error_response(-32_700, "Parse error: #{e.message}")
+          rescue StandardError
+            error_response(-32_603, 'Internal error')
+          end
+
+          def handle_sse(_request)
+            # SSE for notifications (optional)
+            [501, { 'Content-Type' => 'text/plain' }, ['SSE not implemented']]
+          end
+
+          def handle_delete(_request)
+            # Session cleanup
+            [200, {}, ['']]
+          end
+
+          def error_response(code, message)
+            [400, { 'Content-Type' => 'application/json' }, [
+              JSON.generate({
+                              jsonrpc: '2.0',
+                              error: { code: code, message: message },
+                              id: nil
+                            })
+            ]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable_workflow/extensions/ai/mcp/server.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module DurableWorkflow
+  module Extensions
+    module AI
+      module MCP
+        class Server
+          attr_reader :workflow, :options
+
+          def initialize(workflow, **options)
+            @workflow = workflow
+            @options = options
+          end
+
+          # Build MCP::Server with workflow tools
+          def build(server_context: {})
+            ::MCP::Server.new(
+              name: server_name,
+              version: server_version,
+              tools: build_tools,
+              server_context: server_context
+            )
+          end
+
+          # Run as stdio transport (for Claude Desktop)
+          def stdio(server_context: {})
+            require 'mcp/server/transports/stdio_transport'
+            server = build(server_context: server_context)
+            transport = ::MCP::Server::Transports::StdioTransport.new(server)
+            transport.open
+          end
+
+          # Build Rack app for HTTP transport
+          def rack_app(server_context: {})
+            server = build(server_context: server_context)
+            RackApp.new(server)
+          end
+
+          class << self
+            def build(workflow, **options)
+              new(workflow, **options).build
+            end
+
+            def stdio(workflow, **options)
+              new(workflow, **options).stdio
+            end
+
+            def rack_app(workflow, **options)
+              new(workflow, **options).rack_app
+            end
+          end
+
+          private
+
+          def server_name
+            options[:name] || "durable_workflow_#{workflow.id}"
+          end
+
+          def server_version
+            options[:version] || DurableWorkflow::VERSION
+          end
+
+          def build_tools
+            # Convert workflow tools to MCP tools
+            # for_workflow returns instances, not classes
+            mcp_tools = ToolRegistry.for_workflow(workflow).map do |tool_instance|
+              Adapter.to_mcp_tool(tool_instance)
+            end
+
+            # Optionally expose workflow itself as a tool
+            mcp_tools << build_workflow_tool if options[:expose_workflow]
+
+            mcp_tools
+          end
+
+          def build_workflow_tool
+            wf = workflow
+            store = DurableWorkflow.config&.store
+
+            ::MCP::Tool.define(
+              name: "run_#{workflow.id}",
+              description: workflow.description || "Run #{workflow.name} workflow",
+              input_schema: workflow_input_schema
+            ) do |server_context:, **params|
+              runner = DurableWorkflow::Runners::Sync.new(wf, store: store)
+              result = runner.run(params)
+
+              ::MCP::Tool::Response.new([{
+                                          type: 'text',
+                                          text: JSON.pretty_generate({
+                                                                       status: result.status,
+                                                                       output: result.output
+                                                                     })
+                                        }])
+            rescue StandardError => e
+              warn "Workflow error: #{e.message}\n#{e.backtrace.first(5).join("\n")}"
+              ::MCP::Tool::Response.new([{
+                                          type: 'text',
+                                          text: "Error: #{e.message}"
+                                        }], is_error: true)
+            end
+          end
+
+          def workflow_input_schema
+            props = {}
+            required = []
+
+            (workflow.inputs || []).each do |input_def|
+              props[input_def.name] = {
+                type: input_def.type,
+                description: input_def.description
+              }.compact
+              required << input_def.name if input_def.required
+            end
+
+            { properties: props, required: required }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable_workflow/extensions/ai/tool_registry.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module DurableWorkflow
+  module Extensions
+    module AI
+      class ToolRegistry
+        class << self
+          def registry
+            @registry ||= {}
+          end
+
+          # Register a RubyLLM::Tool class directly
+          def register(tool_class)
+            name = tool_name(tool_class)
+            registry[name] = tool_class
+          end
+
+          # Register from ToolDef (YAML-defined)
+          def register_from_def(tool_def)
+            tool_class = tool_def.to_ruby_llm_tool
+            registry[tool_def.id] = tool_class
+          end
+
+          # Get tool class by name
+          def [](name)
+            registry[name.to_s]
+          end
+
+          # Get all tool classes
+          def all
+            registry.values
+          end
+
+          # Get tools for a workflow
+          def for_workflow(workflow)
+            tool_ids = Extension.data_from(workflow)[:tools]&.keys || []
+            for_tool_ids(tool_ids)
+          end
+
+          # Get tool instances by IDs
+          def for_tool_ids(tool_ids)
+            tool_ids.map { |id| registry[id.to_s]&.new }.compact
+          end
+
+          # Clear registry (for testing)
+          def reset!
+            @registry = {}
+          end
+
+          private
+
+          def tool_name(tool_class)
+            if tool_class.respond_to?(:tool_def) && tool_class.tool_def
+              tool_class.tool_def.id
+            else
+              tool_class.name&.split('::')&.last&.gsub(/([A-Z])/, '_\1')&.downcase&.sub(/^_/, '') || 'unknown'
+            end
+          end
+        end
+      end
+    end
+  end
+end