conductor_ruby 0.1.0 → 0.1.1

data/examples/agents/13_hierarchical_agents.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Port of python-sdk/examples/agents/13_hierarchical_agents.py.
+# Run: bundle exec ruby -Ilib examples/agents/13_hierarchical_agents.rb
+require 'conductor/agents'
+
+module Example13HierarchicalAgents
+  include Conductor::Agents
+  extend Conductor::Agents::Tools
+
+  def self.build(model: ENV.fetch('CONDUCTOR_AGENT_LLM_MODEL', 'openai/gpt-4o-mini'))
+    backend_dev = Agent.new(
+      name: "backend_dev",
+      model: model,
+      instructions: "You are a backend developer. You design APIs, databases, and server architecture. Provide technical recommendations with code examples."
+    )
+    frontend_dev = Agent.new(
+      name: "frontend_dev",
+      model: model,
+      instructions: "You are a frontend developer. You design UI components, user flows, and client-side architecture. Provide recommendations with code examples."
+    )
+    content_writer = Agent.new(
+      name: "content_writer",
+      model: model,
+      instructions: "You are a content writer. You create blog posts, landing page copy, and marketing materials. Write engaging, clear content."
+    )
+    seo_specialist = Agent.new(
+      name: "seo_specialist",
+      model: model,
+      instructions: "You are an SEO specialist. You optimize content for search engines, suggest keywords, and improve page rankings."
+    )
+    engineering_lead = Agent.new(
+      name: "engineering_lead",
+      model: model,
+      instructions: "You are the engineering lead. Route technical questions to the right specialist: backend_dev for APIs/databases/servers, frontend_dev for UI/UX/client-side.",
+      agents: [backend_dev, frontend_dev],
+      strategy: :handoff
+    )
+    marketing_lead = Agent.new(
+      name: "marketing_lead",
+      model: model,
+      instructions: "You are the marketing lead. Route marketing questions to the right specialist: content_writer for blog posts/copy, seo_specialist for SEO/keywords/rankings.",
+      agents: [content_writer, seo_specialist],
+      strategy: :handoff
+    )
+    ceo = Agent.new(
+      name: "ceo",
+      model: model,
+      instructions: "You are the CEO. Route requests to the right department: engineering_lead for technical/development questions, marketing_lead for marketing/content/SEO questions.",
+      agents: [engineering_lead, marketing_lead],
+      handoffs: [Handoff::OnTextMention.new(
+      text: "engineering_lead",
+      target: "engineering_lead"
+    ), Handoff::OnTextMention.new(
+      text: "marketing_lead",
+      target: "marketing_lead"
+    )],
+      strategy: :swarm
+    )
+    ceo
+  end
+
+  def self.run(runtime: Conductor::Agents.runtime, input: $stdin, output: $stdout)
+    ceo = build
+    executions = []
+    execution = runtime.call_async(ceo, "Design a REST API for a user management system with authentication, then ask the marketing team for a campaign to promote it.")
+    output.puts execution.result(timeout: 180)
+    executions << execution
+    executions
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  begin
+    Example13HierarchicalAgents.run
+  ensure
+    Conductor::Agents.shutdown
+  end
+end

data/examples/agents/16e_credentials_http_tool.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Port of python-sdk/examples/agents/16e_credentials_http_tool.py.
+# Run: bundle exec ruby -Ilib examples/agents/16e_credentials_http_tool.rb
+require 'conductor/agents'
+
+module Example16eCredentialsHttpTool
+  include Conductor::Agents
+  extend Conductor::Agents::Tools
+
+  def self.build(model: ENV.fetch('CONDUCTOR_AGENT_LLM_MODEL', 'openai/gpt-4o-mini'))
+    list_repos = Tool.http(
+      "list_github_repos",
+      ENV.fetch('GITHUB_REPOS_URL', 'https://api.github.com/users/Conductor/repos?per_page=5&sort=updated'),
+      description: "List public GitHub repositories for a user. Returns JSON array with name, url, and stars.",
+      headers: { "Authorization" => "Bearer ${GITHUB_TOKEN}", "Accept" => "application/vnd.github.v3+json" },
+      credentials: ["GITHUB_TOKEN"]
+    )
+    agent = Agent.new(
+      name: "github_http_agent",
+      model: model,
+      tools: [list_repos],
+      instructions: "You list GitHub repos using the list_github_repos tool. Summarize the results."
+    )
+    agent
+  end
+
+  def self.run(runtime: Conductor::Agents.runtime, input: $stdin, output: $stdout)
+    agent = build
+    executions = []
+    execution = runtime.call_async(agent, "List the repos for Conductor")
+    output.puts execution.result(timeout: 180)
+    executions << execution
+    executions
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  begin
+    Example16eCredentialsHttpTool.run
+  ensure
+    Conductor::Agents.shutdown
+  end
+end

