A platform for community discussion. Free, open, simple.
# 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