agent-cli-runtime 0.1.1 → 0.2.0

data/lib/agent_cli_runtime/profile.rb

@@ -27,7 +27,8 @@ module AgentCliRuntime
                 :effort_argument_builder, :launcher_identity,
                 :cli_capabilities, :declared_capability_support,
                 :credential_environment_keys, :configuration_environment_key,
-                :default_configuration_directory
+                :default_configuration_directory,
+                :permission_policy_required, :result_parser
 
     def initialize(name:, bin_default:, headless_flag:, version_flag:,
                    env_bin_override_keys: [], permission_skip_flag: nil,
@@ -39,7 +40,8 @@ module AgentCliRuntime
                    usage_extractor: nil, auth_configuration_probe: nil,
                    cli_capabilities: {}, raw_cli_arguments_supported: false,
                    credential_environment_keys: [], configuration_environment_key: nil,
-                   default_configuration_directory: nil)
+                   default_configuration_directory: nil,
+                   permission_policy_required: false, result_parser: nil)
       normalized_prompt_style = prompt_style.to_sym
       unless PROMPT_STYLES.include?(normalized_prompt_style)
         raise ArgumentError,
@@ -78,6 +80,8 @@ module AgentCliRuntime
       @default_configuration_directory = optional_relative_directory(
         default_configuration_directory
       )
+      @permission_policy_required = permission_policy_required == true
+      @result_parser = result_parser
       @declared_capability_support = build_declared_capability_support
       freeze
     end
@@ -102,6 +106,10 @@ module AgentCliRuntime
         raise ArgumentError,
               "agent profile #{@name.inspect} cannot enforce read-only sandboxing"
       end
+      if permission_mode.nil? && @permission_policy_required
+        raise ConfigurationError,
+              "agent profile #{@name.inspect} requires an explicit OpenCode permission policy"
+      end
       return [] unless @permission_skip_flag
       return [ @permission_skip_flag ] unless @name == :claude && permission_mode
       return [ @permission_skip_flag ] if permission_mode == "bypassPermissions"
@@ -213,6 +221,26 @@ module AgentCliRuntime
       nil
     end
 
+    def parse_run(stdout)
+      unless @result_parser
+        raise UnsupportedCapability,
+              "agent profile #{@name.inspect} has no strict result parser"
+      end
+
+      @result_parser.parse_run(stdout)
+    end
+
+    def normalize_captured_result(captured, requested_route:)
+      unless @result_parser
+        raise UnsupportedCapability,
+              "agent profile #{@name.inspect} has no strict result parser"
+      end
+
+      @result_parser.normalize(
+        captured, requested_route: requested_route, profile: self
+      )
+    end
+
     def configuration_directory(home: nil, env: ENV)
       if @configuration_environment_key
         configured = env[@configuration_environment_key].to_s
@@ -250,6 +278,12 @@ module AgentCliRuntime
       flags.dup
     end
 
+    def capture_local(*arguments, env: ENV, timeout_sec: CAPTURE_TIMEOUT_SECONDS)
+      bounded_capture3(
+        bin(env:), *arguments, timeout_sec: timeout_sec, env: env
+      )
+    end
+
     private
 
     def immutable_string(value)

data/lib/agent_cli_runtime/profiles.rb

@@ -103,6 +103,37 @@ module AgentCliRuntime
       home_path(home, ".grok", "auth.json")
     end
 
+    def opencode_auth_path(home:, env:)
+      data_home = env["XDG_DATA_HOME"]
+      if !data_home.to_s.empty?
+        unless File.absolute_path?(data_home)
+          raise ArgumentError, "XDG_DATA_HOME must be absolute"
+        end
+
+        return File.join(data_home, "opencode", "auth.json")
+      end
+
+      home_path(home, ".local", "share", "opencode", "auth.json")
+    end
+
+    def opencode_model_arguments(model)
+      route = Route.parse(model)
+      [ "--model", route.to_s ]
+    end
+
+    OPENCODE_VARIANTS = %w[minimal low medium high xhigh max].freeze
+
+    def opencode_variant_arguments(variant)
+      normalized = variant.to_s
+      unless OPENCODE_VARIANTS.include?(normalized)
+        raise ArgumentError,
+              "unsupported OpenCode variant #{variant.inspect}; expected one of " \
+              "#{OPENCODE_VARIANTS.join(', ')}"
+      end
+
+      [ "--variant", normalized ]
+    end
+
     CLAUDE = Profile.new(
       name: :claude,
       bin_default: "claude",
@@ -242,7 +273,45 @@ module AgentCliRuntime
       end
     )
 