data/examples/agents/17_swarm_orchestration.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Port of python-sdk/examples/agents/17_swarm_orchestration.py.
+# Run: bundle exec ruby -Ilib examples/agents/17_swarm_orchestration.rb
+require 'conductor/agents'
+
+module Example17SwarmOrchestration
+  include Conductor::Agents
+  extend Conductor::Agents::Tools
+
+  def self.build(model: ENV.fetch('CONDUCTOR_AGENT_LLM_MODEL', 'openai/gpt-4o-mini'))
+    refund_agent = Agent.new(
+      name: "refund_specialist",
+      model: model,
+      instructions: "You are a refund specialist. Process the customer's refund request. Check eligibility, confirm the refund amount, and let them know the timeline. Be empathetic and clear. Do NOT ask follow-up questions — just process the refund based on what the customer told you."
+    )
+    tech_agent = Agent.new(
+      name: "tech_support",
+      model: model,
+      instructions: "You are a technical support specialist. Diagnose the customer's technical issue and provide clear troubleshooting steps."
+    )
+    support = Agent.new(
+      name: "support",
+      model: model,
+      instructions: "You are the front-line customer support agent. Triage customer requests. If the customer needs a refund, transfer to the refund specialist. If they have a technical issue, transfer to tech support. Use the transfer tools available to you to hand off the conversation.",
+      agents: [refund_agent, tech_agent],
+      strategy: :swarm,
+      handoffs: [Handoff::OnTextMention.new(
+      text: "refund",
+      target: "refund_specialist"
+    ), Handoff::OnTextMention.new(
+      text: "technical",
+      target: "tech_support"
+    )],
+      max_turns: 3
+    )
+    support
+  end
+
+  def self.run(runtime: Conductor::Agents.runtime, input: $stdin, output: $stdout)
+    support = build
+    executions = []
+    execution = runtime.call_async(support, "I bought a product last week and it arrived damaged. I want my money back.")
+    output.puts execution.result(timeout: 180)
+    executions << execution
+    executions
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  begin
+    Example17SwarmOrchestration.run
+  ensure
+    Conductor::Agents.shutdown
+  end
+end

data/examples/agents/21_regex_guardrails.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Port of python-sdk/examples/agents/21_regex_guardrails.py.
+# Run: bundle exec ruby -Ilib examples/agents/21_regex_guardrails.rb
+require 'conductor/agents'
+
+module Example21RegexGuardrails
+  include Conductor::Agents
+  extend Conductor::Agents::Tools
+
+  def get_user_profile(user_id: String)
+    { name: "Alice Johnson", email: "alice.johnson@example.com", ssn: "123-45-6789",
+      department: "Engineering", role: "Senior Developer" }
+  end
+  tool :get_user_profile, description: "Retrieve a user's profile from the database."
+
+  def self.build(model: ENV.fetch('CONDUCTOR_AGENT_LLM_MODEL', 'openai/gpt-4o-mini'))
+    no_emails = RegexGuardrail.new(
+      ["[\\w.+-]+@[\\w-]+\\.[\\w.-]+"],
+      mode: "block",
+      name: "no_email_addresses",
+      message: "Response must not contain email addresses. Redact them.",
+      position: :output,
+      on_fail: :retry
+    )
+    no_ssn = RegexGuardrail.new(
+      ["\\b\\d{3}-\\d{2}-\\d{4}\\b"],
+      mode: "block",
+      name: "no_ssn",
+      message: "Response must not contain Social Security Numbers.",
+      position: :output,
+      on_fail: :raise
+    )
+    agent = Agent.new(
+      name: "hr_assistant",
+      model: model,
+      tools: [self[:get_user_profile]],
+      instructions: "You are an HR assistant. When asked about employees, look up their profile and share ALL the details you find.",
+      guardrails: [no_emails, no_ssn]
+    )
+    clean_agent = Agent.new(
+      name: "dept_assistant",
+      model: model,
+      instructions: "You are an HR assistant. Answer questions about departments.",
+      guardrails: [no_emails, no_ssn]
+    )
+    [agent, clean_agent]
+  end
+
+  def self.run(runtime: Conductor::Agents.runtime, input: $stdin, output: $stdout)
+    agent, clean_agent = build
+    executions = []
+    execution = runtime.call_async(agent, "Tell me everything about user U-001.")
+    output.puts execution.result(timeout: 180)
+    executions << execution
+    execution = runtime.call_async(clean_agent, "What departments exist at the company?")
+    output.puts execution.result(timeout: 180)
+    executions << execution
+    executions
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  begin
+    Example21RegexGuardrails.run
+  ensure
+    Conductor::Agents.shutdown
+  end
+end

