Skip to content

A platform for community discussion. Free, open, simple.

31.3 KB
Raw Blame
# frozen_string_literal: true

RSpec.describe DiscourseAi::Agents::SubagentRunner do
  fab!(:user) { Fabricate(:user, refresh_auto_groups: true) }
  fab!(:model, :fake_model)
  fab!(:child) do
    Fabricate(
      :ai_agent,
      name: "Fact checker",
      description: "Checks one factual claim",
      system_prompt: "Check the supplied claim and report the evidence.",
      default_llm_id: model.id,
      allowed_group_ids: [Group::AUTO_GROUPS[:trust_level_0]],
    )
  end
  fab!(:parent) do
    Fabricate(
      :ai_agent,
      name: "Lead fact checker",
      description: "Delegates individual claims",
      system_prompt: "Delegate claims and synthesize the results.",
      default_llm_id: model.id,
      allowed_group_ids: [Group::AUTO_GROUPS[:trust_level_0]],
      subagent_ids: [child.id],
    )
  end

  before { enable_current_plugin }

  after { AiAgent.agent_cache.flush! }

  it "admits a same-model thinking child while the streaming root retains its output reservation" do
    claude =
      Fabricate(
        :anthropic_model,
        max_prompt_tokens: 200_000,
        max_output_tokens: 64_000,
        provider_params: {
          enable_reasoning: true,
          reasoning_tokens: 32_768,
        },
      )
    parent.update!(default_llm_id: claude.id, max_turn_tokens: 32_000, thinking_effort: "high")
    child.update!(default_llm_id: claude.id, max_turn_tokens: 32_000, thinking_effort: "high")
    spawn = { agent_id: child.id, prompt: "Check this claim" }
    bodies = []
    responses =
      [
        [
          {
            type: "message_start",
            message: {
              role: "assistant",
              content: [],
              usage: {
                input_tokens: 100,
                output_tokens: 1,
              },
            },
          },
          {
            type: "content_block_start",
            index: 0,
            content_block: {
              type: "tool_use",
              id: "spawn_work",
              name: "spawn_agent",
              input: {
              },
            },
          },
          {
            type: "content_block_delta",
            index: 0,
            delta: {
              type: "input_json_delta",
              partial_json: spawn.to_json,
            },
          },
          { type: "content_block_stop", index: 0 },
          {
            type: "message_delta",
            delta: {
              stop_reason: "tool_use",
            },
            usage: {
              output_tokens: 60,
            },
          },
          { type: "message_stop" },
        ],
        [
          {
            type: "message_start",
            message: {
              role: "assistant",
              content: [],
              usage: {
                input_tokens: 100,
                output_tokens: 1,
              },
            },
          },
          { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } },
          {
            type: "content_block_delta",
            index: 0,
            delta: {
              type: "text_delta",
              text: "Child evidence",
            },
          },
          { type: "content_block_stop", index: 0 },
          {
            type: "message_delta",
            delta: {
              stop_reason: "end_turn",
            },
            usage: {
              output_tokens: 40,
            },
          },
          { type: "message_stop" },
        ],
        [
          {
            type: "message_start",
            message: {
              role: "assistant",
              content: [],
              usage: {
                input_tokens: 100,
                output_tokens: 1,
              },
            },
          },
          { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } },
          {
            type: "content_block_delta",
            index: 0,
            delta: {
              type: "text_delta",
              text: "Parent answer",
            },
          },
          { type: "content_block_stop", index: 0 },
          {
            type: "message_delta",
            delta: {
              stop_reason: "end_turn",
            },
            usage: {
              output_tokens: 30,
            },
          },
          { type: "message_stop" },
        ],
      ].map do |events|
        events.map { |event| "event: #{event[:type]}\ndata: #{event.to_json}\n\n" }.join
      end
    request =
      stub_request(:post, claude.url).with(
        body:
          proc do |body|
            bodies << JSON.parse(body)
            true
          end,
      ).to_return(*responses.map { |body| { body: body } })
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        messages: [{ type: :user, content: "Check the claim" }],
      )
    bot = DiscourseAi::Agents::Bot.as(user, agent: parent.class_instance.new, model: claude)
    expect(bot.reply(context).last.first).to eq("Parent answer")
    expect(bodies.first(2).map { |body| body["max_tokens"] }).to eq([16_000, 16_000])
    expect(bodies.first(2).map { |body| body.dig("thinking", "budget_tokens") }).to eq(
      [14_976, 14_976],
    )
    expect(bodies.last["messages"].to_json).to include("Child evidence")
    expect(context.execution_context.work_budget.limit).to eq(32_000)
    expect(context.execution_context.work_budget.used).to be >= 130
    expect(context.execution_context.work_budget.used).to be < 200
    expect(context.execution_context.token_usage_tracker.response).to eq(130)
    expect(request).to have_been_requested.times(3)
  end

  it "charges child output, not imported task input, against the shared root work" do
    model.update!(max_prompt_tokens: 50_000)
    child.update!(max_turn_tokens: 8000, compression_threshold: 80)
    tracker = DiscourseAi::Completions::TokenUsageTracker.new
    execution = DiscourseAi::Completions::ExecutionContext.new(token_usage_tracker: tracker)
    state =
      DiscourseAi::Agents::SubagentExecutionState.new(
        execution_context: execution,
        root_token_budget: 5000,
      )
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        execution_context: execution,
        subagent_execution_state: state,
      )
    runner =
      described_class.new(
        parent_agent: parent.class_instance.new,
        child_id: child.id,
        prompt: "Check the evidence",
        context: context,
        parent_llm: DiscourseAi::Completions::Llm.proxy(model),
      )

    DiscourseAi::Completions::Llm.with_prepared_responses(["Child evidence"]) do |canned|
      allow_any_instance_of(DiscourseAi::Completions::Llm).to receive(
        :generate,
      ).and_wrap_original do |generate, *args, **options, &block|
        result = generate.call(*args, **options, &block)
        options[:execution_context].token_usage_tracker.add_effective(request: 4000, response: 0)
        result
      end
      expect(runner.run[:response]).to eq("Child evidence")
      expect(state.root_token_budget).to eq(5000)
      expect(state.remaining_tokens).to eq(5000 - model.to_llm.tokenizer.size("Child evidence"))
      expect(canned.completions).to eq(1)
      expect(tracker.total).to eq(4000)
      expect(child.reload.max_turn_tokens).to eq(8000)
    end
  end

  it "reserves parent output atomically before admitting a child" do
    model.update!(max_prompt_tokens: 50_000)
    child.update!(max_turn_tokens: 8000, compression_threshold: 80)
    tracker = DiscourseAi::Completions::TokenUsageTracker.new
    execution = DiscourseAi::Completions::ExecutionContext.new(token_usage_tracker: tracker)
    state =
      DiscourseAi::Agents::SubagentExecutionState.new(
        execution_context: execution,
        root_token_budget: 5000,
      )
    reservation = execution.work_budget.reserve_output(5000)
    expect(reservation.tokens).to eq(5000)
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        execution_context: execution,
        subagent_execution_state: state,
      )
    runner =
      described_class.new(
        parent_agent: parent.class_instance.new,
        child_id: child.id,
        prompt: "Check the evidence",
        context: context,
        parent_llm: DiscourseAi::Completions::Llm.proxy(model),
      )
    DiscourseAi::Completions::Llm.with_prepared_responses(["unused"]) do |canned|
      expect(runner.run[:error]).to eq(I18n.t("discourse_ai.ai_bot.subagent_errors.token_limit"))
      expect(canned.completions).to eq(0)
      expect(state.remaining_tokens).to eq(0)
      expect(state.root_token_budget).to eq(5000)
    end
    execution.work_budget.release_output(reservation)
    expect(state.remaining_tokens).to eq(5000)
  end

  it "allows child tools when new work fits regardless of full prompt reservation" do
    child.update!(tools: [["ListCategories", nil, false]])
    execution =
      DiscourseAi::Completions::ExecutionContext.new(
        token_usage_tracker: DiscourseAi::Completions::TokenUsageTracker.new,
      )
    state =
      DiscourseAi::Agents::SubagentExecutionState.new(
        execution_context: execution,
        root_token_budget: 5000,
      )
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        execution_context: execution,
        subagent_execution_state: state,
      )
    runner =
      described_class.new(
        parent_agent: parent.class_instance.new,
        child_id: child.id,
        prompt: "Check the evidence",
        context: context,
        parent_llm: model.to_llm,
      )
    DiscourseAi::Completions::Llm.with_prepared_responses(
      ["Bounded child answer"],
    ) do |_, _, prompts|
      expect(runner.run[:response]).to eq("Bounded child answer")
      expect(prompts.first.tool_choice).not_to eq(:none)
      expect(state.root_token_budget).to eq(5000)
    end
  end

  it "exposes one strict server-owned tool only when delegation is usable" do
    agent = parent.class_instance.new
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        messages: [{ type: :user, content: "Check a claim" }],
        execution_context:
          DiscourseAi::Completions::ExecutionContext.new(
            token_usage_tracker: DiscourseAi::Completions::TokenUsageTracker.new,
          ),
      )
    context.subagent_execution_state =
      DiscourseAi::Agents::SubagentExecutionState.new(
        execution_context: context.execution_context,
        root_token_budget: 10_000,
      )

    tool_class = agent.runtime_tools(context: context).find { |tool| tool.name == "spawn_agent" }
    schema = tool_class.signature[:json_schema]

    expect(schema).to include(
      type: "object",
      required: %w[agent_id prompt],
      additionalProperties: false,
    )
    expect(schema.dig(:properties, :agent_id, :enum)).to eq([child.id])
    expect(schema.dig(:properties, :prompt, :maxLength)).to eq(20_000)

    context.server_owned_tools = false
    expect(agent.runtime_tools(context: context).map(&:name)).not_to include("spawn_agent")

    context.server_owned_tools = true
    context.subagent_depth = 2
    expect(agent.runtime_tools(context: context).map(&:name)).not_to include("spawn_agent")
  end

  it "keeps delegation available after more than five child runs while shared work remains" do
    spawn_calls =
      Array.new(6) do |index|
        DiscourseAi::Completions::ToolCall.new(
          id: "spawn-#{index}",
          name: "spawn_agent",
          parameters: {
            agent_id: child.id,
            prompt: "Check claim #{index}",
          },
        )
      end
    responses =
      spawn_calls.each_with_index.flat_map { |call, index| [call, "Child result #{index}"] }
    responses << "Final answer"

    DiscourseAi::Completions::Llm.with_prepared_responses(responses) do |_endpoint, _llm, prompts|
      bot = DiscourseAi::Agents::Bot.as(user, agent: parent.class_instance.new, model: model)
      context =
        DiscourseAi::Agents::BotContext.new(
          user: user,
          messages: [{ type: :user, content: "Check several claims" }],
        )

      raw_context = bot.reply(context)

      expect(raw_context.last.first).to eq("Final answer")
      expect(prompts.length).to eq(responses.length)
      expect(prompts.map(&:tool_choice)).to all(eq(nil))
      results = raw_context.select { |entry| entry[2] == "tool" && entry[3] == "spawn_agent" }
      expect(results.map { |entry| JSON.parse(entry.first)["response"] }).to eq(
        Array.new(6) { |index| "Child result #{index}" },
      )
      expect(bot.agent.runtime_tools(context: context).map(&:name)).to include("spawn_agent")
      expect(context.subagent_execution_state.completion_count).to eq(responses.length)
      tokenizer = model.to_llm.tokenizer
      generation_tokens =
        responses.sum do |response|
          output = DiscourseAi::Completions::GeneratedOutput.new
          output << response
          output.size(tokenizer)
        end
      evidence_tokens =
        results.sum { |entry| tokenizer.size(JSON.parse(entry.first).except("response").to_json) }
      expect(context.execution_context.work_budget.used).to eq(generation_tokens + evidence_tokens)
    end
  end

  it "rejects further delegation when repeated child output exhausts shared work" do
    child_response = "Child evidence"
    token_budget = model.to_llm.tokenizer.size(child_response) * 6
    execution_context = DiscourseAi::Completions::ExecutionContext.new
    state =
      DiscourseAi::Agents::SubagentExecutionState.new(
        execution_context: execution_context,
        root_token_budget: token_budget,
      )
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        execution_context: execution_context,
        subagent_execution_state: state,
      )
    runner =
      described_class.new(
        parent_agent: parent.class_instance.new,
        child_id: child.id,
        prompt: "Check the evidence",
        context: context,
        parent_llm: model.to_llm,
      )

    DiscourseAi::Completions::Llm.with_prepared_responses(Array.new(6, child_response)) do |canned|
      6.times { expect(runner.run).to include(status: "ok", response: child_response) }

      expect(execution_context.work_budget.used).to eq(token_budget)
      expect(state.remaining_tokens).to eq(0)
      expect(runner.run[:error]).to eq(I18n.t("discourse_ai.ai_bot.subagent_errors.token_limit"))
      expect(canned.completions).to eq(6)
      expect(state.completion_count).to eq(6)
    end
  end

  it "stops repeated failed delegations at the shared completion safety limit" do
    execution_context = DiscourseAi::Completions::ExecutionContext.new
    failed_calls =
      Array.new(7) do |index|
        DiscourseAi::Completions::ToolCall.new(
          id: "invalid-spawn-#{index}",
          name: "spawn_agent",
          parameters: {
            agent_id: child.id,
            prompt: "",
          },
        )
      end
    state =
      DiscourseAi::Agents::SubagentExecutionState.new(
        execution_context: execution_context,
        root_token_budget: 10_000,
        completion_count:
          DiscourseAi::Agents::SubagentExecutionState::MAX_COMPLETIONS - failed_calls.length - 1,
      )
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        messages: [{ type: :user, content: "Check the evidence" }],
        execution_context: execution_context,
        subagent_execution_state: state,
      )

    DiscourseAi::Completions::Llm.with_prepared_responses(
      [*failed_calls, "Unable to complete the delegated work"],
    ) do |canned, _, prompts|
      bot = DiscourseAi::Agents::Bot.as(user, agent: parent.class_instance.new, model: model)
      raw_context = bot.reply(context)
      results = raw_context.select { |entry| entry[2] == "tool" && entry[3] == "spawn_agent" }

      expect(results.length).to eq(failed_calls.length)
      expect(results.map { |entry| JSON.parse(entry.first) }).to all(
        include(
          "status" => "error",
          "error" => I18n.t("discourse_ai.ai_bot.subagent_errors.invalid_prompt"),
        ),
      )
      expect(raw_context.last.first).to eq("Unable to complete the delegated work")
      expect(canned.completions).to eq(failed_calls.length + 1)
      expect(state.completion_count).to eq(
        DiscourseAi::Agents::SubagentExecutionState::MAX_COMPLETIONS,
      )
      expect(state.remaining_tokens).to be > 0
      expect(prompts.last.tool_choice).to eq(:none)
      expect(prompts.last.messages.last).to eq(
        type: :user,
        content: DiscourseAi::Agents::Bot::COMPLETION_LIMIT_FINAL_ANSWER_HINT,
      )
    end
  end

  it "preserves the reserved final completion for the root agent" do
    child.update!(tools: [["Time", nil, false]])
    execution_context =
      DiscourseAi::Completions::ExecutionContext.new(
        token_usage_tracker: DiscourseAi::Completions::TokenUsageTracker.new,
      )
    state =
      DiscourseAi::Agents::SubagentExecutionState.new(
        execution_context: execution_context,
        root_token_budget: 10_000,
      )
    (DiscourseAi::Agents::SubagentExecutionState::MAX_COMPLETIONS - 3).times do
      expect(state.reserve_completion).to eq(true)
    end
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        messages: [{ type: :user, content: "Check the time" }],
        execution_context: execution_context,
        subagent_execution_state: state,
      )
    spawn_call =
      DiscourseAi::Completions::ToolCall.new(
        id: "spawn-1",
        name: "spawn_agent",
        parameters: {
          agent_id: child.id,
          prompt: "Check the time",
        },
      )
    time_call = DiscourseAi::Completions::ToolCall.new(id: "time-1", name: "time", parameters: {})

    DiscourseAi::Completions::Llm.with_prepared_responses(
      [spawn_call, time_call, "Parent final answer"],
    ) do |_endpoint, _llm, prompts|
      bot = DiscourseAi::Agents::Bot.as(user, agent: parent.class_instance.new, model: model)

      raw_context = bot.reply(context)

      expect(raw_context.last.first).to eq("Parent final answer")
      expect(prompts.length).to eq(3)
      spawn_result =
        prompts.last.messages.reverse.find do |message|
          message[:type] == :tool && message[:name] == "spawn_agent"
        end
      expect(JSON.parse(spawn_result[:content])).to include(
        "status" => "error",
        "error" => I18n.t("discourse_ai.ai_bot.subagent_errors.completion_limit"),
      )
    end
  end

  it "runs the child with an isolated prompt and returns its result to the parent" do
    spawn_call =
      DiscourseAi::Completions::ToolCall.new(
        id: "spawn-1",
        name: "spawn_agent",
        parameters: {
          agent_id: child.id,
          prompt: "Check whether the Moon orbits Earth.",
        },
      )
    updates = []

    DiscourseAi::Completions::Llm.with_prepared_responses(
      [spawn_call, "The Moon orbits Earth.", "The claim is verified."],
    ) do |_endpoint, _llm, prompts, prompt_options|
      bot = DiscourseAi::Agents::Bot.as(user, agent: parent.class_instance.new, model: model)
      context =
        DiscourseAi::Agents::BotContext.new(
          user: user,
          messages: [{ type: :user, content: "Verify the Moon claim" }],
          skip_show_thinking: false,
          feature_context: {
            "source" => "spec",
          },
        )

      bot.reply(context) { |content, raw, type| updates << [content, raw, type] }

      expect(prompts[1].messages).to contain_exactly(
        { type: :system, content: child.system_prompt },
        { type: :user, content: "Check whether the Moon orbits Earth." },
      )
      expect(prompts.last.messages.last[:content]).to include("The Moon orbits Earth.")
      expect(prompt_options[1][:feature_context]).to include(
        "subagent_parent_agent_id" => parent.id,
        "subagent_agent_id" => child.id,
        "subagent_depth" => 1,
      )
      expect(prompt_options[1][:feature_context]).not_to have_key("source")
      tokenizer = model.to_llm.tokenizer
      generation_tokens =
        [spawn_call, "The Moon orbits Earth.", "The claim is verified."].sum do |part|
          output = DiscourseAi::Completions::GeneratedOutput.new
          output << part
          output.size(tokenizer)
        end
      wrapper =
        JSON
          .parse(prompts.last.messages.find { |message| message[:type] == :tool }[:content])
          .except("response")
          .to_json
      expect(context.execution_context.work_budget.used).to eq(
        generation_tokens + tokenizer.size(wrapper),
      )
    end

    thinking_updates = updates.select { |update| update[2] == :thinking }.flatten.compact.join
    expect(thinking_updates).to include("Consulting Fact checker")
    expect(thinking_updates).to include("Check whether the Moon orbits Earth.")
    expect(thinking_updates).not_to include("The Moon orbits Earth.")
    expect(updates.none? { |update| update[2] == :custom_raw }).to eq(true)
  end

  it "revalidates the persisted allowlist before starting a child" do
    tool_class = DiscourseAi::Agents::Tools::SpawnAgent.class_instance(parent.id, [child])
    execution_context =
      DiscourseAi::Completions::ExecutionContext.new(
        token_usage_tracker: DiscourseAi::Completions::TokenUsageTracker.new,
      )
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        messages: [],
        execution_context: execution_context,
        subagent_execution_state:
          DiscourseAi::Agents::SubagentExecutionState.new(
            execution_context: execution_context,
            root_token_budget: 10_000,
          ),
      )
    parent.update!(subagent_ids: [])
    tool =
      tool_class.new(
        { agent_id: child.id, prompt: "Check this" },
        bot_user: user,
        llm: DiscourseAi::Completions::Llm.proxy(model),
        context: context,
        agent: parent.class_instance.new,
      )

    result = tool.invoke

    expect(result).to include(status: "error")
    expect(result[:error]).to eq(I18n.t("discourse_ai.ai_bot.subagent_errors.agent_not_allowed"))
    expect(tool.summary).to eq(I18n.t("discourse_ai.ai_bot.spawn_agent.summary", agent: "subagent"))
  end

  it "fails closed for disabled, inaccessible, and deleted children" do
    execution_context =
      DiscourseAi::Completions::ExecutionContext.new(
        token_usage_tracker: DiscourseAi::Completions::TokenUsageTracker.new,
      )
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        messages: [],
        execution_context: execution_context,
        subagent_execution_state:
          DiscourseAi::Agents::SubagentExecutionState.new(
            execution_context: execution_context,
            root_token_budget: 10_000,
          ),
      )
    parent_agent = parent.class_instance.new

    child.update!(enabled: false)
    disabled_result =
      described_class.new(
        parent_agent: parent_agent,
        child_id: child.id,
        prompt: "Check this",
        context: context,
        parent_llm: DiscourseAi::Completions::Llm.proxy(model),
      ).run
    expect(disabled_result[:error]).to eq(
      I18n.t("discourse_ai.ai_bot.subagent_errors.unavailable_agent"),
    )

    child.update!(enabled: true, allowed_group_ids: [Group::AUTO_GROUPS[:admins]])
    inaccessible_result =
      described_class.new(
        parent_agent: parent_agent,
        child_id: child.id,
        prompt: "Check this",
        context: context,
        parent_llm: DiscourseAi::Completions::Llm.proxy(model),
      ).run
    expect(inaccessible_result[:error]).to eq(
      I18n.t("discourse_ai.ai_bot.subagent_errors.unavailable_agent"),
    )

    child.destroy!
    deleted_result =
      described_class.new(
        parent_agent: parent_agent,
        child_id: child.id,
        prompt: "Check this",
        context: context,
        parent_llm: DiscourseAi::Completions::Llm.proxy(model),
      ).run
    expect(deleted_result[:error]).to eq(
      I18n.t("discourse_ai.ai_bot.subagent_errors.agent_not_allowed"),
    )
  end

  it "returns only the child's final answer after child tool calls" do
    child.update!(tools: [["Time", nil, false]])
    execution_context =
      DiscourseAi::Completions::ExecutionContext.new(
        token_usage_tracker: DiscourseAi::Completions::TokenUsageTracker.new,
      )
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        messages: [],
        execution_context: execution_context,
        subagent_execution_state:
          DiscourseAi::Agents::SubagentExecutionState.new(
            execution_context: execution_context,
            root_token_budget: 10_000,
          ),
      )
    time_call = DiscourseAi::Completions::ToolCall.new(id: "time-1", name: "time", parameters: {})

    result = nil
    DiscourseAi::Completions::Llm.with_prepared_responses(
      [["Starting child work", time_call], "Final child answer"],
    ) do
      result =
        described_class.new(
          parent_agent: parent.class_instance.new,
          child_id: child.id,
          prompt: "Check this",
          context: context,
          parent_llm: DiscourseAi::Completions::Llm.proxy(model),
        ).run
    end

    expect(result).to include(status: "ok", response: "Final child answer")
  end

  it "classifies cancellation during the child completion" do
    cancel_manager = DiscourseAi::Completions::CancelManager.new
    execution_context =
      DiscourseAi::Completions::ExecutionContext.new(
        token_usage_tracker: DiscourseAi::Completions::TokenUsageTracker.new,
      )
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        messages: [],
        cancel_manager: cancel_manager,
        execution_context: execution_context,
        subagent_execution_state:
          DiscourseAi::Agents::SubagentExecutionState.new(
            execution_context: execution_context,
            root_token_budget: 10_000,
          ),
      )
    allow_any_instance_of(DiscourseAi::Completions::Llm).to receive(:generate) do
      cancel_manager.cancel!
      raise IOError, "cancelled request"
    end

    result =
      described_class.new(
        parent_agent: parent.class_instance.new,
        child_id: child.id,
        prompt: "Check this",
        context: context,
        parent_llm: DiscourseAi::Completions::Llm.proxy(model),
      ).run

    expect(result[:error]).to eq(I18n.t("discourse_ai.ai_bot.subagent_errors.cancelled"))
  end

  it "truncates oversized child results with the parent tokenizer" do
    execution_context =
      DiscourseAi::Completions::ExecutionContext.new(
        token_usage_tracker: DiscourseAi::Completions::TokenUsageTracker.new,
      )
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        messages: [],
        execution_context: execution_context,
        subagent_execution_state:
          DiscourseAi::Agents::SubagentExecutionState.new(
            execution_context: execution_context,
            root_token_budget: 40_000,
          ),
      )
    parent_llm = DiscourseAi::Completions::Llm.proxy(model)
    tokenizer = mock
    tokenizer.expects(:size).with("Oversized response").returns(30_001)
    tokenizer
      .expects(:truncate)
      .with(
        "Oversized response",
        described_class::MAX_RESULT_TOKENS,
        strict: SiteSetting.ai_strict_token_counting,
      )
      .returns("Bounded response")
    parent_llm.stubs(:tokenizer).returns(tokenizer)

    result = nil
    DiscourseAi::Completions::Llm.with_prepared_responses(["Oversized response"]) do
      result =
        described_class.new(
          parent_agent: parent.class_instance.new,
          child_id: child.id,
          prompt: "Check this",
          context: context,
          parent_llm: parent_llm,
        ).run
    end

    expect(result).to include(status: "ok", response: "Bounded response", truncated: true)
  end

  it "runs approval-capable tools when the child does not require approval" do
    admin = Fabricate(:admin)
    topic = Fabricate(:topic)
    child.update!(tools: [["CloseTopic", nil, false]], require_approval: false)
    spawn_call =
      DiscourseAi::Completions::ToolCall.new(
        id: "spawn-autonomous",
        name: "spawn_agent",
        parameters: {
          agent_id: child.id,
          prompt: "Close the topic",
        },
      )
    close_call =
      DiscourseAi::Completions::ToolCall.new(
        id: "close-autonomous",
        name: "close_topic",
        parameters: {
          topic_id: topic.id,
          closed: true,
          reason: "Requested",
        },
      )

    DiscourseAi::Completions::Llm.with_prepared_responses(
      [spawn_call, close_call, "Closed.", "The child closed it."],
    ) do
      bot = DiscourseAi::Agents::Bot.as(admin, agent: parent.class_instance.new, model: model)
      context =
        DiscourseAi::Agents::BotContext.new(
          user: admin,
          messages: [{ type: :user, content: "Close it" }],
        )

      bot.reply(context)
    end

    expect(topic.reload).to be_closed
    expect(ReviewableAiToolAction.count).to eq(0)
  end

  it "blocks tools configured to require approval in delegated runs" do
    topic = Fabricate(:topic)
    child.update!(tools: [["CloseTopic", nil, false]], require_approval: true)
    spawn_call =
      DiscourseAi::Completions::ToolCall.new(
        id: "spawn-approval",
        name: "spawn_agent",
        parameters: {
          agent_id: child.id,
          prompt: "Close the topic",
        },
      )
    close_call =
      DiscourseAi::Completions::ToolCall.new(
        id: "close-1",
        name: "close_topic",
        parameters: {
          topic_id: topic.id,
          closed: true,
          reason: "Requested",
        },
      )

    DiscourseAi::Completions::Llm.with_prepared_responses(
      [spawn_call, close_call, "Approval is unavailable.", "The child could not close it."],
    ) do |_endpoint, _llm, prompts|
      bot = DiscourseAi::Agents::Bot.as(user, agent: parent.class_instance.new, model: model)
      context =
        DiscourseAi::Agents::BotContext.new(
          user: user,
          messages: [{ type: :user, content: "Close it" }],
        )

      bot.reply(context)

      child_tool_result = prompts[2].messages.find { |message| message[:type] == :tool }
      expect(child_tool_result[:content]).to include(
        I18n.t("discourse_ai.ai_bot.subagent_errors.approval_unavailable"),
      )
    end

    expect(ReviewableAiToolAction.count).to eq(0)
  end

  it "rejects oversized prompts and excessive delegation depth" do
    execution_context =
      DiscourseAi::Completions::ExecutionContext.new(
        token_usage_tracker: DiscourseAi::Completions::TokenUsageTracker.new,
      )
    state =
      DiscourseAi::Agents::SubagentExecutionState.new(
        execution_context: execution_context,
        root_token_budget: 10_000,
      )
    context =
      DiscourseAi::Agents::BotContext.new(
        user: user,
        messages: [],
        execution_context: execution_context,
        subagent_execution_state: state,
      )

    result =
      DiscourseAi::Agents::SubagentRunner.new(
        parent_agent: parent.class_instance.new,
        child_id: child.id,
        prompt: "x" * 20_001,
        context: context,
        parent_llm: DiscourseAi::Completions::Llm.proxy(model),
      ).run
    expect(result[:error]).to eq(I18n.t("discourse_ai.ai_bot.subagent_errors.prompt_too_long"))

    context.subagent_depth = 2
    depth_result =
      described_class.new(
        parent_agent: parent.class_instance.new,
        child_id: child.id,
        prompt: "Check this",
        context: context,
        parent_llm: DiscourseAi::Completions::Llm.proxy(model),
      ).run
    expect(depth_result[:error]).to eq(I18n.t("discourse_ai.ai_bot.subagent_errors.depth_limit"))
  end
end