-    PROFILES = [ CLAUDE, CODEX, PI, GROK ].to_h do |profile|
+    OPENCODE = Profile.new(
+      name: :opencode,
+      bin_default: "opencode",
+      env_bin_override_keys: %w[
+        AGENT_CLI_RUNTIME_OPENCODE_BIN HIVE_OPENCODE_BIN
+      ],
+      headless_flag: "run",
+      output_format_flags: [ "--format", "json" ],
+      version_flag: "--version",
+      min_version: "1.18.16",
+      model_argument_builder: ->(model) { opencode_model_arguments(model) },
+      effort_argument_builder:
+        ->(variant) { opencode_variant_arguments(variant) },
+      launcher_identity: "opencode-cli/v1",
+      credential_environment_keys: PI_CREDENTIAL_ENVIRONMENT_KEYS,
+      configuration_environment_key: "OPENCODE_CONFIG_DIR",
+      default_configuration_directory: ".config/opencode",
+      permission_policy_required: true,
+      result_parser: OpenCode::ResultParser,
+      cli_capabilities: {
+        json_events: [ "run", "--format" ],
+        working_directory: [ "run", "--dir" ],
+        model_variant: [ "run", "--variant" ],
+        pure: [ "run", "--pure" ],
+        sanitized_export: [ "export", "--sanitize" ]
+      },
+      auth_configuration_probe: lambda do |home:, env:|
+        if env_configured?(env, *PI_CREDENTIAL_ENVIRONMENT_KEYS)
+          AuthConfiguration.new(status: :configured, source: "environment")
+        else
+          auth_from_file(
+            opencode_auth_path(home:, env:),
+            source: "opencode auth.json"
+          )
+        end
+      end
+    )
+
+    PROFILES = [ CLAUDE, CODEX, PI, GROK, OPENCODE ].to_h do |profile|
       [ profile.name, profile ]
     end.freeze
     PROVIDER_ORDER = PROFILES.keys.freeze

data/lib/agent_cli_runtime/runtime.rb

@@ -63,9 +63,13 @@ module AgentCliRuntime
       compilation_error!(profile, e)
     end
 
-    def prepare!(profile)
+    def prepare!(profile, env: ENV)
+      if profile.is_a?(OpenCodePreparationRequest)
+        return OpenCode::Overlay.prepare!(profile, env:)
+      end
+
       resolved = Profiles.resolve(profile)
-      result = Probe.call(resolved)
+      result = Probe.call(resolved, env:)
       return result if result.ready
 
       evidence = unsupported_evidence(
@@ -121,6 +125,16 @@ module AgentCliRuntime
       )
     end
 
+    def parse_run(profile, stdout:)
+      Profiles.resolve(profile).parse_run(stdout)
+    end
+
+    def normalize(profile, captured, requested_route:)
+      Profiles.resolve(profile).normalize_captured_result(
+        captured, requested_route:
+      )
+    end
+
     def supported_evidence(profile, capability, arguments = [])
       CapabilityEvidence.new(
         capability: capability,

data/lib/agent_cli_runtime/values.rb

@@ -1,4 +1,11 @@
 module AgentCliRuntime
+  OPENCODE_OVERLAY_ENVIRONMENT_KEYS = %w[
+    XDG_CONFIG_HOME XDG_DATA_HOME XDG_CACHE_HOME XDG_STATE_HOME TMPDIR
+    OPENCODE_CONFIG OPENCODE_DISABLE_PROJECT_CONFIG
+    OPENCODE_DISABLE_CLAUDE_CODE OPENCODE_DISABLE_MODELS_FETCH
+    OPENCODE_DISABLE_AUTOUPDATE OPENCODE_PURE
+  ].freeze
+
   module Immutable
     module_function
 
@@ -14,6 +21,28 @@ module AgentCliRuntime
     def symbols(values)
       Array(values).map(&:to_sym).uniq.freeze
     end
+
+    def hash(value)
+      unless value.is_a?(Hash)
+        raise ArgumentError, "value must be a Hash"
+      end
+
+      value.each_with_object({}) do |(key, item), result|
+        result[string(key)] = deep(item)
+      end.freeze
+    end
+
+    def deep(value)
+      case value
+      when Hash then hash(value)
+      when Array then value.map { |item| deep(item) }.freeze
+      when String then string(value)
+      when Symbol, Numeric, TrueClass, FalseClass, NilClass then value
+      else
+        raise ArgumentError,
+              "unsupported immutable value #{value.class}"
+      end
+    end
   end
   private_constant :Immutable
 
@@ -173,4 +202,407 @@ module AgentCliRuntime
       )
     end
   end