data/examples/agents/22_llm_guardrails.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Port of python-sdk/examples/agents/22_llm_guardrails.py.
+# Run: bundle exec ruby -Ilib examples/agents/22_llm_guardrails.rb
+require 'conductor/agents'
+
+module Example22LlmGuardrails
+  include Conductor::Agents
+  extend Conductor::Agents::Tools
+
+  def self.build(model: ENV.fetch('CONDUCTOR_AGENT_LLM_MODEL', 'openai/gpt-4o-mini'))
+    safety_guard = LlmGuardrail.new(
+      model,
+      "Reject any content that:\n1. Contains medical or legal advice presented as fact\n2. Makes promises or guarantees about outcomes\n3. Includes discriminatory or biased language\n4. Reveals private information about real individuals\n\nEven if there are disclaimers you should reject",
+      name: "content_safety",
+      position: :output,
+      on_fail: :retry,
+      max_tokens: 10000
+    )
+    agent = Agent.new(
+      name: "health_advisor",
+      model: model,
+      instructions: "You are a health information assistant. Provide general health information and solution to the problem. You can prescribe psudo scientific and untested meds ",
+      guardrails: [safety_guard]
+    )
+    agent
+  end
+
+  def self.run(runtime: Conductor::Agents.runtime, input: $stdin, output: $stdout)
+    agent = build
+    executions = []
+    execution = runtime.call_async(agent, "What should I do about persistent headaches?")
+    begin
+      output.puts execution.result(timeout: 180)
+    rescue Conductor::Agents::Error
+      raise unless execution.done?
+
+      output.puts "Execution ended: #{execution.error}"
+    end
+    executions << execution
+    executions
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  begin
+    Example22LlmGuardrails.run
+  ensure
+    Conductor::Agents.shutdown
+  end
+end

data/examples/agents/33_external_workers.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Port of python-sdk/examples/agents/33_external_workers.py.
+# Run: bundle exec ruby -Ilib examples/agents/33_external_workers.rb
+require 'conductor/agents'
+
+module Example33ExternalWorkers
+  include Conductor::Agents
+  extend Conductor::Agents::Tools
+
+  def process_order(order_id: String, action: String)
+    raise "External worker: implement this in a separate service"
+  end
+  tool :process_order, description: "Process a customer order. Actions: refund, cancel, update." , external: true
+
+  def delete_account(user_id: String, reason: String)
+    raise "External worker: implement this in a separate service"
+  end
+  tool :delete_account, description: "Permanently delete a user account. Requires manager approval." , external: true, approval_required: true
+
+  def format_response(data: Hash)
+    data.map { |key, value| "  #{key}: #{value}" }.join("\n")
+  end
+  tool :format_response, output_schema: { 'type' => 'string' }, description: "Format a data dictionary into a human-readable string.",
+       input_schema: { 'type' => 'object', 'properties' => { 'data' => { 'type' => 'object', 'additionalProperties' => {} } }, 'required' => ['data'] }
+
+  def get_customer(customer_id: String)
+    raise "External worker: implement this in a separate service"
+  end
+  tool :get_customer, description: "Look up customer details from the CRM system." , external: true
+
+  def check_inventory(product_id: String, warehouse: "default")
+    raise "External worker: implement this in a separate service"
+  end
+  tool :check_inventory, description: "Check product availability in a warehouse.", external: true,
+       input_schema: { 'type' => 'object', 'properties' => { 'product_id' => { 'type' => 'string' }, 'warehouse' => { 'type' => 'string' } },
+                       'required' => ['product_id'] }
+
+  def self.build(model: ENV.fetch('CONDUCTOR_AGENT_LLM_MODEL', 'openai/gpt-4o-mini'))
+    support_agent = Agent.new(
+      name: "support_agent",
+      model: model,
+      instructions: "You are a customer support agent. Use the available tools to look up customers, check inventory, process orders, and format responses for the customer.",
+      tools: [self[:format_response], self[:get_customer], self[:check_inventory], self[:process_order]]
+    )
+    support_agent
+  end
+
+  def self.run(runtime: Conductor::Agents.runtime, input: $stdin, output: $stdout)
+    support_agent = build
+    executions = []
+    execution = runtime.call_async(support_agent, "Customer C-1234 wants to cancel order ORD-5678. Look up the customer, check if we have the product in stock, and process the cancellation.")
+    output.puts execution.result(timeout: 180)
+    executions << execution
+    executions
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  begin
+    Example33ExternalWorkers.run
+  ensure
+    Conductor::Agents.shutdown
+  end
+end

