luna/oh-my-opencode
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix(athena): parallelize council launches and gate handoff actions

Browse Source
This commit is contained in:
ismeth
2026-02-18 19:26:20 +01:00
committed by YeonGyu-Kim
parent ca199ee85b
commit 4764d65db1
9 changed files with 433 additions and 411 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/tools/athena-council/tools.test.ts
+78 -211
View File
@@ -3,21 +3,8 @@
import { describe, expect, test } from "bun:test"
import type { BackgroundManager } from "../../features/background-agent"
import type { BackgroundTask } from "../../features/background-agent/types"
import type { BackgroundOutputClient } from "../background-task/clients"
import { createAthenaCouncilTool, filterCouncilMembers } from "./tools"
const mockClient = {
session: {
messages: async () => ({
data: [{
id: "msg-1",
info: { role: "assistant" },
parts: [{ type: "text", text: "Test analysis result" }],
}],
}),
},
} as unknown as BackgroundOutputClient
const mockManager = {
getTask: () => undefined,
launch: async () => {
@@ -38,7 +25,7 @@ const configuredMembers = [
{ model: "google/gemini-3-pro" },
]
function createCompletedTask(id: string): BackgroundTask {
function createRunningTask(id: string, sessionID = `ses-${id}`): BackgroundTask {
return {
id,
parentSessionID: "session-1",
@@ -46,288 +33,168 @@ function createCompletedTask(id: string): BackgroundTask {
description: `Council member task ${id}`,
prompt: "prompt",
agent: "council-member",
status: "completed",
sessionID: `ses-${id}`,
status: "running",
sessionID,
}
}
describe("filterCouncilMembers", () => {
test("returns all members when selection is undefined", () => {
// #given
const selectedMembers = undefined
// #when
const result = filterCouncilMembers(configuredMembers, selectedMembers)
// #then
const result = filterCouncilMembers(configuredMembers, undefined)
expect(result.members).toEqual(configuredMembers)
expect(result.error).toBeUndefined()
})
test("returns all members when selection is empty", () => {
// #given
const selectedMembers: string[] = []
// #when
const result = filterCouncilMembers(configuredMembers, selectedMembers)
// #then
const result = filterCouncilMembers(configuredMembers, [])
expect(result.members).toEqual(configuredMembers)
expect(result.error).toBeUndefined()
})
test("filters members using case-insensitive name and model matching", () => {
// #given
const selectedMembers = ["gpt", "GOOGLE/GEMINI-3-PRO"]
// #when
const result = filterCouncilMembers(configuredMembers, selectedMembers)
// #then
const result = filterCouncilMembers(configuredMembers, ["gpt", "GOOGLE/GEMINI-3-PRO"])
expect(result.members).toEqual([configuredMembers[1], configuredMembers[2]])
expect(result.error).toBeUndefined()
})
test("returns helpful error when selected members are not configured", () => {
// #given
const selectedMembers = ["mistral", "xai/grok-3"]
// #when
const result = filterCouncilMembers(configuredMembers, selectedMembers)
// #then
const result = filterCouncilMembers(configuredMembers, ["mistral", "xai/grok-3"])
expect(result.members).toEqual([])
expect(result.error).toBe(
"Unknown council members: mistral, xai/grok-3. Available members: Claude, GPT, google/gemini-3-pro."
)
})
test("selects named member by model ID when name differs from model", () => {
// #given - "Claude" has name "Claude" but model "anthropic/claude-sonnet-4-5"
const selectedMembers = ["anthropic/claude-sonnet-4-5"]
// #when
const result = filterCouncilMembers(configuredMembers, selectedMembers)
// #then - should find the member by model ID even though it has a custom name
expect(result.members).toEqual([configuredMembers[0]])
expect(result.error).toBeUndefined()
})
test("deduplicates when same member is selected by both name and model", () => {
// #given
const selectedMembers = ["Claude", "anthropic/claude-sonnet-4-5"]
// #when
const result = filterCouncilMembers(configuredMembers, selectedMembers)
// #then - should return only one copy
const result = filterCouncilMembers(configuredMembers, ["Claude", "anthropic/claude-sonnet-4-5"])
expect(result.members).toEqual([configuredMembers[0]])
expect(result.error).toBeUndefined()
})
test("returns error listing only unmatched names when partially matched", () => {
// #given
const selectedMembers = ["claude", "non-existent"]
// #when
const result = filterCouncilMembers(configuredMembers, selectedMembers)
// #then
expect(result.members).toEqual([])
expect(result.error).toBe(
"Unknown council members: non-existent. Available members: Claude, GPT, google/gemini-3-pro."
)
})
})
describe("createAthenaCouncilTool", () => {
test("returns error when councilConfig is undefined", async () => {
// #given
const athenaCouncilTool = createAthenaCouncilTool({
backgroundManager: mockManager,
councilConfig: undefined,
client: mockClient,
})
// #when
const result = await athenaCouncilTool.execute({ question: "How should we proceed?" }, mockToolContext)
// #then
expect(result).toBe("Athena council not configured. Add agents.athena.council.members to your config.")
})
test("returns error when councilConfig has empty members", async () => {
// #given
const athenaCouncilTool = createAthenaCouncilTool({
backgroundManager: mockManager,
councilConfig: { members: [] },
client: mockClient,
})
// #when
const result = await athenaCouncilTool.execute({ question: "Any concerns?" }, mockToolContext)
// #then
expect(result).toBe("Athena council not configured. Add agents.athena.council.members to your config.")
})
test("uses expected description and question arg schema", () => {
// #given
const athenaCouncilTool = createAthenaCouncilTool({
backgroundManager: mockManager,
councilConfig: { members: [{ model: "openai/gpt-5.3-codex" }] },
client: mockClient,
})
// #then - description should be dynamic and include the member model
expect(athenaCouncilTool.description).toContain("openai/gpt-5.3-codex")
expect(athenaCouncilTool.description).toContain("Available council members:")
expect((athenaCouncilTool as { args: Record<string, unknown> }).args.question).toBeDefined()
expect((athenaCouncilTool as { args: Record<string, unknown> }).args.members).toBeDefined()
})
test("returns helpful error when members contains invalid names", async () => {
// #given
const athenaCouncilTool = createAthenaCouncilTool({
backgroundManager: mockManager,
councilConfig: { members: configuredMembers },
client: mockClient,
})
const toolArgs = {
question: "Who should investigate this?",
members: ["unknown-model"],
}
// #when
const result = await athenaCouncilTool.execute(toolArgs, mockToolContext)
// #then
expect(result).toBe("Unknown council members: unknown-model. Available members: Claude, GPT, google/gemini-3-pro.")
})
test("returns collected markdown results for all configured council members", async () => {
// #given
let launchCount = 0
const taskStore = new Map<string, BackgroundTask>()
const launchManager = {
launch: async () => {
launchCount += 1
const task = createCompletedTask(`bg-${launchCount}`)
taskStore.set(task.id, task)
return task
},
getTask: (id: string) => taskStore.get(id),
} as unknown as BackgroundManager
const athenaCouncilTool = createAthenaCouncilTool({
backgroundManager: launchManager,
councilConfig: { members: configuredMembers },
client: mockClient,
})
// #when
const result = await athenaCouncilTool.execute({ question: "How should we proceed?" }, mockToolContext)
// #then - returns markdown with council results, one section per member
expect(result).toContain("## Council Results")
expect(result).toContain("How should we proceed?")
expect(result).toContain("### Claude (anthropic/claude-sonnet-4-5)")
expect(result).toContain("### GPT (openai/gpt-5.3-codex)")
expect(result).toContain("### google/gemini-3-pro (google/gemini-3-pro)")
expect(result).toContain("Test analysis result")
})
test("returns collected results only for selected members", async () => {
// #given
let launchCount = 0
const taskStore = new Map<string, BackgroundTask>()
const launchManager = {
launch: async () => {
launchCount += 1
const task = createCompletedTask(`bg-${launchCount}`)
taskStore.set(task.id, task)
return task
},
getTask: (id: string) => taskStore.get(id),
} as unknown as BackgroundManager
const athenaCouncilTool = createAthenaCouncilTool({
backgroundManager: launchManager,
councilConfig: { members: configuredMembers },
client: mockClient,
})
// #when
const result = await athenaCouncilTool.execute(
{
question: "Who should investigate this?",
members: ["GPT", "google/gemini-3-pro"],
},
{ question: "Who should investigate this?", members: ["unknown-model"] },
mockToolContext
)
// #then - only selected members appear in output
expect(result).toContain("### GPT (openai/gpt-5.3-codex)")
expect(result).toContain("### google/gemini-3-pro (google/gemini-3-pro)")
expect(result).not.toContain("### Claude")
expect(launchCount).toBe(2)
expect(result).toBe("Unknown council members: unknown-model. Available members: Claude, GPT, google/gemini-3-pro.")
})
test("includes launch failures alongside successful member results", async () => {
// #given
test("returns selection error when members are omitted", async () => {
const athenaCouncilTool = createAthenaCouncilTool({
backgroundManager: mockManager,
councilConfig: { members: configuredMembers },
})
const result = await athenaCouncilTool.execute({ question: "How should we proceed?" }, mockToolContext)
expect(result).toBe(
"athena_council runs one member per call. Pass exactly one member in members (single-item array). Available members: Claude, GPT, google/gemini-3-pro."
)
})
test("returns selection error when multiple members are provided", async () => {
const athenaCouncilTool = createAthenaCouncilTool({
backgroundManager: mockManager,
councilConfig: { members: configuredMembers },
})
const result = await athenaCouncilTool.execute(
{ question: "How should we proceed?", members: ["Claude", "GPT"] },
mockToolContext
)
expect(result).toBe(
"athena_council runs one member per call. Pass exactly one member in members (single-item array). Available members: Claude, GPT, google/gemini-3-pro."
)
})
test("launches selected member and returns background task metadata", async () => {
let launchCount = 0
const taskStore = new Map<string, BackgroundTask>()
const launchManager = {
launch: async () => {
launchCount += 1
if (launchCount === 2) {
throw new Error("provider outage")
}
const task = createCompletedTask(`bg-${launchCount}`)
const task = createRunningTask(`bg-${launchCount}`)
taskStore.set(task.id, task)
return task
},
getTask: (id: string) => taskStore.get(id),
} as unknown as BackgroundManager
const athenaCouncilTool = createAthenaCouncilTool({
backgroundManager: launchManager,
councilConfig: { members: configuredMembers },
client: mockClient,
})
// #when
const result = await athenaCouncilTool.execute({ question: "Any concerns?" }, mockToolContext)
const result = await athenaCouncilTool.execute(
{ question: "Who should investigate this?", members: ["GPT"] },
mockToolContext
)
// #then - successful members have results, failed member listed in failures section
expect(result).toContain("### Claude (anthropic/claude-sonnet-4-5)")
expect(result).toContain("### google/gemini-3-pro (google/gemini-3-pro)")
expect(launchCount).toBe(1)
expect(result).toContain("Council member launched in background.")
expect(result).toContain("Task ID: bg-1")
expect(result).toContain("Session ID: ses-bg-1")
expect(result).toContain("Member: GPT")
expect(result).toContain("Model: openai/gpt-5.3-codex")
expect(result).toContain("Status: running")
expect(result).toContain("background_output")
expect(result).toContain("task_id=\"bg-1\"")
expect(result).toContain("<task_metadata>")
expect(result).toContain("session_id: ses-bg-1")
})
test("returns launch failure details when selected member fails", async () => {
const launchManager = {
launch: async () => {
throw new Error("provider outage")
},
getTask: () => undefined,
} as unknown as BackgroundManager
const athenaCouncilTool = createAthenaCouncilTool({
backgroundManager: launchManager,
councilConfig: { members: configuredMembers },
})
const result = await athenaCouncilTool.execute(
{ question: "Any concerns?", members: ["GPT"] },
mockToolContext
)
expect(result).toContain("Failed to launch council member.")
expect(result).toContain("### Launch Failures")
expect(result).toContain("**GPT**")
expect(result).toContain("provider outage")
})
test("returns dedup error when council is already running in same session", async () => {
// #given - use a never-resolving launch to keep the first execution in-flight
const pendingLaunch = new Promise<BackgroundTask>(() => {})
const launchManager = {
launch: async () => pendingLaunch,
getTask: () => undefined,
} as unknown as BackgroundManager
const athenaCouncilTool = createAthenaCouncilTool({
backgroundManager: launchManager,
councilConfig: { members: [{ model: "openai/gpt-5.3-codex" }] },
client: mockClient,
})
// #when - first call starts but never resolves (stuck in launch)
// second call should be rejected by session guard
const _firstExecution = athenaCouncilTool.execute({ question: "First run" }, mockToolContext)
// Allow microtask queue to process so markCouncilRunning is called
await new Promise((resolve) => setTimeout(resolve, 0))
const secondExecution = await athenaCouncilTool.execute({ question: "Second run" }, mockToolContext)
// #then
expect(secondExecution).toBe("Council is already running for this session. Wait for the current council execution to complete.")
})
})