import { Type } from "typebox";

import { isRequesterParentOfBackgroundAcpSession } from "../../acp/session-interaction-mode.js";

import { parseSessionThreadInfoFast } from "../../config/sessions/thread-info.js";

import type { SessionEntry } from "../../config/sessions/types.js";

import type { OpenClawConfig } from "../../config/types.openclaw.js";

import { callGateway } from "../../gateway/call.js";

import { formatErrorMessage } from "../../infra/errors.js";

import { normalizeAgentId, resolveAgentIdFromSessionKey } from "../../routing/session-key.js";

import {

isSubagentSessionKey,

normalizeAgentId,

resolveAgentIdFromSessionKey,

} from "../../routing/session-key.js";

import { annotateInterSessionPromptText } from "../../sessions/input-provenance.js";

import { SESSION_LABEL_MAX_LENGTH } from "../../sessions/session-label.js";

import { normalizeOptionalString } from "../../shared/string-coerce.js";

type GatewayCaller = typeof callGateway;

const SESSIONS_SEND_REPLY_HISTORY_LIMIT = 50;

type SessionsSendRouteEntry = Pick<SessionEntry, "acp" | "parentSessionKey" | "spawnedBy">;

function isRequesterParentOfNativeSubagentSession(params: {

entry: SessionsSendRouteEntry | null | undefined;

requesterSessionKey: string | null | undefined;

targetSessionKey: string;

}): boolean {

if (!params.entry || params.entry.acp || !isSubagentSessionKey(params.targetSessionKey)) {

return false;

}

const requester = normalizeOptionalString(params.requesterSessionKey);

if (!requester) {

return false;

}

const spawnedBy = normalizeOptionalString(params.entry.spawnedBy);

const parentSessionKey = normalizeOptionalString(params.entry.parentSessionKey);

return requester === spawnedBy || requester === parentSessionKey;

}

async function startAgentRun(params: {

callGateway: GatewayCaller;

runId: string;

const maxPingPongTurns = resolvePingPongTurns(cfg);

// Skip the A2A ping-pong + announce flow when the current caller is the

// parent of a parent-owned background ACP subagent it spawned itself.

// Such sessions already report their results back to the parent through

// the `[Internal task completion event]` announcement path, and treating

// them as a peer agent causes the parent to be woken with the child's

// reply, generate a user-facing response, and have that response

// forwarded back to the child as a new message — producing a

// ping-pong loop between parent and ACP child (bounded by

// maxPingPongTurns, but user-visible as a runaway conversation).

// parent of a parent-owned child session it spawned itself and another

// parent-visible result path already exists.

//

// ACP background sessions report through the internal task completion

// path. Waited native subagent sends return the child reply inline. In

// both cases treating the child as a peer agent wakes the parent with

// the child's reply, can generate another user-facing response, and can

// forward that response back to the child as a new message — producing a

// ping-pong loop (bounded by maxPingPongTurns, but visible as duplicate

// conversation output).

//

// The skip is gated on requester ownership, not just target type: an

// unrelated sender that can see the same target (e.g. under

// `tools.sessions.visibility=all`) must still go through the normal A2A

// path so it actually receives a follow-up delivery.

const targetSessionEntry = loadSessionEntryByKey(resolvedKey);

const skipA2AFlow = isRequesterParentOfBackgroundAcpSession(

const skipAcpA2AFlow = isRequesterParentOfBackgroundAcpSession(

targetSessionEntry,

effectiveRequesterKey,

);

const skipNativeParentA2AFlow =

timeoutSeconds !== 0 &&

isRequesterParentOfNativeSubagentSession({

entry: targetSessionEntry,

requesterSessionKey: effectiveRequesterKey,

targetSessionKey: resolvedKey,

});

const skipA2AFlow = skipAcpA2AFlow || skipNativeParentA2AFlow;

// When the A2A flow is skipped, no follow-up announcement will fire and

// the reply (when present) is returned inline via the `reply` field.

// Reflect that in the metadata so the parent LLM does not wait for a