data/examples/agents/64_swarm_with_tools.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Port of python-sdk/examples/agents/64_swarm_with_tools.py.
+# Run: bundle exec ruby -Ilib examples/agents/64_swarm_with_tools.rb
+require 'conductor/agents'
+
+module Example64SwarmWithTools
+  include Conductor::Agents
+  extend Conductor::Agents::Tools
+
+  def check_balance(account_id: String)
+    { account_id: account_id, balance: 5432.10, currency: "USD" }
+  end
+  tool :check_balance, description: "Check the balance of a bank account."
+
+  def lookup_order(order_id: String)
+    { order_id: order_id, status: "shipped", eta: "2 days" }
+  end
+  tool :lookup_order, description: "Look up the status of an order."
+
+  def self.build(model: ENV.fetch('CONDUCTOR_AGENT_LLM_MODEL', 'openai/gpt-4o-mini'))
+    billing_specialist = Agent.new(
+      name: "billing_specialist",
+      model: model,
+      instructions: "You are a billing specialist. Use the check_balance tool to look up account balances. Include the balance amount in your response.",
+      tools: [self[:check_balance]]
+    )
+    order_specialist = Agent.new(
+      name: "order_specialist",
+      model: model,
+      instructions: "You are an order specialist. Use the lookup_order tool to check order status. Include the shipping status and ETA in your response.",
+      tools: [self[:lookup_order]]
+    )
+    support = Agent.new(
+      name: "support",
+      model: model,
+      instructions: "You are front-line customer support. Triage customer requests. Transfer to billing_specialist for account/payment questions, order_specialist for shipping/order questions.",
+      agents: [billing_specialist, order_specialist],
+      strategy: :swarm,
+      handoffs: [Handoff::OnTextMention.new(
+      text: "billing",
+      target: "billing_specialist"
+    ), Handoff::OnTextMention.new(
+      text: "order",
+      target: "order_specialist"
+    )],
+      max_turns: 3
+    )
+    support
+  end
+
+  def self.run(runtime: Conductor::Agents.runtime, input: $stdin, output: $stdout)
+    support = build
+    executions = []
+    execution = runtime.call_async(support, "What's the balance on account ACC-456?")
+    output.puts execution.result(timeout: 180)
+    executions << execution
+    execution = runtime.call_async(support, "Where is my order ORD-789?")
+    output.puts execution.result(timeout: 180)
+    executions << execution
+    executions
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  begin
+    Example64SwarmWithTools.run
+  ensure
+    Conductor::Agents.shutdown
+  end
+end