+
+
+  Route = Data.define(:provider, :model) do
+    ROUTE_PATTERN = /\A(?<provider>[a-zA-Z0-9][a-zA-Z0-9._-]*)\/(?<model>[^\s\/][^\s]*)\z/
+
+    def initialize(provider:, model:)
+      normalized_provider = Immutable.string(provider)
+      normalized_model = Immutable.string(model)
+      route = "#{normalized_provider}/#{normalized_model}"
+      unless ROUTE_PATTERN.match?(route) && !normalized_model.include?("\0")
+        raise ArgumentError,
+              "OpenCode route must be a full provider/model value"
+      end
+
+      super(provider: normalized_provider, model: normalized_model)
+    end
+
+    def self.parse(value)
+      match = ROUTE_PATTERN.match(value.to_s)
+      unless match
+        raise ArgumentError,
+              "OpenCode route must be a full provider/model value"
+      end
+
+      new(provider: match[:provider], model: match[:model])
+    end
+
+    def to_s
+      "#{provider}/#{model}"
+    end
+  end
+
+  OpenCodePermissionPolicy = Data.define(:rules) do
+    ACTIONS = %w[allow ask deny].freeze
+
+    def initialize(rules = nil, **keywords)
+      value = rules || keywords[:rules] || keywords
+      normalized = Immutable.hash(value || {})
+      raise ArgumentError, "OpenCode permission policy cannot be empty" if normalized.empty?
+
+      validate_actions!(normalized)
+      super(rules: normalized)
+    end
+
+    private
+
+    def validate_actions!(value)
+      value.each_value do |entry|
+        if entry.is_a?(Hash)
+          validate_actions!(entry)
+        elsif !ACTIONS.include?(entry)
+          raise ArgumentError,
+                "OpenCode permission action must be allow, ask, or deny"
+        end
+      end
+    end
+  end
+
+  OpenCodePreparationRequest = Data.define(
+    :request, :working_directory, :invocation_root,
+    :configuration_path, :configuration,
+    :credential_environment_keys, :credential_file,
+    :permission_policy, :additional_read_roots,
+    :additional_write_roots, :edit_patterns, :plugins, :pure
+  ) do
+    def initialize(request:, working_directory:, invocation_root:,
+                   configuration_path: nil, configuration: nil,
+                   credential_environment_keys: [], credential_file: nil,
+                   permission_policy: nil, additional_read_roots: [],
+                   additional_write_roots: [], edit_patterns: [], plugins: [], pure: true)
+      unless request.is_a?(Request)
+        raise ArgumentError, "request must be an AgentCliRuntime::Request"
+      end
+      if configuration_path && configuration
+        raise ArgumentError,
+              "choose configuration_path or configuration, not both"
+      end
+      if permission_policy &&
+         !permission_policy.is_a?(OpenCodePermissionPolicy)
+        raise ArgumentError,
+              "permission_policy must be an OpenCodePermissionPolicy"
+      end
+
+      keys = Immutable.strings(credential_environment_keys)
+      invalid = keys.find { |key| !key.match?(/\A[A-Z][A-Z0-9_]*\z/) }
+      raise ArgumentError, "invalid credential environment key" if invalid
+      raise ArgumentError, "credential environment keys must be unique" if keys.uniq.length != keys.length
+      reserved = keys & OPENCODE_OVERLAY_ENVIRONMENT_KEYS
+      unless reserved.empty?
+        raise ArgumentError,
+              "credential environment keys cannot override the OpenCode overlay: #{reserved.join(', ')}"
+      end
+
+      super(
+        request: request,
+        working_directory: Immutable.string(working_directory),
+        invocation_root: Immutable.string(invocation_root),
+        configuration_path:
+          configuration_path.nil? ? nil : Immutable.string(configuration_path),
+        configuration:
+          configuration.nil? ? nil : Immutable.hash(configuration),
+        credential_environment_keys: keys,
+        credential_file:
+          credential_file.nil? ? nil : Immutable.string(credential_file),
+        permission_policy: permission_policy,
+        additional_read_roots: Immutable.strings(additional_read_roots),
+        additional_write_roots: Immutable.strings(additional_write_roots),
+        edit_patterns: Immutable.strings(edit_patterns),
+        plugins: Immutable.strings(plugins),
+        pure: pure != false
+      )
+    end
+  end
+
+  ProbeRequest = Data.define(
+    :profile, :route, :variant, :environment,
+    :credential_environment_keys, :credential_file_staged
+  ) do
+    def initialize(profile:, route:, variant: nil, environment: {},
+                   credential_environment_keys: [],
+                   credential_file_staged: false)
+      parsed_route = route.is_a?(Route) ? route : Route.parse(route)
+      super(
+        profile: profile,
+        route: parsed_route,
+        variant: variant.nil? ? nil : Immutable.string(variant),
+        environment: Immutable.hash(environment),
+        credential_environment_keys:
+          Immutable.strings(credential_environment_keys),
+        credential_file_staged: credential_file_staged == true
+      )
+    end
+  end
+
+  RouteProbeResult = Data.define(
+    :provider, :ready, :installed, :executable, :version,
+    :minimum_version, :auth_configuration, :route,
+    :route_available, :available_variants,
+    :capability_evidence, :diagnostic
+  ) do
+    def initialize(provider:, ready:, installed:, executable:, version:,
+                   minimum_version:, auth_configuration:, route:,
+                   route_available:, available_variants:,
+                   capability_evidence:, diagnostic: nil)
+      super(
+        provider: provider.to_sym,
+        ready: ready == true,
+        installed: installed == true,
+        executable: Immutable.string(executable),
+        version: version.nil? ? nil : Immutable.string(version),
+        minimum_version:
+          minimum_version.nil? ? nil : Immutable.string(minimum_version),
+        auth_configuration: auth_configuration,
+        route: route,
+        route_available: route_available == true,
+        available_variants: Immutable.strings(available_variants),
+        capability_evidence: Array(capability_evidence).freeze,
+        diagnostic:
+          diagnostic.nil? ? nil : Immutable.string(diagnostic)
+      )
+    end
+  end
+
+  class PreparedInvocation
+    attr_reader :invocation, :environment, :credential_environment_keys,
+                :invocation_root, :generated_paths, :configuration_path,
+                :requested_route, :configuration_source, :probe_result,
+                :executable
+
+    def initialize(invocation:, environment:, credential_environment_keys:,
+                   invocation_root:, generated_paths:, configuration_path:,
+                   requested_route:, configuration_source:, probe_result:,
+                   cleanup:, executable: nil)
+      @invocation = invocation
+      @environment = Immutable.hash(environment)
+      @credential_environment_keys =
+        Immutable.strings(credential_environment_keys)
+      @invocation_root = Immutable.string(invocation_root)
+      @generated_paths = Immutable.strings(generated_paths)
+      @configuration_path = Immutable.string(configuration_path)
+      @requested_route = requested_route
+      @configuration_source =
+        configuration_source.nil? ? nil : Immutable.string(configuration_source)
+      @probe_result = probe_result
+      @executable = Immutable.string(executable || invocation.argv.fetch(0))
+      @cleanup = cleanup
+      freeze
+    end
+
+    def environment_for(env: ENV)
+      selected = credential_environment_keys.each_with_object({}) do |key, values|
+        value = env[key]
+        values[key] = value.to_s unless value.to_s.empty?
+      end
+      selected.merge(environment).freeze
+    end
+
+    def cleanup!
+      @cleanup.call
+      nil
+    end
+  end
+
+  TerminationEvidence = Data.define(
+    :exit_code, :timed_out, :cancelled, :signal
+  ) do
+    def initialize(exit_code:, timed_out: false, cancelled: false, signal: nil)
+      unless exit_code.nil? || exit_code.is_a?(Integer)
+        raise ArgumentError, "exit_code must be an Integer or nil"
+      end
+
+      super(
+        exit_code: exit_code,
+        timed_out: timed_out == true,
+        cancelled: cancelled == true,
+        signal: signal.nil? ? nil : Immutable.string(signal)
+      )
+    end
+
+    def success?
+      !timed_out && !cancelled && signal.nil? && exit_code == 0
+    end
+  end
+
+  CapturedResult = Data.define(
+    :stdout, :stderr, :termination, :inspection_output
+  ) do
+    def initialize(stdout:, stderr:, termination:, inspection_output: nil)
+      unless termination.is_a?(TerminationEvidence)
+        raise ArgumentError, "termination must be TerminationEvidence"
+      end
+
+      super(
+        stdout: Immutable.string(stdout),
+        stderr: Immutable.string(stderr),
+        termination: termination,
+        inspection_output:
+          inspection_output.nil? ? nil : Immutable.string(inspection_output)
+      )
+    end
+  end
+
+  NormalizedUsage = Data.define(
+    :input, :output, :cache_read, :cache_write, :reasoning, :cost
+  ) do
+    def initialize(input: nil, output: nil, cache_read: nil, cache_write: nil,
+                   reasoning: nil, cost: nil)
+      super(
+        input: number(input, :input, integer: true),
+        output: number(output, :output, integer: true),
+        cache_read: number(cache_read, :cache_read, integer: true),
+        cache_write: number(cache_write, :cache_write, integer: true),
+        reasoning: number(reasoning, :reasoning, integer: true),
+        cost: number(cost, :cost, integer: false)
+      )
+    end
+
+    def cached
+      return nil if cache_read.nil? || cache_write.nil?
+
+      cache_read + cache_write
+    end
+
+    private
+
+    def number(value, label, integer:)
+      return nil if value.nil?
+      valid = integer ? value.is_a?(Integer) : value.is_a?(Numeric)
+      valid &&= value.finite? if value.respond_to?(:finite?)
+      unless valid && value >= 0
+        raise ArgumentError, "#{label} must be a non-negative number or nil"
+      end
+
+      value
+    end
+  end
+
+  RouteIdentity = Data.define(:requested, :actual, :resolution_status) do
+    RESOLUTION_STATUSES = %i[unobserved matched resolved_differently].freeze
+
+    def initialize(requested:, actual: nil, resolution_status: nil)
+      requested_route = requested.is_a?(Route) ? requested : Route.parse(requested)
+      actual_route =
+        if actual.nil?
+          nil
+        elsif actual.is_a?(Route)
+          actual
+        else
+          Route.parse(actual)
+        end
+      status = resolution_status&.to_sym ||
+        (actual_route.nil? ? :unobserved :
+          (requested_route == actual_route ? :matched : :resolved_differently))
+      unless RESOLUTION_STATUSES.include?(status)
+        raise ArgumentError, "invalid route resolution status"
+      end
+
+      super(
+        requested: requested_route,
+        actual: actual_route,
+        resolution_status: status
+      )
+    end
+  end
+
+  ParsedRun = Data.define(
+    :session_id, :terminal_message_id, :terminal_reason,
+    :final_message, :final_message_truncated, :preliminary_usage, :unknown_events
+  ) do
+    def initialize(session_id:, terminal_message_id:, terminal_reason:,
+                   final_message:, preliminary_usage:, unknown_events: [],
+                   final_message_truncated: false)
+      unless preliminary_usage.is_a?(NormalizedUsage)
+        raise ArgumentError, "preliminary_usage must be NormalizedUsage"
+      end
+
+      super(
+        session_id: Immutable.string(session_id),
+        terminal_message_id: Immutable.string(terminal_message_id),
+        terminal_reason: Immutable.string(terminal_reason),
+        final_message: Immutable.string(final_message),
+        final_message_truncated: final_message_truncated == true,
+        preliminary_usage: preliminary_usage,
+        unknown_events: Immutable.strings(unknown_events)
+      )
+    end
+  end
+
+  InspectionCommand = Data.define(
+    :argv, :stdin_data, :environment, :credential_environment_keys,
+    :session_id, :message_id
+  ) do
+    def initialize(argv:, environment:, credential_environment_keys:,
+                   session_id:, message_id:, stdin_data: nil)
+      super(
+        argv: Immutable.strings(argv),
+        stdin_data: stdin_data.nil? ? nil : Immutable.string(stdin_data),
+        environment: Immutable.hash(environment),
+        credential_environment_keys:
+          Immutable.strings(credential_environment_keys),
+        session_id: Immutable.string(session_id),
+        message_id: Immutable.string(message_id)
+      )
+    end
+
+    def environment_for(env: ENV)
+      selected = credential_environment_keys.each_with_object({}) do |key, values|
+        value = env[key]
+        values[key] = value.to_s unless value.to_s.empty?
+      end
+      selected.merge(environment).freeze
+    end
+  end
+
+  NormalizedOutcome = Data.define(
+    :provider, :launcher_identity, :kind, :termination,
+    :final_message, :final_message_truncated, :identity, :usage, :diagnostic,
+    :unknown_events, :session_id, :message_id
+  ) do
+    KINDS = %i[
+      completed authentication_failure configuration_failure cli_failure
+      malformed_output cancelled timed_out
+    ].freeze
+
+    def initialize(provider:, launcher_identity:, kind:, termination:,
+                   final_message: nil, identity:, usage: nil, diagnostic: nil,
+                   unknown_events: [], session_id: nil, message_id: nil,
+                   final_message_truncated: false)
+      normalized_kind = kind.to_sym
+      unless KINDS.include?(normalized_kind)
+        raise ArgumentError, "invalid normalized outcome kind"
+      end
+      unless termination.is_a?(TerminationEvidence)
+        raise ArgumentError, "termination must be TerminationEvidence"
+      end
+      unless identity.is_a?(RouteIdentity)
+        raise ArgumentError, "identity must be RouteIdentity"
+      end
+      unless usage.nil? || usage.is_a?(NormalizedUsage)
+        raise ArgumentError, "usage must be NormalizedUsage or nil"
+      end
+
+      super(
+        provider: provider.to_sym,
+        launcher_identity: Immutable.string(launcher_identity),
+        kind: normalized_kind,
+        termination: termination,
+        final_message:
+          final_message.nil? ? nil : Immutable.string(final_message),
+        final_message_truncated: final_message_truncated == true,
+        identity: identity,
+        usage: usage,
+        diagnostic: diagnostic.nil? ? nil : Immutable.string(diagnostic),
+        unknown_events: Immutable.strings(unknown_events),
+        session_id: session_id.nil? ? nil : Immutable.string(session_id),
+        message_id: message_id.nil? ? nil : Immutable.string(message_id)
+      )
+    end
+
+    def completed?
+      kind == :completed
+    end
+  end
 end

