Files
openclaw/src/agents/subagent-registry-completion.ts
Onur 8178ea472d feat: thread-bound subagents on Discord (#21805)
* docs: thread-bound subagents plan

* docs: add exact thread-bound subagent implementation touchpoints

* Docs: prioritize auto thread-bound subagent flow

* Docs: add ACP harness thread-binding extensions

* Discord: add thread-bound session routing and auto-bind spawn flow

* Subagents: add focus commands and ACP/session binding lifecycle hooks

* Tests: cover thread bindings, focus commands, and ACP unbind hooks

* Docs: add plugin-hook appendix for thread-bound subagents

* Plugins: add subagent lifecycle hook events

* Core: emit subagent lifecycle hooks and decouple Discord bindings

* Discord: handle subagent bind lifecycle via plugin hooks

* Subagents: unify completion finalizer and split registry modules

* Add subagent lifecycle events module

* Hooks: fix subagent ended context key

* Discord: share thread bindings across ESM and Jiti

* Subagents: add persistent sessions_spawn mode for thread-bound sessions

* Subagents: clarify thread intro and persistent completion copy

* test(subagents): stabilize sessions_spawn lifecycle cleanup assertions

* Discord: add thread-bound session TTL with auto-unfocus

* Subagents: fail session spawns when thread bind fails

* Subagents: cover thread session failure cleanup paths

* Session: add thread binding TTL config and /session ttl controls

* Tests: align discord reaction expectations

* Agent: persist sessionFile for keyed subagent sessions

* Discord: normalize imports after conflict resolution

* Sessions: centralize sessionFile resolve/persist helper

* Discord: harden thread-bound subagent session routing

* Rebase: resolve upstream/main conflicts

* Subagents: move thread binding into hooks and split bindings modules

* Docs: add channel-agnostic subagent routing hook plan

* Agents: decouple subagent routing from Discord

* Discord: refactor thread-bound subagent flows

* Subagents: prevent duplicate end hooks and orphaned failed sessions

* Refactor: split subagent command and provider phases

* Subagents: honor hook delivery target overrides

* Discord: add thread binding kill switches and refresh plan doc

* Discord: fix thread bind channel resolution

* Routing: centralize account id normalization

* Discord: clean up thread bindings on startup failures

* Discord: add startup cleanup regression tests

* Docs: add long-term thread-bound subagent architecture

* Docs: split session binding plan and dedupe thread-bound doc

* Subagents: add channel-agnostic session binding routing

* Subagents: stabilize announce completion routing tests

* Subagents: cover multi-bound completion routing

* Subagents: suppress lifecycle hooks on failed thread bind

* tests: fix discord provider mock typing regressions

* docs/protocol: sync slash command aliases and delete param models

* fix: add changelog entry for Discord thread-bound subagents (#21805) (thanks @onutc)

---------

Co-authored-by: Shadow <hi@shadowing.dev>
2026-02-21 16:14:55 +01:00

97 lines
2.6 KiB
TypeScript

import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";
import type { SubagentRunOutcome } from "./subagent-announce.js";
import {
SUBAGENT_ENDED_OUTCOME_ERROR,
SUBAGENT_ENDED_OUTCOME_OK,
SUBAGENT_ENDED_OUTCOME_TIMEOUT,
SUBAGENT_TARGET_KIND_SUBAGENT,
type SubagentLifecycleEndedOutcome,
type SubagentLifecycleEndedReason,
} from "./subagent-lifecycle-events.js";
import type { SubagentRunRecord } from "./subagent-registry.types.js";
export function runOutcomesEqual(
a: SubagentRunOutcome | undefined,
b: SubagentRunOutcome | undefined,
): boolean {
if (!a && !b) {
return true;
}
if (!a || !b) {
return false;
}
if (a.status !== b.status) {
return false;
}
if (a.status === "error" && b.status === "error") {
return (a.error ?? "") === (b.error ?? "");
}
return true;
}
export function resolveLifecycleOutcomeFromRunOutcome(
outcome: SubagentRunOutcome | undefined,
): SubagentLifecycleEndedOutcome {
if (outcome?.status === "error") {
return SUBAGENT_ENDED_OUTCOME_ERROR;
}
if (outcome?.status === "timeout") {
return SUBAGENT_ENDED_OUTCOME_TIMEOUT;
}
return SUBAGENT_ENDED_OUTCOME_OK;
}
export async function emitSubagentEndedHookOnce(params: {
entry: SubagentRunRecord;
reason: SubagentLifecycleEndedReason;
sendFarewell?: boolean;
accountId?: string;
outcome?: SubagentLifecycleEndedOutcome;
error?: string;
inFlightRunIds: Set<string>;
persist: () => void;
}) {
const runId = params.entry.runId.trim();
if (!runId) {
return false;
}
if (params.entry.endedHookEmittedAt) {
return false;
}
if (params.inFlightRunIds.has(runId)) {
return false;
}
params.inFlightRunIds.add(runId);
try {
const hookRunner = getGlobalHookRunner();
if (hookRunner?.hasHooks("subagent_ended")) {
await hookRunner.runSubagentEnded(
{
targetSessionKey: params.entry.childSessionKey,
targetKind: SUBAGENT_TARGET_KIND_SUBAGENT,
reason: params.reason,
sendFarewell: params.sendFarewell,
accountId: params.accountId,
runId: params.entry.runId,
endedAt: params.entry.endedAt,
outcome: params.outcome,
error: params.error,
},
{
runId: params.entry.runId,
childSessionKey: params.entry.childSessionKey,
requesterSessionKey: params.entry.requesterSessionKey,
},
);
}
params.entry.endedHookEmittedAt = Date.now();
params.persist();
return true;
} catch {
return false;
} finally {
params.inFlightRunIds.delete(runId);
}
}