mirror of
https://github.com/openclaw/openclaw.git
synced 2026-05-04 23:50:20 +00:00
585 lines
20 KiB
TypeScript
585 lines
20 KiB
TypeScript
import { resolveQueueSettings } from "../auto-reply/reply/queue.js";
|
|
import { loadConfig } from "../config/config.js";
|
|
import {
|
|
loadSessionStore,
|
|
resolveAgentIdFromSessionKey,
|
|
resolveMainSessionKey,
|
|
resolveStorePath,
|
|
} from "../config/sessions.js";
|
|
import { callGateway } from "../gateway/call.js";
|
|
import { createBoundDeliveryRouter } from "../infra/outbound/bound-delivery-router.js";
|
|
import { resolveConversationIdFromTargets } from "../infra/outbound/conversation-id.js";
|
|
import type { ConversationRef } from "../infra/outbound/session-binding-service.js";
|
|
import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";
|
|
import { normalizeAccountId, normalizeMainKey } from "../routing/session-key.js";
|
|
import { defaultRuntime } from "../runtime.js";
|
|
import { isCronSessionKey } from "../sessions/session-key-utils.js";
|
|
import {
|
|
type DeliveryContext,
|
|
deliveryContextFromSession,
|
|
mergeDeliveryContext,
|
|
normalizeDeliveryContext,
|
|
resolveConversationDeliveryTarget,
|
|
} from "../utils/delivery-context.js";
|
|
import {
|
|
INTERNAL_MESSAGE_CHANNEL,
|
|
isDeliverableMessageChannel,
|
|
isInternalMessageChannel,
|
|
} from "../utils/message-channel.js";
|
|
import { buildAnnounceIdempotencyKey, resolveQueueAnnounceId } from "./announce-idempotency.js";
|
|
import type { AgentInternalEvent } from "./internal-events.js";
|
|
import { isEmbeddedPiRunActive, queueEmbeddedPiMessage } from "./pi-embedded.js";
|
|
import {
|
|
runSubagentAnnounceDispatch,
|
|
type SubagentAnnounceDeliveryResult,
|
|
} from "./subagent-announce-dispatch.js";
|
|
import { type AnnounceQueueItem, enqueueAnnounce } from "./subagent-announce-queue.js";
|
|
import { getSubagentDepthFromSessionStore } from "./subagent-depth.js";
|
|
import type { SpawnSubagentMode } from "./subagent-spawn.js";
|
|
|
|
const FAST_TEST_MODE = process.env.OPENCLAW_TEST_FAST === "1";
|
|
const DEFAULT_SUBAGENT_ANNOUNCE_TIMEOUT_MS = 90_000;
|
|
const MAX_TIMER_SAFE_TIMEOUT_MS = 2_147_000_000;
|
|
|
|
const DIRECT_ANNOUNCE_TRANSIENT_RETRY_DELAYS_MS = FAST_TEST_MODE
|
|
? ([8, 16, 32] as const)
|
|
: ([5_000, 10_000, 20_000] as const);
|
|
|
|
type DeliveryContextSource = Parameters<typeof deliveryContextFromSession>[0];
|
|
|
|
export function resolveSubagentAnnounceTimeoutMs(cfg: ReturnType<typeof loadConfig>): number {
|
|
const configured = cfg.agents?.defaults?.subagents?.announceTimeoutMs;
|
|
if (typeof configured !== "number" || !Number.isFinite(configured)) {
|
|
return DEFAULT_SUBAGENT_ANNOUNCE_TIMEOUT_MS;
|
|
}
|
|
return Math.min(Math.max(1, Math.floor(configured)), MAX_TIMER_SAFE_TIMEOUT_MS);
|
|
}
|
|
|
|
export function isInternalAnnounceRequesterSession(sessionKey: string | undefined): boolean {
|
|
return getSubagentDepthFromSessionStore(sessionKey) >= 1 || isCronSessionKey(sessionKey);
|
|
}
|
|
|
|
function summarizeDeliveryError(error: unknown): string {
|
|
if (error instanceof Error) {
|
|
return error.message || "error";
|
|
}
|
|
if (typeof error === "string") {
|
|
return error;
|
|
}
|
|
if (error === undefined || error === null) {
|
|
return "unknown error";
|
|
}
|
|
try {
|
|
return JSON.stringify(error);
|
|
} catch {
|
|
return "error";
|
|
}
|
|
}
|
|
|
|
const TRANSIENT_ANNOUNCE_DELIVERY_ERROR_PATTERNS: readonly RegExp[] = [
|
|
/\berrorcode=unavailable\b/i,
|
|
/\bstatus\s*[:=]\s*"?unavailable\b/i,
|
|
/\bUNAVAILABLE\b/,
|
|
/no active .* listener/i,
|
|
/gateway not connected/i,
|
|
/gateway closed \(1006/i,
|
|
/gateway timeout/i,
|
|
/\b(econnreset|econnrefused|etimedout|enotfound|ehostunreach|network error)\b/i,
|
|
];
|
|
|
|
const PERMANENT_ANNOUNCE_DELIVERY_ERROR_PATTERNS: readonly RegExp[] = [
|
|
/unsupported channel/i,
|
|
/unknown channel/i,
|
|
/chat not found/i,
|
|
/user not found/i,
|
|
/bot.*not.*member/i,
|
|
/bot was blocked by the user/i,
|
|
/forbidden: bot was kicked/i,
|
|
/recipient is not a valid/i,
|
|
/outbound not configured for channel/i,
|
|
];
|
|
|
|
function isTransientAnnounceDeliveryError(error: unknown): boolean {
|
|
const message = summarizeDeliveryError(error);
|
|
if (!message) {
|
|
return false;
|
|
}
|
|
if (PERMANENT_ANNOUNCE_DELIVERY_ERROR_PATTERNS.some((re) => re.test(message))) {
|
|
return false;
|
|
}
|
|
return TRANSIENT_ANNOUNCE_DELIVERY_ERROR_PATTERNS.some((re) => re.test(message));
|
|
}
|
|
|
|
async function waitForAnnounceRetryDelay(ms: number, signal?: AbortSignal): Promise<void> {
|
|
if (ms <= 0) {
|
|
return;
|
|
}
|
|
if (!signal) {
|
|
await new Promise<void>((resolve) => setTimeout(resolve, ms));
|
|
return;
|
|
}
|
|
if (signal.aborted) {
|
|
return;
|
|
}
|
|
await new Promise<void>((resolve) => {
|
|
const timer = setTimeout(() => {
|
|
signal.removeEventListener("abort", onAbort);
|
|
resolve();
|
|
}, ms);
|
|
const onAbort = () => {
|
|
clearTimeout(timer);
|
|
signal.removeEventListener("abort", onAbort);
|
|
resolve();
|
|
};
|
|
signal.addEventListener("abort", onAbort, { once: true });
|
|
});
|
|
}
|
|
|
|
export async function runAnnounceDeliveryWithRetry<T>(params: {
|
|
operation: string;
|
|
signal?: AbortSignal;
|
|
run: () => Promise<T>;
|
|
}): Promise<T> {
|
|
let retryIndex = 0;
|
|
for (;;) {
|
|
if (params.signal?.aborted) {
|
|
throw new Error("announce delivery aborted");
|
|
}
|
|
try {
|
|
return await params.run();
|
|
} catch (err) {
|
|
const delayMs = DIRECT_ANNOUNCE_TRANSIENT_RETRY_DELAYS_MS[retryIndex];
|
|
if (delayMs == null || !isTransientAnnounceDeliveryError(err) || params.signal?.aborted) {
|
|
throw err;
|
|
}
|
|
const nextAttempt = retryIndex + 2;
|
|
const maxAttempts = DIRECT_ANNOUNCE_TRANSIENT_RETRY_DELAYS_MS.length + 1;
|
|
defaultRuntime.log(
|
|
`[warn] Subagent announce ${params.operation} transient failure, retrying ${nextAttempt}/${maxAttempts} in ${Math.round(delayMs / 1000)}s: ${summarizeDeliveryError(err)}`,
|
|
);
|
|
retryIndex += 1;
|
|
await waitForAnnounceRetryDelay(delayMs, params.signal);
|
|
}
|
|
}
|
|
}
|
|
|
|
export function resolveAnnounceOrigin(
|
|
entry?: DeliveryContextSource,
|
|
requesterOrigin?: DeliveryContext,
|
|
): DeliveryContext | undefined {
|
|
const normalizedRequester = normalizeDeliveryContext(requesterOrigin);
|
|
const normalizedEntry = deliveryContextFromSession(entry);
|
|
if (normalizedRequester?.channel && isInternalMessageChannel(normalizedRequester.channel)) {
|
|
return mergeDeliveryContext(
|
|
{
|
|
accountId: normalizedRequester.accountId,
|
|
threadId: normalizedRequester.threadId,
|
|
},
|
|
normalizedEntry,
|
|
);
|
|
}
|
|
const entryForMerge =
|
|
normalizedRequester?.to &&
|
|
normalizedRequester.threadId == null &&
|
|
normalizedEntry?.threadId != null
|
|
? (() => {
|
|
const { threadId: _ignore, ...rest } = normalizedEntry;
|
|
return rest;
|
|
})()
|
|
: normalizedEntry;
|
|
return mergeDeliveryContext(normalizedRequester, entryForMerge);
|
|
}
|
|
|
|
export async function resolveSubagentCompletionOrigin(params: {
|
|
childSessionKey: string;
|
|
requesterSessionKey: string;
|
|
requesterOrigin?: DeliveryContext;
|
|
childRunId?: string;
|
|
spawnMode?: SpawnSubagentMode;
|
|
expectsCompletionMessage: boolean;
|
|
}): Promise<DeliveryContext | undefined> {
|
|
const requesterOrigin = normalizeDeliveryContext(params.requesterOrigin);
|
|
const channel = requesterOrigin?.channel?.trim().toLowerCase();
|
|
const to = requesterOrigin?.to?.trim();
|
|
const accountId = normalizeAccountId(requesterOrigin?.accountId);
|
|
const threadId =
|
|
requesterOrigin?.threadId != null && requesterOrigin.threadId !== ""
|
|
? String(requesterOrigin.threadId).trim()
|
|
: undefined;
|
|
const conversationId =
|
|
threadId ||
|
|
resolveConversationIdFromTargets({
|
|
targets: [to],
|
|
}) ||
|
|
"";
|
|
const requesterConversation: ConversationRef | undefined =
|
|
channel && conversationId ? { channel, accountId, conversationId } : undefined;
|
|
|
|
const route = createBoundDeliveryRouter().resolveDestination({
|
|
eventKind: "task_completion",
|
|
targetSessionKey: params.childSessionKey,
|
|
requester: requesterConversation,
|
|
failClosed: false,
|
|
});
|
|
if (route.mode === "bound" && route.binding) {
|
|
const boundTarget = resolveConversationDeliveryTarget({
|
|
channel: route.binding.conversation.channel,
|
|
conversationId: route.binding.conversation.conversationId,
|
|
parentConversationId: route.binding.conversation.parentConversationId,
|
|
});
|
|
return mergeDeliveryContext(
|
|
{
|
|
channel: route.binding.conversation.channel,
|
|
accountId: route.binding.conversation.accountId,
|
|
to: boundTarget.to,
|
|
threadId:
|
|
boundTarget.threadId ??
|
|
(requesterOrigin?.threadId != null && requesterOrigin.threadId !== ""
|
|
? String(requesterOrigin.threadId)
|
|
: undefined),
|
|
},
|
|
requesterOrigin,
|
|
);
|
|
}
|
|
|
|
const hookRunner = getGlobalHookRunner();
|
|
if (!hookRunner?.hasHooks("subagent_delivery_target")) {
|
|
return requesterOrigin;
|
|
}
|
|
try {
|
|
const result = await hookRunner.runSubagentDeliveryTarget(
|
|
{
|
|
childSessionKey: params.childSessionKey,
|
|
requesterSessionKey: params.requesterSessionKey,
|
|
requesterOrigin,
|
|
childRunId: params.childRunId,
|
|
spawnMode: params.spawnMode,
|
|
expectsCompletionMessage: params.expectsCompletionMessage,
|
|
},
|
|
{
|
|
runId: params.childRunId,
|
|
childSessionKey: params.childSessionKey,
|
|
requesterSessionKey: params.requesterSessionKey,
|
|
},
|
|
);
|
|
const hookOrigin = normalizeDeliveryContext(result?.origin);
|
|
if (!hookOrigin || (hookOrigin.channel && !isDeliverableMessageChannel(hookOrigin.channel))) {
|
|
return requesterOrigin;
|
|
}
|
|
return mergeDeliveryContext(hookOrigin, requesterOrigin);
|
|
} catch {
|
|
return requesterOrigin;
|
|
}
|
|
}
|
|
|
|
async function sendAnnounce(item: AnnounceQueueItem) {
|
|
const cfg = loadConfig();
|
|
const announceTimeoutMs = resolveSubagentAnnounceTimeoutMs(cfg);
|
|
const requesterIsSubagent = isInternalAnnounceRequesterSession(item.sessionKey);
|
|
const origin = item.origin;
|
|
const threadId =
|
|
origin?.threadId != null && origin.threadId !== "" ? String(origin.threadId) : undefined;
|
|
const idempotencyKey = buildAnnounceIdempotencyKey(
|
|
resolveQueueAnnounceId({
|
|
announceId: item.announceId,
|
|
sessionKey: item.sessionKey,
|
|
enqueuedAt: item.enqueuedAt,
|
|
}),
|
|
);
|
|
await callGateway({
|
|
method: "agent",
|
|
params: {
|
|
sessionKey: item.sessionKey,
|
|
message: item.prompt,
|
|
channel: requesterIsSubagent ? undefined : origin?.channel,
|
|
accountId: requesterIsSubagent ? undefined : origin?.accountId,
|
|
to: requesterIsSubagent ? undefined : origin?.to,
|
|
threadId: requesterIsSubagent ? undefined : threadId,
|
|
deliver: !requesterIsSubagent,
|
|
internalEvents: item.internalEvents,
|
|
inputProvenance: {
|
|
kind: "inter_session",
|
|
sourceSessionKey: item.sourceSessionKey,
|
|
sourceChannel: item.sourceChannel ?? INTERNAL_MESSAGE_CHANNEL,
|
|
sourceTool: item.sourceTool ?? "subagent_announce",
|
|
},
|
|
idempotencyKey,
|
|
},
|
|
timeoutMs: announceTimeoutMs,
|
|
});
|
|
}
|
|
|
|
export function resolveRequesterStoreKey(
|
|
cfg: ReturnType<typeof loadConfig>,
|
|
requesterSessionKey: string,
|
|
): string {
|
|
const raw = (requesterSessionKey ?? "").trim();
|
|
if (!raw) {
|
|
return raw;
|
|
}
|
|
if (raw === "global" || raw === "unknown") {
|
|
return raw;
|
|
}
|
|
if (raw.startsWith("agent:")) {
|
|
return raw;
|
|
}
|
|
const mainKey = normalizeMainKey(cfg.session?.mainKey);
|
|
if (raw === "main" || raw === mainKey) {
|
|
return resolveMainSessionKey(cfg);
|
|
}
|
|
const agentId = resolveAgentIdFromSessionKey(raw);
|
|
return `agent:${agentId}:${raw}`;
|
|
}
|
|
|
|
export function loadRequesterSessionEntry(requesterSessionKey: string) {
|
|
const cfg = loadConfig();
|
|
const canonicalKey = resolveRequesterStoreKey(cfg, requesterSessionKey);
|
|
const agentId = resolveAgentIdFromSessionKey(canonicalKey);
|
|
const storePath = resolveStorePath(cfg.session?.store, { agentId });
|
|
const store = loadSessionStore(storePath);
|
|
const entry = store[canonicalKey];
|
|
return { cfg, entry, canonicalKey };
|
|
}
|
|
|
|
export function loadSessionEntryByKey(sessionKey: string) {
|
|
const cfg = loadConfig();
|
|
const agentId = resolveAgentIdFromSessionKey(sessionKey);
|
|
const storePath = resolveStorePath(cfg.session?.store, { agentId });
|
|
const store = loadSessionStore(storePath);
|
|
return store[sessionKey];
|
|
}
|
|
|
|
function buildAnnounceQueueKey(sessionKey: string, origin?: DeliveryContext): string {
|
|
const accountId = normalizeAccountId(origin?.accountId);
|
|
if (!accountId) {
|
|
return sessionKey;
|
|
}
|
|
return `${sessionKey}:acct:${accountId}`;
|
|
}
|
|
|
|
async function maybeQueueSubagentAnnounce(params: {
|
|
requesterSessionKey: string;
|
|
announceId?: string;
|
|
triggerMessage: string;
|
|
steerMessage: string;
|
|
summaryLine?: string;
|
|
requesterOrigin?: DeliveryContext;
|
|
sourceSessionKey?: string;
|
|
sourceChannel?: string;
|
|
sourceTool?: string;
|
|
internalEvents?: AgentInternalEvent[];
|
|
signal?: AbortSignal;
|
|
}): Promise<"steered" | "queued" | "none" | "dropped"> {
|
|
if (params.signal?.aborted) {
|
|
return "none";
|
|
}
|
|
const { cfg, entry } = loadRequesterSessionEntry(params.requesterSessionKey);
|
|
const canonicalKey = resolveRequesterStoreKey(cfg, params.requesterSessionKey);
|
|
const sessionId = entry?.sessionId;
|
|
if (!sessionId) {
|
|
return "none";
|
|
}
|
|
|
|
const queueSettings = resolveQueueSettings({
|
|
cfg,
|
|
channel: entry?.channel ?? entry?.lastChannel,
|
|
sessionEntry: entry,
|
|
});
|
|
const isActive = isEmbeddedPiRunActive(sessionId);
|
|
|
|
const shouldSteer = queueSettings.mode === "steer" || queueSettings.mode === "steer-backlog";
|
|
if (shouldSteer) {
|
|
const steered = queueEmbeddedPiMessage(sessionId, params.steerMessage);
|
|
if (steered) {
|
|
return "steered";
|
|
}
|
|
}
|
|
|
|
const shouldFollowup =
|
|
queueSettings.mode === "followup" ||
|
|
queueSettings.mode === "collect" ||
|
|
queueSettings.mode === "steer-backlog" ||
|
|
queueSettings.mode === "interrupt";
|
|
if (isActive && (shouldFollowup || queueSettings.mode === "steer")) {
|
|
const origin = resolveAnnounceOrigin(entry, params.requesterOrigin);
|
|
const didQueue = enqueueAnnounce({
|
|
key: buildAnnounceQueueKey(canonicalKey, origin),
|
|
item: {
|
|
announceId: params.announceId,
|
|
prompt: params.triggerMessage,
|
|
summaryLine: params.summaryLine,
|
|
internalEvents: params.internalEvents,
|
|
enqueuedAt: Date.now(),
|
|
sessionKey: canonicalKey,
|
|
origin,
|
|
sourceSessionKey: params.sourceSessionKey,
|
|
sourceChannel: params.sourceChannel,
|
|
sourceTool: params.sourceTool,
|
|
},
|
|
settings: queueSettings,
|
|
send: sendAnnounce,
|
|
});
|
|
return didQueue ? "queued" : "dropped";
|
|
}
|
|
|
|
return "none";
|
|
}
|
|
|
|
async function sendSubagentAnnounceDirectly(params: {
|
|
targetRequesterSessionKey: string;
|
|
triggerMessage: string;
|
|
internalEvents?: AgentInternalEvent[];
|
|
expectsCompletionMessage: boolean;
|
|
bestEffortDeliver?: boolean;
|
|
directIdempotencyKey: string;
|
|
completionDirectOrigin?: DeliveryContext;
|
|
directOrigin?: DeliveryContext;
|
|
sourceSessionKey?: string;
|
|
sourceChannel?: string;
|
|
sourceTool?: string;
|
|
requesterIsSubagent: boolean;
|
|
signal?: AbortSignal;
|
|
}): Promise<SubagentAnnounceDeliveryResult> {
|
|
if (params.signal?.aborted) {
|
|
return {
|
|
delivered: false,
|
|
path: "none",
|
|
};
|
|
}
|
|
const cfg = loadConfig();
|
|
const announceTimeoutMs = resolveSubagentAnnounceTimeoutMs(cfg);
|
|
const canonicalRequesterSessionKey = resolveRequesterStoreKey(
|
|
cfg,
|
|
params.targetRequesterSessionKey,
|
|
);
|
|
try {
|
|
const completionDirectOrigin = normalizeDeliveryContext(params.completionDirectOrigin);
|
|
const directOrigin = normalizeDeliveryContext(params.directOrigin);
|
|
const effectiveDirectOrigin =
|
|
params.expectsCompletionMessage && completionDirectOrigin
|
|
? completionDirectOrigin
|
|
: directOrigin;
|
|
const directChannelRaw =
|
|
typeof effectiveDirectOrigin?.channel === "string"
|
|
? effectiveDirectOrigin.channel.trim()
|
|
: "";
|
|
const directChannel =
|
|
directChannelRaw && isDeliverableMessageChannel(directChannelRaw) ? directChannelRaw : "";
|
|
const directTo =
|
|
typeof effectiveDirectOrigin?.to === "string" ? effectiveDirectOrigin.to.trim() : "";
|
|
const hasDeliverableDirectTarget =
|
|
!params.requesterIsSubagent && Boolean(directChannel) && Boolean(directTo);
|
|
const shouldDeliverExternally =
|
|
!params.requesterIsSubagent &&
|
|
(!params.expectsCompletionMessage || hasDeliverableDirectTarget);
|
|
|
|
const threadId =
|
|
effectiveDirectOrigin?.threadId != null && effectiveDirectOrigin.threadId !== ""
|
|
? String(effectiveDirectOrigin.threadId)
|
|
: undefined;
|
|
if (params.signal?.aborted) {
|
|
return {
|
|
delivered: false,
|
|
path: "none",
|
|
};
|
|
}
|
|
await runAnnounceDeliveryWithRetry({
|
|
operation: params.expectsCompletionMessage
|
|
? "completion direct announce agent call"
|
|
: "direct announce agent call",
|
|
signal: params.signal,
|
|
run: async () =>
|
|
await callGateway({
|
|
method: "agent",
|
|
params: {
|
|
sessionKey: canonicalRequesterSessionKey,
|
|
message: params.triggerMessage,
|
|
deliver: shouldDeliverExternally,
|
|
bestEffortDeliver: params.bestEffortDeliver,
|
|
internalEvents: params.internalEvents,
|
|
channel: shouldDeliverExternally ? directChannel : undefined,
|
|
accountId: shouldDeliverExternally ? effectiveDirectOrigin?.accountId : undefined,
|
|
to: shouldDeliverExternally ? directTo : undefined,
|
|
threadId: shouldDeliverExternally ? threadId : undefined,
|
|
inputProvenance: {
|
|
kind: "inter_session",
|
|
sourceSessionKey: params.sourceSessionKey,
|
|
sourceChannel: params.sourceChannel ?? INTERNAL_MESSAGE_CHANNEL,
|
|
sourceTool: params.sourceTool ?? "subagent_announce",
|
|
},
|
|
idempotencyKey: params.directIdempotencyKey,
|
|
},
|
|
expectFinal: true,
|
|
timeoutMs: announceTimeoutMs,
|
|
}),
|
|
});
|
|
|
|
return {
|
|
delivered: true,
|
|
path: "direct",
|
|
};
|
|
} catch (err) {
|
|
return {
|
|
delivered: false,
|
|
path: "direct",
|
|
error: summarizeDeliveryError(err),
|
|
};
|
|
}
|
|
}
|
|
|
|
export async function deliverSubagentAnnouncement(params: {
|
|
requesterSessionKey: string;
|
|
announceId?: string;
|
|
triggerMessage: string;
|
|
steerMessage: string;
|
|
internalEvents?: AgentInternalEvent[];
|
|
summaryLine?: string;
|
|
requesterOrigin?: DeliveryContext;
|
|
completionDirectOrigin?: DeliveryContext;
|
|
directOrigin?: DeliveryContext;
|
|
sourceSessionKey?: string;
|
|
sourceChannel?: string;
|
|
sourceTool?: string;
|
|
targetRequesterSessionKey: string;
|
|
requesterIsSubagent: boolean;
|
|
expectsCompletionMessage: boolean;
|
|
bestEffortDeliver?: boolean;
|
|
directIdempotencyKey: string;
|
|
signal?: AbortSignal;
|
|
}): Promise<SubagentAnnounceDeliveryResult> {
|
|
return await runSubagentAnnounceDispatch({
|
|
expectsCompletionMessage: params.expectsCompletionMessage,
|
|
signal: params.signal,
|
|
queue: async () =>
|
|
await maybeQueueSubagentAnnounce({
|
|
requesterSessionKey: params.requesterSessionKey,
|
|
announceId: params.announceId,
|
|
triggerMessage: params.triggerMessage,
|
|
steerMessage: params.steerMessage,
|
|
summaryLine: params.summaryLine,
|
|
requesterOrigin: params.requesterOrigin,
|
|
sourceSessionKey: params.sourceSessionKey,
|
|
sourceChannel: params.sourceChannel,
|
|
sourceTool: params.sourceTool,
|
|
internalEvents: params.internalEvents,
|
|
signal: params.signal,
|
|
}),
|
|
direct: async () =>
|
|
await sendSubagentAnnounceDirectly({
|
|
targetRequesterSessionKey: params.targetRequesterSessionKey,
|
|
triggerMessage: params.triggerMessage,
|
|
internalEvents: params.internalEvents,
|
|
directIdempotencyKey: params.directIdempotencyKey,
|
|
completionDirectOrigin: params.completionDirectOrigin,
|
|
directOrigin: params.directOrigin,
|
|
sourceSessionKey: params.sourceSessionKey,
|
|
sourceChannel: params.sourceChannel,
|
|
sourceTool: params.sourceTool,
|
|
requesterIsSubagent: params.requesterIsSubagent,
|
|
expectsCompletionMessage: params.expectsCompletionMessage,
|
|
signal: params.signal,
|
|
bestEffortDeliver: params.bestEffortDeliver,
|
|
}),
|
|
});
|
|
}
|