data/lib/agent_cli_runtime/version.rb

@@ -1,3 +1,3 @@
 module AgentCliRuntime
-  VERSION = "0.1.1".freeze
+  VERSION = "0.2.0".freeze
 end

data/lib/agent_cli_runtime.rb

@@ -8,10 +8,14 @@ end
 
 require "agent_cli_runtime/redactor"
 require "agent_cli_runtime/usage_extractors"
+require "agent_cli_runtime/opencode/result_parser"
 require "agent_cli_runtime/profile"
 require "agent_cli_runtime/profiles"
 require "agent_cli_runtime/probe"
 require "agent_cli_runtime/runtime"
+require "agent_cli_runtime/opencode/probe"
+require "agent_cli_runtime/opencode/overlay"
+require "agent_cli_runtime/opencode/inspection"
 require "agent_cli_runtime/cli"
 
 module AgentCliRuntime
@@ -21,8 +25,8 @@ module AgentCliRuntime
     Runtime.compile(request)
   end
 
-  def prepare!(profile)
-    Runtime.prepare!(profile)
+  def prepare!(profile, env: ENV)
+    Runtime.prepare!(profile, env:)
   end
 
   def require_capability!(profile, capability)
@@ -37,8 +41,24 @@ module AgentCliRuntime
     Runtime.observe(profile, result)
   end
 
+  def parse_run(profile, stdout:)
+    Runtime.parse_run(profile, stdout:)
+  end
+
+  def prepare_inspection(prepared, parsed_run)
+    OpenCode::Inspection.compile(prepared, parsed_run)
+  end
+
+  def normalize(profile, captured, requested_route:)
+    Runtime.normalize(profile, captured, requested_route:)
+  end
+
   def probe(profile, home: nil, env: ENV)
-    Probe.call(profile, home: home, env: env)
+    if profile.is_a?(ProbeRequest)
+      OpenCode::Probe.call(profile, env: env)
+    else
+      Probe.call(profile, home: home, env: env)
+    end
   end
 
   def probe_all(home: nil, env: ENV)