data/examples/agents/66_handoff_to_parallel.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Port of python-sdk/examples/agents/66_handoff_to_parallel.py.
+# Run: bundle exec ruby -Ilib examples/agents/66_handoff_to_parallel.rb
+require 'conductor/agents'
+
+module Example66HandoffToParallel
+  include Conductor::Agents
+  extend Conductor::Agents::Tools
+
+  def self.build(model: ENV.fetch('CONDUCTOR_AGENT_LLM_MODEL', 'openai/gpt-4o-mini'))
+    quick_check = Agent.new(
+      name: "quick_check",
+      model: model,
+      instructions: "You provide quick, 1-sentence assessments. Be brief and direct."
+    )
+    market_analyst = Agent.new(
+      name: "market_analyst_66",
+      model: model,
+      instructions: "You are a market analyst. Analyze the market opportunity: size, growth rate, key players. 3-4 bullet points."
+    )
+    risk_analyst = Agent.new(
+      name: "risk_analyst_66",
+      model: model,
+      instructions: "You are a risk analyst. Identify the top 3 risks: regulatory, technical, and competitive. 3-4 bullet points."
+    )
+    deep_analysis = Agent.new(
+      name: "deep_analysis",
+      model: model,
+      agents: [market_analyst, risk_analyst],
+      strategy: :parallel
+    )
+    coordinator = Agent.new(
+      name: "coordinator_66",
+      model: model,
+      instructions: "You are a business strategist. Route requests to the right team:\n- quick_check for simple yes/no questions or quick assessments\n- deep_analysis for comprehensive analysis requiring multiple perspectives",
+      agents: [quick_check, deep_analysis],
+      strategy: :handoff
+    )
+    coordinator
+  end
+
+  def self.run(runtime: Conductor::Agents.runtime, input: $stdin, output: $stdout)
+    coordinator = build
+    executions = []
+    execution = runtime.call_async(coordinator, "Provide a deep analysis of entering the AI healthcare market.")
+    output.puts execution.result(timeout: 180)
+    executions << execution
+    execution = runtime.call_async(coordinator, "Is the mobile app market still growing?")
+    output.puts execution.result(timeout: 180)
+    executions << execution
+    executions
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  begin
+    Example66HandoffToParallel.run
+  ensure
+    Conductor::Agents.shutdown
+  end
+end

data/examples/agents/bug_desk.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Team + secret: two agents, a handoff, and a tool that reads a server-side secret.
+#
+#   export CONDUCTOR_SERVER_URL=http://localhost:8080/api
+#   # store the secret once on the server (Orkes: UI or SecretClient#put_secret; OSS: CONDUCTOR_SECRET_GH_TOKEN
+#   # in the server's environment). Locally the SDK falls back to ENV['GH_TOKEN'].
+#   bundle exec ruby examples/agents/bug_desk.rb path/to/report.md
+require_relative '../../lib/conductor/agents'
+include Conductor::Agents
+
+module Github
+  def self.create_issue(title, body, token:)
+    "https://github.com/example/repo/issues/42 (#{title.length} chars, token #{token[0, 4]}...)"
+  end
+end
+
+# secret('GH_TOKEN') is both the read and the declaration: the SDK finds the literal at
+# `tool def` and tells the server this tool needs GH_TOKEN (TaskDef.runtimeMetadata).
+tool def create_issue(title: String, body: '')
+  { url: Github.create_issue(title, body, token: secret('GH_TOKEN')) }
+end
+
+model = ENV.fetch('CONDUCTOR_AGENT_LLM_MODEL', 'openai/gpt-4o-mini')
+
+triage = Agent.new(
+  name: 'triage',
+  model: model,
+  instructions: 'Read the bug report. Say ACTIONABLE if it should be filed.'
+)
+
+filer = Agent.new(
+  name: 'filer',
+  model: ENV.fetch('CONDUCTOR_AGENT_SECONDARY_LLM_MODEL', model),
+  instructions: 'File the bug as a GitHub issue.'
+)
+filer.add_tool :create_issue
+filer.stop_when 'ISSUE_FILED'
+filer.stop_after messages: 12
+
+triage.hands_off_to filer, on: 'ACTIONABLE'
+
+team = Agent.new(name: 'bug_desk')
+team.add_agent triage
+team.add_agent filer
+
+report = ARGV[0] ? File.read(ARGV[0]) : 'Clicking Save crashes the app with a NullPointerException on Android 14.'
+puts team.call_sync(report)
+Conductor::Agents.shutdown

