} from "../acp/control-plane/spawn.js";

import { isAcpEnabledByPolicy, resolveAcpAgentPolicyError } from "../acp/policy.js";

import { DEFAULT_HEARTBEAT_EVERY } from "../auto-reply/heartbeat.js";

import { formatThinkingLevels } from "../auto-reply/thinking.js";

import {

resolveChannelDefaultBindingPlacement,

resolveInboundConversationResolution,

inheritedToolDenyPatch,

} from "./inherited-tool-deny.js";

import { AGENT_LANE_SUBAGENT } from "./lanes.js";

import {

resolveConfiguredSubagentSpawnModelSelection,

resolveThinkingDefault,

} from "./model-selection.js";

import { resolveSandboxRuntimeStatus } from "./sandbox/runtime-status.js";

import { resolveRequesterOriginForChild } from "./spawn-requester-origin.js";

import { resolveSpawnedWorkspaceInheritance } from "./spawned-context.js";

} from "./subagent-capabilities.js";

import { getSubagentDepthFromSessionStore } from "./subagent-depth.js";

import { countActiveRunsForSession, getSubagentRunByChildSessionKey } from "./subagent-registry.js";

import { splitModelRef } from "./subagent-spawn-plan.js";

import { resolveSubagentThinkingOverride } from "./subagent-spawn-thinking.js";

import { resolveSubagentTargetPolicy } from "./subagent-target-policy.js";

import { resolveInternalSessionKey, resolveMainSessionAlias } from "./tools/sessions-helpers.js";

function resolveTargetAcpAgentId(params: {

requestedAgentId?: string;

cfg: OpenClawConfig;

}): { ok: true; agentId: string } | { ok: false; error: string } {

}): { ok: true; agentId: string; configAgentId?: string } | { ok: false; error: string } {

const requested = normalizeOptionalAgentId(params.requestedAgentId);

if (requested) {

const configuredAgent = params.cfg.agents?.list?.find(

return {

ok: true,

agentId: normalizeOptionalAgentId(configuredAgent.runtime.acp?.agent) ?? requested,

configAgentId: requested,

};

}

if (configuredAgent && !isExplicitlyAllowedAcpAgent(params.cfg, requested)) {

'Use runtime="acp" only with external ACP harness ids such as codex, claude, droid, gemini, or opencode, or configure agents.list[].runtime.type="acp" with runtime.acp.agent.',

};

}

return { ok: true, agentId: requested };

return {

ok: true,

agentId: requested,

...(configuredAgent ? { configAgentId: requested } : {}),

};

}

const configuredDefault = normalizeOptionalAgentId(params.cfg.acp?.defaultAgent);

};

}

type AcpSpawnRuntimeOptions = {

model?: string;

thinking?: string;

timeoutSeconds?: number;

};

function resolveAcpSpawnRuntimeOptions(params: {

cfg: OpenClawConfig;

targetAgentId: string;

configAgentId?: string;

model?: string;

thinking?: string;

runTimeoutSeconds?: number;

}): { ok: true; runtimeOptions?: AcpSpawnRuntimeOptions } | { ok: false; error: string } {

const policyAgentId = params.configAgentId ?? params.targetAgentId;

const model = resolveConfiguredSubagentSpawnModelSelection({

cfg: params.cfg,

agentId: policyAgentId,

modelOverride: params.model,

includeAgentPrimary: false,

});

const targetAgentConfig = resolveAgentConfig(params.cfg, policyAgentId);

const thinkingPlan = resolveSubagentThinkingOverride({

cfg: params.cfg,

targetAgentConfig,

thinkingOverrideRaw: params.thinking,

});

if (thinkingPlan.status === "error") {

const { provider, model: modelId } = splitModelRef(model);

return {

ok: false,

error: `Invalid thinking level "${thinkingPlan.thinkingCandidateRaw}". Use one of: ${formatThinkingLevels(provider, modelId)}.`,

};

}

let thinking = thinkingPlan.thinkingOverride;

if (!thinking && model) {

const { provider, model: modelId } = splitModelRef(model);

if (provider && modelId) {

thinking = resolveThinkingDefault({

cfg: params.cfg,

provider,

model: modelId,

});

}

}

const runtimeOptions =

model || thinking || params.runTimeoutSeconds

? {

...(model ? { model } : {}),

...(thinking ? { thinking } : {}),

...(params.runTimeoutSeconds ? { timeoutSeconds: params.runTimeoutSeconds } : {}),

}

: undefined;

return { ok: true, runtimeOptions };

}

async function initializeAcpSpawnRuntime(params: {

cfg: OpenClawConfig;

sessionKey: string;

targetAgentId: string;

runtimeMode: AcpRuntimeSessionMode;

resumeSessionId?: string;

model?: string;

thinking?: string;

runTimeoutSeconds?: number;

runtimeOptions?: AcpSpawnRuntimeOptions;

cwd?: string;

}): Promise<AcpSpawnInitializedRuntime> {

const storePath = resolveStorePath(params.cfg.session?.store, { agentId: params.targetAgentId });

agent: params.targetAgentId,

mode: params.runtimeMode,

resumeSessionId: params.resumeSessionId,

runtimeOptions:

params.model || params.thinking || params.runTimeoutSeconds

? {

...(params.model ? { model: params.model } : {}),

...(params.thinking ? { thinking: params.thinking } : {}),

...(params.runTimeoutSeconds ? { timeoutSeconds: params.runTimeoutSeconds } : {}),

}

: undefined,

runtimeOptions: params.runtimeOptions,

cwd: params.cwd,

backendId: params.cfg.acp?.backend,

});

error: resumeAuthorization.error,

});

}

const runtimeOptionsResult = resolveAcpSpawnRuntimeOptions({

cfg,

targetAgentId,

configAgentId: targetAgentResult.configAgentId,

model: params.model,

thinking: params.thinking,

runTimeoutSeconds: params.runTimeoutSeconds,

});

if (!runtimeOptionsResult.ok) {

return createAcpSpawnFailure({

status: "error",

errorCode: "spawn_failed",

error: runtimeOptionsResult.error,

});

}

const { effectiveStreamToParent } = resolveAcpSpawnStreamPlan({

spawnMode,

requestThreadBinding,

targetAgentId,

runtimeMode,

resumeSessionId: params.resumeSessionId,

model: params.model,

thinking: params.thinking,

runTimeoutSeconds: params.runTimeoutSeconds,

runtimeOptions: runtimeOptionsResult.runtimeOptions,

cwd: runtimeCwd,

});

initializedRuntime = initializedSession.runtimeCloseHandle;