mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 02:47:34 +00:00
108 lines
4.6 KiB
TypeScript
108 lines
4.6 KiB
TypeScript
// Hosts select background work; clients additionally hide current-turn commands in old rosters while retaining child agents/earlier commands.
|
|
|
|
import type {
|
|
AgentSessionBackgroundTask,
|
|
AgentSessionBackgroundTaskState
|
|
} from './agent-session/agent-session-background-task-wire'
|
|
import { agentChildWorkLiveness } from './agent-status/child-work/agent-status-child-work-liveness'
|
|
import type { AgentChildWorkView } from './agent-status/child-work/agent-status-child-work-view'
|
|
|
|
export type StructuredSessionBackgroundTasksView = {
|
|
/** Background rows remain visible during a foreground turn. */
|
|
show: boolean
|
|
/** Idle-only monitoring/command gate; a running turn owns the indicator, but background rows remain visible. */
|
|
isMonitoring: boolean
|
|
tasks: AgentSessionBackgroundTask[]
|
|
settledTasks: AgentSessionBackgroundTask[]
|
|
/** The host's child records, when it publishes them; the rows then read these. */
|
|
children?: AgentChildWorkView[]
|
|
supportsStop: boolean
|
|
/** Offer untargeted Stop if no targeted stop exists and host supports it, or if idle unlisted work can be reached by ending the agent. */
|
|
offersStopAll: boolean
|
|
/** Some running work is not listed: the strip stays, and says details are unavailable. */
|
|
incomplete: boolean
|
|
}
|
|
|
|
/** Reuse empty lists to preserve strip memoization across renders. */
|
|
const NO_TASKS: AgentSessionBackgroundTask[] = []
|
|
const NO_FOREGROUND_COMMANDS: ReadonlySet<string> = new Set()
|
|
|
|
function withoutForeground<T>(
|
|
rows: T[],
|
|
foreground: ReadonlySet<string>,
|
|
id: (row: T) => string | undefined
|
|
): T[] {
|
|
const visible = (row: T) => !foreground.has(id(row) ?? '')
|
|
return rows.every(visible) ? rows : rows.filter(visible)
|
|
}
|
|
|
|
export function structuredSessionBackgroundTasksView(
|
|
backgroundTasks: AgentSessionBackgroundTaskState | null | undefined,
|
|
turnId: string | null,
|
|
foregroundCommands: ReadonlySet<string> = NO_FOREGROUND_COMMANDS
|
|
): StructuredSessionBackgroundTasksView {
|
|
const monitoring = backgroundTasks?.state === 'monitoring'
|
|
// Decoded once where the frame entered the client's state, so its identity holds between frames.
|
|
const children =
|
|
monitoring && backgroundTasks.children
|
|
? withoutForeground(backgroundTasks.children, foregroundCommands, (child) => child.providerId)
|
|
: undefined
|
|
const tasks = withoutForeground(
|
|
backgroundTasks?.tasks ?? NO_TASKS,
|
|
foregroundCommands,
|
|
(task) => task.id
|
|
)
|
|
// Older rosters with only finished rows cannot hold the strip open.
|
|
const onlyFinished = !children && !tasks.length && Boolean(backgroundTasks?.settledTasks?.length)
|
|
const onlyForeground =
|
|
foregroundCommands.size > 0 &&
|
|
!children?.length &&
|
|
!tasks.length &&
|
|
Boolean(backgroundTasks?.children?.length || backgroundTasks?.tasks?.length)
|
|
const incomplete = monitoring && backgroundTasks.incomplete === true
|
|
const show = monitoring && (incomplete || (!onlyFinished && !onlyForeground))
|
|
// Commands and rewind follow the listed records, as the host's own admission does.
|
|
const liveWork = children ? agentChildWorkLiveness(children) !== null : show
|
|
const supportsStop = backgroundTasks?.supportsTaskStop === true
|
|
return {
|
|
show,
|
|
isMonitoring: turnId === null && liveWork,
|
|
tasks,
|
|
// Running work only, from any host: an older host's finished rows are not shown either.
|
|
settledTasks: NO_TASKS,
|
|
...(children ? { children } : {}),
|
|
supportsStop,
|
|
// Missing supportsStopAll is legacy support; only explicit false means no untargeted Stop.
|
|
offersStopAll:
|
|
(!supportsStop && backgroundTasks?.supportsStopAll !== false) ||
|
|
(incomplete && turnId === null),
|
|
incomplete
|
|
}
|
|
}
|
|
|
|
/** Identify listed runs by invocation because providers reuse IDs across child runs; old hosts fall back to provider ID. */
|
|
export function structuredSessionListedTaskRun(
|
|
view: StructuredSessionBackgroundTasksView,
|
|
providerId: string
|
|
): string | null {
|
|
if (!view.show) {
|
|
return null
|
|
}
|
|
if (!view.children) {
|
|
return view.tasks.some((task) => task.id === providerId) ? providerId : null
|
|
}
|
|
const child = view.children.find((candidate) => candidate.providerId === providerId)
|
|
return child ? `${child.invocation.invocationId}#${child.invocation.generation}` : null
|
|
}
|
|
|
|
/** Retain confirmed Stops only for still-listed runs; preserve map identity if none left. */
|
|
export function structuredSessionConfirmedStopsStillListed(
|
|
view: StructuredSessionBackgroundTasksView,
|
|
confirmed: ReadonlyMap<string, string>
|
|
): ReadonlyMap<string, string> {
|
|
const listed = [...confirmed].filter(
|
|
([providerId, run]) => structuredSessionListedTaskRun(view, providerId) === run
|
|
)
|
|
return listed.length === confirmed.size ? confirmed : new Map(listed)
|
|
}
|