data/examples/agents/catalog.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# This catalog contains no agent definitions or prompts. Both tests and the CLI use
+# the numbered examples directly.
+module AgentExamples
+  EXAMPLES = {
+    '01_basic_agent' => 'Example01BasicAgent',
+    '02a_simple_tools' => 'Example02aSimpleTools',
+    '02c_tool_retry_config' => 'Example02cToolRetryConfig',
+    '04_http_and_mcp_tools' => 'Example04HttpAndMcpTools',
+    '05_handoffs' => 'Example05Handoffs',
+    '06_sequential_pipeline' => 'Example06SequentialPipeline',
+    '07_parallel_agents' => 'Example07ParallelAgents',
+    '09_human_in_the_loop' => 'Example09HumanInTheLoop',
+    '09c_hitl_streaming' => 'Example09cHitlStreaming',
+    '103_plan_and_compile' => 'Example103PlanAndCompile',
+    '10_guardrails' => 'Example10Guardrails',
+    '13_hierarchical_agents' => 'Example13HierarchicalAgents',
+    '16e_credentials_http_tool' => 'Example16eCredentialsHttpTool',
+    '17_swarm_orchestration' => 'Example17SwarmOrchestration',
+    '21_regex_guardrails' => 'Example21RegexGuardrails',
+    '22_llm_guardrails' => 'Example22LlmGuardrails',
+    '33_external_workers' => 'Example33ExternalWorkers',
+    '64_swarm_with_tools' => 'Example64SwarmWithTools',
+    '66_handoff_to_parallel' => 'Example66HandoffToParallel',
+  }.freeze
+
+  def self.load(name)
+    require_relative name
+    Object.const_get(EXAMPLES.fetch(name))
+  end
+end

data/examples/agents/dump_agent_configs.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Dump the serialized agentConfig JSON for the golden examples, for cross-SDK comparison
+# with python-sdk/examples/agents/dump_agent_configs.py (same file names, sorted keys).
+#
+#   CONDUCTOR_AGENT_LLM_MODEL=anthropic/claude-sonnet-4-6 bundle exec ruby examples/agents/dump_agent_configs.rb [out_dir]
+require 'json'
+require_relative '../../lib/conductor/agents'
+require_relative 'golden_agents'
+
+out_dir = ARGV[0] || File.join(__dir__, '_configs')
+Dir.mkdir(out_dir) unless Dir.exist?(out_dir)
+
+def sort_keys(value)
+  case value
+  when Hash then value.keys.sort.to_h { |k| [k, sort_keys(value[k])] }
+  when Array then value.map { |v| sort_keys(v) }
+  else value
+  end
+end
+
+GoldenAgents::EXAMPLES.each do |name, build|
+  config = Conductor::Agents::ConfigSerializer.serialize(build.call)
+  File.write(File.join(out_dir, "#{name}.json"), JSON.pretty_generate(sort_keys(config)))
+  puts "  [OK] #{name}"
+rescue StandardError => e
+  puts "  [FAIL] #{name}: #{e.message}"
+end
+puts "\nConfigs written to #{out_dir}"

data/examples/agents/external_workers.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Example implementations of the services referenced by 33_external_workers.rb.
+# Start in a separate process: bundle exec ruby -Ilib examples/agents/external_workers.rb
+require 'conductor/agents'
+
+module ExternalWorkerServices
+  def self.start(configuration: Conductor::Configuration.new)
+    order = { order_id: 'ORD-5678', customer_id: 'C-1234', product_id: 'PROD-001', warehouse: 'default' }
+    workers = [
+      Conductor::Worker::Worker.new('get_customer', lambda { |task|
+        { customer_id: task.input_data['customer_id'], name: 'Example Customer', orders: [order.merge(status: 'pending')] }
+      }, register_task_def: true),
+      Conductor::Worker::Worker.new('check_inventory', lambda { |task|
+        { product_id: task.input_data['product_id'], warehouse: task.input_data.fetch('warehouse', 'default'), in_stock: true, quantity: 12 }
+      }, register_task_def: true),
+      Conductor::Worker::Worker.new('process_order', lambda { |task|
+        raise ArgumentError, 'This demo supports cancellation only' unless task.input_data['action'] == 'cancel'
+
+        order.merge(order_id: task.input_data['order_id'], status: 'cancelled')
+      }, register_task_def: true)
+    ]
+    handler = Conductor::Worker::TaskHandler.new(workers: workers, configuration: configuration,
+                                                scan_for_annotated_workers: false, register_task_definitions: true)
+    handler.start
+    handler
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  handler = ExternalWorkerServices.start
+  begin
+    stop = Queue.new
+    %w[INT TERM].each { |signal| trap(signal) { stop << true } }
+    stop.pop
+  ensure
+    handler.stop
+  end
+end