agent-harness 0.11.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 635aae919a5bbbf99af4a24199b45507370c01ccbf637bfd8d9d0fa18bdb3c22
-  data.tar.gz: 30548d834ae0195030e98565007ced6ebf140f12f9a489ae10a6d423c40e087f
+  metadata.gz: cf9a5083c42a6675255f4c0ea0516ab99473813020e3a875b02eeda98b937db8
+  data.tar.gz: e070d74c397e02260d2994783c42124f45ac41b15a7c070834dd43c9c59e712a
 SHA512:
-  metadata.gz: ac200425094b482ad90fd6492ba0bf4d612ed08560bacde517c988375d1d452b12aca7c34f8ed9519cf907daa87a07a96a4c044952126ce3cd9e37f2d6b9a788
-  data.tar.gz: a871de9fcc11224506f4220025016b3b7201ef97bc1e1aca918562c1f983b9dd175a93dbd6315a71a3a270234d3b9cd019f7deaa82030b984e11434ca86328f8
+  metadata.gz: 7bce4c50dc634010ce8d7ac38c4adc661fdff51e2b055d9a585c0a7ef745f4a365a7aa9c68fedac63cfcbce7d7bea18f74a69b1622f2cde8fc5a6d38312ce2df
+  data.tar.gz: cd9adee894f938a0bb104cd4648766f2b6b6f89e1080874436dd774f8313213bdea4d63d3fed0a81b7bddeca319c8e54a39588726fb40f724bb8d858a85314fc

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.11.0"
+  ".": "0.11.1"
 }

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.11.1](https://github.com/viamin/agent-harness/compare/agent-harness/v0.11.0...agent-harness/v0.11.1) (2026-04-26)
+
+
+### Bug Fixes
+
+* 163: Support provider-agnostic sub-agent definitions ([#166](https://github.com/viamin/agent-harness/issues/166)) ([1a00c35](https://github.com/viamin/agent-harness/commit/1a00c35f61c624b23f8d37b0d1b41e007d007ad3))
+
 ## [0.11.0](https://github.com/viamin/agent-harness/compare/agent-harness/v0.10.0...agent-harness/v0.11.0) (2026-04-25)
 
 

data/lib/agent_harness/configuration.rb

@@ -23,6 +23,7 @@ module AgentHarness
     attr_writer :command_executor
 
     attr_reader :providers, :orchestration_config, :callbacks, :custom_provider_classes
+    attr_reader :sub_agents, :tool_registry, :mcp_servers
 
     def initialize
       @logger = nil # Will use null logger if not set
@@ -36,6 +37,9 @@ module AgentHarness
       @orchestration_config = OrchestrationConfig.new
       @callbacks = CallbackRegistry.new
       @custom_provider_classes = {}
+      @sub_agents = {}
+      @tool_registry = ToolRegistry.new
+      @mcp_servers = {}
     end
 
     # Get or lazily initialize the command executor
@@ -74,6 +78,78 @@ module AgentHarness
       @custom_provider_classes[name.to_sym] = klass
     end
 
+    # Configure a provider-agnostic sub-agent definition.
+    #
+    # @param name [Symbol, String] sub-agent name
+    # @param attributes [Hash] sub-agent attributes
+    # @yield [Hash] mutable attributes hash before validation
+    # @return [SubAgentConfig] registered sub-agent config
+    def sub_agent(name, attributes = {})
+      attributes = attributes.dup
+      yield(attributes) if block_given?
+      attributes[:name] = name
+
+      config = SubAgentConfig.from_hash(attributes)
+      @sub_agents[config.name] = config
+    end
+
+    # Load sub-agent definitions from a YAML or Markdown file.
+    #
+    # @param path [String] file path
+    # @return [Array<SubAgentConfig>] loaded sub-agents
+    def load_sub_agents(path)
+      SubAgentFileLoader.load(path).each do |sub_agent|
+        @sub_agents[sub_agent.name] = sub_agent
+      end
+    end
+
+    # Register a generic tool definition that sub-agents can reference.
+    #
+    # @param name [Symbol, String] tool name
+    # @param description [String, nil] tool description
+    # @param provider_mappings [Hash] provider-specific mappings
+    # @return [ToolDefinition]
+    def register_tool(name, description: nil, **provider_mappings)
+      @tool_registry.register(name, description: description, **provider_mappings)
+    end
+
+    # Register a named MCP server for later reference by sub-agents.
+    #
+    # @param name [Symbol, String] server name
+    # @param definition [Hash, McpServer, nil] server definition
+    # @param attributes [Hash] server attributes
+    # @return [McpServer]
+    def register_mcp_server(name, definition = nil, **attributes)
+      server = if definition.is_a?(McpServer)
+        definition
+      else
+        payload = (definition || attributes).dup
+        payload[:name] ||= name.to_s
+        McpServer.from_hash(payload)
+      end
+
+      @mcp_servers[name.to_sym] = server
+    end
+
+    # Resolve a named or inline sub-agent definition.
+    #
+    # @param reference [Symbol, String, Hash, SubAgentConfig, nil] sub-agent reference
+    # @return [SubAgentConfig, nil] resolved sub-agent config
+    def resolve_sub_agent(reference)
+      case reference
+      when nil
+        nil
+      when SubAgentConfig
+        reference
+      when Hash
+        SubAgentConfig.from_hash(reference)
+      else
+        @sub_agents.fetch(reference.to_sym) do
+          raise ConfigurationError, "Unknown sub-agent: #{reference}"
+        end
+      end
+    end
+
     # Register callback for token usage events
     #
     # @yield [TokenEvent] called when tokens are used
@@ -263,6 +339,67 @@ module AgentHarness
     end
   end
 
+  # Provider-agnostic tool definition used during sub-agent translation.
+  class ToolDefinition
+    attr_reader :name, :description, :provider_mappings
+
+    def initialize(name:, description: nil, provider_mappings: {})
+      @name = name.to_sym
+      @description = description
+      @provider_mappings = deep_dup(provider_mappings).each_with_object({}) do |(provider, value), mappings|
+        mappings[provider.to_sym] = value
+      end.freeze
+    end
+
+    def mapping_for(provider)
+      deep_dup(@provider_mappings[provider.to_sym])
+    end
+
+    def to_h
+      {name: @name, description: @description, provider_mappings: deep_dup(@provider_mappings)}
+    end
+
+    private
+
+    def deep_dup(value)
+      case value
+      when Array
+        value.map { |entry| deep_dup(entry) }
+      when Hash
+        value.each_with_object({}) { |(key, entry), copy| copy[key] = deep_dup(entry) }
+      else
+        value.dup
+      end
+    rescue TypeError
+      value
+    end
+  end
+
+  # Registry for canonical tool definitions referenced by sub-agents.
+  class ToolRegistry
+    def initialize
+      @tools = {}
+    end
+
+    def register(name, description: nil, **provider_mappings)
+      @tools[name.to_sym] = ToolDefinition.new(
+        name: name,
+        description: description,
+        provider_mappings: provider_mappings
+      )
+    end
+
+    def fetch(name)
+      @tools.fetch(name.to_sym) do
+        raise ConfigurationError, "Unknown tool: #{name}"
+      end
+    end
+
+    def registered?(name)
+      @tools.key?(name.to_sym)
+    end
+  end
+
   # Registry for event callbacks
   class CallbackRegistry
     def initialize

data/lib/agent_harness/providers/base.rb

@@ -126,6 +126,8 @@ module AgentHarness
 
         # Coerce provider_runtime from Hash if needed
         options = normalize_provider_runtime(options)
+        options = normalize_sub_agent(options)
+        prompt = apply_sub_agent_to_prompt(prompt, options[:translated_sub_agent])
 
         # Normalize and validate MCP servers
         options = normalize_mcp_servers(options)
@@ -210,6 +212,7 @@ module AgentHarness
         end
 
         options = normalize_provider_runtime(options)
+        options = normalize_sub_agent(options)
         runtime = options[:provider_runtime]
         conversation ||= messages
         raise ArgumentError, "conversation or messages is required" unless conversation
@@ -217,6 +220,7 @@ module AgentHarness
 
         transport = resolve_chat_transport(options)
         messages = format_messages_for_transport(conversation, transport)
+        messages = apply_sub_agent_to_messages(messages, options[:translated_sub_agent])
         transport_opts = chat_transport_options(runtime, options)
         transport_opts[:on_chat_chunk] = on_chat_chunk if on_chat_chunk
         transport_opts[:observer] = observer if observer
@@ -446,6 +450,33 @@ module AgentHarness
         options.merge(mcp_servers: normalized)
       end
 
+      def normalize_sub_agent(options)
+        sub_agent = options[:sub_agent]
+        return options unless sub_agent
+
+        resolved = AgentHarness.configuration.resolve_sub_agent(sub_agent)
+        translated = SubAgentTranslator.for_provider(
+          self.class.provider_name,
+          resolved,
+          tool_registry: AgentHarness.configuration.tool_registry,
+          mcp_servers: AgentHarness.configuration.mcp_servers
+        )
+
+        options.merge(sub_agent: resolved, translated_sub_agent: translated)
+      end
+
+      def apply_sub_agent_to_prompt(prompt, translated_sub_agent)
+        return prompt unless translated_sub_agent
+
+        [translated_sub_agent[:runtime_instructions], "User task:\n#{prompt}"].join("\n\n")
+      end
+
+      def apply_sub_agent_to_messages(messages, translated_sub_agent)
+        return messages unless translated_sub_agent
+
+        [{role: "system", content: translated_sub_agent[:runtime_instructions]}] + messages
+      end
+
       def command_execution_options(options)
         execution_options = {
           idle_timeout: options[:idle_timeout],

data/lib/agent_harness/sub_agent_config.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module AgentHarness
+  # Canonical provider-agnostic sub-agent definition.
+  class SubAgentConfig
+    attr_reader :name, :description, :instructions, :model, :tools, :mcp_servers
+    attr_reader :constraints, :handoff_conditions, :type, :sub_agents, :routing
+
+    def initialize(name:, description:, instructions:, model: "default", tools: [],
+      mcp_servers: [], constraints: {}, handoff_conditions: [], type: nil,
+      sub_agents: [], routing: nil)
+      @name = normalize_name(name)
+      @description = validate_string!(:description, description)
+      @instructions = validate_string!(:instructions, instructions)
+      @model = normalize_model(model)
+      @tools = normalize_array(:tools, tools)
+      @mcp_servers = normalize_array(:mcp_servers, mcp_servers)
+      @constraints = normalize_hash(:constraints, constraints)
+      @handoff_conditions = normalize_array(:handoff_conditions, handoff_conditions)
+      @type = type&.to_sym
+      @sub_agents = normalize_array(:sub_agents, sub_agents)
+      @routing = routing.nil? ? nil : normalize_hash(:routing, routing)
+    end
+
+    def self.from_hash(hash)
+      unless hash.is_a?(Hash)
+        raise ConfigurationError, "Sub-agent definition must be a Hash, got #{hash.class}"
+      end
+
+      attrs = hash.each_with_object({}) do |(key, value), memo|
+        memo[key.to_sym] = value
+      end
+
+      %i[name description instructions].each do |field|
+        value = attrs[field]
+        next if value.is_a?(String) && !value.strip.empty?
+        next if value.is_a?(Symbol)
+
+        raise ConfigurationError, "#{field} is required"
+      end
+
+      new(**attrs)
+    end
+
+    def to_h
+      {
+        name: @name,
+        description: @description,
+        instructions: @instructions,
+        model: @model,
+        tools: deep_dup(@tools),
+        mcp_servers: deep_dup(@mcp_servers),
+        constraints: deep_dup(@constraints),
+        handoff_conditions: deep_dup(@handoff_conditions),
+        type: @type,
+        sub_agents: deep_dup(@sub_agents),
+        routing: deep_dup(@routing)
+      }.compact
+    end
+
+    private
+
+    def normalize_name(name)
+      value = validate_string!(:name, name)
+      value.tr(" ", "_").to_sym
+    end
+
+    def normalize_model(model)
+      return "default" if model.nil?
+
+      validate_string!(:model, model)
+    end
+
+    def validate_string!(field, value)
+      unless value.is_a?(String) || value.is_a?(Symbol)
+        raise ConfigurationError, "#{field} must be a String or Symbol"
+      end
+
+      string = value.to_s.strip
+      raise ConfigurationError, "#{field} is required" if string.empty?
+
+      string
+    end
+
+    def normalize_array(field, value)
+      return [].freeze if value.nil?
+
+      unless value.is_a?(Array)
+        raise ConfigurationError, "#{field} must be an Array"
+      end
+
+      deep_dup(value).freeze
+    end
+
+    def normalize_hash(field, value)
+      return {}.freeze if value.nil?
+
+      unless value.is_a?(Hash)
+        raise ConfigurationError, "#{field} must be a Hash"
+      end
+
+      deep_dup(value).freeze
+    end
+
+    def deep_dup(value)
+      case value
+      when Array
+        value.map { |entry| deep_dup(entry) }
+      when Hash
+        value.each_with_object({}) { |(key, entry), copy| copy[key] = deep_dup(entry) }
+      else
+        value.dup
+      end
+    rescue TypeError
+      value
+    end
+  end
+end

data/lib/agent_harness/sub_agent_file_loader.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module AgentHarness
+  # Loads canonical sub-agent definitions from YAML or Markdown files.
+  class SubAgentFileLoader
+    class << self
+      def load(path)
+        case File.extname(path).downcase
+        when ".yml", ".yaml"
+          load_yaml(path)
+        when ".md", ".markdown"
+          [load_markdown(path)]
+        else
+          raise ConfigurationError, "Unsupported sub-agent definition format: #{path}"
+        end
+      end
+
+      private
+
+      def load_yaml(path)
+        parsed = YAML.safe_load_file(path, permitted_classes: [], aliases: false)
+        unless parsed.is_a?(Hash)
+          raise ConfigurationError, "YAML sub-agent definition must be a Hash"
+        end
+
+        agents = parsed["agents"] || parsed[:agents] || [parsed]
+        unless agents.is_a?(Array)
+          raise ConfigurationError, "YAML sub-agent definitions must provide an agents Array"
+        end
+
+        agents.map { |entry| SubAgentConfig.from_hash(entry) }
+      rescue Psych::SyntaxError => e
+        raise ConfigurationError, "Invalid YAML in #{path}: #{e.message}"
+      end
+
+      def load_markdown(path)
+        content = File.read(path)
+        match = content.match(/\A---\s*\n(?<frontmatter>.*?)\n---\s*\n?(?<body>.*)\z/m)
+        raise ConfigurationError, "Markdown sub-agent definitions require YAML frontmatter" unless match
+
+        attrs = YAML.safe_load(match[:frontmatter], permitted_classes: [], aliases: false) || {}
+        unless attrs.is_a?(Hash)
+          raise ConfigurationError, "Markdown frontmatter must be a Hash"
+        end
+
+        attrs["instructions"] ||= match[:body].strip
+        SubAgentConfig.from_hash(attrs)
+      rescue Psych::SyntaxError => e
+        raise ConfigurationError, "Invalid frontmatter in #{path}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/agent_harness/sub_agent_translator.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module AgentHarness
+  # Translates canonical sub-agent definitions into provider-specific formats.
+  module SubAgentTranslator
+    class << self
+      def for_provider(provider, sub_agent_config, tool_registry: AgentHarness.configuration.tool_registry,
+        mcp_servers: AgentHarness.configuration.mcp_servers)
+        config = normalize_sub_agent_config(sub_agent_config)
+        normalized_provider = normalize_provider(provider)
+        tools = resolve_tools(config.tools, provider: normalized_provider, tool_registry: tool_registry)
+        servers = resolve_mcp_servers(config.mcp_servers, mcp_servers: mcp_servers)
+
+        case normalized_provider
+        when :anthropic
+          translate_for_anthropic(config, tools: tools, mcp_servers: servers)
+        when :openai
+          translate_for_openai(config, tools: tools, mcp_servers: servers)
+        when :google
+          translate_for_google(config, tools: tools, mcp_servers: servers)
+        when :claude_code
+          translate_for_claude_code(config, tools: tools, mcp_servers: servers)
+        when :codex
+          translate_for_codex(config, tools: tools, mcp_servers: servers)
+        when :pi
+          translate_for_pi(config, tools: tools, mcp_servers: servers)
+        else
+          translate_generic(normalized_provider, config, tools: tools, mcp_servers: servers)
+        end
+      end
+
+      private
+
+      def normalize_sub_agent_config(sub_agent_config)
+        case sub_agent_config
+        when SubAgentConfig
+          sub_agent_config
+        when Hash
+          SubAgentConfig.from_hash(sub_agent_config)
+        else
+          raise ConfigurationError, "Sub-agent config must be a SubAgentConfig or Hash"
+        end
+      end
+
+      def normalize_provider(provider)
+        case provider.to_sym
+        when :claude then :anthropic
+        when :gemini then :google
+        else provider.to_sym
+        end
+      end
+
+      def resolve_tools(tool_refs, provider:, tool_registry:)
+        tool_refs.map do |tool|
+          case tool
+          when Symbol, String
+            mapping = tool_registry.fetch(tool).mapping_for(provider)
+            mapping.nil? ? tool.to_s : mapping
+          when Hash
+            deep_dup(tool)
+          else
+            raise ConfigurationError, "Unsupported tool reference #{tool.inspect} in sub-agent definition"
+          end
+        end
+      end
+
+      def resolve_mcp_servers(server_refs, mcp_servers:)
+        server_refs.map do |server|
+          resolved = case server
+          when McpServer
+            server
+          when Symbol, String
+            mcp_servers.fetch(server.to_sym) do
+              raise ConfigurationError, "Unknown MCP server: #{server}"
+            end
+          when Hash
+            McpServer.from_hash(server)
+          else
+            raise ConfigurationError, "Unsupported MCP server reference #{server.inspect} in sub-agent definition"
+          end
+
+          resolved.to_h
+        end
+      end
+
+      def translate_for_anthropic(config, tools:, mcp_servers:)
+        {
+          provider: :anthropic,
+          format: :agent_sdk,
+          agent: {
+            name: config.name.to_s,
+            description: config.description,
+            instructions: config.instructions,
+            model: config.model,
+            tools: tools,
+            mcp_servers: mcp_servers,
+            constraints: deep_dup(config.constraints)
+          },
+          runtime_instructions: runtime_instructions(config)
+        }
+      end
+
+      def translate_for_openai(config, tools:, mcp_servers:)
+        {
+          provider: :openai,
+          format: :responses,
+          assistant: {
+            name: config.name.to_s,
+            description: config.description,
+            instructions: config.instructions,
+            model: config.model,
+            tools: tools,
+            metadata: {
+              mcp_servers: mcp_servers,
+              constraints: deep_dup(config.constraints)
+            }
+          },
+          runtime_instructions: runtime_instructions(config)
+        }
+      end
+
+      def translate_for_google(config, tools:, mcp_servers:)
+        {
+          provider: :google,
+          format: :adk,
+          agent: {
+            name: config.name.to_s,
+            description: config.description,
+            instruction: config.instructions,
+            model: config.model,
+            tools: tools,
+            mcp_servers: mcp_servers,
+            constraints: deep_dup(config.constraints)
+          },
+          runtime_instructions: runtime_instructions(config)
+        }
+      end
+
+      def translate_for_claude_code(config, tools:, mcp_servers:)
+        frontmatter = {
+          "name" => config.name.to_s,
+          "description" => config.description,
+          "model" => config.model,
+          "tools" => tools,
+          "mcp_servers" => mcp_servers,
+          "constraints" => deep_dup(config.constraints)
+        }.delete_if { |_key, value| value.respond_to?(:empty?) ? value.empty? : value.nil? }
+
+        {
+          provider: :claude_code,
+          format: :markdown,
+          content: build_markdown_definition(frontmatter, config.instructions),
+          runtime_instructions: runtime_instructions(config)
+        }
+      end
+
+      def translate_for_codex(config, tools:, mcp_servers:)
+        {
+          provider: :codex,
+          format: :delegated_prompt,
+          definition: {
+            name: config.name.to_s,
+            description: config.description,
+            instructions: config.instructions,
+            model: config.model,
+            tools: tools,
+            mcp_servers: mcp_servers,
+            constraints: deep_dup(config.constraints)
+          },
+          runtime_instructions: runtime_instructions(config)
+        }
+      end
+
+      def translate_for_pi(config, tools:, mcp_servers:)
+        frontmatter = {
+          "name" => config.name.to_s,
+          "description" => config.description,
+          "model" => config.model,
+          "tools" => tools,
+          "mcp_servers" => mcp_servers
+        }.delete_if { |_key, value| value.respond_to?(:empty?) ? value.empty? : value.nil? }
+
+        {
+          provider: :pi,
+          format: :skill_markdown,
+          content: build_markdown_definition(frontmatter, config.instructions),
+          runtime_instructions: runtime_instructions(config)
+        }
+      end
+
+      def translate_generic(provider, config, tools:, mcp_servers:)
+        {
+          provider: provider,
+          format: :generic,
+          definition: {
+            name: config.name.to_s,
+            description: config.description,
+            instructions: config.instructions,
+            model: config.model,
+            tools: tools,
+            mcp_servers: mcp_servers,
+            constraints: deep_dup(config.constraints)
+          },
+          runtime_instructions: runtime_instructions(config)
+        }
+      end
+
+      def runtime_instructions(config)
+        <<~TEXT.strip
+          Sub-agent role: #{config.name}
+          Description: #{config.description}
+
+          Follow these sub-agent instructions exactly:
+          #{config.instructions}
+        TEXT
+      end
+
+      def build_markdown_definition(frontmatter, instructions)
+        <<~MARKDOWN
+          ---
+          #{YAML.dump(frontmatter).sub(/\A---\s*\n/, "").strip}
+          ---
+          #{instructions}
+        MARKDOWN
+      end
+
+      def deep_dup(value)
+        case value
+        when Array
+          value.map { |entry| deep_dup(entry) }
+        when Hash
+          value.each_with_object({}) { |(key, entry), copy| copy[key] = deep_dup(entry) }
+        else
+          value.dup
+        end
+      rescue TypeError
+        value
+      end
+    end
+  end
+end

data/lib/agent_harness/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AgentHarness
-  VERSION = "0.11.0"
+  VERSION = "0.11.1"
 end

data/lib/agent_harness.rb

@@ -77,6 +77,23 @@ module AgentHarness
       conductor.send_message(prompt, provider: provider, executor: executor, **options)
     end
 
+    # Resolve a canonical sub-agent definition by name or inline payload.
+    #
+    # @param reference [Symbol, String, Hash, SubAgentConfig]
+    # @return [SubAgentConfig]
+    def sub_agent(reference)
+      configuration.resolve_sub_agent(reference)
+    end
+
+    # Translate a canonical sub-agent definition into a provider-specific format.
+    #
+    # @param reference [Symbol, String, Hash, SubAgentConfig] sub-agent reference
+    # @param provider [Symbol, String] target provider
+    # @return [Hash] provider-specific sub-agent definition
+    def translate_sub_agent(reference, provider:)
+      SubAgentTranslator.for_provider(provider, sub_agent(reference))
+    end
+
     # Get a provider instance
     # @param name [Symbol] the provider name
     # @return [Providers::Base] the provider instance
@@ -261,6 +278,9 @@ end
 # Core components
 require_relative "agent_harness/errors"
 require_relative "agent_harness/mcp_server"
+require_relative "agent_harness/sub_agent_config"
+require_relative "agent_harness/sub_agent_file_loader"
+require_relative "agent_harness/sub_agent_translator"
 require_relative "agent_harness/provider_runtime"
 require_relative "agent_harness/execution_preparation"
 require_relative "agent_harness/configuration"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agent-harness
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Bart Agapinan
@@ -132,6 +132,9 @@ files:
 - lib/agent_harness/providers/registry.rb
 - lib/agent_harness/providers/token_usage_parsing.rb
 - lib/agent_harness/response.rb
+- lib/agent_harness/sub_agent_config.rb
+- lib/agent_harness/sub_agent_file_loader.rb
+- lib/agent_harness/sub_agent_translator.rb
 - lib/agent_harness/text_transport.rb
 - lib/agent_harness/token_tracker.rb
 - lib/agent_harness/version.rb