class LittleGhost::Runtime

# File lib/little_ghost/runtime.rb, line 98
def initialize(configuration:, settings: nil)
  @startup_started_at = monotonic_time
  @startup_phase = "configuration"
  @startup_reported = false

  begin
    raise ArgumentError, "configuration must be a LittleGhost::Configuration" unless configuration.is_a?(Configuration)

    @configuration = configuration
    if settings
      @settings = settings
    else
      bootstrap_root = canonical_application_root(configuration.root)
      configuration.load_file!(root: bootstrap_root)
      @settings = configuration.settings(root: bootstrap_root)
    end
    @task_runner = Support::TaskRunner.new(
      backend: @settings.fetch(:concurrency_backend, :auto)
    )
    report_startup(status: "starting")
    @startup_reported = true
    @root = canonical_application_root(@settings.fetch(:root))
    @skill_resource_root = @settings[:skill_resource_root]
    @workspace_declaration = @settings.fetch(:workspace)
    @sandbox_declaration = @settings.fetch(:sandbox)
    @code_mode_configuration = @settings[:code_mode]
    @runtime_hooks = build_runtime_hooks(@settings[:runtime_hooks])

    @startup_phase = "instrumentation"
    subscribe_instrumentation(@settings[:instrumentation_subscribers])
    emit_startup(:runtime_start)

    @startup_phase = "loader"
    @loader = @settings[:loader] || Support::Loader.new(root: @root)
    loader.setup
    loader.eager_load

    @startup_phase = "model_resolver"
    @invocation_class = @settings[:invocation] || Invocation
    @model_resolver = @settings.fetch(:model_resolver)
    @default_model = @settings.fetch(:default_model, "default").to_s
    @model_operations = ModelOperations.new(model_resolver:)

    @startup_phase = "session_store"
    @session_store = build_session_store(@settings[:session_store])
    @session_actor = @settings[:session_actor]

    @startup_phase = "prompts"
    @prompt_paths = build_lookup_paths(:prompt_paths)
    @skill_paths = build_lookup_paths(:skill_paths)

    @startup_phase = "agent_factory"
    @agent_factory = AgentFactory.new(
      runtime: self,
      prompt_paths: @prompt_paths,
      resolve_agent: method(:resolve_agent_class)
    )

    @startup_phase = "complete"
    emit_startup(:runtime_stop, outcome: "ready")
    report_startup(status: "ready")
  rescue => error
    unless @startup_reported
      report_startup(status: "starting")
      @startup_reported = true
    end
    emit_startup(:runtime_stop, outcome: "failed", error:)
    Instrumentation.flush
    report_startup(status: "failed", error:)
    raise
  end
end

# File lib/little_ghost/runtime.rb, line 172
def build(**overrides)
  values = @settings.merge(overrides)
  values[:root] = canonical_application_root(values.fetch(:root))
  values[:loader] = loader unless overrides.key?(:loader) || overrides.key?(:root)
  self.class.new(
    configuration:,
    settings: values
  )
end

# File lib/little_ghost/runtime.rb, line 215
def build_run(
  payload,
  agent_class: nil,
  assembly_class: nil,
  entrypoint_class: nil,
  execution_class: nil,
  cancellation_token: Support::CancellationToken.new,
  workspace: nil,
  sandbox: nil,
  include_agent_events_by_default: false
)
  entrypoint_class ||= assembly_class || agent_class
  raise ArgumentError, "entrypoint_class is required" unless entrypoint_class

  execution_class ||= assembly_class || entrypoint_class
  agent_class ||= entrypoint_class if entrypoint_class <= Agent
  owned_resources = []
  invocation = parse(payload)
  workspace ||= build_workspace(invocation:).tap { |resource| owned_resources << resource }
  sandbox ||= build_sandbox(workspace:, invocation:).tap { |resource| owned_resources << resource }
  run = Run.new(
    invocation:,
    runtime: self,
    agent_class:,
    entrypoint_class:,
    execution_class:,
    cancellation_token:,
    workspace:,
    sandbox:,
    include_agent_events_by_default:
  )
  owned_resources.each { |resource| run.register(resource) }
  prepare_run(run)
rescue
  if run
    run.close
  else
    close_resources(owned_resources)
  end
  raise
end

# File lib/little_ghost/runtime.rb, line 277
def build_sandbox(workspace:, invocation: nil)
  declaration = sandbox_declaration
  return Sandboxes::Unrestricted.new(workspace:) unless declaration

  provider, options = component_provider(declaration)
  provider = Sandbox.resolve_provider(provider) if provider.is_a?(Symbol)
  policy_options = options.slice(*Sandbox::Policy::COMMON_KEYS)
  policy_options.each_key { |key| options.delete(key) }
  policy_value = options.delete(:policy)
  if policy_value || !policy_options.empty?
    options[:policy] = Sandbox::Policy.coerce(policy_value, **policy_options)
  end
  build_component(provider, options, runtime: self, invocation:, workspace:)
end

# File lib/little_ghost/runtime.rb, line 258
def build_workspace(invocation: nil)
  declaration = workspace_declaration
  unless declaration
    paths = artifacts_enabled? ? {artifacts: "artifacts"} : {}
    return Workspace.new(root: root, paths:)
  end

  provider, options = component_provider(declaration)
  provider = Workspace.resolve_provider(provider) if provider.is_a?(Symbol)
  options[:root] = resolve_component_path(options[:root]) if options.key?(:root)
  options[:root] ||= root.to_s if provider == Workspace
  if artifacts_enabled? && provider == Workspace
    options[:paths] = {artifacts: "artifacts"}.merge(options.fetch(:paths, {}))
  end
  build_component(provider, options, runtime: self, invocation:)
end

# File lib/little_ghost/runtime.rb, line 205
def embed(**arguments)
  @model_operations.embed(**arguments)
end

# File lib/little_ghost/runtime.rb, line 194
def generate(**arguments)
  @model_operations.generate(**arguments)
end

# File lib/little_ghost/runtime.rb, line 183
def parse(payload)
  payload.is_a?(@invocation_class) ? payload : @invocation_class.new(payload)
end